Exemple #1
0
// 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
}
Exemple #2
0
func readHexInt(r *bufio.Reader) (int, error) {
	n := 0
	i := 0
	var k int
	for {
		c, err := r.ReadByte()
		if err != nil {
			if err == io.EOF && i > 0 {
				return n, nil
			}
			return -1, err
		}
		k = hexbyte2int(c)
		if k < 0 {
			if i == 0 {
				return -1, fmt.Errorf("cannot read hex num from empty string")
			}
			r.UnreadByte()
			return n, nil
		}
		if i >= maxHexIntChars {
			return -1, fmt.Errorf("cannot read hex num with more than %d digits", maxHexIntChars)
		}
		n = (n << 4) | k
		i++
	}
}
Exemple #3
0
// read reads the next value, ignoring whitespace.
func read(r *bufio.Reader) []byte {
	var comment bool
	space(r)

	buf := make([]byte, 0, 16)

loop:
	for {
		b, err := r.ReadByte()
		check(err)

		switch {
		case b == '#':
			comment = true
		case (comment && isNewline(b)) || (!comment && isSpace(b)):
			check(r.UnreadByte())
			break loop
		}

		if !comment {
			buf = append(buf, b)
		}
	}

	if len(buf) == 0 {
		return read(r)
	}

	return buf
}
Exemple #4
0
func readHexInt(r *bufio.Reader) (int, error) {
	n := 0
	i := 0
	var k int
	for {
		c, err := r.ReadByte()
		if err != nil {
			if err == io.EOF && i > 0 {
				return n, nil
			}
			return -1, err
		}
		k = hexbyte2int(c)
		if k < 0 {
			if i == 0 {
				return -1, errEmptyHexNum
			}
			r.UnreadByte()
			return n, nil
		}
		if i >= maxHexIntChars {
			return -1, errTooLargeHexNum
		}
		n = (n << 4) | k
		i++
	}
}
Exemple #5
0
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
}
Exemple #6
0
func (p *protocol) ReadParam(r *bufio.Reader) ([]byte, bool, error) {
	data, err := r.ReadSlice('\r')
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	err = p.assumeByte(r, '\n')
	if err != nil {
		return nil, false, err
	}

	next, err := r.ReadByte()
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	hasNext := true
	if next == '\r' {
		hasNext = false
		err = p.assumeByte(r, '\n')
		if err != nil {
			return nil, false, p.sanitizeErr(err)
		}
	} else {
		r.UnreadByte()
	}

	return data, hasNext, nil
}
Exemple #7
0
// skipComments skips all comments (and whitespace) that may occur between PNM
// header tokens.
//
// The singleSpace argument is used to scan comments between the header and the
// raster data where only a single whitespace delimiter is allowed. This
// prevents scanning the image data.
func skipComments(r *bufio.Reader, singleSpace bool) (err error) {
	var c byte

	for {
		// Skip whitespace
		c, err = r.ReadByte()
		for unicode.IsSpace(rune(c)) {
			if c, err = r.ReadByte(); err != nil {
				return err
			}
			if singleSpace {
				break
			}
		}
		// If there are no more comments, unread the last byte and return.
		if c != '#' {
			r.UnreadByte()
			return nil
		}
		// A comment ends with a newline or carriage return.
		for c != '\n' && c != '\r' {
			if c, err = r.ReadByte(); err != nil {
				return
			}
		}
	}
	return
}
Exemple #8
0
func isEndOfString(br *bufio.Reader) (ended bool, text string, err error) {
	var b byte
	w := bytes.NewBufferString("")
	for {
		switch b, err = br.ReadByte(); {
		case err == io.EOF:
			ended = true
			err = nil
			return
		case err != nil:
			return
		case b == ',' || b == ']':
			br.UnreadByte()
			ended = true
			return
		case !unicode.IsSpace(rune(b)):
			ended = false
			text = w.String()
			err = nil
			br.UnreadByte()
			return
		}
		w.WriteByte(b)
	}
	return
}
Exemple #9
0
func Decode(input *bufio.Reader) (_ string, err error) {
	buf := bytes.NewBufferString("")
	for {
		b, err := input.ReadByte()
		if err != nil {
			break
		}
		if b != '=' {
			err = buf.WriteByte(b)
		} else {
			input.UnreadByte()
			charset, err := readCharset(input)
			if err != nil {
				return "", err
			}
			encoding, err := readEncoding(input)
			if err != nil {
				return "", err
			}
			(&Decoder{encoding, charset}).Decode(input, buf)
		}
	}
	if err == io.EOF {
		return buf.String(), nil
	}
	return buf.String(), err
}
Exemple #10
0
func peek(r *bufio.Reader) (c byte, e error) {
	c, e = r.ReadByte()
	if e != io.EOF {
		r.UnreadByte()
	}
	return
}
Exemple #11
0
func expect(r *bufio.Reader, c byte) bool {
	ReadWhitespace(r)
	res, err := r.ReadByte()
	if res != c {
		r.UnreadByte()
	}

	return res == c && err != io.EOF
}
Exemple #12
0
func genericExpect(br *bufio.Reader, what string, predicate func(byte) bool) error {
	switch b, err := br.ReadByte(); {
	case err != nil:
		return err
	case !predicate(b):
		br.UnreadByte()
		return NewErrExpect(br, what)
	}
	return nil
}
Exemple #13
0
func skip(rd *bufio.Reader) {
	var b byte = ' '
	var err error
	for b == ' ' || b == '\t' || b == '\n' {
		b, err = rd.ReadByte()
		if err != nil {
			return
		}
	}
	rd.UnreadByte()
}
Exemple #14
0
// space reads whitespace from the given reader, until
// the stream ends or a non-whitespace character is found.
func space(r *bufio.Reader) {
	for {
		b, err := r.ReadByte()
		check(err)

		if !isSpace(b) {
			check(r.UnreadByte())
			return
		}
	}
}
//Peek and check if packet is EOF
func peekEOF(br *bufio.Reader) (bool, os.Error) {
	b, err := br.ReadByte()
	if err != nil {
		return false, err
	}
	err = br.UnreadByte()
	if b == 0xfe {
		return true, err
	}
	return false, err
}
Exemple #16
0
func readSymbol(self *LIPS, in *bufio.Reader, char byte) (cell Cell, e os.Error) {
	buffer := bytes.NewBuffer(nil)
	buffer.WriteByte(char)
	for char, e = in.ReadByte(); e == nil && (charReadsSymbol(self, char) ||
		charReadsNumber(self, char) || charReadsSign(self, char)); char, e = in.ReadByte() {
		buffer.WriteByte(char)
	}
	in.UnreadByte()
	cell = self.Symbol(buffer.String())
	return
}
Exemple #17
0
func readSign(self *LIPS, in *bufio.Reader, char byte) (cell Cell, e os.Error) {
	sign := char
	if char, e = in.ReadByte(); e == nil {
		in.UnreadByte()
		if charReadsNumber(self, char) {
			cell, e = readNumber(self, in, sign)
		} else {
			cell, e = readSymbol(self, in, sign)
		}
	}
	return
}
Exemple #18
0
func readNumber(self *LIPS, in *bufio.Reader, char byte) (cell Cell, e os.Error) {
	buffer := bytes.NewBuffer(nil)
	buffer.WriteByte(char)
	for char, e = in.ReadByte(); e == nil && charReadsNumber(self, char); char, e = in.ReadByte() {
		buffer.WriteByte(char)
	}
	in.UnreadByte()
	if number, e := strconv.Atoi(buffer.String()); e == nil {
		cell = Number(number)
	}
	return
}
Exemple #19
0
// Read a single S-expression from buffered IO r, returning any error
// encountered.  May return io.EOF if at end of r; may return a valid
// S-expression and io.EOF if the EOF was encountered at the end of
// parsing.
func Read(r *bufio.Reader) (s Sexp, err error) {
	c, err := r.ReadByte()
	if err != nil {
		return nil, err
	}
	switch c {
	case '{':
		enc, err := r.ReadBytes('}')
		acc := make([]byte, 0, len(enc)-1)
		for _, c := range enc[:len(enc)-1] {
			if bytes.IndexByte(whitespaceChar, c) == -1 {
				acc = append(acc, c)
			}
		}
		str := make([]byte, base64.StdEncoding.DecodedLen(len(acc)))
		n, err := base64.StdEncoding.Decode(str, acc)
		if err != nil {
			return nil, err
		}
		s, err = Read(bufio.NewReader(bytes.NewReader(str[:n])))
		if err == nil || err == io.EOF {
			return s, nil
		} else {
			return nil, err
		}
	case '(':
		l := List{}
		// skip whitespace
		for {
			c, err := r.ReadByte()
			switch {
			case c == ')':
				return l, err
			case bytes.IndexByte(whitespaceChar, c) == -1:
				r.UnreadByte()
				element, err := Read(r)
				if err != nil {
					return nil, err
				}
				l = append(l, element)
			}
			if err != nil {
				return nil, err
			}
		}
	default:
		return readString(r, c)
	}
	if err != nil {
		return s, err
	}
	panic("Can't reach here")
}
Exemple #20
0
func checkSeparator(reader *bufio.Reader) error {
	err := reader.UnreadByte()
	if err != nil {
		return err
	}

	delim, err := reader.ReadByte()
	if err == nil && delim != '\n' {
		err = ErrSeparatorMissed
	}
	return err
}
Exemple #21
0
func spaces(br *bufio.Reader) error {
	for {
		switch b, err := br.ReadByte(); {
		case err != nil:
			return err
		case !unicode.IsSpace(rune(b)):
			br.UnreadByte()
			return nil
		}
	}
	return nil
}
Exemple #22
0
func doByteRead(r *bufio.Reader) {
	b, err := r.ReadByte()
	if err != nil {
		log.Fatalf("failed reading a byte: %s", err)
	}
	log.Printf("Read a byte: %x", b)

	log.Printf("Didn't mean to read that either, putting it back")
	err = r.UnreadByte()
	if err != nil {
		log.Fatalf("failed urneading a byte: %s", err)
	}
}
Exemple #23
0
func readList(self *LIPS, in *bufio.Reader, char byte) (head Cell, e os.Error) {
	var tail Cell
	var cell Cell

	var end byte
	switch char {
	case '(':
		end = ')'
	case '[':
		end = ']'
	case '{':
		end = '}'
	}

	head = Cons(nil, nil)
	tail = head
	for char, e = skipBlanks(self, in); e == nil; char, e = skipBlanks(self, in) {
		if char == end {
			break
		}
		if char == ')' || char == ']' || char == '}' {
			e = NewError("Error: unmatched parentheses.")
			break
		}
		if char == '.' {
			if cell, e = self.ReadExpression(in); e == nil {
				Rplacd(tail, cell)
			}
		} else {
			in.UnreadByte()
			if cell, e = self.ReadExpression(in); e == nil {
				tail = Rplacd(tail, Cons(cell, nil))
			} else if e == os.EOF {
				e = NewError("Error: EOF in list.")
			}
		}
	}
	head = Cdr(head)
	if _, is := Car(head).(*TypeSymbol); is {
		if expr := Assq(Car(head), Cdr(self.special)); expr != nil {
			head, e = self.Apply(Cdr(expr), Cdr(head), self.Globals)
		}
		if head == nil {
			return
		}
	}
	if head == nil {
		head = self.nothing
	}
	return
}
Exemple #24
0
func isDelim(r *bufio.Reader, delim byte) (bool, error) {
	c, err := r.ReadByte()
	if err != nil {
		return false, err
	}
	if c == delim {
		return true, nil
	}

	err = r.UnreadByte()
	if err != nil {
		return false, err
	}
	return false, nil
}
Exemple #25
0
func skipSpace(r *bufio.Reader) int {
	n := 0
	for {
		c, err := r.ReadByte()
		if err != nil {
			// Bufio will keep err until next read.
			break
		}
		if c != ' ' && c != '\t' {
			r.UnreadByte()
			break
		}
		n++
	}
	return n
}
Exemple #26
0
/**
 * Read row data packet
 */
func (pkt *packetRowData) read(reader *bufio.Reader) (err os.Error) {
	// Read (check if exists) null bit map
	c, err := reader.ReadByte()
	if err != nil {
		return
	}
	if c >= 0x40 && c <= 0x7f {
		pkt.nullBitMap = c
	} else {
		reader.UnreadByte()
	}
	// Allocate memory
	pkt.values = make([]interface{}, len(pkt.fields))
	// Read data for each field
	for i, field := range pkt.fields {
		str, _, err := pkt.readlengthCodedString(reader)
		if err != nil {
			return
		}
		switch field.Type {
		// Strings and everythign else, keep as string
		default:
			pkt.values[i] = str
		// Tiny, small + med int convert into (u)int
		case FIELD_TYPE_TINY, FIELD_TYPE_SHORT, FIELD_TYPE_LONG:
			if field.Flags.Unsigned {
				pkt.values[i], _ = strconv.Atoui(str)
			} else {
				pkt.values[i], _ = strconv.Atoi(str)
			}
		// Big int convert to (u)int64
		case FIELD_TYPE_LONGLONG:
			if field.Flags.Unsigned {
				pkt.values[i], _ = strconv.Atoui64(str)
			} else {
				pkt.values[i], _ = strconv.Atoi64(str)
			}
		// Floats
		case FIELD_TYPE_FLOAT:
			pkt.values[i], _ = strconv.Atof32(str)
		// Double
		case FIELD_TYPE_DOUBLE:
			pkt.values[i], _ = strconv.Atof64(str)
		}
	}
	return
}
Exemple #27
0
func isEndOfSlice(br *bufio.Reader) (bool, error) {
	var (
		b   byte
		err error
	)
	if err = spaces(br); err != nil {
		return false, err
	}
	switch b, err = br.ReadByte(); {
	case err != nil:
		return false, err
	case b == ']':
		return true, nil
	}
	br.UnreadByte()
	return false, nil
}
Exemple #28
0
// Hack to wait until read is available on a bufio.Reader
func waitForRead(bufr *bufio.Reader) <-chan os.Error {
	ch := make(chan os.Error)
	go func() {
		_, err := bufr.ReadByte()
		if err != nil {
			ch <- err
			return
		}
		err = bufr.UnreadByte()
		if err != nil {
			ch <- err
			return
		}
		ch <- nil
	}()
	return ch
}
Exemple #29
0
func readUnquote(self *LIPS, in *bufio.Reader, char byte) (cell Cell, e os.Error) {
	if char, e = in.ReadByte(); e == nil {
		in.UnreadByte()
		cell, e = self.ReadExpression(in)
		switch e {
		case os.EOF:
			e = NewError("Error: EOF in quasiquoted literal.")
		case nil:
			cell = Cons(cell, nil)
			if char == '@' {
				cell = Cons(self.Symbol("unquote-splicing"), cell)
			} else {
				cell = Cons(self.Symbol("unquote"), cell)
			}
		}
	}
	return
}
Exemple #30
0
func (s *Scanner) lexElement(b *bufio.Reader) bool {

	// Spec says size will always fit into 20 bytes or less
	const maxSizeLength = 20

	sizeBuf := make([]byte, maxSizeLength)
	i := 0

	for i = range sizeBuf {
		c, err := b.ReadByte()
		if err != nil {
			return s.setError(err)
		}

		if !isDigit(c) {
			b.UnreadByte()
			break
		}

		sizeBuf[i] = c
	}

	// Turn the size into an int
	size, err := strconv.ParseInt(string(sizeBuf[:i]), 10, 64)
	if err != nil {
		return s.setError(ErrUnreadableSize)
	}

	c, err := b.ReadByte()
	if err != nil {
		return s.setError(err)
	}

	switch c {
	case '<':
		return s.lexData(b, size)
	case '[':
		return s.lexArrayOrDict(b, size, true)
	case '{':
		return s.lexArrayOrDict(b, size, false)
	}

	return s.setError(ErrUnexpectedChar)
}