blob: 1d997d932b357349227f2799b7a1afe32fb4ca2e [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"
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},
80 "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList},
Cole Faust0e2b2562022-04-01 11:46:50 -070081 "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeString},
Cole Faust1cc08852022-02-28 11:12:08 -080082 "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true},
Cole Faust6c41b8a2022-04-13 13:53:48 -070083 "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addHandle: true},
Cole Faust1cc08852022-02-28 11:12:08 -080084 "error": &makeControlFuncParser{name: baseName + ".mkerror"},
85 "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt},
86 "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList},
87 "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList},
88 "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList},
89 "firstword": &firstOrLastwordCallParser{isLastWord: false},
Cole Faustf035d402022-03-28 14:02:50 -070090 "foreach": &foreachCallParser{},
Cole Faust1cc08852022-02-28 11:12:08 -080091 "if": &ifCallParser{},
92 "info": &makeControlFuncParser{name: baseName + ".mkinfo"},
93 "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
94 "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
95 "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
96 "is-board-platform-in-list2": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
97 "is-product-in-list": &isProductInListCallParser{},
98 "is-vendor-board-platform": &isVendorBoardPlatformCallParser{},
99 "is-vendor-board-qcom": &isVendorBoardQcomCallParser{},
100 "lastword": &firstOrLastwordCallParser{isLastWord: true},
101 "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString},
102 "math_max": &mathMaxOrMinCallParser{function: "max"},
103 "math_min": &mathMaxOrMinCallParser{function: "min"},
104 "math_gt_or_eq": &mathComparisonCallParser{op: ">="},
105 "math_gt": &mathComparisonCallParser{op: ">"},
106 "math_lt": &mathComparisonCallParser{op: "<"},
107 "my-dir": &myDirCallParser{},
108 "patsubst": &substCallParser{fname: "patsubst"},
109 "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList},
Cole Faustea9db582022-03-21 17:50:05 -0700110 "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addHandle: true},
111 "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addHandle: true},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800112 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Cole Faust9ebf6e42021-12-13 14:08:34 -0800113 "shell": &shellCallParser{},
Cole Faust95b95cb2022-04-05 16:37:39 -0700114 "sort": &simpleCallParser{name: baseName + ".mksort", returnType: starlarkTypeList},
Cole Faust1cc08852022-02-28 11:12:08 -0800115 "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800116 "subst": &substCallParser{fname: "subst"},
117 "warning": &makeControlFuncParser{name: baseName + ".mkwarning"},
118 "word": &wordCallParser{},
Cole Faust1cc08852022-02-28 11:12:08 -0800119 "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList},
Cole Faust9ebf6e42021-12-13 14:08:34 -0800120}
121
Cole Faustf035d402022-03-28 14:02:50 -0700122// The same as knownFunctions, but returns a []starlarkNode instead of a starlarkExpr
123var knownNodeFunctions = map[string]interface {
124 parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode
125}{
126 "eval": &evalNodeParser{},
127 "if": &ifCallNodeParser{},
128 "inherit-product": &inheritProductCallParser{loadAlways: true},
129 "inherit-product-if-exists": &inheritProductCallParser{loadAlways: false},
130 "foreach": &foreachCallNodeParser{},
131}
132
Cole Faust9ebf6e42021-12-13 14:08:34 -0800133// These are functions that we don't implement conversions for, but
134// we allow seeing their definitions in the product config files.
135var ignoredDefines = map[string]bool{
136 "find-word-in-list": true, // internal macro
137 "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc.
138 "is-android-codename": true, // unused by product config
139 "is-android-codename-in-list": true, // unused by product config
140 "is-chipset-in-board-platform": true, // unused by product config
141 "is-chipset-prefix-in-board-platform": true, // unused by product config
142 "is-not-board-platform": true, // defined but never used
143 "is-platform-sdk-version-at-least": true, // unused by product config
144 "match-prefix": true, // internal macro
145 "match-word": true, // internal macro
146 "match-word-in-list": true, // internal macro
147 "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800148}
149
Cole Faustb0d32ab2021-12-09 14:00:59 -0800150var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800151
152// Conversion request parameters
153type Request struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800154 MkFile string // file to convert
155 Reader io.Reader // if set, read input from this stream instead
Sasha Smundak422b6142021-11-11 18:31:59 -0800156 OutputSuffix string // generated Starlark files suffix
157 OutputDir string // if set, root of the output hierarchy
158 ErrorLogger ErrorLogger
159 TracedVariables []string // trace assignment to these variables
160 TraceCalls bool
161 SourceFS fs.FS
162 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800163}
164
Sasha Smundak7d934b92021-11-10 12:20:01 -0800165// ErrorLogger prints errors and gathers error statistics.
166// Its NewError function is called on every error encountered during the conversion.
167type ErrorLogger interface {
Sasha Smundak422b6142021-11-11 18:31:59 -0800168 NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{})
169}
170
171type ErrorLocation struct {
172 MkFile string
173 MkLine int
174}
175
176func (el ErrorLocation) String() string {
177 return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800178}
179
180// Derives module name for a given file. It is base name
181// (file name without suffix), with some characters replaced to make it a Starlark identifier
182func moduleNameForFile(mkFile string) string {
183 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
184 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700185 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
186
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800187}
188
189func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
190 r := &mkparser.MakeString{StringPos: mkString.StringPos}
191 r.Strings = append(r.Strings, mkString.Strings...)
192 r.Variables = append(r.Variables, mkString.Variables...)
193 return r
194}
195
196func isMakeControlFunc(s string) bool {
197 return s == "error" || s == "warning" || s == "info"
198}
199
Cole Faustf0632662022-04-07 13:59:24 -0700200// varAssignmentScope points to the last assignment for each variable
201// in the current block. It is used during the parsing to chain
202// the assignments to a variable together.
203type varAssignmentScope struct {
204 outer *varAssignmentScope
205 vars map[string]bool
206}
207
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800208// Starlark output generation context
209type generationContext struct {
Cole Faustf0632662022-04-07 13:59:24 -0700210 buf strings.Builder
211 starScript *StarlarkScript
212 indentLevel int
213 inAssignment bool
214 tracedCount int
215 varAssignments *varAssignmentScope
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800216}
217
218func NewGenerateContext(ss *StarlarkScript) *generationContext {
Cole Faustf0632662022-04-07 13:59:24 -0700219 return &generationContext{
220 starScript: ss,
221 varAssignments: &varAssignmentScope{
222 outer: nil,
223 vars: make(map[string]bool),
224 },
225 }
226}
227
228func (gctx *generationContext) pushVariableAssignments() {
229 va := &varAssignmentScope{
230 outer: gctx.varAssignments,
231 vars: make(map[string]bool),
232 }
233 gctx.varAssignments = va
234}
235
236func (gctx *generationContext) popVariableAssignments() {
237 gctx.varAssignments = gctx.varAssignments.outer
238}
239
240func (gctx *generationContext) hasBeenAssigned(v variable) bool {
241 for va := gctx.varAssignments; va != nil; va = va.outer {
242 if _, ok := va.vars[v.name()]; ok {
243 return true
244 }
245 }
246 return false
247}
248
249func (gctx *generationContext) setHasBeenAssigned(v variable) {
250 gctx.varAssignments.vars[v.name()] = true
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800251}
252
253// emit returns generated script
254func (gctx *generationContext) emit() string {
255 ss := gctx.starScript
256
257 // The emitted code has the following layout:
258 // <initial comments>
259 // preamble, i.e.,
260 // load statement for the runtime support
261 // load statement for each unique submodule pulled in by this one
262 // def init(g, handle):
263 // cfg = rblf.cfg(handle)
264 // <statements>
265 // <warning if conversion was not clean>
266
267 iNode := len(ss.nodes)
268 for i, node := range ss.nodes {
269 if _, ok := node.(*commentNode); !ok {
270 iNode = i
271 break
272 }
273 node.emit(gctx)
274 }
275
276 gctx.emitPreamble()
277
278 gctx.newLine()
279 // The arguments passed to the init function are the global dictionary
280 // ('g') and the product configuration dictionary ('cfg')
281 gctx.write("def init(g, handle):")
282 gctx.indentLevel++
283 if gctx.starScript.traceCalls {
284 gctx.newLine()
285 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
286 }
287 gctx.newLine()
288 gctx.writef("cfg = %s(handle)", cfnGetCfg)
289 for _, node := range ss.nodes[iNode:] {
290 node.emit(gctx)
291 }
292
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800293 if gctx.starScript.traceCalls {
294 gctx.newLine()
295 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
296 }
297 gctx.indentLevel--
298 gctx.write("\n")
299 return gctx.buf.String()
300}
301
302func (gctx *generationContext) emitPreamble() {
303 gctx.newLine()
304 gctx.writef("load(%q, %q)", baseUri, baseName)
305 // Emit exactly one load statement for each URI.
306 loadedSubConfigs := make(map[string]string)
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800307 for _, mi := range gctx.starScript.inherited {
308 uri := mi.path
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800309 if m, ok := loadedSubConfigs[uri]; ok {
310 // No need to emit load statement, but fix module name.
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800311 mi.moduleLocalName = m
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800312 continue
313 }
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800314 if mi.optional || mi.missing {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800315 uri += "|init"
316 }
317 gctx.newLine()
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800318 gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName())
319 loadedSubConfigs[uri] = mi.moduleLocalName
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800320 }
321 gctx.write("\n")
322}
323
324func (gctx *generationContext) emitPass() {
325 gctx.newLine()
326 gctx.write("pass")
327}
328
329func (gctx *generationContext) write(ss ...string) {
330 for _, s := range ss {
331 gctx.buf.WriteString(s)
332 }
333}
334
335func (gctx *generationContext) writef(format string, args ...interface{}) {
336 gctx.write(fmt.Sprintf(format, args...))
337}
338
339func (gctx *generationContext) newLine() {
340 if gctx.buf.Len() == 0 {
341 return
342 }
343 gctx.write("\n")
344 gctx.writef("%*s", 2*gctx.indentLevel, "")
345}
346
Sasha Smundak422b6142021-11-11 18:31:59 -0800347func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) {
348 gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message)
349}
350
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800351func (gctx *generationContext) emitLoadCheck(im inheritedModule) {
352 if !im.needsLoadCheck() {
353 return
354 }
355 gctx.newLine()
356 gctx.writef("if not %s:", im.entryName())
357 gctx.indentLevel++
358 gctx.newLine()
359 gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`)
360 im.pathExpr().emit(gctx)
361 gctx.write("))")
362 gctx.indentLevel--
363}
364
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800365type knownVariable struct {
366 name string
367 class varClass
368 valueType starlarkType
369}
370
371type knownVariables map[string]knownVariable
372
373func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
374 v, exists := pcv[name]
375 if !exists {
376 pcv[name] = knownVariable{name, varClass, valueType}
377 return
378 }
379 // Conflict resolution:
380 // * config class trumps everything
381 // * any type trumps unknown type
382 match := varClass == v.class
383 if !match {
384 if varClass == VarClassConfig {
385 v.class = VarClassConfig
386 match = true
387 } else if v.class == VarClassConfig {
388 match = true
389 }
390 }
391 if valueType != v.valueType {
392 if valueType != starlarkTypeUnknown {
393 if v.valueType == starlarkTypeUnknown {
394 v.valueType = valueType
395 } else {
396 match = false
397 }
398 }
399 }
400 if !match {
401 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
402 name, varClass, valueType, v.class, v.valueType)
403 }
404}
405
406// All known product variables.
407var KnownVariables = make(knownVariables)
408
409func init() {
410 for _, kv := range []string{
411 // Kernel-related variables that we know are lists.
412 "BOARD_VENDOR_KERNEL_MODULES",
413 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
414 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
415 "BOARD_RECOVERY_KERNEL_MODULES",
416 // Other variables we knwo are lists
417 "ART_APEX_JARS",
418 } {
419 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
420 }
421}
422
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800423// Information about the generated Starlark script.
424type StarlarkScript struct {
Sasha Smundak422b6142021-11-11 18:31:59 -0800425 mkFile string
426 moduleName string
427 mkPos scanner.Position
428 nodes []starlarkNode
429 inherited []*moduleInfo
430 hasErrors bool
Sasha Smundak422b6142021-11-11 18:31:59 -0800431 traceCalls bool // print enter/exit each init function
432 sourceFS fs.FS
433 makefileFinder MakefileFinder
434 nodeLocator func(pos mkparser.Pos) int
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800435}
436
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800437// parseContext holds the script we are generating and all the ephemeral data
438// needed during the parsing.
439type parseContext struct {
440 script *StarlarkScript
441 nodes []mkparser.Node // Makefile as parsed by mkparser
442 currentNodeIndex int // Node in it we are processing
443 ifNestLevel int
444 moduleNameCount map[string]int // count of imported modules with given basename
445 fatalError error
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800446 outputSuffix string
Sasha Smundak7d934b92021-11-10 12:20:01 -0800447 errorLogger ErrorLogger
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800448 tracedVariables map[string]bool // variables to be traced in the generated script
449 variables map[string]variable
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800450 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700451 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700452 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700453 includeTops []string
Cole Faustf92c9f22022-03-14 14:35:50 -0700454 typeHints map[string]starlarkType
455 atTopOfMakefile bool
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800456}
457
458func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
459 predefined := []struct{ name, value string }{
460 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
461 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Cole Faust9b6111a2022-02-02 15:38:33 -0800462 {"TOPDIR", ""}, // TOPDIR is just set to an empty string in cleanbuild.mk and core.mk
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800463 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
464 {"TARGET_COPY_OUT_SYSTEM", "system"},
465 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
466 {"TARGET_COPY_OUT_DATA", "data"},
467 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
468 {"TARGET_COPY_OUT_OEM", "oem"},
469 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
470 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
471 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
472 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
473 {"TARGET_COPY_OUT_ROOT", "root"},
474 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800475 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800476 // TODO(asmundak): to process internal config files, we need the following variables:
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800477 // TARGET_VENDOR
478 // target_base_product
479 //
480
481 // the following utility variables are set in build/make/common/core.mk:
482 {"empty", ""},
483 {"space", " "},
484 {"comma", ","},
485 {"newline", "\n"},
486 {"pound", "#"},
487 {"backslash", "\\"},
488 }
489 ctx := &parseContext{
490 script: ss,
491 nodes: nodes,
492 currentNodeIndex: 0,
493 ifNestLevel: 0,
494 moduleNameCount: make(map[string]int),
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800495 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700496 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700497 soongNamespaces: make(map[string]map[string]bool),
Cole Faust6c934f62022-01-06 15:51:12 -0800498 includeTops: []string{},
Cole Faustf92c9f22022-03-14 14:35:50 -0700499 typeHints: make(map[string]starlarkType),
500 atTopOfMakefile: true,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800501 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800502 for _, item := range predefined {
503 ctx.variables[item.name] = &predefinedVariable{
504 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
505 value: &stringLiteralExpr{item.value},
506 }
507 }
508
509 return ctx
510}
511
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800512func (ctx *parseContext) hasNodes() bool {
513 return ctx.currentNodeIndex < len(ctx.nodes)
514}
515
516func (ctx *parseContext) getNode() mkparser.Node {
517 if !ctx.hasNodes() {
518 return nil
519 }
520 node := ctx.nodes[ctx.currentNodeIndex]
521 ctx.currentNodeIndex++
522 return node
523}
524
525func (ctx *parseContext) backNode() {
526 if ctx.currentNodeIndex <= 0 {
527 panic("Cannot back off")
528 }
529 ctx.currentNodeIndex--
530}
531
Cole Faustdd569ae2022-01-31 15:48:29 -0800532func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800533 // Handle only simple variables
534 if !a.Name.Const() {
Cole Faustdd569ae2022-01-31 15:48:29 -0800535 return []starlarkNode{ctx.newBadNode(a, "Only simple variables are handled")}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800536 }
537 name := a.Name.Strings[0]
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800538 // The `override` directive
539 // override FOO :=
540 // is parsed as an assignment to a variable named `override FOO`.
541 // There are very few places where `override` is used, just flag it.
542 if strings.HasPrefix(name, "override ") {
Cole Faustdd569ae2022-01-31 15:48:29 -0800543 return []starlarkNode{ctx.newBadNode(a, "cannot handle override directive")}
Sasha Smundakea3bc3a2021-11-10 13:06:42 -0800544 }
545
Cole Faustc00184e2021-11-08 12:08:57 -0800546 // Soong configuration
Sasha Smundak3deb9682021-07-26 18:42:25 -0700547 if strings.HasPrefix(name, soongNsPrefix) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800548 return ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700549 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800550 lhs := ctx.addVariable(name)
551 if lhs == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -0800552 return []starlarkNode{ctx.newBadNode(a, "unknown variable %s", name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800553 }
Cole Faust3c4fc992022-02-28 16:05:01 -0800554 _, isTraced := ctx.tracedVariables[lhs.name()]
Sasha Smundak422b6142021-11-11 18:31:59 -0800555 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800556 if lhs.valueType() == starlarkTypeUnknown {
557 // Try to divine variable type from the RHS
558 asgn.value = ctx.parseMakeString(a, a.Value)
559 if xBad, ok := asgn.value.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800560 return []starlarkNode{&exprNode{xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800561 }
562 inferred_type := asgn.value.typ()
563 if inferred_type != starlarkTypeUnknown {
Sasha Smundak9d011ab2021-07-09 16:00:57 -0700564 lhs.setValueType(inferred_type)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800565 }
566 }
567 if lhs.valueType() == starlarkTypeList {
Cole Faustdd569ae2022-01-31 15:48:29 -0800568 xConcat, xBad := ctx.buildConcatExpr(a)
569 if xBad != nil {
570 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800571 }
572 switch len(xConcat.items) {
573 case 0:
574 asgn.value = &listExpr{}
575 case 1:
576 asgn.value = xConcat.items[0]
577 default:
578 asgn.value = xConcat
579 }
580 } else {
581 asgn.value = ctx.parseMakeString(a, a.Value)
582 if xBad, ok := asgn.value.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800583 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800584 }
585 }
586
Cole Faust421a1922022-03-16 14:35:45 -0700587 if asgn.lhs.valueType() == starlarkTypeString &&
588 asgn.value.typ() != starlarkTypeUnknown &&
589 asgn.value.typ() != starlarkTypeString {
590 asgn.value = &toStringExpr{expr: asgn.value}
591 }
592
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800593 switch a.Type {
594 case "=", ":=":
595 asgn.flavor = asgnSet
596 case "+=":
Cole Fauste2a37982022-03-09 16:00:17 -0800597 asgn.flavor = asgnAppend
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800598 case "?=":
599 asgn.flavor = asgnMaybeSet
600 default:
601 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
602 }
603
Cole Faustdd569ae2022-01-31 15:48:29 -0800604 return []starlarkNode{asgn}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800605}
606
Cole Faustdd569ae2022-01-31 15:48:29 -0800607func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) []starlarkNode {
Sasha Smundak3deb9682021-07-26 18:42:25 -0700608 val := ctx.parseMakeString(asgn, asgn.Value)
609 if xBad, ok := val.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800610 return []starlarkNode{&exprNode{expr: xBad}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700611 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700612
613 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
614 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
615 // Try to divine the call from the assignment as follows:
616 if name == "NAMESPACES" {
617 // Upon seeng
618 // SOONG_CONFIG_NAMESPACES += foo
619 // remember that there is a namespace `foo` and act as we saw
620 // $(call add_soong_config_namespace,foo)
621 s, ok := maybeString(val)
622 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800623 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 -0700624 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800625 result := make([]starlarkNode, 0)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700626 for _, ns := range strings.Fields(s) {
627 ctx.addSoongNamespace(ns)
Cole Faustdd569ae2022-01-31 15:48:29 -0800628 result = append(result, &exprNode{&callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -0800629 name: baseName + ".soong_config_namespace",
630 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700631 returnType: starlarkTypeVoid,
632 }})
633 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800634 return result
Sasha Smundak3deb9682021-07-26 18:42:25 -0700635 } else {
636 // Upon seeing
637 // SOONG_CONFIG_x_y = v
638 // find a namespace called `x` and act as if we encountered
Cole Faustc00184e2021-11-08 12:08:57 -0800639 // $(call soong_config_set,x,y,v)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700640 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
641 // it.
642 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
643 // and `foo` with a variable `bar_baz`.
644 namespaceName := ""
645 if ctx.hasSoongNamespace(name) {
646 namespaceName = name
647 }
648 var varName string
649 for pos, ch := range name {
650 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
651 continue
652 }
653 if namespaceName != "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800654 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 -0700655 }
656 namespaceName = name[0:pos]
657 varName = name[pos+1:]
658 }
659 if namespaceName == "" {
Cole Faustdd569ae2022-01-31 15:48:29 -0800660 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 -0700661 }
662 if varName == "" {
663 // Remember variables in this namespace
664 s, ok := maybeString(val)
665 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800666 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 -0700667 }
668 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
Cole Faustdd569ae2022-01-31 15:48:29 -0800669 return []starlarkNode{}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700670 }
671
672 // Finally, handle assignment to a namespace variable
673 if !ctx.hasNamespaceVar(namespaceName, varName) {
Cole Faustdd569ae2022-01-31 15:48:29 -0800674 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 -0700675 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800676 fname := baseName + "." + soongConfigAssign
Sasha Smundak65b547e2021-09-17 15:35:41 -0700677 if asgn.Type == "+=" {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800678 fname = baseName + "." + soongConfigAppend
Sasha Smundak65b547e2021-09-17 15:35:41 -0700679 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800680 return []starlarkNode{&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700681 name: fname,
Cole Faust9ebf6e42021-12-13 14:08:34 -0800682 args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700683 returnType: starlarkTypeVoid,
Cole Faustdd569ae2022-01-31 15:48:29 -0800684 }}}
Sasha Smundak3deb9682021-07-26 18:42:25 -0700685 }
686}
687
Cole Faustdd569ae2022-01-31 15:48:29 -0800688func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) (*concatExpr, *badExpr) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800689 xConcat := &concatExpr{}
690 var xItemList *listExpr
691 addToItemList := func(x ...starlarkExpr) {
692 if xItemList == nil {
693 xItemList = &listExpr{[]starlarkExpr{}}
694 }
695 xItemList.items = append(xItemList.items, x...)
696 }
697 finishItemList := func() {
698 if xItemList != nil {
699 xConcat.items = append(xConcat.items, xItemList)
700 xItemList = nil
701 }
702 }
703
704 items := a.Value.Words()
705 for _, item := range items {
706 // A function call in RHS is supposed to return a list, all other item
707 // expressions return individual elements.
708 switch x := ctx.parseMakeString(a, item).(type) {
709 case *badExpr:
Cole Faustdd569ae2022-01-31 15:48:29 -0800710 return nil, x
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800711 case *stringLiteralExpr:
712 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
713 default:
714 switch x.typ() {
715 case starlarkTypeList:
716 finishItemList()
717 xConcat.items = append(xConcat.items, x)
718 case starlarkTypeString:
719 finishItemList()
720 xConcat.items = append(xConcat.items, &callExpr{
721 object: x,
722 name: "split",
723 args: nil,
724 returnType: starlarkTypeList,
725 })
726 default:
727 addToItemList(x)
728 }
729 }
730 }
731 if xItemList != nil {
732 xConcat.items = append(xConcat.items, xItemList)
733 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800734 return xConcat, nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800735}
736
Sasha Smundak6609ba72021-07-22 18:32:56 -0700737func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
738 modulePath := ctx.loadedModulePath(path)
739 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700740 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700741 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800742 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800743 moduleName := moduleNameForFile(path)
744 moduleLocalName := "_" + moduleName
745 n, found := ctx.moduleNameCount[moduleName]
746 if found {
747 moduleLocalName += fmt.Sprintf("%d", n)
748 }
749 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800750 _, err := fs.Stat(ctx.script.sourceFS, path)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700751 mi := &moduleInfo{
752 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800753 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800754 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700755 optional: optional,
Sasha Smundak6bc132a2022-01-10 17:02:16 -0800756 missing: err != nil,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800757 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700758 ctx.dependentModules[modulePath] = mi
759 ctx.script.inherited = append(ctx.script.inherited, mi)
760 return mi
761}
762
763func (ctx *parseContext) handleSubConfig(
Cole Faustdd569ae2022-01-31 15:48:29 -0800764 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule) starlarkNode) []starlarkNode {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700765
Cole Faust62e05112022-04-05 17:56:11 -0700766 // Allow seeing $(sort $(wildcard realPathExpr)) or $(wildcard realPathExpr)
767 // because those are functionally the same as not having the sort/wildcard calls.
768 if ce, ok := pathExpr.(*callExpr); ok && ce.name == "rblf.mksort" && len(ce.args) == 1 {
769 if ce2, ok2 := ce.args[0].(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
770 pathExpr = ce2.args[0]
771 }
772 } else if ce2, ok2 := pathExpr.(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
773 pathExpr = ce2.args[0]
774 }
775
Sasha Smundak6609ba72021-07-22 18:32:56 -0700776 // In a simple case, the name of a module to inherit/include is known statically.
777 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700778 // Note that even if this directive loads a module unconditionally, a module may be
779 // absent without causing any harm if this directive is inside an if/else block.
780 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700781 if strings.Contains(path, "*") {
782 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
Cole Faust62e05112022-04-05 17:56:11 -0700783 sort.Strings(paths)
Cole Faustdd569ae2022-01-31 15:48:29 -0800784 result := make([]starlarkNode, 0)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700785 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700786 mi := ctx.newDependentModule(p, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800787 result = append(result, processModule(inheritedStaticModule{mi, loadAlways}))
Sasha Smundak6609ba72021-07-22 18:32:56 -0700788 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800789 return result
Sasha Smundak6609ba72021-07-22 18:32:56 -0700790 } else {
Cole Faustdd569ae2022-01-31 15:48:29 -0800791 return []starlarkNode{ctx.newBadNode(v, "cannot glob wildcard argument")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700792 }
793 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700794 mi := ctx.newDependentModule(path, !moduleShouldExist)
Cole Faustdd569ae2022-01-31 15:48:29 -0800795 return []starlarkNode{processModule(inheritedStaticModule{mi, loadAlways})}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700796 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700797 }
798
799 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
800 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
801 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
802 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
803 // We then emit the code that loads all of them, e.g.:
804 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
805 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
806 // And then inherit it as follows:
807 // _e = {
808 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
809 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
810 // if _e:
811 // rblf.inherit(handle, _e[0], _e[1])
812 //
813 var matchingPaths []string
814 varPath, ok := pathExpr.(*interpolateExpr)
815 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800816 return []starlarkNode{ctx.newBadNode(v, "inherit-product/include argument is too complex")}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700817 }
818
819 pathPattern := []string{varPath.chunks[0]}
820 for _, chunk := range varPath.chunks[1:] {
821 if chunk != "" {
822 pathPattern = append(pathPattern, chunk)
823 }
824 }
Cole Faust069aba62022-01-26 17:47:33 -0800825 if pathPattern[0] == "" && len(ctx.includeTops) > 0 {
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700826 // If pattern starts from the top. restrict it to the directories where
827 // we know inherit-product uses dynamically calculated path.
828 for _, p := range ctx.includeTops {
829 pathPattern[0] = p
830 matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700831 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700832 } else {
833 matchingPaths = ctx.findMatchingPaths(pathPattern)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700834 }
835 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700836 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700837 if len(matchingPaths) > maxMatchingFiles {
Cole Faustdd569ae2022-01-31 15:48:29 -0800838 return []starlarkNode{ctx.newBadNode(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700839 }
Cole Faust93f8d392022-03-02 13:31:30 -0800840
841 needsWarning := pathPattern[0] == "" && len(ctx.includeTops) == 0
842 res := inheritedDynamicModule{*varPath, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning}
843 for _, p := range matchingPaths {
844 // A product configuration files discovered dynamically may attempt to inherit
845 // from another one which does not exist in this source tree. Prevent load errors
846 // by always loading the dynamic files as optional.
847 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
Sasha Smundak6609ba72021-07-22 18:32:56 -0700848 }
Cole Faust93f8d392022-03-02 13:31:30 -0800849 return []starlarkNode{processModule(res)}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700850}
851
852func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
Cole Faust9b6111a2022-02-02 15:38:33 -0800853 files := ctx.script.makefileFinder.Find(".")
Sasha Smundak6609ba72021-07-22 18:32:56 -0700854 if len(pattern) == 0 {
855 return files
856 }
857
858 // Create regular expression from the pattern
859 s_regexp := "^" + regexp.QuoteMeta(pattern[0])
860 for _, s := range pattern[1:] {
861 s_regexp += ".*" + regexp.QuoteMeta(s)
862 }
863 s_regexp += "$"
864 rex := regexp.MustCompile(s_regexp)
865
866 // Now match
867 var res []string
868 for _, p := range files {
869 if rex.MatchString(p) {
870 res = append(res, p)
871 }
872 }
873 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800874}
875
Cole Faustf035d402022-03-28 14:02:50 -0700876type inheritProductCallParser struct {
877 loadAlways bool
878}
879
880func (p *inheritProductCallParser) parse(ctx *parseContext, v mkparser.Node, args *mkparser.MakeString) []starlarkNode {
Cole Faust9ebf6e42021-12-13 14:08:34 -0800881 args.TrimLeftSpaces()
882 args.TrimRightSpaces()
883 pathExpr := ctx.parseMakeString(v, args)
884 if _, ok := pathExpr.(*badExpr); ok {
Cole Faustdd569ae2022-01-31 15:48:29 -0800885 return []starlarkNode{ctx.newBadNode(v, "Unable to parse argument to inherit")}
Cole Faust9ebf6e42021-12-13 14:08:34 -0800886 }
Cole Faustf035d402022-03-28 14:02:50 -0700887 return ctx.handleSubConfig(v, pathExpr, p.loadAlways, func(im inheritedModule) starlarkNode {
888 return &inheritNode{im, p.loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700889 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800890}
891
Cole Faustdd569ae2022-01-31 15:48:29 -0800892func (ctx *parseContext) handleInclude(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) []starlarkNode {
893 return ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) starlarkNode {
894 return &includeNode{im, loadAlways}
Sasha Smundak6609ba72021-07-22 18:32:56 -0700895 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800896}
897
Cole Faustdd569ae2022-01-31 15:48:29 -0800898func (ctx *parseContext) handleVariable(v *mkparser.Variable) []starlarkNode {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800899 // Handle:
900 // $(call inherit-product,...)
901 // $(call inherit-product-if-exists,...)
902 // $(info xxx)
903 // $(warning xxx)
904 // $(error xxx)
Cole Faust9ebf6e42021-12-13 14:08:34 -0800905 // $(call other-custom-functions,...)
906
Cole Faustf035d402022-03-28 14:02:50 -0700907 if name, args, ok := ctx.maybeParseFunctionCall(v, v.Name); ok {
908 if kf, ok := knownNodeFunctions[name]; ok {
909 return kf.parse(ctx, v, args)
910 }
Cole Faust9ebf6e42021-12-13 14:08:34 -0800911 }
Cole Faustf035d402022-03-28 14:02:50 -0700912
Cole Faustdd569ae2022-01-31 15:48:29 -0800913 return []starlarkNode{&exprNode{expr: ctx.parseReference(v, v.Name)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800914}
915
Cole Faustdd569ae2022-01-31 15:48:29 -0800916func (ctx *parseContext) maybeHandleDefine(directive *mkparser.Directive) starlarkNode {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700917 macro_name := strings.Fields(directive.Args.Strings[0])[0]
918 // Ignore the macros that we handle
Cole Faust9ebf6e42021-12-13 14:08:34 -0800919 _, ignored := ignoredDefines[macro_name]
920 _, known := knownFunctions[macro_name]
921 if !ignored && !known {
Cole Faustdd569ae2022-01-31 15:48:29 -0800922 return ctx.newBadNode(directive, "define is not supported: %s", macro_name)
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700923 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800924 return nil
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800925}
926
Cole Faustdd569ae2022-01-31 15:48:29 -0800927func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) starlarkNode {
928 ssSwitch := &switchNode{
929 ssCases: []*switchCase{ctx.processBranch(ifDirective)},
930 }
931 for ctx.hasNodes() && ctx.fatalError == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800932 node := ctx.getNode()
933 switch x := node.(type) {
934 case *mkparser.Directive:
935 switch x.Name {
936 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
Cole Faustdd569ae2022-01-31 15:48:29 -0800937 ssSwitch.ssCases = append(ssSwitch.ssCases, ctx.processBranch(x))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800938 case "endif":
Cole Faustdd569ae2022-01-31 15:48:29 -0800939 return ssSwitch
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800940 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800941 return ctx.newBadNode(node, "unexpected directive %s", x.Name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800942 }
943 default:
Cole Faustdd569ae2022-01-31 15:48:29 -0800944 return ctx.newBadNode(ifDirective, "unexpected statement")
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800945 }
946 }
947 if ctx.fatalError == nil {
948 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
949 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800950 return ctx.newBadNode(ifDirective, "no matching endif for %s", ifDirective.Dump())
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800951}
952
953// processBranch processes a single branch (if/elseif/else) until the next directive
954// on the same level.
Cole Faustdd569ae2022-01-31 15:48:29 -0800955func (ctx *parseContext) processBranch(check *mkparser.Directive) *switchCase {
956 block := &switchCase{gate: ctx.parseCondition(check)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800957 defer func() {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800958 ctx.ifNestLevel--
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800959 }()
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800960 ctx.ifNestLevel++
961
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800962 for ctx.hasNodes() {
963 node := ctx.getNode()
Cole Faust591a1fe2021-11-08 15:37:57 -0800964 if d, ok := node.(*mkparser.Directive); ok {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800965 switch d.Name {
966 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800967 ctx.backNode()
Cole Faustdd569ae2022-01-31 15:48:29 -0800968 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800969 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800970 }
Cole Faustdd569ae2022-01-31 15:48:29 -0800971 block.nodes = append(block.nodes, ctx.handleSimpleStatement(node)...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800972 }
973 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
Cole Faustdd569ae2022-01-31 15:48:29 -0800974 return block
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800975}
976
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800977func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
978 switch check.Name {
979 case "ifdef", "ifndef", "elifdef", "elifndef":
Cole Faust71514c02022-01-27 17:21:41 -0800980 if !check.Args.Const() {
Cole Faustdd569ae2022-01-31 15:48:29 -0800981 return ctx.newBadNode(check, "ifdef variable ref too complex: %s", check.Args.Dump())
Cole Faust71514c02022-01-27 17:21:41 -0800982 }
Cole Faustf0632662022-04-07 13:59:24 -0700983 v := NewVariableRefExpr(ctx.addVariable(check.Args.Strings[0]))
Cole Faust71514c02022-01-27 17:21:41 -0800984 if strings.HasSuffix(check.Name, "ndef") {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800985 v = &notExpr{v}
986 }
987 return &ifNode{
988 isElif: strings.HasPrefix(check.Name, "elif"),
989 expr: v,
990 }
991 case "ifeq", "ifneq", "elifeq", "elifneq":
992 return &ifNode{
993 isElif: strings.HasPrefix(check.Name, "elif"),
994 expr: ctx.parseCompare(check),
995 }
996 case "else":
997 return &elseNode{}
998 default:
999 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
1000 }
1001}
1002
1003func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001004 if ctx.errorLogger != nil {
Sasha Smundak422b6142021-11-11 18:31:59 -08001005 ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001006 }
1007 ctx.script.hasErrors = true
Cole Faustdd569ae2022-01-31 15:48:29 -08001008 return &badExpr{errorLocation: ctx.errorLocation(node), message: fmt.Sprintf(text, args...)}
1009}
1010
1011// records that the given node failed to be converted and includes an explanatory message
1012func (ctx *parseContext) newBadNode(failedNode mkparser.Node, message string, args ...interface{}) starlarkNode {
1013 return &exprNode{ctx.newBadExpr(failedNode, message, args...)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001014}
1015
1016func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
1017 // Strip outer parentheses
1018 mkArg := cloneMakeString(cond.Args)
1019 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1020 n := len(mkArg.Strings)
1021 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1022 args := mkArg.Split(",")
1023 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1024 if len(args) != 2 {
1025 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1026 }
1027 args[0].TrimRightSpaces()
1028 args[1].TrimLeftSpaces()
1029
1030 isEq := !strings.HasSuffix(cond.Name, "neq")
Cole Faustf8320212021-11-10 15:05:07 -08001031 xLeft := ctx.parseMakeString(cond, args[0])
1032 xRight := ctx.parseMakeString(cond, args[1])
1033 if bad, ok := xLeft.(*badExpr); ok {
1034 return bad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001035 }
Cole Faustf8320212021-11-10 15:05:07 -08001036 if bad, ok := xRight.(*badExpr); ok {
1037 return bad
1038 }
1039
1040 if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok {
1041 return expr
1042 }
1043
Cole Faust9ebf6e42021-12-13 14:08:34 -08001044 var stringOperand string
1045 var otherOperand starlarkExpr
1046 if s, ok := maybeString(xLeft); ok {
1047 stringOperand = s
1048 otherOperand = xRight
1049 } else if s, ok := maybeString(xRight); ok {
1050 stringOperand = s
1051 otherOperand = xLeft
1052 }
1053
Cole Faust9ebf6e42021-12-13 14:08:34 -08001054 // If we've identified one of the operands as being a string literal, check
1055 // for some special cases we can do to simplify the resulting expression.
1056 if otherOperand != nil {
1057 if stringOperand == "" {
1058 if isEq {
Cole Faustf035d402022-03-28 14:02:50 -07001059 return negateExpr(otherOperand)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001060 } else {
1061 return otherOperand
1062 }
1063 }
1064 if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool {
1065 if !isEq {
Cole Faustf035d402022-03-28 14:02:50 -07001066 return negateExpr(otherOperand)
Cole Faust9ebf6e42021-12-13 14:08:34 -08001067 } else {
1068 return otherOperand
1069 }
1070 }
Cole Fausta99afdf2022-04-26 12:06:49 -07001071 if otherOperand.typ() == starlarkTypeList {
1072 fields := strings.Fields(stringOperand)
1073 elements := make([]starlarkExpr, len(fields))
1074 for i, s := range fields {
1075 elements[i] = &stringLiteralExpr{literal: s}
1076 }
1077 return &eqExpr{
1078 left: otherOperand,
1079 right: &listExpr{elements},
1080 isEq: isEq,
1081 }
1082 }
Cole Faustb1103e22022-01-06 15:22:05 -08001083 if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt {
1084 return &eqExpr{
1085 left: otherOperand,
1086 right: &intLiteralExpr{literal: intOperand},
1087 isEq: isEq,
1088 }
1089 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001090 }
1091
Cole Faustf8320212021-11-10 15:05:07 -08001092 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001093}
1094
Cole Faustf8320212021-11-10 15:05:07 -08001095// Given an if statement's directive and the left/right starlarkExprs,
1096// check if the starlarkExprs are one of a few hardcoded special cases
Cole Faust9932f752022-02-08 11:56:25 -08001097// that can be converted to a simpler equality expression than simply comparing
Cole Faustf8320212021-11-10 15:05:07 -08001098// the two.
1099func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr,
1100 right starlarkExpr) (starlarkExpr, bool) {
1101 isEq := !strings.HasSuffix(directive.Name, "neq")
1102
1103 // All the special cases require a call on one side and a
1104 // string literal/variable on the other. Turn the left/right variables into
1105 // call/value variables, and return false if that's not possible.
1106 var value starlarkExpr = nil
1107 call, ok := left.(*callExpr)
1108 if ok {
1109 switch right.(type) {
1110 case *stringLiteralExpr, *variableRefExpr:
1111 value = right
1112 }
1113 } else {
1114 call, _ = right.(*callExpr)
1115 switch left.(type) {
1116 case *stringLiteralExpr, *variableRefExpr:
1117 value = left
1118 }
1119 }
1120
1121 if call == nil || value == nil {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001122 return nil, false
1123 }
Cole Faustf8320212021-11-10 15:05:07 -08001124
Cole Faustf8320212021-11-10 15:05:07 -08001125 switch call.name {
Cole Faust9932f752022-02-08 11:56:25 -08001126 case baseName + ".filter":
1127 return ctx.parseCompareFilterFuncResult(directive, call, value, isEq)
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,
Cole Faust9932f752022-02-08 11:56:25 -08001137 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) (starlarkExpr, bool) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001138 // 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", ...]
Cole Faust9932f752022-02-08 11:56:25 -08001141 if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" {
1142 return nil, false
1143 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001144 xPattern := filterFuncCall.args[0]
1145 xText := filterFuncCall.args[1]
1146 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001147 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001148 var ok bool
Cole Faust9932f752022-02-08 11:56:25 -08001149 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
1150 expr = xText
1151 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
1152 expr = xPattern
1153 } else {
1154 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001155 }
Cole Faust9932f752022-02-08 11:56:25 -08001156 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1157 // Generate simpler code for the common cases:
1158 if expr.typ() == starlarkTypeList {
1159 if len(slExpr.items) == 1 {
1160 // Checking that a string belongs to list
1161 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}, true
Sasha Smundak0554d762021-07-08 18:26:12 -07001162 } else {
Cole Faust9932f752022-02-08 11:56:25 -08001163 return nil, false
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001164 }
Cole Faust9932f752022-02-08 11:56:25 -08001165 } else if len(slExpr.items) == 1 {
1166 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}, true
1167 } else {
1168 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}, true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001169 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001170}
1171
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001172func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1173 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001174 if isEmptyString(xValue) {
1175 return &eqExpr{
1176 left: &callExpr{
1177 object: xCall.args[1],
1178 name: "find",
1179 args: []starlarkExpr{xCall.args[0]},
1180 returnType: starlarkTypeInt,
1181 },
1182 right: &intLiteralExpr{-1},
1183 isEq: !negate,
1184 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001185 } else if s, ok := maybeString(xValue); ok {
1186 if s2, ok := maybeString(xCall.args[0]); ok && s == s2 {
1187 return &eqExpr{
1188 left: &callExpr{
1189 object: xCall.args[1],
1190 name: "find",
1191 args: []starlarkExpr{xCall.args[0]},
1192 returnType: starlarkTypeInt,
1193 },
1194 right: &intLiteralExpr{-1},
1195 isEq: negate,
1196 }
1197 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001198 }
Cole Faust0e9418c2021-12-13 16:33:25 -08001199 return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001200}
1201
1202func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1203 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1204 if _, ok := xValue.(*stringLiteralExpr); !ok {
1205 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1206 }
1207 return &eqExpr{
1208 left: &callExpr{
1209 name: "strip",
1210 args: xCall.args,
1211 returnType: starlarkTypeString,
1212 },
1213 right: xValue, isEq: !negate}
1214}
1215
Cole Faustf035d402022-03-28 14:02:50 -07001216func (ctx *parseContext) maybeParseFunctionCall(node mkparser.Node, ref *mkparser.MakeString) (name string, args *mkparser.MakeString, ok bool) {
1217 ref.TrimLeftSpaces()
1218 ref.TrimRightSpaces()
1219
1220 words := ref.SplitN(" ", 2)
1221 if !words[0].Const() {
1222 return "", nil, false
1223 }
1224
1225 name = words[0].Dump()
1226 args = mkparser.SimpleMakeString("", words[0].Pos())
1227 if len(words) >= 2 {
1228 args = words[1]
1229 }
1230 args.TrimLeftSpaces()
1231 if name == "call" {
1232 words = args.SplitN(",", 2)
1233 if words[0].Empty() || !words[0].Const() {
1234 return "", nil, false
1235 }
1236 name = words[0].Dump()
1237 if len(words) < 2 {
Cole Faust6c41b8a2022-04-13 13:53:48 -07001238 args = mkparser.SimpleMakeString("", words[0].Pos())
Cole Faustf035d402022-03-28 14:02:50 -07001239 } else {
1240 args = words[1]
1241 }
1242 }
1243 ok = true
1244 return
1245}
1246
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001247// parses $(...), returning an expression
1248func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1249 ref.TrimLeftSpaces()
1250 ref.TrimRightSpaces()
1251 refDump := ref.Dump()
1252
1253 // Handle only the case where the first (or only) word is constant
1254 words := ref.SplitN(" ", 2)
1255 if !words[0].Const() {
1256 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1257 }
1258
1259 // If it is a single word, it can be a simple variable
1260 // reference or a function call
Cole Faustf035d402022-03-28 14:02:50 -07001261 if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" && refDump != "eval" {
Sasha Smundak65b547e2021-09-17 15:35:41 -07001262 if strings.HasPrefix(refDump, soongNsPrefix) {
1263 // TODO (asmundak): if we find many, maybe handle them.
Cole Faustc00184e2021-11-08 12:08:57 -08001264 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
Sasha Smundak65b547e2021-09-17 15:35:41 -07001265 }
Cole Faustc36c9622021-12-07 15:20:45 -08001266 // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html
1267 if strings.Contains(refDump, ":") {
1268 parts := strings.SplitN(refDump, ":", 2)
1269 substParts := strings.SplitN(parts[1], "=", 2)
1270 if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 {
1271 return ctx.newBadExpr(node, "Invalid substitution reference")
1272 }
1273 if !strings.Contains(substParts[0], "%") {
1274 if strings.Contains(substParts[1], "%") {
1275 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.")
1276 }
1277 substParts[0] = "%" + substParts[0]
1278 substParts[1] = "%" + substParts[1]
1279 }
1280 v := ctx.addVariable(parts[0])
1281 if v == nil {
1282 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1283 }
1284 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001285 name: baseName + ".mkpatsubst",
1286 returnType: starlarkTypeString,
Cole Faustc36c9622021-12-07 15:20:45 -08001287 args: []starlarkExpr{
1288 &stringLiteralExpr{literal: substParts[0]},
1289 &stringLiteralExpr{literal: substParts[1]},
Cole Faustf0632662022-04-07 13:59:24 -07001290 NewVariableRefExpr(v),
Cole Faustc36c9622021-12-07 15:20:45 -08001291 },
1292 }
1293 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001294 if v := ctx.addVariable(refDump); v != nil {
Cole Faustf0632662022-04-07 13:59:24 -07001295 return NewVariableRefExpr(v)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001296 }
1297 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1298 }
1299
Cole Faustf035d402022-03-28 14:02:50 -07001300 if name, args, ok := ctx.maybeParseFunctionCall(node, ref); ok {
1301 if kf, found := knownFunctions[name]; found {
1302 return kf.parse(ctx, node, args)
Sasha Smundak6609ba72021-07-22 18:32:56 -07001303 } else {
Cole Faustf035d402022-03-28 14:02:50 -07001304 return ctx.newBadExpr(node, "cannot handle invoking %s", name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001305 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001306 } else {
Cole Faustf035d402022-03-28 14:02:50 -07001307 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001308 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001309}
1310
1311type simpleCallParser struct {
1312 name string
1313 returnType starlarkType
1314 addGlobals bool
Cole Faust1cc08852022-02-28 11:12:08 -08001315 addHandle bool
Cole Faust9ebf6e42021-12-13 14:08:34 -08001316}
1317
1318func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1319 expr := &callExpr{name: p.name, returnType: p.returnType}
1320 if p.addGlobals {
1321 expr.args = append(expr.args, &globalsExpr{})
1322 }
Cole Faust1cc08852022-02-28 11:12:08 -08001323 if p.addHandle {
1324 expr.args = append(expr.args, &identifierExpr{name: "handle"})
1325 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001326 for _, arg := range args.Split(",") {
1327 arg.TrimLeftSpaces()
1328 arg.TrimRightSpaces()
1329 x := ctx.parseMakeString(node, arg)
1330 if xBad, ok := x.(*badExpr); ok {
1331 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001332 }
Cole Faust9ebf6e42021-12-13 14:08:34 -08001333 expr.args = append(expr.args, x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001334 }
1335 return expr
1336}
1337
Cole Faust9ebf6e42021-12-13 14:08:34 -08001338type makeControlFuncParser struct {
1339 name string
1340}
1341
1342func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1343 // Make control functions need special treatment as everything
1344 // after the name is a single text argument
1345 x := ctx.parseMakeString(node, args)
1346 if xBad, ok := x.(*badExpr); ok {
1347 return xBad
1348 }
1349 return &callExpr{
1350 name: p.name,
1351 args: []starlarkExpr{
1352 &stringLiteralExpr{ctx.script.mkFile},
1353 x,
1354 },
1355 returnType: starlarkTypeUnknown,
1356 }
1357}
1358
1359type shellCallParser struct{}
1360
1361func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1362 // Shell functions need special treatment as everything
1363 // after the name is a single text argument
1364 x := ctx.parseMakeString(node, args)
1365 if xBad, ok := x.(*badExpr); ok {
1366 return xBad
1367 }
1368 return &callExpr{
1369 name: baseName + ".shell",
1370 args: []starlarkExpr{x},
1371 returnType: starlarkTypeUnknown,
1372 }
1373}
1374
1375type myDirCallParser struct{}
1376
1377func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1378 if !args.Empty() {
1379 return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.")
1380 }
Cole Faustf5adedc2022-03-18 14:05:06 -07001381 return &stringLiteralExpr{literal: filepath.Dir(ctx.script.mkFile)}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001382}
1383
Cole Faust9ebf6e42021-12-13 14:08:34 -08001384type isProductInListCallParser struct{}
1385
1386func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1387 if args.Empty() {
1388 return ctx.newBadExpr(node, "is-product-in-list requires an argument")
1389 }
1390 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001391 expr: NewVariableRefExpr(ctx.addVariable("TARGET_PRODUCT")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001392 list: maybeConvertToStringList(ctx.parseMakeString(node, args)),
1393 isNot: false,
1394 }
1395}
1396
1397type isVendorBoardPlatformCallParser struct{}
1398
1399func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1400 if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) {
1401 return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform")
1402 }
1403 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001404 expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
1405 list: NewVariableRefExpr(ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001406 isNot: false,
1407 }
1408}
1409
1410type isVendorBoardQcomCallParser struct{}
1411
1412func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1413 if !args.Empty() {
1414 return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments")
1415 }
1416 return &inExpr{
Cole Faustf0632662022-04-07 13:59:24 -07001417 expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
1418 list: NewVariableRefExpr(ctx.addVariable("QCOM_BOARD_PLATFORMS")),
Cole Faust9ebf6e42021-12-13 14:08:34 -08001419 isNot: false,
1420 }
1421}
1422
1423type substCallParser struct {
1424 fname string
1425}
1426
1427func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001428 words := args.Split(",")
1429 if len(words) != 3 {
Cole Faust9ebf6e42021-12-13 14:08:34 -08001430 return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001431 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001432 from := ctx.parseMakeString(node, words[0])
1433 if xBad, ok := from.(*badExpr); ok {
1434 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001435 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001436 to := ctx.parseMakeString(node, words[1])
1437 if xBad, ok := to.(*badExpr); ok {
1438 return xBad
1439 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001440 words[2].TrimLeftSpaces()
1441 words[2].TrimRightSpaces()
1442 obj := ctx.parseMakeString(node, words[2])
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001443 typ := obj.typ()
Cole Faust9ebf6e42021-12-13 14:08:34 -08001444 if typ == starlarkTypeString && p.fname == "subst" {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001445 // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001446 return &callExpr{
1447 object: obj,
1448 name: "replace",
Sasha Smundak35434ed2021-11-05 16:29:56 -07001449 args: []starlarkExpr{from, to},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001450 returnType: typ,
1451 }
1452 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001453 return &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001454 name: baseName + ".mk" + p.fname,
Sasha Smundak35434ed2021-11-05 16:29:56 -07001455 args: []starlarkExpr{from, to, obj},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001456 returnType: obj.typ(),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001457 }
1458}
1459
Cole Faust9ebf6e42021-12-13 14:08:34 -08001460type ifCallParser struct{}
1461
1462func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faust4eadba72021-12-07 11:54:52 -08001463 words := args.Split(",")
1464 if len(words) != 2 && len(words) != 3 {
1465 return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))
1466 }
1467 condition := ctx.parseMakeString(node, words[0])
1468 ifTrue := ctx.parseMakeString(node, words[1])
1469 var ifFalse starlarkExpr
1470 if len(words) == 3 {
1471 ifFalse = ctx.parseMakeString(node, words[2])
1472 } else {
1473 switch ifTrue.typ() {
1474 case starlarkTypeList:
1475 ifFalse = &listExpr{items: []starlarkExpr{}}
1476 case starlarkTypeInt:
1477 ifFalse = &intLiteralExpr{literal: 0}
1478 case starlarkTypeBool:
1479 ifFalse = &boolLiteralExpr{literal: false}
1480 default:
1481 ifFalse = &stringLiteralExpr{literal: ""}
1482 }
1483 }
1484 return &ifExpr{
1485 condition,
1486 ifTrue,
1487 ifFalse,
1488 }
1489}
1490
Cole Faustf035d402022-03-28 14:02:50 -07001491type ifCallNodeParser struct{}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001492
Cole Faustf035d402022-03-28 14:02:50 -07001493func (p *ifCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1494 words := args.Split(",")
1495 if len(words) != 2 && len(words) != 3 {
1496 return []starlarkNode{ctx.newBadNode(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))}
1497 }
1498
1499 ifn := &ifNode{expr: ctx.parseMakeString(node, words[0])}
1500 cases := []*switchCase{
1501 {
1502 gate: ifn,
1503 nodes: ctx.parseNodeMakeString(node, words[1]),
1504 },
1505 }
1506 if len(words) == 3 {
1507 cases = append(cases, &switchCase{
1508 gate: &elseNode{},
1509 nodes: ctx.parseNodeMakeString(node, words[2]),
1510 })
1511 }
1512 if len(cases) == 2 {
1513 if len(cases[1].nodes) == 0 {
1514 // Remove else branch if it has no contents
1515 cases = cases[:1]
1516 } else if len(cases[0].nodes) == 0 {
1517 // If the if branch has no contents but the else does,
1518 // move them to the if and negate its condition
1519 ifn.expr = negateExpr(ifn.expr)
1520 cases[0].nodes = cases[1].nodes
1521 cases = cases[:1]
1522 }
1523 }
1524
1525 return []starlarkNode{&switchNode{ssCases: cases}}
1526}
1527
1528type foreachCallParser struct{}
1529
1530func (p *foreachCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Cole Faustb0d32ab2021-12-09 14:00:59 -08001531 words := args.Split(",")
1532 if len(words) != 3 {
1533 return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))
1534 }
1535 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1536 return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier")
1537 }
1538 loopVarName := words[0].Strings[0]
1539 list := ctx.parseMakeString(node, words[1])
1540 action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr {
1541 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1542 return &identifierExpr{loopVarName}
1543 }
1544 return nil
1545 })
1546
1547 if list.typ() != starlarkTypeList {
1548 list = &callExpr{
Cole Faust9ebf6e42021-12-13 14:08:34 -08001549 name: baseName + ".words",
1550 returnType: starlarkTypeList,
Cole Faustb0d32ab2021-12-09 14:00:59 -08001551 args: []starlarkExpr{list},
1552 }
1553 }
1554
1555 return &foreachExpr{
1556 varName: loopVarName,
1557 list: list,
1558 action: action,
1559 }
1560}
1561
Cole Faustf035d402022-03-28 14:02:50 -07001562func transformNode(node starlarkNode, transformer func(expr starlarkExpr) starlarkExpr) {
1563 switch a := node.(type) {
1564 case *ifNode:
1565 a.expr = a.expr.transform(transformer)
1566 case *switchCase:
1567 transformNode(a.gate, transformer)
1568 for _, n := range a.nodes {
1569 transformNode(n, transformer)
1570 }
1571 case *switchNode:
1572 for _, n := range a.ssCases {
1573 transformNode(n, transformer)
1574 }
1575 case *exprNode:
1576 a.expr = a.expr.transform(transformer)
1577 case *assignmentNode:
1578 a.value = a.value.transform(transformer)
1579 case *foreachNode:
1580 a.list = a.list.transform(transformer)
1581 for _, n := range a.actions {
1582 transformNode(n, transformer)
1583 }
1584 }
1585}
1586
1587type foreachCallNodeParser struct{}
1588
1589func (p *foreachCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1590 words := args.Split(",")
1591 if len(words) != 3 {
1592 return []starlarkNode{ctx.newBadNode(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))}
1593 }
1594 if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
1595 return []starlarkNode{ctx.newBadNode(node, "first argument to foreach function must be a simple string identifier")}
1596 }
1597
1598 loopVarName := words[0].Strings[0]
1599
1600 list := ctx.parseMakeString(node, words[1])
1601 if list.typ() != starlarkTypeList {
1602 list = &callExpr{
1603 name: baseName + ".words",
1604 returnType: starlarkTypeList,
1605 args: []starlarkExpr{list},
1606 }
1607 }
1608
1609 actions := ctx.parseNodeMakeString(node, words[2])
1610 // TODO(colefaust): Replace transforming code with something more elegant
1611 for _, action := range actions {
1612 transformNode(action, func(expr starlarkExpr) starlarkExpr {
1613 if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
1614 return &identifierExpr{loopVarName}
1615 }
1616 return nil
1617 })
1618 }
1619
1620 return []starlarkNode{&foreachNode{
1621 varName: loopVarName,
1622 list: list,
1623 actions: actions,
1624 }}
1625}
1626
Cole Faust9ebf6e42021-12-13 14:08:34 -08001627type wordCallParser struct{}
1628
1629func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001630 words := args.Split(",")
1631 if len(words) != 2 {
1632 return ctx.newBadExpr(node, "word function should have 2 arguments")
1633 }
1634 var index uint64 = 0
1635 if words[0].Const() {
1636 index, _ = strconv.ParseUint(strings.TrimSpace(words[0].Strings[0]), 10, 64)
1637 }
1638 if index < 1 {
1639 return ctx.newBadExpr(node, "word index should be constant positive integer")
1640 }
1641 words[1].TrimLeftSpaces()
1642 words[1].TrimRightSpaces()
1643 array := ctx.parseMakeString(node, words[1])
1644 if xBad, ok := array.(*badExpr); ok {
1645 return xBad
1646 }
1647 if array.typ() != starlarkTypeList {
1648 array = &callExpr{object: array, name: "split", returnType: starlarkTypeList}
1649 }
Cole Faustb0d32ab2021-12-09 14:00:59 -08001650 return &indexExpr{array, &intLiteralExpr{int(index - 1)}}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001651}
1652
Cole Faust9ebf6e42021-12-13 14:08:34 -08001653type firstOrLastwordCallParser struct {
1654 isLastWord bool
1655}
1656
1657func (p *firstOrLastwordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
Sasha Smundak16e07732021-07-23 11:38:23 -07001658 arg := ctx.parseMakeString(node, args)
1659 if bad, ok := arg.(*badExpr); ok {
1660 return bad
1661 }
1662 index := &intLiteralExpr{0}
Cole Faust9ebf6e42021-12-13 14:08:34 -08001663 if p.isLastWord {
Sasha Smundak16e07732021-07-23 11:38:23 -07001664 if v, ok := arg.(*variableRefExpr); ok && v.ref.name() == "MAKEFILE_LIST" {
1665 return &stringLiteralExpr{ctx.script.mkFile}
1666 }
1667 index.literal = -1
1668 }
1669 if arg.typ() == starlarkTypeList {
1670 return &indexExpr{arg, index}
1671 }
1672 return &indexExpr{&callExpr{object: arg, name: "split", returnType: starlarkTypeList}, index}
1673}
1674
Cole Faustb1103e22022-01-06 15:22:05 -08001675func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) {
1676 parsedArgs := make([]starlarkExpr, 0)
1677 for _, arg := range args.Split(",") {
1678 expr := ctx.parseMakeString(node, arg)
1679 if expr.typ() == starlarkTypeList {
1680 return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int")
1681 }
1682 if s, ok := maybeString(expr); ok {
1683 intVal, err := strconv.Atoi(strings.TrimSpace(s))
1684 if err != nil {
1685 return nil, err
1686 }
1687 expr = &intLiteralExpr{literal: intVal}
1688 } else if expr.typ() != starlarkTypeInt {
1689 expr = &callExpr{
1690 name: "int",
1691 args: []starlarkExpr{expr},
1692 returnType: starlarkTypeInt,
1693 }
1694 }
1695 parsedArgs = append(parsedArgs, expr)
1696 }
1697 if len(parsedArgs) != expectedArgs {
1698 return nil, fmt.Errorf("function should have %d arguments", expectedArgs)
1699 }
1700 return parsedArgs, nil
1701}
1702
1703type mathComparisonCallParser struct {
1704 op string
1705}
1706
1707func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1708 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1709 if err != nil {
1710 return ctx.newBadExpr(node, err.Error())
1711 }
1712 return &binaryOpExpr{
1713 left: parsedArgs[0],
1714 right: parsedArgs[1],
1715 op: p.op,
1716 returnType: starlarkTypeBool,
1717 }
1718}
1719
1720type mathMaxOrMinCallParser struct {
1721 function string
1722}
1723
1724func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1725 parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
1726 if err != nil {
1727 return ctx.newBadExpr(node, err.Error())
1728 }
1729 return &callExpr{
1730 object: nil,
1731 name: p.function,
1732 args: parsedArgs,
1733 returnType: starlarkTypeInt,
1734 }
1735}
1736
Cole Faustf035d402022-03-28 14:02:50 -07001737type evalNodeParser struct{}
1738
1739func (p *evalNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
1740 parser := mkparser.NewParser("Eval expression", strings.NewReader(args.Dump()))
1741 nodes, errs := parser.Parse()
1742 if errs != nil {
1743 return []starlarkNode{ctx.newBadNode(node, "Unable to parse eval statement")}
1744 }
1745
1746 if len(nodes) == 0 {
1747 return []starlarkNode{}
1748 } else if len(nodes) == 1 {
1749 switch n := nodes[0].(type) {
1750 case *mkparser.Assignment:
1751 if n.Name.Const() {
1752 return ctx.handleAssignment(n)
1753 }
1754 case *mkparser.Comment:
1755 return []starlarkNode{&commentNode{strings.TrimSpace("#" + n.Comment)}}
1756 }
1757 }
1758
1759 return []starlarkNode{ctx.newBadNode(node, "Eval expression too complex; only assignments and comments are supported")}
1760}
1761
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001762func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
1763 if mk.Const() {
1764 return &stringLiteralExpr{mk.Dump()}
1765 }
1766 if mkRef, ok := mk.SingleVariable(); ok {
1767 return ctx.parseReference(node, mkRef)
1768 }
1769 // If we reached here, it's neither string literal nor a simple variable,
1770 // we need a full-blown interpolation node that will generate
1771 // "a%b%c" % (X, Y) for a$(X)b$(Y)c
Cole Faustfc438682021-12-14 12:46:32 -08001772 parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings))
1773 for i := 0; i < len(parts); i++ {
1774 if i%2 == 0 {
1775 parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]}
1776 } else {
1777 parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name)
1778 if x, ok := parts[i].(*badExpr); ok {
1779 return x
1780 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001781 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001782 }
Cole Faustfc438682021-12-14 12:46:32 -08001783 return NewInterpolateExpr(parts)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001784}
1785
Cole Faustf035d402022-03-28 14:02:50 -07001786func (ctx *parseContext) parseNodeMakeString(node mkparser.Node, mk *mkparser.MakeString) []starlarkNode {
1787 // Discard any constant values in the make string, as they would be top level
1788 // string literals and do nothing.
1789 result := make([]starlarkNode, 0, len(mk.Variables))
1790 for i := range mk.Variables {
1791 result = append(result, ctx.handleVariable(&mk.Variables[i])...)
1792 }
1793 return result
1794}
1795
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001796// Handles the statements whose treatment is the same in all contexts: comment,
1797// assignment, variable (which is a macro call in reality) and all constructs that
1798// do not handle in any context ('define directive and any unrecognized stuff).
Cole Faustdd569ae2022-01-31 15:48:29 -08001799func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) []starlarkNode {
1800 var result []starlarkNode
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001801 switch x := node.(type) {
1802 case *mkparser.Comment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001803 if n, handled := ctx.maybeHandleAnnotation(x); handled && n != nil {
1804 result = []starlarkNode{n}
1805 } else if !handled {
1806 result = []starlarkNode{&commentNode{strings.TrimSpace("#" + x.Comment)}}
Cole Faust7940c6a2022-01-31 15:54:05 -08001807 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001808 case *mkparser.Assignment:
Cole Faustdd569ae2022-01-31 15:48:29 -08001809 result = ctx.handleAssignment(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001810 case *mkparser.Variable:
Cole Faustdd569ae2022-01-31 15:48:29 -08001811 result = ctx.handleVariable(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001812 case *mkparser.Directive:
1813 switch x.Name {
1814 case "define":
Cole Faustdd569ae2022-01-31 15:48:29 -08001815 if res := ctx.maybeHandleDefine(x); res != nil {
1816 result = []starlarkNode{res}
1817 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001818 case "include", "-include":
Cole Faustdd569ae2022-01-31 15:48:29 -08001819 result = ctx.handleInclude(node, ctx.parseMakeString(node, x.Args), x.Name[0] != '-')
Cole Faust591a1fe2021-11-08 15:37:57 -08001820 case "ifeq", "ifneq", "ifdef", "ifndef":
Cole Faustdd569ae2022-01-31 15:48:29 -08001821 result = []starlarkNode{ctx.handleIfBlock(x)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001822 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001823 result = []starlarkNode{ctx.newBadNode(x, "unexpected directive %s", x.Name)}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001824 }
1825 default:
Cole Faustdd569ae2022-01-31 15:48:29 -08001826 result = []starlarkNode{ctx.newBadNode(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001827 }
Cole Faust6c934f62022-01-06 15:51:12 -08001828
1829 // Clear the includeTops after each non-comment statement
1830 // so that include annotations placed on certain statements don't apply
1831 // globally for the rest of the makefile was well.
Cole Faustf92c9f22022-03-14 14:35:50 -07001832 if _, wasComment := node.(*mkparser.Comment); !wasComment {
1833 ctx.atTopOfMakefile = false
Cole Faust6c934f62022-01-06 15:51:12 -08001834 ctx.includeTops = []string{}
1835 }
Cole Faustdd569ae2022-01-31 15:48:29 -08001836
1837 if result == nil {
1838 result = []starlarkNode{}
1839 }
Cole Faustf035d402022-03-28 14:02:50 -07001840
Cole Faustdd569ae2022-01-31 15:48:29 -08001841 return result
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001842}
1843
Cole Faustf92c9f22022-03-14 14:35:50 -07001844// The types allowed in a type_hint
1845var typeHintMap = map[string]starlarkType{
1846 "string": starlarkTypeString,
1847 "list": starlarkTypeList,
1848}
1849
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001850// Processes annotation. An annotation is a comment that starts with #RBC# and provides
1851// a conversion hint -- say, where to look for the dynamically calculated inherit/include
Cole Faust7940c6a2022-01-31 15:54:05 -08001852// paths. Returns true if the comment was a successfully-handled annotation.
Cole Faustdd569ae2022-01-31 15:48:29 -08001853func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) (starlarkNode, bool) {
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001854 maybeTrim := func(s, prefix string) (string, bool) {
1855 if strings.HasPrefix(s, prefix) {
1856 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
1857 }
1858 return s, false
1859 }
1860 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
1861 if !ok {
Cole Faustdd569ae2022-01-31 15:48:29 -08001862 return nil, false
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001863 }
1864 if p, ok := maybeTrim(annotation, "include_top"); ok {
Cole Faustf7ed5342021-12-21 14:15:12 -08001865 // Don't allow duplicate include tops, because then we will generate
1866 // invalid starlark code. (duplicate keys in the _entry dictionary)
1867 for _, top := range ctx.includeTops {
1868 if top == p {
Cole Faustdd569ae2022-01-31 15:48:29 -08001869 return nil, true
Cole Faustf7ed5342021-12-21 14:15:12 -08001870 }
1871 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001872 ctx.includeTops = append(ctx.includeTops, p)
Cole Faustdd569ae2022-01-31 15:48:29 -08001873 return nil, true
Cole Faustf92c9f22022-03-14 14:35:50 -07001874 } else if p, ok := maybeTrim(annotation, "type_hint"); ok {
1875 // Type hints must come at the beginning the file, to avoid confusion
1876 // if a type hint was specified later and thus only takes effect for half
1877 // of the file.
1878 if !ctx.atTopOfMakefile {
1879 return ctx.newBadNode(cnode, "type_hint annotations must come before the first Makefile statement"), true
1880 }
1881
1882 parts := strings.Fields(p)
1883 if len(parts) <= 1 {
1884 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
1885 }
1886
1887 var varType starlarkType
1888 if varType, ok = typeHintMap[parts[0]]; !ok {
1889 varType = starlarkTypeUnknown
1890 }
1891 if varType == starlarkTypeUnknown {
1892 return ctx.newBadNode(cnode, "Invalid type_hint annotation. Only list/string types are accepted, found %s", parts[0]), true
1893 }
1894
1895 for _, name := range parts[1:] {
1896 // Don't allow duplicate type hints
1897 if _, ok := ctx.typeHints[name]; ok {
1898 return ctx.newBadNode(cnode, "Duplicate type hint for variable %s", name), true
1899 }
1900 ctx.typeHints[name] = varType
1901 }
1902 return nil, true
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001903 }
Cole Faustdd569ae2022-01-31 15:48:29 -08001904 return ctx.newBadNode(cnode, "unsupported annotation %s", cnode.Comment), true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001905}
1906
1907func (ctx *parseContext) loadedModulePath(path string) string {
1908 // During the transition to Roboleaf some of the product configuration files
1909 // will be converted and checked in while the others will be generated on the fly
1910 // and run. The runner (rbcrun application) accommodates this by allowing three
1911 // different ways to specify the loaded file location:
1912 // 1) load(":<file>",...) loads <file> from the same directory
1913 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
1914 // 3) load("/absolute/path/to/<file> absolute path
1915 // If the file being generated and the file it wants to load are in the same directory,
1916 // generate option 1.
1917 // Otherwise, if output directory is not specified, generate 2)
1918 // Finally, if output directory has been specified and the file being generated and
1919 // the file it wants to load from are in the different directories, generate 2) or 3):
1920 // * if the file being loaded exists in the source tree, generate 2)
1921 // * otherwise, generate 3)
1922 // Finally, figure out the loaded module path and name and create a node for it
1923 loadedModuleDir := filepath.Dir(path)
1924 base := filepath.Base(path)
1925 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
1926 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
1927 return ":" + loadedModuleName
1928 }
1929 if ctx.outputDir == "" {
1930 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1931 }
1932 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
1933 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1934 }
1935 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
1936}
1937
Sasha Smundak3deb9682021-07-26 18:42:25 -07001938func (ctx *parseContext) addSoongNamespace(ns string) {
1939 if _, ok := ctx.soongNamespaces[ns]; ok {
1940 return
1941 }
1942 ctx.soongNamespaces[ns] = make(map[string]bool)
1943}
1944
1945func (ctx *parseContext) hasSoongNamespace(name string) bool {
1946 _, ok := ctx.soongNamespaces[name]
1947 return ok
1948}
1949
1950func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
1951 ctx.addSoongNamespace(namespaceName)
1952 vars := ctx.soongNamespaces[namespaceName]
1953 if replace {
1954 vars = make(map[string]bool)
1955 ctx.soongNamespaces[namespaceName] = vars
1956 }
1957 for _, v := range varNames {
1958 vars[v] = true
1959 }
1960}
1961
1962func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
1963 vars, ok := ctx.soongNamespaces[namespaceName]
1964 if ok {
1965 _, ok = vars[varName]
1966 }
1967 return ok
1968}
1969
Sasha Smundak422b6142021-11-11 18:31:59 -08001970func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation {
1971 return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())}
1972}
1973
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001974func (ss *StarlarkScript) String() string {
1975 return NewGenerateContext(ss).emit()
1976}
1977
1978func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001979
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001980 var subs []string
1981 for _, src := range ss.inherited {
1982 subs = append(subs, src.originalPath)
1983 }
1984 return subs
1985}
1986
1987func (ss *StarlarkScript) HasErrors() bool {
1988 return ss.hasErrors
1989}
1990
1991// Convert reads and parses a makefile. If successful, parsed tree
1992// is returned and then can be passed to String() to get the generated
1993// Starlark file.
1994func Convert(req Request) (*StarlarkScript, error) {
1995 reader := req.Reader
1996 if reader == nil {
1997 mkContents, err := ioutil.ReadFile(req.MkFile)
1998 if err != nil {
1999 return nil, err
2000 }
2001 reader = bytes.NewBuffer(mkContents)
2002 }
2003 parser := mkparser.NewParser(req.MkFile, reader)
2004 nodes, errs := parser.Parse()
2005 if len(errs) > 0 {
2006 for _, e := range errs {
2007 fmt.Fprintln(os.Stderr, "ERROR:", e)
2008 }
2009 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
2010 }
2011 starScript := &StarlarkScript{
Sasha Smundak422b6142021-11-11 18:31:59 -08002012 moduleName: moduleNameForFile(req.MkFile),
2013 mkFile: req.MkFile,
Sasha Smundak422b6142021-11-11 18:31:59 -08002014 traceCalls: req.TraceCalls,
2015 sourceFS: req.SourceFS,
2016 makefileFinder: req.MakefileFinder,
2017 nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line },
Cole Faustdd569ae2022-01-31 15:48:29 -08002018 nodes: make([]starlarkNode, 0),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002019 }
2020 ctx := newParseContext(starScript, nodes)
2021 ctx.outputSuffix = req.OutputSuffix
2022 ctx.outputDir = req.OutputDir
2023 ctx.errorLogger = req.ErrorLogger
2024 if len(req.TracedVariables) > 0 {
2025 ctx.tracedVariables = make(map[string]bool)
2026 for _, v := range req.TracedVariables {
2027 ctx.tracedVariables[v] = true
2028 }
2029 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002030 for ctx.hasNodes() && ctx.fatalError == nil {
Cole Faustdd569ae2022-01-31 15:48:29 -08002031 starScript.nodes = append(starScript.nodes, ctx.handleSimpleStatement(ctx.getNode())...)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002032 }
2033 if ctx.fatalError != nil {
2034 return nil, ctx.fatalError
2035 }
2036 return starScript, nil
2037}
2038
Cole Faust864028a2021-12-01 13:43:17 -08002039func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002040 var buf bytes.Buffer
2041 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Cole Faust864028a2021-12-01 13:43:17 -08002042 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07002043 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
Cole Faust864028a2021-12-01 13:43:17 -08002044 fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002045 return buf.String()
2046}
2047
Cole Faust6ed7cb42021-10-07 17:08:46 -07002048func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
2049 var buf bytes.Buffer
2050 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
2051 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
2052 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
Cole Fausta0604662022-02-28 11:53:58 -08002053 fmt.Fprintf(&buf, "%s(%s(init, input_variables_init))\n", cfnPrintVars, cfnBoardMain)
Cole Faust6ed7cb42021-10-07 17:08:46 -07002054 return buf.String()
2055}
2056
Sasha Smundakb051c4e2020-11-05 20:45:07 -08002057func MakePath2ModuleName(mkPath string) string {
2058 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
2059}