var psr psr.Parser
psr = compiler
ast, _ := psr.Call(tokens)
ast.Eval(code) // codeにアセンブラが書き込まれている。

type Parser struct {
	Call func([]tok.Token) (ast.AST, []tok.Token)
}

type AST struct {
	nodes []*AST
	Token *tok.Token
	atype *ASTType
	eval  Eval
}

func (a AST) Eval(code asm.Code) {
	if a.eval == nil {
		for _, node := range a.nodes {
			node.Eval(code)
		}
	} else {
		a.eval(a.nodes, code)
	}
}

func eval(nodes []ast.AST, code asm.Code) {
	nodes[0].Eval(code) // (+ 1 2)に対応するコードの書き出し。実行時に評価されるとstackに3をpushする
	nodes[1].Eval(code) // 1に対応するコードの書き出し。実行時に評価されるとstackに1をpushする

	// このコードパスに来た段階でstackに3と2が積まれいるはず。
	// その2つをpopして足して再びstackにpushするコードを`code`に書き込んでいく
	code.
		Ins(asm.I().Pop().Rax()).
		Ins(asm.I().Pop().Rdi()).
		Ins(asm.I().Add().Rax().Rdi()).
		Ins(asm.I().Push().Rax())
}

var numInt = andId().And(psr.Int, true).
	SetEval(func(nodes []*ast.AST, code asm.Code) {
		i := nodes[0].Token.Vali()
		code.Ins(asm.I().Push().Val(i)) // intをstackにpushする
	})

var add = andId().And(psr.Int, true).And(psr.Plus, false).And(psr.Int, true).
	SetEval(func(nodes []*ast.AST, code asm.Code) {
		// ノードの数は2つ(+リテラルはASTへの追加をしていない)
		nodes[0].Eval(code)
		nodes[1].Eval(code)

		code.
			Ins(asm.I().Pop().Rax()).
			Ins(asm.I().Pop().Rdi()).
			Ins(asm.I().Add().Rax().Rdi()).
			Ins(asm.I().Push().Rax())
	})

tokens := tok.Tokenize("1 + 2")
ast, _ := add.Call(tokens)
ast.Eval(code) // codeにアセンブリが書き込まれている。

func (psr Parser) SetEval(eval func(nodes []ast.AST, code asm.Code)) Parser {
	call := func(tokens []tok.Token) (ast.AST, []tok.Token) {
		if ast, tokens := psr.Call(tokens); ast.Fail() {
			return ast.Fail, tokens
		} else {
			// psrが吐くASTにevalをアタッチしてる
			ast.SetEval(eval)
			return ast, tokens
		}
	}
	return Parser{Call: call}
}

func adder(expr *psr.Parser) psr.Parser{
	add := andId().And(expr, true).And(psr.Plus, false).And(expr, true).
		SetEval(func(nodes []*ast.AST, code asm.Code) {
			// ノードの数は2つ(+リテラルはASTへの追加をしていない)
			nodes[0].Eval(code)
			nodes[1].Eval(code)

			code.
				Ins(asm.I().Pop().Rax()).
				Ins(asm.I().Pop().Rdi()).
				Ins(asm.I().Add().Rax().Rdi()).
				Ins(asm.I().Push().Rax())
		})

	return add
}

func Generator() psr.Parser {
	body := func(st *SymTable) psr.Parser {
		lvIdent := lvIdenter(st)
		rvIdent := rvIdenter(&lvIdent)

		var term, muls, adds, expr, eqs, call, ifex psr.Parser
		num := orId().Or(&numInt).Or(&call).Or(&rvIdent)

		eqs, adds, muls = eqneqs(&adds), addsubs(&muls), muldivs(&term)

		parTerm := andId().And(psr.LPar, false).And(&adds, true).And(psr.RPar, false).Trans(ast.PopSingle)
		term = orId().Or(&num).Or(&parTerm)

		assign := assigner(&lvIdent, &expr)
		expr = orId().Or(&assign).Or(&eqs)
		call = funcCaller(&expr)
		semi := andId().And(&expr, true).And(psr.Semi, false)

		line := andId().And(&semi, true).And(&popRax, true)
		ret := returner(&semi)

		retIfLine := orId().Or(&ifex).Or(&ret).Or(&line)
		lines := andId().Rep(&retIfLine)
		ifex = ifer(&expr, &lines)

		return andId().And(&lines, true)
	}

	function := funcDefiner(body)
	functions := andId().Rep(&function)

	return andId().And(&functions, true).And(psr.EOF, false)
}

asmCode := "        mov rax, 42"
asmCode += "        ret"

asmCode := "        mob rax, 42"

acode.Ins(asm.I().Mov().Rax().Val(42))

for {
	if len(s) == 0 {
	break
	}
	if s[0] == "+" {
		tokens = append(tokens, PlusToken)
		s = s[1:]
		continue
	}
	if s[0] == "-" {
		tokens = append(tokens, MinusToken)
		s = s[1:]
		continue
	}

}

var TPlus TokenType = TokenType{literal: "+"}
var TMinus TokenType = TokenType{literal: "-"}
var TLPar TokenType = TokenType{literal: "("}
var TRPar TokenType = TokenType{literal: ")"}
var TMul TokenType = TokenType{literal: "*"}
var TDiv TokenType = TokenType{literal: "/"}

var TokenTypes = []*TokenType{&TPlus, &TMinus, &TInt, &TLPar, &TRPar, &TMul, &TDiv}

func Tokenize(s string) []Token {
	return tokenize(TokenTypes, s)

}

mul := OrId()
add := OrId()
term := OrId()

termPlusMul := AndId().And(&term).And(Plus).And(&mul)
termMinusMul := AndId().And(&term).And(Minus).And(&mul)
add = add.Or(&termPlusMul).Or(&termMinusMul).Or(&term)
// add = term + mul | term - mul | term

termMulMul := AndId().And(&term).And(Mul).And(&mul)
termDivMul := AndId().And(&term).And(Div).And(&mul)
mul = mul.Or(&termMulMul).Or(&termDivMul).Or(&add)
// mul = term * mul | term / mul | add

parTerm := AndId().And(LPar).And(&mul).And(RPar)
term = term.Or(&parTerm).Or(num)
// term = ( term ) | num

return AndId().And(&mul).And(EOF)
// mul EOF

var TFail ASTType = ASTType{}
var Fail = AST{atype: &TFail}

// 足し算(`expr + expr`)の形のコードをコンパイルするコンパイラを生成する関数
// @param expr 足し算の引数部分(expr)をコンパイルするコンパイラ
// @return 戻り値として引数2つを取る足し算のコンパイラが返る
func adder(expr *psr.Parser) psr.Parser {
	// `expr + expr`という形の構文をパースする
	return andId().And(expr, true).And(psr.Plus, false).And(expr, true).

		// コード生成の定義を以下に書いていく
		SetEval(func(nodes []*ast.AST, code asm.Code) {

			// 左側のexprをアセンブリコードとして書き出す
			nodes[0].Eval(code)
			// 右側のexprをアセンブリコードとして書き出す
			nodes[1].Eval(code)

			// 生成されたアセンブリコードが実行されてこのコードに到達した時、
			// 2つのexprが評価された結果、値が2つスタックに積まれているはずである
			// なので、その2つの値をpopし、足し合わせて結果をスタックに積むコードを
			// 以下で書き込んでいく:
			code.
				// スタックをpopして値をraxレジスタに乘せる
				Ins(asm.I().Pop().Rax()).
				// スタックをpopして値をrdiレジスタに乘せる
				Ins(asm.I().Pop().Rdi()).
				// raxとrdiレジスタの値を足す、結果はraxに乗る
				Ins(asm.I().Add().Rax().Rdi()).
				// raxレジスタの値をスタックに積む
				Ins(asm.I().Push().Rax())
		})
}

// 文字列をトークンナイズする
tokens := Tokenize("1 + 2")
// 整数一文字をコンパイルするコンパイラ(`Int`)を渡して、足し算コンパイラをインスタンス化する
add := adder(&Int)
// トークン列をパースしてAST(抽象構文木)を返す
ast, _ := add.Call(tokens)
// ASTを評価してアセンブリコードを`code`に書き出す
ast.Eval(code)

var Int = andId().And(psr.Int, true).
	SetEval(func(nodes []*ast.AST, code asm.Code) {
		// トークンに入っている値を取り出す
		i := nodes[0].Token.Vali()
		// 取り出された値をstackにpushする
		code.Ins(asm.I().Push().Val(i))
	})

func Generator() psr.Parser {
	body := func(st *SymTable) psr.Parser {
		lvIdent := lvIdenter(st)
		ptrDeRef := ptrDeRefer(st, &lvIdent)

		rvAddr := rvAddrer(&lvIdent)
		rvIdent := rvIdenter(&ptrDeRef)
		rvVal := orId().Or(&rvAddr).Or(&rvIdent)

		var term, muls, adds, expr, eqs, call, ifex, while, forex psr.Parser
		num := orId().Or(&numInt).Or(&call).Or(&rvVal)

		eqs, adds, muls = eqneqs(&adds), addsubs(&muls), muldivs(&term)

		parTerm := andId().And(psr.LPar, false).And(&adds, true).And(psr.RPar, false).Trans(ast.PopSingle)
		term = orId().Or(&num).Or(&parTerm)

		assign := assigner(&ptrDeRef, &expr)
		expr = orId().Or(&assign).Or(&eqs)
		call = funcCaller(&expr)
		semi := andId().And(&expr, true).And(psr.Semi, false)
		varDeclare := varDeclarer(st, psr.Semi)

		line := andId().And(&semi, true).And(&popRax, true)
		ret := returner(&semi)

		body := orId().Or(&ifex).Or(&forex).Or(&while).Or(&ret).Or(&varDeclare).Or(&line)
		bodies := andId().Rep(&body)

		ifex, forex, while = ifer(&expr, &bodies), forer(&expr, &bodies), whiler(&expr, &bodies)

		return andId().And(&bodies, true)
	}

	function := funcDefiner(body)
	functions := andId().Rep(&function)

	return andId().And(&functions, true).And(psr.EOF, false)
}

// 入力される文字列
var input = "1+2"

// 出力されるトークン列
var output = []struct {
	tokenType string
	value     string
}{
	{tokenType: "Integer", value: "1"},
	{tokenType: "Opetator", value: "+"},
	{tokenType: "Integer", value: "2"},
}

// 入力されるトークン列
var output = []struct {
	tokenType string
	value     string
}{
	{tokenType: "Integer", value: "1"},
	{tokenType: "Opetator", value: "+"},
	{tokenType: "Integer", value: "2"},
}

// 構文木を表現する構造体
type Tree struct {
	treeType string
	value    int
	children []Tree
}

var one = Tree{treeType: "integer", value: 1} // "1"を表現する構文木
var two = Tree{treeType: "integer", value: 2} // "2"を表現する構文木

// 出力される構文木("1+2"を表現する)
var output = Tree{treeType: "add", children: []Tree{one, two}} 

// 入力されるトークン列
var input2 = []struct {
	tokenType string
	value     string
}{
	{tokenType: "Integer", value: "1"},
	{tokenType: "Opetator", value: "+"},
	{tokenType: "Brace", value: "("},
	{tokenType: "Integer", value: "2"},
	{tokenType: "Opetator", value: "+"},
	{tokenType: "Integer", value: "3"},
	{tokenType: "Brace", value: ")"},
}

var one = Tree{treeType: "integer", value: 1} // "1"を表現する構文木
var two = Tree{treeType: "integer", value: 2} // "2"を表現する構文木
var three = Tree{treeType: "integer", value: 3} // "3"を表現する構文木

// "2+3"を表現する構文木
var onePlusTwo = Tree{treeType: "add", children: []Tree{two, three}}

// 出力される構文木("1+(2+3)"を表現)
var output = Tree{treeType: "add", children: []Tree{one, onePlusTwo}}