blob: ebb463b0992f925ec1d0b0aff5b4ffb4e8d54ac8 [file] [log] [blame]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001// Copyright 2021 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Convert makefile containing device configuration to Starlark file
16// The conversion can handle the following constructs in a makefile:
17// * comments
18// * simple variable assignments
19// * $(call init-product,<file>)
20// * $(call inherit-product-if-exists
21// * if directives
22// All other constructs are carried over to the output starlark file as comments.
23//
24package mk2rbc
25
26import (
27 "bytes"
28 "fmt"
29 "io"
Sasha Smundak6609ba72021-07-22 18:32:56 -070030 "io/fs"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080031 "io/ioutil"
32 "os"
33 "path/filepath"
34 "regexp"
35 "strconv"
36 "strings"
37 "text/scanner"
38
39 mkparser "android/soong/androidmk/parser"
40)
41
42const (
Sasha Smundak6d852dd2021-09-27 20:34:39 -070043 annotationCommentPrefix = "RBC#"
44 baseUri = "//build/make/core:product_config.rbc"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080045 // The name of the struct exported by the product_config.rbc
46 // that contains the functions and variables available to
47 // product configuration Starlark files.
48 baseName = "rblf"
49
Sasha Smundak65b547e2021-09-17 15:35:41 -070050 soongNsPrefix = "SOONG_CONFIG_"
51
Sasha Smundakb051c4e2020-11-05 20:45:07 -080052 // And here are the functions and variables:
53 cfnGetCfg = baseName + ".cfg"
54 cfnMain = baseName + ".product_configuration"
Cole Faust6ed7cb42021-10-07 17:08:46 -070055 cfnBoardMain = baseName + ".board_configuration"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080056 cfnPrintVars = baseName + ".printvars"
57 cfnWarning = baseName + ".warning"
58 cfnLocalAppend = baseName + ".local_append"
59 cfnLocalSetDefault = baseName + ".local_set_default"
60 cfnInherit = baseName + ".inherit"
61 cfnSetListDefault = baseName + ".setdefault"
62)
63
64const (
Cole Faust9ebf6e42021-12-13 14:08:34 -080065 soongConfigAppend = "soong_config_append"
66 soongConfigAssign = "soong_config_set"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080067)
68
Cole Faust9ebf6e42021-12-13 14:08:34 -080069var knownFunctions = map[string]interface {
70 parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -080071}{
Cole Faust9ebf6e42021-12-13 14:08:34 -080072 "abspath": &simpleCallParser{name: baseName + ".abspath", returnType: starlarkTypeString, addGlobals: false},
73 "add_soong_config_namespace": &simpleCallParser{name: baseName + ".soong_config_namespace", returnType: starlarkTypeVoid, addGlobals: true},
74 "add_soong_config_var_value": &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
75 soongConfigAssign: &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
76 soongConfigAppend: &simpleCallParser{name: baseName + ".soong_config_append", returnType: starlarkTypeVoid, addGlobals: true},
77 "soong_config_get": &simpleCallParser{name: baseName + ".soong_config_get", returnType: starlarkTypeString, addGlobals: true},
78 "add-to-product-copy-files-if-exists": &simpleCallParser{name: baseName + ".copy_if_exists", returnType: starlarkTypeList, addGlobals: false},
79 "addprefix": &simpleCallParser{name: baseName + ".addprefix", returnType: starlarkTypeList, addGlobals: false},
80 "addsuffix": &simpleCallParser{name: baseName + ".addsuffix", returnType: starlarkTypeList, addGlobals: false},
81 "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList, addGlobals: false},
82 "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeList, addGlobals: false},
83 "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true},
84 "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addGlobals: false},
85 "error": &makeControlFuncParser{name: baseName + ".mkerror"},
86 "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt, addGlobals: false},
87 "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList, addGlobals: false},
88 "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList, addGlobals: false},
89 "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList, addGlobals: false},
90 "firstword": &firstOrLastwordCallParser{isLastWord: false},
91 "foreach": &foreachCallPaser{},
92 "if": &ifCallParser{},
93 "info": &makeControlFuncParser{name: baseName + ".mkinfo"},
Cole Faustb2e0b602022-01-07 15:46:58 -080094 "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
Cole Faust9ebf6e42021-12-13 14:08:34 -080095 "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
Cole Faustb2e0b602022-01-07 15:46:58 -080096 "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
Cole Faust9ebf6e42021-12-13 14:08:34 -080097 "is-board-platform-in-list2": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
98 "is-product-in-list": &isProductInListCallParser{},
99 "is-vendor-board-platform": &isVendorBoardPlatformCallParser{},
100 "is-vendor-board-qcom": &isVendorBoardQcomCallParser{},
101 "lastword": &firstOrLastwordCallParser{isLastWord: true},
102 "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString, addGlobals: false},
Cole Faustb1103e22022-01-06 15:22:05 -0800103 "math_max": &mathMaxOrMinCallParser{function: "max"},
104 "math_min": &mathMaxOrMinCallParser{function: "min"},
105 "math_gt_or_eq": &mathComparisonCallParser{op: ">="},
106 "math_gt": &mathComparisonCallParser{op: ">"},
107 "math_lt": &mathComparisonCallParser{op: "<"},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800108 "my-dir": &myDirCallParser{},
109 "patsubst": &substCallParser{fname: "patsubst"},
110 "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList, addGlobals: false},
111 "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addGlobals: false},
112 "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addGlobals: false},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800113 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Cole Faust9ebf6e42021-12-13 14:08:34 -0800114 "shell": &shellCallParser{},
115 "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString, addGlobals: false},
116 "subst": &substCallParser{fname: "subst"},
117 "warning": &makeControlFuncParser{name: baseName + ".mkwarning"},
118 "word": &wordCallParser{},
119 "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList, addGlobals: false},
120}
121
122// These are functions that we don't implement conversions for, but
123// we allow seeing their definitions in the product config files.
124var ignoredDefines = map[string]bool{
125 "find-word-in-list": true, // internal macro
126 "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc.
127 "is-android-codename": true, // unused by product config
128 "is-android-codename-in-list": true, // unused by product config
129 "is-chipset-in-board-platform": true, // unused by product config
130 "is-chipset-prefix-in-board-platform": true, // unused by product config
131 "is-not-board-platform": true, // defined but never used
132 "is-platform-sdk-version-at-least": true, // unused by product config
133 "match-prefix": true, // internal macro
134 "match-word": true, // internal macro
135 "match-word-in-list": true, // internal macro
136 "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800137}
138
Cole Faustb0d32ab2021-12-09 14:00:59 -0800139var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800140
141// Conversion request parameters
142type Request struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800143 MkFile string // file to convert
144 Reader io.Reader // if set, read input from this stream instead
145 RootDir string // root directory path used to resolve included files
146 OutputSuffix string // generated Starlark files suffix
147 OutputDir string // if set, root of the output hierarchy
148 ErrorLogger ErrorLogger
149 TracedVariables []string // trace assignment to these variables
150 TraceCalls bool
151 SourceFS fs.FS
152 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800153}
154
Sasha Smundak7d934b92021-11-10 12:20:01 -0800155// ErrorLogger prints errors and gathers error statistics.
156// Its NewError function is called on every error encountered during the conversion.
157type ErrorLogger interface {
Sasha Smundak422b6142021-11-11 18:31:59 -0800158 NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{})
159}
160
161type ErrorLocation struct {
162 MkFile string
163 MkLine int
164}
165
166func (el ErrorLocation) String() string {
167 return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800168}
169
170// Derives module name for a given file. It is base name
171// (file name without suffix), with some characters replaced to make it a Starlark identifier
172func moduleNameForFile(mkFile string) string {
173 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
174 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700175 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
176
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800177}
178
179func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
180 r := &mkparser.MakeString{StringPos: mkString.StringPos}
181 r.Strings = append(r.Strings, mkString.Strings...)
182 r.Variables = append(r.Variables, mkString.Variables...)
183 return r
184}
185
186func isMakeControlFunc(s string) bool {
187 return s == "error" || s == "warning" || s == "info"
188}
189
190// Starlark output generation context
191type generationContext struct {
192 buf strings.Builder
193 starScript *StarlarkScript
194 indentLevel int
195 inAssignment bool
196 tracedCount int
197}
198
199func NewGenerateContext(ss *StarlarkScript) *generationContext {
200 return &generationContext{starScript: ss}
201}
202
203// emit returns generated script
204func (gctx *generationContext) emit() string {
205 ss := gctx.starScript
206
207 // The emitted code has the following layout:
208 // <initial comments>
209 // preamble, i.e.,
210 // load statement for the runtime support
211 // load statement for each unique submodule pulled in by this one
212 // def init(g, handle):
213 // cfg = rblf.cfg(handle)
214 // <statements>
215 // <warning if conversion was not clean>
216
217 iNode := len(ss.nodes)
218 for i, node := range ss.nodes {
219 if _, ok := node.(*commentNode); !ok {
220 iNode = i
221 break
222 }
223 node.emit(gctx)
224 }
225
226 gctx.emitPreamble()
227
228 gctx.newLine()
229 // The arguments passed to the init function are the global dictionary
230 // ('g') and the product configuration dictionary ('cfg')
231 gctx.write("def init(g, handle):")
232 gctx.indentLevel++
233 if gctx.starScript.traceCalls {
234 gctx.newLine()
235 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
236 }
237 gctx.newLine()
238 gctx.writef("cfg = %s(handle)", cfnGetCfg)
239 for _, node := range ss.nodes[iNode:] {
240 node.emit(gctx)
241 }
242
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800243 if gctx.starScript.traceCalls {
244 gctx.newLine()
245 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
246 }
247 gctx.indentLevel--
248 gctx.write("\n")
249 return gctx.buf.String()
250}
251
252func (gctx *generationContext) emitPreamble() {
253 gctx.newLine()
254 gctx.writef("load(%q, %q)", baseUri, baseName)
255 // Emit exactly one load statement for each URI.
256 loadedSubConfigs := make(map[string]string)
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800257 for _, mi := range gctx.starScript.inherited {
258 uri := mi.path
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800259 if m, ok := loadedSubConfigs[uri]; ok {
260 // No need to emit load statement, but fix module name.
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800261 mi.moduleLocalName = m
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800262 continue
263 }
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800264 if mi.optional || mi.missing {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800265 uri += "|init"
266 }
267 gctx.newLine()
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800268 gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName())
269 loadedSubConfigs[uri] = mi.moduleLocalName
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800270 }
271 gctx.write("\n")
272}
273
274func (gctx *generationContext) emitPass() {
275 gctx.newLine()
276 gctx.write("pass")
277}
278
279func (gctx *generationContext) write(ss ...string) {
280 for _, s := range ss {
281 gctx.buf.WriteString(s)
282 }
283}
284
285func (gctx *generationContext) writef(format string, args ...interface{}) {
286 gctx.write(fmt.Sprintf(format, args...))
287}
288
289func (gctx *generationContext) newLine() {
290 if gctx.buf.Len() == 0 {
291 return
292 }
293 gctx.write("\n")
294 gctx.writef("%*s", 2*gctx.indentLevel, "")
295}
296
Sasha Smundak422b6142021-11-11 18:31:59 -0800297func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) {
298 gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message)
299}
300
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800301func (gctx *generationContext) emitLoadCheck(im inheritedModule) {
302 if !im.needsLoadCheck() {
303 return
304 }
305 gctx.newLine()
306 gctx.writef("if not %s:", im.entryName())
307 gctx.indentLevel++
308 gctx.newLine()
309 gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`)
310 im.pathExpr().emit(gctx)
311 gctx.write("))")
312 gctx.indentLevel--
313}
314
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800315type knownVariable struct {
316 name string
317 class varClass
318 valueType starlarkType
319}
320
321type knownVariables map[string]knownVariable
322
323func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
324 v, exists := pcv[name]
325 if !exists {
326 pcv[name] = knownVariable{name, varClass, valueType}
327 return
328 }
329 // Conflict resolution:
330 // * config class trumps everything
331 // * any type trumps unknown type
332 match := varClass == v.class
333 if !match {
334 if varClass == VarClassConfig {
335 v.class = VarClassConfig
336 match = true
337 } else if v.class == VarClassConfig {
338 match = true
339 }
340 }
341 if valueType != v.valueType {
342 if valueType != starlarkTypeUnknown {
343 if v.valueType == starlarkTypeUnknown {
344 v.valueType = valueType
345 } else {
346 match = false
347 }
348 }
349 }
350 if !match {
351 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
352 name, varClass, valueType, v.class, v.valueType)
353 }
354}
355
356// All known product variables.
357var KnownVariables = make(knownVariables)
358
359func init() {
360 for _, kv := range []string{
361 // Kernel-related variables that we know are lists.
362 "BOARD_VENDOR_KERNEL_MODULES",
363 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
364 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
365 "BOARD_RECOVERY_KERNEL_MODULES",
366 // Other variables we knwo are lists
367 "ART_APEX_JARS",
368 } {
369 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
370 }
371}
372
373type nodeReceiver interface {
374 newNode(node starlarkNode)
375}
376
377// Information about the generated Starlark script.
378type StarlarkScript struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800379 mkFile string
380 moduleName string
381 mkPos scanner.Position
382 nodes []starlarkNode
383 inherited []*moduleInfo
384 hasErrors bool
385 topDir string
386 traceCalls bool // print enter/exit each init function
387 sourceFS fs.FS
388 makefileFinder MakefileFinder
389 nodeLocator func(pos mkparser.Pos) int
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800390}
391
392func (ss *StarlarkScript) newNode(node starlarkNode) {
393 ss.nodes = append(ss.nodes, node)
394}
395
396// varAssignmentScope points to the last assignment for each variable
397// in the current block. It is used during the parsing to chain
398// the assignments to a variable together.
399type varAssignmentScope struct {
400 outer *varAssignmentScope
401 vars map[string]*assignmentNode
402}
403
404// parseContext holds the script we are generating and all the ephemeral data
405// needed during the parsing.
406type parseContext struct {
407 script *StarlarkScript
408 nodes []mkparser.Node // Makefile as parsed by mkparser
409 currentNodeIndex int // Node in it we are processing
410 ifNestLevel int
411 moduleNameCount map[string]int // count of imported modules with given basename
412 fatalError error
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800413 outputSuffix string
Sasha Smundak7d934b92021-11-10 12:20:01 -0800414 errorLogger ErrorLogger
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800415 tracedVariables map[string]bool // variables to be traced in the generated script
416 variables map[string]variable
417 varAssignments *varAssignmentScope
418 receiver nodeReceiver // receptacle for the generated starlarkNode's
419 receiverStack []nodeReceiver
420 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700421 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700422 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700423 includeTops []string
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800424}
425
426func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700427 topdir, _ := filepath.Split(filepath.Join(ss.topDir, "foo"))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800428 predefined := []struct{ name, value string }{
429 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
430 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Sasha Smundak6609ba72021-07-22 18:32:56 -0700431 {"TOPDIR", topdir},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800432 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
433 {"TARGET_COPY_OUT_SYSTEM", "system"},
434 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
435 {"TARGET_COPY_OUT_DATA", "data"},
436 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
437 {"TARGET_COPY_OUT_OEM", "oem"},
438 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
439 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
440 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
441 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
442 {"TARGET_COPY_OUT_ROOT", "root"},
443 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800444 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800445 // TODO(asmundak): to process internal config files, we need the following variables:
446 // BOARD_CONFIG_VENDOR_PATH
447 // TARGET_VENDOR
448 // target_base_product
449 //
450
451 // the following utility variables are set in build/make/common/core.mk:
452 {"empty", ""},
453 {"space", " "},
454 {"comma", ","},
455 {"newline", "\n"},
456 {"pound", "#"},
457 {"backslash", "\\"},
458 }
459 ctx := &parseContext{
460 script: ss,
461 nodes: nodes,
462 currentNodeIndex: 0,
463 ifNestLevel: 0,
464 moduleNameCount: make(map[string]int),
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800465 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700466 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700467 soongNamespaces: make(map[string]map[string]bool),
Cole Faust6c934f62022-01-06 15:51:12 -0800468 includeTops: []string{},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800469 }
470 ctx.pushVarAssignments()
471 for _, item := range predefined {
472 ctx.variables[item.name] = &predefinedVariable{
473 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
474 value: &stringLiteralExpr{item.value},
475 }
476 }
477
478 return ctx
479}
480
481func (ctx *parseContext) lastAssignment(name string) *assignmentNode {
482 for va := ctx.varAssignments; va != nil; va = va.outer {
483 if v, ok := va.vars[name]; ok {
484 return v
485 }
486 }
487 return nil
488}
489
490func (ctx *parseContext) setLastAssignment(name string, asgn *assignmentNode) {
491 ctx.varAssignments.vars[name] = asgn
492}
493
494func (ctx *parseContext) pushVarAssignments() {
495 va := &varAssignmentScope{
496 outer: ctx.varAssignments,
497 vars: make(map[string]*assignmentNode),
498 }
499 ctx.varAssignments = va
500}
501
502func (ctx *parseContext) popVarAssignments() {
503 ctx.varAssignments = ctx.varAssignments.outer
504}
505
506func (ctx *parseContext) pushReceiver(rcv nodeReceiver) {
507 ctx.receiverStack = append(ctx.receiverStack, ctx.receiver)
508 ctx.receiver = rcv
509}
510
511func (ctx *parseContext) popReceiver() {
512 last := len(ctx.receiverStack) - 1
513 if last < 0 {
514 panic(fmt.Errorf("popReceiver: receiver stack empty"))
515 }
516 ctx.receiver = ctx.receiverStack[last]
517 ctx.receiverStack = ctx.receiverStack[0:last]
518}
519
520func (ctx *parseContext) hasNodes() bool {
521 return ctx.currentNodeIndex < len(ctx.nodes)
522}
523
524func (ctx *parseContext) getNode() mkparser.Node {
525 if !ctx.hasNodes() {
526 return nil
527 }
528 node := ctx.nodes[ctx.currentNodeIndex]
529 ctx.currentNodeIndex++
530 return node
531}
532
533func (ctx *parseContext) backNode() {
534 if ctx.currentNodeIndex <= 0 {
535 panic("Cannot back off")
536 }
537 ctx.currentNodeIndex--
538}
539
540func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) {
541 // Handle only simple variables
542 if !a.Name.Const() {
543 ctx.errorf(a, "Only simple variables are handled")
544 return
545 }
546 name := a.Name.Strings[0]
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800547 // The `override` directive
548 // override FOO :=
549 // is parsed as an assignment to a variable named `override FOO`.
550 // There are very few places where `override` is used, just flag it.
551 if strings.HasPrefix(name, "override ") {
552 ctx.errorf(a, "cannot handle override directive")
553 }
554
Cole Faustc00184e2021-11-08 12:08:57 -0800555 // Soong configuration
Sasha Smundak3deb9682021-07-26 18:42:25 -0700556 if strings.HasPrefix(name, soongNsPrefix) {
557 ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
558 return
559 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800560 lhs := ctx.addVariable(name)
561 if lhs == nil {
562 ctx.errorf(a, "unknown variable %s", name)
563 return
564 }
565 _, isTraced := ctx.tracedVariables[name]
Sasha Smundak422b6142021-11-11 18:31:59 -0800566 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800567 if lhs.valueType() == starlarkTypeUnknown {
568 // Try to divine variable type from the RHS
569 asgn.value = ctx.parseMakeString(a, a.Value)
570 if xBad, ok := asgn.value.(*badExpr); ok {
571 ctx.wrapBadExpr(xBad)
572 return
573 }
574 inferred_type := asgn.value.typ()
575 if inferred_type != starlarkTypeUnknown {
Sasha Smundak9d011ab2021-07-09 16:00:57 -0700576 lhs.setValueType(inferred_type)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800577 }
578 }
579 if lhs.valueType() == starlarkTypeList {
580 xConcat := ctx.buildConcatExpr(a)
581 if xConcat == nil {
582 return
583 }
584 switch len(xConcat.items) {
585 case 0:
586 asgn.value = &listExpr{}
587 case 1:
588 asgn.value = xConcat.items[0]
589 default:
590 asgn.value = xConcat
591 }
592 } else {
593 asgn.value = ctx.parseMakeString(a, a.Value)
594 if xBad, ok := asgn.value.(*badExpr); ok {
595 ctx.wrapBadExpr(xBad)
596 return
597 }
598 }
599
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800600 asgn.previous = ctx.lastAssignment(name)
601 ctx.setLastAssignment(name, asgn)
602 switch a.Type {
603 case "=", ":=":
604 asgn.flavor = asgnSet
605 case "+=":
606 if asgn.previous == nil && !asgn.lhs.isPreset() {
607 asgn.flavor = asgnMaybeAppend
608 } else {
609 asgn.flavor = asgnAppend
610 }
611 case "?=":
612 asgn.flavor = asgnMaybeSet
613 default:
614 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
615 }
616
617 ctx.receiver.newNode(asgn)
618}
619
Sasha Smundak3deb9682021-07-26 18:42:25 -0700620func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) {
621 val := ctx.parseMakeString(asgn, asgn.Value)
622 if xBad, ok := val.(*badExpr); ok {
623 ctx.wrapBadExpr(xBad)
624 return
625 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700626
627 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
628 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
629 // Try to divine the call from the assignment as follows:
630 if name == "NAMESPACES" {
631 // Upon seeng
632 // SOONG_CONFIG_NAMESPACES += foo
633 // remember that there is a namespace `foo` and act as we saw
634 // $(call add_soong_config_namespace,foo)
635 s, ok := maybeString(val)
636 if !ok {
637 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")
638 return
639 }
640 for _, ns := range strings.Fields(s) {
641 ctx.addSoongNamespace(ns)
642 ctx.receiver.newNode(&exprNode{&callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -0800643 name: baseName + ".soong_config_namespace",
644 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700645 returnType: starlarkTypeVoid,
646 }})
647 }
648 } else {
649 // Upon seeing
650 // SOONG_CONFIG_x_y = v
651 // find a namespace called `x` and act as if we encountered
Cole Faustc00184e2021-11-08 12:08:57 -0800652 // $(call soong_config_set,x,y,v)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700653 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
654 // it.
655 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
656 // and `foo` with a variable `bar_baz`.
657 namespaceName := ""
658 if ctx.hasSoongNamespace(name) {
659 namespaceName = name
660 }
661 var varName string
662 for pos, ch := range name {
663 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
664 continue
665 }
666 if namespaceName != "" {
667 ctx.errorf(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])
668 return
669 }
670 namespaceName = name[0:pos]
671 varName = name[pos+1:]
672 }
673 if namespaceName == "" {
674 ctx.errorf(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")
675 return
676 }
677 if varName == "" {
678 // Remember variables in this namespace
679 s, ok := maybeString(val)
680 if !ok {
681 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")
682 return
683 }
684 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
685 return
686 }
687
688 // Finally, handle assignment to a namespace variable
689 if !ctx.hasNamespaceVar(namespaceName, varName) {
690 ctx.errorf(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)
691 return
692 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800693 fname := baseName + "." + soongConfigAssign
Sasha Smundak65b547e2021-09-17 15:35:41 -0700694 if asgn.Type == "+=" {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800695 fname = baseName + "." + soongConfigAppend
Sasha Smundak65b547e2021-09-17 15:35:41 -0700696 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700697 ctx.receiver.newNode(&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700698 name: fname,
Cole Faust9ebf6e42021-12-13 14:08:34 -0800699 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700700 returnType: starlarkTypeVoid,
701 }})
702 }
703}
704
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800705func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) *concatExpr {
706 xConcat := &concatExpr{}
707 var xItemList *listExpr
708 addToItemList := func(x ...starlarkExpr) {
709 if xItemList == nil {
710 xItemList = &listExpr{[]starlarkExpr{}}
711 }
712 xItemList.items = append(xItemList.items, x...)
713 }
714 finishItemList := func() {
715 if xItemList != nil {
716 xConcat.items = append(xConcat.items, xItemList)
717 xItemList = nil
718 }
719 }
720
721 items := a.Value.Words()
722 for _, item := range items {
723 // A function call in RHS is supposed to return a list, all other item
724 // expressions return individual elements.
725 switch x := ctx.parseMakeString(a, item).(type) {
726 case *badExpr:
727 ctx.wrapBadExpr(x)
728 return nil
729 case *stringLiteralExpr:
730 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
731 default:
732 switch x.typ() {
733 case starlarkTypeList:
734 finishItemList()
735 xConcat.items = append(xConcat.items, x)
736 case starlarkTypeString:
737 finishItemList()
738 xConcat.items = append(xConcat.items, &callExpr{
739 object: x,
740 name: "split",
741 args: nil,
742 returnType: starlarkTypeList,
743 })
744 default:
745 addToItemList(x)
746 }
747 }
748 }
749 if xItemList != nil {
750 xConcat.items = append(xConcat.items, xItemList)
751 }
752 return xConcat
753}
754
Sasha Smundak6609ba72021-07-22 18:32:56 -0700755func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
756 modulePath := ctx.loadedModulePath(path)
757 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700758 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700759 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800760 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800761 moduleName := moduleNameForFile(path)
762 moduleLocalName := "_" + moduleName
763 n, found := ctx.moduleNameCount[moduleName]
764 if found {
765 moduleLocalName += fmt.Sprintf("%d", n)
766 }
767 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800768 _, err := fs.Stat(ctx.script.sourceFS, path)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700769 mi := &moduleInfo{
770 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800771 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800772 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700773 optional: optional,
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800774 missing: err != nil,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800775 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700776 ctx.dependentModules[modulePath] = mi
777 ctx.script.inherited = append(ctx.script.inherited, mi)
778 return mi
779}
780
781func (ctx *parseContext) handleSubConfig(
782 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule)) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700783
784 // In a simple case, the name of a module to inherit/include is known statically.
785 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700786 // Note that even if this directive loads a module unconditionally, a module may be
787 // absent without causing any harm if this directive is inside an if/else block.
788 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700789 if strings.Contains(path, "*") {
790 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
791 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700792 mi := ctx.newDependentModule(p, !moduleShouldExist)
793 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700794 }
795 } else {
796 ctx.errorf(v, "cannot glob wildcard argument")
797 }
798 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700799 mi := ctx.newDependentModule(path, !moduleShouldExist)
800 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700801 }
802 return
803 }
804
805 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
806 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
807 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
808 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
809 // We then emit the code that loads all of them, e.g.:
810 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
811 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
812 // And then inherit it as follows:
813 // _e = {
814 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
815 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
816 // if _e:
817 // rblf.inherit(handle, _e[0], _e[1])
818 //
819 var matchingPaths []string
820 varPath, ok := pathExpr.(*interpolateExpr)
821 if !ok {
822 ctx.errorf(v, "inherit-product/include argument is too complex")
823 return
824 }
825
826 pathPattern := []string{varPath.chunks[0]}
827 for _, chunk := range varPath.chunks[1:] {
828 if chunk != "" {
829 pathPattern = append(pathPattern, chunk)
830 }
831 }
Cole Faust069aba62022-01-26 17:47:33 -0800832 if pathPattern[0] == "" && len(ctx.includeTops) > 0 {
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700833 // If pattern starts from the top. restrict it to the directories where
834 // we know inherit-product uses dynamically calculated path.
835 for _, p := range ctx.includeTops {
836 pathPattern[0] = p
837 matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700838 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700839 } else {
840 matchingPaths = ctx.findMatchingPaths(pathPattern)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700841 }
842 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700843 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700844 if len(matchingPaths) > maxMatchingFiles {
845 ctx.errorf(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)
846 return
847 }
Cole Faust069aba62022-01-26 17:47:33 -0800848 if len(matchingPaths) == 1 {
849 res := inheritedStaticModule{ctx.newDependentModule(matchingPaths[0], loadAlways && ctx.ifNestLevel == 0), loadAlways}
850 processModule(res)
851 } else {
852 needsWarning := pathPattern[0] == "" && len(ctx.includeTops) == 0
853 res := inheritedDynamicModule{*varPath, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning}
854 for _, p := range matchingPaths {
855 // A product configuration files discovered dynamically may attempt to inherit
856 // from another one which does not exist in this source tree. Prevent load errors
857 // by always loading the dynamic files as optional.
858 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
859 }
860 processModule(res)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700861 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700862}
863
864func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
865 files := ctx.script.makefileFinder.Find(ctx.script.topDir)
866 if len(pattern) == 0 {
867 return files
868 }
869
870 // Create regular expression from the pattern
871 s_regexp := "^" + regexp.QuoteMeta(pattern[0])
872 for _, s := range pattern[1:] {
873 s_regexp += ".*" + regexp.QuoteMeta(s)
874 }
875 s_regexp += "$"
876 rex := regexp.MustCompile(s_regexp)
877
878 // Now match
879 var res []string
880 for _, p := range files {
881 if rex.MatchString(p) {
882 res = append(res, p)
883 }
884 }
885 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800886}
887
Cole Faust9ebf6e42021-12-13 14:08:34 -0800888func (ctx *parseContext) handleInheritModule(v mkparser.Node, args *mkparser.MakeString, loadAlways bool) {
889 args.TrimLeftSpaces()
890 args.TrimRightSpaces()
891 pathExpr := ctx.parseMakeString(v, args)
892 if _, ok := pathExpr.(*badExpr); ok {
893 ctx.errorf(v, "Unable to parse argument to inherit")
894 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700895 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700896 ctx.receiver.newNode(&inheritNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700897 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800898}
899
900func (ctx *parseContext) handleInclude(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700901 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700902 ctx.receiver.newNode(&includeNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700903 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800904}
905
906func (ctx *parseContext) handleVariable(v *mkparser.Variable) {
907 // Handle:
908 // $(call inherit-product,...)
909 // $(call inherit-product-if-exists,...)
910 // $(info xxx)
911 // $(warning xxx)
912 // $(error xxx)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800913 // $(call other-custom-functions,...)
914
915 // inherit-product(-if-exists) gets converted to a series of statements,
916 // not just a single expression like parseReference returns. So handle it
917 // separately at the beginning here.
918 if strings.HasPrefix(v.Name.Dump(), "call inherit-product,") {
919 args := v.Name.Clone()
920 args.ReplaceLiteral("call inherit-product,", "")
921 ctx.handleInheritModule(v, args, true)
922 return
923 }
924 if strings.HasPrefix(v.Name.Dump(), "call inherit-product-if-exists,") {
925 args := v.Name.Clone()
926 args.ReplaceLiteral("call inherit-product-if-exists,", "")
927 ctx.handleInheritModule(v, args, false)
928 return
929 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800930 expr := ctx.parseReference(v, v.Name)
931 switch x := expr.(type) {
932 case *callExpr:
Cole Faust9ebf6e42021-12-13 14:08:34 -0800933 ctx.receiver.newNode(&exprNode{expr})
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800934 case *badExpr:
935 ctx.wrapBadExpr(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800936 default:
937 ctx.errorf(v, "cannot handle %s", v.Dump())
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800938 }
939}
940
941func (ctx *parseContext) handleDefine(directive *mkparser.Directive) {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700942 macro_name := strings.Fields(directive.Args.Strings[0])[0]
943 // Ignore the macros that we handle
Cole Faust9ebf6e42021-12-13 14:08:34 -0800944 _, ignored := ignoredDefines[macro_name]
945 _, known := knownFunctions[macro_name]
946 if !ignored && !known {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700947 ctx.errorf(directive, "define is not supported: %s", macro_name)
948 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800949}
950
951func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) {
952 ssSwitch := &switchNode{}
953 ctx.pushReceiver(ssSwitch)
954 for ctx.processBranch(ifDirective); ctx.hasNodes() && ctx.fatalError == nil; {
955 node := ctx.getNode()
956 switch x := node.(type) {
957 case *mkparser.Directive:
958 switch x.Name {
959 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
960 ctx.processBranch(x)
961 case "endif":
962 ctx.popReceiver()
963 ctx.receiver.newNode(ssSwitch)
964 return
965 default:
966 ctx.errorf(node, "unexpected directive %s", x.Name)
967 }
968 default:
969 ctx.errorf(ifDirective, "unexpected statement")
970 }
971 }
972 if ctx.fatalError == nil {
973 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
974 }
975 ctx.popReceiver()
976}
977
978// processBranch processes a single branch (if/elseif/else) until the next directive
979// on the same level.
980func (ctx *parseContext) processBranch(check *mkparser.Directive) {
981 block := switchCase{gate: ctx.parseCondition(check)}
982 defer func() {
983 ctx.popVarAssignments()
984 ctx.ifNestLevel--
985
986 }()
987 ctx.pushVarAssignments()
988 ctx.ifNestLevel++
989
990 ctx.pushReceiver(&block)
991 for ctx.hasNodes() {
992 node := ctx.getNode()
Cole Faust591a1fe2021-11-08 15:37:57 -0800993 if d, ok := node.(*mkparser.Directive); ok {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800994 switch d.Name {
995 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
996 ctx.popReceiver()
997 ctx.receiver.newNode(&block)
998 ctx.backNode()
999 return
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001000 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001001 }
Cole Faust591a1fe2021-11-08 15:37:57 -08001002 ctx.handleSimpleStatement(node)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001003 }
1004 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
1005 ctx.popReceiver()
1006}
1007
1008func (ctx *parseContext) newIfDefinedNode(check *mkparser.Directive) (starlarkExpr, bool) {
1009 if !check.Args.Const() {
1010 return ctx.newBadExpr(check, "ifdef variable ref too complex: %s", check.Args.Dump()), false
1011 }
1012 v := ctx.addVariable(check.Args.Strings[0])
1013 return &variableDefinedExpr{v}, true
1014}
1015
1016func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
1017 switch check.Name {
1018 case "ifdef", "ifndef", "elifdef", "elifndef":
1019 v, ok := ctx.newIfDefinedNode(check)
1020 if ok && strings.HasSuffix(check.Name, "ndef") {
1021 v = &notExpr{v}
1022 }
1023 return &ifNode{
1024 isElif: strings.HasPrefix(check.Name, "elif"),
1025 expr: v,
1026 }
1027 case "ifeq", "ifneq", "elifeq", "elifneq":
1028 return &ifNode{
1029 isElif: strings.HasPrefix(check.Name, "elif"),
1030 expr: ctx.parseCompare(check),
1031 }
1032 case "else":
1033 return &elseNode{}
1034 default:
1035 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
1036 }
1037}
1038
1039func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
1040 message := fmt.Sprintf(text, args...)
1041 if ctx.errorLogger != nil {
Sasha Smundak422b6142021-11-11 18:31:59 -08001042 ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001043 }
1044 ctx.script.hasErrors = true
Sasha Smundak422b6142021-11-11 18:31:59 -08001045 return &badExpr{errorLocation: ctx.errorLocation(node), message: message}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001046}
1047
1048func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
1049 // Strip outer parentheses
1050 mkArg := cloneMakeString(cond.Args)
1051 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1052 n := len(mkArg.Strings)
1053 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1054 args := mkArg.Split(",")
1055 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1056 if len(args) != 2 {
1057 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1058 }
1059 args[0].TrimRightSpaces()
1060 args[1].TrimLeftSpaces()
1061
1062 isEq := !strings.HasSuffix(cond.Name, "neq")
Cole Faustf8320212021-11-10 15:05:07 -08001063 xLeft := ctx.parseMakeString(cond, args[0])
1064 xRight := ctx.parseMakeString(cond, args[1])
1065 if bad, ok := xLeft.(*badExpr); ok {
1066 return bad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001067 }
Cole Faustf8320212021-11-10 15:05:07 -08001068 if bad, ok := xRight.(*badExpr); ok {
1069 return bad
1070 }
1071
1072 if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok {
1073 return expr
1074 }
1075
Cole Faust9ebf6e42021-12-13 14:08:34 -08001076 var stringOperand string
1077 var otherOperand starlarkExpr
1078 if s, ok := maybeString(xLeft); ok {
1079 stringOperand = s
1080 otherOperand = xRight
1081 } else if s, ok := maybeString(xRight); ok {
1082 stringOperand = s
1083 otherOperand = xLeft
1084 }
1085
1086 not := func(expr starlarkExpr) starlarkExpr {
1087 switch typedExpr := expr.(type) {
1088 case *inExpr:
1089 typedExpr.isNot = !typedExpr.isNot
1090 return typedExpr
1091 case *eqExpr:
1092 typedExpr.isEq = !typedExpr.isEq
1093 return typedExpr
Cole Faustb1103e22022-01-06 15:22:05 -08001094 case *binaryOpExpr:
1095 switch typedExpr.op {
1096 case ">":
1097 typedExpr.op = "<="
1098 return typedExpr
1099 case "<":
1100 typedExpr.op = ">="
1101 return typedExpr
1102 case ">=":
1103 typedExpr.op = "<"
1104 return typedExpr
1105 case "<=":
1106 typedExpr.op = ">"
1107 return typedExpr
1108 default:
1109 return &notExpr{expr: expr}
1110 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001111 default:
1112 return &notExpr{expr: expr}
1113 }
1114 }
1115
1116 // If we've identified one of the operands as being a string literal, check
1117 // for some special cases we can do to simplify the resulting expression.
1118 if otherOperand != nil {
1119 if stringOperand == "" {
1120 if isEq {
1121 return not(otherOperand)
1122 } else {
1123 return otherOperand
1124 }
1125 }
1126 if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool {
1127 if !isEq {
1128 return not(otherOperand)
1129 } else {
1130 return otherOperand
1131 }
1132 }
Cole Faustb1103e22022-01-06 15:22:05 -08001133 if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt {
1134 return &eqExpr{
1135 left: otherOperand,
1136 right: &intLiteralExpr{literal: intOperand},
1137 isEq: isEq,
1138 }
1139 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001140 }
1141
Cole Faustf8320212021-11-10 15:05:07 -08001142 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001143}
1144
Cole Faustf8320212021-11-10 15:05:07 -08001145// Given an if statement's directive and the left/right starlarkExprs,
1146// check if the starlarkExprs are one of a few hardcoded special cases
1147// that can be converted to a simpler equalify expression than simply comparing
1148// the two.
1149func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr,
1150 right starlarkExpr) (starlarkExpr, bool) {
1151 isEq := !strings.HasSuffix(directive.Name, "neq")
1152
1153 // All the special cases require a call on one side and a
1154 // string literal/variable on the other. Turn the left/right variables into
1155 // call/value variables, and return false if that's not possible.
1156 var value starlarkExpr = nil
1157 call, ok := left.(*callExpr)
1158 if ok {
1159 switch right.(type) {
1160 case *stringLiteralExpr, *variableRefExpr:
1161 value = right
1162 }
1163 } else {
1164 call, _ = right.(*callExpr)
1165 switch left.(type) {
1166 case *stringLiteralExpr, *variableRefExpr:
1167 value = left
1168 }
1169 }
1170
1171 if call == nil || value == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001172 return nil, false
1173 }
Cole Faustf8320212021-11-10 15:05:07 -08001174
Cole Faustf8320212021-11-10 15:05:07 -08001175 switch call.name {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001176 case baseName + ".filter", baseName + ".filter-out":
Cole Faustf8320212021-11-10 15:05:07 -08001177 return ctx.parseCompareFilterFuncResult(directive, call, value, isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001178 case baseName + ".expand_wildcard":
Cole Faustf8320212021-11-10 15:05:07 -08001179 return ctx.parseCompareWildcardFuncResult(directive, call, value, !isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001180 case baseName + ".findstring":
Cole Faustf8320212021-11-10 15:05:07 -08001181 return ctx.parseCheckFindstringFuncResult(directive, call, value, !isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001182 case baseName + ".strip":
Cole Faustf8320212021-11-10 15:05:07 -08001183 return ctx.parseCompareStripFuncResult(directive, call, value, !isEq), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001184 }
Cole Faustf8320212021-11-10 15:05:07 -08001185 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001186}
1187
1188func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
1189 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1190 // We handle:
Sasha Smundak0554d762021-07-08 18:26:12 -07001191 // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
1192 // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001193 // * ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...) becomes if VAR in/not in ["v1", "v2"]
1194 // TODO(Asmundak): check the last case works for filter-out, too.
1195 xPattern := filterFuncCall.args[0]
1196 xText := filterFuncCall.args[1]
1197 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001198 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001199 var ok bool
1200 switch x := xValue.(type) {
1201 case *stringLiteralExpr:
1202 if x.literal != "" {
1203 return ctx.newBadExpr(cond, "filter comparison to non-empty value: %s", xValue)
1204 }
1205 // Either pattern or text should be const, and the
1206 // non-const one should be varRefExpr
Sasha Smundak5f463be2021-09-15 18:43:36 -07001207 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
Sasha Smundak0554d762021-07-08 18:26:12 -07001208 expr = xText
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001209 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
Sasha Smundak0554d762021-07-08 18:26:12 -07001210 expr = xPattern
1211 } else {
Sasha Smundak5f463be2021-09-15 18:43:36 -07001212 expr = &callExpr{
Sasha Smundak0554d762021-07-08 18:26:12 -07001213 object: nil,
1214 name: filterFuncCall.name,
1215 args: filterFuncCall.args,
1216 returnType: starlarkTypeBool,
1217 }
Sasha Smundak5f463be2021-09-15 18:43:36 -07001218 if negate {
1219 expr = &notExpr{expr: expr}
1220 }
1221 return expr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001222 }
1223 case *variableRefExpr:
1224 if v, ok := xPattern.(*variableRefExpr); ok {
1225 if xInList, ok = xText.(*stringLiteralExpr); ok && v.ref.name() == x.ref.name() {
1226 // ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...), flip negate,
1227 // it's the opposite to what is done when comparing to empty.
Sasha Smundak0554d762021-07-08 18:26:12 -07001228 expr = xPattern
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001229 negate = !negate
1230 }
1231 }
1232 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001233 if expr != nil && xInList != nil {
1234 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1235 // Generate simpler code for the common cases:
1236 if expr.typ() == starlarkTypeList {
1237 if len(slExpr.items) == 1 {
1238 // Checking that a string belongs to list
1239 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}
1240 } else {
1241 // TODO(asmundak):
1242 panic("TBD")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001243 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001244 } else if len(slExpr.items) == 1 {
1245 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}
1246 } else {
1247 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001248 }
1249 }
1250 return ctx.newBadExpr(cond, "filter arguments are too complex: %s", cond.Dump())
1251}
1252
1253func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Directive,
1254 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001255 if !isEmptyString(xValue) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001256 return ctx.newBadExpr(directive, "wildcard result can be compared only to empty: %s", xValue)
1257 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001258 callFunc := baseName + ".file_wildcard_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001259 if s, ok := xCall.args[0].(*stringLiteralExpr); ok && !strings.ContainsAny(s.literal, "*?{[") {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001260 callFunc = baseName + ".file_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001261 }
1262 var cc starlarkExpr = &callExpr{name: callFunc, args: xCall.args, returnType: starlarkTypeBool}
1263 if !negate {
1264 cc = &notExpr{cc}
1265 }
1266 return cc
1267}
1268
1269func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1270 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001271 if isEmptyString(xValue) {
1272 return &eqExpr{
1273 left: &callExpr{
1274 object: xCall.args[1],
1275 name: "find",
1276 args: []starlarkExpr{xCall.args[0]},
1277 returnType: starlarkTypeInt,
1278 },
1279 right: &intLiteralExpr{-1},
1280 isEq: !negate,
1281 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001282 } else if s, ok := maybeString(xValue); ok {
1283 if s2, ok := maybeString(xCall.args[0]); ok && s == s2 {
1284 return &eqExpr{
1285 left: &callExpr{
1286 object: xCall.args[1],
1287 name: "find",
1288 args: []starlarkExpr{xCall.args[0]},
1289 returnType: starlarkTypeInt,
1290 },
1291 right: &intLiteralExpr{-1},
1292 isEq: negate,
1293 }
1294 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001295 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001296 return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001297}
1298
1299func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1300 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1301 if _, ok := xValue.(*stringLiteralExpr); !ok {
1302 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1303 }
1304 return &eqExpr{
1305 left: &callExpr{
1306 name: "strip",
1307 args: xCall.args,
1308 returnType: starlarkTypeString,
1309 },
1310 right: xValue, isEq: !negate}
1311}
1312
1313// parses $(...), returning an expression
1314func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1315 ref.TrimLeftSpaces()
1316 ref.TrimRightSpaces()
1317 refDump := ref.Dump()
1318
1319 // Handle only the case where the first (or only) word is constant
1320 words := ref.SplitN(" ", 2)
1321 if !words[0].Const() {
1322 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1323 }
1324
1325 // If it is a single word, it can be a simple variable
1326 // reference or a function call
Cole Faust9ebf6e42021-12-13 14:08:34 -08001327 if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" {
Sasha Smundak65b547e2021-09-17 15:35:41 -07001328 if strings.HasPrefix(refDump, soongNsPrefix) {
1329 // TODO (asmundak): if we find many, maybe handle them.
Cole Faustc00184e2021-11-08 12:08:57 -08001330 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
Sasha Smundak65b547e2021-09-17 15:35:41 -07001331 }
Cole Faustc36c9622021-12-07 15:20:45 -08001332 // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html
1333 if strings.Contains(refDump, ":") {
1334 parts := strings.SplitN(refDump, ":", 2)
1335 substParts := strings.SplitN(parts[1], "=", 2)
1336 if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 {
1337 return ctx.newBadExpr(node, "Invalid substitution reference")
1338 }
1339 if !strings.Contains(substParts[0], "%") {
1340 if strings.Contains(substParts[1], "%") {
1341 return ctx.newBadExpr(node, "A substitution reference must have a %% in the \"before\" part of the substitution if it has one in the \"after\" part.")
1342 }
1343 substParts[0] = "%" + substParts[0]
1344 substParts[1] = "%" + substParts[1]
1345 }
1346 v := ctx.addVariable(parts[0])
1347 if v == nil {
1348 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1349 }
1350 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001351 name: baseName + ".mkpatsubst",
1352 returnType: starlarkTypeString,
Cole Faustc36c9622021-12-07 15:20:45 -08001353 args: []starlarkExpr{
1354 &stringLiteralExpr{literal: substParts[0]},
1355 &stringLiteralExpr{literal: substParts[1]},
Cole Faustfc438682021-12-14 12:46:32 -08001356 NewVariableRefExpr(v, ctx.lastAssignment(v.name()) != nil),
Cole Faustc36c9622021-12-07 15:20:45 -08001357 },
1358 }
1359 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001360 if v := ctx.addVariable(refDump); v != nil {
Cole Faustfc438682021-12-14 12:46:32 -08001361 return NewVariableRefExpr(v, ctx.lastAssignment(v.name()) != nil)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001362 }
1363 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1364 }
1365
1366 expr := &callExpr{name: words[0].Dump(), returnType: starlarkTypeUnknown}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001367 args := mkparser.SimpleMakeString("", words[0].Pos())
1368 if len(words) >= 2 {
1369 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001370 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001371 args.TrimLeftSpaces()
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001372 if expr.name == "call" {
1373 words = args.SplitN(",", 2)
1374 if words[0].Empty() || !words[0].Const() {
Sasha Smundakf2c9f8b2021-07-27 10:44:48 -07001375 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001376 }
1377 expr.name = words[0].Dump()
1378 if len(words) < 2 {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001379 args = &mkparser.MakeString{}
1380 } else {
1381 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001382 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001383 }
1384 if kf, found := knownFunctions[expr.name]; found {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001385 return kf.parse(ctx, node, args)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001386 } else {
1387 return ctx.newBadExpr(node, "cannot handle invoking %s", expr.name)
1388 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001389}
1390
1391type simpleCallParser struct {
1392 name string
1393 returnType starlarkType
1394 addGlobals bool
1395}
1396
1397func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1398 expr := &callExpr{name: p.name, returnType: p.returnType}
1399 if p.addGlobals {
1400 expr.args = append(expr.args, &globalsExpr{})
1401 }
1402 for _, arg := range args.Split(",") {
1403 arg.TrimLeftSpaces()
1404 arg.TrimRightSpaces()
1405 x := ctx.parseMakeString(node, arg)
1406 if xBad, ok := x.(*badExpr); ok {
1407 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001408 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001409 expr.args = append(expr.args, x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001410 }
1411 return expr
1412}
1413
Cole Faust9ebf6e42021-12-13 14:08:34 -08001414type makeControlFuncParser struct {
1415 name string
1416}
1417
1418func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1419 // Make control functions need special treatment as everything
1420 // after the name is a single text argument
1421 x := ctx.parseMakeString(node, args)
1422 if xBad, ok := x.(*badExpr); ok {
1423 return xBad
1424 }
1425 return &callExpr{
1426 name: p.name,
1427 args: []starlarkExpr{
1428 &stringLiteralExpr{ctx.script.mkFile},
1429 x,
1430 },
1431 returnType: starlarkTypeUnknown,
1432 }
1433}
1434
1435type shellCallParser struct{}
1436
1437func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1438 // Shell functions need special treatment as everything
1439 // after the name is a single text argument
1440 x := ctx.parseMakeString(node, args)
1441 if xBad, ok := x.(*badExpr); ok {
1442 return xBad
1443 }
1444 return &callExpr{
1445 name: baseName + ".shell",
1446 args: []starlarkExpr{x},
1447 returnType: starlarkTypeUnknown,
1448 }
1449}
1450
1451type myDirCallParser struct{}
1452
1453func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1454 if !args.Empty() {
1455 return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.")
1456 }
1457 return &variableRefExpr{ctx.addVariable("LOCAL_PATH"), true}
1458}
1459
Cole Faust9ebf6e42021-12-13 14:08:34 -08001460type isProductInListCallParser struct{}
1461
1462func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1463 if args.Empty() {
1464 return ctx.newBadExpr(node, "is-product-in-list requires an argument")
1465 }
1466 return &inExpr{
1467 expr: &variableRefExpr{ctx.addVariable("TARGET_PRODUCT"), true},
1468 list: maybeConvertToStringList(ctx.parseMakeString(node, args)),
1469 isNot: false,
1470 }
1471}
1472
1473type isVendorBoardPlatformCallParser struct{}
1474
1475func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1476 if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) {
1477 return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform")
1478 }
1479 return &inExpr{
1480 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1481 list: &variableRefExpr{ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS"), true},
1482 isNot: false,
1483 }
1484}
1485
1486type isVendorBoardQcomCallParser struct{}
1487
1488func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1489 if !args.Empty() {
1490 return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments")
1491 }
1492 return &inExpr{
1493 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1494 list: &variableRefExpr{ctx.addVariable("QCOM_BOARD_PLATFORMS"), true},
1495 isNot: false,
1496 }
1497}
1498
1499type substCallParser struct {
1500 fname string
1501}
1502
1503func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001504 words := args.Split(",")
1505 if len(words) != 3 {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001506 return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001507 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001508 from := ctx.parseMakeString(node, words[0])
1509 if xBad, ok := from.(*badExpr); ok {
1510 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001511 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001512 to := ctx.parseMakeString(node, words[1])
1513 if xBad, ok := to.(*badExpr); ok {
1514 return xBad
1515 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001516 words[2].TrimLeftSpaces()
1517 words[2].TrimRightSpaces()
1518 obj := ctx.parseMakeString(node, words[2])
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001519 typ := obj.typ()
Cole Faust9ebf6e42021-12-13 14:08:34 -08001520 if typ == starlarkTypeString && p.fname == "subst" {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001521 // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001522 return &callExpr{
1523 object: obj,
1524 name: "replace",
Sasha Smundak35434ed2021-11-05 16:29:56 -07001525 args: []starlarkExpr{from, to},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001526 returnType: typ,
1527 }
1528 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001529 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001530 name: baseName + ".mk" + p.fname,
Sasha Smundak35434ed2021-11-05 16:29:56 -07001531 args: []starlarkExpr{from, to, obj},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001532 returnType: obj.typ(),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001533 }
1534}
1535
Cole Faust9ebf6e42021-12-13 14:08:34 -08001536type ifCallParser struct{}
1537
1538func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faust4eadba72021-12-07 11:54:52 -08001539 words := args.Split(",")
1540 if len(words) != 2 && len(words) != 3 {
1541 return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))
1542 }
1543 condition := ctx.parseMakeString(node, words[0])
1544 ifTrue := ctx.parseMakeString(node, words[1])
1545 var ifFalse starlarkExpr
1546 if len(words) == 3 {
1547 ifFalse = ctx.parseMakeString(node, words[2])
1548 } else {
1549 switch ifTrue.typ() {
1550 case starlarkTypeList:
1551 ifFalse = &listExpr{items: []starlarkExpr{}}
1552 case starlarkTypeInt:
1553 ifFalse = &intLiteralExpr{literal: 0}
1554 case starlarkTypeBool:
1555 ifFalse = &boolLiteralExpr{literal: false}
1556 default:
1557 ifFalse = &stringLiteralExpr{literal: ""}
1558 }
1559 }
1560 return &ifExpr{
1561 condition,
1562 ifTrue,
1563 ifFalse,
1564 }
1565}
1566
Cole Faust9ebf6e42021-12-13 14:08:34 -08001567type foreachCallPaser struct{}
1568
1569func (p *foreachCallPaser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faustb0d32ab2021-12-09 14:00:59 -08001570 words := args.Split(",")
1571 if len(words) != 3 {
1572 return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))
1573 }
1574 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1575 return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier")
1576 }
1577 loopVarName := words[0].Strings[0]
1578 list := ctx.parseMakeString(node, words[1])
1579 action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr {
1580 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1581 return &identifierExpr{loopVarName}
1582 }
1583 return nil
1584 })
1585
1586 if list.typ() != starlarkTypeList {
1587 list = &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001588 name: baseName + ".words",
1589 returnType: starlarkTypeList,
Cole Faustb0d32ab2021-12-09 14:00:59 -08001590 args: []starlarkExpr{list},
1591 }
1592 }
1593
1594 return &foreachExpr{
1595 varName: loopVarName,
1596 list: list,
1597 action: action,
1598 }
1599}
1600
Cole Faust9ebf6e42021-12-13 14:08:34 -08001601type wordCallParser struct{}
1602
1603func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001604 words := args.Split(",")
1605 if len(words) != 2 {
1606 return ctx.newBadExpr(node, "word function should have 2 arguments")
1607 }
1608 var index uint64 = 0
1609 if words[0].Const() {
1610 index, _ = strconv.ParseUint(strings.TrimSpace(words[0].Strings[0]), 10, 64)
1611 }
1612 if index < 1 {
1613 return ctx.newBadExpr(node, "word index should be constant positive integer")
1614 }
1615 words[1].TrimLeftSpaces()
1616 words[1].TrimRightSpaces()
1617 array := ctx.parseMakeString(node, words[1])
1618 if xBad, ok := array.(*badExpr); ok {
1619 return xBad
1620 }
1621 if array.typ() != starlarkTypeList {
1622 array = &callExpr{object: array, name: "split", returnType: starlarkTypeList}
1623 }
Cole Faustb0d32ab2021-12-09 14:00:59 -08001624 return &indexExpr{array, &intLiteralExpr{int(index - 1)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001625}
1626
Cole Faust9ebf6e42021-12-13 14:08:34 -08001627type firstOrLastwordCallParser struct {
1628 isLastWord bool
1629}
1630
1631func (p *firstOrLastwordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundak16e07732021-07-23 11:38:23 -07001632 arg := ctx.parseMakeString(node, args)
1633 if bad, ok := arg.(*badExpr); ok {
1634 return bad
1635 }
1636 index := &intLiteralExpr{0}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001637 if p.isLastWord {
Sasha Smundak16e07732021-07-23 11:38:23 -07001638 if v, ok := arg.(*variableRefExpr); ok && v.ref.name() == "MAKEFILE_LIST" {
1639 return &stringLiteralExpr{ctx.script.mkFile}
1640 }
1641 index.literal = -1
1642 }
1643 if arg.typ() == starlarkTypeList {
1644 return &indexExpr{arg, index}
1645 }
1646 return &indexExpr{&callExpr{object: arg, name: "split", returnType: starlarkTypeList}, index}
1647}
1648
Cole Faustb1103e22022-01-06 15:22:05 -08001649func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) {
1650 parsedArgs := make([]starlarkExpr, 0)
1651 for _, arg := range args.Split(",") {
1652 expr := ctx.parseMakeString(node, arg)
1653 if expr.typ() == starlarkTypeList {
1654 return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int")
1655 }
1656 if s, ok := maybeString(expr); ok {
1657 intVal, err := strconv.Atoi(strings.TrimSpace(s))
1658 if err != nil {
1659 return nil, err
1660 }
1661 expr = &intLiteralExpr{literal: intVal}
1662 } else if expr.typ() != starlarkTypeInt {
1663 expr = &callExpr{
1664 name: "int",
1665 args: []starlarkExpr{expr},
1666 returnType: starlarkTypeInt,
1667 }
1668 }
1669 parsedArgs = append(parsedArgs, expr)
1670 }
1671 if len(parsedArgs) != expectedArgs {
1672 return nil, fmt.Errorf("function should have %d arguments", expectedArgs)
1673 }
1674 return parsedArgs, nil
1675}
1676
1677type mathComparisonCallParser struct {
1678 op string
1679}
1680
1681func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1682 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1683 if err != nil {
1684 return ctx.newBadExpr(node, err.Error())
1685 }
1686 return &binaryOpExpr{
1687 left: parsedArgs[0],
1688 right: parsedArgs[1],
1689 op: p.op,
1690 returnType: starlarkTypeBool,
1691 }
1692}
1693
1694type mathMaxOrMinCallParser struct {
1695 function string
1696}
1697
1698func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1699 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1700 if err != nil {
1701 return ctx.newBadExpr(node, err.Error())
1702 }
1703 return &callExpr{
1704 object: nil,
1705 name: p.function,
1706 args: parsedArgs,
1707 returnType: starlarkTypeInt,
1708 }
1709}
1710
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001711func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
1712 if mk.Const() {
1713 return &stringLiteralExpr{mk.Dump()}
1714 }
1715 if mkRef, ok := mk.SingleVariable(); ok {
1716 return ctx.parseReference(node, mkRef)
1717 }
1718 // If we reached here, it's neither string literal nor a simple variable,
1719 // we need a full-blown interpolation node that will generate
1720 // "a%b%c" % (X, Y) for a$(X)b$(Y)c
Cole Faustfc438682021-12-14 12:46:32 -08001721 parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings))
1722 for i := 0; i < len(parts); i++ {
1723 if i%2 == 0 {
1724 parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]}
1725 } else {
1726 parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name)
1727 if x, ok := parts[i].(*badExpr); ok {
1728 return x
1729 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001730 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001731 }
Cole Faustfc438682021-12-14 12:46:32 -08001732 return NewInterpolateExpr(parts)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001733}
1734
1735// Handles the statements whose treatment is the same in all contexts: comment,
1736// assignment, variable (which is a macro call in reality) and all constructs that
1737// do not handle in any context ('define directive and any unrecognized stuff).
Cole Faust591a1fe2021-11-08 15:37:57 -08001738func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001739 switch x := node.(type) {
1740 case *mkparser.Comment:
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001741 ctx.maybeHandleAnnotation(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001742 ctx.insertComment("#" + x.Comment)
1743 case *mkparser.Assignment:
1744 ctx.handleAssignment(x)
1745 case *mkparser.Variable:
1746 ctx.handleVariable(x)
1747 case *mkparser.Directive:
1748 switch x.Name {
1749 case "define":
1750 ctx.handleDefine(x)
1751 case "include", "-include":
1752 ctx.handleInclude(node, ctx.parseMakeString(node, x.Args), x.Name[0] != '-')
Cole Faust591a1fe2021-11-08 15:37:57 -08001753 case "ifeq", "ifneq", "ifdef", "ifndef":
1754 ctx.handleIfBlock(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001755 default:
Cole Faust591a1fe2021-11-08 15:37:57 -08001756 ctx.errorf(x, "unexpected directive %s", x.Name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001757 }
1758 default:
Sasha Smundak2afb9d72021-10-24 15:16:59 -07001759 ctx.errorf(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001760 }
Cole Faust6c934f62022-01-06 15:51:12 -08001761
1762 // Clear the includeTops after each non-comment statement
1763 // so that include annotations placed on certain statements don't apply
1764 // globally for the rest of the makefile was well.
1765 if _, wasComment := node.(*mkparser.Comment); !wasComment && len(ctx.includeTops) > 0 {
1766 ctx.includeTops = []string{}
1767 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001768}
1769
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001770// Processes annotation. An annotation is a comment that starts with #RBC# and provides
1771// a conversion hint -- say, where to look for the dynamically calculated inherit/include
1772// paths.
1773func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) {
1774 maybeTrim := func(s, prefix string) (string, bool) {
1775 if strings.HasPrefix(s, prefix) {
1776 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
1777 }
1778 return s, false
1779 }
1780 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
1781 if !ok {
1782 return
1783 }
1784 if p, ok := maybeTrim(annotation, "include_top"); ok {
Cole Faustf7ed5342021-12-21 14:15:12 -08001785 // Don't allow duplicate include tops, because then we will generate
1786 // invalid starlark code. (duplicate keys in the _entry dictionary)
1787 for _, top := range ctx.includeTops {
1788 if top == p {
1789 return
1790 }
1791 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001792 ctx.includeTops = append(ctx.includeTops, p)
1793 return
1794 }
1795 ctx.errorf(cnode, "unsupported annotation %s", cnode.Comment)
1796
1797}
1798
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001799func (ctx *parseContext) insertComment(s string) {
1800 ctx.receiver.newNode(&commentNode{strings.TrimSpace(s)})
1801}
1802
1803func (ctx *parseContext) carryAsComment(failedNode mkparser.Node) {
1804 for _, line := range strings.Split(failedNode.Dump(), "\n") {
1805 ctx.insertComment("# " + line)
1806 }
1807}
1808
1809// records that the given node failed to be converted and includes an explanatory message
1810func (ctx *parseContext) errorf(failedNode mkparser.Node, message string, args ...interface{}) {
1811 if ctx.errorLogger != nil {
Sasha Smundak422b6142021-11-11 18:31:59 -08001812 ctx.errorLogger.NewError(ctx.errorLocation(failedNode), failedNode, message, args...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001813 }
Sasha Smundak422b6142021-11-11 18:31:59 -08001814 ctx.receiver.newNode(&exprNode{ctx.newBadExpr(failedNode, message, args...)})
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001815 ctx.script.hasErrors = true
1816}
1817
1818func (ctx *parseContext) wrapBadExpr(xBad *badExpr) {
Sasha Smundak422b6142021-11-11 18:31:59 -08001819 ctx.receiver.newNode(&exprNode{xBad})
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001820}
1821
1822func (ctx *parseContext) loadedModulePath(path string) string {
1823 // During the transition to Roboleaf some of the product configuration files
1824 // will be converted and checked in while the others will be generated on the fly
1825 // and run. The runner (rbcrun application) accommodates this by allowing three
1826 // different ways to specify the loaded file location:
1827 // 1) load(":<file>",...) loads <file> from the same directory
1828 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
1829 // 3) load("/absolute/path/to/<file> absolute path
1830 // If the file being generated and the file it wants to load are in the same directory,
1831 // generate option 1.
1832 // Otherwise, if output directory is not specified, generate 2)
1833 // Finally, if output directory has been specified and the file being generated and
1834 // the file it wants to load from are in the different directories, generate 2) or 3):
1835 // * if the file being loaded exists in the source tree, generate 2)
1836 // * otherwise, generate 3)
1837 // Finally, figure out the loaded module path and name and create a node for it
1838 loadedModuleDir := filepath.Dir(path)
1839 base := filepath.Base(path)
1840 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
1841 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
1842 return ":" + loadedModuleName
1843 }
1844 if ctx.outputDir == "" {
1845 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1846 }
1847 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
1848 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1849 }
1850 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
1851}
1852
Sasha Smundak3deb9682021-07-26 18:42:25 -07001853func (ctx *parseContext) addSoongNamespace(ns string) {
1854 if _, ok := ctx.soongNamespaces[ns]; ok {
1855 return
1856 }
1857 ctx.soongNamespaces[ns] = make(map[string]bool)
1858}
1859
1860func (ctx *parseContext) hasSoongNamespace(name string) bool {
1861 _, ok := ctx.soongNamespaces[name]
1862 return ok
1863}
1864
1865func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
1866 ctx.addSoongNamespace(namespaceName)
1867 vars := ctx.soongNamespaces[namespaceName]
1868 if replace {
1869 vars = make(map[string]bool)
1870 ctx.soongNamespaces[namespaceName] = vars
1871 }
1872 for _, v := range varNames {
1873 vars[v] = true
1874 }
1875}
1876
1877func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
1878 vars, ok := ctx.soongNamespaces[namespaceName]
1879 if ok {
1880 _, ok = vars[varName]
1881 }
1882 return ok
1883}
1884
Sasha Smundak422b6142021-11-11 18:31:59 -08001885func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation {
1886 return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())}
1887}
1888
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001889func (ss *StarlarkScript) String() string {
1890 return NewGenerateContext(ss).emit()
1891}
1892
1893func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001894
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001895 var subs []string
1896 for _, src := range ss.inherited {
1897 subs = append(subs, src.originalPath)
1898 }
1899 return subs
1900}
1901
1902func (ss *StarlarkScript) HasErrors() bool {
1903 return ss.hasErrors
1904}
1905
1906// Convert reads and parses a makefile. If successful, parsed tree
1907// is returned and then can be passed to String() to get the generated
1908// Starlark file.
1909func Convert(req Request) (*StarlarkScript, error) {
1910 reader := req.Reader
1911 if reader == nil {
1912 mkContents, err := ioutil.ReadFile(req.MkFile)
1913 if err != nil {
1914 return nil, err
1915 }
1916 reader = bytes.NewBuffer(mkContents)
1917 }
1918 parser := mkparser.NewParser(req.MkFile, reader)
1919 nodes, errs := parser.Parse()
1920 if len(errs) > 0 {
1921 for _, e := range errs {
1922 fmt.Fprintln(os.Stderr, "ERROR:", e)
1923 }
1924 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
1925 }
1926 starScript := &StarlarkScript{
Sasha Smundak422b6142021-11-11 18:31:59 -08001927 moduleName: moduleNameForFile(req.MkFile),
1928 mkFile: req.MkFile,
1929 topDir: req.RootDir,
1930 traceCalls: req.TraceCalls,
1931 sourceFS: req.SourceFS,
1932 makefileFinder: req.MakefileFinder,
1933 nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line },
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001934 }
1935 ctx := newParseContext(starScript, nodes)
1936 ctx.outputSuffix = req.OutputSuffix
1937 ctx.outputDir = req.OutputDir
1938 ctx.errorLogger = req.ErrorLogger
1939 if len(req.TracedVariables) > 0 {
1940 ctx.tracedVariables = make(map[string]bool)
1941 for _, v := range req.TracedVariables {
1942 ctx.tracedVariables[v] = true
1943 }
1944 }
1945 ctx.pushReceiver(starScript)
1946 for ctx.hasNodes() && ctx.fatalError == nil {
Cole Faust591a1fe2021-11-08 15:37:57 -08001947 ctx.handleSimpleStatement(ctx.getNode())
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001948 }
1949 if ctx.fatalError != nil {
1950 return nil, ctx.fatalError
1951 }
1952 return starScript, nil
1953}
1954
Cole Faust864028a2021-12-01 13:43:17 -08001955func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001956 var buf bytes.Buffer
1957 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Cole Faust864028a2021-12-01 13:43:17 -08001958 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001959 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
Cole Faust864028a2021-12-01 13:43:17 -08001960 fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001961 return buf.String()
1962}
1963
Cole Faust6ed7cb42021-10-07 17:08:46 -07001964func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
1965 var buf bytes.Buffer
1966 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
1967 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
1968 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
1969 fmt.Fprintf(&buf, "globals, cfg, globals_base = %s(init, input_variables_init)\n", cfnBoardMain)
1970 fmt.Fprintf(&buf, "# TODO: Some product config variables need to be printed, but most are readonly so we can't just print cfg here.\n")
Cole Faust3c1868b2021-11-22 16:34:11 -08001971 fmt.Fprintf(&buf, "%s((globals, cfg, globals_base))\n", cfnPrintVars)
Cole Faust6ed7cb42021-10-07 17:08:46 -07001972 return buf.String()
1973}
1974
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001975func MakePath2ModuleName(mkPath string) string {
1976 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
1977}