unexport ast

5 files changed, 120 insertions, 120 deletions

diff --git a/ast.go b/ast.go
index 19b4a31..f30668a 100644
--- a/ast.go
+++ b/ast.go
@@ -20,29 +20,29 @@ import (
 	"strings"
 )
 
-type AST interface {
+type ast interface {
 	eval(*Evaluator)
 	show()
 }
 
-type ASTBase struct {
+type astBase struct {
 	filename string
 	lineno   int
 }
 
-type AssignAST struct {
-	ASTBase
+type assignAST struct {
+	astBase
 	lhs Value
 	rhs Value
 	op  string
 	opt string // "override", "export"
 }
 
-func (ast *AssignAST) eval(ev *Evaluator) {
+func (ast *assignAST) eval(ev *Evaluator) {
 	ev.evalAssign(ast)
 }
 
-func (ast *AssignAST) evalRHS(ev *Evaluator, lhs string) Var {
+func (ast *assignAST) evalRHS(ev *Evaluator, lhs string) Var {
 	origin := "file"
 	if ast.filename == bootstrapMakefileName {
 		origin = "default"
@@ -82,84 +82,84 @@ func (ast *AssignAST) evalRHS(ev *Evaluator, lhs string) Var {
 	}
 }
 
-func (ast *AssignAST) show() {
+func (ast *assignAST) show() {
 	Logf("%s %s %s %q", ast.opt, ast.lhs, ast.op, ast.rhs)
 }
 
-// MaybeRuleAST is an ast for rule line.
+// maybeRuleAST is an ast for rule line.
 // Note we cannot be sure what this is, until all variables in |expr|
 // are expanded.
-type MaybeRuleAST struct {
-	ASTBase
+type maybeRuleAST struct {
+	astBase
 	expr      Value
 	term      byte // Either ':', '=', or 0
 	afterTerm []byte
 }
 
-func (ast *MaybeRuleAST) eval(ev *Evaluator) {
+func (ast *maybeRuleAST) eval(ev *Evaluator) {
 	ev.evalMaybeRule(ast)
 }
 
-func (ast *MaybeRuleAST) show() {
+func (ast *maybeRuleAST) show() {
 	Logf("%s", ast.expr)
 }
 
-type CommandAST struct {
-	ASTBase
+type commandAST struct {
+	astBase
 	cmd string
 }
 
-func (ast *CommandAST) eval(ev *Evaluator) {
+func (ast *commandAST) eval(ev *Evaluator) {
 	ev.evalCommand(ast)
 }
 
-func (ast *CommandAST) show() {
+func (ast *commandAST) show() {
 	Logf("\t%s", strings.Replace(ast.cmd, "\n", `\n`, -1))
 }
 
-type IncludeAST struct {
-	ASTBase
+type includeAST struct {
+	astBase
 	expr string
 	op   string
 }
 
-func (ast *IncludeAST) eval(ev *Evaluator) {
+func (ast *includeAST) eval(ev *Evaluator) {
 	ev.evalInclude(ast)
 }
 
-func (ast *IncludeAST) show() {
+func (ast *includeAST) show() {
 	Logf("include %s", ast.expr)
 }
 
-type IfAST struct {
-	ASTBase
+type ifAST struct {
+	astBase
 	op         string
 	lhs        Value
 	rhs        Value // Empty if |op| is ifdef or ifndef.
-	trueStmts  []AST
-	falseStmts []AST
+	trueStmts  []ast
+	falseStmts []ast
 }
 
-func (ast *IfAST) eval(ev *Evaluator) {
+func (ast *ifAST) eval(ev *Evaluator) {
 	ev.evalIf(ast)
 }
 
-func (ast *IfAST) show() {
+func (ast *ifAST) show() {
 	// TODO
 	Logf("if")
 }
 
-type ExportAST struct {
-	ASTBase
+type exportAST struct {
+	astBase
 	expr   []byte
 	export bool
 }
 
-func (ast *ExportAST) eval(ev *Evaluator) {
+func (ast *exportAST) eval(ev *Evaluator) {
 	ev.evalExport(ast)
 }
 
-func (ast *ExportAST) show() {
+func (ast *exportAST) show() {
 	// TODO
 	Logf("export")
 }
diff --git a/eval.go b/eval.go
index 8d388c6..a662f6b 100644
--- a/eval.go
+++ b/eval.go
@@ -89,7 +89,7 @@ func (ev *Evaluator) args(buf *buffer, args ...Value) [][]byte {
 	return buf.args
 }
 
-func (ev *Evaluator) evalAssign(ast *AssignAST) {
+func (ev *Evaluator) evalAssign(ast *assignAST) {
 	ev.lastRule = nil
 	lhs, rhs := ev.evalAssignAST(ast)
 	if LogFlag {
@@ -101,7 +101,7 @@ func (ev *Evaluator) evalAssign(ast *AssignAST) {
 	ev.outVars.Assign(lhs, rhs)
 }
 
-func (ev *Evaluator) evalAssignAST(ast *AssignAST) (string, Var) {
+func (ev *Evaluator) evalAssignAST(ast *assignAST) (string, Var) {
 	ev.filename = ast.filename
 	ev.lineno = ast.lineno
 
@@ -121,7 +121,7 @@ func (ev *Evaluator) evalAssignAST(ast *AssignAST) (string, Var) {
 	return lhs, rhs
 }
 
-func (ev *Evaluator) setTargetSpecificVar(assign *AssignAST, output string) {
+func (ev *Evaluator) setTargetSpecificVar(assign *assignAST, output string) {
 	vars, present := ev.outRuleVars[output]
 	if !present {
 		vars = make(Vars)
@@ -136,7 +136,7 @@ func (ev *Evaluator) setTargetSpecificVar(assign *AssignAST, output string) {
 	ev.currentScope = nil
 }
 
-func (ev *Evaluator) evalMaybeRule(ast *MaybeRuleAST) {
+func (ev *Evaluator) evalMaybeRule(ast *maybeRuleAST) {
 	ev.lastRule = nil
 	ev.filename = ast.filename
 	ev.lineno = ast.lineno
@@ -209,7 +209,7 @@ func (ev *Evaluator) evalMaybeRule(ast *MaybeRuleAST) {
 	ev.outRules = append(ev.outRules, rule)
 }
 
-func (ev *Evaluator) evalCommand(ast *CommandAST) {
+func (ev *Evaluator) evalCommand(ast *commandAST) {
 	ev.filename = ast.filename
 	ev.lineno = ast.lineno
 	if ev.lastRule == nil {
@@ -221,7 +221,7 @@ func (ev *Evaluator) evalCommand(ast *CommandAST) {
 			if err != nil {
 				panic(err)
 			}
-			if len(mk.stmts) == 1 && mk.stmts[0].(*AssignAST) != nil {
+			if len(mk.stmts) == 1 && mk.stmts[0].(*assignAST) != nil {
 				ev.eval(mk.stmts[0])
 			}
 			return
@@ -321,7 +321,7 @@ func (ev *Evaluator) updateReadMakefile(fn string, hash [sha1.Size]byte, st File
 	}
 }
 
-func (ev *Evaluator) evalInclude(ast *IncludeAST) {
+func (ev *Evaluator) evalInclude(ast *includeAST) {
 	ev.lastRule = nil
 	ev.filename = ast.filename
 	ev.lineno = ast.lineno
@@ -370,11 +370,11 @@ func (ev *Evaluator) evalInclude(ast *IncludeAST) {
 	}
 }
 
-func (ev *Evaluator) evalIf(ast *IfAST) {
+func (ev *Evaluator) evalIf(iast *ifAST) {
 	var isTrue bool
-	switch ast.op {
+	switch iast.op {
 	case "ifdef", "ifndef":
-		expr := ast.lhs
+		expr := iast.lhs
 		buf := newBuf()
 		expr.Eval(buf, ev)
 		v := ev.LookupVar(buf.String())
@@ -383,38 +383,38 @@ func (ev *Evaluator) evalIf(ast *IfAST) {
 		value := buf.String()
 		val := buf.Len()
 		freeBuf(buf)
-		isTrue = (val > 0) == (ast.op == "ifdef")
+		isTrue = (val > 0) == (iast.op == "ifdef")
 		if LogFlag {
-			Logf("%s lhs=%q value=%q => %t", ast.op, ast.lhs, value, isTrue)
+			Logf("%s lhs=%q value=%q => %t", iast.op, iast.lhs, value, isTrue)
 		}
 	case "ifeq", "ifneq":
-		lexpr := ast.lhs
-		rexpr := ast.rhs
+		lexpr := iast.lhs
+		rexpr := iast.rhs
 		buf := newBuf()
 		params := ev.args(buf, lexpr, rexpr)
 		lhs := string(params[0])
 		rhs := string(params[1])
 		freeBuf(buf)
-		isTrue = (lhs == rhs) == (ast.op == "ifeq")
+		isTrue = (lhs == rhs) == (iast.op == "ifeq")
 		if LogFlag {
-			Logf("%s lhs=%q %q rhs=%q %q => %t", ast.op, ast.lhs, lhs, ast.rhs, rhs, isTrue)
+			Logf("%s lhs=%q %q rhs=%q %q => %t", iast.op, iast.lhs, lhs, iast.rhs, rhs, isTrue)
 		}
 	default:
-		panic(fmt.Sprintf("unknown if statement: %q", ast.op))
+		panic(fmt.Sprintf("unknown if statement: %q", iast.op))
 	}
 
-	var stmts []AST
+	var stmts []ast
 	if isTrue {
-		stmts = ast.trueStmts
+		stmts = iast.trueStmts
 	} else {
-		stmts = ast.falseStmts
+		stmts = iast.falseStmts
 	}
 	for _, stmt := range stmts {
 		ev.eval(stmt)
 	}
 }
 
-func (ev *Evaluator) evalExport(ast *ExportAST) {
+func (ev *Evaluator) evalExport(ast *exportAST) {
 	ev.lastRule = nil
 	ev.filename = ast.filename
 	ev.lineno = ast.lineno
@@ -430,8 +430,8 @@ func (ev *Evaluator) evalExport(ast *ExportAST) {
 	}
 }
 
-func (ev *Evaluator) eval(ast AST) {
-	ast.eval(ev)
+func (ev *Evaluator) eval(stmt ast) {
+	stmt.eval(ev)
 }
 
 func createReadMakefileArray(mp map[string]*ReadMakefile) []*ReadMakefile {
diff --git a/parser.go b/parser.go
index 4e7574d..9bcba52 100644
--- a/parser.go
+++ b/parser.go
@@ -34,11 +34,11 @@ import (
 
 type Makefile struct {
 	filename string
-	stmts    []AST
+	stmts    []ast
 }
 
 type ifState struct {
-	ast     *IfAST
+	ast     *ifAST
 	inElse  bool
 	numNest int
 }
@@ -52,7 +52,7 @@ type parser struct {
 	unBuf       []byte
 	hasUnBuf    bool
 	done        bool
-	outStmts    *[]AST
+	outStmts    *[]ast
 	ifStack     []ifState
 	inDef       []string
 	defOpt      string
@@ -68,8 +68,8 @@ func newParser(rd io.Reader, filename string) *parser {
 	return p
 }
 
-func (p *parser) addStatement(ast AST) {
-	*p.outStmts = append(*p.outStmts, ast)
+func (p *parser) addStatement(stmt ast) {
+	*p.outStmts = append(*p.outStmts, stmt)
 }
 
 func (p *parser) readLine() []byte {
@@ -172,7 +172,7 @@ func (p *parser) unreadLine(line []byte) {
 	p.hasUnBuf = true
 }
 
-func newAssignAST(p *parser, lhsBytes []byte, rhsBytes []byte, op string) *AssignAST {
+func newAssignAST(p *parser, lhsBytes []byte, rhsBytes []byte, op string) *assignAST {
 	lhs, _, err := parseExpr(lhsBytes, nil, true)
 	if err != nil {
 		panic(err)
@@ -185,7 +185,7 @@ func newAssignAST(p *parser, lhsBytes []byte, rhsBytes []byte, op string) *Assig
 	if p != nil {
 		opt = p.defOpt
 	}
-	return &AssignAST{
+	return &assignAST{
 		lhs: lhs,
 		rhs: rhs,
 		op:  op,
@@ -193,15 +193,15 @@ func newAssignAST(p *parser, lhsBytes []byte, rhsBytes []byte, op string) *Assig
 	}
 }
 
-func (p *parser) parseAssign(line []byte, sep, esep int) AST {
+func (p *parser) parseAssign(line []byte, sep, esep int) ast {
 	Logf("parseAssign %q op:%q", line, line[sep:esep])
-	ast := newAssignAST(p, bytes.TrimSpace(line[:sep]), trimLeftSpaceBytes(line[esep:]), string(line[sep:esep]))
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	return ast
+	aast := newAssignAST(p, bytes.TrimSpace(line[:sep]), trimLeftSpaceBytes(line[esep:]), string(line[sep:esep]))
+	aast.filename = p.mk.filename
+	aast.lineno = p.lineno
+	return aast
 }
 
-func (p *parser) parseMaybeRule(line []byte, equalIndex, semicolonIndex int) AST {
+func (p *parser) parseMaybeRule(line []byte, equalIndex, semicolonIndex int) ast {
 	if len(trimSpaceBytes(line)) == 0 {
 		return nil
 	}
@@ -233,42 +233,42 @@ func (p *parser) parseMaybeRule(line []byte, equalIndex, semicolonIndex int) AST
 		panic(fmt.Errorf("parse %s:%d %v", p.mk.filename, p.lineno, err))
 	}
 
-	ast := &MaybeRuleAST{
+	rast := &maybeRuleAST{
 		expr:      v,
 		term:      term,
 		afterTerm: afterTerm,
 	}
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	return ast
+	rast.filename = p.mk.filename
+	rast.lineno = p.lineno
+	return rast
 }
 
-func (p *parser) parseInclude(line string, oplen int) AST {
+func (p *parser) parseInclude(line string, oplen int) ast {
 	// TODO(ukai): parse expr here
-	ast := &IncludeAST{
+	iast := &includeAST{
 		expr: line[oplen+1:],
 		op:   line[:oplen],
 	}
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	return ast
+	iast.filename = p.mk.filename
+	iast.lineno = p.lineno
+	return iast
 }
 
-func (p *parser) parseIfdef(line []byte, oplen int) AST {
+func (p *parser) parseIfdef(line []byte, oplen int) ast {
 	lhs, _, err := parseExpr(trimLeftSpaceBytes(line[oplen+1:]), nil, true)
 	if err != nil {
 		panic(fmt.Errorf("ifdef parse %s:%d %v", p.mk.filename, p.lineno, err))
 	}
-	ast := &IfAST{
+	iast := &ifAST{
 		op:  string(line[:oplen]),
 		lhs: lhs,
 	}
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	p.addStatement(ast)
-	p.ifStack = append(p.ifStack, ifState{ast: ast, numNest: p.numIfNest})
-	p.outStmts = &ast.trueStmts
-	return ast
+	iast.filename = p.mk.filename
+	iast.lineno = p.lineno
+	p.addStatement(iast)
+	p.ifStack = append(p.ifStack, ifState{ast: iast, numNest: p.numIfNest})
+	p.outStmts = &iast.trueStmts
+	return iast
 }
 
 func (p *parser) parseTwoQuotes(s string, op string) ([]string, bool) {
@@ -324,7 +324,7 @@ func (p *parser) parseEq(s string, op string) (string, string, bool) {
 	return args[0], args[1], true
 }
 
-func (p *parser) parseIfeq(line string, oplen int) AST {
+func (p *parser) parseIfeq(line string, oplen int) ast {
 	op := line[:oplen]
 	lhsBytes, rhsBytes, ok := p.parseEq(strings.TrimSpace(line[oplen+1:]), op)
 	if !ok {
@@ -340,17 +340,17 @@ func (p *parser) parseIfeq(line string, oplen int) AST {
 		panic(fmt.Errorf("parse ifeq rhs %s:%d %v", p.mk.filename, p.lineno, err))
 	}
 
-	ast := &IfAST{
+	iast := &ifAST{
 		op:  op,
 		lhs: lhs,
 		rhs: rhs,
 	}
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	p.addStatement(ast)
-	p.ifStack = append(p.ifStack, ifState{ast: ast, numNest: p.numIfNest})
-	p.outStmts = &ast.trueStmts
-	return ast
+	iast.filename = p.mk.filename
+	iast.lineno = p.lineno
+	p.addStatement(iast)
+	p.ifStack = append(p.ifStack, ifState{ast: iast, numNest: p.numIfNest})
+	p.outStmts = &iast.trueStmts
+	return iast
 }
 
 func (p *parser) checkIfStack(curKeyword string) {
@@ -519,13 +519,13 @@ func handleExport(p *parser, line []byte, export bool) (hasEqual bool) {
 		line = line[:equalIndex]
 	}
 
-	ast := &ExportAST{
+	east := &exportAST{
 		expr:   line,
 		export: export,
 	}
-	ast.filename = p.mk.filename
-	ast.lineno = p.lineno
-	p.addStatement(ast)
+	east.filename = p.mk.filename
+	east.lineno = p.lineno
+	p.addStatement(east)
 	return hasEqual
 }
 
@@ -582,10 +582,10 @@ func (p *parser) parse() (mk Makefile, err error) {
 			lineStr := string(p.processDefineLine(line))
 			if p.isEndef(lineStr) {
 				Logf("multilineAssign %q", p.inDef)
-				ast := newAssignAST(p, []byte(p.inDef[0]), []byte(strings.Join(p.inDef[1:], "\n")), "=")
-				ast.filename = p.mk.filename
-				ast.lineno = p.lineno - len(p.inDef)
-				p.addStatement(ast)
+				aast := newAssignAST(p, []byte(p.inDef[0]), []byte(strings.Join(p.inDef[1:], "\n")), "=")
+				aast.filename = p.mk.filename
+				aast.lineno = p.lineno - len(p.inDef)
+				p.addStatement(aast)
 				p.inDef = nil
 				p.defOpt = ""
 				continue
@@ -607,16 +607,16 @@ func (p *parser) parse() (mk Makefile, err error) {
 			}
 		}
 		if line[0] == '\t' {
-			ast := &CommandAST{cmd: string(p.processRecipeLine(line[1:]))}
-			ast.filename = p.mk.filename
-			ast.lineno = p.lineno
-			p.addStatement(ast)
+			cast := &commandAST{cmd: string(p.processRecipeLine(line[1:]))}
+			cast.filename = p.mk.filename
+			cast.lineno = p.lineno
+			p.addStatement(cast)
 			continue
 		}
 
 		line = p.processMakefileLine(line)
 
-		var ast AST
+		var stmt ast
 		var parenStack []byte
 		equalIndex := -1
 		semicolonIndex := -1
@@ -643,7 +643,7 @@ func (p *parser) parse() (mk Makefile, err error) {
 			case ':':
 				if i+1 < len(line) && line[i+1] == '=' {
 					if !isRule {
-						ast = p.parseAssign(line, i, i+2)
+						stmt = p.parseAssign(line, i, i+2)
 					}
 				} else {
 					isRule = true
@@ -654,25 +654,25 @@ func (p *parser) parse() (mk Makefile, err error) {
 				}
 			case '=':
 				if !isRule {
-					ast = p.parseAssign(line, i, i+1)
+					stmt = p.parseAssign(line, i, i+1)
 				}
 				if equalIndex < 0 {
 					equalIndex = i
 				}
 			case '?', '+':
 				if !isRule && i+1 < len(line) && line[i+1] == '=' {
-					ast = p.parseAssign(line, i, i+2)
+					stmt = p.parseAssign(line, i, i+2)
 				}
 			}
-			if ast != nil {
-				p.addStatement(ast)
+			if stmt != nil {
+				p.addStatement(stmt)
 				break
 			}
 		}
-		if ast == nil {
-			ast = p.parseMaybeRule(line, equalIndex, semicolonIndex)
-			if ast != nil {
-				p.addStatement(ast)
+		if stmt == nil {
+			stmt = p.parseMaybeRule(line, equalIndex, semicolonIndex)
+			if stmt != nil {
+				p.addStatement(stmt)
 			}
 		}
 	}
diff --git a/rule_parser.go b/rule_parser.go
index ccc207d..98914fe 100644
--- a/rule_parser.go
+++ b/rule_parser.go
@@ -93,7 +93,7 @@ func (r *Rule) parseInputs(s []byte) {
 	}
 }
 
-func (r *Rule) parseVar(s []byte) *AssignAST {
+func (r *Rule) parseVar(s []byte) *assignAST {
 	eq := bytes.IndexByte(s, '=')
 	if eq <= 0 {
 		return nil
@@ -122,7 +122,7 @@ func (r *Rule) parseVar(s []byte) *AssignAST {
 	return assign
 }
 
-func (r *Rule) parse(line []byte) (*AssignAST, error) {
+func (r *Rule) parse(line []byte) (*assignAST, error) {
 	index := bytes.IndexByte(line, ':')
 	if index < 0 {
 		return nil, errors.New("*** missing separator.")
diff --git a/rule_parser_test.go b/rule_parser_test.go
index b1db3ec..41b70c8 100644
--- a/rule_parser_test.go
+++ b/rule_parser_test.go
@@ -23,7 +23,7 @@ func TestRuleParser(t *testing.T) {
 	for _, tc := range []struct {
 		in     string
 		want   Rule
-		assign *AssignAST
+		assign *assignAST
 		err    string
 	}{
 		{
@@ -100,7 +100,7 @@ func TestRuleParser(t *testing.T) {
 			want: Rule{
 				outputs: []string{"foo"},
 			},
-			assign: &AssignAST{
+			assign: &assignAST{
 				lhs: literal("CFLAGS"),
 				rhs: literal("-g"),
 				op:  "=",
@@ -111,7 +111,7 @@ func TestRuleParser(t *testing.T) {
 			want: Rule{
 				outputs: []string{"foo"},
 			},
-			assign: &AssignAST{
+			assign: &assignAST{
 				lhs: literal("CFLAGS"),
 				rhs: literal("-g"),
 				op:  "=",
@@ -122,7 +122,7 @@ func TestRuleParser(t *testing.T) {
 			want: Rule{
 				outputs: []string{"foo"},
 			},
-			assign: &AssignAST{
+			assign: &assignAST{
 				lhs: literal("CFLAGS"),
 				rhs: literal("-g"),
 				op:  ":=",
@@ -133,7 +133,7 @@ func TestRuleParser(t *testing.T) {
 			want: Rule{
 				outputPatterns: []pattern{pattern{suffix: ".o"}},
 			},
-			assign: &AssignAST{
+			assign: &assignAST{
 				lhs: literal("CFLAGS"),
 				rhs: literal("-g"),
 				op:  ":=",