split lexer out into lex.go
parent
e54e565279
commit
7bf30556ad
@ -0,0 +1,307 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"io"
|
||||||
|
"fmt"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
type typ3 int
|
||||||
|
|
||||||
|
const (
|
||||||
|
invalid typ3 = iota
|
||||||
|
int3ger
|
||||||
|
symbol
|
||||||
|
openParen
|
||||||
|
closeParen
|
||||||
|
str1ng
|
||||||
|
fl0at
|
||||||
|
)
|
||||||
|
|
||||||
|
func (t typ3) String() string {
|
||||||
|
switch t {
|
||||||
|
case int3ger:
|
||||||
|
return "integer"
|
||||||
|
case symbol:
|
||||||
|
return "symbol"
|
||||||
|
case openParen:
|
||||||
|
return "open_paren"
|
||||||
|
case closeParen:
|
||||||
|
return "close_paren"
|
||||||
|
case str1ng:
|
||||||
|
return "string"
|
||||||
|
case fl0at:
|
||||||
|
return "float"
|
||||||
|
}
|
||||||
|
panic("wtf")
|
||||||
|
}
|
||||||
|
|
||||||
|
type token struct {
|
||||||
|
lexeme string
|
||||||
|
t typ3
|
||||||
|
}
|
||||||
|
|
||||||
|
type stateFn func(*lexer) (stateFn, error)
|
||||||
|
|
||||||
|
type lexer struct {
|
||||||
|
io.RuneReader
|
||||||
|
cur []rune
|
||||||
|
depth int
|
||||||
|
out chan token
|
||||||
|
}
|
||||||
|
|
||||||
|
// clears the current lexem buffer and emits a token of the given type.
|
||||||
|
// There's no sanity checking to make sure you don't emit some bullshit, so
|
||||||
|
// don't fuck it up.
|
||||||
|
func (l *lexer) emit(t typ3) {
|
||||||
|
debugPrint("emit " + string(l.cur))
|
||||||
|
l.out <- token{lexeme: string(l.cur), t: t}
|
||||||
|
l.cur = nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// appends the rune to the current in-progress lexem
|
||||||
|
func (l *lexer) append(r rune) {
|
||||||
|
debugPrint(fmt.Sprintf("append %c\n", (r)))
|
||||||
|
if l.cur == nil {
|
||||||
|
l.cur = make([]rune, 0, 32)
|
||||||
|
}
|
||||||
|
l.cur = append(l.cur, r)
|
||||||
|
}
|
||||||
|
|
||||||
|
func isDigit(r rune) bool {
|
||||||
|
switch r {
|
||||||
|
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func debugPrint(s string) {
|
||||||
|
if DEBUG {
|
||||||
|
fmt.Println(s)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexes an open parenthesis
|
||||||
|
func lexOpenParen(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexOpenParen")
|
||||||
|
l.out <- token{"(", openParen}
|
||||||
|
l.depth++
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case '(':
|
||||||
|
return lexOpenParen, nil
|
||||||
|
case ')':
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
if isDigit(r) {
|
||||||
|
l.append(r)
|
||||||
|
return lexInt, nil
|
||||||
|
}
|
||||||
|
l.append(r)
|
||||||
|
return lexSymbol, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexes some whitespace in progress. Maybe this should be combined with root
|
||||||
|
// and the lexer shouldn't have a state. I think wehat I'm doing now is
|
||||||
|
// "wrong" but who honestly gives a shit.
|
||||||
|
func lexWhitespace(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexWhitespace")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case '"':
|
||||||
|
return lexString, nil
|
||||||
|
case '(':
|
||||||
|
return lexOpenParen, nil
|
||||||
|
case ')':
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
if isDigit(r) {
|
||||||
|
l.append(r)
|
||||||
|
return lexInt, nil
|
||||||
|
}
|
||||||
|
l.append(r)
|
||||||
|
return lexSymbol, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func lexString(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexString")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case '"':
|
||||||
|
l.emit(str1ng)
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case '\\':
|
||||||
|
return lexStringEsc, nil
|
||||||
|
}
|
||||||
|
l.append(r)
|
||||||
|
return lexString, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// lex the character *after* the string escape character \
|
||||||
|
func lexStringEsc(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexStringEsc")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
l.append(r)
|
||||||
|
return lexString, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// lex an integer. Once we're on an integer, the only valid characters are
|
||||||
|
// whitespace, close paren, a period to indicate we want a float, or more
|
||||||
|
// digits. Everything else is crap.
|
||||||
|
func lexInt(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexInt")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
l.emit(int3ger)
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case '.':
|
||||||
|
l.append(r)
|
||||||
|
return lexFloat, nil
|
||||||
|
case ')':
|
||||||
|
l.emit(int3ger)
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
l.emit(int3ger)
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
if isDigit(r) {
|
||||||
|
l.append(r)
|
||||||
|
return lexInt, nil
|
||||||
|
}
|
||||||
|
return nil, fmt.Errorf("unexpected rune in lexInt: %c", r)
|
||||||
|
}
|
||||||
|
|
||||||
|
// once we're in a float, the only valid values are digits, whitespace or close
|
||||||
|
// paren.
|
||||||
|
func lexFloat(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexFloat")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
l.emit(fl0at)
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case ')':
|
||||||
|
l.emit(fl0at)
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
l.emit(fl0at)
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
if isDigit(r) {
|
||||||
|
l.append(r)
|
||||||
|
return lexFloat, nil
|
||||||
|
}
|
||||||
|
return nil, fmt.Errorf("unexpected run in lexFloat: %c", r)
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexes a symbol in progress
|
||||||
|
func lexSymbol(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexSymbol")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
debugPrint("ending lexSymbol on whitespace")
|
||||||
|
l.emit(symbol)
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case ')':
|
||||||
|
l.emit(symbol)
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
l.emit(symbol)
|
||||||
|
return lexComment, nil
|
||||||
|
default:
|
||||||
|
l.append(r)
|
||||||
|
return lexSymbol, nil
|
||||||
|
}
|
||||||
|
panic("not reached")
|
||||||
|
}
|
||||||
|
|
||||||
|
// lex a close parenthesis
|
||||||
|
func lexCloseParen(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexCloseParen")
|
||||||
|
l.out <- token{")", closeParen}
|
||||||
|
l.depth--
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case ' ', '\t', '\n', '\r':
|
||||||
|
return lexWhitespace, nil
|
||||||
|
case ')':
|
||||||
|
return lexCloseParen, nil
|
||||||
|
case ';':
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
return nil, fmt.Errorf("unimplemented")
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexes a comment
|
||||||
|
func lexComment(l *lexer) (stateFn, error) {
|
||||||
|
debugPrint("-->lexComment")
|
||||||
|
r, _, err := l.ReadRune()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch r {
|
||||||
|
case '\n', '\r':
|
||||||
|
return lexWhitespace, nil
|
||||||
|
}
|
||||||
|
return lexComment, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexes some lispy input from an io.Reader, emiting tokens on chan c. The
|
||||||
|
// channel is closed when the input reaches EOF, signaling that there are no
|
||||||
|
// new tokens.
|
||||||
|
func lex(input io.RuneReader, c chan token) {
|
||||||
|
defer close(c)
|
||||||
|
l := &lexer{input, nil, 0, c}
|
||||||
|
|
||||||
|
var err error
|
||||||
|
f := stateFn(lexWhitespace)
|
||||||
|
for err == nil {
|
||||||
|
f, err = f(l)
|
||||||
|
}
|
||||||
|
if err != io.EOF {
|
||||||
|
fmt.Println(err)
|
||||||
|
}
|
||||||
|
if l.depth != 0 {
|
||||||
|
fmt.Println("error: unbalanced parenthesis")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
func lexs(input string, c chan token) {
|
||||||
|
lex(strings.NewReader(input), c)
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue