Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 1 | package main |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
Fumitoshi Ukai | f8efa0a | 2015-03-30 18:10:11 +0900 | [diff] [blame] | 5 | "fmt" |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 6 | "strings" |
| 7 | ) |
| 8 | |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 9 | type EvalResult struct { |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 10 | vars Vars |
| 11 | rules []*Rule |
| 12 | ruleVars map[string]Vars |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 13 | } |
| 14 | |
| 15 | type Evaluator struct { |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 16 | paramVars []tmpval // $1 => paramVars[1] |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 17 | outVars Vars |
| 18 | outRules []*Rule |
| 19 | outRuleVars map[string]Vars |
| 20 | vars Vars |
| 21 | lastRule *Rule |
| 22 | currentScope Vars |
Shinichiro Hamaji | 51d53d9 | 2015-03-30 18:32:16 +0900 | [diff] [blame] | 23 | |
| 24 | filename string |
| 25 | lineno int |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 26 | } |
| 27 | |
Shinichiro Hamaji | cc919ae | 2015-04-09 17:23:30 +0900 | [diff] [blame] | 28 | func newEvaluator(vars map[string]Var) *Evaluator { |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 29 | return &Evaluator{ |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 30 | outVars: make(Vars), |
| 31 | vars: vars, |
| 32 | outRuleVars: make(map[string]Vars), |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 33 | } |
| 34 | } |
| 35 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 36 | func (ev *Evaluator) Value(v Value) []byte { |
Fumitoshi Ukai | 6ac7f69 | 2015-04-15 17:13:51 +0900 | [diff] [blame] | 37 | if v, ok := v.(Valuer); ok { |
| 38 | return v.Value() |
| 39 | } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 40 | var buf bytes.Buffer |
| 41 | v.Eval(&buf, ev) |
| 42 | return buf.Bytes() |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 43 | } |
| 44 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 45 | // TODO(ukai): use unicode.IsSpace? |
| 46 | func isWhitespace(b byte) bool { |
| 47 | switch b { |
| 48 | case ' ', '\t', '\n', '\r': |
| 49 | return true |
Shinichiro Hamaji | fce5a45 | 2015-04-09 17:02:23 +0900 | [diff] [blame] | 50 | } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 51 | return false |
| 52 | } |
Shinichiro Hamaji | fce5a45 | 2015-04-09 17:02:23 +0900 | [diff] [blame] | 53 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 54 | func (ev *Evaluator) Values(v Value) [][]byte { |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 55 | var buf bytes.Buffer |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 56 | v.Eval(&buf, ev) |
| 57 | val := buf.Bytes() |
| 58 | var values [][]byte |
| 59 | b := -1 |
| 60 | for i := 0; i < len(val); i++ { |
| 61 | if b < 0 { |
| 62 | if isWhitespace(val[i]) { |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 63 | continue |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 64 | } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 65 | b = i |
| 66 | } else { |
| 67 | if isWhitespace(val[i]) { |
| 68 | values = append(values, val[b:i]) |
| 69 | b = -1 |
| 70 | continue |
Fumitoshi Ukai | 0822c41 | 2015-04-05 22:51:18 +0900 | [diff] [blame] | 71 | } |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 72 | } |
| 73 | } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 74 | if b >= 0 { |
| 75 | values = append(values, val[b:]) |
| 76 | } |
| 77 | return values |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 78 | } |
| 79 | |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 80 | func (ev *Evaluator) evalAssign(ast *AssignAST) { |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 81 | ev.lastRule = nil |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 82 | lhs, rhs := ev.evalAssignAST(ast) |
| 83 | Log("ASSIGN: %s=%q (flavor:%q)", lhs, rhs, rhs.Flavor()) |
Shinichiro Hamaji | 46ee5cf | 2015-04-06 18:07:10 +0900 | [diff] [blame] | 84 | if len(lhs) == 0 { |
| 85 | Error(ast.filename, ast.lineno, "*** empty variable name.") |
| 86 | } |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 87 | ev.outVars.Assign(lhs, rhs) |
| 88 | } |
| 89 | |
| 90 | func (ev *Evaluator) evalAssignAST(ast *AssignAST) (string, Var) { |
Shinichiro Hamaji | 51d53d9 | 2015-03-30 18:32:16 +0900 | [diff] [blame] | 91 | ev.filename = ast.filename |
| 92 | ev.lineno = ast.lineno |
| 93 | |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 94 | v, _, err := parseExpr([]byte(ast.lhs), nil) |
| 95 | if err != nil { |
| 96 | panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err)) |
| 97 | } |
| 98 | var lhs string |
| 99 | switch v := v.(type) { |
| 100 | case literal: |
| 101 | lhs = string(v) |
| 102 | case tmpval: |
| 103 | lhs = string(v) |
| 104 | default: |
| 105 | lhs = string(bytes.TrimSpace(ev.Value(v))) |
| 106 | } |
Shinichiro Hamaji | 69b7f65 | 2015-03-31 01:01:59 +0900 | [diff] [blame] | 107 | rhs := ast.evalRHS(ev, lhs) |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 108 | return lhs, rhs |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 109 | } |
| 110 | |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 111 | func (ev *Evaluator) setTargetSpecificVar(assign *AssignAST, output string) { |
| 112 | vars, present := ev.outRuleVars[output] |
| 113 | if !present { |
| 114 | vars = make(Vars) |
| 115 | ev.outRuleVars[output] = vars |
| 116 | } |
| 117 | ev.currentScope = vars |
| 118 | lhs, rhs := ev.evalAssignAST(assign) |
| 119 | Log("rule outputs:%q assign:%q=%q (flavor:%q)", output, lhs, rhs, rhs.Flavor()) |
| 120 | vars.Assign(lhs, TargetSpecificVar{v: rhs, op: assign.op}) |
| 121 | ev.currentScope = nil |
| 122 | } |
| 123 | |
Shinichiro Hamaji | de82971 | 2015-03-31 18:26:56 +0900 | [diff] [blame] | 124 | func (ev *Evaluator) evalMaybeRule(ast *MaybeRuleAST) { |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 125 | ev.lastRule = nil |
Shinichiro Hamaji | 51d53d9 | 2015-03-30 18:32:16 +0900 | [diff] [blame] | 126 | ev.filename = ast.filename |
| 127 | ev.lineno = ast.lineno |
| 128 | |
Shinichiro Hamaji | 486e9de | 2015-04-09 15:20:32 +0900 | [diff] [blame] | 129 | expr := ast.expr |
| 130 | if ast.semicolonIndex >= 0 { |
| 131 | expr = expr[0:ast.semicolonIndex] |
| 132 | } |
Shinichiro Hamaji | e12e24d | 2015-04-11 23:09:20 +0900 | [diff] [blame] | 133 | if ast.equalIndex >= 0 { |
| 134 | expr = expr[0:ast.equalIndex] |
| 135 | } |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 136 | lexpr, _, err := parseExpr([]byte(expr), nil) |
| 137 | if err != nil { |
| 138 | panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err)) |
| 139 | } |
| 140 | line := ev.Value(lexpr) |
Shinichiro Hamaji | e12e24d | 2015-04-11 23:09:20 +0900 | [diff] [blame] | 141 | if ast.equalIndex >= 0 { |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 142 | line = append(line, []byte(ast.expr[ast.equalIndex:])...) |
Shinichiro Hamaji | e12e24d | 2015-04-11 23:09:20 +0900 | [diff] [blame] | 143 | } |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 144 | Log("rule? %q=>%q", ast.expr, line) |
Shinichiro Hamaji | 0493261 | 2015-03-31 23:46:56 +0900 | [diff] [blame] | 145 | |
Shinichiro Hamaji | 3fab47e | 2015-04-08 18:34:41 +0900 | [diff] [blame] | 146 | // See semicolon.mk. |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 147 | if len(bytes.TrimRight(line, " \t\n;")) == 0 { |
Shinichiro Hamaji | de82971 | 2015-03-31 18:26:56 +0900 | [diff] [blame] | 148 | return |
| 149 | } |
| 150 | |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 151 | rule := &Rule{ |
Shinichiro Hamaji | 3fab47e | 2015-04-08 18:34:41 +0900 | [diff] [blame] | 152 | filename: ast.filename, |
| 153 | lineno: ast.lineno, |
Shinichiro Hamaji | 7c4e325 | 2015-03-30 23:04:25 +0900 | [diff] [blame] | 154 | } |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 155 | assign, err := rule.parse(string(line)) // use []byte? |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 156 | if err != nil { |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 157 | Error(ast.filename, ast.lineno, "%v", err.Error()) |
Shinichiro Hamaji | 21a9b5f | 2015-04-01 02:42:59 +0900 | [diff] [blame] | 158 | } |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 159 | Log("rule %q => outputs:%q, inputs:%q", line, rule.outputs, rule.inputs) |
Shinichiro Hamaji | de82971 | 2015-03-31 18:26:56 +0900 | [diff] [blame] | 160 | |
Shinichiro Hamaji | 0493261 | 2015-03-31 23:46:56 +0900 | [diff] [blame] | 161 | // TODO: Pretty print. |
| 162 | //Log("RULE: %s=%s (%d commands)", lhs, rhs, len(cmds)) |
| 163 | |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 164 | if assign != nil { |
Shinichiro Hamaji | 486e9de | 2015-04-09 15:20:32 +0900 | [diff] [blame] | 165 | if ast.semicolonIndex >= 0 { |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 166 | // TODO(ukai): reuse lexpr above? |
| 167 | lexpr, _, err := parseExpr([]byte(ast.expr), nil) |
| 168 | if err != nil { |
| 169 | panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err)) |
| 170 | } |
| 171 | assign, err = rule.parse(string(ev.Value(lexpr))) |
Shinichiro Hamaji | 486e9de | 2015-04-09 15:20:32 +0900 | [diff] [blame] | 172 | if err != nil { |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 173 | Error(ast.filename, ast.lineno, "%v", err.Error()) |
Shinichiro Hamaji | 486e9de | 2015-04-09 15:20:32 +0900 | [diff] [blame] | 174 | } |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 175 | } |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 176 | for _, output := range rule.outputs { |
| 177 | ev.setTargetSpecificVar(assign, output) |
Shinichiro Hamaji | 6cc5c61 | 2015-04-15 12:59:40 +0900 | [diff] [blame] | 178 | } |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 179 | for _, output := range rule.outputPatterns { |
| 180 | ev.setTargetSpecificVar(assign, output) |
Shinichiro Hamaji | ea170b1 | 2015-04-15 10:02:33 +0900 | [diff] [blame] | 181 | } |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 182 | return |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 183 | } |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 184 | |
| 185 | if ast.semicolonIndex > 0 { |
| 186 | rule.cmds = append(rule.cmds, ast.expr[ast.semicolonIndex+1:]) |
| 187 | } |
| 188 | Log("rule outputs:%q cmds:%q", rule.outputs, rule.cmds) |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 189 | ev.lastRule = rule |
Fumitoshi Ukai | 953ce6f | 2015-04-04 00:38:53 +0900 | [diff] [blame] | 190 | ev.outRules = append(ev.outRules, rule) |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 191 | } |
| 192 | |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 193 | func (ev *Evaluator) evalCommand(ast *CommandAST) { |
| 194 | ev.filename = ast.filename |
| 195 | ev.lineno = ast.lineno |
| 196 | if ev.lastRule == nil { |
Shinichiro Hamaji | b0e8116 | 2015-04-09 07:50:06 +0900 | [diff] [blame] | 197 | // This could still be an assignment statement. See |
| 198 | // assign_after_tab.mk. |
| 199 | if strings.IndexByte(ast.cmd, '=') >= 0 { |
Shinichiro Hamaji | c88618f | 2015-04-11 19:58:06 +0900 | [diff] [blame] | 200 | line := trimLeftSpace(ast.cmd) |
Shinichiro Hamaji | b0e8116 | 2015-04-09 07:50:06 +0900 | [diff] [blame] | 201 | mk, err := ParseMakefileString(line, ast.filename, ast.lineno) |
| 202 | if err != nil { |
| 203 | panic(err) |
| 204 | } |
| 205 | if len(mk.stmts) == 1 && mk.stmts[0].(*AssignAST) != nil { |
| 206 | ev.eval(mk.stmts[0]) |
| 207 | } |
| 208 | return |
| 209 | } |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 210 | Error(ast.filename, ast.lineno, "*** commands commence before first target.") |
| 211 | } |
| 212 | ev.lastRule.cmds = append(ev.lastRule.cmds, ast.cmd) |
| 213 | if ev.lastRule.cmdLineno == 0 { |
| 214 | ev.lastRule.cmdLineno = ast.lineno |
| 215 | } |
| 216 | } |
| 217 | |
Fumitoshi Ukai | 8edcb79 | 2015-04-02 11:23:23 +0900 | [diff] [blame] | 218 | func (ev *Evaluator) LookupVar(name string) Var { |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 219 | if ev.currentScope != nil { |
| 220 | v := ev.currentScope.Lookup(name) |
| 221 | if v.IsDefined() { |
| 222 | return v |
| 223 | } |
| 224 | } |
| 225 | v := ev.outVars.Lookup(name) |
| 226 | if v.IsDefined() { |
| 227 | return v |
| 228 | } |
| 229 | return ev.vars.Lookup(name) |
| 230 | } |
| 231 | |
| 232 | func (ev *Evaluator) LookupVarInCurrentScope(name string) Var { |
| 233 | if ev.currentScope != nil { |
| 234 | v := ev.currentScope.Lookup(name) |
| 235 | return v |
| 236 | } |
Fumitoshi Ukai | 8edcb79 | 2015-04-02 11:23:23 +0900 | [diff] [blame] | 237 | v := ev.outVars.Lookup(name) |
| 238 | if v.IsDefined() { |
| 239 | return v |
Shinichiro Hamaji | 69b7f65 | 2015-03-31 01:01:59 +0900 | [diff] [blame] | 240 | } |
Fumitoshi Ukai | 8edcb79 | 2015-04-02 11:23:23 +0900 | [diff] [blame] | 241 | return ev.vars.Lookup(name) |
Shinichiro Hamaji | 69b7f65 | 2015-03-31 01:01:59 +0900 | [diff] [blame] | 242 | } |
| 243 | |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 244 | func (ev *Evaluator) evalInclude(ast *IncludeAST) { |
Shinichiro Hamaji | 0b93c86 | 2015-04-07 06:15:15 +0900 | [diff] [blame] | 245 | ev.lastRule = nil |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 246 | ev.filename = ast.filename |
| 247 | ev.lineno = ast.lineno |
| 248 | |
Fumitoshi Ukai | a9e5136 | 2015-04-17 10:26:00 +0900 | [diff] [blame] | 249 | Log("%s:%d include %q", ev.filename, ev.lineno, ast.expr) |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 250 | // TODO: Handle glob |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 251 | v, _, err := parseExpr([]byte(ast.expr), nil) |
| 252 | if err != nil { |
| 253 | panic(err) |
| 254 | } |
| 255 | files := ev.Values(v) |
| 256 | for _, f := range files { |
| 257 | file := string(f) |
Fumitoshi Ukai | a9e5136 | 2015-04-17 10:26:00 +0900 | [diff] [blame] | 258 | Log("Reading makefile %q", file) |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 259 | mk, err := ParseMakefile(file) |
| 260 | if err != nil { |
| 261 | if ast.op == "include" { |
| 262 | panic(err) |
| 263 | } else { |
| 264 | continue |
| 265 | } |
| 266 | } |
| 267 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 268 | makefileList := ev.outVars.Lookup("MAKEFILE_LIST") |
| 269 | makefileList = makefileList.Append(ev, mk.filename) |
| 270 | ev.outVars.Assign("MAKEFILE_LIST", makefileList) |
Shinichiro Hamaji | b2388ec | 2015-04-09 16:58:33 +0900 | [diff] [blame] | 271 | |
| 272 | for _, stmt := range mk.stmts { |
| 273 | ev.eval(stmt) |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 274 | } |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 275 | } |
| 276 | } |
| 277 | |
Shinichiro Hamaji | 497754d | 2015-03-31 02:02:11 +0900 | [diff] [blame] | 278 | func (ev *Evaluator) evalIf(ast *IfAST) { |
Shinichiro Hamaji | af1e816 | 2015-03-31 02:15:37 +0900 | [diff] [blame] | 279 | var isTrue bool |
Shinichiro Hamaji | 497754d | 2015-03-31 02:02:11 +0900 | [diff] [blame] | 280 | switch ast.op { |
| 281 | case "ifdef", "ifndef": |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 282 | expr, _, err := parseExpr([]byte(ast.lhs), nil) |
| 283 | if err != nil { |
| 284 | panic(fmt.Errorf("ifdef parse %s:%d %v", ast.filename, ast.lineno, err)) |
| 285 | } |
| 286 | vname := ev.Value(expr) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 287 | v := ev.LookupVar(string(vname)) |
| 288 | value := ev.Value(v) |
| 289 | isTrue = (len(value) > 0) == (ast.op == "ifdef") |
Fumitoshi Ukai | 8edcb79 | 2015-04-02 11:23:23 +0900 | [diff] [blame] | 290 | Log("%s lhs=%q value=%q => %t", ast.op, ast.lhs, value, isTrue) |
Shinichiro Hamaji | 497754d | 2015-03-31 02:02:11 +0900 | [diff] [blame] | 291 | case "ifeq", "ifneq": |
Fumitoshi Ukai | 00178d1 | 2015-04-18 00:11:05 +0900 | [diff] [blame] | 292 | lexpr, _, err := parseExpr([]byte(ast.lhs), nil) |
| 293 | if err != nil { |
| 294 | panic(fmt.Errorf("ifeq lhs parse %s:%d %v", ast.filename, ast.lineno, err)) |
| 295 | } |
| 296 | rexpr, _, err := parseExpr([]byte(ast.rhs), nil) |
| 297 | if err != nil { |
| 298 | panic(fmt.Errorf("ifeq rhs parse %s:%d %v", ast.filename, ast.lineno, err)) |
| 299 | } |
| 300 | lhs := string(ev.Value(lexpr)) |
| 301 | rhs := string(ev.Value(rexpr)) |
Shinichiro Hamaji | af1e816 | 2015-03-31 02:15:37 +0900 | [diff] [blame] | 302 | isTrue = (lhs == rhs) == (ast.op == "ifeq") |
Fumitoshi Ukai | 7008483 | 2015-04-05 23:27:28 +0900 | [diff] [blame] | 303 | Log("%s lhs=%q %q rhs=%q %q => %t", ast.op, ast.lhs, lhs, ast.rhs, rhs, isTrue) |
Shinichiro Hamaji | 497754d | 2015-03-31 02:02:11 +0900 | [diff] [blame] | 304 | default: |
| 305 | panic(fmt.Sprintf("unknown if statement: %q", ast.op)) |
| 306 | } |
Shinichiro Hamaji | af1e816 | 2015-03-31 02:15:37 +0900 | [diff] [blame] | 307 | |
| 308 | var stmts []AST |
| 309 | if isTrue { |
| 310 | stmts = ast.trueStmts |
| 311 | } else { |
| 312 | stmts = ast.falseStmts |
| 313 | } |
Shinichiro Hamaji | 497754d | 2015-03-31 02:02:11 +0900 | [diff] [blame] | 314 | for _, stmt := range stmts { |
| 315 | ev.eval(stmt) |
| 316 | } |
| 317 | } |
| 318 | |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 319 | func (ev *Evaluator) eval(ast AST) { |
Fumitoshi Ukai | e34c179 | 2015-03-30 17:53:47 +0900 | [diff] [blame] | 320 | ast.eval(ev) |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 321 | } |
| 322 | |
Shinichiro Hamaji | cc919ae | 2015-04-09 17:23:30 +0900 | [diff] [blame] | 323 | func Eval(mk Makefile, vars Vars) (er *EvalResult, err error) { |
Shinichiro Hamaji | d7bef60 | 2015-03-30 19:55:32 +0900 | [diff] [blame] | 324 | ev := newEvaluator(vars) |
Fumitoshi Ukai | f8efa0a | 2015-03-30 18:10:11 +0900 | [diff] [blame] | 325 | defer func() { |
| 326 | if r := recover(); r != nil { |
Fumitoshi Ukai | a9e5136 | 2015-04-17 10:26:00 +0900 | [diff] [blame] | 327 | err = fmt.Errorf("panic in eval %s: %v", mk.filename, r) |
Fumitoshi Ukai | f8efa0a | 2015-03-30 18:10:11 +0900 | [diff] [blame] | 328 | } |
| 329 | }() |
Shinichiro Hamaji | 491e73f | 2015-04-07 12:41:59 +0900 | [diff] [blame] | 330 | |
| 331 | makefile_list := vars.Lookup("MAKEFILE_LIST") |
| 332 | makefile_list = makefile_list.Append(ev, mk.filename) |
| 333 | ev.outVars.Assign("MAKEFILE_LIST", makefile_list) |
| 334 | |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 335 | for _, stmt := range mk.stmts { |
| 336 | ev.eval(stmt) |
| 337 | } |
| 338 | return &EvalResult{ |
Shinichiro Hamaji | a485d2f | 2015-04-16 14:03:24 +0900 | [diff] [blame] | 339 | vars: ev.outVars, |
| 340 | rules: ev.outRules, |
| 341 | ruleVars: ev.outRuleVars, |
Fumitoshi Ukai | f8efa0a | 2015-03-30 18:10:11 +0900 | [diff] [blame] | 342 | }, nil |
Fumitoshi Ukai | 119dc91 | 2015-03-30 16:52:41 +0900 | [diff] [blame] | 343 | } |