Example #1
0
// translate EscX to Meta+X
func escapeKey(r rune, reader *bufio.Reader) rune {
	switch r {
	case 'b':
		r = MetaBackward
	case 'f':
		r = MetaForward
	case 'd':
		r = MetaDelete
	case CharTranspose:
		r = MetaTranspose
	case CharBackspace:
		r = MetaBackspace
	case 'O':
		d, _, _ := reader.ReadRune()
		switch d {
		case 'H':
			r = CharLineStart
		case 'F':
			r = CharLineEnd
		default:
			reader.UnreadRune()
		}
	case CharEsc:

	}
	return r
}
Example #2
0
func Rune(r *bufio.Reader) rune {
	v, _, err := r.ReadRune()
	if err != nil {
		panic(err)
	}
	return v
}
Example #3
0
func readRune(r *bufio.Reader) (rune, error) {
	rn, _, err := r.ReadRune()
	if err == io.EOF {
		return EOF, nil
	}
	return rn, err
}
Example #4
0
File: io.go Project: dtromb/logic
func (sr *StandardReader) NextIdentifier(in *bufio.Reader) string {
	var id []rune
	if sr.cIdentifier != "" {
		rv := sr.cIdentifier
		sr.cIdentifier = ""
		return rv
	}
	for {
		c, _, err := in.ReadRune()
		if err != nil {
			if len(id) != 0 {
				break
			}
			sr.Error(errors.New(fmt.Sprintf("expected identifier (%s)", err.Error())))
		}
		var ok bool
		if len(id) == 0 {
			ok = sr.IdentifierStart(c)
		} else {
			ok = sr.IdentifierPart(c)
		}
		if !ok {
			in.UnreadRune()
			if len(id) == 0 {
				break
			}
			sr.Error(errors.New(fmt.Sprintf("expected identifier (%s)", err.Error())))
		}
		sr.pos += 1
		sr.col += 1
		id = append(id, c)
	}
	return string(id)
}
Example #5
0
func (p *parser) nextToken(reader *bufio.Reader) (string, syms.SymbolID) {
	var sid stateID
	var str bytes.Buffer
	s := p.all[sid]
	for {
		r, _, err := reader.ReadRune()
		if err != nil {
			if sid == 0 {
				if err == io.EOF {
					return "", syms.EOF
				}
				return "", syms.ERROR
			}
			return str.String(), s.id
		}
		sid = s.tr[r]
		if sid == 0 {
			// fmt.Println("nextToken: unaccepted ", string(r), " returning ", s.id)
			reader.UnreadRune()
			return str.String(), s.id
		}
		// fmt.Println("nextToken: move via ", string(r), " to ", sid)
		s = p.all[sid]
		str.WriteRune(r)
	}
}
Example #6
0
// translate Esc[X
func escapeExKey(r rune, reader *bufio.Reader) rune {
	switch r {
	case 'D':
		r = CharBackward
	case 'C':
		r = CharForward
	case 'A':
		r = CharPrev
	case 'B':
		r = CharNext
	case 'H':
		r = CharLineStart
	case 'F':
		r = CharLineEnd
	default:
		if r == '3' && reader != nil {
			d, _, _ := reader.ReadRune()
			if d == '~' {
				r = CharDelete
			} else {
				reader.UnreadRune()
			}
		}
	}
	return r
}
Example #7
0
// CharCount scans a *bufio.Reader and returns a map of the counts of its
// Unicode character types.
func CharCount(in *bufio.Reader) map[string]int {
	counts := make(map[string]int) // counts of Unicode character types

	for {
		r, n, err := in.ReadRune() // returns rune, nbytes, error
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Fprintf(os.Stderr, "charcount: %v\n", err)
			os.Exit(1)
		}

		switch {
		case r == unicode.ReplacementChar && n == 1:
			counts["invalid"]++
		case unicode.IsControl(r):
			counts["control"]++
		case unicode.IsLetter(r):
			counts["letter"]++
		case unicode.IsMark(r):
			counts["mark"]++
		case unicode.IsNumber(r):
			counts["number"]++
		case unicode.IsPunct(r):
			counts["punct"]++
		case unicode.IsSpace(r):
			counts["space"]++
		case unicode.IsSymbol(r):
			counts["symbol"]++
		}
	}
	return counts
}
Example #8
0
func nextLine(f *bufio.Reader) {
	// Consume whitespace
	for {
		r, _, err := f.ReadRune()
		if err != nil {
			if err == io.EOF {
				return
			}
			panic(err.Error())
		}
		if r != ' ' && r != '\t' {
			f.UnreadRune()
			break
		}
	}
	// Consume any number of endline runes
	for {
		r, _, err := f.ReadRune()
		if err != nil {
			if err == io.EOF {
				return
			}
			panic(err.Error())
		}
		if r != '\r' && r != '\n' {
			f.UnreadRune()
			return
		}
	}
}
Example #9
0
func main() {
	scripts := flag.Bool("scripts", false, "print contained script names")
	cats := flag.Bool("cats", false, "print unicode categories")
	nochars := flag.Bool("no-chars", false, "do not print character information")
	flag.Parse()

	var reader *bufio.Reader
	args := flag.Args()
	if len(args) > 0 {
		is, err := os.Open(args[0])
		if err != nil {
			panic(err)
		}
		defer is.Close()
		reader = bufio.NewReader(is)
	} else {
		reader = bufio.NewReader(os.Stdin)
	}
	chars := make(map[rune]int)
	for r, _, err := reader.ReadRune(); err == nil; r, _, err = reader.ReadRune() {
		chars[r]++
	}
	if !*nochars {
		printChars(chars)
	}
	if *cats {
		printCategories(chars)
	}
	if *scripts {
		printScripts(chars)
	}
}
// Lint reads the provided reader (with an optional associated path)
// and checks the markdown for basic errors. Any errors found are
// sent to the provided out channel
func Lint(reader *bufio.Reader, path string, out chan<- error) {
	brackets, parens := list.New(), list.New()
	line := 1
	column := 1
	enDashes := make(map[int]int)
	pos := int64(0)

	// Parse the file
	for {
		r, size, err := reader.ReadRune()
		pos += int64(size)

		if err != nil {
			if err != io.EOF {
				out <- fmt.Errorf("Error reading from %s - %s", path, err)
			}
			break
		}

		switch r {
		case '[':
			brackets.PushFront(syntaxError{line, column, pos})
		case ']':
			top := brackets.Front()
			if top == nil {
				basicError := fmt.Errorf(`Bad Markdown URL in %s:
	extra closing bracket at line %d, column %d`, path, line, column)
				out <- usefulError(path, pos, basicError)
			} else {
				brackets.Remove(top)
			}
		case '(':
			parens.PushFront(syntaxError{line, column, pos})
		case ')':
			top := parens.Front()
			if top == nil {
				basicError := fmt.Errorf(`Bad Markdown URL in %s:
	extra closing parenthesis at line %d, column %d`, path, line, column)
				out <- usefulError(path, pos, basicError)
			} else {
				parens.Remove(top)
			}
		case '–':
			enDashes[line]++
		case '\n':
			line++
			column = 0
		}

		column++
	}

	// Check the results and accumulate any problems
	checkHanging(brackets, "bracket", out, path)
	checkHanging(parens, "parenthesis", out, path)

	for line := range enDashes {
		out <- fmt.Errorf("literal en dash at %s:%d - please use -- instead", path, line)
	}
}
Example #11
0
func main() {
	flag.Usage = usage
	flag.Parse()

	var r *bufio.Reader
	if flag.NArg() < 1 {
		r = bufio.NewReader(os.Stdin)
	} else {
		line := strings.Join(flag.Args(), " ")
		r = bufio.NewReader(strings.NewReader(line))
	}

	for {
		ch, _, err := r.ReadRune()
		if err != nil {
			break
		}

		switch {
		case 'A' <= ch && ch <= 'M',
			'a' <= ch && ch <= 'm':
			ch += 13
		case 'N' <= ch && ch <= 'Z',
			'n' <= ch && ch <= 'z':
			ch -= 13
		}
		fmt.Printf("%c", ch)
	}
}
Example #12
0
func preprocess(buf []byte, r *bufio.Reader) (int, error) {
	i := 0
	for c, n, err := r.ReadRune(); err == nil; c, n, err = r.ReadRune() {
		if i+n > len(buf) {
			// We don't have room so unread the rune and return.
			r.UnreadRune()
			return i, err
		}
		switch c {
		case '\x00':
			if len(buf)-1 < i+len(unknownRune) {
				copy(buf[i:len(unknownRune)], unknownRune)
			} else {
				// We don't have room so unread the rune and
				// return.
				r.UnreadRune()
				return i + n, err
			}
		case '\r':
			buf[i] = '\n'
			nxt, err := r.Peek(1)
			if err == nil && len(nxt) == 1 && nxt[0] == '\n' {
				r.ReadByte()
			}
		case '\f':
			buf[i] = '\n'
		default:
			copy(buf[i:i+n], []byte(string(c)))
		}
		i += n
	}
	return i, nil
}
Example #13
0
File: main.go Project: PieterD/crap
func (_ myHandler) Handle(reader *bufio.Reader, t *term.Full, c <-chan WindowSize) error {
	go func() {
		for ws := range c {
			t.SetDimensions(ws.Width, ws.Height)
		}
	}()

	t.Clear()
	for {
		r, _, err := reader.ReadRune()
		Panic(err)
		fmt.Printf("'%c'\n", r)

		t.Clear()
		t.Pos(10, 5)
		t.Printf("'%c' ", r)
		t.Attr().Fore(term.Red).Done()
		t.Printf("red ")
		t.Attr().Fore(term.Default).Done()
		t.Printf("default ")
		t.Attr().Fore(term.Red).Bright().Done()
		t.Printf("brightred ")
		t.Attr().Reset().Done()
		t.Printf("reset ")

		if t.Error() != nil {
			fmt.Printf("%v\n", t.Error())
		}
	}

	return nil
}
Example #14
0
File: mud.go Project: herth/mud
func skipWS(reader *bufio.Reader) (eof bool) {
	eof = false
	for {
		rune, size, _ := reader.ReadRune()
		if size == 0 {
			eof = true
			break
		}
		if rune == 32 {
			continue
		}
		if rune == 13 {
			continue
		}
		if rune == 10 {
			continue
		}
		if rune == 9 {
			continue
		}
		reader.UnreadRune()
		break
	}
	return eof
}
Example #15
0
File: parser.go Project: vron/sem
// Parse a address greedily from the buffer, if the first non-witespace
// token found is not a valid start of an adr nil, nil is returned
// If a valid adr is parsed, !nil, nil is returned
// If there is an error whilst parsing the addr nil, !nil is returned
// Note that it will consume all spaces in the buffer to check the next char
func Parse(b *bufio.Reader) (*Node, error) {
	// TODO: Change from bytes.Bufer to something nicer... Best is an interface..
	//Check for start, is it the start of an adr
	tl := newLexer(b)
	tl.consume(unicode.IsSpace)
	r, _, e := b.ReadRune()
	if e != nil {
		return nil, nil
	}
	b.UnreadRune()
	if !(unicode.IsDigit(r) ||
		r == '/' ||
		r == '+' ||
		r == '-' ||
		r == '.' ||
		r == '$' ||
		r == '\'' ||
		r == '#' ||
		r == ',' ||
		r == ';') {
		return nil, nil
	}

	fullNode = nil
	l := newLexer(b)
	ok := yyParse(l)
	if ok != 0 {
		// There was an error whils parsing:
		return nil, err
	}
	return fullNode, nil
}
Example #16
0
File: mud.go Project: herth/mud
func readQuoted(reader *bufio.Reader, delim rune) (result string, eof bool) {
	var b bytes.Buffer
	esc := false

	for {
		r, s, _ := reader.ReadRune()
		if s == 0 {
			eof = true
			break
		}
		if esc {
			switch r {
			case 'n':
				b.WriteRune(10)
			case 't':
				b.WriteRune(8)
			default:
				b.WriteRune(r)
			}
			esc = false
		} else {
			switch r {
			case delim:
				return b.String(), eof
			case '\\':
				esc = true
			default:
				b.WriteRune(r)
			}
		}

	}
	return b.String(), eof
}
Example #17
0
func readSexp(r *bufio.Reader) (*Sexp, error) {
	// read ( or atom
	c, _, err := r.ReadRune()
	if err != nil {
		return nil, err
	} else if c != '(' {
		r.UnreadRune()
		return readAtom(r)
	}

	// read two space-separated Sexps
	x, err := readSexp(r)
	if err != nil {
		return nil, err
	}
	if err = expect(r, ' '); err != nil {
		return nil, err
	}
	y, err := readSexp(r)
	if err != nil {
		return nil, err
	}

	// read )
	if err = expect(r, ')'); err != nil {
		return nil, err
	}

	return &Sexp{X: x, Y: y}, nil
}
Example #18
0
File: parse.go Project: nhoss2/logo
func parse(r *bufio.Reader, line, col *int, inList bool) (n Node, err error) {

	err = readSeparator(r, List, line, col)
	if err != nil {
		return
	}

	c, _, err := r.ReadRune()
	checkNewline(c, line, col)
	switch c {
	case comment:
		err = readComment(r, line, col)
	case listStart:
		n, err = readList(r, line, col)
	case listEnd:
		r.UnreadRune()
	case groupStart:
		n, err = readGroup(r, line, col)
	case groupEnd:
		r.UnreadRune()
	default:
		n, err = readWord(r, line, col)
	}

	return
}
Example #19
0
func getc(b *bufio.Reader) rune {
	c, _, err := b.ReadRune()
	if err != nil {
		return eof
	}
	return c
}
Example #20
0
func count(in *bufio.Reader) (nl, nw, nr, nc int, err error) {
	inword := false
	for {
		var r rune
		var sz int
		r, sz, err = in.ReadRune()
		if err == io.EOF {
			err = nil
			break
		}
		if err != nil {
			return
		}

		nr++
		nc += sz
		if r == '\n' {
			nl++
		}
		if unicode.IsSpace(r) && inword {
			inword = false
			nw++
		} else if !unicode.IsSpace(r) {
			inword = true
		}
	}
	return
}
Example #21
0
// Reads a character and returns its index in the vocabulary
func ReadCharIndex(fin *bufio.Reader) (int, error) {
	var char rune
	char, _, err := fin.ReadRune()
	if err == io.EOF {
		return -1, err
	}
	return SearchVocab(char), nil
}
Example #22
0
func readRune(state *LexerState,
	reader *bufio.Reader) (rune int, size int, err os.Error) {
	rune, size, err = reader.ReadRune()
	if size > 0 {
		state.rune += 1
	}
	return
}
Example #23
0
File: io.go Project: dtromb/logic
func (sr *StandardReader) TestPeek(in *bufio.Reader, c rune) bool {
	c0, _, err := in.ReadRune()
	if err != nil {
		return false
	}
	in.UnreadRune()
	return c == c0
}
Example #24
0
func expect(r *bufio.Reader, exp rune) error {
	c, _, err := r.ReadRune()
	if err != nil {
		return err
	} else if c != exp {
		return errors.New("expected " + string(exp) + ", got " + string(c))
	}
	return nil
}
Example #25
0
func checkEmpty(data *bufio.Reader) (err error) {
	if _, _, err = data.ReadRune(); err != nil {
		return errors.New("unable to locate front matter")
	}
	if err = data.UnreadRune(); err != nil {
		return errors.New("unable to unread first charactor in page buffer.")
	}
	return
}
Example #26
0
File: parse.go Project: nhoss2/logo
func readComment(r *bufio.Reader, line, col *int) (err error) {

	c, _, err := r.ReadRune()
	checkNewline(c, line, col)
	for err == nil && c != newLine {
		c, _, err = r.ReadRune()
		checkNewline(c, line, col)
	}
	return err
}
func lint(reader *bufio.Reader, path string, out chan<- error) lintResult {
	res := lintResult{list.New(), list.New(), make(map[int]int), make(map[int]int)}
	line := 1
	column := 1
	pos := int64(0)

	// Parse the file
	for {
		r, size, err := reader.ReadRune()
		pos += int64(size)

		if err != nil {
			if err != io.EOF {
				out <- fmt.Errorf("Error reading from %s - %s", path, err)
			}
			break
		}

		switch r {
		case '[':
			res.brackets.PushFront(syntaxError{line, column, pos})
		case ']':
			top := res.brackets.Front()
			if top == nil {
				basicError := fmt.Errorf(`Bad Markdown URL in %s:
	extra closing bracket at line %d, column %d`, path, line, column)
				out <- usefulError(path, pos, basicError)
			} else {
				res.brackets.Remove(top)
			}
		case '(':
			res.parens.PushFront(syntaxError{line, column, pos})
		case ')':
			top := res.parens.Front()
			if top == nil {
				basicError := fmt.Errorf(`Bad Markdown URL in %s:
	extra closing parenthesis at line %d, column %d`, path, line, column)
				out <- usefulError(path, pos, basicError)
			} else {
				res.parens.Remove(top)
			}
		case '–':
			res.enDashes[line]++
		case '—':
			res.emDashes[line]++
		case '\n':
			line++
			column = 0
		}

		column++
	}
	return res
}
Example #28
0
func fgetln(r *bufio.Reader) (string, error) {
	b := new(bytes.Buffer)
	for {
		c, _, err := r.ReadRune()
		if err != nil || c == '\n' {
			return b.String(), err
		}

		b.WriteRune(c)
	}
}
Example #29
0
File: io.go Project: js-arias/jdh
// PeeKNext peek next valid (non space) rune from an input buffer.
func peekNext(in *bufio.Reader) (rune, error) {
	if err := skipSpaces(in); err != nil {
		return rune(0), err
	}
	r, _, err := in.ReadRune()
	if err != nil {
		return rune(0), err
	}
	in.UnreadRune()
	return r, nil
}
Example #30
0
func skipline(r *bufio.Reader) (err error) {
	var char rune
	for {
		char, _, err = r.ReadRune()
		if err != nil {
			return err
		}
		if char == '\n' {
			return nil
		}
	}
}