blob: c3b192d44932610fbb8f0e1653c0a0c725b0516a [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:
Colin Crossd079e0b2022-08-16 10:27:33 -070017// - comments
18// - simple variable assignments
19// - $(call init-product,<file>)
20// - $(call inherit-product-if-exists
21// - if directives
Sasha Smundakb051c4e2020-11-05 20:45:07 -080022//
Colin Crossd079e0b2022-08-16 10:27:33 -070023// All other constructs are carried over to the output starlark file as comments.
Sasha Smundakb051c4e2020-11-05 20:45:07 -080024package 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"
Cole Faust62e05112022-04-05 17:56:11 -070035 "sort"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080036 "strconv"
37 "strings"
38 "text/scanner"
39
40 mkparser "android/soong/androidmk/parser"
41)
42
43const (
Sasha Smundak6d852dd2021-09-27 20:34:39 -070044 annotationCommentPrefix = "RBC#"
45 baseUri = "//build/make/core:product_config.rbc"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080046 // The name of the struct exported by the product_config.rbc
47 // that contains the functions and variables available to
48 // product configuration Starlark files.
49 baseName = "rblf"
50
Sasha Smundak65b547e2021-09-17 15:35:41 -070051 soongNsPrefix = "SOONG_CONFIG_"
52
Sasha Smundakb051c4e2020-11-05 20:45:07 -080053 // And here are the functions and variables:
Cole Fauste2a37982022-03-09 16:00:17 -080054 cfnGetCfg = baseName + ".cfg"
55 cfnMain = baseName + ".product_configuration"
56 cfnBoardMain = baseName + ".board_configuration"
57 cfnPrintVars = baseName + ".printvars"
58 cfnInherit = baseName + ".inherit"
59 cfnSetListDefault = baseName + ".setdefault"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080060)
61
62const (
Cole Faust9ebf6e42021-12-13 14:08:34 -080063 soongConfigAppend = "soong_config_append"
64 soongConfigAssign = "soong_config_set"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080065)
66
Cole Faust9ebf6e42021-12-13 14:08:34 -080067var knownFunctions = map[string]interface {
68 parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -080069}{
Cole Faust1cc08852022-02-28 11:12:08 -080070 "abspath": &simpleCallParser{name: baseName + ".abspath", returnType: starlarkTypeString},
71 "add-product-dex-preopt-module-config": &simpleCallParser{name: baseName + ".add_product_dex_preopt_module_config", returnType: starlarkTypeString, addHandle: true},
72 "add_soong_config_namespace": &simpleCallParser{name: baseName + ".soong_config_namespace", returnType: starlarkTypeVoid, addGlobals: true},
73 "add_soong_config_var_value": &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
74 soongConfigAssign: &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
75 soongConfigAppend: &simpleCallParser{name: baseName + ".soong_config_append", returnType: starlarkTypeVoid, addGlobals: true},
76 "soong_config_get": &simpleCallParser{name: baseName + ".soong_config_get", returnType: starlarkTypeString, addGlobals: true},
77 "add-to-product-copy-files-if-exists": &simpleCallParser{name: baseName + ".copy_if_exists", returnType: starlarkTypeList},
78 "addprefix": &simpleCallParser{name: baseName + ".addprefix", returnType: starlarkTypeList},
79 "addsuffix": &simpleCallParser{name: baseName + ".addsuffix", returnType: starlarkTypeList},
Cole Faustd2daabf2022-12-12 17:38:01 -080080 "and": &andOrParser{isAnd: true},
Cole Faust1cc08852022-02-28 11:12:08 -080081 "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList},
Cole Faust0e2b2562022-04-01 11:46:50 -070082 "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeString},
Cole Faust1cc08852022-02-28 11:12:08 -080083 "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true},
Cole Faust6c41b8a2022-04-13 13:53:48 -070084 "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addHandle: true},
Cole Faust1cc08852022-02-28 11:12:08 -080085 "error": &makeControlFuncParser{name: baseName + ".mkerror"},
86 "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt},
87 "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList},
88 "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList},
89 "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList},
Cole Faust5a13aaf2022-04-27 17:49:35 -070090 "firstword": &simpleCallParser{name: baseName + ".first_word", returnType: starlarkTypeString},
Cole Faustf035d402022-03-28 14:02:50 -070091 "foreach": &foreachCallParser{},
Cole Faust1cc08852022-02-28 11:12:08 -080092 "if": &ifCallParser{},
93 "info": &makeControlFuncParser{name: baseName + ".mkinfo"},
94 "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
95 "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
96 "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
97 "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{},
Cole Faust5a13aaf2022-04-27 17:49:35 -0700101 "lastword": &simpleCallParser{name: baseName + ".last_word", returnType: starlarkTypeString},
Cole Faust1cc08852022-02-28 11:12:08 -0800102 "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString},
103 "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: "<"},
108 "my-dir": &myDirCallParser{},
Cole Faustd2daabf2022-12-12 17:38:01 -0800109 "or": &andOrParser{isAnd: false},
Cole Faust1cc08852022-02-28 11:12:08 -0800110 "patsubst": &substCallParser{fname: "patsubst"},
111 "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList},
Cole Faustea9db582022-03-21 17:50:05 -0700112 "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addHandle: true},
113 "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addHandle: true},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800114 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Cole Faust9ebf6e42021-12-13 14:08:34 -0800115 "shell": &shellCallParser{},
Cole Faust95b95cb2022-04-05 16:37:39 -0700116 "sort": &simpleCallParser{name: baseName + ".mksort", returnType: starlarkTypeList},
Cole Faust1cc08852022-02-28 11:12:08 -0800117 "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800118 "subst": &substCallParser{fname: "subst"},
Cole Faust2dee63d2022-12-12 18:11:00 -0800119 "to-lower": &lowerUpperParser{isUpper: false},
120 "to-upper": &lowerUpperParser{isUpper: true},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800121 "warning": &makeControlFuncParser{name: baseName + ".mkwarning"},
122 "word": &wordCallParser{},
Cole Faust94c4a9a2022-04-22 17:43:52 -0700123 "words": &wordsCallParser{},
Cole Faust1cc08852022-02-28 11:12:08 -0800124 "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800125}
126
Cole Faustf035d402022-03-28 14:02:50 -0700127// The same as knownFunctions, but returns a []starlarkNode instead of a starlarkExpr
128var knownNodeFunctions = map[string]interface {
129 parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode
130}{
131 "eval": &evalNodeParser{},
132 "if": &ifCallNodeParser{},
133 "inherit-product": &inheritProductCallParser{loadAlways: true},
134 "inherit-product-if-exists": &inheritProductCallParser{loadAlways: false},
135 "foreach": &foreachCallNodeParser{},
136}
137
Cole Faust1e275862022-04-26 14:28:04 -0700138// These look like variables, but are actually functions, and would give
139// undefined variable errors if we converted them as variables. Instead,
140// emit an error instead of converting them.
141var unsupportedFunctions = map[string]bool{
142 "local-generated-sources-dir": true,
143 "local-intermediates-dir": true,
144}
145
Cole Faust9ebf6e42021-12-13 14:08:34 -0800146// These are functions that we don't implement conversions for, but
147// we allow seeing their definitions in the product config files.
148var ignoredDefines = map[string]bool{
149 "find-word-in-list": true, // internal macro
150 "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc.
151 "is-android-codename": true, // unused by product config
152 "is-android-codename-in-list": true, // unused by product config
153 "is-chipset-in-board-platform": true, // unused by product config
154 "is-chipset-prefix-in-board-platform": true, // unused by product config
155 "is-not-board-platform": true, // defined but never used
156 "is-platform-sdk-version-at-least": true, // unused by product config
157 "match-prefix": true, // internal macro
158 "match-word": true, // internal macro
159 "match-word-in-list": true, // internal macro
160 "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800161}
162
Cole Faustb0d32ab2021-12-09 14:00:59 -0800163var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800164
165// Conversion request parameters
166type Request struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800167 MkFile string // file to convert
168 Reader io.Reader // if set, read input from this stream instead
Sasha Smundak422b6142021-11-11 18:31:59 -0800169 OutputSuffix string // generated Starlark files suffix
170 OutputDir string // if set, root of the output hierarchy
171 ErrorLogger ErrorLogger
172 TracedVariables []string // trace assignment to these variables
173 TraceCalls bool
174 SourceFS fs.FS
175 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800176}
177
Sasha Smundak7d934b92021-11-10 12:20:01 -0800178// ErrorLogger prints errors and gathers error statistics.
179// Its NewError function is called on every error encountered during the conversion.
180type ErrorLogger interface {
Sasha Smundak422b6142021-11-11 18:31:59 -0800181 NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{})
182}
183
184type ErrorLocation struct {
185 MkFile string
186 MkLine int
187}
188
189func (el ErrorLocation) String() string {
190 return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800191}
192
193// Derives module name for a given file. It is base name
194// (file name without suffix), with some characters replaced to make it a Starlark identifier
195func moduleNameForFile(mkFile string) string {
196 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
197 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700198 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
199
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800200}
201
202func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
203 r := &mkparser.MakeString{StringPos: mkString.StringPos}
204 r.Strings = append(r.Strings, mkString.Strings...)
205 r.Variables = append(r.Variables, mkString.Variables...)
206 return r
207}
208
209func isMakeControlFunc(s string) bool {
210 return s == "error" || s == "warning" || s == "info"
211}
212
Cole Faustf0632662022-04-07 13:59:24 -0700213// varAssignmentScope points to the last assignment for each variable
214// in the current block. It is used during the parsing to chain
215// the assignments to a variable together.
216type varAssignmentScope struct {
217 outer *varAssignmentScope
218 vars map[string]bool
219}
220
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800221// Starlark output generation context
222type generationContext struct {
Cole Faustf0632662022-04-07 13:59:24 -0700223 buf strings.Builder
224 starScript *StarlarkScript
225 indentLevel int
226 inAssignment bool
227 tracedCount int
228 varAssignments *varAssignmentScope
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800229}
230
231func NewGenerateContext(ss *StarlarkScript) *generationContext {
Cole Faustf0632662022-04-07 13:59:24 -0700232 return &generationContext{
233 starScript: ss,
234 varAssignments: &varAssignmentScope{
235 outer: nil,
236 vars: make(map[string]bool),
237 },
238 }
239}
240
241func (gctx *generationContext) pushVariableAssignments() {
242 va := &varAssignmentScope{
243 outer: gctx.varAssignments,
244 vars: make(map[string]bool),
245 }
246 gctx.varAssignments = va
247}
248
249func (gctx *generationContext) popVariableAssignments() {
250 gctx.varAssignments = gctx.varAssignments.outer
251}
252
253func (gctx *generationContext) hasBeenAssigned(v variable) bool {
254 for va := gctx.varAssignments; va != nil; va = va.outer {
255 if _, ok := va.vars[v.name()]; ok {
256 return true
257 }
258 }
259 return false
260}
261
262func (gctx *generationContext) setHasBeenAssigned(v variable) {
263 gctx.varAssignments.vars[v.name()] = true
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800264}
265
266// emit returns generated script
267func (gctx *generationContext) emit() string {
268 ss := gctx.starScript
269
270 // The emitted code has the following layout:
271 // <initial comments>
272 // preamble, i.e.,
273 // load statement for the runtime support
274 // load statement for each unique submodule pulled in by this one
275 // def init(g, handle):
276 // cfg = rblf.cfg(handle)
277 // <statements>
278 // <warning if conversion was not clean>
279
280 iNode := len(ss.nodes)
281 for i, node := range ss.nodes {
282 if _, ok := node.(*commentNode); !ok {
283 iNode = i
284 break
285 }
286 node.emit(gctx)
287 }
288
289 gctx.emitPreamble()
290
291 gctx.newLine()
292 // The arguments passed to the init function are the global dictionary
293 // ('g') and the product configuration dictionary ('cfg')
294 gctx.write("def init(g, handle):")
295 gctx.indentLevel++
296 if gctx.starScript.traceCalls {
297 gctx.newLine()
298 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
299 }
300 gctx.newLine()
301 gctx.writef("cfg = %s(handle)", cfnGetCfg)
302 for _, node := range ss.nodes[iNode:] {
303 node.emit(gctx)
304 }
305
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800306 if gctx.starScript.traceCalls {
307 gctx.newLine()
308 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
309 }
310 gctx.indentLevel--
311 gctx.write("\n")
312 return gctx.buf.String()
313}
314
315func (gctx *generationContext) emitPreamble() {
316 gctx.newLine()
317 gctx.writef("load(%q, %q)", baseUri, baseName)
318 // Emit exactly one load statement for each URI.
319 loadedSubConfigs := make(map[string]string)
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800320 for _, mi := range gctx.starScript.inherited {
321 uri := mi.path
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800322 if m, ok := loadedSubConfigs[uri]; ok {
323 // No need to emit load statement, but fix module name.
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800324 mi.moduleLocalName = m
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800325 continue
326 }
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800327 if mi.optional || mi.missing {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800328 uri += "|init"
329 }
330 gctx.newLine()
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800331 gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName())
332 loadedSubConfigs[uri] = mi.moduleLocalName
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800333 }
334 gctx.write("\n")
335}
336
337func (gctx *generationContext) emitPass() {
338 gctx.newLine()
339 gctx.write("pass")
340}
341
342func (gctx *generationContext) write(ss ...string) {
343 for _, s := range ss {
344 gctx.buf.WriteString(s)
345 }
346}
347
348func (gctx *generationContext) writef(format string, args ...interface{}) {
349 gctx.write(fmt.Sprintf(format, args...))
350}
351
352func (gctx *generationContext) newLine() {
353 if gctx.buf.Len() == 0 {
354 return
355 }
356 gctx.write("\n")
357 gctx.writef("%*s", 2*gctx.indentLevel, "")
358}
359
Sasha Smundak422b6142021-11-11 18:31:59 -0800360func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) {
361 gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message)
362}
363
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800364func (gctx *generationContext) emitLoadCheck(im inheritedModule) {
365 if !im.needsLoadCheck() {
366 return
367 }
368 gctx.newLine()
369 gctx.writef("if not %s:", im.entryName())
370 gctx.indentLevel++
371 gctx.newLine()
372 gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`)
373 im.pathExpr().emit(gctx)
374 gctx.write("))")
375 gctx.indentLevel--
376}
377
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800378type knownVariable struct {
379 name string
380 class varClass
381 valueType starlarkType
382}
383
384type knownVariables map[string]knownVariable
385
386func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
387 v, exists := pcv[name]
388 if !exists {
389 pcv[name] = knownVariable{name, varClass, valueType}
390 return
391 }
392 // Conflict resolution:
393 // * config class trumps everything
394 // * any type trumps unknown type
395 match := varClass == v.class
396 if !match {
397 if varClass == VarClassConfig {
398 v.class = VarClassConfig
399 match = true
400 } else if v.class == VarClassConfig {
401 match = true
402 }
403 }
404 if valueType != v.valueType {
405 if valueType != starlarkTypeUnknown {
406 if v.valueType == starlarkTypeUnknown {
407 v.valueType = valueType
408 } else {
409 match = false
410 }
411 }
412 }
413 if !match {
414 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
415 name, varClass, valueType, v.class, v.valueType)
416 }
417}
418
419// All known product variables.
420var KnownVariables = make(knownVariables)
421
422func init() {
423 for _, kv := range []string{
424 // Kernel-related variables that we know are lists.
425 "BOARD_VENDOR_KERNEL_MODULES",
426 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
427 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
428 "BOARD_RECOVERY_KERNEL_MODULES",
429 // Other variables we knwo are lists
430 "ART_APEX_JARS",
431 } {
432 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
433 }
434}
435
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800436// Information about the generated Starlark script.
437type StarlarkScript struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800438 mkFile string
439 moduleName string
440 mkPos scanner.Position
441 nodes []starlarkNode
442 inherited []*moduleInfo
443 hasErrors bool
Sasha Smundak422b6142021-11-11 18:31:59 -0800444 traceCalls bool // print enter/exit each init function
445 sourceFS fs.FS
446 makefileFinder MakefileFinder
447 nodeLocator func(pos mkparser.Pos) int
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800448}
449
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800450// parseContext holds the script we are generating and all the ephemeral data
451// needed during the parsing.
452type parseContext struct {
453 script *StarlarkScript
454 nodes []mkparser.Node // Makefile as parsed by mkparser
455 currentNodeIndex int // Node in it we are processing
456 ifNestLevel int
457 moduleNameCount map[string]int // count of imported modules with given basename
458 fatalError error
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800459 outputSuffix string
Sasha Smundak7d934b92021-11-10 12:20:01 -0800460 errorLogger ErrorLogger
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800461 tracedVariables map[string]bool // variables to be traced in the generated script
462 variables map[string]variable
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800463 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700464 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700465 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700466 includeTops []string
Cole Faustf92c9f22022-03-14 14:35:50 -0700467 typeHints map[string]starlarkType
468 atTopOfMakefile bool
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800469}
470
471func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
472 predefined := []struct{ name, value string }{
473 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
474 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Cole Faust5a13aaf2022-04-27 17:49:35 -0700475 {"MAKEFILE_LIST", ss.mkFile},
Cole Faust9b6111a2022-02-02 15:38:33 -0800476 {"TOPDIR", ""}, // TOPDIR is just set to an empty string in cleanbuild.mk and core.mk
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800477 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
478 {"TARGET_COPY_OUT_SYSTEM", "system"},
479 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
480 {"TARGET_COPY_OUT_DATA", "data"},
481 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
482 {"TARGET_COPY_OUT_OEM", "oem"},
483 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
484 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
485 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
486 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
487 {"TARGET_COPY_OUT_ROOT", "root"},
488 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800489 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800490 // TODO(asmundak): to process internal config files, we need the following variables:
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800491 // TARGET_VENDOR
492 // target_base_product
493 //
494
495 // the following utility variables are set in build/make/common/core.mk:
496 {"empty", ""},
497 {"space", " "},
498 {"comma", ","},
499 {"newline", "\n"},
500 {"pound", "#"},
501 {"backslash", "\\"},
502 }
503 ctx := &parseContext{
504 script: ss,
505 nodes: nodes,
506 currentNodeIndex: 0,
507 ifNestLevel: 0,
508 moduleNameCount: make(map[string]int),
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800509 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700510 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700511 soongNamespaces: make(map[string]map[string]bool),
Cole Faust6c934f62022-01-06 15:51:12 -0800512 includeTops: []string{},
Cole Faustf92c9f22022-03-14 14:35:50 -0700513 typeHints: make(map[string]starlarkType),
514 atTopOfMakefile: true,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800515 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800516 for _, item := range predefined {
517 ctx.variables[item.name] = &predefinedVariable{
518 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
519 value: &stringLiteralExpr{item.value},
520 }
521 }
522
523 return ctx
524}
525
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800526func (ctx *parseContext) hasNodes() bool {
527 return ctx.currentNodeIndex < len(ctx.nodes)
528}
529
530func (ctx *parseContext) getNode() mkparser.Node {
531 if !ctx.hasNodes() {
532 return nil
533 }
534 node := ctx.nodes[ctx.currentNodeIndex]
535 ctx.currentNodeIndex++
536 return node
537}
538
539func (ctx *parseContext) backNode() {
540 if ctx.currentNodeIndex <= 0 {
541 panic("Cannot back off")
542 }
543 ctx.currentNodeIndex--
544}
545
Cole Faustdd569ae2022-01-31 15:48:29 -0800546func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800547 // Handle only simple variables
Cole Faust00afd4f2022-04-26 14:01:56 -0700548 if !a.Name.Const() || a.Target != nil {
Cole Faustdd569ae2022-01-31 15:48:29 -0800549 return []starlarkNode{ctx.newBadNode(a, "Only simple variables are handled")}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800550 }
551 name := a.Name.Strings[0]
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800552 // The `override` directive
553 // override FOO :=
554 // is parsed as an assignment to a variable named `override FOO`.
555 // There are very few places where `override` is used, just flag it.
556 if strings.HasPrefix(name, "override ") {
Cole Faustdd569ae2022-01-31 15:48:29 -0800557 return []starlarkNode{ctx.newBadNode(a, "cannot handle override directive")}
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800558 }
Cole Faust5d5fcc32022-04-26 18:02:05 -0700559 if name == ".KATI_READONLY" {
560 // Skip assignments to .KATI_READONLY. If it was in the output file, it
561 // would be an error because it would be sorted before the definition of
562 // the variable it's trying to make readonly.
563 return []starlarkNode{}
564 }
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800565
Cole Faustc00184e2021-11-08 12:08:57 -0800566 // Soong configuration
Sasha Smundak3deb9682021-07-26 18:42:25 -0700567 if strings.HasPrefix(name, soongNsPrefix) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800568 return ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700569 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800570 lhs := ctx.addVariable(name)
571 if lhs == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -0800572 return []starlarkNode{ctx.newBadNode(a, "unknown variable %s", name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800573 }
Cole Faust3c4fc992022-02-28 16:05:01 -0800574 _, isTraced := ctx.tracedVariables[lhs.name()]
Sasha Smundak422b6142021-11-11 18:31:59 -0800575 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800576 if lhs.valueType() == starlarkTypeUnknown {
577 // Try to divine variable type from the RHS
578 asgn.value = ctx.parseMakeString(a, a.Value)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800579 inferred_type := asgn.value.typ()
580 if inferred_type != starlarkTypeUnknown {
Sasha Smundak9d011ab2021-07-09 16:00:57 -0700581 lhs.setValueType(inferred_type)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800582 }
583 }
584 if lhs.valueType() == starlarkTypeList {
Cole Faustdd569ae2022-01-31 15:48:29 -0800585 xConcat, xBad := ctx.buildConcatExpr(a)
586 if xBad != nil {
Cole Faust1e275862022-04-26 14:28:04 -0700587 asgn.value = xBad
588 } else {
589 switch len(xConcat.items) {
590 case 0:
591 asgn.value = &listExpr{}
592 case 1:
593 asgn.value = xConcat.items[0]
594 default:
595 asgn.value = xConcat
596 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800597 }
598 } else {
599 asgn.value = ctx.parseMakeString(a, a.Value)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800600 }
601
Cole Faust421a1922022-03-16 14:35:45 -0700602 if asgn.lhs.valueType() == starlarkTypeString &&
603 asgn.value.typ() != starlarkTypeUnknown &&
604 asgn.value.typ() != starlarkTypeString {
605 asgn.value = &toStringExpr{expr: asgn.value}
606 }
607
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800608 switch a.Type {
609 case "=", ":=":
610 asgn.flavor = asgnSet
611 case "+=":
Cole Fauste2a37982022-03-09 16:00:17 -0800612 asgn.flavor = asgnAppend
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800613 case "?=":
614 asgn.flavor = asgnMaybeSet
615 default:
616 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
617 }
618
Cole Faustdd569ae2022-01-31 15:48:29 -0800619 return []starlarkNode{asgn}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800620}
621
Cole Faustdd569ae2022-01-31 15:48:29 -0800622func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) []starlarkNode {
Sasha Smundak3deb9682021-07-26 18:42:25 -0700623 val := ctx.parseMakeString(asgn, asgn.Value)
624 if xBad, ok := val.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800625 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700626 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700627
628 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
629 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
630 // Try to divine the call from the assignment as follows:
631 if name == "NAMESPACES" {
632 // Upon seeng
633 // SOONG_CONFIG_NAMESPACES += foo
634 // remember that there is a namespace `foo` and act as we saw
635 // $(call add_soong_config_namespace,foo)
636 s, ok := maybeString(val)
637 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800638 return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700639 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800640 result := make([]starlarkNode, 0)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700641 for _, ns := range strings.Fields(s) {
642 ctx.addSoongNamespace(ns)
Cole Faustdd569ae2022-01-31 15:48:29 -0800643 result = append(result, &exprNode{&callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -0800644 name: baseName + ".soong_config_namespace",
645 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700646 returnType: starlarkTypeVoid,
647 }})
648 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800649 return result
Sasha Smundak3deb9682021-07-26 18:42:25 -0700650 } else {
651 // Upon seeing
652 // SOONG_CONFIG_x_y = v
653 // find a namespace called `x` and act as if we encountered
Cole Faustc00184e2021-11-08 12:08:57 -0800654 // $(call soong_config_set,x,y,v)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700655 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
656 // it.
657 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
658 // and `foo` with a variable `bar_baz`.
659 namespaceName := ""
660 if ctx.hasSoongNamespace(name) {
661 namespaceName = name
662 }
663 var varName string
664 for pos, ch := range name {
665 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
666 continue
667 }
668 if namespaceName != "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800669 return []starlarkNode{ctx.newBadNode(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700670 }
671 namespaceName = name[0:pos]
672 varName = name[pos+1:]
673 }
674 if namespaceName == "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800675 return []starlarkNode{ctx.newBadNode(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700676 }
677 if varName == "" {
678 // Remember variables in this namespace
679 s, ok := maybeString(val)
680 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800681 return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700682 }
683 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
Cole Faustdd569ae2022-01-31 15:48:29 -0800684 return []starlarkNode{}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700685 }
686
687 // Finally, handle assignment to a namespace variable
688 if !ctx.hasNamespaceVar(namespaceName, varName) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800689 return []starlarkNode{ctx.newBadNode(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700690 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800691 fname := baseName + "." + soongConfigAssign
Sasha Smundak65b547e2021-09-17 15:35:41 -0700692 if asgn.Type == "+=" {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800693 fname = baseName + "." + soongConfigAppend
Sasha Smundak65b547e2021-09-17 15:35:41 -0700694 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800695 return []starlarkNode{&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700696 name: fname,
Cole Faust9ebf6e42021-12-13 14:08:34 -0800697 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700698 returnType: starlarkTypeVoid,
Cole Faustdd569ae2022-01-31 15:48:29 -0800699 }}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700700 }
701}
702
Cole Faustdd569ae2022-01-31 15:48:29 -0800703func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) (*concatExpr, *badExpr) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800704 xConcat := &concatExpr{}
705 var xItemList *listExpr
706 addToItemList := func(x ...starlarkExpr) {
707 if xItemList == nil {
708 xItemList = &listExpr{[]starlarkExpr{}}
709 }
710 xItemList.items = append(xItemList.items, x...)
711 }
712 finishItemList := func() {
713 if xItemList != nil {
714 xConcat.items = append(xConcat.items, xItemList)
715 xItemList = nil
716 }
717 }
718
719 items := a.Value.Words()
720 for _, item := range items {
721 // A function call in RHS is supposed to return a list, all other item
722 // expressions return individual elements.
723 switch x := ctx.parseMakeString(a, item).(type) {
724 case *badExpr:
Cole Faustdd569ae2022-01-31 15:48:29 -0800725 return nil, x
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800726 case *stringLiteralExpr:
727 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
728 default:
729 switch x.typ() {
730 case starlarkTypeList:
731 finishItemList()
732 xConcat.items = append(xConcat.items, x)
733 case starlarkTypeString:
734 finishItemList()
735 xConcat.items = append(xConcat.items, &callExpr{
736 object: x,
737 name: "split",
738 args: nil,
739 returnType: starlarkTypeList,
740 })
741 default:
742 addToItemList(x)
743 }
744 }
745 }
746 if xItemList != nil {
747 xConcat.items = append(xConcat.items, xItemList)
748 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800749 return xConcat, nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800750}
751
Sasha Smundak6609ba72021-07-22 18:32:56 -0700752func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
753 modulePath := ctx.loadedModulePath(path)
754 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700755 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700756 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800757 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800758 moduleName := moduleNameForFile(path)
759 moduleLocalName := "_" + moduleName
760 n, found := ctx.moduleNameCount[moduleName]
761 if found {
762 moduleLocalName += fmt.Sprintf("%d", n)
763 }
764 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800765 _, err := fs.Stat(ctx.script.sourceFS, path)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700766 mi := &moduleInfo{
767 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800768 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800769 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700770 optional: optional,
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800771 missing: err != nil,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800772 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700773 ctx.dependentModules[modulePath] = mi
774 ctx.script.inherited = append(ctx.script.inherited, mi)
775 return mi
776}
777
778func (ctx *parseContext) handleSubConfig(
Cole Faustdd569ae2022-01-31 15:48:29 -0800779 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule) starlarkNode) []starlarkNode {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700780
Cole Faust62e05112022-04-05 17:56:11 -0700781 // Allow seeing $(sort $(wildcard realPathExpr)) or $(wildcard realPathExpr)
782 // because those are functionally the same as not having the sort/wildcard calls.
783 if ce, ok := pathExpr.(*callExpr); ok && ce.name == "rblf.mksort" && len(ce.args) == 1 {
784 if ce2, ok2 := ce.args[0].(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
785 pathExpr = ce2.args[0]
786 }
787 } else if ce2, ok2 := pathExpr.(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
788 pathExpr = ce2.args[0]
789 }
790
Sasha Smundak6609ba72021-07-22 18:32:56 -0700791 // In a simple case, the name of a module to inherit/include is known statically.
792 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700793 // Note that even if this directive loads a module unconditionally, a module may be
794 // absent without causing any harm if this directive is inside an if/else block.
795 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700796 if strings.Contains(path, "*") {
797 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
Cole Faust62e05112022-04-05 17:56:11 -0700798 sort.Strings(paths)
Cole Faustdd569ae2022-01-31 15:48:29 -0800799 result := make([]starlarkNode, 0)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700800 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700801 mi := ctx.newDependentModule(p, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800802 result = append(result, processModule(inheritedStaticModule{mi, loadAlways}))
Sasha Smundak6609ba72021-07-22 18:32:56 -0700803 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800804 return result
Sasha Smundak6609ba72021-07-22 18:32:56 -0700805 } else {
Cole Faustdd569ae2022-01-31 15:48:29 -0800806 return []starlarkNode{ctx.newBadNode(v, "cannot glob wildcard argument")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700807 }
808 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700809 mi := ctx.newDependentModule(path, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800810 return []starlarkNode{processModule(inheritedStaticModule{mi, loadAlways})}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700811 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700812 }
813
814 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
815 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
816 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
817 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
818 // We then emit the code that loads all of them, e.g.:
819 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
820 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
821 // And then inherit it as follows:
822 // _e = {
823 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
824 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
825 // if _e:
826 // rblf.inherit(handle, _e[0], _e[1])
827 //
828 var matchingPaths []string
Cole Faust9df1d732022-04-26 16:27:22 -0700829 var needsWarning = false
830 if interpolate, ok := pathExpr.(*interpolateExpr); ok {
831 pathPattern := []string{interpolate.chunks[0]}
832 for _, chunk := range interpolate.chunks[1:] {
833 if chunk != "" {
834 pathPattern = append(pathPattern, chunk)
835 }
836 }
Cole Faust74ac0272022-06-14 12:45:26 -0700837 if len(pathPattern) == 1 {
838 pathPattern = append(pathPattern, "")
Cole Faust9df1d732022-04-26 16:27:22 -0700839 }
Cole Faust74ac0272022-06-14 12:45:26 -0700840 matchingPaths = ctx.findMatchingPaths(pathPattern)
Cole Faust9df1d732022-04-26 16:27:22 -0700841 needsWarning = pathPattern[0] == "" && len(ctx.includeTops) == 0
842 } else if len(ctx.includeTops) > 0 {
Cole Faust74ac0272022-06-14 12:45:26 -0700843 matchingPaths = append(matchingPaths, ctx.findMatchingPaths([]string{"", ""})...)
Cole Faust9df1d732022-04-26 16:27:22 -0700844 } else {
Cole Faustdd569ae2022-01-31 15:48:29 -0800845 return []starlarkNode{ctx.newBadNode(v, "inherit-product/include argument is too complex")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700846 }
847
Sasha Smundak6609ba72021-07-22 18:32:56 -0700848 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700849 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700850 if len(matchingPaths) > maxMatchingFiles {
Cole Faustdd569ae2022-01-31 15:48:29 -0800851 return []starlarkNode{ctx.newBadNode(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700852 }
Cole Faust93f8d392022-03-02 13:31:30 -0800853
Cole Faust9df1d732022-04-26 16:27:22 -0700854 res := inheritedDynamicModule{pathExpr, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning}
Cole Faust93f8d392022-03-02 13:31:30 -0800855 for _, p := range matchingPaths {
856 // A product configuration files discovered dynamically may attempt to inherit
857 // from another one which does not exist in this source tree. Prevent load errors
858 // by always loading the dynamic files as optional.
859 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
Sasha Smundak6609ba72021-07-22 18:32:56 -0700860 }
Cole Faust93f8d392022-03-02 13:31:30 -0800861 return []starlarkNode{processModule(res)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700862}
863
864func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
Cole Faust9b6111a2022-02-02 15:38:33 -0800865 files := ctx.script.makefileFinder.Find(".")
Sasha Smundak6609ba72021-07-22 18:32:56 -0700866 if len(pattern) == 0 {
867 return files
868 }
869
870 // Create regular expression from the pattern
Cole Faust74ac0272022-06-14 12:45:26 -0700871 regexString := "^" + regexp.QuoteMeta(pattern[0])
Sasha Smundak6609ba72021-07-22 18:32:56 -0700872 for _, s := range pattern[1:] {
Cole Faust74ac0272022-06-14 12:45:26 -0700873 regexString += ".*" + regexp.QuoteMeta(s)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700874 }
Cole Faust74ac0272022-06-14 12:45:26 -0700875 regexString += "$"
876 rex := regexp.MustCompile(regexString)
877
878 includeTopRegexString := ""
879 if len(ctx.includeTops) > 0 {
880 for i, top := range ctx.includeTops {
881 if i > 0 {
882 includeTopRegexString += "|"
883 }
884 includeTopRegexString += "^" + regexp.QuoteMeta(top)
885 }
886 } else {
887 includeTopRegexString = ".*"
888 }
889
890 includeTopRegex := regexp.MustCompile(includeTopRegexString)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700891
892 // Now match
893 var res []string
894 for _, p := range files {
Cole Faust74ac0272022-06-14 12:45:26 -0700895 if rex.MatchString(p) && includeTopRegex.MatchString(p) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700896 res = append(res, p)
897 }
898 }
899 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800900}
901
Cole Faustf035d402022-03-28 14:02:50 -0700902type inheritProductCallParser struct {
903 loadAlways bool
904}
905
906func (p *inheritProductCallParser) parse(ctx *parseContext, v mkparser.Node, args *mkparser.MakeString) []starlarkNode {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800907 args.TrimLeftSpaces()
908 args.TrimRightSpaces()
909 pathExpr := ctx.parseMakeString(v, args)
910 if _, ok := pathExpr.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800911 return []starlarkNode{ctx.newBadNode(v, "Unable to parse argument to inherit")}
Cole Faust9ebf6e42021-12-13 14:08:34 -0800912 }
Cole Faustf035d402022-03-28 14:02:50 -0700913 return ctx.handleSubConfig(v, pathExpr, p.loadAlways, func(im inheritedModule) starlarkNode {
914 return &inheritNode{im, p.loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700915 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800916}
917
Cole Faust20052982022-04-22 14:43:55 -0700918func (ctx *parseContext) handleInclude(v *mkparser.Directive) []starlarkNode {
919 loadAlways := v.Name[0] != '-'
920 return ctx.handleSubConfig(v, ctx.parseMakeString(v, v.Args), loadAlways, func(im inheritedModule) starlarkNode {
Cole Faustdd569ae2022-01-31 15:48:29 -0800921 return &includeNode{im, loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700922 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800923}
924
Cole Faustdd569ae2022-01-31 15:48:29 -0800925func (ctx *parseContext) handleVariable(v *mkparser.Variable) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800926 // Handle:
927 // $(call inherit-product,...)
928 // $(call inherit-product-if-exists,...)
929 // $(info xxx)
930 // $(warning xxx)
931 // $(error xxx)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800932 // $(call other-custom-functions,...)
933
Cole Faustf035d402022-03-28 14:02:50 -0700934 if name, args, ok := ctx.maybeParseFunctionCall(v, v.Name); ok {
935 if kf, ok := knownNodeFunctions[name]; ok {
936 return kf.parse(ctx, v, args)
937 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800938 }
Cole Faustf035d402022-03-28 14:02:50 -0700939
Cole Faustdd569ae2022-01-31 15:48:29 -0800940 return []starlarkNode{&exprNode{expr: ctx.parseReference(v, v.Name)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800941}
942
Cole Faustdd569ae2022-01-31 15:48:29 -0800943func (ctx *parseContext) maybeHandleDefine(directive *mkparser.Directive) starlarkNode {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700944 macro_name := strings.Fields(directive.Args.Strings[0])[0]
945 // Ignore the macros that we handle
Cole Faust9ebf6e42021-12-13 14:08:34 -0800946 _, ignored := ignoredDefines[macro_name]
947 _, known := knownFunctions[macro_name]
948 if !ignored && !known {
Cole Faustdd569ae2022-01-31 15:48:29 -0800949 return ctx.newBadNode(directive, "define is not supported: %s", macro_name)
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700950 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800951 return nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800952}
953
Cole Faustdd569ae2022-01-31 15:48:29 -0800954func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) starlarkNode {
955 ssSwitch := &switchNode{
956 ssCases: []*switchCase{ctx.processBranch(ifDirective)},
957 }
958 for ctx.hasNodes() && ctx.fatalError == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800959 node := ctx.getNode()
960 switch x := node.(type) {
961 case *mkparser.Directive:
962 switch x.Name {
963 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
Cole Faustdd569ae2022-01-31 15:48:29 -0800964 ssSwitch.ssCases = append(ssSwitch.ssCases, ctx.processBranch(x))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800965 case "endif":
Cole Faustdd569ae2022-01-31 15:48:29 -0800966 return ssSwitch
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800967 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800968 return ctx.newBadNode(node, "unexpected directive %s", x.Name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800969 }
970 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800971 return ctx.newBadNode(ifDirective, "unexpected statement")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800972 }
973 }
974 if ctx.fatalError == nil {
975 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
976 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800977 return ctx.newBadNode(ifDirective, "no matching endif for %s", ifDirective.Dump())
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800978}
979
980// processBranch processes a single branch (if/elseif/else) until the next directive
981// on the same level.
Cole Faustdd569ae2022-01-31 15:48:29 -0800982func (ctx *parseContext) processBranch(check *mkparser.Directive) *switchCase {
983 block := &switchCase{gate: ctx.parseCondition(check)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800984 defer func() {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800985 ctx.ifNestLevel--
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800986 }()
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800987 ctx.ifNestLevel++
988
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800989 for ctx.hasNodes() {
990 node := ctx.getNode()
Cole Faust591a1fe2021-11-08 15:37:57 -0800991 if d, ok := node.(*mkparser.Directive); ok {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800992 switch d.Name {
993 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800994 ctx.backNode()
Cole Faustdd569ae2022-01-31 15:48:29 -0800995 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800996 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800997 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800998 block.nodes = append(block.nodes, ctx.handleSimpleStatement(node)...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800999 }
1000 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
Cole Faustdd569ae2022-01-31 15:48:29 -08001001 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001002}
1003
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001004func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
1005 switch check.Name {
1006 case "ifdef", "ifndef", "elifdef", "elifndef":
Cole Faust71514c02022-01-27 17:21:41 -08001007 if !check.Args.Const() {
Cole Faustdd569ae2022-01-31 15:48:29 -08001008 return ctx.newBadNode(check, "ifdef variable ref too complex: %s", check.Args.Dump())
Cole Faust71514c02022-01-27 17:21:41 -08001009 }
Cole Faustf0632662022-04-07 13:59:24 -07001010 v := NewVariableRefExpr(ctx.addVariable(check.Args.Strings[0]))
Cole Faust71514c02022-01-27 17:21:41 -08001011 if strings.HasSuffix(check.Name, "ndef") {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001012 v = &notExpr{v}
1013 }
1014 return &ifNode{
1015 isElif: strings.HasPrefix(check.Name, "elif"),
1016 expr: v,
1017 }
1018 case "ifeq", "ifneq", "elifeq", "elifneq":
1019 return &ifNode{
1020 isElif: strings.HasPrefix(check.Name, "elif"),
1021 expr: ctx.parseCompare(check),
1022 }
1023 case "else":
1024 return &elseNode{}
1025 default:
1026 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
1027 }
1028}
1029
1030func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001031 if ctx.errorLogger != nil {
Sasha Smundak422b6142021-11-11 18:31:59 -08001032 ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001033 }
1034 ctx.script.hasErrors = true
Cole Faustdd569ae2022-01-31 15:48:29 -08001035 return &badExpr{errorLocation: ctx.errorLocation(node), message: fmt.Sprintf(text, args...)}
1036}
1037
1038// records that the given node failed to be converted and includes an explanatory message
1039func (ctx *parseContext) newBadNode(failedNode mkparser.Node, message string, args ...interface{}) starlarkNode {
1040 return &exprNode{ctx.newBadExpr(failedNode, message, args...)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001041}
1042
1043func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
1044 // Strip outer parentheses
1045 mkArg := cloneMakeString(cond.Args)
1046 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1047 n := len(mkArg.Strings)
1048 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1049 args := mkArg.Split(",")
1050 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1051 if len(args) != 2 {
1052 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1053 }
1054 args[0].TrimRightSpaces()
1055 args[1].TrimLeftSpaces()
1056
1057 isEq := !strings.HasSuffix(cond.Name, "neq")
Cole Faustf8320212021-11-10 15:05:07 -08001058 xLeft := ctx.parseMakeString(cond, args[0])
1059 xRight := ctx.parseMakeString(cond, args[1])
1060 if bad, ok := xLeft.(*badExpr); ok {
1061 return bad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001062 }
Cole Faustf8320212021-11-10 15:05:07 -08001063 if bad, ok := xRight.(*badExpr); ok {
1064 return bad
1065 }
1066
1067 if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok {
1068 return expr
1069 }
1070
Cole Faust9ebf6e42021-12-13 14:08:34 -08001071 var stringOperand string
1072 var otherOperand starlarkExpr
1073 if s, ok := maybeString(xLeft); ok {
1074 stringOperand = s
1075 otherOperand = xRight
1076 } else if s, ok := maybeString(xRight); ok {
1077 stringOperand = s
1078 otherOperand = xLeft
1079 }
1080
Cole Faust9ebf6e42021-12-13 14:08:34 -08001081 // If we've identified one of the operands as being a string literal, check
1082 // for some special cases we can do to simplify the resulting expression.
1083 if otherOperand != nil {
1084 if stringOperand == "" {
1085 if isEq {
Cole Faustf035d402022-03-28 14:02:50 -07001086 return negateExpr(otherOperand)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001087 } else {
1088 return otherOperand
1089 }
1090 }
1091 if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool {
1092 if !isEq {
Cole Faustf035d402022-03-28 14:02:50 -07001093 return negateExpr(otherOperand)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001094 } else {
1095 return otherOperand
1096 }
1097 }
Cole Fausta99afdf2022-04-26 12:06:49 -07001098 if otherOperand.typ() == starlarkTypeList {
1099 fields := strings.Fields(stringOperand)
1100 elements := make([]starlarkExpr, len(fields))
1101 for i, s := range fields {
1102 elements[i] = &stringLiteralExpr{literal: s}
1103 }
1104 return &eqExpr{
1105 left: otherOperand,
1106 right: &listExpr{elements},
1107 isEq: isEq,
1108 }
1109 }
Cole Faustb1103e22022-01-06 15:22:05 -08001110 if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt {
1111 return &eqExpr{
1112 left: otherOperand,
1113 right: &intLiteralExpr{literal: intOperand},
1114 isEq: isEq,
1115 }
1116 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001117 }
1118
Cole Faustf8320212021-11-10 15:05:07 -08001119 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001120}
1121
Cole Faustf8320212021-11-10 15:05:07 -08001122// Given an if statement's directive and the left/right starlarkExprs,
1123// check if the starlarkExprs are one of a few hardcoded special cases
Cole Faust9932f752022-02-08 11:56:25 -08001124// that can be converted to a simpler equality expression than simply comparing
Cole Faustf8320212021-11-10 15:05:07 -08001125// the two.
1126func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr,
1127 right starlarkExpr) (starlarkExpr, bool) {
1128 isEq := !strings.HasSuffix(directive.Name, "neq")
1129
1130 // All the special cases require a call on one side and a
1131 // string literal/variable on the other. Turn the left/right variables into
1132 // call/value variables, and return false if that's not possible.
1133 var value starlarkExpr = nil
1134 call, ok := left.(*callExpr)
1135 if ok {
1136 switch right.(type) {
1137 case *stringLiteralExpr, *variableRefExpr:
1138 value = right
1139 }
1140 } else {
1141 call, _ = right.(*callExpr)
1142 switch left.(type) {
1143 case *stringLiteralExpr, *variableRefExpr:
1144 value = left
1145 }
1146 }
1147
1148 if call == nil || value == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001149 return nil, false
1150 }
Cole Faustf8320212021-11-10 15:05:07 -08001151
Cole Faustf8320212021-11-10 15:05:07 -08001152 switch call.name {
Cole Faust9932f752022-02-08 11:56:25 -08001153 case baseName + ".filter":
1154 return ctx.parseCompareFilterFuncResult(directive, call, value, isEq)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001155 case baseName + ".findstring":
Cole Faustf8320212021-11-10 15:05:07 -08001156 return ctx.parseCheckFindstringFuncResult(directive, call, value, !isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001157 case baseName + ".strip":
Cole Faustf8320212021-11-10 15:05:07 -08001158 return ctx.parseCompareStripFuncResult(directive, call, value, !isEq), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001159 }
Cole Faustf8320212021-11-10 15:05:07 -08001160 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001161}
1162
1163func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
Cole Faust9932f752022-02-08 11:56:25 -08001164 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) (starlarkExpr, bool) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001165 // We handle:
Sasha Smundak0554d762021-07-08 18:26:12 -07001166 // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
1167 // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
Cole Faust9932f752022-02-08 11:56:25 -08001168 if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" {
1169 return nil, false
1170 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001171 xPattern := filterFuncCall.args[0]
1172 xText := filterFuncCall.args[1]
1173 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001174 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001175 var ok bool
Cole Faust9932f752022-02-08 11:56:25 -08001176 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
1177 expr = xText
1178 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
1179 expr = xPattern
1180 } else {
1181 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001182 }
Cole Faust9932f752022-02-08 11:56:25 -08001183 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1184 // Generate simpler code for the common cases:
1185 if expr.typ() == starlarkTypeList {
1186 if len(slExpr.items) == 1 {
1187 // Checking that a string belongs to list
1188 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}, true
Sasha Smundak0554d762021-07-08 18:26:12 -07001189 } else {
Cole Faust9932f752022-02-08 11:56:25 -08001190 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001191 }
Cole Faust9932f752022-02-08 11:56:25 -08001192 } else if len(slExpr.items) == 1 {
1193 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}, true
1194 } else {
1195 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}, true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001196 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001197}
1198
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001199func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1200 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001201 if isEmptyString(xValue) {
1202 return &eqExpr{
1203 left: &callExpr{
1204 object: xCall.args[1],
1205 name: "find",
1206 args: []starlarkExpr{xCall.args[0]},
1207 returnType: starlarkTypeInt,
1208 },
1209 right: &intLiteralExpr{-1},
1210 isEq: !negate,
1211 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001212 } else if s, ok := maybeString(xValue); ok {
1213 if s2, ok := maybeString(xCall.args[0]); ok && s == s2 {
1214 return &eqExpr{
1215 left: &callExpr{
1216 object: xCall.args[1],
1217 name: "find",
1218 args: []starlarkExpr{xCall.args[0]},
1219 returnType: starlarkTypeInt,
1220 },
1221 right: &intLiteralExpr{-1},
1222 isEq: negate,
1223 }
1224 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001225 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001226 return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001227}
1228
1229func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1230 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1231 if _, ok := xValue.(*stringLiteralExpr); !ok {
1232 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1233 }
1234 return &eqExpr{
1235 left: &callExpr{
1236 name: "strip",
1237 args: xCall.args,
1238 returnType: starlarkTypeString,
1239 },
1240 right: xValue, isEq: !negate}
1241}
1242
Cole Faustf035d402022-03-28 14:02:50 -07001243func (ctx *parseContext) maybeParseFunctionCall(node mkparser.Node, ref *mkparser.MakeString) (name string, args *mkparser.MakeString, ok bool) {
1244 ref.TrimLeftSpaces()
1245 ref.TrimRightSpaces()
1246
1247 words := ref.SplitN(" ", 2)
1248 if !words[0].Const() {
1249 return "", nil, false
1250 }
1251
1252 name = words[0].Dump()
1253 args = mkparser.SimpleMakeString("", words[0].Pos())
1254 if len(words) >= 2 {
1255 args = words[1]
1256 }
1257 args.TrimLeftSpaces()
1258 if name == "call" {
1259 words = args.SplitN(",", 2)
1260 if words[0].Empty() || !words[0].Const() {
1261 return "", nil, false
1262 }
1263 name = words[0].Dump()
1264 if len(words) < 2 {
Cole Faust6c41b8a2022-04-13 13:53:48 -07001265 args = mkparser.SimpleMakeString("", words[0].Pos())
Cole Faustf035d402022-03-28 14:02:50 -07001266 } else {
1267 args = words[1]
1268 }
1269 }
1270 ok = true
1271 return
1272}
1273
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001274// parses $(...), returning an expression
1275func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1276 ref.TrimLeftSpaces()
1277 ref.TrimRightSpaces()
1278 refDump := ref.Dump()
1279
1280 // Handle only the case where the first (or only) word is constant
1281 words := ref.SplitN(" ", 2)
1282 if !words[0].Const() {
Cole Faust13238772022-04-28 14:29:57 -07001283 if len(words) == 1 {
1284 expr := ctx.parseMakeString(node, ref)
1285 return &callExpr{
1286 object: &identifierExpr{"cfg"},
1287 name: "get",
1288 args: []starlarkExpr{
1289 expr,
1290 &callExpr{
1291 object: &identifierExpr{"g"},
1292 name: "get",
1293 args: []starlarkExpr{
1294 expr,
1295 &stringLiteralExpr{literal: ""},
1296 },
1297 returnType: starlarkTypeUnknown,
1298 },
1299 },
1300 returnType: starlarkTypeUnknown,
1301 }
1302 } else {
1303 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1304 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001305 }
1306
Cole Faust1e275862022-04-26 14:28:04 -07001307 if name, _, ok := ctx.maybeParseFunctionCall(node, ref); ok {
1308 if _, unsupported := unsupportedFunctions[name]; unsupported {
1309 return ctx.newBadExpr(node, "%s is not supported", refDump)
1310 }
1311 }
1312
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001313 // If it is a single word, it can be a simple variable
1314 // reference or a function call
Cole Faustf035d402022-03-28 14:02:50 -07001315 if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" && refDump != "eval" {
Sasha Smundak65b547e2021-09-17 15:35:41 -07001316 if strings.HasPrefix(refDump, soongNsPrefix) {
1317 // TODO (asmundak): if we find many, maybe handle them.
Cole Faustc00184e2021-11-08 12:08:57 -08001318 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
Sasha Smundak65b547e2021-09-17 15:35:41 -07001319 }
Cole Faustc36c9622021-12-07 15:20:45 -08001320 // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html
1321 if strings.Contains(refDump, ":") {
1322 parts := strings.SplitN(refDump, ":", 2)
1323 substParts := strings.SplitN(parts[1], "=", 2)
1324 if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 {
1325 return ctx.newBadExpr(node, "Invalid substitution reference")
1326 }
1327 if !strings.Contains(substParts[0], "%") {
1328 if strings.Contains(substParts[1], "%") {
1329 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.")
1330 }
1331 substParts[0] = "%" + substParts[0]
1332 substParts[1] = "%" + substParts[1]
1333 }
1334 v := ctx.addVariable(parts[0])
1335 if v == nil {
1336 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1337 }
1338 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001339 name: baseName + ".mkpatsubst",
1340 returnType: starlarkTypeString,
Cole Faustc36c9622021-12-07 15:20:45 -08001341 args: []starlarkExpr{
1342 &stringLiteralExpr{literal: substParts[0]},
1343 &stringLiteralExpr{literal: substParts[1]},
Cole Faustf0632662022-04-07 13:59:24 -07001344 NewVariableRefExpr(v),
Cole Faustc36c9622021-12-07 15:20:45 -08001345 },
1346 }
1347 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001348 if v := ctx.addVariable(refDump); v != nil {
Cole Faustf0632662022-04-07 13:59:24 -07001349 return NewVariableRefExpr(v)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001350 }
1351 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1352 }
1353
Cole Faustf035d402022-03-28 14:02:50 -07001354 if name, args, ok := ctx.maybeParseFunctionCall(node, ref); ok {
1355 if kf, found := knownFunctions[name]; found {
1356 return kf.parse(ctx, node, args)
Sasha Smundak6609ba72021-07-22 18:32:56 -07001357 } else {
Cole Faustf035d402022-03-28 14:02:50 -07001358 return ctx.newBadExpr(node, "cannot handle invoking %s", name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001359 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001360 }
Cole Faust1e275862022-04-26 14:28:04 -07001361 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001362}
1363
1364type simpleCallParser struct {
1365 name string
1366 returnType starlarkType
1367 addGlobals bool
Cole Faust1cc08852022-02-28 11:12:08 -08001368 addHandle bool
Cole Faust9ebf6e42021-12-13 14:08:34 -08001369}
1370
1371func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1372 expr := &callExpr{name: p.name, returnType: p.returnType}
1373 if p.addGlobals {
1374 expr.args = append(expr.args, &globalsExpr{})
1375 }
Cole Faust1cc08852022-02-28 11:12:08 -08001376 if p.addHandle {
1377 expr.args = append(expr.args, &identifierExpr{name: "handle"})
1378 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001379 for _, arg := range args.Split(",") {
1380 arg.TrimLeftSpaces()
1381 arg.TrimRightSpaces()
1382 x := ctx.parseMakeString(node, arg)
1383 if xBad, ok := x.(*badExpr); ok {
1384 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001385 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001386 expr.args = append(expr.args, x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001387 }
1388 return expr
1389}
1390
Cole Faust9ebf6e42021-12-13 14:08:34 -08001391type makeControlFuncParser struct {
1392 name string
1393}
1394
1395func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1396 // Make control functions need special treatment as everything
1397 // after the name is a single text argument
1398 x := ctx.parseMakeString(node, args)
1399 if xBad, ok := x.(*badExpr); ok {
1400 return xBad
1401 }
1402 return &callExpr{
1403 name: p.name,
1404 args: []starlarkExpr{
1405 &stringLiteralExpr{ctx.script.mkFile},
1406 x,
1407 },
1408 returnType: starlarkTypeUnknown,
1409 }
1410}
1411
1412type shellCallParser struct{}
1413
1414func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1415 // Shell functions need special treatment as everything
1416 // after the name is a single text argument
1417 x := ctx.parseMakeString(node, args)
1418 if xBad, ok := x.(*badExpr); ok {
1419 return xBad
1420 }
1421 return &callExpr{
1422 name: baseName + ".shell",
1423 args: []starlarkExpr{x},
1424 returnType: starlarkTypeUnknown,
1425 }
1426}
1427
1428type myDirCallParser struct{}
1429
1430func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1431 if !args.Empty() {
1432 return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.")
1433 }
Cole Faustf5adedc2022-03-18 14:05:06 -07001434 return &stringLiteralExpr{literal: filepath.Dir(ctx.script.mkFile)}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001435}
1436
Cole Faustd2daabf2022-12-12 17:38:01 -08001437type andOrParser struct {
1438 isAnd bool
1439}
1440
1441func (p *andOrParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1442 if args.Empty() {
1443 return ctx.newBadExpr(node, "and/or function must have at least 1 argument")
1444 }
1445 op := "or"
1446 if p.isAnd {
1447 op = "and"
1448 }
1449
1450 argsParsed := make([]starlarkExpr, 0)
1451
1452 for _, arg := range args.Split(",") {
1453 arg.TrimLeftSpaces()
1454 arg.TrimRightSpaces()
1455 x := ctx.parseMakeString(node, arg)
1456 if xBad, ok := x.(*badExpr); ok {
1457 return xBad
1458 }
1459 argsParsed = append(argsParsed, x)
1460 }
1461 typ := starlarkTypeUnknown
1462 for _, arg := range argsParsed {
1463 if typ != arg.typ() && arg.typ() != starlarkTypeUnknown && typ != starlarkTypeUnknown {
1464 return ctx.newBadExpr(node, "Expected all arguments to $(or) or $(and) to have the same type, found %q and %q", typ.String(), arg.typ().String())
1465 }
1466 if arg.typ() != starlarkTypeUnknown {
1467 typ = arg.typ()
1468 }
1469 }
1470 result := argsParsed[0]
1471 for _, arg := range argsParsed[1:] {
1472 result = &binaryOpExpr{
1473 left: result,
1474 right: arg,
1475 op: op,
1476 returnType: typ,
1477 }
1478 }
1479 return result
1480}
1481
Cole Faust9ebf6e42021-12-13 14:08:34 -08001482type isProductInListCallParser struct{}
1483
1484func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1485 if args.Empty() {
1486 return ctx.newBadExpr(node, "is-product-in-list requires an argument")
1487 }
1488 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001489 expr: NewVariableRefExpr(ctx.addVariable("TARGET_PRODUCT")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001490 list: maybeConvertToStringList(ctx.parseMakeString(node, args)),
1491 isNot: false,
1492 }
1493}
1494
1495type isVendorBoardPlatformCallParser struct{}
1496
1497func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1498 if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) {
1499 return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform")
1500 }
1501 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001502 expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
1503 list: NewVariableRefExpr(ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001504 isNot: false,
1505 }
1506}
1507
1508type isVendorBoardQcomCallParser struct{}
1509
1510func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1511 if !args.Empty() {
1512 return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments")
1513 }
1514 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001515 expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
1516 list: NewVariableRefExpr(ctx.addVariable("QCOM_BOARD_PLATFORMS")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001517 isNot: false,
1518 }
1519}
1520
1521type substCallParser struct {
1522 fname string
1523}
1524
1525func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001526 words := args.Split(",")
1527 if len(words) != 3 {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001528 return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001529 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001530 from := ctx.parseMakeString(node, words[0])
1531 if xBad, ok := from.(*badExpr); ok {
1532 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001533 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001534 to := ctx.parseMakeString(node, words[1])
1535 if xBad, ok := to.(*badExpr); ok {
1536 return xBad
1537 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001538 words[2].TrimLeftSpaces()
1539 words[2].TrimRightSpaces()
1540 obj := ctx.parseMakeString(node, words[2])
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001541 typ := obj.typ()
Cole Faust9ebf6e42021-12-13 14:08:34 -08001542 if typ == starlarkTypeString && p.fname == "subst" {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001543 // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001544 return &callExpr{
1545 object: obj,
1546 name: "replace",
Sasha Smundak35434ed2021-11-05 16:29:56 -07001547 args: []starlarkExpr{from, to},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001548 returnType: typ,
1549 }
1550 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001551 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001552 name: baseName + ".mk" + p.fname,
Sasha Smundak35434ed2021-11-05 16:29:56 -07001553 args: []starlarkExpr{from, to, obj},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001554 returnType: obj.typ(),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001555 }
1556}
1557
Cole Faust9ebf6e42021-12-13 14:08:34 -08001558type ifCallParser struct{}
1559
1560func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faust4eadba72021-12-07 11:54:52 -08001561 words := args.Split(",")
1562 if len(words) != 2 && len(words) != 3 {
1563 return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))
1564 }
1565 condition := ctx.parseMakeString(node, words[0])
1566 ifTrue := ctx.parseMakeString(node, words[1])
1567 var ifFalse starlarkExpr
1568 if len(words) == 3 {
1569 ifFalse = ctx.parseMakeString(node, words[2])
1570 } else {
1571 switch ifTrue.typ() {
1572 case starlarkTypeList:
1573 ifFalse = &listExpr{items: []starlarkExpr{}}
1574 case starlarkTypeInt:
1575 ifFalse = &intLiteralExpr{literal: 0}
1576 case starlarkTypeBool:
1577 ifFalse = &boolLiteralExpr{literal: false}
1578 default:
1579 ifFalse = &stringLiteralExpr{literal: ""}
1580 }
1581 }
1582 return &ifExpr{
1583 condition,
1584 ifTrue,
1585 ifFalse,
1586 }
1587}
1588
Cole Faustf035d402022-03-28 14:02:50 -07001589type ifCallNodeParser struct{}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001590
Cole Faustf035d402022-03-28 14:02:50 -07001591func (p *ifCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1592 words := args.Split(",")
1593 if len(words) != 2 && len(words) != 3 {
1594 return []starlarkNode{ctx.newBadNode(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))}
1595 }
1596
1597 ifn := &ifNode{expr: ctx.parseMakeString(node, words[0])}
1598 cases := []*switchCase{
1599 {
1600 gate: ifn,
1601 nodes: ctx.parseNodeMakeString(node, words[1]),
1602 },
1603 }
1604 if len(words) == 3 {
1605 cases = append(cases, &switchCase{
1606 gate: &elseNode{},
1607 nodes: ctx.parseNodeMakeString(node, words[2]),
1608 })
1609 }
1610 if len(cases) == 2 {
1611 if len(cases[1].nodes) == 0 {
1612 // Remove else branch if it has no contents
1613 cases = cases[:1]
1614 } else if len(cases[0].nodes) == 0 {
1615 // If the if branch has no contents but the else does,
1616 // move them to the if and negate its condition
1617 ifn.expr = negateExpr(ifn.expr)
1618 cases[0].nodes = cases[1].nodes
1619 cases = cases[:1]
1620 }
1621 }
1622
1623 return []starlarkNode{&switchNode{ssCases: cases}}
1624}
1625
1626type foreachCallParser struct{}
1627
1628func (p *foreachCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faustb0d32ab2021-12-09 14:00:59 -08001629 words := args.Split(",")
1630 if len(words) != 3 {
1631 return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))
1632 }
1633 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1634 return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier")
1635 }
1636 loopVarName := words[0].Strings[0]
1637 list := ctx.parseMakeString(node, words[1])
1638 action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr {
1639 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1640 return &identifierExpr{loopVarName}
1641 }
1642 return nil
1643 })
1644
1645 if list.typ() != starlarkTypeList {
1646 list = &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001647 name: baseName + ".words",
1648 returnType: starlarkTypeList,
Cole Faustb0d32ab2021-12-09 14:00:59 -08001649 args: []starlarkExpr{list},
1650 }
1651 }
1652
Cole Faust72374fc2022-05-05 11:45:04 -07001653 var result starlarkExpr = &foreachExpr{
Cole Faustb0d32ab2021-12-09 14:00:59 -08001654 varName: loopVarName,
1655 list: list,
1656 action: action,
1657 }
Cole Faust72374fc2022-05-05 11:45:04 -07001658
1659 if action.typ() == starlarkTypeList {
1660 result = &callExpr{
1661 name: baseName + ".flatten_2d_list",
1662 args: []starlarkExpr{result},
1663 returnType: starlarkTypeList,
1664 }
1665 }
1666
1667 return result
Cole Faustb0d32ab2021-12-09 14:00:59 -08001668}
1669
Cole Faustf035d402022-03-28 14:02:50 -07001670func transformNode(node starlarkNode, transformer func(expr starlarkExpr) starlarkExpr) {
1671 switch a := node.(type) {
1672 case *ifNode:
1673 a.expr = a.expr.transform(transformer)
1674 case *switchCase:
1675 transformNode(a.gate, transformer)
1676 for _, n := range a.nodes {
1677 transformNode(n, transformer)
1678 }
1679 case *switchNode:
1680 for _, n := range a.ssCases {
1681 transformNode(n, transformer)
1682 }
1683 case *exprNode:
1684 a.expr = a.expr.transform(transformer)
1685 case *assignmentNode:
1686 a.value = a.value.transform(transformer)
1687 case *foreachNode:
1688 a.list = a.list.transform(transformer)
1689 for _, n := range a.actions {
1690 transformNode(n, transformer)
1691 }
Cole Faust9df1d732022-04-26 16:27:22 -07001692 case *inheritNode:
1693 if b, ok := a.module.(inheritedDynamicModule); ok {
1694 b.path = b.path.transform(transformer)
1695 a.module = b
1696 }
1697 case *includeNode:
1698 if b, ok := a.module.(inheritedDynamicModule); ok {
1699 b.path = b.path.transform(transformer)
1700 a.module = b
1701 }
Cole Faustf035d402022-03-28 14:02:50 -07001702 }
1703}
1704
1705type foreachCallNodeParser struct{}
1706
1707func (p *foreachCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1708 words := args.Split(",")
1709 if len(words) != 3 {
1710 return []starlarkNode{ctx.newBadNode(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))}
1711 }
1712 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1713 return []starlarkNode{ctx.newBadNode(node, "first argument to foreach function must be a simple string identifier")}
1714 }
1715
1716 loopVarName := words[0].Strings[0]
1717
1718 list := ctx.parseMakeString(node, words[1])
1719 if list.typ() != starlarkTypeList {
1720 list = &callExpr{
1721 name: baseName + ".words",
1722 returnType: starlarkTypeList,
1723 args: []starlarkExpr{list},
1724 }
1725 }
1726
1727 actions := ctx.parseNodeMakeString(node, words[2])
1728 // TODO(colefaust): Replace transforming code with something more elegant
1729 for _, action := range actions {
1730 transformNode(action, func(expr starlarkExpr) starlarkExpr {
1731 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1732 return &identifierExpr{loopVarName}
1733 }
1734 return nil
1735 })
1736 }
1737
1738 return []starlarkNode{&foreachNode{
1739 varName: loopVarName,
1740 list: list,
1741 actions: actions,
1742 }}
1743}
1744
Cole Faust9ebf6e42021-12-13 14:08:34 -08001745type wordCallParser struct{}
1746
1747func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001748 words := args.Split(",")
1749 if len(words) != 2 {
1750 return ctx.newBadExpr(node, "word function should have 2 arguments")
1751 }
Cole Faust94c4a9a2022-04-22 17:43:52 -07001752 var index = 0
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001753 if words[0].Const() {
Cole Faust94c4a9a2022-04-22 17:43:52 -07001754 if i, err := strconv.Atoi(strings.TrimSpace(words[0].Strings[0])); err == nil {
1755 index = i
1756 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001757 }
1758 if index < 1 {
1759 return ctx.newBadExpr(node, "word index should be constant positive integer")
1760 }
1761 words[1].TrimLeftSpaces()
1762 words[1].TrimRightSpaces()
1763 array := ctx.parseMakeString(node, words[1])
Cole Faust94c4a9a2022-04-22 17:43:52 -07001764 if bad, ok := array.(*badExpr); ok {
1765 return bad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001766 }
1767 if array.typ() != starlarkTypeList {
Cole Faust94c4a9a2022-04-22 17:43:52 -07001768 array = &callExpr{
1769 name: baseName + ".words",
1770 args: []starlarkExpr{array},
1771 returnType: starlarkTypeList,
1772 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001773 }
Cole Faust94c4a9a2022-04-22 17:43:52 -07001774 return &indexExpr{array, &intLiteralExpr{index - 1}}
1775}
1776
1777type wordsCallParser struct{}
1778
1779func (p *wordsCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1780 args.TrimLeftSpaces()
1781 args.TrimRightSpaces()
1782 array := ctx.parseMakeString(node, args)
1783 if bad, ok := array.(*badExpr); ok {
1784 return bad
1785 }
1786 if array.typ() != starlarkTypeList {
1787 array = &callExpr{
1788 name: baseName + ".words",
1789 args: []starlarkExpr{array},
1790 returnType: starlarkTypeList,
1791 }
1792 }
1793 return &callExpr{
1794 name: "len",
1795 args: []starlarkExpr{array},
1796 returnType: starlarkTypeInt,
1797 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001798}
1799
Cole Faustb1103e22022-01-06 15:22:05 -08001800func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) {
1801 parsedArgs := make([]starlarkExpr, 0)
1802 for _, arg := range args.Split(",") {
1803 expr := ctx.parseMakeString(node, arg)
1804 if expr.typ() == starlarkTypeList {
1805 return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int")
1806 }
1807 if s, ok := maybeString(expr); ok {
1808 intVal, err := strconv.Atoi(strings.TrimSpace(s))
1809 if err != nil {
1810 return nil, err
1811 }
1812 expr = &intLiteralExpr{literal: intVal}
1813 } else if expr.typ() != starlarkTypeInt {
1814 expr = &callExpr{
1815 name: "int",
1816 args: []starlarkExpr{expr},
1817 returnType: starlarkTypeInt,
1818 }
1819 }
1820 parsedArgs = append(parsedArgs, expr)
1821 }
1822 if len(parsedArgs) != expectedArgs {
1823 return nil, fmt.Errorf("function should have %d arguments", expectedArgs)
1824 }
1825 return parsedArgs, nil
1826}
1827
1828type mathComparisonCallParser struct {
1829 op string
1830}
1831
1832func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1833 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1834 if err != nil {
1835 return ctx.newBadExpr(node, err.Error())
1836 }
1837 return &binaryOpExpr{
1838 left: parsedArgs[0],
1839 right: parsedArgs[1],
1840 op: p.op,
1841 returnType: starlarkTypeBool,
1842 }
1843}
1844
1845type mathMaxOrMinCallParser struct {
1846 function string
1847}
1848
1849func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1850 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1851 if err != nil {
1852 return ctx.newBadExpr(node, err.Error())
1853 }
1854 return &callExpr{
1855 object: nil,
1856 name: p.function,
1857 args: parsedArgs,
1858 returnType: starlarkTypeInt,
1859 }
1860}
1861
Cole Faustf035d402022-03-28 14:02:50 -07001862type evalNodeParser struct{}
1863
1864func (p *evalNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1865 parser := mkparser.NewParser("Eval expression", strings.NewReader(args.Dump()))
1866 nodes, errs := parser.Parse()
1867 if errs != nil {
1868 return []starlarkNode{ctx.newBadNode(node, "Unable to parse eval statement")}
1869 }
1870
1871 if len(nodes) == 0 {
1872 return []starlarkNode{}
1873 } else if len(nodes) == 1 {
1874 switch n := nodes[0].(type) {
1875 case *mkparser.Assignment:
1876 if n.Name.Const() {
1877 return ctx.handleAssignment(n)
1878 }
1879 case *mkparser.Comment:
1880 return []starlarkNode{&commentNode{strings.TrimSpace("#" + n.Comment)}}
Cole Faust20052982022-04-22 14:43:55 -07001881 case *mkparser.Directive:
1882 if n.Name == "include" || n.Name == "-include" {
1883 return ctx.handleInclude(n)
1884 }
1885 case *mkparser.Variable:
1886 // Technically inherit-product(-if-exists) don't need to be put inside
1887 // an eval, but some makefiles do it, presumably because they copy+pasted
1888 // from a $(eval include ...)
1889 if name, _, ok := ctx.maybeParseFunctionCall(n, n.Name); ok {
1890 if name == "inherit-product" || name == "inherit-product-if-exists" {
1891 return ctx.handleVariable(n)
1892 }
1893 }
Cole Faustf035d402022-03-28 14:02:50 -07001894 }
1895 }
1896
Cole Faust20052982022-04-22 14:43:55 -07001897 return []starlarkNode{ctx.newBadNode(node, "Eval expression too complex; only assignments, comments, includes, and inherit-products are supported")}
Cole Faustf035d402022-03-28 14:02:50 -07001898}
1899
Cole Faust2dee63d2022-12-12 18:11:00 -08001900type lowerUpperParser struct {
1901 isUpper bool
1902}
1903
1904func (p *lowerUpperParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1905 fn := "lower"
1906 if p.isUpper {
1907 fn = "upper"
1908 }
1909 arg := ctx.parseMakeString(node, args)
1910
1911 return &callExpr{
1912 object: arg,
1913 name: fn,
1914 returnType: starlarkTypeString,
1915 }
1916}
1917
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001918func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
1919 if mk.Const() {
1920 return &stringLiteralExpr{mk.Dump()}
1921 }
1922 if mkRef, ok := mk.SingleVariable(); ok {
1923 return ctx.parseReference(node, mkRef)
1924 }
1925 // If we reached here, it's neither string literal nor a simple variable,
1926 // we need a full-blown interpolation node that will generate
1927 // "a%b%c" % (X, Y) for a$(X)b$(Y)c
Cole Faustfc438682021-12-14 12:46:32 -08001928 parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings))
1929 for i := 0; i < len(parts); i++ {
1930 if i%2 == 0 {
1931 parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]}
1932 } else {
1933 parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name)
1934 if x, ok := parts[i].(*badExpr); ok {
1935 return x
1936 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001937 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001938 }
Cole Faustfc438682021-12-14 12:46:32 -08001939 return NewInterpolateExpr(parts)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001940}
1941
Cole Faustf035d402022-03-28 14:02:50 -07001942func (ctx *parseContext) parseNodeMakeString(node mkparser.Node, mk *mkparser.MakeString) []starlarkNode {
1943 // Discard any constant values in the make string, as they would be top level
1944 // string literals and do nothing.
1945 result := make([]starlarkNode, 0, len(mk.Variables))
1946 for i := range mk.Variables {
1947 result = append(result, ctx.handleVariable(&mk.Variables[i])...)
1948 }
1949 return result
1950}
1951
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001952// Handles the statements whose treatment is the same in all contexts: comment,
1953// assignment, variable (which is a macro call in reality) and all constructs that
1954// do not handle in any context ('define directive and any unrecognized stuff).
Cole Faustdd569ae2022-01-31 15:48:29 -08001955func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) []starlarkNode {
1956 var result []starlarkNode
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001957 switch x := node.(type) {
1958 case *mkparser.Comment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001959 if n, handled := ctx.maybeHandleAnnotation(x); handled && n != nil {
1960 result = []starlarkNode{n}
1961 } else if !handled {
1962 result = []starlarkNode{&commentNode{strings.TrimSpace("#" + x.Comment)}}
Cole Faust7940c6a2022-01-31 15:54:05 -08001963 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001964 case *mkparser.Assignment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001965 result = ctx.handleAssignment(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001966 case *mkparser.Variable:
Cole Faustdd569ae2022-01-31 15:48:29 -08001967 result = ctx.handleVariable(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001968 case *mkparser.Directive:
1969 switch x.Name {
1970 case "define":
Cole Faustdd569ae2022-01-31 15:48:29 -08001971 if res := ctx.maybeHandleDefine(x); res != nil {
1972 result = []starlarkNode{res}
1973 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001974 case "include", "-include":
Cole Faust20052982022-04-22 14:43:55 -07001975 result = ctx.handleInclude(x)
Cole Faust591a1fe2021-11-08 15:37:57 -08001976 case "ifeq", "ifneq", "ifdef", "ifndef":
Cole Faustdd569ae2022-01-31 15:48:29 -08001977 result = []starlarkNode{ctx.handleIfBlock(x)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001978 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001979 result = []starlarkNode{ctx.newBadNode(x, "unexpected directive %s", x.Name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001980 }
1981 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001982 result = []starlarkNode{ctx.newBadNode(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001983 }
Cole Faust6c934f62022-01-06 15:51:12 -08001984
1985 // Clear the includeTops after each non-comment statement
1986 // so that include annotations placed on certain statements don't apply
1987 // globally for the rest of the makefile was well.
Cole Faustf92c9f22022-03-14 14:35:50 -07001988 if _, wasComment := node.(*mkparser.Comment); !wasComment {
1989 ctx.atTopOfMakefile = false
Cole Faust6c934f62022-01-06 15:51:12 -08001990 ctx.includeTops = []string{}
1991 }
Cole Faustdd569ae2022-01-31 15:48:29 -08001992
1993 if result == nil {
1994 result = []starlarkNode{}
1995 }
Cole Faustf035d402022-03-28 14:02:50 -07001996
Cole Faustdd569ae2022-01-31 15:48:29 -08001997 return result
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001998}
1999
Cole Faustf92c9f22022-03-14 14:35:50 -07002000// The types allowed in a type_hint
2001var typeHintMap = map[string]starlarkType{
2002 "string": starlarkTypeString,
2003 "list": starlarkTypeList,
2004}
2005
Sasha Smundak6d852dd2021-09-27 20:34:39 -07002006// Processes annotation. An annotation is a comment that starts with #RBC# and provides
2007// a conversion hint -- say, where to look for the dynamically calculated inherit/include
Cole Faust7940c6a2022-01-31 15:54:05 -08002008// paths. Returns true if the comment was a successfully-handled annotation.
Cole Faustdd569ae2022-01-31 15:48:29 -08002009func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) (starlarkNode, bool) {
Sasha Smundak6d852dd2021-09-27 20:34:39 -07002010 maybeTrim := func(s, prefix string) (string, bool) {
2011 if strings.HasPrefix(s, prefix) {
2012 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
2013 }
2014 return s, false
2015 }
2016 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
2017 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -08002018 return nil, false
Sasha Smundak6d852dd2021-09-27 20:34:39 -07002019 }
2020 if p, ok := maybeTrim(annotation, "include_top"); ok {
Cole Faustf7ed5342021-12-21 14:15:12 -08002021 // Don't allow duplicate include tops, because then we will generate
2022 // invalid starlark code. (duplicate keys in the _entry dictionary)
2023 for _, top := range ctx.includeTops {
2024 if top == p {
Cole Faustdd569ae2022-01-31 15:48:29 -08002025 return nil, true
Cole Faustf7ed5342021-12-21 14:15:12 -08002026 }
2027 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -07002028 ctx.includeTops = append(ctx.includeTops, p)
Cole Faustdd569ae2022-01-31 15:48:29 -08002029 return nil, true
Cole Faustf92c9f22022-03-14 14:35:50 -07002030 } else if p, ok := maybeTrim(annotation, "type_hint"); ok {
2031 // Type hints must come at the beginning the file, to avoid confusion
2032 // if a type hint was specified later and thus only takes effect for half
2033 // of the file.
2034 if !ctx.atTopOfMakefile {
2035 return ctx.newBadNode(cnode, "type_hint annotations must come before the first Makefile statement"), true
2036 }
2037
2038 parts := strings.Fields(p)
2039 if len(parts) <= 1 {
2040 return ctx.newBadNode(cnode, "Invalid type_hint annotation: %s. Must be a variable type followed by a list of variables of that type", p), true
2041 }
2042
2043 var varType starlarkType
2044 if varType, ok = typeHintMap[parts[0]]; !ok {
2045 varType = starlarkTypeUnknown
2046 }
2047 if varType == starlarkTypeUnknown {
2048 return ctx.newBadNode(cnode, "Invalid type_hint annotation. Only list/string types are accepted, found %s", parts[0]), true
2049 }
2050
2051 for _, name := range parts[1:] {
2052 // Don't allow duplicate type hints
2053 if _, ok := ctx.typeHints[name]; ok {
2054 return ctx.newBadNode(cnode, "Duplicate type hint for variable %s", name), true
2055 }
2056 ctx.typeHints[name] = varType
2057 }
2058 return nil, true
Sasha Smundak6d852dd2021-09-27 20:34:39 -07002059 }
Cole Faustdd569ae2022-01-31 15:48:29 -08002060 return ctx.newBadNode(cnode, "unsupported annotation %s", cnode.Comment), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002061}
2062
2063func (ctx *parseContext) loadedModulePath(path string) string {
2064 // During the transition to Roboleaf some of the product configuration files
2065 // will be converted and checked in while the others will be generated on the fly
2066 // and run. The runner (rbcrun application) accommodates this by allowing three
2067 // different ways to specify the loaded file location:
2068 // 1) load(":<file>",...) loads <file> from the same directory
2069 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
2070 // 3) load("/absolute/path/to/<file> absolute path
2071 // If the file being generated and the file it wants to load are in the same directory,
2072 // generate option 1.
2073 // Otherwise, if output directory is not specified, generate 2)
2074 // Finally, if output directory has been specified and the file being generated and
2075 // the file it wants to load from are in the different directories, generate 2) or 3):
2076 // * if the file being loaded exists in the source tree, generate 2)
2077 // * otherwise, generate 3)
2078 // Finally, figure out the loaded module path and name and create a node for it
2079 loadedModuleDir := filepath.Dir(path)
2080 base := filepath.Base(path)
2081 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
2082 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
2083 return ":" + loadedModuleName
2084 }
2085 if ctx.outputDir == "" {
2086 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
2087 }
2088 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
2089 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
2090 }
2091 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
2092}
2093
Sasha Smundak3deb9682021-07-26 18:42:25 -07002094func (ctx *parseContext) addSoongNamespace(ns string) {
2095 if _, ok := ctx.soongNamespaces[ns]; ok {
2096 return
2097 }
2098 ctx.soongNamespaces[ns] = make(map[string]bool)
2099}
2100
2101func (ctx *parseContext) hasSoongNamespace(name string) bool {
2102 _, ok := ctx.soongNamespaces[name]
2103 return ok
2104}
2105
2106func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
2107 ctx.addSoongNamespace(namespaceName)
2108 vars := ctx.soongNamespaces[namespaceName]
2109 if replace {
2110 vars = make(map[string]bool)
2111 ctx.soongNamespaces[namespaceName] = vars
2112 }
2113 for _, v := range varNames {
2114 vars[v] = true
2115 }
2116}
2117
2118func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
2119 vars, ok := ctx.soongNamespaces[namespaceName]
2120 if ok {
2121 _, ok = vars[varName]
2122 }
2123 return ok
2124}
2125
Sasha Smundak422b6142021-11-11 18:31:59 -08002126func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation {
2127 return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())}
2128}
2129
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002130func (ss *StarlarkScript) String() string {
2131 return NewGenerateContext(ss).emit()
2132}
2133
2134func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07002135
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002136 var subs []string
2137 for _, src := range ss.inherited {
2138 subs = append(subs, src.originalPath)
2139 }
2140 return subs
2141}
2142
2143func (ss *StarlarkScript) HasErrors() bool {
2144 return ss.hasErrors
2145}
2146
2147// Convert reads and parses a makefile. If successful, parsed tree
2148// is returned and then can be passed to String() to get the generated
2149// Starlark file.
2150func Convert(req Request) (*StarlarkScript, error) {
2151 reader := req.Reader
2152 if reader == nil {
2153 mkContents, err := ioutil.ReadFile(req.MkFile)
2154 if err != nil {
2155 return nil, err
2156 }
2157 reader = bytes.NewBuffer(mkContents)
2158 }
2159 parser := mkparser.NewParser(req.MkFile, reader)
2160 nodes, errs := parser.Parse()
2161 if len(errs) > 0 {
2162 for _, e := range errs {
2163 fmt.Fprintln(os.Stderr, "ERROR:", e)
2164 }
2165 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
2166 }
2167 starScript := &StarlarkScript{
Sasha Smundak422b6142021-11-11 18:31:59 -08002168 moduleName: moduleNameForFile(req.MkFile),
2169 mkFile: req.MkFile,
Sasha Smundak422b6142021-11-11 18:31:59 -08002170 traceCalls: req.TraceCalls,
2171 sourceFS: req.SourceFS,
2172 makefileFinder: req.MakefileFinder,
2173 nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line },
Cole Faustdd569ae2022-01-31 15:48:29 -08002174 nodes: make([]starlarkNode, 0),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002175 }
2176 ctx := newParseContext(starScript, nodes)
2177 ctx.outputSuffix = req.OutputSuffix
2178 ctx.outputDir = req.OutputDir
2179 ctx.errorLogger = req.ErrorLogger
2180 if len(req.TracedVariables) > 0 {
2181 ctx.tracedVariables = make(map[string]bool)
2182 for _, v := range req.TracedVariables {
2183 ctx.tracedVariables[v] = true
2184 }
2185 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002186 for ctx.hasNodes() && ctx.fatalError == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -08002187 starScript.nodes = append(starScript.nodes, ctx.handleSimpleStatement(ctx.getNode())...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002188 }
2189 if ctx.fatalError != nil {
2190 return nil, ctx.fatalError
2191 }
2192 return starScript, nil
2193}
2194
Cole Faust864028a2021-12-01 13:43:17 -08002195func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002196 var buf bytes.Buffer
2197 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Cole Faust864028a2021-12-01 13:43:17 -08002198 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07002199 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
Cole Faust864028a2021-12-01 13:43:17 -08002200 fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002201 return buf.String()
2202}
2203
Cole Faust6ed7cb42021-10-07 17:08:46 -07002204func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
2205 var buf bytes.Buffer
2206 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
2207 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
2208 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Cole Fausta0604662022-02-28 11:53:58 -08002209 fmt.Fprintf(&buf, "%s(%s(init, input_variables_init))\n", cfnPrintVars, cfnBoardMain)
Cole Faust6ed7cb42021-10-07 17:08:46 -07002210 return buf.String()
2211}
2212
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002213func MakePath2ModuleName(mkPath string) string {
2214 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
2215}