Golang Reader.ReadByte方法代码示例

func (d *Decoder) Decode(in *bufio.Reader, out *bytes.Buffer) (err error) {
	for {
		b, err := in.ReadByte()
		if err != nil {
			break
		}
		switch b {
		case '=':
			char := make([]byte, 2)
			in.Read(char)
			code, _ := strconv.ParseUint(string(char), 16, 8)
			out.WriteByte(byte(code))
		case '_':
			err = out.WriteByte(' ')
		case ' ':
			return errors.New("Invalid char ` `")
		case '?':
			b, err = in.ReadByte()
			if b == '=' {
				return nil
			}
			return errors.New("Unexpected `?`")
		default:
			err = out.WriteByte(b)
		}
	}
	return err
}

func readBulkData(conn *bufio.Reader, len int64) ([]byte, os.Error) {
	buff := make([]byte, len)

	_, e := io.ReadFull(conn, buff)
	if e != nil {
		return nil, NewErrorWithCause(SYSTEM_ERR, "Error while attempting read of bulkdata", e)
	}
	//	fmt.Println ("Read ", n, " bytes.  data: ", buff);

	crb, e1 := conn.ReadByte()
	if e1 != nil {
		return nil, os.NewError("Error while attempting read of bulkdata terminal CR:" + e1.String())
	}
	if crb != CR_BYTE {
		return nil, os.NewError("<BUG> bulkdata terminal was not CR as expected")
	}
	lfb, e2 := conn.ReadByte()
	if e2 != nil {
		return nil, os.NewError("Error while attempting read of bulkdata terminal LF:" + e2.String())
	}
	if lfb != LF_BYTE {
		return nil, os.NewError("<BUG> bulkdata terminal was not LF as expected.")
	}

	return buff, nil
}

func newMessageReader(bufr *bufio.Reader) (*messageReader, error) {
	if _, err := bufr.ReadBytes('"'); err != nil {
		return nil, err
	}
	msg, err := bufr.ReadBytes('"')
	if err != nil {
		return nil, err
	}
	for {
		b, err := bufr.Peek(1)
		if err != nil {
			return nil, err
		}
		if b[0] == ',' {
			bufr.ReadByte()
			break
		}
		if b[0] != ' ' {
			break
		}
		bufr.ReadByte()
	}
	return &messageReader{
		reader:    bufr,
		message:   string(msg[:len(msg)-1]),
		firstRead: true,
	}, nil
}

func readArgument(r *bufio.Reader) ([]byte, error) {

	line, err := r.ReadString('\n')
	if err != nil {
		return nil, malformed("$<argumentLength>", line)
	}
	var argSize int
	if _, err := fmt.Sscanf(line, "$%d\r", &argSize); err != nil {
		return nil, malformed("$<argumentSize>", line)
	}

	// I think int is safe here as the max length of request
	// should be less then max int value?
	data, err := ioutil.ReadAll(io.LimitReader(r, int64(argSize)))
	if err != nil {
		return nil, err
	}

	if len(data) != argSize {
		return nil, malformedLength(argSize, len(data))
	}

	// Now check for trailing CR
	if b, err := r.ReadByte(); err != nil || b != '\r' {
		return nil, malformedMissingCRLF()
	}

	// And LF
	if b, err := r.ReadByte(); err != nil || b != '\n' {
		return nil, malformedMissingCRLF()
	}

	return data, nil
}

func readArray(r *bufio.Reader) (interface{}, error) {
	_, err := r.ReadByte()
	if err != nil {
		return EMPTY_STRING, err
	}
	countAsStr, err := ReadLine(r)
	if err != nil {
		return EMPTY_STRING, err
	}

	arrLen, err := strconv.Atoi(countAsStr)
	if err != nil {
		return EMPTY_STRING, err
	}

	l := list.New()
	for i := 0; i < arrLen; i++ {
		val, err := readType(r)
		if err != nil {
			return EMPTY_STRING, err
		}
		l.PushBack(val)
	}
	return l, nil
}

func readByte(r *bufio.Reader) byte {
	b, err := r.ReadByte()
	if err != nil {
		fmt.Println("error reading byte: ", err)
	}
	return b
}

func read_symbol(b *bufio.Reader) (goscm.SCMT, error) {
	ret := ""
	var c byte
	var err error

	for {
		c, err = b.ReadByte()
		if err != nil {
			break
		}
		if c == ')' {
			b.UnreadByte()
			break
		}
		if c == ';' {
			read_comment(b)
			continue
		}
		if is_whitespace(c) {
			break
		}
		ret = string(append([]byte(ret), c))
	}
	return goscm.NewSymbol(ret), err
}

func (state *scpUploadState) Protocol(in *bufio.Reader, out io.Writer) error {
	for {
		b, err := in.ReadByte()
		if err != nil {
			return err
		}
		switch b {
		case 'T':
			err := state.TimeProtocol(in, out)
			if err != nil {
				return err
			}
		case 'C':
			return state.FileProtocol(in, out)
		case 'E':
			state.dir = filepath.Dir(state.dir)
			fmt.Fprintf(out, scpOK)
			return nil
		case 'D':
			return state.DirProtocol(in, out)
		default:
			fmt.Fprintf(out, scpEmptyError)
			return fmt.Errorf("unexpected message: %c", b)
		}
	}
}

func peek(r *bufio.Reader) (c byte, e error) {
	c, e = r.ReadByte()
	if e != io.EOF {
		r.UnreadByte()
	}
	return
}

func newLexer(in *bufio.Reader) *lexer {
	l := &lexer{src: in, line: 1}
	if b, err := in.ReadByte(); err == nil {
		l.current = b
	}
	return l
}

func readArgument(reader *bufio.Reader) ([]byte, error) {
	line, err := reader.ReadString('\n')
	if err != nil {
		return nil, Malformed("$<ArgumentLength>", line)
	}

	var argLength int
	if _, err := fmt.Sscanf(line, "$%d\r", &argLength); err != nil {
		return nil, Malformed("$<ArgumentLength>", line)
	}

	data, err := ioutil.ReadAll(io.LimitReader(reader, int64(argLength)))
	if err != nil {
		return nil, err
	}
	if len(data) != argLength {
		return nil, MalformedLength(argLength, len(data))
	}
	if b, err := reader.ReadByte(); err != nil || b != '\r' {
		return nil, MalformedMissingCRLF()
	}
	if b, err := reader.ReadByte(); err != nil || b != '\n' {
		return nil, MalformedMissingCRLF()
	}

	return data, nil
}

// Reads a single word from a file, assuming space + tab + EOL to be word boundaries
func ReadWord(fin *bufio.Reader) (word string, err error) {
	var a int = 0
	var ch byte
	var buf bytes.Buffer
	for {
		ch, err = fin.ReadByte()
		if err == io.EOF {
			break
		}
		if ch == 13 {
			continue
		}
		if (ch == ' ') || (ch == '\t') || (ch == '\n') {
			if a > 0 {
				if ch == '\n' {
					fin.UnreadByte()
				}
				break
			}
			if ch == '\n' {
				word = "</s>"
				return
			} else {
				continue
			}
		}
		buf.WriteByte(ch)
		a++
	}
	if a >= MAX_STRING { // Truncate too long words
		buf.Truncate(MAX_STRING)
	}
	word = buf.String()
	return
}

func (g *CGIRefVar) RefByte(strand int, ref_stream *bufio.Reader) (byte, error) {

	if strand <= 0 {
		ref_bp, e := ref_stream.ReadByte()
		if e != nil {
			return ref_bp, e
		}
		for (ref_bp == '\n') || (ref_bp == ' ') || (ref_bp == '\r') || (ref_bp == '\t') {
			ref_bp, e = ref_stream.ReadByte()
			if e != nil {
				return ref_bp, e
			}
		}
		g.RefBuf = append(g.RefBuf, ref_bp)
		g.RefPos[0]++
		return ref_bp, e
	}

	if g.RefPos[1] >= len(g.RefBuf) {
		panic(fmt.Sprintf("g.RefPos[1] %d >= len(g.RefBuf) %d (RefPos:%v, RefBuf:%s, line %d '%s')", g.RefPos[1], len(g.RefBuf), g.RefPos, g.RefBuf, g.LCounter, g.CGIVarLine))
	}

	ref_bp := g.RefBuf[g.RefPos[1]]
	g.RefPos[1]++

	return ref_bp, nil

}

func groupLs(r *bufio.Reader, w *bufio.Writer, args []string, thisUser *utils.User) (err error) {

	if len(args) != 2 {
		fmt.Println("Wrong number of arguments for call to group-ls:")
		fmt.Println("Format should be: group-ls GID")
		return nil
	}

	err = w.WriteByte(23)
	w.Flush()
	if err != nil {
		return err
	}

	// send the group id
	w.WriteString(args[1] + "\n")
	w.Flush()

	// get success (1) or fail (2)
	success, _ := r.ReadByte()
	if success != 1 {
		fmt.Println("The group does not exist")
		return err
	}

	// get uuids of the group
	result, _ := r.ReadString('\n')
	result = strings.TrimSuffix(strings.TrimSpace(result), ",")

	fmt.Println("Members of Group " + args[1] + ": " + result)

	return err
}

// ReadWhitespace will read from the reader until no whitespace is encountered
func ReadWhitespace(r *bufio.Reader) {
	c, e := peek(r)
	for e != io.EOF && isWhitespace(c) {
		r.ReadByte()
		c, e = peek(r)
	}
}