blob: b8fe162392fba71eb8a016bd5767c0c7e1601d75 [file] [log] [blame]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001// Copyright 2021 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Convert makefile containing device configuration to Starlark file
16// The conversion can handle the following constructs in a makefile:
17// * comments
18// * simple variable assignments
19// * $(call init-product,<file>)
20// * $(call inherit-product-if-exists
21// * if directives
22// All other constructs are carried over to the output starlark file as comments.
23//
24package mk2rbc
25
26import (
27 "bytes"
28 "fmt"
29 "io"
Sasha Smundak6609ba72021-07-22 18:32:56 -070030 "io/fs"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080031 "io/ioutil"
32 "os"
33 "path/filepath"
34 "regexp"
35 "strconv"
36 "strings"
37 "text/scanner"
38
39 mkparser "android/soong/androidmk/parser"
40)
41
42const (
Sasha Smundak6d852dd2021-09-27 20:34:39 -070043 annotationCommentPrefix = "RBC#"
44 baseUri = "//build/make/core:product_config.rbc"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080045 // The name of the struct exported by the product_config.rbc
46 // that contains the functions and variables available to
47 // product configuration Starlark files.
48 baseName = "rblf"
49
Sasha Smundak65b547e2021-09-17 15:35:41 -070050 soongNsPrefix = "SOONG_CONFIG_"
51
Sasha Smundakb051c4e2020-11-05 20:45:07 -080052 // And here are the functions and variables:
53 cfnGetCfg = baseName + ".cfg"
54 cfnMain = baseName + ".product_configuration"
Cole Faust6ed7cb42021-10-07 17:08:46 -070055 cfnBoardMain = baseName + ".board_configuration"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080056 cfnPrintVars = baseName + ".printvars"
57 cfnWarning = baseName + ".warning"
58 cfnLocalAppend = baseName + ".local_append"
59 cfnLocalSetDefault = baseName + ".local_set_default"
60 cfnInherit = baseName + ".inherit"
61 cfnSetListDefault = baseName + ".setdefault"
62)
63
64const (
Cole Faust9ebf6e42021-12-13 14:08:34 -080065 soongConfigAppend = "soong_config_append"
66 soongConfigAssign = "soong_config_set"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080067)
68
Cole Faust9ebf6e42021-12-13 14:08:34 -080069var knownFunctions = map[string]interface {
70 parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -080071}{
Cole Faust9ebf6e42021-12-13 14:08:34 -080072 "abspath": &simpleCallParser{name: baseName + ".abspath", returnType: starlarkTypeString, addGlobals: false},
73 "add_soong_config_namespace": &simpleCallParser{name: baseName + ".soong_config_namespace", returnType: starlarkTypeVoid, addGlobals: true},
74 "add_soong_config_var_value": &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
75 soongConfigAssign: &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
76 soongConfigAppend: &simpleCallParser{name: baseName + ".soong_config_append", returnType: starlarkTypeVoid, addGlobals: true},
77 "soong_config_get": &simpleCallParser{name: baseName + ".soong_config_get", returnType: starlarkTypeString, addGlobals: true},
78 "add-to-product-copy-files-if-exists": &simpleCallParser{name: baseName + ".copy_if_exists", returnType: starlarkTypeList, addGlobals: false},
79 "addprefix": &simpleCallParser{name: baseName + ".addprefix", returnType: starlarkTypeList, addGlobals: false},
80 "addsuffix": &simpleCallParser{name: baseName + ".addsuffix", returnType: starlarkTypeList, addGlobals: false},
81 "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList, addGlobals: false},
82 "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeList, addGlobals: false},
83 "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true},
84 "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addGlobals: false},
85 "error": &makeControlFuncParser{name: baseName + ".mkerror"},
86 "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt, addGlobals: false},
87 "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList, addGlobals: false},
88 "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList, addGlobals: false},
89 "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList, addGlobals: false},
90 "firstword": &firstOrLastwordCallParser{isLastWord: false},
91 "foreach": &foreachCallPaser{},
92 "if": &ifCallParser{},
93 "info": &makeControlFuncParser{name: baseName + ".mkinfo"},
Cole Faustb2e0b602022-01-07 15:46:58 -080094 "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
Cole Faust9ebf6e42021-12-13 14:08:34 -080095 "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
Cole Faustb2e0b602022-01-07 15:46:58 -080096 "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
Cole Faust9ebf6e42021-12-13 14:08:34 -080097 "is-board-platform-in-list2": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
98 "is-product-in-list": &isProductInListCallParser{},
99 "is-vendor-board-platform": &isVendorBoardPlatformCallParser{},
100 "is-vendor-board-qcom": &isVendorBoardQcomCallParser{},
101 "lastword": &firstOrLastwordCallParser{isLastWord: true},
102 "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString, addGlobals: false},
Cole Faustb1103e22022-01-06 15:22:05 -0800103 "math_max": &mathMaxOrMinCallParser{function: "max"},
104 "math_min": &mathMaxOrMinCallParser{function: "min"},
105 "math_gt_or_eq": &mathComparisonCallParser{op: ">="},
106 "math_gt": &mathComparisonCallParser{op: ">"},
107 "math_lt": &mathComparisonCallParser{op: "<"},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800108 "my-dir": &myDirCallParser{},
109 "patsubst": &substCallParser{fname: "patsubst"},
110 "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList, addGlobals: false},
111 "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addGlobals: false},
112 "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addGlobals: false},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800113 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Cole Faust9ebf6e42021-12-13 14:08:34 -0800114 "shell": &shellCallParser{},
115 "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString, addGlobals: false},
116 "subst": &substCallParser{fname: "subst"},
117 "warning": &makeControlFuncParser{name: baseName + ".mkwarning"},
118 "word": &wordCallParser{},
119 "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList, addGlobals: false},
120}
121
122// These are functions that we don't implement conversions for, but
123// we allow seeing their definitions in the product config files.
124var ignoredDefines = map[string]bool{
125 "find-word-in-list": true, // internal macro
126 "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc.
127 "is-android-codename": true, // unused by product config
128 "is-android-codename-in-list": true, // unused by product config
129 "is-chipset-in-board-platform": true, // unused by product config
130 "is-chipset-prefix-in-board-platform": true, // unused by product config
131 "is-not-board-platform": true, // defined but never used
132 "is-platform-sdk-version-at-least": true, // unused by product config
133 "match-prefix": true, // internal macro
134 "match-word": true, // internal macro
135 "match-word-in-list": true, // internal macro
136 "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800137}
138
Cole Faustb0d32ab2021-12-09 14:00:59 -0800139var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800140
141// Conversion request parameters
142type Request struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800143 MkFile string // file to convert
144 Reader io.Reader // if set, read input from this stream instead
Sasha Smundak422b6142021-11-11 18:31:59 -0800145 OutputSuffix string // generated Starlark files suffix
146 OutputDir string // if set, root of the output hierarchy
147 ErrorLogger ErrorLogger
148 TracedVariables []string // trace assignment to these variables
149 TraceCalls bool
150 SourceFS fs.FS
151 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800152}
153
Sasha Smundak7d934b92021-11-10 12:20:01 -0800154// ErrorLogger prints errors and gathers error statistics.
155// Its NewError function is called on every error encountered during the conversion.
156type ErrorLogger interface {
Sasha Smundak422b6142021-11-11 18:31:59 -0800157 NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{})
158}
159
160type ErrorLocation struct {
161 MkFile string
162 MkLine int
163}
164
165func (el ErrorLocation) String() string {
166 return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800167}
168
169// Derives module name for a given file. It is base name
170// (file name without suffix), with some characters replaced to make it a Starlark identifier
171func moduleNameForFile(mkFile string) string {
172 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
173 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700174 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
175
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800176}
177
178func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
179 r := &mkparser.MakeString{StringPos: mkString.StringPos}
180 r.Strings = append(r.Strings, mkString.Strings...)
181 r.Variables = append(r.Variables, mkString.Variables...)
182 return r
183}
184
185func isMakeControlFunc(s string) bool {
186 return s == "error" || s == "warning" || s == "info"
187}
188
189// Starlark output generation context
190type generationContext struct {
191 buf strings.Builder
192 starScript *StarlarkScript
193 indentLevel int
194 inAssignment bool
195 tracedCount int
196}
197
198func NewGenerateContext(ss *StarlarkScript) *generationContext {
199 return &generationContext{starScript: ss}
200}
201
202// emit returns generated script
203func (gctx *generationContext) emit() string {
204 ss := gctx.starScript
205
206 // The emitted code has the following layout:
207 // <initial comments>
208 // preamble, i.e.,
209 // load statement for the runtime support
210 // load statement for each unique submodule pulled in by this one
211 // def init(g, handle):
212 // cfg = rblf.cfg(handle)
213 // <statements>
214 // <warning if conversion was not clean>
215
216 iNode := len(ss.nodes)
217 for i, node := range ss.nodes {
218 if _, ok := node.(*commentNode); !ok {
219 iNode = i
220 break
221 }
222 node.emit(gctx)
223 }
224
225 gctx.emitPreamble()
226
227 gctx.newLine()
228 // The arguments passed to the init function are the global dictionary
229 // ('g') and the product configuration dictionary ('cfg')
230 gctx.write("def init(g, handle):")
231 gctx.indentLevel++
232 if gctx.starScript.traceCalls {
233 gctx.newLine()
234 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
235 }
236 gctx.newLine()
237 gctx.writef("cfg = %s(handle)", cfnGetCfg)
238 for _, node := range ss.nodes[iNode:] {
239 node.emit(gctx)
240 }
241
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800242 if gctx.starScript.traceCalls {
243 gctx.newLine()
244 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
245 }
246 gctx.indentLevel--
247 gctx.write("\n")
248 return gctx.buf.String()
249}
250
251func (gctx *generationContext) emitPreamble() {
252 gctx.newLine()
253 gctx.writef("load(%q, %q)", baseUri, baseName)
254 // Emit exactly one load statement for each URI.
255 loadedSubConfigs := make(map[string]string)
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800256 for _, mi := range gctx.starScript.inherited {
257 uri := mi.path
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800258 if m, ok := loadedSubConfigs[uri]; ok {
259 // No need to emit load statement, but fix module name.
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800260 mi.moduleLocalName = m
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800261 continue
262 }
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800263 if mi.optional || mi.missing {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800264 uri += "|init"
265 }
266 gctx.newLine()
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800267 gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName())
268 loadedSubConfigs[uri] = mi.moduleLocalName
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800269 }
270 gctx.write("\n")
271}
272
273func (gctx *generationContext) emitPass() {
274 gctx.newLine()
275 gctx.write("pass")
276}
277
278func (gctx *generationContext) write(ss ...string) {
279 for _, s := range ss {
280 gctx.buf.WriteString(s)
281 }
282}
283
284func (gctx *generationContext) writef(format string, args ...interface{}) {
285 gctx.write(fmt.Sprintf(format, args...))
286}
287
288func (gctx *generationContext) newLine() {
289 if gctx.buf.Len() == 0 {
290 return
291 }
292 gctx.write("\n")
293 gctx.writef("%*s", 2*gctx.indentLevel, "")
294}
295
Sasha Smundak422b6142021-11-11 18:31:59 -0800296func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) {
297 gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message)
298}
299
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800300func (gctx *generationContext) emitLoadCheck(im inheritedModule) {
301 if !im.needsLoadCheck() {
302 return
303 }
304 gctx.newLine()
305 gctx.writef("if not %s:", im.entryName())
306 gctx.indentLevel++
307 gctx.newLine()
308 gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`)
309 im.pathExpr().emit(gctx)
310 gctx.write("))")
311 gctx.indentLevel--
312}
313
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800314type knownVariable struct {
315 name string
316 class varClass
317 valueType starlarkType
318}
319
320type knownVariables map[string]knownVariable
321
322func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
323 v, exists := pcv[name]
324 if !exists {
325 pcv[name] = knownVariable{name, varClass, valueType}
326 return
327 }
328 // Conflict resolution:
329 // * config class trumps everything
330 // * any type trumps unknown type
331 match := varClass == v.class
332 if !match {
333 if varClass == VarClassConfig {
334 v.class = VarClassConfig
335 match = true
336 } else if v.class == VarClassConfig {
337 match = true
338 }
339 }
340 if valueType != v.valueType {
341 if valueType != starlarkTypeUnknown {
342 if v.valueType == starlarkTypeUnknown {
343 v.valueType = valueType
344 } else {
345 match = false
346 }
347 }
348 }
349 if !match {
350 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
351 name, varClass, valueType, v.class, v.valueType)
352 }
353}
354
355// All known product variables.
356var KnownVariables = make(knownVariables)
357
358func init() {
359 for _, kv := range []string{
360 // Kernel-related variables that we know are lists.
361 "BOARD_VENDOR_KERNEL_MODULES",
362 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
363 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
364 "BOARD_RECOVERY_KERNEL_MODULES",
365 // Other variables we knwo are lists
366 "ART_APEX_JARS",
367 } {
368 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
369 }
370}
371
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800372// Information about the generated Starlark script.
373type StarlarkScript struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800374 mkFile string
375 moduleName string
376 mkPos scanner.Position
377 nodes []starlarkNode
378 inherited []*moduleInfo
379 hasErrors bool
Sasha Smundak422b6142021-11-11 18:31:59 -0800380 traceCalls bool // print enter/exit each init function
381 sourceFS fs.FS
382 makefileFinder MakefileFinder
383 nodeLocator func(pos mkparser.Pos) int
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800384}
385
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800386// varAssignmentScope points to the last assignment for each variable
387// in the current block. It is used during the parsing to chain
388// the assignments to a variable together.
389type varAssignmentScope struct {
390 outer *varAssignmentScope
391 vars map[string]*assignmentNode
392}
393
394// parseContext holds the script we are generating and all the ephemeral data
395// needed during the parsing.
396type parseContext struct {
397 script *StarlarkScript
398 nodes []mkparser.Node // Makefile as parsed by mkparser
399 currentNodeIndex int // Node in it we are processing
400 ifNestLevel int
401 moduleNameCount map[string]int // count of imported modules with given basename
402 fatalError error
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800403 outputSuffix string
Sasha Smundak7d934b92021-11-10 12:20:01 -0800404 errorLogger ErrorLogger
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800405 tracedVariables map[string]bool // variables to be traced in the generated script
406 variables map[string]variable
407 varAssignments *varAssignmentScope
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800408 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700409 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700410 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700411 includeTops []string
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800412}
413
414func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
415 predefined := []struct{ name, value string }{
416 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
417 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Cole Faust9b6111a2022-02-02 15:38:33 -0800418 {"TOPDIR", ""}, // TOPDIR is just set to an empty string in cleanbuild.mk and core.mk
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800419 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
420 {"TARGET_COPY_OUT_SYSTEM", "system"},
421 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
422 {"TARGET_COPY_OUT_DATA", "data"},
423 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
424 {"TARGET_COPY_OUT_OEM", "oem"},
425 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
426 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
427 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
428 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
429 {"TARGET_COPY_OUT_ROOT", "root"},
430 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800431 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800432 // TODO(asmundak): to process internal config files, we need the following variables:
433 // BOARD_CONFIG_VENDOR_PATH
434 // TARGET_VENDOR
435 // target_base_product
436 //
437
438 // the following utility variables are set in build/make/common/core.mk:
439 {"empty", ""},
440 {"space", " "},
441 {"comma", ","},
442 {"newline", "\n"},
443 {"pound", "#"},
444 {"backslash", "\\"},
445 }
446 ctx := &parseContext{
447 script: ss,
448 nodes: nodes,
449 currentNodeIndex: 0,
450 ifNestLevel: 0,
451 moduleNameCount: make(map[string]int),
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800452 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700453 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700454 soongNamespaces: make(map[string]map[string]bool),
Cole Faust6c934f62022-01-06 15:51:12 -0800455 includeTops: []string{},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800456 }
457 ctx.pushVarAssignments()
458 for _, item := range predefined {
459 ctx.variables[item.name] = &predefinedVariable{
460 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
461 value: &stringLiteralExpr{item.value},
462 }
463 }
464
465 return ctx
466}
467
468func (ctx *parseContext) lastAssignment(name string) *assignmentNode {
469 for va := ctx.varAssignments; va != nil; va = va.outer {
470 if v, ok := va.vars[name]; ok {
471 return v
472 }
473 }
474 return nil
475}
476
477func (ctx *parseContext) setLastAssignment(name string, asgn *assignmentNode) {
478 ctx.varAssignments.vars[name] = asgn
479}
480
481func (ctx *parseContext) pushVarAssignments() {
482 va := &varAssignmentScope{
483 outer: ctx.varAssignments,
484 vars: make(map[string]*assignmentNode),
485 }
486 ctx.varAssignments = va
487}
488
489func (ctx *parseContext) popVarAssignments() {
490 ctx.varAssignments = ctx.varAssignments.outer
491}
492
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800493func (ctx *parseContext) hasNodes() bool {
494 return ctx.currentNodeIndex < len(ctx.nodes)
495}
496
497func (ctx *parseContext) getNode() mkparser.Node {
498 if !ctx.hasNodes() {
499 return nil
500 }
501 node := ctx.nodes[ctx.currentNodeIndex]
502 ctx.currentNodeIndex++
503 return node
504}
505
506func (ctx *parseContext) backNode() {
507 if ctx.currentNodeIndex <= 0 {
508 panic("Cannot back off")
509 }
510 ctx.currentNodeIndex--
511}
512
Cole Faustdd569ae2022-01-31 15:48:29 -0800513func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800514 // Handle only simple variables
515 if !a.Name.Const() {
Cole Faustdd569ae2022-01-31 15:48:29 -0800516 return []starlarkNode{ctx.newBadNode(a, "Only simple variables are handled")}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800517 }
518 name := a.Name.Strings[0]
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800519 // The `override` directive
520 // override FOO :=
521 // is parsed as an assignment to a variable named `override FOO`.
522 // There are very few places where `override` is used, just flag it.
523 if strings.HasPrefix(name, "override ") {
Cole Faustdd569ae2022-01-31 15:48:29 -0800524 return []starlarkNode{ctx.newBadNode(a, "cannot handle override directive")}
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800525 }
526
Cole Faustc00184e2021-11-08 12:08:57 -0800527 // Soong configuration
Sasha Smundak3deb9682021-07-26 18:42:25 -0700528 if strings.HasPrefix(name, soongNsPrefix) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800529 return ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700530 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800531 lhs := ctx.addVariable(name)
532 if lhs == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -0800533 return []starlarkNode{ctx.newBadNode(a, "unknown variable %s", name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800534 }
535 _, isTraced := ctx.tracedVariables[name]
Sasha Smundak422b6142021-11-11 18:31:59 -0800536 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800537 if lhs.valueType() == starlarkTypeUnknown {
538 // Try to divine variable type from the RHS
539 asgn.value = ctx.parseMakeString(a, a.Value)
540 if xBad, ok := asgn.value.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800541 return []starlarkNode{&exprNode{xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800542 }
543 inferred_type := asgn.value.typ()
544 if inferred_type != starlarkTypeUnknown {
Sasha Smundak9d011ab2021-07-09 16:00:57 -0700545 lhs.setValueType(inferred_type)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800546 }
547 }
548 if lhs.valueType() == starlarkTypeList {
Cole Faustdd569ae2022-01-31 15:48:29 -0800549 xConcat, xBad := ctx.buildConcatExpr(a)
550 if xBad != nil {
551 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800552 }
553 switch len(xConcat.items) {
554 case 0:
555 asgn.value = &listExpr{}
556 case 1:
557 asgn.value = xConcat.items[0]
558 default:
559 asgn.value = xConcat
560 }
561 } else {
562 asgn.value = ctx.parseMakeString(a, a.Value)
563 if xBad, ok := asgn.value.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800564 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800565 }
566 }
567
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800568 asgn.previous = ctx.lastAssignment(name)
569 ctx.setLastAssignment(name, asgn)
570 switch a.Type {
571 case "=", ":=":
572 asgn.flavor = asgnSet
573 case "+=":
574 if asgn.previous == nil && !asgn.lhs.isPreset() {
575 asgn.flavor = asgnMaybeAppend
576 } else {
577 asgn.flavor = asgnAppend
578 }
579 case "?=":
580 asgn.flavor = asgnMaybeSet
581 default:
582 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
583 }
584
Cole Faustdd569ae2022-01-31 15:48:29 -0800585 return []starlarkNode{asgn}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800586}
587
Cole Faustdd569ae2022-01-31 15:48:29 -0800588func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) []starlarkNode {
Sasha Smundak3deb9682021-07-26 18:42:25 -0700589 val := ctx.parseMakeString(asgn, asgn.Value)
590 if xBad, ok := val.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800591 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700592 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700593
594 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
595 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
596 // Try to divine the call from the assignment as follows:
597 if name == "NAMESPACES" {
598 // Upon seeng
599 // SOONG_CONFIG_NAMESPACES += foo
600 // remember that there is a namespace `foo` and act as we saw
601 // $(call add_soong_config_namespace,foo)
602 s, ok := maybeString(val)
603 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800604 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 -0700605 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800606 result := make([]starlarkNode, 0)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700607 for _, ns := range strings.Fields(s) {
608 ctx.addSoongNamespace(ns)
Cole Faustdd569ae2022-01-31 15:48:29 -0800609 result = append(result, &exprNode{&callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -0800610 name: baseName + ".soong_config_namespace",
611 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700612 returnType: starlarkTypeVoid,
613 }})
614 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800615 return result
Sasha Smundak3deb9682021-07-26 18:42:25 -0700616 } else {
617 // Upon seeing
618 // SOONG_CONFIG_x_y = v
619 // find a namespace called `x` and act as if we encountered
Cole Faustc00184e2021-11-08 12:08:57 -0800620 // $(call soong_config_set,x,y,v)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700621 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
622 // it.
623 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
624 // and `foo` with a variable `bar_baz`.
625 namespaceName := ""
626 if ctx.hasSoongNamespace(name) {
627 namespaceName = name
628 }
629 var varName string
630 for pos, ch := range name {
631 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
632 continue
633 }
634 if namespaceName != "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800635 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 -0700636 }
637 namespaceName = name[0:pos]
638 varName = name[pos+1:]
639 }
640 if namespaceName == "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800641 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 -0700642 }
643 if varName == "" {
644 // Remember variables in this namespace
645 s, ok := maybeString(val)
646 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800647 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 -0700648 }
649 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
Cole Faustdd569ae2022-01-31 15:48:29 -0800650 return []starlarkNode{}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700651 }
652
653 // Finally, handle assignment to a namespace variable
654 if !ctx.hasNamespaceVar(namespaceName, varName) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800655 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 -0700656 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800657 fname := baseName + "." + soongConfigAssign
Sasha Smundak65b547e2021-09-17 15:35:41 -0700658 if asgn.Type == "+=" {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800659 fname = baseName + "." + soongConfigAppend
Sasha Smundak65b547e2021-09-17 15:35:41 -0700660 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800661 return []starlarkNode{&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700662 name: fname,
Cole Faust9ebf6e42021-12-13 14:08:34 -0800663 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700664 returnType: starlarkTypeVoid,
Cole Faustdd569ae2022-01-31 15:48:29 -0800665 }}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700666 }
667}
668
Cole Faustdd569ae2022-01-31 15:48:29 -0800669func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) (*concatExpr, *badExpr) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800670 xConcat := &concatExpr{}
671 var xItemList *listExpr
672 addToItemList := func(x ...starlarkExpr) {
673 if xItemList == nil {
674 xItemList = &listExpr{[]starlarkExpr{}}
675 }
676 xItemList.items = append(xItemList.items, x...)
677 }
678 finishItemList := func() {
679 if xItemList != nil {
680 xConcat.items = append(xConcat.items, xItemList)
681 xItemList = nil
682 }
683 }
684
685 items := a.Value.Words()
686 for _, item := range items {
687 // A function call in RHS is supposed to return a list, all other item
688 // expressions return individual elements.
689 switch x := ctx.parseMakeString(a, item).(type) {
690 case *badExpr:
Cole Faustdd569ae2022-01-31 15:48:29 -0800691 return nil, x
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800692 case *stringLiteralExpr:
693 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
694 default:
695 switch x.typ() {
696 case starlarkTypeList:
697 finishItemList()
698 xConcat.items = append(xConcat.items, x)
699 case starlarkTypeString:
700 finishItemList()
701 xConcat.items = append(xConcat.items, &callExpr{
702 object: x,
703 name: "split",
704 args: nil,
705 returnType: starlarkTypeList,
706 })
707 default:
708 addToItemList(x)
709 }
710 }
711 }
712 if xItemList != nil {
713 xConcat.items = append(xConcat.items, xItemList)
714 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800715 return xConcat, nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800716}
717
Sasha Smundak6609ba72021-07-22 18:32:56 -0700718func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
719 modulePath := ctx.loadedModulePath(path)
720 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700721 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700722 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800723 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800724 moduleName := moduleNameForFile(path)
725 moduleLocalName := "_" + moduleName
726 n, found := ctx.moduleNameCount[moduleName]
727 if found {
728 moduleLocalName += fmt.Sprintf("%d", n)
729 }
730 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800731 _, err := fs.Stat(ctx.script.sourceFS, path)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700732 mi := &moduleInfo{
733 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800734 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800735 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700736 optional: optional,
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800737 missing: err != nil,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800738 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700739 ctx.dependentModules[modulePath] = mi
740 ctx.script.inherited = append(ctx.script.inherited, mi)
741 return mi
742}
743
744func (ctx *parseContext) handleSubConfig(
Cole Faustdd569ae2022-01-31 15:48:29 -0800745 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule) starlarkNode) []starlarkNode {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700746
747 // In a simple case, the name of a module to inherit/include is known statically.
748 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700749 // Note that even if this directive loads a module unconditionally, a module may be
750 // absent without causing any harm if this directive is inside an if/else block.
751 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700752 if strings.Contains(path, "*") {
753 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -0800754 result := make([]starlarkNode, 0)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700755 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700756 mi := ctx.newDependentModule(p, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800757 result = append(result, processModule(inheritedStaticModule{mi, loadAlways}))
Sasha Smundak6609ba72021-07-22 18:32:56 -0700758 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800759 return result
Sasha Smundak6609ba72021-07-22 18:32:56 -0700760 } else {
Cole Faustdd569ae2022-01-31 15:48:29 -0800761 return []starlarkNode{ctx.newBadNode(v, "cannot glob wildcard argument")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700762 }
763 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700764 mi := ctx.newDependentModule(path, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800765 return []starlarkNode{processModule(inheritedStaticModule{mi, loadAlways})}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700766 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700767 }
768
769 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
770 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
771 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
772 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
773 // We then emit the code that loads all of them, e.g.:
774 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
775 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
776 // And then inherit it as follows:
777 // _e = {
778 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
779 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
780 // if _e:
781 // rblf.inherit(handle, _e[0], _e[1])
782 //
783 var matchingPaths []string
784 varPath, ok := pathExpr.(*interpolateExpr)
785 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800786 return []starlarkNode{ctx.newBadNode(v, "inherit-product/include argument is too complex")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700787 }
788
789 pathPattern := []string{varPath.chunks[0]}
790 for _, chunk := range varPath.chunks[1:] {
791 if chunk != "" {
792 pathPattern = append(pathPattern, chunk)
793 }
794 }
Cole Faust069aba62022-01-26 17:47:33 -0800795 if pathPattern[0] == "" && len(ctx.includeTops) > 0 {
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700796 // If pattern starts from the top. restrict it to the directories where
797 // we know inherit-product uses dynamically calculated path.
798 for _, p := range ctx.includeTops {
799 pathPattern[0] = p
800 matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700801 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700802 } else {
803 matchingPaths = ctx.findMatchingPaths(pathPattern)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700804 }
805 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700806 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700807 if len(matchingPaths) > maxMatchingFiles {
Cole Faustdd569ae2022-01-31 15:48:29 -0800808 return []starlarkNode{ctx.newBadNode(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700809 }
Cole Faust069aba62022-01-26 17:47:33 -0800810 if len(matchingPaths) == 1 {
811 res := inheritedStaticModule{ctx.newDependentModule(matchingPaths[0], loadAlways && ctx.ifNestLevel == 0), loadAlways}
Cole Faustdd569ae2022-01-31 15:48:29 -0800812 return []starlarkNode{processModule(res)}
Cole Faust069aba62022-01-26 17:47:33 -0800813 } else {
814 needsWarning := pathPattern[0] == "" && len(ctx.includeTops) == 0
815 res := inheritedDynamicModule{*varPath, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning}
816 for _, p := range matchingPaths {
817 // A product configuration files discovered dynamically may attempt to inherit
818 // from another one which does not exist in this source tree. Prevent load errors
819 // by always loading the dynamic files as optional.
820 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
821 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800822 return []starlarkNode{processModule(res)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700823 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700824}
825
826func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
Cole Faust9b6111a2022-02-02 15:38:33 -0800827 files := ctx.script.makefileFinder.Find(".")
Sasha Smundak6609ba72021-07-22 18:32:56 -0700828 if len(pattern) == 0 {
829 return files
830 }
831
832 // Create regular expression from the pattern
833 s_regexp := "^" + regexp.QuoteMeta(pattern[0])
834 for _, s := range pattern[1:] {
835 s_regexp += ".*" + regexp.QuoteMeta(s)
836 }
837 s_regexp += "$"
838 rex := regexp.MustCompile(s_regexp)
839
840 // Now match
841 var res []string
842 for _, p := range files {
843 if rex.MatchString(p) {
844 res = append(res, p)
845 }
846 }
847 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800848}
849
Cole Faustdd569ae2022-01-31 15:48:29 -0800850func (ctx *parseContext) handleInheritModule(v mkparser.Node, args *mkparser.MakeString, loadAlways bool) []starlarkNode {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800851 args.TrimLeftSpaces()
852 args.TrimRightSpaces()
853 pathExpr := ctx.parseMakeString(v, args)
854 if _, ok := pathExpr.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800855 return []starlarkNode{ctx.newBadNode(v, "Unable to parse argument to inherit")}
Cole Faust9ebf6e42021-12-13 14:08:34 -0800856 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800857 return ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) starlarkNode {
858 return &inheritNode{im, loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700859 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800860}
861
Cole Faustdd569ae2022-01-31 15:48:29 -0800862func (ctx *parseContext) handleInclude(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) []starlarkNode {
863 return ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) starlarkNode {
864 return &includeNode{im, loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700865 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800866}
867
Cole Faustdd569ae2022-01-31 15:48:29 -0800868func (ctx *parseContext) handleVariable(v *mkparser.Variable) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800869 // Handle:
870 // $(call inherit-product,...)
871 // $(call inherit-product-if-exists,...)
872 // $(info xxx)
873 // $(warning xxx)
874 // $(error xxx)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800875 // $(call other-custom-functions,...)
876
877 // inherit-product(-if-exists) gets converted to a series of statements,
878 // not just a single expression like parseReference returns. So handle it
879 // separately at the beginning here.
880 if strings.HasPrefix(v.Name.Dump(), "call inherit-product,") {
881 args := v.Name.Clone()
882 args.ReplaceLiteral("call inherit-product,", "")
Cole Faustdd569ae2022-01-31 15:48:29 -0800883 return ctx.handleInheritModule(v, args, true)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800884 }
885 if strings.HasPrefix(v.Name.Dump(), "call inherit-product-if-exists,") {
886 args := v.Name.Clone()
887 args.ReplaceLiteral("call inherit-product-if-exists,", "")
Cole Faustdd569ae2022-01-31 15:48:29 -0800888 return ctx.handleInheritModule(v, args, false)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800889 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800890 return []starlarkNode{&exprNode{expr: ctx.parseReference(v, v.Name)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800891}
892
Cole Faustdd569ae2022-01-31 15:48:29 -0800893func (ctx *parseContext) maybeHandleDefine(directive *mkparser.Directive) starlarkNode {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700894 macro_name := strings.Fields(directive.Args.Strings[0])[0]
895 // Ignore the macros that we handle
Cole Faust9ebf6e42021-12-13 14:08:34 -0800896 _, ignored := ignoredDefines[macro_name]
897 _, known := knownFunctions[macro_name]
898 if !ignored && !known {
Cole Faustdd569ae2022-01-31 15:48:29 -0800899 return ctx.newBadNode(directive, "define is not supported: %s", macro_name)
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700900 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800901 return nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800902}
903
Cole Faustdd569ae2022-01-31 15:48:29 -0800904func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) starlarkNode {
905 ssSwitch := &switchNode{
906 ssCases: []*switchCase{ctx.processBranch(ifDirective)},
907 }
908 for ctx.hasNodes() && ctx.fatalError == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800909 node := ctx.getNode()
910 switch x := node.(type) {
911 case *mkparser.Directive:
912 switch x.Name {
913 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
Cole Faustdd569ae2022-01-31 15:48:29 -0800914 ssSwitch.ssCases = append(ssSwitch.ssCases, ctx.processBranch(x))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800915 case "endif":
Cole Faustdd569ae2022-01-31 15:48:29 -0800916 return ssSwitch
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800917 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800918 return ctx.newBadNode(node, "unexpected directive %s", x.Name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800919 }
920 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800921 return ctx.newBadNode(ifDirective, "unexpected statement")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800922 }
923 }
924 if ctx.fatalError == nil {
925 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
926 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800927 return ctx.newBadNode(ifDirective, "no matching endif for %s", ifDirective.Dump())
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800928}
929
930// processBranch processes a single branch (if/elseif/else) until the next directive
931// on the same level.
Cole Faustdd569ae2022-01-31 15:48:29 -0800932func (ctx *parseContext) processBranch(check *mkparser.Directive) *switchCase {
933 block := &switchCase{gate: ctx.parseCondition(check)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800934 defer func() {
935 ctx.popVarAssignments()
936 ctx.ifNestLevel--
937
938 }()
939 ctx.pushVarAssignments()
940 ctx.ifNestLevel++
941
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800942 for ctx.hasNodes() {
943 node := ctx.getNode()
Cole Faust591a1fe2021-11-08 15:37:57 -0800944 if d, ok := node.(*mkparser.Directive); ok {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800945 switch d.Name {
946 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800947 ctx.backNode()
Cole Faustdd569ae2022-01-31 15:48:29 -0800948 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800949 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800950 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800951 block.nodes = append(block.nodes, ctx.handleSimpleStatement(node)...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800952 }
953 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
Cole Faustdd569ae2022-01-31 15:48:29 -0800954 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800955}
956
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800957func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
958 switch check.Name {
959 case "ifdef", "ifndef", "elifdef", "elifndef":
Cole Faust71514c02022-01-27 17:21:41 -0800960 if !check.Args.Const() {
Cole Faustdd569ae2022-01-31 15:48:29 -0800961 return ctx.newBadNode(check, "ifdef variable ref too complex: %s", check.Args.Dump())
Cole Faust71514c02022-01-27 17:21:41 -0800962 }
963 v := NewVariableRefExpr(ctx.addVariable(check.Args.Strings[0]), false)
964 if strings.HasSuffix(check.Name, "ndef") {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800965 v = &notExpr{v}
966 }
967 return &ifNode{
968 isElif: strings.HasPrefix(check.Name, "elif"),
969 expr: v,
970 }
971 case "ifeq", "ifneq", "elifeq", "elifneq":
972 return &ifNode{
973 isElif: strings.HasPrefix(check.Name, "elif"),
974 expr: ctx.parseCompare(check),
975 }
976 case "else":
977 return &elseNode{}
978 default:
979 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
980 }
981}
982
983func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800984 if ctx.errorLogger != nil {
Sasha Smundak422b6142021-11-11 18:31:59 -0800985 ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800986 }
987 ctx.script.hasErrors = true
Cole Faustdd569ae2022-01-31 15:48:29 -0800988 return &badExpr{errorLocation: ctx.errorLocation(node), message: fmt.Sprintf(text, args...)}
989}
990
991// records that the given node failed to be converted and includes an explanatory message
992func (ctx *parseContext) newBadNode(failedNode mkparser.Node, message string, args ...interface{}) starlarkNode {
993 return &exprNode{ctx.newBadExpr(failedNode, message, args...)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800994}
995
996func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
997 // Strip outer parentheses
998 mkArg := cloneMakeString(cond.Args)
999 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1000 n := len(mkArg.Strings)
1001 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1002 args := mkArg.Split(",")
1003 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1004 if len(args) != 2 {
1005 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1006 }
1007 args[0].TrimRightSpaces()
1008 args[1].TrimLeftSpaces()
1009
1010 isEq := !strings.HasSuffix(cond.Name, "neq")
Cole Faustf8320212021-11-10 15:05:07 -08001011 xLeft := ctx.parseMakeString(cond, args[0])
1012 xRight := ctx.parseMakeString(cond, args[1])
1013 if bad, ok := xLeft.(*badExpr); ok {
1014 return bad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001015 }
Cole Faustf8320212021-11-10 15:05:07 -08001016 if bad, ok := xRight.(*badExpr); ok {
1017 return bad
1018 }
1019
1020 if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok {
1021 return expr
1022 }
1023
Cole Faust9ebf6e42021-12-13 14:08:34 -08001024 var stringOperand string
1025 var otherOperand starlarkExpr
1026 if s, ok := maybeString(xLeft); ok {
1027 stringOperand = s
1028 otherOperand = xRight
1029 } else if s, ok := maybeString(xRight); ok {
1030 stringOperand = s
1031 otherOperand = xLeft
1032 }
1033
1034 not := func(expr starlarkExpr) starlarkExpr {
1035 switch typedExpr := expr.(type) {
1036 case *inExpr:
1037 typedExpr.isNot = !typedExpr.isNot
1038 return typedExpr
1039 case *eqExpr:
1040 typedExpr.isEq = !typedExpr.isEq
1041 return typedExpr
Cole Faustb1103e22022-01-06 15:22:05 -08001042 case *binaryOpExpr:
1043 switch typedExpr.op {
1044 case ">":
1045 typedExpr.op = "<="
1046 return typedExpr
1047 case "<":
1048 typedExpr.op = ">="
1049 return typedExpr
1050 case ">=":
1051 typedExpr.op = "<"
1052 return typedExpr
1053 case "<=":
1054 typedExpr.op = ">"
1055 return typedExpr
1056 default:
1057 return &notExpr{expr: expr}
1058 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001059 default:
1060 return &notExpr{expr: expr}
1061 }
1062 }
1063
1064 // If we've identified one of the operands as being a string literal, check
1065 // for some special cases we can do to simplify the resulting expression.
1066 if otherOperand != nil {
1067 if stringOperand == "" {
1068 if isEq {
1069 return not(otherOperand)
1070 } else {
1071 return otherOperand
1072 }
1073 }
1074 if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool {
1075 if !isEq {
1076 return not(otherOperand)
1077 } else {
1078 return otherOperand
1079 }
1080 }
Cole Faustb1103e22022-01-06 15:22:05 -08001081 if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt {
1082 return &eqExpr{
1083 left: otherOperand,
1084 right: &intLiteralExpr{literal: intOperand},
1085 isEq: isEq,
1086 }
1087 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001088 }
1089
Cole Faustf8320212021-11-10 15:05:07 -08001090 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001091}
1092
Cole Faustf8320212021-11-10 15:05:07 -08001093// Given an if statement's directive and the left/right starlarkExprs,
1094// check if the starlarkExprs are one of a few hardcoded special cases
1095// that can be converted to a simpler equalify expression than simply comparing
1096// the two.
1097func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr,
1098 right starlarkExpr) (starlarkExpr, bool) {
1099 isEq := !strings.HasSuffix(directive.Name, "neq")
1100
1101 // All the special cases require a call on one side and a
1102 // string literal/variable on the other. Turn the left/right variables into
1103 // call/value variables, and return false if that's not possible.
1104 var value starlarkExpr = nil
1105 call, ok := left.(*callExpr)
1106 if ok {
1107 switch right.(type) {
1108 case *stringLiteralExpr, *variableRefExpr:
1109 value = right
1110 }
1111 } else {
1112 call, _ = right.(*callExpr)
1113 switch left.(type) {
1114 case *stringLiteralExpr, *variableRefExpr:
1115 value = left
1116 }
1117 }
1118
1119 if call == nil || value == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001120 return nil, false
1121 }
Cole Faustf8320212021-11-10 15:05:07 -08001122
Cole Faustf8320212021-11-10 15:05:07 -08001123 switch call.name {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001124 case baseName + ".filter", baseName + ".filter-out":
Cole Faustf8320212021-11-10 15:05:07 -08001125 return ctx.parseCompareFilterFuncResult(directive, call, value, isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001126 case baseName + ".expand_wildcard":
Cole Faustf8320212021-11-10 15:05:07 -08001127 return ctx.parseCompareWildcardFuncResult(directive, call, value, !isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001128 case baseName + ".findstring":
Cole Faustf8320212021-11-10 15:05:07 -08001129 return ctx.parseCheckFindstringFuncResult(directive, call, value, !isEq), true
Cole Faust9ebf6e42021-12-13 14:08:34 -08001130 case baseName + ".strip":
Cole Faustf8320212021-11-10 15:05:07 -08001131 return ctx.parseCompareStripFuncResult(directive, call, value, !isEq), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001132 }
Cole Faustf8320212021-11-10 15:05:07 -08001133 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001134}
1135
1136func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
1137 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1138 // We handle:
Sasha Smundak0554d762021-07-08 18:26:12 -07001139 // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
1140 // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001141 // * ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...) becomes if VAR in/not in ["v1", "v2"]
1142 // TODO(Asmundak): check the last case works for filter-out, too.
1143 xPattern := filterFuncCall.args[0]
1144 xText := filterFuncCall.args[1]
1145 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001146 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001147 var ok bool
1148 switch x := xValue.(type) {
1149 case *stringLiteralExpr:
1150 if x.literal != "" {
1151 return ctx.newBadExpr(cond, "filter comparison to non-empty value: %s", xValue)
1152 }
1153 // Either pattern or text should be const, and the
1154 // non-const one should be varRefExpr
Sasha Smundak5f463be2021-09-15 18:43:36 -07001155 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
Sasha Smundak0554d762021-07-08 18:26:12 -07001156 expr = xText
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001157 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
Sasha Smundak0554d762021-07-08 18:26:12 -07001158 expr = xPattern
1159 } else {
Sasha Smundak5f463be2021-09-15 18:43:36 -07001160 expr = &callExpr{
Sasha Smundak0554d762021-07-08 18:26:12 -07001161 object: nil,
1162 name: filterFuncCall.name,
1163 args: filterFuncCall.args,
1164 returnType: starlarkTypeBool,
1165 }
Sasha Smundak5f463be2021-09-15 18:43:36 -07001166 if negate {
1167 expr = &notExpr{expr: expr}
1168 }
1169 return expr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001170 }
1171 case *variableRefExpr:
1172 if v, ok := xPattern.(*variableRefExpr); ok {
1173 if xInList, ok = xText.(*stringLiteralExpr); ok && v.ref.name() == x.ref.name() {
1174 // ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...), flip negate,
1175 // it's the opposite to what is done when comparing to empty.
Sasha Smundak0554d762021-07-08 18:26:12 -07001176 expr = xPattern
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001177 negate = !negate
1178 }
1179 }
1180 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001181 if expr != nil && xInList != nil {
1182 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1183 // Generate simpler code for the common cases:
1184 if expr.typ() == starlarkTypeList {
1185 if len(slExpr.items) == 1 {
1186 // Checking that a string belongs to list
1187 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}
1188 } else {
1189 // TODO(asmundak):
1190 panic("TBD")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001191 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001192 } else if len(slExpr.items) == 1 {
1193 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}
1194 } else {
1195 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001196 }
1197 }
1198 return ctx.newBadExpr(cond, "filter arguments are too complex: %s", cond.Dump())
1199}
1200
1201func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Directive,
1202 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001203 if !isEmptyString(xValue) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001204 return ctx.newBadExpr(directive, "wildcard result can be compared only to empty: %s", xValue)
1205 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001206 callFunc := baseName + ".file_wildcard_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001207 if s, ok := xCall.args[0].(*stringLiteralExpr); ok && !strings.ContainsAny(s.literal, "*?{[") {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001208 callFunc = baseName + ".file_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001209 }
1210 var cc starlarkExpr = &callExpr{name: callFunc, args: xCall.args, returnType: starlarkTypeBool}
1211 if !negate {
1212 cc = &notExpr{cc}
1213 }
1214 return cc
1215}
1216
1217func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1218 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001219 if isEmptyString(xValue) {
1220 return &eqExpr{
1221 left: &callExpr{
1222 object: xCall.args[1],
1223 name: "find",
1224 args: []starlarkExpr{xCall.args[0]},
1225 returnType: starlarkTypeInt,
1226 },
1227 right: &intLiteralExpr{-1},
1228 isEq: !negate,
1229 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001230 } else if s, ok := maybeString(xValue); ok {
1231 if s2, ok := maybeString(xCall.args[0]); ok && s == s2 {
1232 return &eqExpr{
1233 left: &callExpr{
1234 object: xCall.args[1],
1235 name: "find",
1236 args: []starlarkExpr{xCall.args[0]},
1237 returnType: starlarkTypeInt,
1238 },
1239 right: &intLiteralExpr{-1},
1240 isEq: negate,
1241 }
1242 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001243 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001244 return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001245}
1246
1247func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1248 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1249 if _, ok := xValue.(*stringLiteralExpr); !ok {
1250 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1251 }
1252 return &eqExpr{
1253 left: &callExpr{
1254 name: "strip",
1255 args: xCall.args,
1256 returnType: starlarkTypeString,
1257 },
1258 right: xValue, isEq: !negate}
1259}
1260
1261// parses $(...), returning an expression
1262func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1263 ref.TrimLeftSpaces()
1264 ref.TrimRightSpaces()
1265 refDump := ref.Dump()
1266
1267 // Handle only the case where the first (or only) word is constant
1268 words := ref.SplitN(" ", 2)
1269 if !words[0].Const() {
1270 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1271 }
1272
1273 // If it is a single word, it can be a simple variable
1274 // reference or a function call
Cole Faust9ebf6e42021-12-13 14:08:34 -08001275 if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" {
Sasha Smundak65b547e2021-09-17 15:35:41 -07001276 if strings.HasPrefix(refDump, soongNsPrefix) {
1277 // TODO (asmundak): if we find many, maybe handle them.
Cole Faustc00184e2021-11-08 12:08:57 -08001278 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
Sasha Smundak65b547e2021-09-17 15:35:41 -07001279 }
Cole Faustc36c9622021-12-07 15:20:45 -08001280 // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html
1281 if strings.Contains(refDump, ":") {
1282 parts := strings.SplitN(refDump, ":", 2)
1283 substParts := strings.SplitN(parts[1], "=", 2)
1284 if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 {
1285 return ctx.newBadExpr(node, "Invalid substitution reference")
1286 }
1287 if !strings.Contains(substParts[0], "%") {
1288 if strings.Contains(substParts[1], "%") {
1289 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.")
1290 }
1291 substParts[0] = "%" + substParts[0]
1292 substParts[1] = "%" + substParts[1]
1293 }
1294 v := ctx.addVariable(parts[0])
1295 if v == nil {
1296 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1297 }
1298 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001299 name: baseName + ".mkpatsubst",
1300 returnType: starlarkTypeString,
Cole Faustc36c9622021-12-07 15:20:45 -08001301 args: []starlarkExpr{
1302 &stringLiteralExpr{literal: substParts[0]},
1303 &stringLiteralExpr{literal: substParts[1]},
Cole Faustfc438682021-12-14 12:46:32 -08001304 NewVariableRefExpr(v, ctx.lastAssignment(v.name()) != nil),
Cole Faustc36c9622021-12-07 15:20:45 -08001305 },
1306 }
1307 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001308 if v := ctx.addVariable(refDump); v != nil {
Cole Faustfc438682021-12-14 12:46:32 -08001309 return NewVariableRefExpr(v, ctx.lastAssignment(v.name()) != nil)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001310 }
1311 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1312 }
1313
1314 expr := &callExpr{name: words[0].Dump(), returnType: starlarkTypeUnknown}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001315 args := mkparser.SimpleMakeString("", words[0].Pos())
1316 if len(words) >= 2 {
1317 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001318 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001319 args.TrimLeftSpaces()
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001320 if expr.name == "call" {
1321 words = args.SplitN(",", 2)
1322 if words[0].Empty() || !words[0].Const() {
Sasha Smundakf2c9f8b2021-07-27 10:44:48 -07001323 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001324 }
1325 expr.name = words[0].Dump()
1326 if len(words) < 2 {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001327 args = &mkparser.MakeString{}
1328 } else {
1329 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001330 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001331 }
1332 if kf, found := knownFunctions[expr.name]; found {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001333 return kf.parse(ctx, node, args)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001334 } else {
1335 return ctx.newBadExpr(node, "cannot handle invoking %s", expr.name)
1336 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001337}
1338
1339type simpleCallParser struct {
1340 name string
1341 returnType starlarkType
1342 addGlobals bool
1343}
1344
1345func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1346 expr := &callExpr{name: p.name, returnType: p.returnType}
1347 if p.addGlobals {
1348 expr.args = append(expr.args, &globalsExpr{})
1349 }
1350 for _, arg := range args.Split(",") {
1351 arg.TrimLeftSpaces()
1352 arg.TrimRightSpaces()
1353 x := ctx.parseMakeString(node, arg)
1354 if xBad, ok := x.(*badExpr); ok {
1355 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001356 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001357 expr.args = append(expr.args, x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001358 }
1359 return expr
1360}
1361
Cole Faust9ebf6e42021-12-13 14:08:34 -08001362type makeControlFuncParser struct {
1363 name string
1364}
1365
1366func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1367 // Make control functions need special treatment as everything
1368 // after the name is a single text argument
1369 x := ctx.parseMakeString(node, args)
1370 if xBad, ok := x.(*badExpr); ok {
1371 return xBad
1372 }
1373 return &callExpr{
1374 name: p.name,
1375 args: []starlarkExpr{
1376 &stringLiteralExpr{ctx.script.mkFile},
1377 x,
1378 },
1379 returnType: starlarkTypeUnknown,
1380 }
1381}
1382
1383type shellCallParser struct{}
1384
1385func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1386 // Shell functions need special treatment as everything
1387 // after the name is a single text argument
1388 x := ctx.parseMakeString(node, args)
1389 if xBad, ok := x.(*badExpr); ok {
1390 return xBad
1391 }
1392 return &callExpr{
1393 name: baseName + ".shell",
1394 args: []starlarkExpr{x},
1395 returnType: starlarkTypeUnknown,
1396 }
1397}
1398
1399type myDirCallParser struct{}
1400
1401func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1402 if !args.Empty() {
1403 return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.")
1404 }
1405 return &variableRefExpr{ctx.addVariable("LOCAL_PATH"), true}
1406}
1407
Cole Faust9ebf6e42021-12-13 14:08:34 -08001408type isProductInListCallParser struct{}
1409
1410func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1411 if args.Empty() {
1412 return ctx.newBadExpr(node, "is-product-in-list requires an argument")
1413 }
1414 return &inExpr{
1415 expr: &variableRefExpr{ctx.addVariable("TARGET_PRODUCT"), true},
1416 list: maybeConvertToStringList(ctx.parseMakeString(node, args)),
1417 isNot: false,
1418 }
1419}
1420
1421type isVendorBoardPlatformCallParser struct{}
1422
1423func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1424 if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) {
1425 return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform")
1426 }
1427 return &inExpr{
1428 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1429 list: &variableRefExpr{ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS"), true},
1430 isNot: false,
1431 }
1432}
1433
1434type isVendorBoardQcomCallParser struct{}
1435
1436func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1437 if !args.Empty() {
1438 return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments")
1439 }
1440 return &inExpr{
1441 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1442 list: &variableRefExpr{ctx.addVariable("QCOM_BOARD_PLATFORMS"), true},
1443 isNot: false,
1444 }
1445}
1446
1447type substCallParser struct {
1448 fname string
1449}
1450
1451func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001452 words := args.Split(",")
1453 if len(words) != 3 {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001454 return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001455 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001456 from := ctx.parseMakeString(node, words[0])
1457 if xBad, ok := from.(*badExpr); ok {
1458 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001459 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001460 to := ctx.parseMakeString(node, words[1])
1461 if xBad, ok := to.(*badExpr); ok {
1462 return xBad
1463 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001464 words[2].TrimLeftSpaces()
1465 words[2].TrimRightSpaces()
1466 obj := ctx.parseMakeString(node, words[2])
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001467 typ := obj.typ()
Cole Faust9ebf6e42021-12-13 14:08:34 -08001468 if typ == starlarkTypeString && p.fname == "subst" {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001469 // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001470 return &callExpr{
1471 object: obj,
1472 name: "replace",
Sasha Smundak35434ed2021-11-05 16:29:56 -07001473 args: []starlarkExpr{from, to},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001474 returnType: typ,
1475 }
1476 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001477 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001478 name: baseName + ".mk" + p.fname,
Sasha Smundak35434ed2021-11-05 16:29:56 -07001479 args: []starlarkExpr{from, to, obj},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001480 returnType: obj.typ(),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001481 }
1482}
1483
Cole Faust9ebf6e42021-12-13 14:08:34 -08001484type ifCallParser struct{}
1485
1486func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faust4eadba72021-12-07 11:54:52 -08001487 words := args.Split(",")
1488 if len(words) != 2 && len(words) != 3 {
1489 return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))
1490 }
1491 condition := ctx.parseMakeString(node, words[0])
1492 ifTrue := ctx.parseMakeString(node, words[1])
1493 var ifFalse starlarkExpr
1494 if len(words) == 3 {
1495 ifFalse = ctx.parseMakeString(node, words[2])
1496 } else {
1497 switch ifTrue.typ() {
1498 case starlarkTypeList:
1499 ifFalse = &listExpr{items: []starlarkExpr{}}
1500 case starlarkTypeInt:
1501 ifFalse = &intLiteralExpr{literal: 0}
1502 case starlarkTypeBool:
1503 ifFalse = &boolLiteralExpr{literal: false}
1504 default:
1505 ifFalse = &stringLiteralExpr{literal: ""}
1506 }
1507 }
1508 return &ifExpr{
1509 condition,
1510 ifTrue,
1511 ifFalse,
1512 }
1513}
1514
Cole Faust9ebf6e42021-12-13 14:08:34 -08001515type foreachCallPaser struct{}
1516
1517func (p *foreachCallPaser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faustb0d32ab2021-12-09 14:00:59 -08001518 words := args.Split(",")
1519 if len(words) != 3 {
1520 return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))
1521 }
1522 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1523 return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier")
1524 }
1525 loopVarName := words[0].Strings[0]
1526 list := ctx.parseMakeString(node, words[1])
1527 action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr {
1528 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1529 return &identifierExpr{loopVarName}
1530 }
1531 return nil
1532 })
1533
1534 if list.typ() != starlarkTypeList {
1535 list = &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001536 name: baseName + ".words",
1537 returnType: starlarkTypeList,
Cole Faustb0d32ab2021-12-09 14:00:59 -08001538 args: []starlarkExpr{list},
1539 }
1540 }
1541
1542 return &foreachExpr{
1543 varName: loopVarName,
1544 list: list,
1545 action: action,
1546 }
1547}
1548
Cole Faust9ebf6e42021-12-13 14:08:34 -08001549type wordCallParser struct{}
1550
1551func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001552 words := args.Split(",")
1553 if len(words) != 2 {
1554 return ctx.newBadExpr(node, "word function should have 2 arguments")
1555 }
1556 var index uint64 = 0
1557 if words[0].Const() {
1558 index, _ = strconv.ParseUint(strings.TrimSpace(words[0].Strings[0]), 10, 64)
1559 }
1560 if index < 1 {
1561 return ctx.newBadExpr(node, "word index should be constant positive integer")
1562 }
1563 words[1].TrimLeftSpaces()
1564 words[1].TrimRightSpaces()
1565 array := ctx.parseMakeString(node, words[1])
1566 if xBad, ok := array.(*badExpr); ok {
1567 return xBad
1568 }
1569 if array.typ() != starlarkTypeList {
1570 array = &callExpr{object: array, name: "split", returnType: starlarkTypeList}
1571 }
Cole Faustb0d32ab2021-12-09 14:00:59 -08001572 return &indexExpr{array, &intLiteralExpr{int(index - 1)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001573}
1574
Cole Faust9ebf6e42021-12-13 14:08:34 -08001575type firstOrLastwordCallParser struct {
1576 isLastWord bool
1577}
1578
1579func (p *firstOrLastwordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundak16e07732021-07-23 11:38:23 -07001580 arg := ctx.parseMakeString(node, args)
1581 if bad, ok := arg.(*badExpr); ok {
1582 return bad
1583 }
1584 index := &intLiteralExpr{0}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001585 if p.isLastWord {
Sasha Smundak16e07732021-07-23 11:38:23 -07001586 if v, ok := arg.(*variableRefExpr); ok && v.ref.name() == "MAKEFILE_LIST" {
1587 return &stringLiteralExpr{ctx.script.mkFile}
1588 }
1589 index.literal = -1
1590 }
1591 if arg.typ() == starlarkTypeList {
1592 return &indexExpr{arg, index}
1593 }
1594 return &indexExpr{&callExpr{object: arg, name: "split", returnType: starlarkTypeList}, index}
1595}
1596
Cole Faustb1103e22022-01-06 15:22:05 -08001597func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) {
1598 parsedArgs := make([]starlarkExpr, 0)
1599 for _, arg := range args.Split(",") {
1600 expr := ctx.parseMakeString(node, arg)
1601 if expr.typ() == starlarkTypeList {
1602 return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int")
1603 }
1604 if s, ok := maybeString(expr); ok {
1605 intVal, err := strconv.Atoi(strings.TrimSpace(s))
1606 if err != nil {
1607 return nil, err
1608 }
1609 expr = &intLiteralExpr{literal: intVal}
1610 } else if expr.typ() != starlarkTypeInt {
1611 expr = &callExpr{
1612 name: "int",
1613 args: []starlarkExpr{expr},
1614 returnType: starlarkTypeInt,
1615 }
1616 }
1617 parsedArgs = append(parsedArgs, expr)
1618 }
1619 if len(parsedArgs) != expectedArgs {
1620 return nil, fmt.Errorf("function should have %d arguments", expectedArgs)
1621 }
1622 return parsedArgs, nil
1623}
1624
1625type mathComparisonCallParser struct {
1626 op string
1627}
1628
1629func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1630 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1631 if err != nil {
1632 return ctx.newBadExpr(node, err.Error())
1633 }
1634 return &binaryOpExpr{
1635 left: parsedArgs[0],
1636 right: parsedArgs[1],
1637 op: p.op,
1638 returnType: starlarkTypeBool,
1639 }
1640}
1641
1642type mathMaxOrMinCallParser struct {
1643 function string
1644}
1645
1646func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1647 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1648 if err != nil {
1649 return ctx.newBadExpr(node, err.Error())
1650 }
1651 return &callExpr{
1652 object: nil,
1653 name: p.function,
1654 args: parsedArgs,
1655 returnType: starlarkTypeInt,
1656 }
1657}
1658
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001659func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
1660 if mk.Const() {
1661 return &stringLiteralExpr{mk.Dump()}
1662 }
1663 if mkRef, ok := mk.SingleVariable(); ok {
1664 return ctx.parseReference(node, mkRef)
1665 }
1666 // If we reached here, it's neither string literal nor a simple variable,
1667 // we need a full-blown interpolation node that will generate
1668 // "a%b%c" % (X, Y) for a$(X)b$(Y)c
Cole Faustfc438682021-12-14 12:46:32 -08001669 parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings))
1670 for i := 0; i < len(parts); i++ {
1671 if i%2 == 0 {
1672 parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]}
1673 } else {
1674 parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name)
1675 if x, ok := parts[i].(*badExpr); ok {
1676 return x
1677 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001678 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001679 }
Cole Faustfc438682021-12-14 12:46:32 -08001680 return NewInterpolateExpr(parts)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001681}
1682
1683// Handles the statements whose treatment is the same in all contexts: comment,
1684// assignment, variable (which is a macro call in reality) and all constructs that
1685// do not handle in any context ('define directive and any unrecognized stuff).
Cole Faustdd569ae2022-01-31 15:48:29 -08001686func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) []starlarkNode {
1687 var result []starlarkNode
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001688 switch x := node.(type) {
1689 case *mkparser.Comment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001690 if n, handled := ctx.maybeHandleAnnotation(x); handled && n != nil {
1691 result = []starlarkNode{n}
1692 } else if !handled {
1693 result = []starlarkNode{&commentNode{strings.TrimSpace("#" + x.Comment)}}
Cole Faust7940c6a2022-01-31 15:54:05 -08001694 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001695 case *mkparser.Assignment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001696 result = ctx.handleAssignment(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001697 case *mkparser.Variable:
Cole Faustdd569ae2022-01-31 15:48:29 -08001698 result = ctx.handleVariable(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001699 case *mkparser.Directive:
1700 switch x.Name {
1701 case "define":
Cole Faustdd569ae2022-01-31 15:48:29 -08001702 if res := ctx.maybeHandleDefine(x); res != nil {
1703 result = []starlarkNode{res}
1704 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001705 case "include", "-include":
Cole Faustdd569ae2022-01-31 15:48:29 -08001706 result = ctx.handleInclude(node, ctx.parseMakeString(node, x.Args), x.Name[0] != '-')
Cole Faust591a1fe2021-11-08 15:37:57 -08001707 case "ifeq", "ifneq", "ifdef", "ifndef":
Cole Faustdd569ae2022-01-31 15:48:29 -08001708 result = []starlarkNode{ctx.handleIfBlock(x)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001709 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001710 result = []starlarkNode{ctx.newBadNode(x, "unexpected directive %s", x.Name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001711 }
1712 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001713 result = []starlarkNode{ctx.newBadNode(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001714 }
Cole Faust6c934f62022-01-06 15:51:12 -08001715
1716 // Clear the includeTops after each non-comment statement
1717 // so that include annotations placed on certain statements don't apply
1718 // globally for the rest of the makefile was well.
1719 if _, wasComment := node.(*mkparser.Comment); !wasComment && len(ctx.includeTops) > 0 {
1720 ctx.includeTops = []string{}
1721 }
Cole Faustdd569ae2022-01-31 15:48:29 -08001722
1723 if result == nil {
1724 result = []starlarkNode{}
1725 }
1726 return result
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001727}
1728
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001729// Processes annotation. An annotation is a comment that starts with #RBC# and provides
1730// a conversion hint -- say, where to look for the dynamically calculated inherit/include
Cole Faust7940c6a2022-01-31 15:54:05 -08001731// paths. Returns true if the comment was a successfully-handled annotation.
Cole Faustdd569ae2022-01-31 15:48:29 -08001732func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) (starlarkNode, bool) {
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001733 maybeTrim := func(s, prefix string) (string, bool) {
1734 if strings.HasPrefix(s, prefix) {
1735 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
1736 }
1737 return s, false
1738 }
1739 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
1740 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -08001741 return nil, false
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001742 }
1743 if p, ok := maybeTrim(annotation, "include_top"); ok {
Cole Faustf7ed5342021-12-21 14:15:12 -08001744 // Don't allow duplicate include tops, because then we will generate
1745 // invalid starlark code. (duplicate keys in the _entry dictionary)
1746 for _, top := range ctx.includeTops {
1747 if top == p {
Cole Faustdd569ae2022-01-31 15:48:29 -08001748 return nil, true
Cole Faustf7ed5342021-12-21 14:15:12 -08001749 }
1750 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001751 ctx.includeTops = append(ctx.includeTops, p)
Cole Faustdd569ae2022-01-31 15:48:29 -08001752 return nil, true
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001753 }
Cole Faustdd569ae2022-01-31 15:48:29 -08001754 return ctx.newBadNode(cnode, "unsupported annotation %s", cnode.Comment), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001755}
1756
1757func (ctx *parseContext) loadedModulePath(path string) string {
1758 // During the transition to Roboleaf some of the product configuration files
1759 // will be converted and checked in while the others will be generated on the fly
1760 // and run. The runner (rbcrun application) accommodates this by allowing three
1761 // different ways to specify the loaded file location:
1762 // 1) load(":<file>",...) loads <file> from the same directory
1763 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
1764 // 3) load("/absolute/path/to/<file> absolute path
1765 // If the file being generated and the file it wants to load are in the same directory,
1766 // generate option 1.
1767 // Otherwise, if output directory is not specified, generate 2)
1768 // Finally, if output directory has been specified and the file being generated and
1769 // the file it wants to load from are in the different directories, generate 2) or 3):
1770 // * if the file being loaded exists in the source tree, generate 2)
1771 // * otherwise, generate 3)
1772 // Finally, figure out the loaded module path and name and create a node for it
1773 loadedModuleDir := filepath.Dir(path)
1774 base := filepath.Base(path)
1775 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
1776 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
1777 return ":" + loadedModuleName
1778 }
1779 if ctx.outputDir == "" {
1780 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1781 }
1782 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
1783 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1784 }
1785 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
1786}
1787
Sasha Smundak3deb9682021-07-26 18:42:25 -07001788func (ctx *parseContext) addSoongNamespace(ns string) {
1789 if _, ok := ctx.soongNamespaces[ns]; ok {
1790 return
1791 }
1792 ctx.soongNamespaces[ns] = make(map[string]bool)
1793}
1794
1795func (ctx *parseContext) hasSoongNamespace(name string) bool {
1796 _, ok := ctx.soongNamespaces[name]
1797 return ok
1798}
1799
1800func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
1801 ctx.addSoongNamespace(namespaceName)
1802 vars := ctx.soongNamespaces[namespaceName]
1803 if replace {
1804 vars = make(map[string]bool)
1805 ctx.soongNamespaces[namespaceName] = vars
1806 }
1807 for _, v := range varNames {
1808 vars[v] = true
1809 }
1810}
1811
1812func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
1813 vars, ok := ctx.soongNamespaces[namespaceName]
1814 if ok {
1815 _, ok = vars[varName]
1816 }
1817 return ok
1818}
1819
Sasha Smundak422b6142021-11-11 18:31:59 -08001820func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation {
1821 return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())}
1822}
1823
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001824func (ss *StarlarkScript) String() string {
1825 return NewGenerateContext(ss).emit()
1826}
1827
1828func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001829
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001830 var subs []string
1831 for _, src := range ss.inherited {
1832 subs = append(subs, src.originalPath)
1833 }
1834 return subs
1835}
1836
1837func (ss *StarlarkScript) HasErrors() bool {
1838 return ss.hasErrors
1839}
1840
1841// Convert reads and parses a makefile. If successful, parsed tree
1842// is returned and then can be passed to String() to get the generated
1843// Starlark file.
1844func Convert(req Request) (*StarlarkScript, error) {
1845 reader := req.Reader
1846 if reader == nil {
1847 mkContents, err := ioutil.ReadFile(req.MkFile)
1848 if err != nil {
1849 return nil, err
1850 }
1851 reader = bytes.NewBuffer(mkContents)
1852 }
1853 parser := mkparser.NewParser(req.MkFile, reader)
1854 nodes, errs := parser.Parse()
1855 if len(errs) > 0 {
1856 for _, e := range errs {
1857 fmt.Fprintln(os.Stderr, "ERROR:", e)
1858 }
1859 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
1860 }
1861 starScript := &StarlarkScript{
Sasha Smundak422b6142021-11-11 18:31:59 -08001862 moduleName: moduleNameForFile(req.MkFile),
1863 mkFile: req.MkFile,
Sasha Smundak422b6142021-11-11 18:31:59 -08001864 traceCalls: req.TraceCalls,
1865 sourceFS: req.SourceFS,
1866 makefileFinder: req.MakefileFinder,
1867 nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line },
Cole Faustdd569ae2022-01-31 15:48:29 -08001868 nodes: make([]starlarkNode, 0),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001869 }
1870 ctx := newParseContext(starScript, nodes)
1871 ctx.outputSuffix = req.OutputSuffix
1872 ctx.outputDir = req.OutputDir
1873 ctx.errorLogger = req.ErrorLogger
1874 if len(req.TracedVariables) > 0 {
1875 ctx.tracedVariables = make(map[string]bool)
1876 for _, v := range req.TracedVariables {
1877 ctx.tracedVariables[v] = true
1878 }
1879 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001880 for ctx.hasNodes() && ctx.fatalError == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -08001881 starScript.nodes = append(starScript.nodes, ctx.handleSimpleStatement(ctx.getNode())...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001882 }
1883 if ctx.fatalError != nil {
1884 return nil, ctx.fatalError
1885 }
1886 return starScript, nil
1887}
1888
Cole Faust864028a2021-12-01 13:43:17 -08001889func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001890 var buf bytes.Buffer
1891 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Cole Faust864028a2021-12-01 13:43:17 -08001892 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001893 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
Cole Faust864028a2021-12-01 13:43:17 -08001894 fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001895 return buf.String()
1896}
1897
Cole Faust6ed7cb42021-10-07 17:08:46 -07001898func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
1899 var buf bytes.Buffer
1900 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
1901 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
1902 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
1903 fmt.Fprintf(&buf, "globals, cfg, globals_base = %s(init, input_variables_init)\n", cfnBoardMain)
1904 fmt.Fprintf(&buf, "# TODO: Some product config variables need to be printed, but most are readonly so we can't just print cfg here.\n")
Cole Faust3c1868b2021-11-22 16:34:11 -08001905 fmt.Fprintf(&buf, "%s((globals, cfg, globals_base))\n", cfnPrintVars)
Cole Faust6ed7cb42021-10-07 17:08:46 -07001906 return buf.String()
1907}
1908
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001909func MakePath2ModuleName(mkPath string) string {
1910 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
1911}