Fumitoshi Ukai | f2f8456 | 2015-03-30 19:47:45 +0900 | [diff] [blame] | 1 | package main |
| 2 | |
| 3 | import ( |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 4 | "bytes" |
Fumitoshi Ukai | f2f8456 | 2015-03-30 19:47:45 +0900 | [diff] [blame] | 5 | "fmt" |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 6 | "io" |
Shinichiro Hamaji | e7aafb0 | 2015-04-09 18:23:46 +0900 | [diff] [blame] | 7 | "os" |
Fumitoshi Ukai | f2f8456 | 2015-03-30 19:47:45 +0900 | [diff] [blame] | 8 | "os/exec" |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 9 | "path/filepath" |
Shinichiro Hamaji | 13b30d9 | 2015-04-03 14:42:21 +0900 | [diff] [blame] | 10 | "sort" |
Shinichiro Hamaji | e708a9d | 2015-04-03 14:34:35 +0900 | [diff] [blame] | 11 | "strconv" |
Fumitoshi Ukai | f2f8456 | 2015-03-30 19:47:45 +0900 | [diff] [blame] | 12 | "strings" |
Fumitoshi Ukai | 586b02a | 2015-05-08 00:23:10 +0900 | [diff] [blame] | 13 | "time" |
Fumitoshi Ukai | f2f8456 | 2015-03-30 19:47:45 +0900 | [diff] [blame] | 14 | ) |
| 15 | |
| 16 | // Func is a make function. |
| 17 | // http://www.gnu.org/software/make/manual/make.html#Functions |
Fumitoshi Ukai | e520f26 | 2015-03-31 17:27:03 +0900 | [diff] [blame] | 18 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 19 | // Func is make builtin function. |
| 20 | type Func interface { |
| 21 | // Arity is max function's arity. |
| 22 | // ',' will not be handled as argument separator more than arity. |
| 23 | // 0 means varargs. |
| 24 | Arity() int |
| 25 | |
| 26 | // AddArg adds value as an argument. |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 27 | // the first argument will be "(funcname", or "{funcname". |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 28 | AddArg(Value) |
| 29 | |
| 30 | Value |
| 31 | } |
| 32 | |
| 33 | var ( |
| 34 | funcMap = map[string]func() Func{ |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 35 | "patsubst": func() Func { return &funcPatsubst{} }, |
| 36 | "strip": func() Func { return &funcStrip{} }, |
| 37 | "subst": func() Func { return &funcSubst{} }, |
| 38 | "findstring": func() Func { return &funcFindstring{} }, |
| 39 | "filter": func() Func { return &funcFilter{} }, |
| 40 | "filter-out": func() Func { return &funcFilterOut{} }, |
| 41 | "sort": func() Func { return &funcSort{} }, |
| 42 | "word": func() Func { return &funcWord{} }, |
| 43 | "wordlist": func() Func { return &funcWordlist{} }, |
| 44 | "words": func() Func { return &funcWords{} }, |
| 45 | "firstword": func() Func { return &funcFirstword{} }, |
| 46 | "lastword": func() Func { return &funcLastword{} }, |
| 47 | |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 48 | "join": func() Func { return &funcJoin{} }, |
| 49 | "wildcard": func() Func { return &funcWildcard{} }, |
| 50 | "dir": func() Func { return &funcDir{} }, |
| 51 | "notdir": func() Func { return &funcNotdir{} }, |
| 52 | "suffix": func() Func { return &funcSuffix{} }, |
| 53 | "basename": func() Func { return &funcBasename{} }, |
| 54 | "addsuffix": func() Func { return &funcAddsuffix{} }, |
| 55 | "addprefix": func() Func { return &funcAddprefix{} }, |
| 56 | "realpath": func() Func { return &funcRealpath{} }, |
| 57 | "abspath": func() Func { return &funcAbspath{} }, |
| 58 | |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 59 | "if": func() Func { return &funcIf{} }, |
| 60 | "and": func() Func { return &funcAnd{} }, |
| 61 | "or": func() Func { return &funcOr{} }, |
| 62 | |
Shinichiro Hamaji | 28ea5bc | 2015-04-11 12:41:08 +0900 | [diff] [blame] | 63 | "value": func() Func { return &funcValue{} }, |
| 64 | |
| 65 | "eval": func() Func { return &funcEval{} }, |
| 66 | |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 67 | "shell": func() Func { return &funcShell{} }, |
| 68 | "call": func() Func { return &funcCall{} }, |
| 69 | "foreach": func() Func { return &funcForeach{} }, |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 70 | |
| 71 | "origin": func() Func { return &funcOrigin{} }, |
| 72 | "flavor": func() Func { return &funcFlavor{} }, |
| 73 | "info": func() Func { return &funcInfo{} }, |
| 74 | "warning": func() Func { return &funcWarning{} }, |
| 75 | "error": func() Func { return &funcError{} }, |
Fumitoshi Ukai | 0b5e18b | 2015-04-03 22:57:17 +0900 | [diff] [blame] | 76 | } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 77 | ) |
| 78 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 79 | func assertArity(name string, req, n int) { |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 80 | if n-1 < req { |
| 81 | panic(fmt.Sprintf("*** insufficient number of arguments (%d) to function `%s'.", n-1, name)) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 82 | } |
| 83 | } |
| 84 | |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 85 | // A space separated values writer. |
| 86 | type ssvWriter struct { |
| 87 | w io.Writer |
| 88 | needsSpace bool |
| 89 | } |
| 90 | |
| 91 | func (sw *ssvWriter) Write(b []byte) { |
| 92 | if sw.needsSpace { |
| 93 | sw.w.Write([]byte{' '}) |
| 94 | } |
| 95 | sw.needsSpace = true |
| 96 | sw.w.Write(b) |
| 97 | } |
| 98 | |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 99 | func (sw *ssvWriter) WriteString(s string) { |
| 100 | // TODO: Ineffcient. Nice if we can remove the cast. |
| 101 | sw.Write([]byte(s)) |
| 102 | } |
| 103 | |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 104 | func numericValueForFunc(v string) (int, bool) { |
| 105 | n, err := strconv.Atoi(v) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 106 | if err != nil || n < 0 { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 107 | return n, false |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 108 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 109 | return n, true |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 110 | } |
| 111 | |
Shinichiro Hamaji | ba6b84d | 2015-06-03 18:46:13 +0900 | [diff] [blame^] | 112 | func formatCommandOutput(out []byte) []byte { |
| 113 | out = bytes.TrimRight(out, "\n") |
| 114 | out = bytes.Replace(out, []byte{'\n'}, []byte{' '}, -1) |
| 115 | return out |
| 116 | } |
| 117 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 118 | type fclosure struct { |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 119 | // args[0] is "(funcname", or "{funcname". |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 120 | args []Value |
| 121 | } |
| 122 | |
| 123 | func (c *fclosure) AddArg(v Value) { |
| 124 | c.args = append(c.args, v) |
Fumitoshi Ukai | 0b5e18b | 2015-04-03 22:57:17 +0900 | [diff] [blame] | 125 | } |
| 126 | |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 127 | func (c *fclosure) String() string { |
| 128 | if len(c.args) == 0 { |
| 129 | panic("no args in func") |
| 130 | } |
| 131 | arg0 := c.args[0].String() |
| 132 | if arg0 == "" { |
| 133 | panic(fmt.Errorf("wrong format of arg0: %q", arg0)) |
| 134 | } |
| 135 | cp := closeParen(arg0[0]) |
| 136 | if cp == 0 { |
| 137 | panic(fmt.Errorf("wrong format of arg0: %q", arg0)) |
| 138 | } |
| 139 | var args []string |
| 140 | for _, arg := range c.args[1:] { |
| 141 | args = append(args, arg.String()) |
| 142 | } |
| 143 | return fmt.Sprintf("$%s %s%c", arg0, strings.Join(args, ","), cp) |
| 144 | } |
Fumitoshi Ukai | 7878113 | 2015-04-10 17:08:40 +0900 | [diff] [blame] | 145 | |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 146 | func (c *fclosure) Serialize() SerializableVar { |
Shinichiro Hamaji | c8bc731 | 2015-04-28 02:48:03 +0900 | [diff] [blame] | 147 | r := SerializableVar{Type: "func"} |
| 148 | for _, a := range c.args { |
| 149 | r.Children = append(r.Children, a.Serialize()) |
| 150 | } |
| 151 | return r |
| 152 | } |
| 153 | |
Shinichiro Hamaji | 723f56a | 2015-05-15 17:12:55 +0900 | [diff] [blame] | 154 | func (c *fclosure) Dump(w io.Writer) { |
| 155 | dumpByte(w, VALUE_TYPE_FUNC) |
| 156 | for _, a := range c.args { |
| 157 | a.Dump(w) |
| 158 | } |
| 159 | } |
| 160 | |
Shinichiro Hamaji | 4125cf4 | 2015-04-03 11:42:28 +0900 | [diff] [blame] | 161 | // http://www.gnu.org/software/make/manual/make.html#Text-Functions |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 162 | type funcSubst struct{ fclosure } |
| 163 | |
| 164 | func (f *funcSubst) Arity() int { return 3 } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 165 | func (f *funcSubst) Eval(w io.Writer, ev *Evaluator) { |
| 166 | assertArity("subst", 3, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 167 | abuf := newBuf() |
| 168 | fargs := ev.args(abuf, f.args[1:]...) |
| 169 | from := fargs[0] |
| 170 | to := fargs[1] |
| 171 | text := fargs[2] |
Fumitoshi Ukai | bb79a9d | 2015-04-02 12:46:54 +0900 | [diff] [blame] | 172 | Log("subst from:%q to:%q text:%q", from, to, text) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 173 | w.Write(bytes.Replace(text, from, to, -1)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 174 | freeBuf(abuf) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 175 | } |
| 176 | |
Shinichiro Hamaji | 98e910d | 2015-04-11 10:38:44 +0900 | [diff] [blame] | 177 | type funcPatsubst struct{ fclosure } |
| 178 | |
| 179 | func (f *funcPatsubst) Arity() int { return 3 } |
| 180 | func (f *funcPatsubst) Eval(w io.Writer, ev *Evaluator) { |
| 181 | assertArity("patsubst", 3, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 182 | abuf := newBuf() |
| 183 | fargs := ev.args(abuf, f.args[1:]...) |
| 184 | pat := fargs[0] |
| 185 | repl := fargs[1] |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 186 | ws := newWordScanner(fargs[2]) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 187 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 188 | for ws.Scan() { |
| 189 | t := substPatternBytes(pat, repl, ws.Bytes()) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 190 | sw.Write(t) |
Shinichiro Hamaji | 98e910d | 2015-04-11 10:38:44 +0900 | [diff] [blame] | 191 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 192 | freeBuf(abuf) |
Shinichiro Hamaji | 98e910d | 2015-04-11 10:38:44 +0900 | [diff] [blame] | 193 | } |
| 194 | |
| 195 | type funcStrip struct{ fclosure } |
| 196 | |
| 197 | func (f *funcStrip) Arity() int { return 1 } |
| 198 | func (f *funcStrip) Eval(w io.Writer, ev *Evaluator) { |
| 199 | assertArity("strip", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 200 | abuf := newBuf() |
| 201 | f.args[1].Eval(abuf, ev) |
| 202 | w.Write(trimSpaceBytes(abuf.Bytes())) |
| 203 | freeBuf(abuf) |
Shinichiro Hamaji | 98e910d | 2015-04-11 10:38:44 +0900 | [diff] [blame] | 204 | } |
| 205 | |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 206 | type funcFindstring struct{ fclosure } |
| 207 | |
| 208 | func (f *funcFindstring) Arity() int { return 2 } |
| 209 | func (f *funcFindstring) Eval(w io.Writer, ev *Evaluator) { |
| 210 | assertArity("findstring", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 211 | abuf := newBuf() |
| 212 | fargs := ev.args(abuf, f.args[1:]...) |
| 213 | find := fargs[0] |
| 214 | text := fargs[1] |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 215 | if bytes.Index(text, find) >= 0 { |
| 216 | w.Write(find) |
| 217 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 218 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | type funcFilter struct{ fclosure } |
| 222 | |
| 223 | func (f *funcFilter) Arity() int { return 2 } |
| 224 | func (f *funcFilter) Eval(w io.Writer, ev *Evaluator) { |
| 225 | assertArity("filter", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 226 | abuf := newBuf() |
| 227 | fargs := ev.args(abuf, f.args[1:]...) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 228 | var patterns [][]byte |
| 229 | ws := newWordScanner(fargs[0]) |
| 230 | for ws.Scan() { |
| 231 | patterns = append(patterns, ws.Bytes()) |
| 232 | } |
| 233 | ws = newWordScanner(fargs[1]) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 234 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 235 | for ws.Scan() { |
| 236 | text := ws.Bytes() |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 237 | for _, pat := range patterns { |
| 238 | if matchPatternBytes(pat, text) { |
| 239 | sw.Write(text) |
| 240 | } |
| 241 | } |
| 242 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 243 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | type funcFilterOut struct{ fclosure } |
| 247 | |
| 248 | func (f *funcFilterOut) Arity() int { return 2 } |
| 249 | func (f *funcFilterOut) Eval(w io.Writer, ev *Evaluator) { |
| 250 | assertArity("filter-out", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 251 | abuf := newBuf() |
| 252 | fargs := ev.args(abuf, f.args[1:]...) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 253 | var patterns [][]byte |
| 254 | ws := newWordScanner(fargs[0]) |
| 255 | for ws.Scan() { |
| 256 | patterns = append(patterns, ws.Bytes()) |
| 257 | } |
| 258 | ws = newWordScanner(fargs[1]) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 259 | sw := ssvWriter{w: w} |
| 260 | Loop: |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 261 | for ws.Scan() { |
| 262 | text := ws.Bytes() |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 263 | for _, pat := range patterns { |
| 264 | if matchPatternBytes(pat, text) { |
| 265 | continue Loop |
| 266 | } |
| 267 | } |
| 268 | sw.Write(text) |
| 269 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 270 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 271 | } |
| 272 | |
| 273 | type funcSort struct{ fclosure } |
| 274 | |
| 275 | func (f *funcSort) Arity() int { return 1 } |
| 276 | func (f *funcSort) Eval(w io.Writer, ev *Evaluator) { |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 277 | assertArity("sort", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 278 | abuf := newBuf() |
| 279 | f.args[1].Eval(abuf, ev) |
| 280 | toks := splitSpaces(abuf.String()) |
| 281 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 282 | sort.Strings(toks) |
| 283 | |
| 284 | // Remove duplicate words. |
| 285 | var prev string |
| 286 | sw := ssvWriter{w: w} |
| 287 | for _, tok := range toks { |
| 288 | if prev != tok { |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 289 | sw.WriteString(tok) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 290 | prev = tok |
| 291 | } |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | type funcWord struct{ fclosure } |
| 296 | |
| 297 | func (f *funcWord) Arity() int { return 2 } |
| 298 | func (f *funcWord) Eval(w io.Writer, ev *Evaluator) { |
| 299 | assertArity("word", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 300 | abuf := newBuf() |
| 301 | fargs := ev.args(abuf, f.args[1:]...) |
| 302 | v := string(trimSpaceBytes(fargs[0])) |
| 303 | index, ok := numericValueForFunc(v) |
| 304 | if !ok { |
| 305 | Error(ev.filename, ev.lineno, `*** non-numeric first argument to "word" function: %q.`, v) |
| 306 | } |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 307 | if index == 0 { |
| 308 | Error(ev.filename, ev.lineno, `*** first argument to "word" function must be greater than 0.`) |
| 309 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 310 | ws := newWordScanner(fargs[1]) |
| 311 | for ws.Scan() { |
| 312 | index-- |
| 313 | if index == 0 { |
| 314 | w.Write(ws.Bytes()) |
| 315 | break |
| 316 | } |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 317 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 318 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | type funcWordlist struct{ fclosure } |
| 322 | |
| 323 | func (f *funcWordlist) Arity() int { return 3 } |
| 324 | func (f *funcWordlist) Eval(w io.Writer, ev *Evaluator) { |
| 325 | assertArity("wordlist", 3, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 326 | abuf := newBuf() |
| 327 | fargs := ev.args(abuf, f.args[1:]...) |
| 328 | v := string(trimSpaceBytes(fargs[0])) |
| 329 | si, ok := numericValueForFunc(v) |
| 330 | if !ok { |
| 331 | Error(ev.filename, ev.lineno, `*** non-numeric first argument to "wordlist" function: %q.`, v) |
| 332 | } |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 333 | if si == 0 { |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 334 | Error(ev.filename, ev.lineno, `*** invalid first argument to "wordlist" function: %s`, f.args[1]) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 335 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 336 | v = string(trimSpaceBytes(fargs[1])) |
| 337 | ei, ok := numericValueForFunc(v) |
| 338 | if !ok { |
| 339 | Error(ev.filename, ev.lineno, `*** non-numeric second argument to "wordlist" function: %q.`, v) |
| 340 | } |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 341 | |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 342 | ws := newWordScanner(fargs[2]) |
| 343 | i := 0 |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 344 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 345 | for ws.Scan() { |
| 346 | i++ |
| 347 | if si <= i && i <= ei { |
| 348 | sw.Write(ws.Bytes()) |
| 349 | } |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 350 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 351 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | type funcWords struct{ fclosure } |
| 355 | |
| 356 | func (f *funcWords) Arity() int { return 1 } |
| 357 | func (f *funcWords) Eval(w io.Writer, ev *Evaluator) { |
| 358 | assertArity("words", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 359 | abuf := newBuf() |
| 360 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 361 | ws := newWordScanner(abuf.Bytes()) |
| 362 | n := 0 |
| 363 | for ws.Scan() { |
| 364 | n++ |
| 365 | } |
| 366 | w.Write([]byte(strconv.Itoa(n))) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 367 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | type funcFirstword struct{ fclosure } |
| 371 | |
| 372 | func (f *funcFirstword) Arity() int { return 1 } |
| 373 | func (f *funcFirstword) Eval(w io.Writer, ev *Evaluator) { |
| 374 | assertArity("firstword", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 375 | abuf := newBuf() |
| 376 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 377 | ws := newWordScanner(abuf.Bytes()) |
| 378 | if ws.Scan() { |
| 379 | w.Write(ws.Bytes()) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 380 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 381 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 382 | } |
| 383 | |
| 384 | type funcLastword struct{ fclosure } |
| 385 | |
| 386 | func (f *funcLastword) Arity() int { return 1 } |
| 387 | func (f *funcLastword) Eval(w io.Writer, ev *Evaluator) { |
| 388 | assertArity("lastword", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 389 | abuf := newBuf() |
| 390 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 391 | ws := newWordScanner(abuf.Bytes()) |
| 392 | var lw []byte |
| 393 | for ws.Scan() { |
| 394 | lw = ws.Bytes() |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 395 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 396 | if lw != nil { |
| 397 | w.Write(lw) |
| 398 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 399 | freeBuf(abuf) |
Shinichiro Hamaji | 05b222d | 2015-04-11 11:36:37 +0900 | [diff] [blame] | 400 | } |
| 401 | |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 402 | // https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html#File-Name-Functions |
| 403 | |
| 404 | type funcJoin struct{ fclosure } |
| 405 | |
| 406 | func (f *funcJoin) Arity() int { return 2 } |
| 407 | func (f *funcJoin) Eval(w io.Writer, ev *Evaluator) { |
| 408 | assertArity("join", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 409 | abuf := newBuf() |
| 410 | fargs := ev.args(abuf, f.args[1:]...) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 411 | ws1 := newWordScanner(fargs[0]) |
| 412 | ws2 := newWordScanner(fargs[1]) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 413 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 414 | for { |
| 415 | if w1, w2 := ws1.Scan(), ws2.Scan(); !w1 && !w2 { |
| 416 | break |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 417 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 418 | sw.Write(ws1.Bytes()) |
| 419 | // Use |w| not to append extra ' '. |
| 420 | w.Write(ws2.Bytes()) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 421 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 422 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 423 | } |
| 424 | |
| 425 | type funcWildcard struct{ fclosure } |
| 426 | |
| 427 | func (f *funcWildcard) Arity() int { return 1 } |
| 428 | func (f *funcWildcard) Eval(w io.Writer, ev *Evaluator) { |
| 429 | assertArity("wildcard", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 430 | abuf := newBuf() |
| 431 | f.args[1].Eval(abuf, ev) |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 432 | if ev.avoidIO { |
| 433 | ev.hasIO = true |
| 434 | w.Write([]byte("$(/bin/ls ")) |
| 435 | w.Write(abuf.Bytes()) |
| 436 | w.Write([]byte(" 2> /dev/null)")) |
| 437 | return |
| 438 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 439 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 440 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 441 | for ws.Scan() { |
Shinichiro Hamaji | ba6b84d | 2015-06-03 18:46:13 +0900 | [diff] [blame^] | 442 | pat := string(ws.Bytes()) |
| 443 | if strings.Contains(pat, "..") { |
| 444 | // For some reason, go's Glob normalizes |
| 445 | // foo/../bar to bar. We ask shell to expand |
| 446 | // a glob to avoid this. |
| 447 | cmdline := []string{"/bin/sh", "-c", "/bin/ls " + pat} |
| 448 | cmd := exec.Cmd{ |
| 449 | Path: cmdline[0], |
| 450 | Args: cmdline, |
| 451 | } |
| 452 | // Ignore errors. |
| 453 | out, _ := cmd.Output() |
| 454 | w.Write(formatCommandOutput(out)) |
| 455 | } else { |
| 456 | files, err := filepath.Glob(string(ws.Bytes())) |
| 457 | if err != nil { |
| 458 | panic(err) |
| 459 | } |
| 460 | for _, file := range files { |
| 461 | sw.WriteString(file) |
| 462 | } |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 463 | } |
| 464 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 465 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 466 | } |
| 467 | |
| 468 | type funcDir struct{ fclosure } |
| 469 | |
| 470 | func (f *funcDir) Arity() int { return 1 } |
| 471 | func (f *funcDir) Eval(w io.Writer, ev *Evaluator) { |
| 472 | assertArity("dir", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 473 | abuf := newBuf() |
| 474 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 475 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 476 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 477 | for ws.Scan() { |
| 478 | name := string(ws.Bytes()) |
Shinichiro Hamaji | 37626b6 | 2015-04-21 16:59:23 +0900 | [diff] [blame] | 479 | if name == "/" { |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 480 | sw.WriteString(name) |
| 481 | continue |
Shinichiro Hamaji | 37626b6 | 2015-04-21 16:59:23 +0900 | [diff] [blame] | 482 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 483 | sw.WriteString(filepath.Dir(string(name)) + string(filepath.Separator)) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 484 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 485 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | type funcNotdir struct{ fclosure } |
| 489 | |
| 490 | func (f *funcNotdir) Arity() int { return 1 } |
| 491 | func (f *funcNotdir) Eval(w io.Writer, ev *Evaluator) { |
| 492 | assertArity("notdir", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 493 | abuf := newBuf() |
| 494 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 495 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 496 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 497 | for ws.Scan() { |
| 498 | name := string(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 499 | if name == string(filepath.Separator) { |
| 500 | sw.Write([]byte{}) |
| 501 | continue |
| 502 | } |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 503 | sw.WriteString(filepath.Base(name)) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 504 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 505 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | type funcSuffix struct{ fclosure } |
| 509 | |
| 510 | func (f *funcSuffix) Arity() int { return 1 } |
| 511 | func (f *funcSuffix) Eval(w io.Writer, ev *Evaluator) { |
| 512 | assertArity("suffix", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 513 | abuf := newBuf() |
| 514 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 515 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 516 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 517 | for ws.Scan() { |
| 518 | tok := string(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 519 | e := filepath.Ext(tok) |
| 520 | if len(e) > 0 { |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 521 | sw.WriteString(e) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 522 | } |
| 523 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 524 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 525 | } |
| 526 | |
| 527 | type funcBasename struct{ fclosure } |
| 528 | |
| 529 | func (f *funcBasename) Arity() int { return 1 } |
| 530 | func (f *funcBasename) Eval(w io.Writer, ev *Evaluator) { |
| 531 | assertArity("basename", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 532 | abuf := newBuf() |
| 533 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 534 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 535 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 536 | for ws.Scan() { |
| 537 | tok := string(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 538 | e := stripExt(tok) |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 539 | sw.WriteString(e) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 540 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 541 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 542 | } |
| 543 | |
| 544 | type funcAddsuffix struct{ fclosure } |
| 545 | |
| 546 | func (f *funcAddsuffix) Arity() int { return 2 } |
| 547 | func (f *funcAddsuffix) Eval(w io.Writer, ev *Evaluator) { |
| 548 | assertArity("addsuffix", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 549 | abuf := newBuf() |
| 550 | fargs := ev.args(abuf, f.args[1:]...) |
| 551 | suf := fargs[0] |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 552 | ws := newWordScanner(fargs[1]) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 553 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 554 | for ws.Scan() { |
| 555 | sw.Write(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 556 | // Use |w| not to append extra ' '. |
| 557 | w.Write(suf) |
| 558 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 559 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 560 | } |
| 561 | |
| 562 | type funcAddprefix struct{ fclosure } |
| 563 | |
| 564 | func (f *funcAddprefix) Arity() int { return 2 } |
| 565 | func (f *funcAddprefix) Eval(w io.Writer, ev *Evaluator) { |
| 566 | assertArity("addprefix", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 567 | abuf := newBuf() |
| 568 | fargs := ev.args(abuf, f.args[1:]...) |
| 569 | pre := fargs[0] |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 570 | ws := newWordScanner(fargs[1]) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 571 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 572 | for ws.Scan() { |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 573 | sw.Write(pre) |
| 574 | // Use |w| not to append extra ' '. |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 575 | w.Write(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 576 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 577 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 578 | } |
| 579 | |
| 580 | type funcRealpath struct{ fclosure } |
| 581 | |
| 582 | func (f *funcRealpath) Arity() int { return 1 } |
| 583 | func (f *funcRealpath) Eval(w io.Writer, ev *Evaluator) { |
| 584 | assertArity("realpath", 1, len(f.args)) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 585 | if ev.avoidIO { |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 586 | w.Write([]byte("KATI_TODO(realpath)")) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 587 | ev.hasIO = true |
| 588 | return |
| 589 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 590 | abuf := newBuf() |
| 591 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 592 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 593 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 594 | for ws.Scan() { |
| 595 | name := string(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 596 | name, err := filepath.Abs(name) |
| 597 | if err != nil { |
| 598 | Log("abs: %v", err) |
| 599 | continue |
| 600 | } |
| 601 | name, err = filepath.EvalSymlinks(name) |
| 602 | if err != nil { |
| 603 | Log("realpath: %v", err) |
| 604 | continue |
| 605 | } |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 606 | sw.WriteString(name) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 607 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 608 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 609 | } |
| 610 | |
| 611 | type funcAbspath struct{ fclosure } |
| 612 | |
| 613 | func (f *funcAbspath) Arity() int { return 1 } |
| 614 | func (f *funcAbspath) Eval(w io.Writer, ev *Evaluator) { |
| 615 | assertArity("abspath", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 616 | abuf := newBuf() |
| 617 | f.args[1].Eval(abuf, ev) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 618 | ws := newWordScanner(abuf.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 619 | sw := ssvWriter{w: w} |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 620 | for ws.Scan() { |
| 621 | name := string(ws.Bytes()) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 622 | name, err := filepath.Abs(name) |
| 623 | if err != nil { |
| 624 | Log("abs: %v", err) |
| 625 | continue |
| 626 | } |
Shinichiro Hamaji | a135891 | 2015-04-11 12:16:21 +0900 | [diff] [blame] | 627 | sw.WriteString(name) |
Shinichiro Hamaji | af61af2 | 2015-04-11 12:13:22 +0900 | [diff] [blame] | 628 | } |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 629 | freeBuf(abuf) |
Shinichiro Hamaji | c20b84d | 2015-04-11 12:02:51 +0900 | [diff] [blame] | 630 | } |
| 631 | |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 632 | // http://www.gnu.org/software/make/manual/make.html#Conditional-Functions |
| 633 | type funcIf struct{ fclosure } |
| 634 | |
| 635 | func (f *funcIf) Arity() int { return 3 } |
| 636 | func (f *funcIf) Eval(w io.Writer, ev *Evaluator) { |
| 637 | assertArity("if", 2, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 638 | abuf := newBuf() |
| 639 | f.args[1].Eval(abuf, ev) |
| 640 | if len(abuf.Bytes()) != 0 { |
| 641 | freeBuf(abuf) |
Fumitoshi Ukai | e27a25d | 2015-04-18 00:31:01 +0900 | [diff] [blame] | 642 | f.args[2].Eval(w, ev) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 643 | return |
| 644 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 645 | freeBuf(abuf) |
Fumitoshi Ukai | e27a25d | 2015-04-18 00:31:01 +0900 | [diff] [blame] | 646 | if len(f.args) > 3 { |
| 647 | f.args[3].Eval(w, ev) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 648 | } |
| 649 | } |
| 650 | |
| 651 | type funcAnd struct{ fclosure } |
| 652 | |
| 653 | func (f *funcAnd) Arity() int { return 0 } |
| 654 | func (f *funcAnd) Eval(w io.Writer, ev *Evaluator) { |
| 655 | assertArity("and", 0, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 656 | abuf := newBuf() |
Shinichiro Hamaji | 2216dd6 | 2015-04-11 13:44:39 +0900 | [diff] [blame] | 657 | var cond []byte |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 658 | for _, arg := range f.args[1:] { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 659 | abuf.Reset() |
| 660 | arg.Eval(abuf, ev) |
| 661 | cond = abuf.Bytes() |
Shinichiro Hamaji | 2216dd6 | 2015-04-11 13:44:39 +0900 | [diff] [blame] | 662 | if len(cond) == 0 { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 663 | freeBuf(abuf) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 664 | return |
| 665 | } |
| 666 | } |
Shinichiro Hamaji | 2216dd6 | 2015-04-11 13:44:39 +0900 | [diff] [blame] | 667 | w.Write(cond) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 668 | freeBuf(abuf) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | type funcOr struct{ fclosure } |
| 672 | |
| 673 | func (f *funcOr) Arity() int { return 0 } |
| 674 | func (f *funcOr) Eval(w io.Writer, ev *Evaluator) { |
| 675 | assertArity("or", 0, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 676 | abuf := newBuf() |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 677 | for _, arg := range f.args[1:] { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 678 | abuf.Reset() |
| 679 | arg.Eval(abuf, ev) |
| 680 | cond := abuf.Bytes() |
Shinichiro Hamaji | 2216dd6 | 2015-04-11 13:44:39 +0900 | [diff] [blame] | 681 | if len(cond) != 0 { |
| 682 | w.Write(cond) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 683 | freeBuf(abuf) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 684 | return |
| 685 | } |
| 686 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 687 | freeBuf(abuf) |
Shinichiro Hamaji | 424baeb | 2015-04-11 12:35:42 +0900 | [diff] [blame] | 688 | } |
| 689 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 690 | // http://www.gnu.org/software/make/manual/make.html#Shell-Function |
| 691 | type funcShell struct{ fclosure } |
| 692 | |
Fumitoshi Ukai | 586b02a | 2015-05-08 00:23:10 +0900 | [diff] [blame] | 693 | var shellFuncTime time.Duration |
| 694 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 695 | func (f *funcShell) Arity() int { return 1 } |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 696 | |
Shinichiro Hamaji | c0095e3 | 2015-05-27 18:49:06 +0900 | [diff] [blame] | 697 | // A hack for Android build. We need to evaluate things like $((3+4)) |
| 698 | // when we emit ninja file, because the result of such expressions |
| 699 | // will be passed to other make functions. |
| 700 | // TODO: Maybe we should modify Android's Makefile and remove this |
| 701 | // workaround. It would be also nice if we can detect things like |
| 702 | // this. |
| 703 | func hasNoIoInShellScript(s []byte) bool { |
| 704 | if len(s) == 0 { |
| 705 | return true |
| 706 | } |
| 707 | if !bytes.HasPrefix(s, []byte("echo $((")) || s[len(s)-1] != ')' { |
| 708 | return false |
| 709 | } |
Shinichiro Hamaji | 80017a0 | 2015-05-27 18:56:38 +0900 | [diff] [blame] | 710 | Log("has no IO - evaluate now: %s", s) |
Shinichiro Hamaji | c0095e3 | 2015-05-27 18:49:06 +0900 | [diff] [blame] | 711 | return true |
| 712 | } |
| 713 | |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 714 | func (f *funcShell) Eval(w io.Writer, ev *Evaluator) { |
| 715 | assertArity("shell", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 716 | abuf := newBuf() |
| 717 | f.args[1].Eval(abuf, ev) |
Shinichiro Hamaji | c0095e3 | 2015-05-27 18:49:06 +0900 | [diff] [blame] | 718 | if ev.avoidIO && !hasNoIoInShellScript(abuf.Bytes()) { |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 719 | ev.hasIO = true |
| 720 | w.Write([]byte("$(")) |
| 721 | w.Write(abuf.Bytes()) |
| 722 | w.Write([]byte{')'}) |
| 723 | return |
| 724 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 725 | arg := abuf.String() |
| 726 | freeBuf(abuf) |
Shinichiro Hamaji | 89551c9 | 2015-04-11 19:33:03 +0900 | [diff] [blame] | 727 | shellVar := ev.LookupVar("SHELL") |
| 728 | // TODO: Should be Eval, not String. |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 729 | cmdline := []string{shellVar.String(), "-c", arg} |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 730 | cmd := exec.Cmd{ |
| 731 | Path: cmdline[0], |
| 732 | Args: cmdline, |
| 733 | Stderr: os.Stderr, |
| 734 | } |
Fumitoshi Ukai | 586b02a | 2015-05-08 00:23:10 +0900 | [diff] [blame] | 735 | t := time.Now() |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 736 | out, err := cmd.Output() |
Fumitoshi Ukai | 586b02a | 2015-05-08 00:23:10 +0900 | [diff] [blame] | 737 | shellFuncTime += time.Now().Sub(t) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 738 | if err != nil { |
| 739 | Log("$(shell %q) failed: %q", arg, err) |
| 740 | } |
| 741 | |
Shinichiro Hamaji | ba6b84d | 2015-06-03 18:46:13 +0900 | [diff] [blame^] | 742 | w.Write(formatCommandOutput(out)) |
Fumitoshi Ukai | b36f387 | 2015-04-10 15:06:38 +0900 | [diff] [blame] | 743 | } |
| 744 | |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 745 | // https://www.gnu.org/software/make/manual/html_node/Call-Function.html#Call-Function |
| 746 | type funcCall struct{ fclosure } |
| 747 | |
| 748 | func (f *funcCall) Arity() int { return 0 } |
| 749 | |
| 750 | func (f *funcCall) Eval(w io.Writer, ev *Evaluator) { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 751 | abuf := newBuf() |
| 752 | fargs := ev.args(abuf, f.args[1:]...) |
| 753 | variable := fargs[0] |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 754 | Log("call %q variable %q", f.args[1], variable) |
| 755 | v := ev.LookupVar(string(variable)) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 756 | // Evalualte all arguments first before we modify the table. |
Shinichiro Hamaji | 39728f1 | 2015-04-11 20:12:23 +0900 | [diff] [blame] | 757 | var args []tmpval |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 758 | // $0 is variable. |
| 759 | args = append(args, tmpval(variable)) |
| 760 | // TODO(ukai): If variable is the name of a built-in function, |
| 761 | // the built-in function is always invoked (even if a make variable |
| 762 | // by that name also exists). |
| 763 | |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 764 | for i, arg := range fargs[1:] { |
| 765 | // f.args[2]=>args[1] will be $1. |
| 766 | args = append(args, tmpval(arg)) |
| 767 | Log("call $%d: %q=>%q", i+1, arg, fargs[i+1]) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 768 | } |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 769 | oldParams := ev.paramVars |
| 770 | ev.paramVars = args |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 771 | |
Fumitoshi Ukai | 9b10ecf | 2015-04-15 17:45:50 +0900 | [diff] [blame] | 772 | var restores []func() |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 773 | for i, arg := range args { |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 774 | name := fmt.Sprintf("%d", i) |
Fumitoshi Ukai | 9b10ecf | 2015-04-15 17:45:50 +0900 | [diff] [blame] | 775 | restores = append(restores, ev.outVars.save(name)) |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 776 | ev.outVars.Assign(name, SimpleVar{ |
| 777 | value: arg, |
| 778 | origin: "automatic", // ?? |
| 779 | }) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 780 | } |
| 781 | |
| 782 | var buf bytes.Buffer |
Fumitoshi Ukai | e27a25d | 2015-04-18 00:31:01 +0900 | [diff] [blame] | 783 | if katiLogFlag { |
| 784 | w = io.MultiWriter(w, &buf) |
| 785 | } |
| 786 | v.Eval(w, ev) |
Fumitoshi Ukai | 9b10ecf | 2015-04-15 17:45:50 +0900 | [diff] [blame] | 787 | for _, restore := range restores { |
| 788 | restore() |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 789 | } |
Fumitoshi Ukai | f0a2ba7 | 2015-04-19 00:02:32 +0900 | [diff] [blame] | 790 | ev.paramVars = oldParams |
| 791 | Log("call %q variable %q return %q", f.args[1], variable, buf.Bytes()) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 792 | freeBuf(abuf) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 793 | } |
| 794 | |
Shinichiro Hamaji | 28ea5bc | 2015-04-11 12:41:08 +0900 | [diff] [blame] | 795 | // http://www.gnu.org/software/make/manual/make.html#Value-Function |
| 796 | type funcValue struct{ fclosure } |
| 797 | |
| 798 | func (f *funcValue) Arity() int { return 1 } |
| 799 | func (f *funcValue) Eval(w io.Writer, ev *Evaluator) { |
| 800 | assertArity("value", 1, len(f.args)) |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 801 | v := ev.LookupVar(f.args[1].String()) |
Shinichiro Hamaji | 28ea5bc | 2015-04-11 12:41:08 +0900 | [diff] [blame] | 802 | w.Write([]byte(v.String())) |
| 803 | } |
| 804 | |
| 805 | // http://www.gnu.org/software/make/manual/make.html#Eval-Function |
| 806 | type funcEval struct{ fclosure } |
| 807 | |
| 808 | func (f *funcEval) Arity() int { return 1 } |
| 809 | func (f *funcEval) Eval(w io.Writer, ev *Evaluator) { |
| 810 | assertArity("eval", 1, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 811 | abuf := newBuf() |
| 812 | f.args[1].Eval(abuf, ev) |
| 813 | s := abuf.Bytes() |
| 814 | Log("eval %q at %s:%d", s, ev.filename, ev.lineno) |
Shinichiro Hamaji | 28ea5bc | 2015-04-11 12:41:08 +0900 | [diff] [blame] | 815 | mk, err := ParseMakefileBytes(s, ev.filename, ev.lineno) |
| 816 | if err != nil { |
| 817 | panic(err) |
| 818 | } |
| 819 | |
| 820 | for _, stmt := range mk.stmts { |
| 821 | ev.eval(stmt) |
| 822 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 823 | freeBuf(abuf) |
Shinichiro Hamaji | 28ea5bc | 2015-04-11 12:41:08 +0900 | [diff] [blame] | 824 | } |
| 825 | |
Fumitoshi Ukai | 9f6b635 | 2015-04-16 16:25:09 +0900 | [diff] [blame] | 826 | func (f *funcEval) Compact() Value { |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 827 | if len(f.args)-1 < 1 { |
| 828 | return f |
| 829 | } |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 830 | switch arg := f.args[1].(type) { |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 831 | case literal, tmpval: |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 832 | case Expr: |
| 833 | if len(arg) == 1 { |
| 834 | return f |
| 835 | } |
| 836 | switch prefix := arg[0].(type) { |
| 837 | case literal, tmpval: |
| 838 | lhs, op, rhsprefix, ok := parseAssignLiteral(prefix.String()) |
| 839 | if ok { |
| 840 | // $(eval foo = $(bar)) |
| 841 | var rhs Expr |
| 842 | if rhsprefix != literal("") { |
| 843 | rhs = append(rhs, rhsprefix) |
| 844 | } |
| 845 | rhs = append(rhs, arg[1:]...) |
| 846 | Log("eval assign %#v => lhs:%q op:%q rhs:%#v", f, lhs, op, rhs) |
| 847 | return &funcEvalAssign{ |
| 848 | lhs: lhs, |
| 849 | op: op, |
| 850 | rhs: compactExpr(rhs), |
| 851 | } |
| 852 | } |
| 853 | } |
| 854 | // TODO(ukai): eval -> varassign. e.g $(eval $(foo) := $(x)). |
Fumitoshi Ukai | 769157a | 2015-06-02 15:18:53 +0900 | [diff] [blame] | 855 | return f |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 856 | default: |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 857 | return f |
| 858 | } |
| 859 | arg := f.args[1].String() |
| 860 | arg = stripComment(arg) |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 861 | if arg == "" || strings.TrimSpace(arg) == "" { |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 862 | return &funcNop{expr: f.String()} |
| 863 | } |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 864 | f.args[1] = literal(arg) |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 865 | lhs, op, rhs, ok := parseAssignLiteral(f.args[1].String()) |
| 866 | if ok { |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 867 | return &funcEvalAssign{ |
| 868 | lhs: lhs, |
| 869 | op: op, |
| 870 | rhs: rhs, |
| 871 | } |
| 872 | } |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 873 | return f |
| 874 | } |
| 875 | |
| 876 | func stripComment(arg string) string { |
| 877 | for { |
| 878 | i := strings.Index(arg, "#") |
| 879 | if i < 0 { |
| 880 | return arg |
| 881 | } |
| 882 | eol := strings.Index(arg[i:], "\n") |
| 883 | if eol < 0 { |
| 884 | return arg[:i] |
| 885 | } |
| 886 | arg = arg[:i] + arg[eol+1:] |
| 887 | } |
| 888 | } |
| 889 | |
| 890 | type funcNop struct{ expr string } |
| 891 | |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 892 | func (f *funcNop) String() string { return f.expr } |
| 893 | func (f *funcNop) Eval(io.Writer, *Evaluator) {} |
Shinichiro Hamaji | c8bc731 | 2015-04-28 02:48:03 +0900 | [diff] [blame] | 894 | func (f *funcNop) Serialize() SerializableVar { |
| 895 | return SerializableVar{ |
| 896 | Type: "funcNop", |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 897 | V: f.expr, |
Shinichiro Hamaji | c8bc731 | 2015-04-28 02:48:03 +0900 | [diff] [blame] | 898 | } |
| 899 | } |
Shinichiro Hamaji | 723f56a | 2015-05-15 17:12:55 +0900 | [diff] [blame] | 900 | func (f *funcNop) Dump(w io.Writer) { |
| 901 | dumpByte(w, VALUE_TYPE_NOP) |
| 902 | } |
Fumitoshi Ukai | da7f255 | 2015-04-16 13:33:37 +0900 | [diff] [blame] | 903 | |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 904 | func parseAssignLiteral(s string) (lhs, op string, rhs Value, ok bool) { |
| 905 | eq := strings.Index(s, "=") |
| 906 | if eq < 0 { |
| 907 | return "", "", nil, false |
| 908 | } |
| 909 | // TODO(ukai): factor out parse assign? |
| 910 | lhs = s[:eq] |
| 911 | op = s[eq : eq+1] |
| 912 | if eq >= 1 && (s[eq-1] == ':' || s[eq-1] == '+' || s[eq-1] == '?') { |
| 913 | lhs = s[:eq-1] |
| 914 | op = s[eq-1 : eq+1] |
| 915 | } |
| 916 | lhs = strings.TrimSpace(lhs) |
| 917 | if strings.IndexAny(lhs, ":$") >= 0 { |
| 918 | // target specific var, or need eval. |
| 919 | return "", "", nil, false |
| 920 | } |
| 921 | r := strings.TrimLeft(s[eq+1:], " \t") |
| 922 | rhs = literal(r) |
| 923 | return lhs, op, rhs, true |
| 924 | } |
| 925 | |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 926 | type funcEvalAssign struct { |
| 927 | lhs string |
| 928 | op string |
| 929 | rhs Value |
| 930 | } |
| 931 | |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 932 | func (f *funcEvalAssign) String() string { |
| 933 | return fmt.Sprintf("$(eval %s %s %s)", f.lhs, f.op, f.rhs) |
| 934 | } |
| 935 | |
| 936 | func (f *funcEvalAssign) Eval(w io.Writer, ev *Evaluator) { |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 937 | var abuf bytes.Buffer |
| 938 | f.rhs.Eval(&abuf, ev) |
| 939 | rhs := trimLeftSpaceBytes(abuf.Bytes()) |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 940 | var rvalue Var |
| 941 | switch f.op { |
| 942 | case ":=": |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 943 | // TODO(ukai): compute parsed expr in Compact when f.rhs is |
| 944 | // literal? e.g. literal("$(foo)") => varref{literal("foo")}. |
Fumitoshi Ukai | fa5e922 | 2015-04-17 11:45:20 +0900 | [diff] [blame] | 945 | expr, _, err := parseExpr(rhs, nil) |
| 946 | if err != nil { |
| 947 | panic(fmt.Sprintf("eval assign error: %q: %v", f.String(), err)) |
| 948 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 949 | abuf.Reset() |
| 950 | expr.Eval(&abuf, ev) |
| 951 | rvalue = SimpleVar{value: tmpval(abuf.Bytes()), origin: "file"} |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 952 | case "=": |
| 953 | rvalue = RecursiveVar{expr: tmpval(rhs), origin: "file"} |
| 954 | case "+=": |
| 955 | prev := ev.LookupVar(f.lhs) |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 956 | if prev.IsDefined() { |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 957 | rvalue = prev.Append(ev, string(rhs)) |
| 958 | } else { |
| 959 | rvalue = RecursiveVar{expr: tmpval(rhs), origin: "file"} |
| 960 | } |
| 961 | case "?=": |
| 962 | prev := ev.LookupVar(f.lhs) |
| 963 | if prev.IsDefined() { |
| 964 | return |
| 965 | } |
| 966 | rvalue = RecursiveVar{expr: tmpval(rhs), origin: "file"} |
| 967 | } |
Fumitoshi Ukai | d8cec17 | 2015-04-28 00:08:09 +0900 | [diff] [blame] | 968 | Log("Eval ASSIGN: %s=%q (flavor:%q)", f.lhs, rvalue, rvalue.Flavor()) |
Fumitoshi Ukai | 150c861 | 2015-04-16 15:35:44 +0900 | [diff] [blame] | 969 | ev.outVars.Assign(f.lhs, rvalue) |
| 970 | } |
| 971 | |
Shinichiro Hamaji | c8bc731 | 2015-04-28 02:48:03 +0900 | [diff] [blame] | 972 | func (f *funcEvalAssign) Serialize() SerializableVar { |
| 973 | return SerializableVar{ |
| 974 | Type: "funcEvalAssign", |
| 975 | Children: []SerializableVar{ |
| 976 | SerializableVar{V: f.lhs}, |
| 977 | SerializableVar{V: f.op}, |
| 978 | f.rhs.Serialize(), |
| 979 | }, |
| 980 | } |
| 981 | } |
| 982 | |
Shinichiro Hamaji | 723f56a | 2015-05-15 17:12:55 +0900 | [diff] [blame] | 983 | func (f *funcEvalAssign) Dump(w io.Writer) { |
| 984 | dumpByte(w, VALUE_TYPE_ASSIGN) |
| 985 | dumpString(w, f.lhs) |
| 986 | dumpString(w, f.op) |
| 987 | f.rhs.Dump(w) |
| 988 | } |
| 989 | |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 990 | // http://www.gnu.org/software/make/manual/make.html#Origin-Function |
| 991 | type funcOrigin struct{ fclosure } |
| 992 | |
| 993 | func (f *funcOrigin) Arity() int { return 1 } |
| 994 | func (f *funcOrigin) Eval(w io.Writer, ev *Evaluator) { |
| 995 | assertArity("origin", 1, len(f.args)) |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 996 | v := ev.LookupVar(f.args[1].String()) |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 997 | w.Write([]byte(v.Origin())) |
| 998 | } |
| 999 | |
| 1000 | // https://www.gnu.org/software/make/manual/html_node/Flavor-Function.html#Flavor-Function |
| 1001 | type funcFlavor struct{ fclosure } |
| 1002 | |
| 1003 | func (f *funcFlavor) Arity() int { return 1 } |
| 1004 | func (f *funcFlavor) Eval(w io.Writer, ev *Evaluator) { |
| 1005 | assertArity("flavor", 1, len(f.args)) |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 1006 | v := ev.LookupVar(f.args[1].String()) |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 1007 | w.Write([]byte(v.Flavor())) |
| 1008 | } |
| 1009 | |
| 1010 | // http://www.gnu.org/software/make/manual/make.html#Make-Control-Functions |
| 1011 | type funcInfo struct{ fclosure } |
| 1012 | |
| 1013 | func (f *funcInfo) Arity() int { return 1 } |
| 1014 | func (f *funcInfo) Eval(w io.Writer, ev *Evaluator) { |
| 1015 | assertArity("info", 1, len(f.args)) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1016 | if ev.avoidIO { |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 1017 | w.Write([]byte("KATI_TODO(info)")) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1018 | ev.hasIO = true |
| 1019 | return |
| 1020 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1021 | abuf := newBuf() |
| 1022 | f.args[1].Eval(abuf, ev) |
| 1023 | fmt.Printf("%s\n", abuf.String()) |
| 1024 | freeBuf(abuf) |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 1025 | } |
| 1026 | |
| 1027 | type funcWarning struct{ fclosure } |
| 1028 | |
| 1029 | func (f *funcWarning) Arity() int { return 1 } |
| 1030 | func (f *funcWarning) Eval(w io.Writer, ev *Evaluator) { |
| 1031 | assertArity("warning", 1, len(f.args)) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1032 | if ev.avoidIO { |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 1033 | w.Write([]byte("KATI_TODO(warning)")) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1034 | ev.hasIO = true |
| 1035 | return |
| 1036 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1037 | abuf := newBuf() |
| 1038 | f.args[1].Eval(abuf, ev) |
| 1039 | fmt.Printf("%s:%d: %s\n", ev.filename, ev.lineno, abuf.String()) |
| 1040 | freeBuf(abuf) |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 1041 | } |
| 1042 | |
| 1043 | type funcError struct{ fclosure } |
| 1044 | |
| 1045 | func (f *funcError) Arity() int { return 1 } |
| 1046 | func (f *funcError) Eval(w io.Writer, ev *Evaluator) { |
| 1047 | assertArity("error", 1, len(f.args)) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1048 | if ev.avoidIO { |
Shinichiro Hamaji | 8b6487f | 2015-05-26 16:21:47 +0900 | [diff] [blame] | 1049 | w.Write([]byte("KATI_TODO(error)")) |
Shinichiro Hamaji | b41fd50 | 2015-04-29 03:34:07 +0900 | [diff] [blame] | 1050 | ev.hasIO = true |
| 1051 | return |
| 1052 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1053 | abuf := newBuf() |
| 1054 | f.args[1].Eval(abuf, ev) |
| 1055 | Error(ev.filename, ev.lineno, "*** %s.", abuf.String()) |
| 1056 | freeBuf(abuf) |
Shinichiro Hamaji | 916f35f | 2015-04-11 12:46:19 +0900 | [diff] [blame] | 1057 | } |
| 1058 | |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1059 | // http://www.gnu.org/software/make/manual/make.html#Foreach-Function |
| 1060 | type funcForeach struct{ fclosure } |
| 1061 | |
| 1062 | func (f *funcForeach) Arity() int { return 3 } |
| 1063 | |
| 1064 | func (f *funcForeach) Eval(w io.Writer, ev *Evaluator) { |
| 1065 | assertArity("foreach", 3, len(f.args)) |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1066 | abuf := newBuf() |
| 1067 | fargs := ev.args(abuf, f.args[1], f.args[2]) |
| 1068 | varname := string(fargs[0]) |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 1069 | ws := newWordScanner(fargs[1]) |
Fumitoshi Ukai | b2670d9 | 2015-04-16 10:28:27 +0900 | [diff] [blame] | 1070 | text := f.args[3] |
Fumitoshi Ukai | 9b10ecf | 2015-04-15 17:45:50 +0900 | [diff] [blame] | 1071 | restore := ev.outVars.save(varname) |
| 1072 | defer restore() |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1073 | space := false |
Fumitoshi Ukai | 9da19f6 | 2015-05-08 14:39:08 +0900 | [diff] [blame] | 1074 | for ws.Scan() { |
| 1075 | word := ws.Bytes() |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1076 | ev.outVars.Assign(varname, |
| 1077 | SimpleVar{ |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1078 | value: tmpval(word), |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1079 | origin: "automatic", |
| 1080 | }) |
| 1081 | if space { |
| 1082 | w.Write([]byte{' '}) |
| 1083 | } |
Fumitoshi Ukai | e27a25d | 2015-04-18 00:31:01 +0900 | [diff] [blame] | 1084 | text.Eval(w, ev) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1085 | space = true |
| 1086 | } |
Fumitoshi Ukai | b06cd9d | 2015-05-07 12:56:12 +0900 | [diff] [blame] | 1087 | freeBuf(abuf) |
Fumitoshi Ukai | d2bcf66 | 2015-04-11 01:02:27 +0900 | [diff] [blame] | 1088 | } |