lex integer/float nodes properly (needs tests), stab at stack collaps…

…ing for order of ops but it is too simplistic

neo/lex.go

@@ -387,6 +387,8 @@ func lexInsideBlock(l *lexer) stateFn {
 		switch {
 		case isSpace(r):
 			return lexSpace
+		case isNumeric(r):
+			return lexNumber
 		case isAlphaNumeric(r):
 			return lexIdentifier
 		case r == '"':
@@ -514,6 +516,26 @@ func lexIdentifier(l *lexer) stateFn {
 	}
 }
 
+func lexNumber(l *lexer) stateFn {
+	tokType := tokenInteger
+	for {
+		switch r := l.next(); {
+		case isNumeric(r):
+			// abosrb
+		case r == '.':
+			if tokType != tokenFloat {
+				tokType = tokenFloat
+			} else {
+				l.errorf("two dots in numeric token")
+			}
+		default:
+			l.backup()
+			l.emit(tokType)
+			return lexInsideBlock
+		}
+	}
+}
+
 // Called at the end of a string
 func (l *lexer) emitString() {
 	l.backup()
@@ -567,3 +589,7 @@ func isEndOfLine(r rune) bool {
 func isAlphaNumeric(r rune) bool {
 	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
 }
+
+func isNumeric(r rune) bool {
+	return unicode.IsDigit(r)
+}

neo/parse.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"runtime"
 	"strings"
+
+	"github.com/davecgh/go-spew/spew"
 )
 
 // Important to jigo, as to most languages, is the idea of an expression.
@@ -203,6 +205,29 @@ func (t *Tree) expect(i itemType) (token item) {
 	return t.nextNonSpace()
 }
 
+// Collapse N nodes into one
+func (t *Tree) collapse(stack *nodeStack) Node {
+	if stack.len() < 2 {
+		return stack.pop()
+	}
+	rhs := stack.pop()
+	lhs := stack.pop()
+	switch lhs.(type) {
+	case *AddExpr:
+		lhs := lhs.(*AddExpr)
+		lhs.rhs = rhs
+		return lhs
+	case *MulExpr:
+		lhs := lhs.(*MulExpr)
+		lhs.rhs = rhs
+		return lhs
+	default:
+		stack.push(lhs)
+		stack.push(rhs)
+		return nil
+	}
+}
+
 // Parsing.
 
 // New allocates a new parse tree with the given name.
@@ -402,6 +427,11 @@ func (t *Tree) parseExpr(stack *nodeStack, terminator itemType) Node {
 		if unary.typ != 0 && stack.len() > 0 {
 			// apply the unary to the expression
 		}
+		if stack.len() > 1 {
+			fmt.Printf("Stack: ")
+			spew.Dump(stack.Nodes)
+			return t.collapse(stack)
+		}
 		token = t.peekNonSpace()
 		switch token.typ {
 		case terminator:

neo/parse_test.go

@@ -42,6 +42,13 @@ func spewTree(n Node, indent string) {
 		fmt.Printf("%s    +\n", indent)
 		spewTree(n.rhs, indent+"  ")
 		fmt.Printf("%s}\n", indent)
+	case *MulExpr:
+		n := n.(*MulExpr)
+		fmt.Printf("%s(MulExpr) {\n", indent)
+		spewTree(n.lhs, indent+"  ")
+		fmt.Printf("%s    *\n", indent)
+		spewTree(n.rhs, indent+"  ")
+		fmt.Printf("%s}\n", indent)
 	default:
 		fmt.Printf(indent)
 		spew.Dump(n)