blob: 2fbcf38a21637864864bcafad7a00d7724c8c241 [file] [log] [blame]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001// Copyright 2021 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Convert makefile containing device configuration to Starlark file
16// The conversion can handle the following constructs in a makefile:
17// * comments
18// * simple variable assignments
19// * $(call init-product,<file>)
20// * $(call inherit-product-if-exists
21// * if directives
22// All other constructs are carried over to the output starlark file as comments.
23//
24package mk2rbc
25
26import (
27 "bytes"
28 "fmt"
29 "io"
Sasha Smundak6609ba72021-07-22 18:32:56 -070030 "io/fs"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080031 "io/ioutil"
32 "os"
33 "path/filepath"
34 "regexp"
35 "strconv"
36 "strings"
37 "text/scanner"
38
39 mkparser "android/soong/androidmk/parser"
40)
41
42const (
Sasha Smundak6d852dd2021-09-27 20:34:39 -070043 annotationCommentPrefix = "RBC#"
44 baseUri = "//build/make/core:product_config.rbc"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080045 // The name of the struct exported by the product_config.rbc
46 // that contains the functions and variables available to
47 // product configuration Starlark files.
48 baseName = "rblf"
49
Sasha Smundak65b547e2021-09-17 15:35:41 -070050 soongNsPrefix = "SOONG_CONFIG_"
51
Sasha Smundakb051c4e2020-11-05 20:45:07 -080052 // And here are the functions and variables:
53 cfnGetCfg = baseName + ".cfg"
54 cfnMain = baseName + ".product_configuration"
Cole Faust6ed7cb42021-10-07 17:08:46 -070055 cfnBoardMain = baseName + ".board_configuration"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080056 cfnPrintVars = baseName + ".printvars"
Cole Faust6ed7cb42021-10-07 17:08:46 -070057 cfnPrintGlobals = baseName + ".printglobals"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080058 cfnWarning = baseName + ".warning"
59 cfnLocalAppend = baseName + ".local_append"
60 cfnLocalSetDefault = baseName + ".local_set_default"
61 cfnInherit = baseName + ".inherit"
62 cfnSetListDefault = baseName + ".setdefault"
63)
64
65const (
66 // Phony makefile functions, they are eventually rewritten
67 // according to knownFunctions map
Sasha Smundak65b547e2021-09-17 15:35:41 -070068 fileExistsPhony = "$file_exists"
69 // The following two macros are obsolete, and will we deleted once
70 // there are deleted from the makefiles:
71 soongConfigNamespaceOld = "add_soong_config_namespace"
72 soongConfigVarSetOld = "add_soong_config_var_value"
73 soongConfigAppend = "soong_config_append"
74 soongConfigAssign = "soong_config_set"
Cole Faustc00184e2021-11-08 12:08:57 -080075 soongConfigGet = "soong_config_get"
Sasha Smundak65b547e2021-09-17 15:35:41 -070076 wildcardExistsPhony = "$wildcard_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080077)
78
79const (
80 callLoadAlways = "inherit-product"
81 callLoadIf = "inherit-product-if-exists"
82)
83
84var knownFunctions = map[string]struct {
85 // The name of the runtime function this function call in makefiles maps to.
86 // If it starts with !, then this makefile function call is rewritten to
87 // something else.
88 runtimeName string
89 returnType starlarkType
Sasha Smundak3deb9682021-07-26 18:42:25 -070090 hiddenArg hiddenArgType
Sasha Smundakb051c4e2020-11-05 20:45:07 -080091}{
Sasha Smundak3deb9682021-07-26 18:42:25 -070092 "abspath": {baseName + ".abspath", starlarkTypeString, hiddenArgNone},
93 fileExistsPhony: {baseName + ".file_exists", starlarkTypeBool, hiddenArgNone},
94 wildcardExistsPhony: {baseName + ".file_wildcard_exists", starlarkTypeBool, hiddenArgNone},
Sasha Smundak65b547e2021-09-17 15:35:41 -070095 soongConfigNamespaceOld: {baseName + ".soong_config_namespace", starlarkTypeVoid, hiddenArgGlobal},
96 soongConfigVarSetOld: {baseName + ".soong_config_set", starlarkTypeVoid, hiddenArgGlobal},
97 soongConfigAssign: {baseName + ".soong_config_set", starlarkTypeVoid, hiddenArgGlobal},
98 soongConfigAppend: {baseName + ".soong_config_append", starlarkTypeVoid, hiddenArgGlobal},
Cole Faustc00184e2021-11-08 12:08:57 -080099 soongConfigGet: {baseName + ".soong_config_get", starlarkTypeString, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700100 "add-to-product-copy-files-if-exists": {baseName + ".copy_if_exists", starlarkTypeList, hiddenArgNone},
101 "addprefix": {baseName + ".addprefix", starlarkTypeList, hiddenArgNone},
102 "addsuffix": {baseName + ".addsuffix", starlarkTypeList, hiddenArgNone},
103 "copy-files": {baseName + ".copy_files", starlarkTypeList, hiddenArgNone},
104 "dir": {baseName + ".dir", starlarkTypeList, hiddenArgNone},
105 "enforce-product-packages-exist": {baseName + ".enforce_product_packages_exist", starlarkTypeVoid, hiddenArgNone},
106 "error": {baseName + ".mkerror", starlarkTypeVoid, hiddenArgNone},
107 "findstring": {"!findstring", starlarkTypeInt, hiddenArgNone},
108 "find-copy-subdir-files": {baseName + ".find_and_copy", starlarkTypeList, hiddenArgNone},
109 "find-word-in-list": {"!find-word-in-list", starlarkTypeUnknown, hiddenArgNone}, // internal macro
110 "filter": {baseName + ".filter", starlarkTypeList, hiddenArgNone},
111 "filter-out": {baseName + ".filter_out", starlarkTypeList, hiddenArgNone},
112 "firstword": {"!firstword", starlarkTypeString, hiddenArgNone},
113 "get-vendor-board-platforms": {"!get-vendor-board-platforms", starlarkTypeList, hiddenArgNone}, // internal macro, used by is-board-platform, etc.
114 "info": {baseName + ".mkinfo", starlarkTypeVoid, hiddenArgNone},
115 "is-android-codename": {"!is-android-codename", starlarkTypeBool, hiddenArgNone}, // unused by product config
116 "is-android-codename-in-list": {"!is-android-codename-in-list", starlarkTypeBool, hiddenArgNone}, // unused by product config
117 "is-board-platform": {"!is-board-platform", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700118 "is-board-platform2": {baseName + ".board_platform_is", starlarkTypeBool, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700119 "is-board-platform-in-list": {"!is-board-platform-in-list", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700120 "is-board-platform-in-list2": {baseName + ".board_platform_in", starlarkTypeBool, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700121 "is-chipset-in-board-platform": {"!is-chipset-in-board-platform", starlarkTypeUnknown, hiddenArgNone}, // unused by product config
122 "is-chipset-prefix-in-board-platform": {"!is-chipset-prefix-in-board-platform", starlarkTypeBool, hiddenArgNone}, // unused by product config
123 "is-not-board-platform": {"!is-not-board-platform", starlarkTypeBool, hiddenArgNone}, // defined but never used
124 "is-platform-sdk-version-at-least": {"!is-platform-sdk-version-at-least", starlarkTypeBool, hiddenArgNone}, // unused by product config
125 "is-product-in-list": {"!is-product-in-list", starlarkTypeBool, hiddenArgNone},
126 "is-vendor-board-platform": {"!is-vendor-board-platform", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700127 "is-vendor-board-qcom": {"!is-vendor-board-qcom", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700128 callLoadAlways: {"!inherit-product", starlarkTypeVoid, hiddenArgNone},
129 callLoadIf: {"!inherit-product-if-exists", starlarkTypeVoid, hiddenArgNone},
130 "lastword": {"!lastword", starlarkTypeString, hiddenArgNone},
131 "match-prefix": {"!match-prefix", starlarkTypeUnknown, hiddenArgNone}, // internal macro
132 "match-word": {"!match-word", starlarkTypeUnknown, hiddenArgNone}, // internal macro
133 "match-word-in-list": {"!match-word-in-list", starlarkTypeUnknown, hiddenArgNone}, // internal macro
134 "notdir": {baseName + ".notdir", starlarkTypeString, hiddenArgNone},
135 "my-dir": {"!my-dir", starlarkTypeString, hiddenArgNone},
136 "patsubst": {baseName + ".mkpatsubst", starlarkTypeString, hiddenArgNone},
Sasha Smundak04453082021-08-17 18:14:41 -0700137 "product-copy-files-by-pattern": {baseName + ".product_copy_files_by_pattern", starlarkTypeList, hiddenArgNone},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700138 "require-artifacts-in-path": {baseName + ".require_artifacts_in_path", starlarkTypeVoid, hiddenArgNone},
139 "require-artifacts-in-path-relaxed": {baseName + ".require_artifacts_in_path_relaxed", starlarkTypeVoid, hiddenArgNone},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800140 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Sasha Smundak3deb9682021-07-26 18:42:25 -0700141 "shell": {baseName + ".shell", starlarkTypeString, hiddenArgNone},
142 "strip": {baseName + ".mkstrip", starlarkTypeString, hiddenArgNone},
143 "tb-modules": {"!tb-modules", starlarkTypeUnknown, hiddenArgNone}, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
144 "subst": {baseName + ".mksubst", starlarkTypeString, hiddenArgNone},
145 "warning": {baseName + ".mkwarning", starlarkTypeVoid, hiddenArgNone},
146 "word": {baseName + "!word", starlarkTypeString, hiddenArgNone},
147 "wildcard": {baseName + ".expand_wildcard", starlarkTypeList, hiddenArgNone},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800148}
149
150var builtinFuncRex = regexp.MustCompile(
151 "^(addprefix|addsuffix|abspath|and|basename|call|dir|error|eval" +
152 "|flavor|foreach|file|filter|filter-out|findstring|firstword|guile" +
153 "|if|info|join|lastword|notdir|or|origin|patsubst|realpath" +
154 "|shell|sort|strip|subst|suffix|value|warning|word|wordlist|words" +
155 "|wildcard)")
156
157// Conversion request parameters
158type Request struct {
159 MkFile string // file to convert
160 Reader io.Reader // if set, read input from this stream instead
161 RootDir string // root directory path used to resolve included files
162 OutputSuffix string // generated Starlark files suffix
163 OutputDir string // if set, root of the output hierarchy
164 ErrorLogger ErrorMonitorCB
165 TracedVariables []string // trace assignment to these variables
166 TraceCalls bool
167 WarnPartialSuccess bool
Sasha Smundak6609ba72021-07-22 18:32:56 -0700168 SourceFS fs.FS
169 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800170}
171
172// An error sink allowing to gather error statistics.
173// NewError is called on every error encountered during processing.
174type ErrorMonitorCB interface {
175 NewError(s string, node mkparser.Node, args ...interface{})
176}
177
178// Derives module name for a given file. It is base name
179// (file name without suffix), with some characters replaced to make it a Starlark identifier
180func moduleNameForFile(mkFile string) string {
181 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
182 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700183 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
184
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800185}
186
187func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
188 r := &mkparser.MakeString{StringPos: mkString.StringPos}
189 r.Strings = append(r.Strings, mkString.Strings...)
190 r.Variables = append(r.Variables, mkString.Variables...)
191 return r
192}
193
194func isMakeControlFunc(s string) bool {
195 return s == "error" || s == "warning" || s == "info"
196}
197
198// Starlark output generation context
199type generationContext struct {
200 buf strings.Builder
201 starScript *StarlarkScript
202 indentLevel int
203 inAssignment bool
204 tracedCount int
205}
206
207func NewGenerateContext(ss *StarlarkScript) *generationContext {
208 return &generationContext{starScript: ss}
209}
210
211// emit returns generated script
212func (gctx *generationContext) emit() string {
213 ss := gctx.starScript
214
215 // The emitted code has the following layout:
216 // <initial comments>
217 // preamble, i.e.,
218 // load statement for the runtime support
219 // load statement for each unique submodule pulled in by this one
220 // def init(g, handle):
221 // cfg = rblf.cfg(handle)
222 // <statements>
223 // <warning if conversion was not clean>
224
225 iNode := len(ss.nodes)
226 for i, node := range ss.nodes {
227 if _, ok := node.(*commentNode); !ok {
228 iNode = i
229 break
230 }
231 node.emit(gctx)
232 }
233
234 gctx.emitPreamble()
235
236 gctx.newLine()
237 // The arguments passed to the init function are the global dictionary
238 // ('g') and the product configuration dictionary ('cfg')
239 gctx.write("def init(g, handle):")
240 gctx.indentLevel++
241 if gctx.starScript.traceCalls {
242 gctx.newLine()
243 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
244 }
245 gctx.newLine()
246 gctx.writef("cfg = %s(handle)", cfnGetCfg)
247 for _, node := range ss.nodes[iNode:] {
248 node.emit(gctx)
249 }
250
251 if ss.hasErrors && ss.warnPartialSuccess {
252 gctx.newLine()
253 gctx.writef("%s(%q, %q)", cfnWarning, filepath.Base(ss.mkFile), "partially successful conversion")
254 }
255 if gctx.starScript.traceCalls {
256 gctx.newLine()
257 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
258 }
259 gctx.indentLevel--
260 gctx.write("\n")
261 return gctx.buf.String()
262}
263
264func (gctx *generationContext) emitPreamble() {
265 gctx.newLine()
266 gctx.writef("load(%q, %q)", baseUri, baseName)
267 // Emit exactly one load statement for each URI.
268 loadedSubConfigs := make(map[string]string)
269 for _, sc := range gctx.starScript.inherited {
270 uri := sc.path
271 if m, ok := loadedSubConfigs[uri]; ok {
272 // No need to emit load statement, but fix module name.
273 sc.moduleLocalName = m
274 continue
275 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700276 if sc.optional {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800277 uri += "|init"
278 }
279 gctx.newLine()
280 gctx.writef("load(%q, %s = \"init\")", uri, sc.entryName())
281 loadedSubConfigs[uri] = sc.moduleLocalName
282 }
283 gctx.write("\n")
284}
285
286func (gctx *generationContext) emitPass() {
287 gctx.newLine()
288 gctx.write("pass")
289}
290
291func (gctx *generationContext) write(ss ...string) {
292 for _, s := range ss {
293 gctx.buf.WriteString(s)
294 }
295}
296
297func (gctx *generationContext) writef(format string, args ...interface{}) {
298 gctx.write(fmt.Sprintf(format, args...))
299}
300
301func (gctx *generationContext) newLine() {
302 if gctx.buf.Len() == 0 {
303 return
304 }
305 gctx.write("\n")
306 gctx.writef("%*s", 2*gctx.indentLevel, "")
307}
308
309type knownVariable struct {
310 name string
311 class varClass
312 valueType starlarkType
313}
314
315type knownVariables map[string]knownVariable
316
317func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
318 v, exists := pcv[name]
319 if !exists {
320 pcv[name] = knownVariable{name, varClass, valueType}
321 return
322 }
323 // Conflict resolution:
324 // * config class trumps everything
325 // * any type trumps unknown type
326 match := varClass == v.class
327 if !match {
328 if varClass == VarClassConfig {
329 v.class = VarClassConfig
330 match = true
331 } else if v.class == VarClassConfig {
332 match = true
333 }
334 }
335 if valueType != v.valueType {
336 if valueType != starlarkTypeUnknown {
337 if v.valueType == starlarkTypeUnknown {
338 v.valueType = valueType
339 } else {
340 match = false
341 }
342 }
343 }
344 if !match {
345 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
346 name, varClass, valueType, v.class, v.valueType)
347 }
348}
349
350// All known product variables.
351var KnownVariables = make(knownVariables)
352
353func init() {
354 for _, kv := range []string{
355 // Kernel-related variables that we know are lists.
356 "BOARD_VENDOR_KERNEL_MODULES",
357 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
358 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
359 "BOARD_RECOVERY_KERNEL_MODULES",
360 // Other variables we knwo are lists
361 "ART_APEX_JARS",
362 } {
363 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
364 }
365}
366
367type nodeReceiver interface {
368 newNode(node starlarkNode)
369}
370
371// Information about the generated Starlark script.
372type StarlarkScript struct {
373 mkFile string
374 moduleName string
375 mkPos scanner.Position
376 nodes []starlarkNode
Sasha Smundak6609ba72021-07-22 18:32:56 -0700377 inherited []*moduleInfo
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800378 hasErrors bool
379 topDir string
380 traceCalls bool // print enter/exit each init function
381 warnPartialSuccess bool
Sasha Smundak6609ba72021-07-22 18:32:56 -0700382 sourceFS fs.FS
383 makefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800384}
385
386func (ss *StarlarkScript) newNode(node starlarkNode) {
387 ss.nodes = append(ss.nodes, node)
388}
389
390// varAssignmentScope points to the last assignment for each variable
391// in the current block. It is used during the parsing to chain
392// the assignments to a variable together.
393type varAssignmentScope struct {
394 outer *varAssignmentScope
395 vars map[string]*assignmentNode
396}
397
398// parseContext holds the script we are generating and all the ephemeral data
399// needed during the parsing.
400type parseContext struct {
401 script *StarlarkScript
402 nodes []mkparser.Node // Makefile as parsed by mkparser
403 currentNodeIndex int // Node in it we are processing
404 ifNestLevel int
405 moduleNameCount map[string]int // count of imported modules with given basename
406 fatalError error
407 builtinMakeVars map[string]starlarkExpr
408 outputSuffix string
409 errorLogger ErrorMonitorCB
410 tracedVariables map[string]bool // variables to be traced in the generated script
411 variables map[string]variable
412 varAssignments *varAssignmentScope
413 receiver nodeReceiver // receptacle for the generated starlarkNode's
414 receiverStack []nodeReceiver
415 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700416 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700417 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700418 includeTops []string
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800419}
420
421func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700422 topdir, _ := filepath.Split(filepath.Join(ss.topDir, "foo"))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800423 predefined := []struct{ name, value string }{
424 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
425 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Sasha Smundak6609ba72021-07-22 18:32:56 -0700426 {"TOPDIR", topdir},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800427 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
428 {"TARGET_COPY_OUT_SYSTEM", "system"},
429 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
430 {"TARGET_COPY_OUT_DATA", "data"},
431 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
432 {"TARGET_COPY_OUT_OEM", "oem"},
433 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
434 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
435 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
436 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
437 {"TARGET_COPY_OUT_ROOT", "root"},
438 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800439 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800440 // TODO(asmundak): to process internal config files, we need the following variables:
441 // BOARD_CONFIG_VENDOR_PATH
442 // TARGET_VENDOR
443 // target_base_product
444 //
445
446 // the following utility variables are set in build/make/common/core.mk:
447 {"empty", ""},
448 {"space", " "},
449 {"comma", ","},
450 {"newline", "\n"},
451 {"pound", "#"},
452 {"backslash", "\\"},
453 }
454 ctx := &parseContext{
455 script: ss,
456 nodes: nodes,
457 currentNodeIndex: 0,
458 ifNestLevel: 0,
459 moduleNameCount: make(map[string]int),
460 builtinMakeVars: map[string]starlarkExpr{},
461 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700462 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700463 soongNamespaces: make(map[string]map[string]bool),
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700464 includeTops: []string{"vendor/google-devices"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800465 }
466 ctx.pushVarAssignments()
467 for _, item := range predefined {
468 ctx.variables[item.name] = &predefinedVariable{
469 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
470 value: &stringLiteralExpr{item.value},
471 }
472 }
473
474 return ctx
475}
476
477func (ctx *parseContext) lastAssignment(name string) *assignmentNode {
478 for va := ctx.varAssignments; va != nil; va = va.outer {
479 if v, ok := va.vars[name]; ok {
480 return v
481 }
482 }
483 return nil
484}
485
486func (ctx *parseContext) setLastAssignment(name string, asgn *assignmentNode) {
487 ctx.varAssignments.vars[name] = asgn
488}
489
490func (ctx *parseContext) pushVarAssignments() {
491 va := &varAssignmentScope{
492 outer: ctx.varAssignments,
493 vars: make(map[string]*assignmentNode),
494 }
495 ctx.varAssignments = va
496}
497
498func (ctx *parseContext) popVarAssignments() {
499 ctx.varAssignments = ctx.varAssignments.outer
500}
501
502func (ctx *parseContext) pushReceiver(rcv nodeReceiver) {
503 ctx.receiverStack = append(ctx.receiverStack, ctx.receiver)
504 ctx.receiver = rcv
505}
506
507func (ctx *parseContext) popReceiver() {
508 last := len(ctx.receiverStack) - 1
509 if last < 0 {
510 panic(fmt.Errorf("popReceiver: receiver stack empty"))
511 }
512 ctx.receiver = ctx.receiverStack[last]
513 ctx.receiverStack = ctx.receiverStack[0:last]
514}
515
516func (ctx *parseContext) hasNodes() bool {
517 return ctx.currentNodeIndex < len(ctx.nodes)
518}
519
520func (ctx *parseContext) getNode() mkparser.Node {
521 if !ctx.hasNodes() {
522 return nil
523 }
524 node := ctx.nodes[ctx.currentNodeIndex]
525 ctx.currentNodeIndex++
526 return node
527}
528
529func (ctx *parseContext) backNode() {
530 if ctx.currentNodeIndex <= 0 {
531 panic("Cannot back off")
532 }
533 ctx.currentNodeIndex--
534}
535
536func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) {
537 // Handle only simple variables
538 if !a.Name.Const() {
539 ctx.errorf(a, "Only simple variables are handled")
540 return
541 }
542 name := a.Name.Strings[0]
Cole Faustc00184e2021-11-08 12:08:57 -0800543 // Soong configuration
Sasha Smundak3deb9682021-07-26 18:42:25 -0700544 if strings.HasPrefix(name, soongNsPrefix) {
545 ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
546 return
547 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800548 lhs := ctx.addVariable(name)
549 if lhs == nil {
550 ctx.errorf(a, "unknown variable %s", name)
551 return
552 }
553 _, isTraced := ctx.tracedVariables[name]
554 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced}
555 if lhs.valueType() == starlarkTypeUnknown {
556 // Try to divine variable type from the RHS
557 asgn.value = ctx.parseMakeString(a, a.Value)
558 if xBad, ok := asgn.value.(*badExpr); ok {
559 ctx.wrapBadExpr(xBad)
560 return
561 }
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 {
568 xConcat := ctx.buildConcatExpr(a)
569 if xConcat == nil {
570 return
571 }
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 {
583 ctx.wrapBadExpr(xBad)
584 return
585 }
586 }
587
588 // TODO(asmundak): move evaluation to a separate pass
589 asgn.value, _ = asgn.value.eval(ctx.builtinMakeVars)
590
591 asgn.previous = ctx.lastAssignment(name)
592 ctx.setLastAssignment(name, asgn)
593 switch a.Type {
594 case "=", ":=":
595 asgn.flavor = asgnSet
596 case "+=":
597 if asgn.previous == nil && !asgn.lhs.isPreset() {
598 asgn.flavor = asgnMaybeAppend
599 } else {
600 asgn.flavor = asgnAppend
601 }
602 case "?=":
603 asgn.flavor = asgnMaybeSet
604 default:
605 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
606 }
607
608 ctx.receiver.newNode(asgn)
609}
610
Sasha Smundak3deb9682021-07-26 18:42:25 -0700611func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) {
612 val := ctx.parseMakeString(asgn, asgn.Value)
613 if xBad, ok := val.(*badExpr); ok {
614 ctx.wrapBadExpr(xBad)
615 return
616 }
617 val, _ = val.eval(ctx.builtinMakeVars)
618
619 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
620 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
621 // Try to divine the call from the assignment as follows:
622 if name == "NAMESPACES" {
623 // Upon seeng
624 // SOONG_CONFIG_NAMESPACES += foo
625 // remember that there is a namespace `foo` and act as we saw
626 // $(call add_soong_config_namespace,foo)
627 s, ok := maybeString(val)
628 if !ok {
629 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")
630 return
631 }
632 for _, ns := range strings.Fields(s) {
633 ctx.addSoongNamespace(ns)
634 ctx.receiver.newNode(&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700635 name: soongConfigNamespaceOld,
Sasha Smundak3deb9682021-07-26 18:42:25 -0700636 args: []starlarkExpr{&stringLiteralExpr{ns}},
637 returnType: starlarkTypeVoid,
638 }})
639 }
640 } else {
641 // Upon seeing
642 // SOONG_CONFIG_x_y = v
643 // find a namespace called `x` and act as if we encountered
Cole Faustc00184e2021-11-08 12:08:57 -0800644 // $(call soong_config_set,x,y,v)
Sasha Smundak3deb9682021-07-26 18:42:25 -0700645 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
646 // it.
647 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
648 // and `foo` with a variable `bar_baz`.
649 namespaceName := ""
650 if ctx.hasSoongNamespace(name) {
651 namespaceName = name
652 }
653 var varName string
654 for pos, ch := range name {
655 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
656 continue
657 }
658 if namespaceName != "" {
659 ctx.errorf(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])
660 return
661 }
662 namespaceName = name[0:pos]
663 varName = name[pos+1:]
664 }
665 if namespaceName == "" {
666 ctx.errorf(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")
667 return
668 }
669 if varName == "" {
670 // Remember variables in this namespace
671 s, ok := maybeString(val)
672 if !ok {
673 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")
674 return
675 }
676 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
677 return
678 }
679
680 // Finally, handle assignment to a namespace variable
681 if !ctx.hasNamespaceVar(namespaceName, varName) {
682 ctx.errorf(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)
683 return
684 }
Cole Faustc00184e2021-11-08 12:08:57 -0800685 fname := soongConfigAssign
Sasha Smundak65b547e2021-09-17 15:35:41 -0700686 if asgn.Type == "+=" {
687 fname = soongConfigAppend
688 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700689 ctx.receiver.newNode(&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700690 name: fname,
Sasha Smundak3deb9682021-07-26 18:42:25 -0700691 args: []starlarkExpr{&stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
692 returnType: starlarkTypeVoid,
693 }})
694 }
695}
696
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800697func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) *concatExpr {
698 xConcat := &concatExpr{}
699 var xItemList *listExpr
700 addToItemList := func(x ...starlarkExpr) {
701 if xItemList == nil {
702 xItemList = &listExpr{[]starlarkExpr{}}
703 }
704 xItemList.items = append(xItemList.items, x...)
705 }
706 finishItemList := func() {
707 if xItemList != nil {
708 xConcat.items = append(xConcat.items, xItemList)
709 xItemList = nil
710 }
711 }
712
713 items := a.Value.Words()
714 for _, item := range items {
715 // A function call in RHS is supposed to return a list, all other item
716 // expressions return individual elements.
717 switch x := ctx.parseMakeString(a, item).(type) {
718 case *badExpr:
719 ctx.wrapBadExpr(x)
720 return nil
721 case *stringLiteralExpr:
722 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
723 default:
724 switch x.typ() {
725 case starlarkTypeList:
726 finishItemList()
727 xConcat.items = append(xConcat.items, x)
728 case starlarkTypeString:
729 finishItemList()
730 xConcat.items = append(xConcat.items, &callExpr{
731 object: x,
732 name: "split",
733 args: nil,
734 returnType: starlarkTypeList,
735 })
736 default:
737 addToItemList(x)
738 }
739 }
740 }
741 if xItemList != nil {
742 xConcat.items = append(xConcat.items, xItemList)
743 }
744 return xConcat
745}
746
Sasha Smundak6609ba72021-07-22 18:32:56 -0700747func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
748 modulePath := ctx.loadedModulePath(path)
749 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700750 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700751 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800752 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800753 moduleName := moduleNameForFile(path)
754 moduleLocalName := "_" + moduleName
755 n, found := ctx.moduleNameCount[moduleName]
756 if found {
757 moduleLocalName += fmt.Sprintf("%d", n)
758 }
759 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6609ba72021-07-22 18:32:56 -0700760 mi := &moduleInfo{
761 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800762 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800763 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700764 optional: optional,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800765 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700766 ctx.dependentModules[modulePath] = mi
767 ctx.script.inherited = append(ctx.script.inherited, mi)
768 return mi
769}
770
771func (ctx *parseContext) handleSubConfig(
772 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule)) {
773 pathExpr, _ = pathExpr.eval(ctx.builtinMakeVars)
774
775 // In a simple case, the name of a module to inherit/include is known statically.
776 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700777 // Note that even if this directive loads a module unconditionally, a module may be
778 // absent without causing any harm if this directive is inside an if/else block.
779 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700780 if strings.Contains(path, "*") {
781 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
782 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700783 mi := ctx.newDependentModule(p, !moduleShouldExist)
784 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700785 }
786 } else {
787 ctx.errorf(v, "cannot glob wildcard argument")
788 }
789 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700790 mi := ctx.newDependentModule(path, !moduleShouldExist)
791 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700792 }
793 return
794 }
795
796 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
797 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
798 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
799 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
800 // We then emit the code that loads all of them, e.g.:
801 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
802 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
803 // And then inherit it as follows:
804 // _e = {
805 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
806 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
807 // if _e:
808 // rblf.inherit(handle, _e[0], _e[1])
809 //
810 var matchingPaths []string
811 varPath, ok := pathExpr.(*interpolateExpr)
812 if !ok {
813 ctx.errorf(v, "inherit-product/include argument is too complex")
814 return
815 }
816
817 pathPattern := []string{varPath.chunks[0]}
818 for _, chunk := range varPath.chunks[1:] {
819 if chunk != "" {
820 pathPattern = append(pathPattern, chunk)
821 }
822 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700823 if pathPattern[0] == "" {
824 // If pattern starts from the top. restrict it to the directories where
825 // we know inherit-product uses dynamically calculated path.
826 for _, p := range ctx.includeTops {
827 pathPattern[0] = p
828 matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700829 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700830 } else {
831 matchingPaths = ctx.findMatchingPaths(pathPattern)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700832 }
833 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700834 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700835 if len(matchingPaths) > maxMatchingFiles {
836 ctx.errorf(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)
837 return
838 }
839 res := inheritedDynamicModule{*varPath, []*moduleInfo{}, loadAlways}
840 for _, p := range matchingPaths {
841 // A product configuration files discovered dynamically may attempt to inherit
842 // from another one which does not exist in this source tree. Prevent load errors
843 // by always loading the dynamic files as optional.
844 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
845 }
846 processModule(res)
847}
848
849func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
850 files := ctx.script.makefileFinder.Find(ctx.script.topDir)
851 if len(pattern) == 0 {
852 return files
853 }
854
855 // Create regular expression from the pattern
856 s_regexp := "^" + regexp.QuoteMeta(pattern[0])
857 for _, s := range pattern[1:] {
858 s_regexp += ".*" + regexp.QuoteMeta(s)
859 }
860 s_regexp += "$"
861 rex := regexp.MustCompile(s_regexp)
862
863 // Now match
864 var res []string
865 for _, p := range files {
866 if rex.MatchString(p) {
867 res = append(res, p)
868 }
869 }
870 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800871}
872
873func (ctx *parseContext) handleInheritModule(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700874 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700875 ctx.receiver.newNode(&inheritNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700876 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800877}
878
879func (ctx *parseContext) handleInclude(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700880 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700881 ctx.receiver.newNode(&includeNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700882 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800883}
884
885func (ctx *parseContext) handleVariable(v *mkparser.Variable) {
886 // Handle:
887 // $(call inherit-product,...)
888 // $(call inherit-product-if-exists,...)
889 // $(info xxx)
890 // $(warning xxx)
891 // $(error xxx)
892 expr := ctx.parseReference(v, v.Name)
893 switch x := expr.(type) {
894 case *callExpr:
895 if x.name == callLoadAlways || x.name == callLoadIf {
896 ctx.handleInheritModule(v, x.args[0], x.name == callLoadAlways)
897 } else if isMakeControlFunc(x.name) {
898 // File name is the first argument
899 args := []starlarkExpr{
900 &stringLiteralExpr{ctx.script.mkFile},
901 x.args[0],
902 }
903 ctx.receiver.newNode(&exprNode{
904 &callExpr{name: x.name, args: args, returnType: starlarkTypeUnknown},
905 })
906 } else {
907 ctx.receiver.newNode(&exprNode{expr})
908 }
909 case *badExpr:
910 ctx.wrapBadExpr(x)
911 return
912 default:
913 ctx.errorf(v, "cannot handle %s", v.Dump())
914 return
915 }
916}
917
918func (ctx *parseContext) handleDefine(directive *mkparser.Directive) {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700919 macro_name := strings.Fields(directive.Args.Strings[0])[0]
920 // Ignore the macros that we handle
921 if _, ok := knownFunctions[macro_name]; !ok {
922 ctx.errorf(directive, "define is not supported: %s", macro_name)
923 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800924}
925
926func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) {
927 ssSwitch := &switchNode{}
928 ctx.pushReceiver(ssSwitch)
929 for ctx.processBranch(ifDirective); ctx.hasNodes() && ctx.fatalError == nil; {
930 node := ctx.getNode()
931 switch x := node.(type) {
932 case *mkparser.Directive:
933 switch x.Name {
934 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
935 ctx.processBranch(x)
936 case "endif":
937 ctx.popReceiver()
938 ctx.receiver.newNode(ssSwitch)
939 return
940 default:
941 ctx.errorf(node, "unexpected directive %s", x.Name)
942 }
943 default:
944 ctx.errorf(ifDirective, "unexpected statement")
945 }
946 }
947 if ctx.fatalError == nil {
948 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
949 }
950 ctx.popReceiver()
951}
952
953// processBranch processes a single branch (if/elseif/else) until the next directive
954// on the same level.
955func (ctx *parseContext) processBranch(check *mkparser.Directive) {
956 block := switchCase{gate: ctx.parseCondition(check)}
957 defer func() {
958 ctx.popVarAssignments()
959 ctx.ifNestLevel--
960
961 }()
962 ctx.pushVarAssignments()
963 ctx.ifNestLevel++
964
965 ctx.pushReceiver(&block)
966 for ctx.hasNodes() {
967 node := ctx.getNode()
Cole Faust591a1fe2021-11-08 15:37:57 -0800968 if d, ok := node.(*mkparser.Directive); ok {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800969 switch d.Name {
970 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
971 ctx.popReceiver()
972 ctx.receiver.newNode(&block)
973 ctx.backNode()
974 return
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800975 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800976 }
Cole Faust591a1fe2021-11-08 15:37:57 -0800977 ctx.handleSimpleStatement(node)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800978 }
979 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
980 ctx.popReceiver()
981}
982
983func (ctx *parseContext) newIfDefinedNode(check *mkparser.Directive) (starlarkExpr, bool) {
984 if !check.Args.Const() {
985 return ctx.newBadExpr(check, "ifdef variable ref too complex: %s", check.Args.Dump()), false
986 }
987 v := ctx.addVariable(check.Args.Strings[0])
988 return &variableDefinedExpr{v}, true
989}
990
991func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
992 switch check.Name {
993 case "ifdef", "ifndef", "elifdef", "elifndef":
994 v, ok := ctx.newIfDefinedNode(check)
995 if ok && strings.HasSuffix(check.Name, "ndef") {
996 v = &notExpr{v}
997 }
998 return &ifNode{
999 isElif: strings.HasPrefix(check.Name, "elif"),
1000 expr: v,
1001 }
1002 case "ifeq", "ifneq", "elifeq", "elifneq":
1003 return &ifNode{
1004 isElif: strings.HasPrefix(check.Name, "elif"),
1005 expr: ctx.parseCompare(check),
1006 }
1007 case "else":
1008 return &elseNode{}
1009 default:
1010 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
1011 }
1012}
1013
1014func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
1015 message := fmt.Sprintf(text, args...)
1016 if ctx.errorLogger != nil {
1017 ctx.errorLogger.NewError(text, node, args)
1018 }
1019 ctx.script.hasErrors = true
1020 return &badExpr{node, message}
1021}
1022
1023func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
1024 // Strip outer parentheses
1025 mkArg := cloneMakeString(cond.Args)
1026 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1027 n := len(mkArg.Strings)
1028 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1029 args := mkArg.Split(",")
1030 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1031 if len(args) != 2 {
1032 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1033 }
1034 args[0].TrimRightSpaces()
1035 args[1].TrimLeftSpaces()
1036
1037 isEq := !strings.HasSuffix(cond.Name, "neq")
1038 switch xLeft := ctx.parseMakeString(cond, args[0]).(type) {
1039 case *stringLiteralExpr, *variableRefExpr:
1040 switch xRight := ctx.parseMakeString(cond, args[1]).(type) {
1041 case *stringLiteralExpr, *variableRefExpr:
1042 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
1043 case *badExpr:
1044 return xRight
1045 default:
1046 expr, ok := ctx.parseCheckFunctionCallResult(cond, xLeft, args[1])
1047 if ok {
1048 return expr
1049 }
1050 return ctx.newBadExpr(cond, "right operand is too complex: %s", args[1].Dump())
1051 }
1052 case *badExpr:
1053 return xLeft
1054 default:
1055 switch xRight := ctx.parseMakeString(cond, args[1]).(type) {
1056 case *stringLiteralExpr, *variableRefExpr:
1057 expr, ok := ctx.parseCheckFunctionCallResult(cond, xRight, args[0])
1058 if ok {
1059 return expr
1060 }
1061 return ctx.newBadExpr(cond, "left operand is too complex: %s", args[0].Dump())
1062 case *badExpr:
1063 return xRight
1064 default:
1065 return ctx.newBadExpr(cond, "operands are too complex: (%s,%s)", args[0].Dump(), args[1].Dump())
1066 }
1067 }
1068}
1069
1070func (ctx *parseContext) parseCheckFunctionCallResult(directive *mkparser.Directive, xValue starlarkExpr,
1071 varArg *mkparser.MakeString) (starlarkExpr, bool) {
1072 mkSingleVar, ok := varArg.SingleVariable()
1073 if !ok {
1074 return nil, false
1075 }
1076 expr := ctx.parseReference(directive, mkSingleVar)
1077 negate := strings.HasSuffix(directive.Name, "neq")
1078 checkIsSomethingFunction := func(xCall *callExpr) starlarkExpr {
1079 s, ok := maybeString(xValue)
1080 if !ok || s != "true" {
1081 return ctx.newBadExpr(directive,
1082 fmt.Sprintf("the result of %s can be compared only to 'true'", xCall.name))
1083 }
1084 if len(xCall.args) < 1 {
1085 return ctx.newBadExpr(directive, "%s requires an argument", xCall.name)
1086 }
1087 return nil
1088 }
1089 switch x := expr.(type) {
1090 case *callExpr:
1091 switch x.name {
1092 case "filter":
1093 return ctx.parseCompareFilterFuncResult(directive, x, xValue, !negate), true
1094 case "filter-out":
1095 return ctx.parseCompareFilterFuncResult(directive, x, xValue, negate), true
1096 case "wildcard":
1097 return ctx.parseCompareWildcardFuncResult(directive, x, xValue, negate), true
1098 case "findstring":
1099 return ctx.parseCheckFindstringFuncResult(directive, x, xValue, negate), true
1100 case "strip":
1101 return ctx.parseCompareStripFuncResult(directive, x, xValue, negate), true
1102 case "is-board-platform":
1103 if xBad := checkIsSomethingFunction(x); xBad != nil {
1104 return xBad, true
1105 }
1106 return &eqExpr{
1107 left: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1108 right: x.args[0],
1109 isEq: !negate,
1110 }, true
1111 case "is-board-platform-in-list":
1112 if xBad := checkIsSomethingFunction(x); xBad != nil {
1113 return xBad, true
1114 }
1115 return &inExpr{
1116 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1117 list: maybeConvertToStringList(x.args[0]),
1118 isNot: negate,
1119 }, true
1120 case "is-product-in-list":
1121 if xBad := checkIsSomethingFunction(x); xBad != nil {
1122 return xBad, true
1123 }
1124 return &inExpr{
1125 expr: &variableRefExpr{ctx.addVariable("TARGET_PRODUCT"), true},
1126 list: maybeConvertToStringList(x.args[0]),
1127 isNot: negate,
1128 }, true
1129 case "is-vendor-board-platform":
1130 if xBad := checkIsSomethingFunction(x); xBad != nil {
1131 return xBad, true
1132 }
1133 s, ok := maybeString(x.args[0])
1134 if !ok {
1135 return ctx.newBadExpr(directive, "cannot handle non-constant argument to is-vendor-board-platform"), true
1136 }
1137 return &inExpr{
1138 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1139 list: &variableRefExpr{ctx.addVariable(s + "_BOARD_PLATFORMS"), true},
1140 isNot: negate,
1141 }, true
Sasha Smundak3a9b8e82021-08-25 14:11:04 -07001142
1143 case "is-board-platform2", "is-board-platform-in-list2":
1144 if s, ok := maybeString(xValue); !ok || s != "" {
1145 return ctx.newBadExpr(directive,
1146 fmt.Sprintf("the result of %s can be compared only to empty", x.name)), true
1147 }
1148 if len(x.args) != 1 {
1149 return ctx.newBadExpr(directive, "%s requires an argument", x.name), true
1150 }
1151 cc := &callExpr{
1152 name: x.name,
1153 args: []starlarkExpr{x.args[0]},
1154 returnType: starlarkTypeBool,
1155 }
1156 if !negate {
1157 return &notExpr{cc}, true
1158 }
1159 return cc, true
1160 case "is-vendor-board-qcom":
1161 if s, ok := maybeString(xValue); !ok || s != "" {
1162 return ctx.newBadExpr(directive,
1163 fmt.Sprintf("the result of %s can be compared only to empty", x.name)), true
1164 }
Sasha Smundak4f1f1182021-11-04 17:57:39 -07001165 // if the expression is ifneq (,$(call is-vendor-board-platform,...)), negate==true,
1166 // so we should set inExpr.isNot to false
Sasha Smundak3a9b8e82021-08-25 14:11:04 -07001167 return &inExpr{
1168 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1169 list: &variableRefExpr{ctx.addVariable("QCOM_BOARD_PLATFORMS"), true},
Sasha Smundak4f1f1182021-11-04 17:57:39 -07001170 isNot: !negate,
Sasha Smundak3a9b8e82021-08-25 14:11:04 -07001171 }, true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001172 default:
1173 return ctx.newBadExpr(directive, "Unknown function in ifeq: %s", x.name), true
1174 }
1175 case *badExpr:
1176 return x, true
1177 default:
1178 return nil, false
1179 }
1180}
1181
1182func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
1183 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1184 // We handle:
Sasha Smundak0554d762021-07-08 18:26:12 -07001185 // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
1186 // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001187 // * ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...) becomes if VAR in/not in ["v1", "v2"]
1188 // TODO(Asmundak): check the last case works for filter-out, too.
1189 xPattern := filterFuncCall.args[0]
1190 xText := filterFuncCall.args[1]
1191 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001192 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001193 var ok bool
1194 switch x := xValue.(type) {
1195 case *stringLiteralExpr:
1196 if x.literal != "" {
1197 return ctx.newBadExpr(cond, "filter comparison to non-empty value: %s", xValue)
1198 }
1199 // Either pattern or text should be const, and the
1200 // non-const one should be varRefExpr
Sasha Smundak5f463be2021-09-15 18:43:36 -07001201 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
Sasha Smundak0554d762021-07-08 18:26:12 -07001202 expr = xText
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001203 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
Sasha Smundak0554d762021-07-08 18:26:12 -07001204 expr = xPattern
1205 } else {
Sasha Smundak5f463be2021-09-15 18:43:36 -07001206 expr = &callExpr{
Sasha Smundak0554d762021-07-08 18:26:12 -07001207 object: nil,
1208 name: filterFuncCall.name,
1209 args: filterFuncCall.args,
1210 returnType: starlarkTypeBool,
1211 }
Sasha Smundak5f463be2021-09-15 18:43:36 -07001212 if negate {
1213 expr = &notExpr{expr: expr}
1214 }
1215 return expr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001216 }
1217 case *variableRefExpr:
1218 if v, ok := xPattern.(*variableRefExpr); ok {
1219 if xInList, ok = xText.(*stringLiteralExpr); ok && v.ref.name() == x.ref.name() {
1220 // ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...), flip negate,
1221 // it's the opposite to what is done when comparing to empty.
Sasha Smundak0554d762021-07-08 18:26:12 -07001222 expr = xPattern
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001223 negate = !negate
1224 }
1225 }
1226 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001227 if expr != nil && xInList != nil {
1228 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1229 // Generate simpler code for the common cases:
1230 if expr.typ() == starlarkTypeList {
1231 if len(slExpr.items) == 1 {
1232 // Checking that a string belongs to list
1233 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}
1234 } else {
1235 // TODO(asmundak):
1236 panic("TBD")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001237 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001238 } else if len(slExpr.items) == 1 {
1239 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}
1240 } else {
1241 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001242 }
1243 }
1244 return ctx.newBadExpr(cond, "filter arguments are too complex: %s", cond.Dump())
1245}
1246
1247func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Directive,
1248 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001249 if !isEmptyString(xValue) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001250 return ctx.newBadExpr(directive, "wildcard result can be compared only to empty: %s", xValue)
1251 }
1252 callFunc := wildcardExistsPhony
1253 if s, ok := xCall.args[0].(*stringLiteralExpr); ok && !strings.ContainsAny(s.literal, "*?{[") {
1254 callFunc = fileExistsPhony
1255 }
1256 var cc starlarkExpr = &callExpr{name: callFunc, args: xCall.args, returnType: starlarkTypeBool}
1257 if !negate {
1258 cc = &notExpr{cc}
1259 }
1260 return cc
1261}
1262
1263func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1264 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001265 if isEmptyString(xValue) {
1266 return &eqExpr{
1267 left: &callExpr{
1268 object: xCall.args[1],
1269 name: "find",
1270 args: []starlarkExpr{xCall.args[0]},
1271 returnType: starlarkTypeInt,
1272 },
1273 right: &intLiteralExpr{-1},
1274 isEq: !negate,
1275 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001276 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001277 return ctx.newBadExpr(directive, "findstring result can be compared only to empty: %s", xValue)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001278}
1279
1280func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1281 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1282 if _, ok := xValue.(*stringLiteralExpr); !ok {
1283 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1284 }
1285 return &eqExpr{
1286 left: &callExpr{
1287 name: "strip",
1288 args: xCall.args,
1289 returnType: starlarkTypeString,
1290 },
1291 right: xValue, isEq: !negate}
1292}
1293
1294// parses $(...), returning an expression
1295func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1296 ref.TrimLeftSpaces()
1297 ref.TrimRightSpaces()
1298 refDump := ref.Dump()
1299
1300 // Handle only the case where the first (or only) word is constant
1301 words := ref.SplitN(" ", 2)
1302 if !words[0].Const() {
1303 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1304 }
1305
1306 // If it is a single word, it can be a simple variable
1307 // reference or a function call
1308 if len(words) == 1 {
1309 if isMakeControlFunc(refDump) || refDump == "shell" {
1310 return &callExpr{
1311 name: refDump,
1312 args: []starlarkExpr{&stringLiteralExpr{""}},
1313 returnType: starlarkTypeUnknown,
1314 }
1315 }
Sasha Smundak65b547e2021-09-17 15:35:41 -07001316 if strings.HasPrefix(refDump, soongNsPrefix) {
1317 // TODO (asmundak): if we find many, maybe handle them.
Cole Faustc00184e2021-11-08 12:08:57 -08001318 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
Sasha Smundak65b547e2021-09-17 15:35:41 -07001319 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001320 if v := ctx.addVariable(refDump); v != nil {
1321 return &variableRefExpr{v, ctx.lastAssignment(v.name()) != nil}
1322 }
1323 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1324 }
1325
1326 expr := &callExpr{name: words[0].Dump(), returnType: starlarkTypeUnknown}
1327 args := words[1]
1328 args.TrimLeftSpaces()
1329 // Make control functions and shell need special treatment as everything
1330 // after the name is a single text argument
1331 if isMakeControlFunc(expr.name) || expr.name == "shell" {
1332 x := ctx.parseMakeString(node, args)
1333 if xBad, ok := x.(*badExpr); ok {
1334 return xBad
1335 }
1336 expr.args = []starlarkExpr{x}
1337 return expr
1338 }
1339 if expr.name == "call" {
1340 words = args.SplitN(",", 2)
1341 if words[0].Empty() || !words[0].Const() {
Sasha Smundakf2c9f8b2021-07-27 10:44:48 -07001342 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001343 }
1344 expr.name = words[0].Dump()
1345 if len(words) < 2 {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001346 args = &mkparser.MakeString{}
1347 } else {
1348 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001349 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001350 }
1351 if kf, found := knownFunctions[expr.name]; found {
1352 expr.returnType = kf.returnType
1353 } else {
1354 return ctx.newBadExpr(node, "cannot handle invoking %s", expr.name)
1355 }
1356 switch expr.name {
1357 case "word":
1358 return ctx.parseWordFunc(node, args)
Sasha Smundak16e07732021-07-23 11:38:23 -07001359 case "firstword", "lastword":
1360 return ctx.parseFirstOrLastwordFunc(node, expr.name, args)
Sasha Smundak6609ba72021-07-22 18:32:56 -07001361 case "my-dir":
1362 return &variableRefExpr{ctx.addVariable("LOCAL_PATH"), true}
Sasha Smundak94b41c72021-07-12 18:30:42 -07001363 case "subst", "patsubst":
1364 return ctx.parseSubstFunc(node, expr.name, args)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001365 default:
1366 for _, arg := range args.Split(",") {
1367 arg.TrimLeftSpaces()
1368 arg.TrimRightSpaces()
1369 x := ctx.parseMakeString(node, arg)
1370 if xBad, ok := x.(*badExpr); ok {
1371 return xBad
1372 }
1373 expr.args = append(expr.args, x)
1374 }
1375 }
1376 return expr
1377}
1378
Sasha Smundak94b41c72021-07-12 18:30:42 -07001379func (ctx *parseContext) parseSubstFunc(node mkparser.Node, fname string, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001380 words := args.Split(",")
1381 if len(words) != 3 {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001382 return ctx.newBadExpr(node, "%s function should have 3 arguments", fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001383 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001384 from := ctx.parseMakeString(node, words[0])
1385 if xBad, ok := from.(*badExpr); ok {
1386 return xBad
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001387 }
Sasha Smundak35434ed2021-11-05 16:29:56 -07001388 to := ctx.parseMakeString(node, words[1])
1389 if xBad, ok := to.(*badExpr); ok {
1390 return xBad
1391 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001392 words[2].TrimLeftSpaces()
1393 words[2].TrimRightSpaces()
1394 obj := ctx.parseMakeString(node, words[2])
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001395 typ := obj.typ()
Sasha Smundak94b41c72021-07-12 18:30:42 -07001396 if typ == starlarkTypeString && fname == "subst" {
1397 // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001398 return &callExpr{
1399 object: obj,
1400 name: "replace",
Sasha Smundak35434ed2021-11-05 16:29:56 -07001401 args: []starlarkExpr{from, to},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001402 returnType: typ,
1403 }
1404 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001405 return &callExpr{
Sasha Smundak94b41c72021-07-12 18:30:42 -07001406 name: fname,
Sasha Smundak35434ed2021-11-05 16:29:56 -07001407 args: []starlarkExpr{from, to, obj},
Sasha Smundak9d011ab2021-07-09 16:00:57 -07001408 returnType: obj.typ(),
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001409 }
1410}
1411
1412func (ctx *parseContext) parseWordFunc(node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
1413 words := args.Split(",")
1414 if len(words) != 2 {
1415 return ctx.newBadExpr(node, "word function should have 2 arguments")
1416 }
1417 var index uint64 = 0
1418 if words[0].Const() {
1419 index, _ = strconv.ParseUint(strings.TrimSpace(words[0].Strings[0]), 10, 64)
1420 }
1421 if index < 1 {
1422 return ctx.newBadExpr(node, "word index should be constant positive integer")
1423 }
1424 words[1].TrimLeftSpaces()
1425 words[1].TrimRightSpaces()
1426 array := ctx.parseMakeString(node, words[1])
1427 if xBad, ok := array.(*badExpr); ok {
1428 return xBad
1429 }
1430 if array.typ() != starlarkTypeList {
1431 array = &callExpr{object: array, name: "split", returnType: starlarkTypeList}
1432 }
1433 return indexExpr{array, &intLiteralExpr{int(index - 1)}}
1434}
1435
Sasha Smundak16e07732021-07-23 11:38:23 -07001436func (ctx *parseContext) parseFirstOrLastwordFunc(node mkparser.Node, name string, args *mkparser.MakeString) starlarkExpr {
1437 arg := ctx.parseMakeString(node, args)
1438 if bad, ok := arg.(*badExpr); ok {
1439 return bad
1440 }
1441 index := &intLiteralExpr{0}
1442 if name == "lastword" {
1443 if v, ok := arg.(*variableRefExpr); ok && v.ref.name() == "MAKEFILE_LIST" {
1444 return &stringLiteralExpr{ctx.script.mkFile}
1445 }
1446 index.literal = -1
1447 }
1448 if arg.typ() == starlarkTypeList {
1449 return &indexExpr{arg, index}
1450 }
1451 return &indexExpr{&callExpr{object: arg, name: "split", returnType: starlarkTypeList}, index}
1452}
1453
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001454func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
1455 if mk.Const() {
1456 return &stringLiteralExpr{mk.Dump()}
1457 }
1458 if mkRef, ok := mk.SingleVariable(); ok {
1459 return ctx.parseReference(node, mkRef)
1460 }
1461 // If we reached here, it's neither string literal nor a simple variable,
1462 // we need a full-blown interpolation node that will generate
1463 // "a%b%c" % (X, Y) for a$(X)b$(Y)c
1464 xInterp := &interpolateExpr{args: make([]starlarkExpr, len(mk.Variables))}
1465 for i, ref := range mk.Variables {
1466 arg := ctx.parseReference(node, ref.Name)
1467 if x, ok := arg.(*badExpr); ok {
1468 return x
1469 }
1470 xInterp.args[i] = arg
1471 }
1472 xInterp.chunks = append(xInterp.chunks, mk.Strings...)
1473 return xInterp
1474}
1475
1476// Handles the statements whose treatment is the same in all contexts: comment,
1477// assignment, variable (which is a macro call in reality) and all constructs that
1478// do not handle in any context ('define directive and any unrecognized stuff).
Cole Faust591a1fe2021-11-08 15:37:57 -08001479func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001480 switch x := node.(type) {
1481 case *mkparser.Comment:
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001482 ctx.maybeHandleAnnotation(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001483 ctx.insertComment("#" + x.Comment)
1484 case *mkparser.Assignment:
1485 ctx.handleAssignment(x)
1486 case *mkparser.Variable:
1487 ctx.handleVariable(x)
1488 case *mkparser.Directive:
1489 switch x.Name {
1490 case "define":
1491 ctx.handleDefine(x)
1492 case "include", "-include":
1493 ctx.handleInclude(node, ctx.parseMakeString(node, x.Args), x.Name[0] != '-')
Cole Faust591a1fe2021-11-08 15:37:57 -08001494 case "ifeq", "ifneq", "ifdef", "ifndef":
1495 ctx.handleIfBlock(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001496 default:
Cole Faust591a1fe2021-11-08 15:37:57 -08001497 ctx.errorf(x, "unexpected directive %s", x.Name)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001498 }
1499 default:
Sasha Smundak2afb9d72021-10-24 15:16:59 -07001500 ctx.errorf(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001501 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001502}
1503
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001504// Processes annotation. An annotation is a comment that starts with #RBC# and provides
1505// a conversion hint -- say, where to look for the dynamically calculated inherit/include
1506// paths.
1507func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) {
1508 maybeTrim := func(s, prefix string) (string, bool) {
1509 if strings.HasPrefix(s, prefix) {
1510 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
1511 }
1512 return s, false
1513 }
1514 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
1515 if !ok {
1516 return
1517 }
1518 if p, ok := maybeTrim(annotation, "include_top"); ok {
1519 ctx.includeTops = append(ctx.includeTops, p)
1520 return
1521 }
1522 ctx.errorf(cnode, "unsupported annotation %s", cnode.Comment)
1523
1524}
1525
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001526func (ctx *parseContext) insertComment(s string) {
1527 ctx.receiver.newNode(&commentNode{strings.TrimSpace(s)})
1528}
1529
1530func (ctx *parseContext) carryAsComment(failedNode mkparser.Node) {
1531 for _, line := range strings.Split(failedNode.Dump(), "\n") {
1532 ctx.insertComment("# " + line)
1533 }
1534}
1535
1536// records that the given node failed to be converted and includes an explanatory message
1537func (ctx *parseContext) errorf(failedNode mkparser.Node, message string, args ...interface{}) {
1538 if ctx.errorLogger != nil {
1539 ctx.errorLogger.NewError(message, failedNode, args...)
1540 }
1541 message = fmt.Sprintf(message, args...)
1542 ctx.insertComment(fmt.Sprintf("# MK2RBC TRANSLATION ERROR: %s", message))
1543 ctx.carryAsComment(failedNode)
1544 ctx.script.hasErrors = true
1545}
1546
1547func (ctx *parseContext) wrapBadExpr(xBad *badExpr) {
1548 ctx.insertComment(fmt.Sprintf("# MK2RBC TRANSLATION ERROR: %s", xBad.message))
1549 ctx.carryAsComment(xBad.node)
1550}
1551
1552func (ctx *parseContext) loadedModulePath(path string) string {
1553 // During the transition to Roboleaf some of the product configuration files
1554 // will be converted and checked in while the others will be generated on the fly
1555 // and run. The runner (rbcrun application) accommodates this by allowing three
1556 // different ways to specify the loaded file location:
1557 // 1) load(":<file>",...) loads <file> from the same directory
1558 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
1559 // 3) load("/absolute/path/to/<file> absolute path
1560 // If the file being generated and the file it wants to load are in the same directory,
1561 // generate option 1.
1562 // Otherwise, if output directory is not specified, generate 2)
1563 // Finally, if output directory has been specified and the file being generated and
1564 // the file it wants to load from are in the different directories, generate 2) or 3):
1565 // * if the file being loaded exists in the source tree, generate 2)
1566 // * otherwise, generate 3)
1567 // Finally, figure out the loaded module path and name and create a node for it
1568 loadedModuleDir := filepath.Dir(path)
1569 base := filepath.Base(path)
1570 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
1571 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
1572 return ":" + loadedModuleName
1573 }
1574 if ctx.outputDir == "" {
1575 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1576 }
1577 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
1578 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1579 }
1580 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
1581}
1582
Sasha Smundak3deb9682021-07-26 18:42:25 -07001583func (ctx *parseContext) addSoongNamespace(ns string) {
1584 if _, ok := ctx.soongNamespaces[ns]; ok {
1585 return
1586 }
1587 ctx.soongNamespaces[ns] = make(map[string]bool)
1588}
1589
1590func (ctx *parseContext) hasSoongNamespace(name string) bool {
1591 _, ok := ctx.soongNamespaces[name]
1592 return ok
1593}
1594
1595func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
1596 ctx.addSoongNamespace(namespaceName)
1597 vars := ctx.soongNamespaces[namespaceName]
1598 if replace {
1599 vars = make(map[string]bool)
1600 ctx.soongNamespaces[namespaceName] = vars
1601 }
1602 for _, v := range varNames {
1603 vars[v] = true
1604 }
1605}
1606
1607func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
1608 vars, ok := ctx.soongNamespaces[namespaceName]
1609 if ok {
1610 _, ok = vars[varName]
1611 }
1612 return ok
1613}
1614
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001615func (ss *StarlarkScript) String() string {
1616 return NewGenerateContext(ss).emit()
1617}
1618
1619func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001620
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001621 var subs []string
1622 for _, src := range ss.inherited {
1623 subs = append(subs, src.originalPath)
1624 }
1625 return subs
1626}
1627
1628func (ss *StarlarkScript) HasErrors() bool {
1629 return ss.hasErrors
1630}
1631
1632// Convert reads and parses a makefile. If successful, parsed tree
1633// is returned and then can be passed to String() to get the generated
1634// Starlark file.
1635func Convert(req Request) (*StarlarkScript, error) {
1636 reader := req.Reader
1637 if reader == nil {
1638 mkContents, err := ioutil.ReadFile(req.MkFile)
1639 if err != nil {
1640 return nil, err
1641 }
1642 reader = bytes.NewBuffer(mkContents)
1643 }
1644 parser := mkparser.NewParser(req.MkFile, reader)
1645 nodes, errs := parser.Parse()
1646 if len(errs) > 0 {
1647 for _, e := range errs {
1648 fmt.Fprintln(os.Stderr, "ERROR:", e)
1649 }
1650 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
1651 }
1652 starScript := &StarlarkScript{
1653 moduleName: moduleNameForFile(req.MkFile),
1654 mkFile: req.MkFile,
1655 topDir: req.RootDir,
1656 traceCalls: req.TraceCalls,
1657 warnPartialSuccess: req.WarnPartialSuccess,
Sasha Smundak6609ba72021-07-22 18:32:56 -07001658 sourceFS: req.SourceFS,
1659 makefileFinder: req.MakefileFinder,
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001660 }
1661 ctx := newParseContext(starScript, nodes)
1662 ctx.outputSuffix = req.OutputSuffix
1663 ctx.outputDir = req.OutputDir
1664 ctx.errorLogger = req.ErrorLogger
1665 if len(req.TracedVariables) > 0 {
1666 ctx.tracedVariables = make(map[string]bool)
1667 for _, v := range req.TracedVariables {
1668 ctx.tracedVariables[v] = true
1669 }
1670 }
1671 ctx.pushReceiver(starScript)
1672 for ctx.hasNodes() && ctx.fatalError == nil {
Cole Faust591a1fe2021-11-08 15:37:57 -08001673 ctx.handleSimpleStatement(ctx.getNode())
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001674 }
1675 if ctx.fatalError != nil {
1676 return nil, ctx.fatalError
1677 }
1678 return starScript, nil
1679}
1680
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001681func Launcher(mainModuleUri, versionDefaultsUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001682 var buf bytes.Buffer
1683 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001684 fmt.Fprintf(&buf, "load(%q, \"version_defaults\")\n", versionDefaultsUri)
1685 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
1686 fmt.Fprintf(&buf, "%s(%s(%q, init, version_defaults))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001687 return buf.String()
1688}
1689
Cole Faust6ed7cb42021-10-07 17:08:46 -07001690func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
1691 var buf bytes.Buffer
1692 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
1693 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
1694 fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
1695 fmt.Fprintf(&buf, "globals, cfg, globals_base = %s(init, input_variables_init)\n", cfnBoardMain)
1696 fmt.Fprintf(&buf, "# TODO: Some product config variables need to be printed, but most are readonly so we can't just print cfg here.\n")
1697 fmt.Fprintf(&buf, "%s(globals, globals_base)\n", cfnPrintGlobals)
1698 return buf.String()
1699}
1700
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001701func MakePath2ModuleName(mkPath string) string {
1702 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
1703}