unexport Func and Expr

8 files changed, 125 insertions, 129 deletions

diff --git a/eval.go b/eval.go
index 2b83b92..15e4f4e 100644
--- a/eval.go
+++ b/eval.go
@@ -238,7 +238,7 @@ func (ev *Evaluator) evalMaybeRule(ast *maybeRuleAST) {
 			if err != nil {
 				panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err))
 			}
-			lexpr = Expr{lexpr, nexpr}
+			lexpr = expr{lexpr, nexpr}
 
 			buf = newBuf()
 			lexpr.Eval(buf, ev)
diff --git a/expr.go b/expr.go
index 599a241..df81be3 100644
--- a/expr.go
+++ b/expr.go
@@ -60,10 +60,6 @@ type Value interface {
 	dump(w io.Writer)
 }
 
-type Valuer interface {
-	Value() []byte
-}
-
 // literal is literal value.
 type literal string
 
@@ -95,10 +91,10 @@ func (t tmpval) dump(w io.Writer) {
 	dumpBytes(w, t)
 }
 
-// Expr is a list of values.
-type Expr []Value
+// expr is a list of values.
+type expr []Value
 
-func (e Expr) String() string {
+func (e expr) String() string {
 	var s []string
 	for _, v := range e {
 		s = append(s, v.String())
@@ -106,20 +102,20 @@ func (e Expr) String() string {
 	return strings.Join(s, "")
 }
 
-func (e Expr) Eval(w io.Writer, ev *Evaluator) {
+func (e expr) Eval(w io.Writer, ev *Evaluator) {
 	for _, v := range e {
 		v.Eval(w, ev)
 	}
 }
 
-func (e Expr) serialize() serializableVar {
+func (e expr) serialize() serializableVar {
 	r := serializableVar{Type: "expr"}
 	for _, v := range e {
 		r.Children = append(r.Children, v.serialize())
 	}
 	return r
 }
-func (e Expr) dump(w io.Writer) {
+func (e expr) dump(w io.Writer) {
 	dumpByte(w, valueTypeExpr)
 	dumpInt(w, len(e))
 	for _, v := range e {
@@ -127,7 +123,7 @@ func (e Expr) dump(w io.Writer) {
 	}
 }
 
-func compactExpr(e Expr) Value {
+func compactExpr(e expr) Value {
 	if len(e) == 1 {
 		return e[0]
 	}
@@ -256,24 +252,24 @@ func str(buf []byte, alloc bool) Value {
 	return tmpval(buf)
 }
 
-func appendStr(expr Expr, buf []byte, alloc bool) Expr {
+func appendStr(exp expr, buf []byte, alloc bool) expr {
 	if len(buf) == 0 {
-		return expr
+		return exp
 	}
-	if len(expr) == 0 {
-		return append(expr, str(buf, alloc))
+	if len(exp) == 0 {
+		return append(exp, str(buf, alloc))
 	}
-	switch v := expr[len(expr)-1].(type) {
+	switch v := exp[len(exp)-1].(type) {
 	case literal:
 		v += literal(string(buf))
-		expr[len(expr)-1] = v
-		return expr
+		exp[len(exp)-1] = v
+		return exp
 	case tmpval:
 		v = append(v, buf...)
-		expr[len(expr)-1] = v
-		return expr
+		exp[len(exp)-1] = v
+		return exp
 	}
-	return append(expr, str(buf, alloc))
+	return append(exp, str(buf, alloc))
 }
 
 func valueNum(v Value) (int, error) {
@@ -293,7 +289,7 @@ func valueNum(v Value) (int, error) {
 // if alloc is true, text will be literal (allocate string).
 // otherwise, text will be tmpval on in.
 func parseExpr(in, term []byte, alloc bool) (Value, int, error) {
-	var expr Expr
+	var exp expr
 	b := 0
 	i := 0
 	var saveParen byte
@@ -310,26 +306,26 @@ Loop:
 				break Loop
 			}
 			if in[i+1] == '$' {
-				expr = appendStr(expr, in[b:i+1], alloc)
+				exp = appendStr(exp, in[b:i+1], alloc)
 				i += 2
 				b = i
 				continue
 			}
 			if bytes.IndexByte(term, in[i+1]) >= 0 {
-				expr = appendStr(expr, in[b:i], alloc)
-				expr = append(expr, &varref{varname: literal("")})
+				exp = appendStr(exp, in[b:i], alloc)
+				exp = append(exp, &varref{varname: literal("")})
 				i++
 				b = i
 				break Loop
 			}
-			expr = appendStr(expr, in[b:i], alloc)
+			exp = appendStr(exp, in[b:i], alloc)
 			v, n, err := parseDollar(in[i:], alloc)
 			if err != nil {
 				return nil, 0, err
 			}
 			i += n
 			b = i
-			expr = append(expr, v)
+			exp = append(exp, v)
 			continue
 		case '(', '{':
 			cp := closeParen(ch)
@@ -350,11 +346,11 @@ Loop:
 		}
 		i++
 	}
-	expr = appendStr(expr, in[b:i], alloc)
+	exp = appendStr(exp, in[b:i], alloc)
 	if i == len(in) && term != nil {
-		return expr, i, errEndOfInput
+		return exp, i, errEndOfInput
 	}
-	return compactExpr(expr), i, nil
+	return compactExpr(exp), i, nil
 }
 
 func closeParen(ch byte) byte {
@@ -392,7 +388,7 @@ func parseDollar(in []byte, alloc bool) (Value, int, error) {
 		return &varref{varname: str(in[1:2], alloc)}, 2, nil
 	}
 	term := []byte{paren, ':', ' '}
-	var varname Expr
+	var varname expr
 	i := 2
 Again:
 	for {
@@ -483,7 +479,7 @@ func trimLiteralSpace(v Value) Value {
 			return literal("")
 		}
 		return tmpval(b)
-	case Expr:
+	case expr:
 		if len(v) == 0 {
 			return v
 		}
@@ -535,7 +531,7 @@ func concatLine(v Value) Value {
 			buf.Write(bytes.TrimLeft(b[i+2:], " \t"))
 			v = tmpval(buf.Bytes())
 		}
-	case Expr:
+	case expr:
 		for i := range v {
 			switch vv := v[i].(type) {
 			case literal, tmpval:
@@ -550,7 +546,7 @@ func concatLine(v Value) Value {
 // parseFunc parses function arguments from in[s:] for f.
 // in[0] is '$' and in[s] is space just after func name.
 // in[:n] will be "${func args...}"
-func parseFunc(f Func, in []byte, s int, term []byte, funcName string, alloc bool) (Value, int, error) {
+func parseFunc(f mkFunc, in []byte, s int, term []byte, funcName string, alloc bool) (Value, int, error) {
 	f.AddArg(str(in[1:s-1], alloc))
 	arity := f.Arity()
 	term = append(term, ',')
@@ -588,7 +584,7 @@ func parseFunc(f Func, in []byte, s int, term []byte, funcName string, alloc boo
 	}
 	var fv Value
 	fv = f
-	if compactor, ok := f.(Compactor); ok {
+	if compactor, ok := f.(compactor); ok {
 		fv = compactor.Compact()
 	}
 	if EvalStatsFlag || traceEvent.enabled() {
@@ -601,7 +597,7 @@ func parseFunc(f Func, in []byte, s int, term []byte, funcName string, alloc boo
 	return fv, i, nil
 }
 
-type Compactor interface {
+type compactor interface {
 	Compact() Value
 }
 
@@ -639,33 +635,33 @@ func (r literalRE) Eval(w io.Writer, ev *Evaluator) { panic("not implemented") }
 func (r literalRE) serialize() serializableVar      { panic("not implemented") }
 func (r literalRE) dump(w io.Writer)                { panic("not implemented") }
 
-func matchValue(expr, pat Value) bool {
+func matchValue(exp, pat Value) bool {
 	switch pat := pat.(type) {
 	case literal:
-		return literal(expr.String()) == pat
+		return literal(exp.String()) == pat
 	}
 	// TODO: other type match?
 	return false
 }
 
-func matchExpr(expr, pat Expr) ([]Value, bool) {
-	if len(expr) != len(pat) {
+func matchExpr(exp, pat expr) ([]Value, bool) {
+	if len(exp) != len(pat) {
 		return nil, false
 	}
 	var mv matchVarref
 	var matches []Value
-	for i := range expr {
+	for i := range exp {
 		if pat[i] == mv {
-			switch expr[i].(type) {
+			switch exp[i].(type) {
 			case paramref, *varref:
-				matches = append(matches, expr[i])
+				matches = append(matches, exp[i])
 				continue
 			}
 			return nil, false
 		}
 		if patre, ok := pat[i].(literalRE); ok {
 			re := patre.Regexp
-			m := re.FindStringSubmatch(expr[i].String())
+			m := re.FindStringSubmatch(exp[i].String())
 			if m == nil {
 				return nil, false
 			}
@@ -674,7 +670,7 @@ func matchExpr(expr, pat Expr) ([]Value, bool) {
 			}
 			continue
 		}
-		if !matchValue(expr[i], pat[i]) {
+		if !matchValue(exp[i], pat[i]) {
 			return nil, false
 		}
 	}
diff --git a/expr_test.go b/expr_test.go
index a7f2fe3..75bc3d1 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -47,7 +47,7 @@ func TestParseExpr(t *testing.T) {
 		},
 		{
 			in:  "$foo",
-			val: Expr{&varref{varname: literal("f")}, literal("oo")},
+			val: expr{&varref{varname: literal("f")}, literal("oo")},
 		},
 		{
 			in:  "$(foo)",
@@ -63,7 +63,7 @@ func TestParseExpr(t *testing.T) {
 		},
 		{
 			in: "$(subst $(space),$(,),$(foo))/bar",
-			val: Expr{
+			val: expr{
 				&funcSubst{
 					fclosure: fclosure{
 						args: []Value{
@@ -95,7 +95,7 @@ func TestParseExpr(t *testing.T) {
 						&varref{
 							varname: literal(""),
 						},
-						Expr{
+						expr{
 							literal(","),
 							&varref{
 								varname: literal("foo"),
@@ -129,7 +129,7 @@ func TestParseExpr(t *testing.T) {
 		},
 		{
 			in: `$(shell echo ')')`,
-			val: Expr{
+			val: expr{
 				&funcShell{
 					fclosure: fclosure{
 						args: []Value{
@@ -154,7 +154,7 @@ func TestParseExpr(t *testing.T) {
 		},
 		{
 			in: `${shell echo '}'}`,
-			val: Expr{
+			val: expr{
 				&funcShell{
 					fclosure: fclosure{
 						args: []Value{
diff --git a/func.go b/func.go
index 6266a77..121cfa6 100644
--- a/func.go
+++ b/func.go
@@ -27,11 +27,11 @@ import (
 	"time"
 )
 
-// Func is a make function.
+// mkFunc is a make function.
 // http://www.gnu.org/software/make/manual/make.html#Functions
 
-// Func is make builtin function.
-type Func interface {
+// mkFunc is make builtin function.
+type mkFunc interface {
 	// Arity is max function's arity.
 	// ',' will not be handled as argument separator more than arity.
 	// 0 means varargs.
@@ -45,48 +45,48 @@ type Func interface {
 }
 
 var (
-	funcMap = map[string]func() Func{
-		"patsubst":   func() Func { return &funcPatsubst{} },
-		"strip":      func() Func { return &funcStrip{} },
-		"subst":      func() Func { return &funcSubst{} },
-		"findstring": func() Func { return &funcFindstring{} },
-		"filter":     func() Func { return &funcFilter{} },
-		"filter-out": func() Func { return &funcFilterOut{} },
-		"sort":       func() Func { return &funcSort{} },
-		"word":       func() Func { return &funcWord{} },
-		"wordlist":   func() Func { return &funcWordlist{} },
-		"words":      func() Func { return &funcWords{} },
-		"firstword":  func() Func { return &funcFirstword{} },
-		"lastword":   func() Func { return &funcLastword{} },
-
-		"join":      func() Func { return &funcJoin{} },
-		"wildcard":  func() Func { return &funcWildcard{} },
-		"dir":       func() Func { return &funcDir{} },
-		"notdir":    func() Func { return &funcNotdir{} },
-		"suffix":    func() Func { return &funcSuffix{} },
-		"basename":  func() Func { return &funcBasename{} },
-		"addsuffix": func() Func { return &funcAddsuffix{} },
-		"addprefix": func() Func { return &funcAddprefix{} },
-		"realpath":  func() Func { return &funcRealpath{} },
-		"abspath":   func() Func { return &funcAbspath{} },
-
-		"if":  func() Func { return &funcIf{} },
-		"and": func() Func { return &funcAnd{} },
-		"or":  func() Func { return &funcOr{} },
-
-		"value": func() Func { return &funcValue{} },
-
-		"eval": func() Func { return &funcEval{} },
-
-		"shell":   func() Func { return &funcShell{} },
-		"call":    func() Func { return &funcCall{} },
-		"foreach": func() Func { return &funcForeach{} },
-
-		"origin":  func() Func { return &funcOrigin{} },
-		"flavor":  func() Func { return &funcFlavor{} },
-		"info":    func() Func { return &funcInfo{} },
-		"warning": func() Func { return &funcWarning{} },
-		"error":   func() Func { return &funcError{} },
+	funcMap = map[string]func() mkFunc{
+		"patsubst":   func() mkFunc { return &funcPatsubst{} },
+		"strip":      func() mkFunc { return &funcStrip{} },
+		"subst":      func() mkFunc { return &funcSubst{} },
+		"findstring": func() mkFunc { return &funcFindstring{} },
+		"filter":     func() mkFunc { return &funcFilter{} },
+		"filter-out": func() mkFunc { return &funcFilterOut{} },
+		"sort":       func() mkFunc { return &funcSort{} },
+		"word":       func() mkFunc { return &funcWord{} },
+		"wordlist":   func() mkFunc { return &funcWordlist{} },
+		"words":      func() mkFunc { return &funcWords{} },
+		"firstword":  func() mkFunc { return &funcFirstword{} },
+		"lastword":   func() mkFunc { return &funcLastword{} },
+
+		"join":      func() mkFunc { return &funcJoin{} },
+		"wildcard":  func() mkFunc { return &funcWildcard{} },
+		"dir":       func() mkFunc { return &funcDir{} },
+		"notdir":    func() mkFunc { return &funcNotdir{} },
+		"suffix":    func() mkFunc { return &funcSuffix{} },
+		"basename":  func() mkFunc { return &funcBasename{} },
+		"addsuffix": func() mkFunc { return &funcAddsuffix{} },
+		"addprefix": func() mkFunc { return &funcAddprefix{} },
+		"realpath":  func() mkFunc { return &funcRealpath{} },
+		"abspath":   func() mkFunc { return &funcAbspath{} },
+
+		"if":  func() mkFunc { return &funcIf{} },
+		"and": func() mkFunc { return &funcAnd{} },
+		"or":  func() mkFunc { return &funcOr{} },
+
+		"value": func() mkFunc { return &funcValue{} },
+
+		"eval": func() mkFunc { return &funcEval{} },
+
+		"shell":   func() mkFunc { return &funcShell{} },
+		"call":    func() mkFunc { return &funcCall{} },
+		"foreach": func() mkFunc { return &funcForeach{} },
+
+		"origin":  func() mkFunc { return &funcOrigin{} },
+		"flavor":  func() mkFunc { return &funcFlavor{} },
+		"info":    func() mkFunc { return &funcInfo{} },
+		"warning": func() mkFunc { return &funcWarning{} },
+		"error":   func() mkFunc { return &funcError{} },
 	}
 )
 
@@ -800,22 +800,22 @@ func (f *funcShell) Compact() Value {
 		return f
 	}
 
-	var expr Expr
+	var exp expr
 	switch v := f.args[1].(type) {
-	case Expr:
-		expr = v
+	case expr:
+		exp = v
 	default:
-		expr = Expr{v}
+		exp = expr{v}
 	}
 	if UseShellBuiltins {
 		// hack for android
 		for _, sb := range shBuiltins {
-			if v, ok := matchExpr(expr, sb.pattern); ok {
-				Logf("shell compact apply %s for %s", sb.name, expr)
+			if v, ok := matchExpr(exp, sb.pattern); ok {
+				Logf("shell compact apply %s for %s", sb.name, exp)
 				return sb.compact(f, v)
 			}
 		}
-		Logf("shell compact no match: %s", expr)
+		Logf("shell compact no match: %s", exp)
 	}
 	return f
 }
@@ -903,7 +903,7 @@ func (f *funcEval) Compact() Value {
 	}
 	switch arg := f.args[1].(type) {
 	case literal, tmpval:
-	case Expr:
+	case expr:
 		if len(arg) == 1 {
 			return f
 		}
@@ -912,7 +912,7 @@ func (f *funcEval) Compact() Value {
 			lhs, op, rhsprefix, ok := parseAssignLiteral(prefix.String())
 			if ok {
 				// $(eval foo = $(bar))
-				var rhs Expr
+				var rhs expr
 				if rhsprefix != literal("") {
 					rhs = append(rhs, rhsprefix)
 				}
@@ -1016,12 +1016,12 @@ func (f *funcEvalAssign) Eval(w io.Writer, ev *Evaluator) {
 	case ":=":
 		// TODO(ukai): compute parsed expr in Compact when f.rhs is
 		// literal? e.g. literal("$(foo)") => varref{literal("foo")}.
-		expr, _, err := parseExpr(rhs, nil, false)
+		exp, _, err := parseExpr(rhs, nil, false)
 		if err != nil {
 			panic(fmt.Sprintf("eval assign error: %q: %v", f.String(), err))
 		}
 		vbuf := newBuf()
-		expr.Eval(vbuf, ev)
+		exp.Eval(vbuf, ev)
 		rvalue = &simpleVar{value: vbuf.String(), origin: "file"}
 		freeBuf(vbuf)
 	case "=":
diff --git a/serialize.go b/serialize.go
index 5b1fd34..9a18062 100644
--- a/serialize.go
+++ b/serialize.go
@@ -314,7 +314,7 @@ func deserializeVar(sv serializableVar) (r Value) {
 	case "tmpval":
 		return tmpval([]byte(sv.V))
 	case "expr":
-		var e Expr
+		var e expr
 		for _, v := range sv.Children {
 			e = append(e, deserializeVar(v))
 		}
diff --git a/shellutil.go b/shellutil.go
index 93a53df..71fd620 100644
--- a/shellutil.go
+++ b/shellutil.go
@@ -23,14 +23,14 @@ import (
 
 var shBuiltins = []struct {
 	name    string
-	pattern Expr
+	pattern expr
 	compact func(*funcShell, []Value) Value
 }{
 	{
 		name: "android:rot13",
 		// in repo/android/build/core/definisions.mk
 		// echo $(1) | tr 'a-zA-Z' 'n-za-mN-ZA-M'
-		pattern: Expr{
+		pattern: expr{
 			literal("echo "),
 			matchVarref{},
 			literal(" | tr 'a-zA-Z' 'n-za-mN-ZA-M'"),
@@ -46,7 +46,7 @@ var shBuiltins = []struct {
 		name: "android:find-subdir-assets",
 		// in repo/android/build/core/definitions.mk
 		// if [ -d $1 ] ; then cd $1 ; find ./ -not -name '.*' -and -type f -and -not -type l ; fi
-		pattern: Expr{
+		pattern: expr{
 			literal("if [ -d "),
 			matchVarref{},
 			literal(" ] ; then cd "),
@@ -68,7 +68,7 @@ var shBuiltins = []struct {
 		name: "android:all-java-files-under",
 		// in repo/android/build/core/definitions.mk
 		// cd ${LOCAL_PATH} ; find -L $1 -name "*.java" -and -not -name ".*"
-		pattern: Expr{
+		pattern: expr{
 			literal("cd "),
 			matchVarref{},
 			literal(" ; find -L "),
@@ -90,7 +90,7 @@ var shBuiltins = []struct {
 		// in repo/android/build/core/definitions.mk
 		// cd $(LOCAL_PATH) ; \
 		// find -L $(1) -name "*.proto" -and -not -name ".*"
-		pattern: Expr{
+		pattern: expr{
 			literal("cd "),
 			matchVarref{},
 			literal(" ; find -L "),
@@ -115,7 +115,7 @@ var shBuiltins = []struct {
 		// -a \! -name "package.html" -a \! -name "overview.html" \
 		// -a \! -name ".*.swp" -a \! -name ".DS_Store" \
 		// -a \! -name "*~" -print )
-		pattern: Expr{
+		pattern: expr{
 			literal("cd "),
 			matchVarref{},
 			matchVarref{},
@@ -127,7 +127,7 @@ var shBuiltins = []struct {
 			androidFindCache.init(nil)
 			return &funcShellAndroidFindJavaResourceFileGroup{
 				funcShell: sh,
-				dir:       Expr(v),
+				dir:       expr(v),
 			}
 		},
 	},
@@ -135,7 +135,7 @@ var shBuiltins = []struct {
 		name: "android:subdir_cleanspecs",
 		// in repo/android/build/core/cleanspec.mk
 		// build/tools/findleaves.py --prune=$(OUT_DIR) --prune=.repo --prune=.git . CleanSpec.mk)
-		pattern: Expr{
+		pattern: expr{
 			literal("build/tools/findleaves.py --prune="),
 			matchVarref{},
 			literal(" --prune=.repo --prune=.git . CleanSpec.mk"),
@@ -162,7 +162,7 @@ var shBuiltins = []struct {
 		name: "android:subdir_makefiles",
 		// in repo/android/build/core/main.mk
 		// build/tools/findleaves.py --prune=$(OUT_DIR) --prune=.repo --prune=.git $(subdirs) Android.mk
-		pattern: Expr{
+		pattern: expr{
 			literal("build/tools/findleaves.py --prune="),
 			matchVarref{},
 			literal(" --prune=.repo --prune=.git "),
@@ -192,7 +192,7 @@ var shBuiltins = []struct {
 		// in repo/android/build/core/definisions.mk
 		// build/tools/findleaves.py --prune=$(OUT_DIR) --prune=.repo --prune=.git \
 		// --mindepth=2 $(1) Android.mk
-		pattern: Expr{
+		pattern: expr{
 			literal("build/tools/findleaves.py --prune="),
 			matchVarref{},
 			literal(" --prune=.repo --prune=.git --mindepth=2 "),
@@ -219,14 +219,14 @@ var shBuiltins = []struct {
 	},
 	{
 		name: "shell-date",
-		pattern: Expr{
+		pattern: expr{
 			mustLiteralRE(`date \+(\S+)`),
 		},
 		compact: compactShellDate,
 	},
 	{
 		name: "shell-date-quoted",
-		pattern: Expr{
+		pattern: expr{
 			mustLiteralRE(`date "\+([^"]+)"`),
 		},
 		compact: compactShellDate,
diff --git a/shellutil_test.go b/shellutil_test.go
index e4c200d..39c2c64 100644
--- a/shellutil_test.go
+++ b/shellutil_test.go
@@ -69,7 +69,7 @@ func TestShellDate(t *testing.T) {
 			if b.name != "shell-date" && b.name != "shell-date-quoted" {
 				continue
 			}
-			m, ok := matchExpr(Expr{tc.sharg}, b.pattern)
+			m, ok := matchExpr(expr{tc.sharg}, b.pattern)
 			if !ok {
 				t.Logf("%s not match with %s", b.name, tc.sharg)
 				continue
diff --git a/var.go b/var.go
index f44a224..f952e6e 100644
--- a/var.go
+++ b/var.go
@@ -194,22 +194,22 @@ func (v *recursiveVar) dump(w io.Writer) {
 }
 
 func (v *recursiveVar) Append(_ *Evaluator, s string) Var {
-	var expr Expr
-	if e, ok := v.expr.(Expr); ok {
-		expr = append(e, literal(" "))
+	var exp expr
+	if e, ok := v.expr.(expr); ok {
+		exp = append(e, literal(" "))
 	} else {
-		expr = Expr{v.expr, literal(" ")}
+		exp = expr{v.expr, literal(" ")}
 	}
 	sv, _, err := parseExpr([]byte(s), nil, true)
 	if err != nil {
 		panic(err)
 	}
-	if aexpr, ok := sv.(Expr); ok {
-		expr = append(expr, aexpr...)
+	if aexpr, ok := sv.(expr); ok {
+		exp = append(exp, aexpr...)
 	} else {
-		expr = append(expr, sv)
+		exp = append(exp, sv)
 	}
-	v.expr = expr
+	v.expr = exp
 	return v
 }