calc.go

package main

import (
	"fmt"
	"unicode"
	"unicode/utf8"
)

type NodeKind int

const (
	AddOp NodeKind = iota
	SubOp
	MulOp
	DivOp
	Num
)

type Node struct {
	kind NodeKind
	num  int
	lhs  *Node
	rhs  *Node
}

type Parser struct {
	input string
	pos   int
}

func NewNumNode(num int) *Node {
	node := new(Node)
	node.num = num
	node.kind = Num
	return node
}

func NewOpNode(kind NodeKind, lhs *Node, rhs *Node) *Node {
	node := new(Node)
	node.kind = kind
	node.lhs = lhs
	node.rhs = rhs
	return node
}

func (n *Node) Show() {
	switch n.kind {
	case Num:
		fmt.Print(n.num)
	default:
		fmt.Println("unimplemented ops")
	}
}

func NewParser(input string) *Parser {
	parser := new(Parser)
	parser.input = input
	parser.pos = 0
	return parser
}

func (p *Parser) Cur() rune {
	r, w := utf8.DecodeRuneInString(p.input[p.pos:])
	if unicode.IsSpace(r) {
		p.pos += w
		return p.Cur()
	}
	return r
}

func (p *Parser) Next() rune {
	r, w := utf8.DecodeRuneInString(p.input[p.pos:])
	p.pos += w
	if unicode.IsSpace(r) {
		return p.Next()
	}
	return r
}

func (p *Parser) ParseExpression() *Node {
	n := 0
	for {
		if !unicode.IsDigit(p.Cur()) {
			break
		}
		n = n*10 + int(p.Next()-'0')
	}
	return NewNumNode(n)
}

func main() {
	parser := NewParser("1+2")
	node := parser.ParseExpression()
	node.Show()
}