blob: 6227164e1ee013e32bf7ae93e7aa2aca87450bf0 [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"
55 cfnPrintVars = baseName + ".printvars"
56 cfnWarning = baseName + ".warning"
57 cfnLocalAppend = baseName + ".local_append"
58 cfnLocalSetDefault = baseName + ".local_set_default"
59 cfnInherit = baseName + ".inherit"
60 cfnSetListDefault = baseName + ".setdefault"
61)
62
63const (
64 // Phony makefile functions, they are eventually rewritten
65 // according to knownFunctions map
Sasha Smundak65b547e2021-09-17 15:35:41 -070066 fileExistsPhony = "$file_exists"
67 // The following two macros are obsolete, and will we deleted once
68 // there are deleted from the makefiles:
69 soongConfigNamespaceOld = "add_soong_config_namespace"
70 soongConfigVarSetOld = "add_soong_config_var_value"
71 soongConfigAppend = "soong_config_append"
72 soongConfigAssign = "soong_config_set"
73 wildcardExistsPhony = "$wildcard_exists"
Sasha Smundakb051c4e2020-11-05 20:45:07 -080074)
75
76const (
77 callLoadAlways = "inherit-product"
78 callLoadIf = "inherit-product-if-exists"
79)
80
81var knownFunctions = map[string]struct {
82 // The name of the runtime function this function call in makefiles maps to.
83 // If it starts with !, then this makefile function call is rewritten to
84 // something else.
85 runtimeName string
86 returnType starlarkType
Sasha Smundak3deb9682021-07-26 18:42:25 -070087 hiddenArg hiddenArgType
Sasha Smundakb051c4e2020-11-05 20:45:07 -080088}{
Sasha Smundak3deb9682021-07-26 18:42:25 -070089 "abspath": {baseName + ".abspath", starlarkTypeString, hiddenArgNone},
90 fileExistsPhony: {baseName + ".file_exists", starlarkTypeBool, hiddenArgNone},
91 wildcardExistsPhony: {baseName + ".file_wildcard_exists", starlarkTypeBool, hiddenArgNone},
Sasha Smundak65b547e2021-09-17 15:35:41 -070092 soongConfigNamespaceOld: {baseName + ".soong_config_namespace", starlarkTypeVoid, hiddenArgGlobal},
93 soongConfigVarSetOld: {baseName + ".soong_config_set", starlarkTypeVoid, hiddenArgGlobal},
94 soongConfigAssign: {baseName + ".soong_config_set", starlarkTypeVoid, hiddenArgGlobal},
95 soongConfigAppend: {baseName + ".soong_config_append", starlarkTypeVoid, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -070096 "add-to-product-copy-files-if-exists": {baseName + ".copy_if_exists", starlarkTypeList, hiddenArgNone},
97 "addprefix": {baseName + ".addprefix", starlarkTypeList, hiddenArgNone},
98 "addsuffix": {baseName + ".addsuffix", starlarkTypeList, hiddenArgNone},
99 "copy-files": {baseName + ".copy_files", starlarkTypeList, hiddenArgNone},
100 "dir": {baseName + ".dir", starlarkTypeList, hiddenArgNone},
101 "enforce-product-packages-exist": {baseName + ".enforce_product_packages_exist", starlarkTypeVoid, hiddenArgNone},
102 "error": {baseName + ".mkerror", starlarkTypeVoid, hiddenArgNone},
103 "findstring": {"!findstring", starlarkTypeInt, hiddenArgNone},
104 "find-copy-subdir-files": {baseName + ".find_and_copy", starlarkTypeList, hiddenArgNone},
105 "find-word-in-list": {"!find-word-in-list", starlarkTypeUnknown, hiddenArgNone}, // internal macro
106 "filter": {baseName + ".filter", starlarkTypeList, hiddenArgNone},
107 "filter-out": {baseName + ".filter_out", starlarkTypeList, hiddenArgNone},
108 "firstword": {"!firstword", starlarkTypeString, hiddenArgNone},
109 "get-vendor-board-platforms": {"!get-vendor-board-platforms", starlarkTypeList, hiddenArgNone}, // internal macro, used by is-board-platform, etc.
110 "info": {baseName + ".mkinfo", starlarkTypeVoid, hiddenArgNone},
111 "is-android-codename": {"!is-android-codename", starlarkTypeBool, hiddenArgNone}, // unused by product config
112 "is-android-codename-in-list": {"!is-android-codename-in-list", starlarkTypeBool, hiddenArgNone}, // unused by product config
113 "is-board-platform": {"!is-board-platform", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700114 "is-board-platform2": {baseName + ".board_platform_is", starlarkTypeBool, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700115 "is-board-platform-in-list": {"!is-board-platform-in-list", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700116 "is-board-platform-in-list2": {baseName + ".board_platform_in", starlarkTypeBool, hiddenArgGlobal},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700117 "is-chipset-in-board-platform": {"!is-chipset-in-board-platform", starlarkTypeUnknown, hiddenArgNone}, // unused by product config
118 "is-chipset-prefix-in-board-platform": {"!is-chipset-prefix-in-board-platform", starlarkTypeBool, hiddenArgNone}, // unused by product config
119 "is-not-board-platform": {"!is-not-board-platform", starlarkTypeBool, hiddenArgNone}, // defined but never used
120 "is-platform-sdk-version-at-least": {"!is-platform-sdk-version-at-least", starlarkTypeBool, hiddenArgNone}, // unused by product config
121 "is-product-in-list": {"!is-product-in-list", starlarkTypeBool, hiddenArgNone},
122 "is-vendor-board-platform": {"!is-vendor-board-platform", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3a9b8e82021-08-25 14:11:04 -0700123 "is-vendor-board-qcom": {"!is-vendor-board-qcom", starlarkTypeBool, hiddenArgNone},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700124 callLoadAlways: {"!inherit-product", starlarkTypeVoid, hiddenArgNone},
125 callLoadIf: {"!inherit-product-if-exists", starlarkTypeVoid, hiddenArgNone},
126 "lastword": {"!lastword", starlarkTypeString, hiddenArgNone},
127 "match-prefix": {"!match-prefix", starlarkTypeUnknown, hiddenArgNone}, // internal macro
128 "match-word": {"!match-word", starlarkTypeUnknown, hiddenArgNone}, // internal macro
129 "match-word-in-list": {"!match-word-in-list", starlarkTypeUnknown, hiddenArgNone}, // internal macro
130 "notdir": {baseName + ".notdir", starlarkTypeString, hiddenArgNone},
131 "my-dir": {"!my-dir", starlarkTypeString, hiddenArgNone},
132 "patsubst": {baseName + ".mkpatsubst", starlarkTypeString, hiddenArgNone},
Sasha Smundak04453082021-08-17 18:14:41 -0700133 "product-copy-files-by-pattern": {baseName + ".product_copy_files_by_pattern", starlarkTypeList, hiddenArgNone},
Sasha Smundak3deb9682021-07-26 18:42:25 -0700134 "require-artifacts-in-path": {baseName + ".require_artifacts_in_path", starlarkTypeVoid, hiddenArgNone},
135 "require-artifacts-in-path-relaxed": {baseName + ".require_artifacts_in_path_relaxed", starlarkTypeVoid, hiddenArgNone},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800136 // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
Sasha Smundak3deb9682021-07-26 18:42:25 -0700137 "shell": {baseName + ".shell", starlarkTypeString, hiddenArgNone},
138 "strip": {baseName + ".mkstrip", starlarkTypeString, hiddenArgNone},
139 "tb-modules": {"!tb-modules", starlarkTypeUnknown, hiddenArgNone}, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
140 "subst": {baseName + ".mksubst", starlarkTypeString, hiddenArgNone},
141 "warning": {baseName + ".mkwarning", starlarkTypeVoid, hiddenArgNone},
142 "word": {baseName + "!word", starlarkTypeString, hiddenArgNone},
143 "wildcard": {baseName + ".expand_wildcard", starlarkTypeList, hiddenArgNone},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800144}
145
146var builtinFuncRex = regexp.MustCompile(
147 "^(addprefix|addsuffix|abspath|and|basename|call|dir|error|eval" +
148 "|flavor|foreach|file|filter|filter-out|findstring|firstword|guile" +
149 "|if|info|join|lastword|notdir|or|origin|patsubst|realpath" +
150 "|shell|sort|strip|subst|suffix|value|warning|word|wordlist|words" +
151 "|wildcard)")
152
153// Conversion request parameters
154type Request struct {
155 MkFile string // file to convert
156 Reader io.Reader // if set, read input from this stream instead
157 RootDir string // root directory path used to resolve included files
158 OutputSuffix string // generated Starlark files suffix
159 OutputDir string // if set, root of the output hierarchy
160 ErrorLogger ErrorMonitorCB
161 TracedVariables []string // trace assignment to these variables
162 TraceCalls bool
163 WarnPartialSuccess bool
Sasha Smundak6609ba72021-07-22 18:32:56 -0700164 SourceFS fs.FS
165 MakefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800166}
167
168// An error sink allowing to gather error statistics.
169// NewError is called on every error encountered during processing.
170type ErrorMonitorCB interface {
171 NewError(s string, node mkparser.Node, args ...interface{})
172}
173
174// Derives module name for a given file. It is base name
175// (file name without suffix), with some characters replaced to make it a Starlark identifier
176func moduleNameForFile(mkFile string) string {
177 base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
178 // TODO(asmundak): what else can be in the product file names?
Sasha Smundak6609ba72021-07-22 18:32:56 -0700179 return strings.NewReplacer("-", "_", ".", "_").Replace(base)
180
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800181}
182
183func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
184 r := &mkparser.MakeString{StringPos: mkString.StringPos}
185 r.Strings = append(r.Strings, mkString.Strings...)
186 r.Variables = append(r.Variables, mkString.Variables...)
187 return r
188}
189
190func isMakeControlFunc(s string) bool {
191 return s == "error" || s == "warning" || s == "info"
192}
193
194// Starlark output generation context
195type generationContext struct {
196 buf strings.Builder
197 starScript *StarlarkScript
198 indentLevel int
199 inAssignment bool
200 tracedCount int
201}
202
203func NewGenerateContext(ss *StarlarkScript) *generationContext {
204 return &generationContext{starScript: ss}
205}
206
207// emit returns generated script
208func (gctx *generationContext) emit() string {
209 ss := gctx.starScript
210
211 // The emitted code has the following layout:
212 // <initial comments>
213 // preamble, i.e.,
214 // load statement for the runtime support
215 // load statement for each unique submodule pulled in by this one
216 // def init(g, handle):
217 // cfg = rblf.cfg(handle)
218 // <statements>
219 // <warning if conversion was not clean>
220
221 iNode := len(ss.nodes)
222 for i, node := range ss.nodes {
223 if _, ok := node.(*commentNode); !ok {
224 iNode = i
225 break
226 }
227 node.emit(gctx)
228 }
229
230 gctx.emitPreamble()
231
232 gctx.newLine()
233 // The arguments passed to the init function are the global dictionary
234 // ('g') and the product configuration dictionary ('cfg')
235 gctx.write("def init(g, handle):")
236 gctx.indentLevel++
237 if gctx.starScript.traceCalls {
238 gctx.newLine()
239 gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
240 }
241 gctx.newLine()
242 gctx.writef("cfg = %s(handle)", cfnGetCfg)
243 for _, node := range ss.nodes[iNode:] {
244 node.emit(gctx)
245 }
246
247 if ss.hasErrors && ss.warnPartialSuccess {
248 gctx.newLine()
249 gctx.writef("%s(%q, %q)", cfnWarning, filepath.Base(ss.mkFile), "partially successful conversion")
250 }
251 if gctx.starScript.traceCalls {
252 gctx.newLine()
253 gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
254 }
255 gctx.indentLevel--
256 gctx.write("\n")
257 return gctx.buf.String()
258}
259
260func (gctx *generationContext) emitPreamble() {
261 gctx.newLine()
262 gctx.writef("load(%q, %q)", baseUri, baseName)
263 // Emit exactly one load statement for each URI.
264 loadedSubConfigs := make(map[string]string)
265 for _, sc := range gctx.starScript.inherited {
266 uri := sc.path
267 if m, ok := loadedSubConfigs[uri]; ok {
268 // No need to emit load statement, but fix module name.
269 sc.moduleLocalName = m
270 continue
271 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700272 if sc.optional {
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800273 uri += "|init"
274 }
275 gctx.newLine()
276 gctx.writef("load(%q, %s = \"init\")", uri, sc.entryName())
277 loadedSubConfigs[uri] = sc.moduleLocalName
278 }
279 gctx.write("\n")
280}
281
282func (gctx *generationContext) emitPass() {
283 gctx.newLine()
284 gctx.write("pass")
285}
286
287func (gctx *generationContext) write(ss ...string) {
288 for _, s := range ss {
289 gctx.buf.WriteString(s)
290 }
291}
292
293func (gctx *generationContext) writef(format string, args ...interface{}) {
294 gctx.write(fmt.Sprintf(format, args...))
295}
296
297func (gctx *generationContext) newLine() {
298 if gctx.buf.Len() == 0 {
299 return
300 }
301 gctx.write("\n")
302 gctx.writef("%*s", 2*gctx.indentLevel, "")
303}
304
305type knownVariable struct {
306 name string
307 class varClass
308 valueType starlarkType
309}
310
311type knownVariables map[string]knownVariable
312
313func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
314 v, exists := pcv[name]
315 if !exists {
316 pcv[name] = knownVariable{name, varClass, valueType}
317 return
318 }
319 // Conflict resolution:
320 // * config class trumps everything
321 // * any type trumps unknown type
322 match := varClass == v.class
323 if !match {
324 if varClass == VarClassConfig {
325 v.class = VarClassConfig
326 match = true
327 } else if v.class == VarClassConfig {
328 match = true
329 }
330 }
331 if valueType != v.valueType {
332 if valueType != starlarkTypeUnknown {
333 if v.valueType == starlarkTypeUnknown {
334 v.valueType = valueType
335 } else {
336 match = false
337 }
338 }
339 }
340 if !match {
341 fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
342 name, varClass, valueType, v.class, v.valueType)
343 }
344}
345
346// All known product variables.
347var KnownVariables = make(knownVariables)
348
349func init() {
350 for _, kv := range []string{
351 // Kernel-related variables that we know are lists.
352 "BOARD_VENDOR_KERNEL_MODULES",
353 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
354 "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
355 "BOARD_RECOVERY_KERNEL_MODULES",
356 // Other variables we knwo are lists
357 "ART_APEX_JARS",
358 } {
359 KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
360 }
361}
362
363type nodeReceiver interface {
364 newNode(node starlarkNode)
365}
366
367// Information about the generated Starlark script.
368type StarlarkScript struct {
369 mkFile string
370 moduleName string
371 mkPos scanner.Position
372 nodes []starlarkNode
Sasha Smundak6609ba72021-07-22 18:32:56 -0700373 inherited []*moduleInfo
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800374 hasErrors bool
375 topDir string
376 traceCalls bool // print enter/exit each init function
377 warnPartialSuccess bool
Sasha Smundak6609ba72021-07-22 18:32:56 -0700378 sourceFS fs.FS
379 makefileFinder MakefileFinder
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800380}
381
382func (ss *StarlarkScript) newNode(node starlarkNode) {
383 ss.nodes = append(ss.nodes, node)
384}
385
386// varAssignmentScope points to the last assignment for each variable
387// in the current block. It is used during the parsing to chain
388// the assignments to a variable together.
389type varAssignmentScope struct {
390 outer *varAssignmentScope
391 vars map[string]*assignmentNode
392}
393
394// parseContext holds the script we are generating and all the ephemeral data
395// needed during the parsing.
396type parseContext struct {
397 script *StarlarkScript
398 nodes []mkparser.Node // Makefile as parsed by mkparser
399 currentNodeIndex int // Node in it we are processing
400 ifNestLevel int
401 moduleNameCount map[string]int // count of imported modules with given basename
402 fatalError error
403 builtinMakeVars map[string]starlarkExpr
404 outputSuffix string
405 errorLogger ErrorMonitorCB
406 tracedVariables map[string]bool // variables to be traced in the generated script
407 variables map[string]variable
408 varAssignments *varAssignmentScope
409 receiver nodeReceiver // receptacle for the generated starlarkNode's
410 receiverStack []nodeReceiver
411 outputDir string
Sasha Smundak6609ba72021-07-22 18:32:56 -0700412 dependentModules map[string]*moduleInfo
Sasha Smundak3deb9682021-07-26 18:42:25 -0700413 soongNamespaces map[string]map[string]bool
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700414 includeTops []string
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800415}
416
417func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700418 topdir, _ := filepath.Split(filepath.Join(ss.topDir, "foo"))
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800419 predefined := []struct{ name, value string }{
420 {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
421 {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
Sasha Smundak6609ba72021-07-22 18:32:56 -0700422 {"TOPDIR", topdir},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800423 // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
424 {"TARGET_COPY_OUT_SYSTEM", "system"},
425 {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
426 {"TARGET_COPY_OUT_DATA", "data"},
427 {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
428 {"TARGET_COPY_OUT_OEM", "oem"},
429 {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
430 {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
431 {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
432 {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
433 {"TARGET_COPY_OUT_ROOT", "root"},
434 {"TARGET_COPY_OUT_RECOVERY", "recovery"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800435 {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800436 // TODO(asmundak): to process internal config files, we need the following variables:
437 // BOARD_CONFIG_VENDOR_PATH
438 // TARGET_VENDOR
439 // target_base_product
440 //
441
442 // the following utility variables are set in build/make/common/core.mk:
443 {"empty", ""},
444 {"space", " "},
445 {"comma", ","},
446 {"newline", "\n"},
447 {"pound", "#"},
448 {"backslash", "\\"},
449 }
450 ctx := &parseContext{
451 script: ss,
452 nodes: nodes,
453 currentNodeIndex: 0,
454 ifNestLevel: 0,
455 moduleNameCount: make(map[string]int),
456 builtinMakeVars: map[string]starlarkExpr{},
457 variables: make(map[string]variable),
Sasha Smundak6609ba72021-07-22 18:32:56 -0700458 dependentModules: make(map[string]*moduleInfo),
Sasha Smundak3deb9682021-07-26 18:42:25 -0700459 soongNamespaces: make(map[string]map[string]bool),
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700460 includeTops: []string{"vendor/google-devices"},
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800461 }
462 ctx.pushVarAssignments()
463 for _, item := range predefined {
464 ctx.variables[item.name] = &predefinedVariable{
465 baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
466 value: &stringLiteralExpr{item.value},
467 }
468 }
469
470 return ctx
471}
472
473func (ctx *parseContext) lastAssignment(name string) *assignmentNode {
474 for va := ctx.varAssignments; va != nil; va = va.outer {
475 if v, ok := va.vars[name]; ok {
476 return v
477 }
478 }
479 return nil
480}
481
482func (ctx *parseContext) setLastAssignment(name string, asgn *assignmentNode) {
483 ctx.varAssignments.vars[name] = asgn
484}
485
486func (ctx *parseContext) pushVarAssignments() {
487 va := &varAssignmentScope{
488 outer: ctx.varAssignments,
489 vars: make(map[string]*assignmentNode),
490 }
491 ctx.varAssignments = va
492}
493
494func (ctx *parseContext) popVarAssignments() {
495 ctx.varAssignments = ctx.varAssignments.outer
496}
497
498func (ctx *parseContext) pushReceiver(rcv nodeReceiver) {
499 ctx.receiverStack = append(ctx.receiverStack, ctx.receiver)
500 ctx.receiver = rcv
501}
502
503func (ctx *parseContext) popReceiver() {
504 last := len(ctx.receiverStack) - 1
505 if last < 0 {
506 panic(fmt.Errorf("popReceiver: receiver stack empty"))
507 }
508 ctx.receiver = ctx.receiverStack[last]
509 ctx.receiverStack = ctx.receiverStack[0:last]
510}
511
512func (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
532func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) {
533 // Handle only simple variables
534 if !a.Name.Const() {
535 ctx.errorf(a, "Only simple variables are handled")
536 return
537 }
538 name := a.Name.Strings[0]
Sasha Smundak3deb9682021-07-26 18:42:25 -0700539 // Soong confuguration
540 if strings.HasPrefix(name, soongNsPrefix) {
541 ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
542 return
543 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800544 lhs := ctx.addVariable(name)
545 if lhs == nil {
546 ctx.errorf(a, "unknown variable %s", name)
547 return
548 }
549 _, isTraced := ctx.tracedVariables[name]
550 asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced}
551 if lhs.valueType() == starlarkTypeUnknown {
552 // Try to divine variable type from the RHS
553 asgn.value = ctx.parseMakeString(a, a.Value)
554 if xBad, ok := asgn.value.(*badExpr); ok {
555 ctx.wrapBadExpr(xBad)
556 return
557 }
558 inferred_type := asgn.value.typ()
559 if inferred_type != starlarkTypeUnknown {
Sasha Smundak9d011ab2021-07-09 16:00:57 -0700560 lhs.setValueType(inferred_type)
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800561 }
562 }
563 if lhs.valueType() == starlarkTypeList {
564 xConcat := ctx.buildConcatExpr(a)
565 if xConcat == nil {
566 return
567 }
568 switch len(xConcat.items) {
569 case 0:
570 asgn.value = &listExpr{}
571 case 1:
572 asgn.value = xConcat.items[0]
573 default:
574 asgn.value = xConcat
575 }
576 } else {
577 asgn.value = ctx.parseMakeString(a, a.Value)
578 if xBad, ok := asgn.value.(*badExpr); ok {
579 ctx.wrapBadExpr(xBad)
580 return
581 }
582 }
583
584 // TODO(asmundak): move evaluation to a separate pass
585 asgn.value, _ = asgn.value.eval(ctx.builtinMakeVars)
586
587 asgn.previous = ctx.lastAssignment(name)
588 ctx.setLastAssignment(name, asgn)
589 switch a.Type {
590 case "=", ":=":
591 asgn.flavor = asgnSet
592 case "+=":
593 if asgn.previous == nil && !asgn.lhs.isPreset() {
594 asgn.flavor = asgnMaybeAppend
595 } else {
596 asgn.flavor = asgnAppend
597 }
598 case "?=":
599 asgn.flavor = asgnMaybeSet
600 default:
601 panic(fmt.Errorf("unexpected assignment type %s", a.Type))
602 }
603
604 ctx.receiver.newNode(asgn)
605}
606
Sasha Smundak3deb9682021-07-26 18:42:25 -0700607func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) {
608 val := ctx.parseMakeString(asgn, asgn.Value)
609 if xBad, ok := val.(*badExpr); ok {
610 ctx.wrapBadExpr(xBad)
611 return
612 }
613 val, _ = val.eval(ctx.builtinMakeVars)
614
615 // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
616 // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
617 // Try to divine the call from the assignment as follows:
618 if name == "NAMESPACES" {
619 // Upon seeng
620 // SOONG_CONFIG_NAMESPACES += foo
621 // remember that there is a namespace `foo` and act as we saw
622 // $(call add_soong_config_namespace,foo)
623 s, ok := maybeString(val)
624 if !ok {
625 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")
626 return
627 }
628 for _, ns := range strings.Fields(s) {
629 ctx.addSoongNamespace(ns)
630 ctx.receiver.newNode(&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700631 name: soongConfigNamespaceOld,
Sasha Smundak3deb9682021-07-26 18:42:25 -0700632 args: []starlarkExpr{&stringLiteralExpr{ns}},
633 returnType: starlarkTypeVoid,
634 }})
635 }
636 } else {
637 // Upon seeing
638 // SOONG_CONFIG_x_y = v
639 // find a namespace called `x` and act as if we encountered
640 // $(call add_config_var_value(x,y,v)
641 // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
642 // it.
643 // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
644 // and `foo` with a variable `bar_baz`.
645 namespaceName := ""
646 if ctx.hasSoongNamespace(name) {
647 namespaceName = name
648 }
649 var varName string
650 for pos, ch := range name {
651 if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
652 continue
653 }
654 if namespaceName != "" {
655 ctx.errorf(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])
656 return
657 }
658 namespaceName = name[0:pos]
659 varName = name[pos+1:]
660 }
661 if namespaceName == "" {
662 ctx.errorf(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")
663 return
664 }
665 if varName == "" {
666 // Remember variables in this namespace
667 s, ok := maybeString(val)
668 if !ok {
669 ctx.errorf(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")
670 return
671 }
672 ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
673 return
674 }
675
676 // Finally, handle assignment to a namespace variable
677 if !ctx.hasNamespaceVar(namespaceName, varName) {
678 ctx.errorf(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)
679 return
680 }
Sasha Smundak65b547e2021-09-17 15:35:41 -0700681 fname := soongConfigVarSetOld
682 if asgn.Type == "+=" {
683 fname = soongConfigAppend
684 }
Sasha Smundak3deb9682021-07-26 18:42:25 -0700685 ctx.receiver.newNode(&exprNode{&callExpr{
Sasha Smundak65b547e2021-09-17 15:35:41 -0700686 name: fname,
Sasha Smundak3deb9682021-07-26 18:42:25 -0700687 args: []starlarkExpr{&stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
688 returnType: starlarkTypeVoid,
689 }})
690 }
691}
692
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800693func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) *concatExpr {
694 xConcat := &concatExpr{}
695 var xItemList *listExpr
696 addToItemList := func(x ...starlarkExpr) {
697 if xItemList == nil {
698 xItemList = &listExpr{[]starlarkExpr{}}
699 }
700 xItemList.items = append(xItemList.items, x...)
701 }
702 finishItemList := func() {
703 if xItemList != nil {
704 xConcat.items = append(xConcat.items, xItemList)
705 xItemList = nil
706 }
707 }
708
709 items := a.Value.Words()
710 for _, item := range items {
711 // A function call in RHS is supposed to return a list, all other item
712 // expressions return individual elements.
713 switch x := ctx.parseMakeString(a, item).(type) {
714 case *badExpr:
715 ctx.wrapBadExpr(x)
716 return nil
717 case *stringLiteralExpr:
718 addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
719 default:
720 switch x.typ() {
721 case starlarkTypeList:
722 finishItemList()
723 xConcat.items = append(xConcat.items, x)
724 case starlarkTypeString:
725 finishItemList()
726 xConcat.items = append(xConcat.items, &callExpr{
727 object: x,
728 name: "split",
729 args: nil,
730 returnType: starlarkTypeList,
731 })
732 default:
733 addToItemList(x)
734 }
735 }
736 }
737 if xItemList != nil {
738 xConcat.items = append(xConcat.items, xItemList)
739 }
740 return xConcat
741}
742
Sasha Smundak6609ba72021-07-22 18:32:56 -0700743func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
744 modulePath := ctx.loadedModulePath(path)
745 if mi, ok := ctx.dependentModules[modulePath]; ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700746 mi.optional = mi.optional && optional
Sasha Smundak6609ba72021-07-22 18:32:56 -0700747 return mi
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800748 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800749 moduleName := moduleNameForFile(path)
750 moduleLocalName := "_" + moduleName
751 n, found := ctx.moduleNameCount[moduleName]
752 if found {
753 moduleLocalName += fmt.Sprintf("%d", n)
754 }
755 ctx.moduleNameCount[moduleName] = n + 1
Sasha Smundak6609ba72021-07-22 18:32:56 -0700756 mi := &moduleInfo{
757 path: modulePath,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800758 originalPath: path,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800759 moduleLocalName: moduleLocalName,
Sasha Smundak6609ba72021-07-22 18:32:56 -0700760 optional: optional,
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800761 }
Sasha Smundak6609ba72021-07-22 18:32:56 -0700762 ctx.dependentModules[modulePath] = mi
763 ctx.script.inherited = append(ctx.script.inherited, mi)
764 return mi
765}
766
767func (ctx *parseContext) handleSubConfig(
768 v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule)) {
769 pathExpr, _ = pathExpr.eval(ctx.builtinMakeVars)
770
771 // In a simple case, the name of a module to inherit/include is known statically.
772 if path, ok := maybeString(pathExpr); ok {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700773 // Note that even if this directive loads a module unconditionally, a module may be
774 // absent without causing any harm if this directive is inside an if/else block.
775 moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
Sasha Smundak6609ba72021-07-22 18:32:56 -0700776 if strings.Contains(path, "*") {
777 if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
778 for _, p := range paths {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700779 mi := ctx.newDependentModule(p, !moduleShouldExist)
780 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700781 }
782 } else {
783 ctx.errorf(v, "cannot glob wildcard argument")
784 }
785 } else {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700786 mi := ctx.newDependentModule(path, !moduleShouldExist)
787 processModule(inheritedStaticModule{mi, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700788 }
789 return
790 }
791
792 // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
793 // source tree that may be a match and the corresponding variable values. For instance, if the source tree
794 // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
795 // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
796 // We then emit the code that loads all of them, e.g.:
797 // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
798 // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
799 // And then inherit it as follows:
800 // _e = {
801 // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
802 // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
803 // if _e:
804 // rblf.inherit(handle, _e[0], _e[1])
805 //
806 var matchingPaths []string
807 varPath, ok := pathExpr.(*interpolateExpr)
808 if !ok {
809 ctx.errorf(v, "inherit-product/include argument is too complex")
810 return
811 }
812
813 pathPattern := []string{varPath.chunks[0]}
814 for _, chunk := range varPath.chunks[1:] {
815 if chunk != "" {
816 pathPattern = append(pathPattern, chunk)
817 }
818 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700819 if pathPattern[0] == "" {
820 // If pattern starts from the top. restrict it to the directories where
821 // we know inherit-product uses dynamically calculated path.
822 for _, p := range ctx.includeTops {
823 pathPattern[0] = p
824 matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700825 }
Sasha Smundak6d852dd2021-09-27 20:34:39 -0700826 } else {
827 matchingPaths = ctx.findMatchingPaths(pathPattern)
Sasha Smundak6609ba72021-07-22 18:32:56 -0700828 }
829 // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
Sasha Smundak90be8c52021-08-03 11:06:10 -0700830 const maxMatchingFiles = 150
Sasha Smundak6609ba72021-07-22 18:32:56 -0700831 if len(matchingPaths) > maxMatchingFiles {
832 ctx.errorf(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)
833 return
834 }
835 res := inheritedDynamicModule{*varPath, []*moduleInfo{}, loadAlways}
836 for _, p := range matchingPaths {
837 // A product configuration files discovered dynamically may attempt to inherit
838 // from another one which does not exist in this source tree. Prevent load errors
839 // by always loading the dynamic files as optional.
840 res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
841 }
842 processModule(res)
843}
844
845func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
846 files := ctx.script.makefileFinder.Find(ctx.script.topDir)
847 if len(pattern) == 0 {
848 return files
849 }
850
851 // Create regular expression from the pattern
852 s_regexp := "^" + regexp.QuoteMeta(pattern[0])
853 for _, s := range pattern[1:] {
854 s_regexp += ".*" + regexp.QuoteMeta(s)
855 }
856 s_regexp += "$"
857 rex := regexp.MustCompile(s_regexp)
858
859 // Now match
860 var res []string
861 for _, p := range files {
862 if rex.MatchString(p) {
863 res = append(res, p)
864 }
865 }
866 return res
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800867}
868
869func (ctx *parseContext) handleInheritModule(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700870 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700871 ctx.receiver.newNode(&inheritNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700872 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800873}
874
875func (ctx *parseContext) handleInclude(v mkparser.Node, pathExpr starlarkExpr, loadAlways bool) {
Sasha Smundak6609ba72021-07-22 18:32:56 -0700876 ctx.handleSubConfig(v, pathExpr, loadAlways, func(im inheritedModule) {
Sasha Smundak868c5e32021-09-23 16:20:58 -0700877 ctx.receiver.newNode(&includeNode{im, loadAlways})
Sasha Smundak6609ba72021-07-22 18:32:56 -0700878 })
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800879}
880
881func (ctx *parseContext) handleVariable(v *mkparser.Variable) {
882 // Handle:
883 // $(call inherit-product,...)
884 // $(call inherit-product-if-exists,...)
885 // $(info xxx)
886 // $(warning xxx)
887 // $(error xxx)
888 expr := ctx.parseReference(v, v.Name)
889 switch x := expr.(type) {
890 case *callExpr:
891 if x.name == callLoadAlways || x.name == callLoadIf {
892 ctx.handleInheritModule(v, x.args[0], x.name == callLoadAlways)
893 } else if isMakeControlFunc(x.name) {
894 // File name is the first argument
895 args := []starlarkExpr{
896 &stringLiteralExpr{ctx.script.mkFile},
897 x.args[0],
898 }
899 ctx.receiver.newNode(&exprNode{
900 &callExpr{name: x.name, args: args, returnType: starlarkTypeUnknown},
901 })
902 } else {
903 ctx.receiver.newNode(&exprNode{expr})
904 }
905 case *badExpr:
906 ctx.wrapBadExpr(x)
907 return
908 default:
909 ctx.errorf(v, "cannot handle %s", v.Dump())
910 return
911 }
912}
913
914func (ctx *parseContext) handleDefine(directive *mkparser.Directive) {
Sasha Smundakf3e072a2021-07-14 12:50:28 -0700915 macro_name := strings.Fields(directive.Args.Strings[0])[0]
916 // Ignore the macros that we handle
917 if _, ok := knownFunctions[macro_name]; !ok {
918 ctx.errorf(directive, "define is not supported: %s", macro_name)
919 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -0800920}
921
922func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) {
923 ssSwitch := &switchNode{}
924 ctx.pushReceiver(ssSwitch)
925 for ctx.processBranch(ifDirective); ctx.hasNodes() && ctx.fatalError == nil; {
926 node := ctx.getNode()
927 switch x := node.(type) {
928 case *mkparser.Directive:
929 switch x.Name {
930 case "else", "elifdef", "elifndef", "elifeq", "elifneq":
931 ctx.processBranch(x)
932 case "endif":
933 ctx.popReceiver()
934 ctx.receiver.newNode(ssSwitch)
935 return
936 default:
937 ctx.errorf(node, "unexpected directive %s", x.Name)
938 }
939 default:
940 ctx.errorf(ifDirective, "unexpected statement")
941 }
942 }
943 if ctx.fatalError == nil {
944 ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
945 }
946 ctx.popReceiver()
947}
948
949// processBranch processes a single branch (if/elseif/else) until the next directive
950// on the same level.
951func (ctx *parseContext) processBranch(check *mkparser.Directive) {
952 block := switchCase{gate: ctx.parseCondition(check)}
953 defer func() {
954 ctx.popVarAssignments()
955 ctx.ifNestLevel--
956
957 }()
958 ctx.pushVarAssignments()
959 ctx.ifNestLevel++
960
961 ctx.pushReceiver(&block)
962 for ctx.hasNodes() {
963 node := ctx.getNode()
964 if ctx.handleSimpleStatement(node) {
965 continue
966 }
967 switch d := node.(type) {
968 case *mkparser.Directive:
969 switch d.Name {
970 case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
971 ctx.popReceiver()
972 ctx.receiver.newNode(&block)
973 ctx.backNode()
974 return
975 case "ifdef", "ifndef", "ifeq", "ifneq":
976 ctx.handleIfBlock(d)
977 default:
978 ctx.errorf(d, "unexpected directive %s", d.Name)
979 }
980 default:
981 ctx.errorf(node, "unexpected statement")
982 }
983 }
984 ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
985 ctx.popReceiver()
986}
987
988func (ctx *parseContext) newIfDefinedNode(check *mkparser.Directive) (starlarkExpr, bool) {
989 if !check.Args.Const() {
990 return ctx.newBadExpr(check, "ifdef variable ref too complex: %s", check.Args.Dump()), false
991 }
992 v := ctx.addVariable(check.Args.Strings[0])
993 return &variableDefinedExpr{v}, true
994}
995
996func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
997 switch check.Name {
998 case "ifdef", "ifndef", "elifdef", "elifndef":
999 v, ok := ctx.newIfDefinedNode(check)
1000 if ok && strings.HasSuffix(check.Name, "ndef") {
1001 v = &notExpr{v}
1002 }
1003 return &ifNode{
1004 isElif: strings.HasPrefix(check.Name, "elif"),
1005 expr: v,
1006 }
1007 case "ifeq", "ifneq", "elifeq", "elifneq":
1008 return &ifNode{
1009 isElif: strings.HasPrefix(check.Name, "elif"),
1010 expr: ctx.parseCompare(check),
1011 }
1012 case "else":
1013 return &elseNode{}
1014 default:
1015 panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
1016 }
1017}
1018
1019func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
1020 message := fmt.Sprintf(text, args...)
1021 if ctx.errorLogger != nil {
1022 ctx.errorLogger.NewError(text, node, args)
1023 }
1024 ctx.script.hasErrors = true
1025 return &badExpr{node, message}
1026}
1027
1028func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
1029 // Strip outer parentheses
1030 mkArg := cloneMakeString(cond.Args)
1031 mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
1032 n := len(mkArg.Strings)
1033 mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
1034 args := mkArg.Split(",")
1035 // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
1036 if len(args) != 2 {
1037 return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
1038 }
1039 args[0].TrimRightSpaces()
1040 args[1].TrimLeftSpaces()
1041
1042 isEq := !strings.HasSuffix(cond.Name, "neq")
1043 switch xLeft := ctx.parseMakeString(cond, args[0]).(type) {
1044 case *stringLiteralExpr, *variableRefExpr:
1045 switch xRight := ctx.parseMakeString(cond, args[1]).(type) {
1046 case *stringLiteralExpr, *variableRefExpr:
1047 return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
1048 case *badExpr:
1049 return xRight
1050 default:
1051 expr, ok := ctx.parseCheckFunctionCallResult(cond, xLeft, args[1])
1052 if ok {
1053 return expr
1054 }
1055 return ctx.newBadExpr(cond, "right operand is too complex: %s", args[1].Dump())
1056 }
1057 case *badExpr:
1058 return xLeft
1059 default:
1060 switch xRight := ctx.parseMakeString(cond, args[1]).(type) {
1061 case *stringLiteralExpr, *variableRefExpr:
1062 expr, ok := ctx.parseCheckFunctionCallResult(cond, xRight, args[0])
1063 if ok {
1064 return expr
1065 }
1066 return ctx.newBadExpr(cond, "left operand is too complex: %s", args[0].Dump())
1067 case *badExpr:
1068 return xRight
1069 default:
1070 return ctx.newBadExpr(cond, "operands are too complex: (%s,%s)", args[0].Dump(), args[1].Dump())
1071 }
1072 }
1073}
1074
1075func (ctx *parseContext) parseCheckFunctionCallResult(directive *mkparser.Directive, xValue starlarkExpr,
1076 varArg *mkparser.MakeString) (starlarkExpr, bool) {
1077 mkSingleVar, ok := varArg.SingleVariable()
1078 if !ok {
1079 return nil, false
1080 }
1081 expr := ctx.parseReference(directive, mkSingleVar)
1082 negate := strings.HasSuffix(directive.Name, "neq")
1083 checkIsSomethingFunction := func(xCall *callExpr) starlarkExpr {
1084 s, ok := maybeString(xValue)
1085 if !ok || s != "true" {
1086 return ctx.newBadExpr(directive,
1087 fmt.Sprintf("the result of %s can be compared only to 'true'", xCall.name))
1088 }
1089 if len(xCall.args) < 1 {
1090 return ctx.newBadExpr(directive, "%s requires an argument", xCall.name)
1091 }
1092 return nil
1093 }
1094 switch x := expr.(type) {
1095 case *callExpr:
1096 switch x.name {
1097 case "filter":
1098 return ctx.parseCompareFilterFuncResult(directive, x, xValue, !negate), true
1099 case "filter-out":
1100 return ctx.parseCompareFilterFuncResult(directive, x, xValue, negate), true
1101 case "wildcard":
1102 return ctx.parseCompareWildcardFuncResult(directive, x, xValue, negate), true
1103 case "findstring":
1104 return ctx.parseCheckFindstringFuncResult(directive, x, xValue, negate), true
1105 case "strip":
1106 return ctx.parseCompareStripFuncResult(directive, x, xValue, negate), true
1107 case "is-board-platform":
1108 if xBad := checkIsSomethingFunction(x); xBad != nil {
1109 return xBad, true
1110 }
1111 return &eqExpr{
1112 left: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1113 right: x.args[0],
1114 isEq: !negate,
1115 }, true
1116 case "is-board-platform-in-list":
1117 if xBad := checkIsSomethingFunction(x); xBad != nil {
1118 return xBad, true
1119 }
1120 return &inExpr{
1121 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1122 list: maybeConvertToStringList(x.args[0]),
1123 isNot: negate,
1124 }, true
1125 case "is-product-in-list":
1126 if xBad := checkIsSomethingFunction(x); xBad != nil {
1127 return xBad, true
1128 }
1129 return &inExpr{
1130 expr: &variableRefExpr{ctx.addVariable("TARGET_PRODUCT"), true},
1131 list: maybeConvertToStringList(x.args[0]),
1132 isNot: negate,
1133 }, true
1134 case "is-vendor-board-platform":
1135 if xBad := checkIsSomethingFunction(x); xBad != nil {
1136 return xBad, true
1137 }
1138 s, ok := maybeString(x.args[0])
1139 if !ok {
1140 return ctx.newBadExpr(directive, "cannot handle non-constant argument to is-vendor-board-platform"), true
1141 }
1142 return &inExpr{
1143 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1144 list: &variableRefExpr{ctx.addVariable(s + "_BOARD_PLATFORMS"), true},
1145 isNot: negate,
1146 }, true
Sasha Smundak3a9b8e82021-08-25 14:11:04 -07001147
1148 case "is-board-platform2", "is-board-platform-in-list2":
1149 if s, ok := maybeString(xValue); !ok || s != "" {
1150 return ctx.newBadExpr(directive,
1151 fmt.Sprintf("the result of %s can be compared only to empty", x.name)), true
1152 }
1153 if len(x.args) != 1 {
1154 return ctx.newBadExpr(directive, "%s requires an argument", x.name), true
1155 }
1156 cc := &callExpr{
1157 name: x.name,
1158 args: []starlarkExpr{x.args[0]},
1159 returnType: starlarkTypeBool,
1160 }
1161 if !negate {
1162 return &notExpr{cc}, true
1163 }
1164 return cc, true
1165 case "is-vendor-board-qcom":
1166 if s, ok := maybeString(xValue); !ok || s != "" {
1167 return ctx.newBadExpr(directive,
1168 fmt.Sprintf("the result of %s can be compared only to empty", x.name)), true
1169 }
1170 return &inExpr{
1171 expr: &variableRefExpr{ctx.addVariable("TARGET_BOARD_PLATFORM"), false},
1172 list: &variableRefExpr{ctx.addVariable("QCOM_BOARD_PLATFORMS"), true},
1173 isNot: negate,
1174 }, true
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001175 default:
1176 return ctx.newBadExpr(directive, "Unknown function in ifeq: %s", x.name), true
1177 }
1178 case *badExpr:
1179 return x, true
1180 default:
1181 return nil, false
1182 }
1183}
1184
1185func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
1186 filterFuncCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1187 // We handle:
Sasha Smundak0554d762021-07-08 18:26:12 -07001188 // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
1189 // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001190 // * ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...) becomes if VAR in/not in ["v1", "v2"]
1191 // TODO(Asmundak): check the last case works for filter-out, too.
1192 xPattern := filterFuncCall.args[0]
1193 xText := filterFuncCall.args[1]
1194 var xInList *stringLiteralExpr
Sasha Smundak0554d762021-07-08 18:26:12 -07001195 var expr starlarkExpr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001196 var ok bool
1197 switch x := xValue.(type) {
1198 case *stringLiteralExpr:
1199 if x.literal != "" {
1200 return ctx.newBadExpr(cond, "filter comparison to non-empty value: %s", xValue)
1201 }
1202 // Either pattern or text should be const, and the
1203 // non-const one should be varRefExpr
Sasha Smundak5f463be2021-09-15 18:43:36 -07001204 if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
Sasha Smundak0554d762021-07-08 18:26:12 -07001205 expr = xText
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001206 } else if xInList, ok = xText.(*stringLiteralExpr); ok {
Sasha Smundak0554d762021-07-08 18:26:12 -07001207 expr = xPattern
1208 } else {
Sasha Smundak5f463be2021-09-15 18:43:36 -07001209 expr = &callExpr{
Sasha Smundak0554d762021-07-08 18:26:12 -07001210 object: nil,
1211 name: filterFuncCall.name,
1212 args: filterFuncCall.args,
1213 returnType: starlarkTypeBool,
1214 }
Sasha Smundak5f463be2021-09-15 18:43:36 -07001215 if negate {
1216 expr = &notExpr{expr: expr}
1217 }
1218 return expr
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001219 }
1220 case *variableRefExpr:
1221 if v, ok := xPattern.(*variableRefExpr); ok {
1222 if xInList, ok = xText.(*stringLiteralExpr); ok && v.ref.name() == x.ref.name() {
1223 // ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...), flip negate,
1224 // it's the opposite to what is done when comparing to empty.
Sasha Smundak0554d762021-07-08 18:26:12 -07001225 expr = xPattern
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001226 negate = !negate
1227 }
1228 }
1229 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001230 if expr != nil && xInList != nil {
1231 slExpr := newStringListExpr(strings.Fields(xInList.literal))
1232 // Generate simpler code for the common cases:
1233 if expr.typ() == starlarkTypeList {
1234 if len(slExpr.items) == 1 {
1235 // Checking that a string belongs to list
1236 return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}
1237 } else {
1238 // TODO(asmundak):
1239 panic("TBD")
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001240 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001241 } else if len(slExpr.items) == 1 {
1242 return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}
1243 } else {
1244 return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001245 }
1246 }
1247 return ctx.newBadExpr(cond, "filter arguments are too complex: %s", cond.Dump())
1248}
1249
1250func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Directive,
1251 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001252 if !isEmptyString(xValue) {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001253 return ctx.newBadExpr(directive, "wildcard result can be compared only to empty: %s", xValue)
1254 }
1255 callFunc := wildcardExistsPhony
1256 if s, ok := xCall.args[0].(*stringLiteralExpr); ok && !strings.ContainsAny(s.literal, "*?{[") {
1257 callFunc = fileExistsPhony
1258 }
1259 var cc starlarkExpr = &callExpr{name: callFunc, args: xCall.args, returnType: starlarkTypeBool}
1260 if !negate {
1261 cc = &notExpr{cc}
1262 }
1263 return cc
1264}
1265
1266func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
1267 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
Sasha Smundak0554d762021-07-08 18:26:12 -07001268 if isEmptyString(xValue) {
1269 return &eqExpr{
1270 left: &callExpr{
1271 object: xCall.args[1],
1272 name: "find",
1273 args: []starlarkExpr{xCall.args[0]},
1274 returnType: starlarkTypeInt,
1275 },
1276 right: &intLiteralExpr{-1},
1277 isEq: !negate,
1278 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001279 }
Sasha Smundak0554d762021-07-08 18:26:12 -07001280 return ctx.newBadExpr(directive, "findstring result can be compared only to empty: %s", xValue)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001281}
1282
1283func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
1284 xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
1285 if _, ok := xValue.(*stringLiteralExpr); !ok {
1286 return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
1287 }
1288 return &eqExpr{
1289 left: &callExpr{
1290 name: "strip",
1291 args: xCall.args,
1292 returnType: starlarkTypeString,
1293 },
1294 right: xValue, isEq: !negate}
1295}
1296
1297// parses $(...), returning an expression
1298func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
1299 ref.TrimLeftSpaces()
1300 ref.TrimRightSpaces()
1301 refDump := ref.Dump()
1302
1303 // Handle only the case where the first (or only) word is constant
1304 words := ref.SplitN(" ", 2)
1305 if !words[0].Const() {
1306 return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
1307 }
1308
1309 // If it is a single word, it can be a simple variable
1310 // reference or a function call
1311 if len(words) == 1 {
1312 if isMakeControlFunc(refDump) || refDump == "shell" {
1313 return &callExpr{
1314 name: refDump,
1315 args: []starlarkExpr{&stringLiteralExpr{""}},
1316 returnType: starlarkTypeUnknown,
1317 }
1318 }
Sasha Smundak65b547e2021-09-17 15:35:41 -07001319 if strings.HasPrefix(refDump, soongNsPrefix) {
1320 // TODO (asmundak): if we find many, maybe handle them.
1321 return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced: %s", refDump)
1322 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001323 if v := ctx.addVariable(refDump); v != nil {
1324 return &variableRefExpr{v, ctx.lastAssignment(v.name()) != nil}
1325 }
1326 return ctx.newBadExpr(node, "unknown variable %s", refDump)
1327 }
1328
1329 expr := &callExpr{name: words[0].Dump(), returnType: starlarkTypeUnknown}
1330 args := words[1]
1331 args.TrimLeftSpaces()
1332 // Make control functions and shell need special treatment as everything
1333 // after the name is a single text argument
1334 if isMakeControlFunc(expr.name) || expr.name == "shell" {
1335 x := ctx.parseMakeString(node, args)
1336 if xBad, ok := x.(*badExpr); ok {
1337 return xBad
1338 }
1339 expr.args = []starlarkExpr{x}
1340 return expr
1341 }
1342 if expr.name == "call" {
1343 words = args.SplitN(",", 2)
1344 if words[0].Empty() || !words[0].Const() {
Sasha Smundakf2c9f8b2021-07-27 10:44:48 -07001345 return ctx.newBadExpr(node, "cannot handle %s", refDump)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001346 }
1347 expr.name = words[0].Dump()
1348 if len(words) < 2 {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001349 args = &mkparser.MakeString{}
1350 } else {
1351 args = words[1]
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001352 }
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001353 }
1354 if kf, found := knownFunctions[expr.name]; found {
1355 expr.returnType = kf.returnType
1356 } else {
1357 return ctx.newBadExpr(node, "cannot handle invoking %s", expr.name)
1358 }
1359 switch expr.name {
1360 case "word":
1361 return ctx.parseWordFunc(node, args)
Sasha Smundak16e07732021-07-23 11:38:23 -07001362 case "firstword", "lastword":
1363 return ctx.parseFirstOrLastwordFunc(node, expr.name, args)
Sasha Smundak6609ba72021-07-22 18:32:56 -07001364 case "my-dir":
1365 return &variableRefExpr{ctx.addVariable("LOCAL_PATH"), true}
Sasha Smundak94b41c72021-07-12 18:30:42 -07001366 case "subst", "patsubst":
1367 return ctx.parseSubstFunc(node, expr.name, args)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001368 default:
1369 for _, arg := range args.Split(",") {
1370 arg.TrimLeftSpaces()
1371 arg.TrimRightSpaces()
1372 x := ctx.parseMakeString(node, arg)
1373 if xBad, ok := x.(*badExpr); ok {
1374 return xBad
1375 }
1376 expr.args = append(expr.args, x)
1377 }
1378 }
1379 return expr
1380}
1381
Sasha Smundak94b41c72021-07-12 18:30:42 -07001382func (ctx *parseContext) parseSubstFunc(node mkparser.Node, fname string, args *mkparser.MakeString) starlarkExpr {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001383 words := args.Split(",")
1384 if len(words) != 3 {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001385 return ctx.newBadExpr(node, "%s function should have 3 arguments", fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001386 }
1387 if !words[0].Const() || !words[1].Const() {
Sasha Smundak94b41c72021-07-12 18:30:42 -07001388 return ctx.newBadExpr(node, "%s function's from and to arguments should be constant", fname)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001389 }
1390 from := words[0].Strings[0]
1391 to := words[1].Strings[0]
1392 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",
1401 args: []starlarkExpr{&stringLiteralExpr{from}, &stringLiteralExpr{to}},
1402 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 Smundak9d011ab2021-07-09 16:00:57 -07001407 args: []starlarkExpr{&stringLiteralExpr{from}, &stringLiteralExpr{to}, obj},
1408 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).
1479// Return true if we handled it.
1480func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) bool {
1481 handled := true
1482 switch x := node.(type) {
1483 case *mkparser.Comment:
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001484 ctx.maybeHandleAnnotation(x)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001485 ctx.insertComment("#" + x.Comment)
1486 case *mkparser.Assignment:
1487 ctx.handleAssignment(x)
1488 case *mkparser.Variable:
1489 ctx.handleVariable(x)
1490 case *mkparser.Directive:
1491 switch x.Name {
1492 case "define":
1493 ctx.handleDefine(x)
1494 case "include", "-include":
1495 ctx.handleInclude(node, ctx.parseMakeString(node, x.Args), x.Name[0] != '-')
1496 default:
1497 handled = false
1498 }
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 }
1502 return handled
1503}
1504
Sasha Smundak6d852dd2021-09-27 20:34:39 -07001505// Processes annotation. An annotation is a comment that starts with #RBC# and provides
1506// a conversion hint -- say, where to look for the dynamically calculated inherit/include
1507// paths.
1508func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) {
1509 maybeTrim := func(s, prefix string) (string, bool) {
1510 if strings.HasPrefix(s, prefix) {
1511 return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
1512 }
1513 return s, false
1514 }
1515 annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
1516 if !ok {
1517 return
1518 }
1519 if p, ok := maybeTrim(annotation, "include_top"); ok {
1520 ctx.includeTops = append(ctx.includeTops, p)
1521 return
1522 }
1523 ctx.errorf(cnode, "unsupported annotation %s", cnode.Comment)
1524
1525}
1526
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001527func (ctx *parseContext) insertComment(s string) {
1528 ctx.receiver.newNode(&commentNode{strings.TrimSpace(s)})
1529}
1530
1531func (ctx *parseContext) carryAsComment(failedNode mkparser.Node) {
1532 for _, line := range strings.Split(failedNode.Dump(), "\n") {
1533 ctx.insertComment("# " + line)
1534 }
1535}
1536
1537// records that the given node failed to be converted and includes an explanatory message
1538func (ctx *parseContext) errorf(failedNode mkparser.Node, message string, args ...interface{}) {
1539 if ctx.errorLogger != nil {
1540 ctx.errorLogger.NewError(message, failedNode, args...)
1541 }
1542 message = fmt.Sprintf(message, args...)
1543 ctx.insertComment(fmt.Sprintf("# MK2RBC TRANSLATION ERROR: %s", message))
1544 ctx.carryAsComment(failedNode)
1545 ctx.script.hasErrors = true
1546}
1547
1548func (ctx *parseContext) wrapBadExpr(xBad *badExpr) {
1549 ctx.insertComment(fmt.Sprintf("# MK2RBC TRANSLATION ERROR: %s", xBad.message))
1550 ctx.carryAsComment(xBad.node)
1551}
1552
1553func (ctx *parseContext) loadedModulePath(path string) string {
1554 // During the transition to Roboleaf some of the product configuration files
1555 // will be converted and checked in while the others will be generated on the fly
1556 // and run. The runner (rbcrun application) accommodates this by allowing three
1557 // different ways to specify the loaded file location:
1558 // 1) load(":<file>",...) loads <file> from the same directory
1559 // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
1560 // 3) load("/absolute/path/to/<file> absolute path
1561 // If the file being generated and the file it wants to load are in the same directory,
1562 // generate option 1.
1563 // Otherwise, if output directory is not specified, generate 2)
1564 // Finally, if output directory has been specified and the file being generated and
1565 // the file it wants to load from are in the different directories, generate 2) or 3):
1566 // * if the file being loaded exists in the source tree, generate 2)
1567 // * otherwise, generate 3)
1568 // Finally, figure out the loaded module path and name and create a node for it
1569 loadedModuleDir := filepath.Dir(path)
1570 base := filepath.Base(path)
1571 loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
1572 if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
1573 return ":" + loadedModuleName
1574 }
1575 if ctx.outputDir == "" {
1576 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1577 }
1578 if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
1579 return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
1580 }
1581 return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
1582}
1583
Sasha Smundak3deb9682021-07-26 18:42:25 -07001584func (ctx *parseContext) addSoongNamespace(ns string) {
1585 if _, ok := ctx.soongNamespaces[ns]; ok {
1586 return
1587 }
1588 ctx.soongNamespaces[ns] = make(map[string]bool)
1589}
1590
1591func (ctx *parseContext) hasSoongNamespace(name string) bool {
1592 _, ok := ctx.soongNamespaces[name]
1593 return ok
1594}
1595
1596func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
1597 ctx.addSoongNamespace(namespaceName)
1598 vars := ctx.soongNamespaces[namespaceName]
1599 if replace {
1600 vars = make(map[string]bool)
1601 ctx.soongNamespaces[namespaceName] = vars
1602 }
1603 for _, v := range varNames {
1604 vars[v] = true
1605 }
1606}
1607
1608func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
1609 vars, ok := ctx.soongNamespaces[namespaceName]
1610 if ok {
1611 _, ok = vars[varName]
1612 }
1613 return ok
1614}
1615
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001616func (ss *StarlarkScript) String() string {
1617 return NewGenerateContext(ss).emit()
1618}
1619
1620func (ss *StarlarkScript) SubConfigFiles() []string {
Sasha Smundak6609ba72021-07-22 18:32:56 -07001621
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001622 var subs []string
1623 for _, src := range ss.inherited {
1624 subs = append(subs, src.originalPath)
1625 }
1626 return subs
1627}
1628
1629func (ss *StarlarkScript) HasErrors() bool {
1630 return ss.hasErrors
1631}
1632
1633// Convert reads and parses a makefile. If successful, parsed tree
1634// is returned and then can be passed to String() to get the generated
1635// Starlark file.
1636func Convert(req Request) (*StarlarkScript, error) {
1637 reader := req.Reader
1638 if reader == nil {
1639 mkContents, err := ioutil.ReadFile(req.MkFile)
1640 if err != nil {
1641 return nil, err
1642 }
1643 reader = bytes.NewBuffer(mkContents)
1644 }
1645 parser := mkparser.NewParser(req.MkFile, reader)
1646 nodes, errs := parser.Parse()
1647 if len(errs) > 0 {
1648 for _, e := range errs {
1649 fmt.Fprintln(os.Stderr, "ERROR:", e)
1650 }
1651 return nil, fmt.Errorf("bad makefile %s", req.MkFile)
1652 }
1653 starScript := &StarlarkScript{
1654 moduleName: moduleNameForFile(req.MkFile),
1655 mkFile: req.MkFile,
1656 topDir: req.RootDir,
1657 traceCalls: req.TraceCalls,
1658 warnPartialSuccess: req.WarnPartialSuccess,
Sasha Smundak6609ba72021-07-22 18:32:56 -07001659 sourceFS: req.SourceFS,
1660 makefileFinder: req.MakefileFinder,
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001661 }
1662 ctx := newParseContext(starScript, nodes)
1663 ctx.outputSuffix = req.OutputSuffix
1664 ctx.outputDir = req.OutputDir
1665 ctx.errorLogger = req.ErrorLogger
1666 if len(req.TracedVariables) > 0 {
1667 ctx.tracedVariables = make(map[string]bool)
1668 for _, v := range req.TracedVariables {
1669 ctx.tracedVariables[v] = true
1670 }
1671 }
1672 ctx.pushReceiver(starScript)
1673 for ctx.hasNodes() && ctx.fatalError == nil {
1674 node := ctx.getNode()
1675 if ctx.handleSimpleStatement(node) {
1676 continue
1677 }
1678 switch x := node.(type) {
1679 case *mkparser.Directive:
1680 switch x.Name {
1681 case "ifeq", "ifneq", "ifdef", "ifndef":
1682 ctx.handleIfBlock(x)
1683 default:
1684 ctx.errorf(x, "unexpected directive %s", x.Name)
1685 }
1686 default:
1687 ctx.errorf(x, "unsupported line")
1688 }
1689 }
1690 if ctx.fatalError != nil {
1691 return nil, ctx.fatalError
1692 }
1693 return starScript, nil
1694}
1695
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001696func Launcher(mainModuleUri, versionDefaultsUri, mainModuleName string) string {
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001697 var buf bytes.Buffer
1698 fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
Sasha Smundakd7d07ad2021-09-10 15:42:34 -07001699 fmt.Fprintf(&buf, "load(%q, \"version_defaults\")\n", versionDefaultsUri)
1700 fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
1701 fmt.Fprintf(&buf, "%s(%s(%q, init, version_defaults))\n", cfnPrintVars, cfnMain, mainModuleName)
Sasha Smundakb051c4e2020-11-05 20:45:07 -08001702 return buf.String()
1703}
1704
1705func MakePath2ModuleName(mkPath string) string {
1706 return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
1707}