Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1 | // 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 | // |
| 24 | package mk2rbc |
| 25 | |
| 26 | import ( |
| 27 | "bytes" |
| 28 | "fmt" |
| 29 | "io" |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 30 | "io/fs" |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 31 | "io/ioutil" |
| 32 | "os" |
| 33 | "path/filepath" |
| 34 | "regexp" |
Cole Faust | 62e0511 | 2022-04-05 17:56:11 -0700 | [diff] [blame] | 35 | "sort" |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 36 | "strconv" |
| 37 | "strings" |
| 38 | "text/scanner" |
| 39 | |
| 40 | mkparser "android/soong/androidmk/parser" |
| 41 | ) |
| 42 | |
| 43 | const ( |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 44 | annotationCommentPrefix = "RBC#" |
| 45 | baseUri = "//build/make/core:product_config.rbc" |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 46 | // The name of the struct exported by the product_config.rbc |
| 47 | // that contains the functions and variables available to |
| 48 | // product configuration Starlark files. |
| 49 | baseName = "rblf" |
| 50 | |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 51 | soongNsPrefix = "SOONG_CONFIG_" |
| 52 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 53 | // And here are the functions and variables: |
Cole Faust | e2a3798 | 2022-03-09 16:00:17 -0800 | [diff] [blame] | 54 | cfnGetCfg = baseName + ".cfg" |
| 55 | cfnMain = baseName + ".product_configuration" |
| 56 | cfnBoardMain = baseName + ".board_configuration" |
| 57 | cfnPrintVars = baseName + ".printvars" |
| 58 | cfnInherit = baseName + ".inherit" |
| 59 | cfnSetListDefault = baseName + ".setdefault" |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 60 | ) |
| 61 | |
| 62 | const ( |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 63 | soongConfigAppend = "soong_config_append" |
| 64 | soongConfigAssign = "soong_config_set" |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 65 | ) |
| 66 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 67 | var knownFunctions = map[string]interface { |
| 68 | parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 69 | }{ |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 70 | "abspath": &simpleCallParser{name: baseName + ".abspath", returnType: starlarkTypeString}, |
| 71 | "add-product-dex-preopt-module-config": &simpleCallParser{name: baseName + ".add_product_dex_preopt_module_config", returnType: starlarkTypeString, addHandle: true}, |
| 72 | "add_soong_config_namespace": &simpleCallParser{name: baseName + ".soong_config_namespace", returnType: starlarkTypeVoid, addGlobals: true}, |
| 73 | "add_soong_config_var_value": &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true}, |
| 74 | soongConfigAssign: &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true}, |
| 75 | soongConfigAppend: &simpleCallParser{name: baseName + ".soong_config_append", returnType: starlarkTypeVoid, addGlobals: true}, |
| 76 | "soong_config_get": &simpleCallParser{name: baseName + ".soong_config_get", returnType: starlarkTypeString, addGlobals: true}, |
| 77 | "add-to-product-copy-files-if-exists": &simpleCallParser{name: baseName + ".copy_if_exists", returnType: starlarkTypeList}, |
| 78 | "addprefix": &simpleCallParser{name: baseName + ".addprefix", returnType: starlarkTypeList}, |
| 79 | "addsuffix": &simpleCallParser{name: baseName + ".addsuffix", returnType: starlarkTypeList}, |
| 80 | "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList}, |
Cole Faust | 0e2b256 | 2022-04-01 11:46:50 -0700 | [diff] [blame] | 81 | "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeString}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 82 | "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true}, |
Cole Faust | 6c41b8a | 2022-04-13 13:53:48 -0700 | [diff] [blame] | 83 | "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addHandle: true}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 84 | "error": &makeControlFuncParser{name: baseName + ".mkerror"}, |
| 85 | "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt}, |
| 86 | "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList}, |
| 87 | "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList}, |
| 88 | "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList}, |
Cole Faust | 5a13aaf | 2022-04-27 17:49:35 -0700 | [diff] [blame] | 89 | "firstword": &simpleCallParser{name: baseName + ".first_word", returnType: starlarkTypeString}, |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 90 | "foreach": &foreachCallParser{}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 91 | "if": &ifCallParser{}, |
| 92 | "info": &makeControlFuncParser{name: baseName + ".mkinfo"}, |
| 93 | "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true}, |
| 94 | "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true}, |
| 95 | "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true}, |
| 96 | "is-board-platform-in-list2": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true}, |
| 97 | "is-product-in-list": &isProductInListCallParser{}, |
| 98 | "is-vendor-board-platform": &isVendorBoardPlatformCallParser{}, |
| 99 | "is-vendor-board-qcom": &isVendorBoardQcomCallParser{}, |
Cole Faust | 5a13aaf | 2022-04-27 17:49:35 -0700 | [diff] [blame] | 100 | "lastword": &simpleCallParser{name: baseName + ".last_word", returnType: starlarkTypeString}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 101 | "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString}, |
| 102 | "math_max": &mathMaxOrMinCallParser{function: "max"}, |
| 103 | "math_min": &mathMaxOrMinCallParser{function: "min"}, |
| 104 | "math_gt_or_eq": &mathComparisonCallParser{op: ">="}, |
| 105 | "math_gt": &mathComparisonCallParser{op: ">"}, |
| 106 | "math_lt": &mathComparisonCallParser{op: "<"}, |
| 107 | "my-dir": &myDirCallParser{}, |
| 108 | "patsubst": &substCallParser{fname: "patsubst"}, |
| 109 | "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList}, |
Cole Faust | ea9db58 | 2022-03-21 17:50:05 -0700 | [diff] [blame] | 110 | "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addHandle: true}, |
| 111 | "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addHandle: true}, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 112 | // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002 |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 113 | "shell": &shellCallParser{}, |
Cole Faust | 95b95cb | 2022-04-05 16:37:39 -0700 | [diff] [blame] | 114 | "sort": &simpleCallParser{name: baseName + ".mksort", returnType: starlarkTypeList}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 115 | "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString}, |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 116 | "subst": &substCallParser{fname: "subst"}, |
| 117 | "warning": &makeControlFuncParser{name: baseName + ".mkwarning"}, |
| 118 | "word": &wordCallParser{}, |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 119 | "words": &wordsCallParser{}, |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 120 | "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList}, |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 121 | } |
| 122 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 123 | // The same as knownFunctions, but returns a []starlarkNode instead of a starlarkExpr |
| 124 | var knownNodeFunctions = map[string]interface { |
| 125 | parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode |
| 126 | }{ |
| 127 | "eval": &evalNodeParser{}, |
| 128 | "if": &ifCallNodeParser{}, |
| 129 | "inherit-product": &inheritProductCallParser{loadAlways: true}, |
| 130 | "inherit-product-if-exists": &inheritProductCallParser{loadAlways: false}, |
| 131 | "foreach": &foreachCallNodeParser{}, |
| 132 | } |
| 133 | |
Cole Faust | 1e27586 | 2022-04-26 14:28:04 -0700 | [diff] [blame] | 134 | // These look like variables, but are actually functions, and would give |
| 135 | // undefined variable errors if we converted them as variables. Instead, |
| 136 | // emit an error instead of converting them. |
| 137 | var unsupportedFunctions = map[string]bool{ |
| 138 | "local-generated-sources-dir": true, |
| 139 | "local-intermediates-dir": true, |
| 140 | } |
| 141 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 142 | // These are functions that we don't implement conversions for, but |
| 143 | // we allow seeing their definitions in the product config files. |
| 144 | var ignoredDefines = map[string]bool{ |
| 145 | "find-word-in-list": true, // internal macro |
| 146 | "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc. |
| 147 | "is-android-codename": true, // unused by product config |
| 148 | "is-android-codename-in-list": true, // unused by product config |
| 149 | "is-chipset-in-board-platform": true, // unused by product config |
| 150 | "is-chipset-prefix-in-board-platform": true, // unused by product config |
| 151 | "is-not-board-platform": true, // defined but never used |
| 152 | "is-platform-sdk-version-at-least": true, // unused by product config |
| 153 | "match-prefix": true, // internal macro |
| 154 | "match-word": true, // internal macro |
| 155 | "match-word-in-list": true, // internal macro |
| 156 | "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 157 | } |
| 158 | |
Cole Faust | b0d32ab | 2021-12-09 14:00:59 -0800 | [diff] [blame] | 159 | var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$") |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 160 | |
| 161 | // Conversion request parameters |
| 162 | type Request struct { |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 163 | MkFile string // file to convert |
| 164 | Reader io.Reader // if set, read input from this stream instead |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 165 | OutputSuffix string // generated Starlark files suffix |
| 166 | OutputDir string // if set, root of the output hierarchy |
| 167 | ErrorLogger ErrorLogger |
| 168 | TracedVariables []string // trace assignment to these variables |
| 169 | TraceCalls bool |
| 170 | SourceFS fs.FS |
| 171 | MakefileFinder MakefileFinder |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 172 | } |
| 173 | |
Sasha Smundak | 7d934b9 | 2021-11-10 12:20:01 -0800 | [diff] [blame] | 174 | // ErrorLogger prints errors and gathers error statistics. |
| 175 | // Its NewError function is called on every error encountered during the conversion. |
| 176 | type ErrorLogger interface { |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 177 | NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{}) |
| 178 | } |
| 179 | |
| 180 | type ErrorLocation struct { |
| 181 | MkFile string |
| 182 | MkLine int |
| 183 | } |
| 184 | |
| 185 | func (el ErrorLocation) String() string { |
| 186 | return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | // Derives module name for a given file. It is base name |
| 190 | // (file name without suffix), with some characters replaced to make it a Starlark identifier |
| 191 | func moduleNameForFile(mkFile string) string { |
| 192 | base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile)) |
| 193 | // TODO(asmundak): what else can be in the product file names? |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 194 | return strings.NewReplacer("-", "_", ".", "_").Replace(base) |
| 195 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString { |
| 199 | r := &mkparser.MakeString{StringPos: mkString.StringPos} |
| 200 | r.Strings = append(r.Strings, mkString.Strings...) |
| 201 | r.Variables = append(r.Variables, mkString.Variables...) |
| 202 | return r |
| 203 | } |
| 204 | |
| 205 | func isMakeControlFunc(s string) bool { |
| 206 | return s == "error" || s == "warning" || s == "info" |
| 207 | } |
| 208 | |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 209 | // varAssignmentScope points to the last assignment for each variable |
| 210 | // in the current block. It is used during the parsing to chain |
| 211 | // the assignments to a variable together. |
| 212 | type varAssignmentScope struct { |
| 213 | outer *varAssignmentScope |
| 214 | vars map[string]bool |
| 215 | } |
| 216 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 217 | // Starlark output generation context |
| 218 | type generationContext struct { |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 219 | buf strings.Builder |
| 220 | starScript *StarlarkScript |
| 221 | indentLevel int |
| 222 | inAssignment bool |
| 223 | tracedCount int |
| 224 | varAssignments *varAssignmentScope |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | func NewGenerateContext(ss *StarlarkScript) *generationContext { |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 228 | return &generationContext{ |
| 229 | starScript: ss, |
| 230 | varAssignments: &varAssignmentScope{ |
| 231 | outer: nil, |
| 232 | vars: make(map[string]bool), |
| 233 | }, |
| 234 | } |
| 235 | } |
| 236 | |
| 237 | func (gctx *generationContext) pushVariableAssignments() { |
| 238 | va := &varAssignmentScope{ |
| 239 | outer: gctx.varAssignments, |
| 240 | vars: make(map[string]bool), |
| 241 | } |
| 242 | gctx.varAssignments = va |
| 243 | } |
| 244 | |
| 245 | func (gctx *generationContext) popVariableAssignments() { |
| 246 | gctx.varAssignments = gctx.varAssignments.outer |
| 247 | } |
| 248 | |
| 249 | func (gctx *generationContext) hasBeenAssigned(v variable) bool { |
| 250 | for va := gctx.varAssignments; va != nil; va = va.outer { |
| 251 | if _, ok := va.vars[v.name()]; ok { |
| 252 | return true |
| 253 | } |
| 254 | } |
| 255 | return false |
| 256 | } |
| 257 | |
| 258 | func (gctx *generationContext) setHasBeenAssigned(v variable) { |
| 259 | gctx.varAssignments.vars[v.name()] = true |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | // emit returns generated script |
| 263 | func (gctx *generationContext) emit() string { |
| 264 | ss := gctx.starScript |
| 265 | |
| 266 | // The emitted code has the following layout: |
| 267 | // <initial comments> |
| 268 | // preamble, i.e., |
| 269 | // load statement for the runtime support |
| 270 | // load statement for each unique submodule pulled in by this one |
| 271 | // def init(g, handle): |
| 272 | // cfg = rblf.cfg(handle) |
| 273 | // <statements> |
| 274 | // <warning if conversion was not clean> |
| 275 | |
| 276 | iNode := len(ss.nodes) |
| 277 | for i, node := range ss.nodes { |
| 278 | if _, ok := node.(*commentNode); !ok { |
| 279 | iNode = i |
| 280 | break |
| 281 | } |
| 282 | node.emit(gctx) |
| 283 | } |
| 284 | |
| 285 | gctx.emitPreamble() |
| 286 | |
| 287 | gctx.newLine() |
| 288 | // The arguments passed to the init function are the global dictionary |
| 289 | // ('g') and the product configuration dictionary ('cfg') |
| 290 | gctx.write("def init(g, handle):") |
| 291 | gctx.indentLevel++ |
| 292 | if gctx.starScript.traceCalls { |
| 293 | gctx.newLine() |
| 294 | gctx.writef(`print(">%s")`, gctx.starScript.mkFile) |
| 295 | } |
| 296 | gctx.newLine() |
| 297 | gctx.writef("cfg = %s(handle)", cfnGetCfg) |
| 298 | for _, node := range ss.nodes[iNode:] { |
| 299 | node.emit(gctx) |
| 300 | } |
| 301 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 302 | if gctx.starScript.traceCalls { |
| 303 | gctx.newLine() |
| 304 | gctx.writef(`print("<%s")`, gctx.starScript.mkFile) |
| 305 | } |
| 306 | gctx.indentLevel-- |
| 307 | gctx.write("\n") |
| 308 | return gctx.buf.String() |
| 309 | } |
| 310 | |
| 311 | func (gctx *generationContext) emitPreamble() { |
| 312 | gctx.newLine() |
| 313 | gctx.writef("load(%q, %q)", baseUri, baseName) |
| 314 | // Emit exactly one load statement for each URI. |
| 315 | loadedSubConfigs := make(map[string]string) |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 316 | for _, mi := range gctx.starScript.inherited { |
| 317 | uri := mi.path |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 318 | if m, ok := loadedSubConfigs[uri]; ok { |
| 319 | // No need to emit load statement, but fix module name. |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 320 | mi.moduleLocalName = m |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 321 | continue |
| 322 | } |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 323 | if mi.optional || mi.missing { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 324 | uri += "|init" |
| 325 | } |
| 326 | gctx.newLine() |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 327 | gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName()) |
| 328 | loadedSubConfigs[uri] = mi.moduleLocalName |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 329 | } |
| 330 | gctx.write("\n") |
| 331 | } |
| 332 | |
| 333 | func (gctx *generationContext) emitPass() { |
| 334 | gctx.newLine() |
| 335 | gctx.write("pass") |
| 336 | } |
| 337 | |
| 338 | func (gctx *generationContext) write(ss ...string) { |
| 339 | for _, s := range ss { |
| 340 | gctx.buf.WriteString(s) |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | func (gctx *generationContext) writef(format string, args ...interface{}) { |
| 345 | gctx.write(fmt.Sprintf(format, args...)) |
| 346 | } |
| 347 | |
| 348 | func (gctx *generationContext) newLine() { |
| 349 | if gctx.buf.Len() == 0 { |
| 350 | return |
| 351 | } |
| 352 | gctx.write("\n") |
| 353 | gctx.writef("%*s", 2*gctx.indentLevel, "") |
| 354 | } |
| 355 | |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 356 | func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) { |
| 357 | gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message) |
| 358 | } |
| 359 | |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 360 | func (gctx *generationContext) emitLoadCheck(im inheritedModule) { |
| 361 | if !im.needsLoadCheck() { |
| 362 | return |
| 363 | } |
| 364 | gctx.newLine() |
| 365 | gctx.writef("if not %s:", im.entryName()) |
| 366 | gctx.indentLevel++ |
| 367 | gctx.newLine() |
| 368 | gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`) |
| 369 | im.pathExpr().emit(gctx) |
| 370 | gctx.write("))") |
| 371 | gctx.indentLevel-- |
| 372 | } |
| 373 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 374 | type knownVariable struct { |
| 375 | name string |
| 376 | class varClass |
| 377 | valueType starlarkType |
| 378 | } |
| 379 | |
| 380 | type knownVariables map[string]knownVariable |
| 381 | |
| 382 | func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) { |
| 383 | v, exists := pcv[name] |
| 384 | if !exists { |
| 385 | pcv[name] = knownVariable{name, varClass, valueType} |
| 386 | return |
| 387 | } |
| 388 | // Conflict resolution: |
| 389 | // * config class trumps everything |
| 390 | // * any type trumps unknown type |
| 391 | match := varClass == v.class |
| 392 | if !match { |
| 393 | if varClass == VarClassConfig { |
| 394 | v.class = VarClassConfig |
| 395 | match = true |
| 396 | } else if v.class == VarClassConfig { |
| 397 | match = true |
| 398 | } |
| 399 | } |
| 400 | if valueType != v.valueType { |
| 401 | if valueType != starlarkTypeUnknown { |
| 402 | if v.valueType == starlarkTypeUnknown { |
| 403 | v.valueType = valueType |
| 404 | } else { |
| 405 | match = false |
| 406 | } |
| 407 | } |
| 408 | } |
| 409 | if !match { |
| 410 | fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n", |
| 411 | name, varClass, valueType, v.class, v.valueType) |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | // All known product variables. |
| 416 | var KnownVariables = make(knownVariables) |
| 417 | |
| 418 | func init() { |
| 419 | for _, kv := range []string{ |
| 420 | // Kernel-related variables that we know are lists. |
| 421 | "BOARD_VENDOR_KERNEL_MODULES", |
| 422 | "BOARD_VENDOR_RAMDISK_KERNEL_MODULES", |
| 423 | "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD", |
| 424 | "BOARD_RECOVERY_KERNEL_MODULES", |
| 425 | // Other variables we knwo are lists |
| 426 | "ART_APEX_JARS", |
| 427 | } { |
| 428 | KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList) |
| 429 | } |
| 430 | } |
| 431 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 432 | // Information about the generated Starlark script. |
| 433 | type StarlarkScript struct { |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 434 | mkFile string |
| 435 | moduleName string |
| 436 | mkPos scanner.Position |
| 437 | nodes []starlarkNode |
| 438 | inherited []*moduleInfo |
| 439 | hasErrors bool |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 440 | traceCalls bool // print enter/exit each init function |
| 441 | sourceFS fs.FS |
| 442 | makefileFinder MakefileFinder |
| 443 | nodeLocator func(pos mkparser.Pos) int |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 444 | } |
| 445 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 446 | // parseContext holds the script we are generating and all the ephemeral data |
| 447 | // needed during the parsing. |
| 448 | type parseContext struct { |
| 449 | script *StarlarkScript |
| 450 | nodes []mkparser.Node // Makefile as parsed by mkparser |
| 451 | currentNodeIndex int // Node in it we are processing |
| 452 | ifNestLevel int |
| 453 | moduleNameCount map[string]int // count of imported modules with given basename |
| 454 | fatalError error |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 455 | outputSuffix string |
Sasha Smundak | 7d934b9 | 2021-11-10 12:20:01 -0800 | [diff] [blame] | 456 | errorLogger ErrorLogger |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 457 | tracedVariables map[string]bool // variables to be traced in the generated script |
| 458 | variables map[string]variable |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 459 | outputDir string |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 460 | dependentModules map[string]*moduleInfo |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 461 | soongNamespaces map[string]map[string]bool |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 462 | includeTops []string |
Cole Faust | f92c9f2 | 2022-03-14 14:35:50 -0700 | [diff] [blame] | 463 | typeHints map[string]starlarkType |
| 464 | atTopOfMakefile bool |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 465 | } |
| 466 | |
| 467 | func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext { |
| 468 | predefined := []struct{ name, value string }{ |
| 469 | {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")}, |
| 470 | {"LOCAL_PATH", filepath.Dir(ss.mkFile)}, |
Cole Faust | 5a13aaf | 2022-04-27 17:49:35 -0700 | [diff] [blame] | 471 | {"MAKEFILE_LIST", ss.mkFile}, |
Cole Faust | 9b6111a | 2022-02-02 15:38:33 -0800 | [diff] [blame] | 472 | {"TOPDIR", ""}, // TOPDIR is just set to an empty string in cleanbuild.mk and core.mk |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 473 | // TODO(asmundak): maybe read it from build/make/core/envsetup.mk? |
| 474 | {"TARGET_COPY_OUT_SYSTEM", "system"}, |
| 475 | {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"}, |
| 476 | {"TARGET_COPY_OUT_DATA", "data"}, |
| 477 | {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")}, |
| 478 | {"TARGET_COPY_OUT_OEM", "oem"}, |
| 479 | {"TARGET_COPY_OUT_RAMDISK", "ramdisk"}, |
| 480 | {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"}, |
| 481 | {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"}, |
| 482 | {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"}, |
| 483 | {"TARGET_COPY_OUT_ROOT", "root"}, |
| 484 | {"TARGET_COPY_OUT_RECOVERY", "recovery"}, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 485 | {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"}, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 486 | // TODO(asmundak): to process internal config files, we need the following variables: |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 487 | // TARGET_VENDOR |
| 488 | // target_base_product |
| 489 | // |
| 490 | |
| 491 | // the following utility variables are set in build/make/common/core.mk: |
| 492 | {"empty", ""}, |
| 493 | {"space", " "}, |
| 494 | {"comma", ","}, |
| 495 | {"newline", "\n"}, |
| 496 | {"pound", "#"}, |
| 497 | {"backslash", "\\"}, |
| 498 | } |
| 499 | ctx := &parseContext{ |
| 500 | script: ss, |
| 501 | nodes: nodes, |
| 502 | currentNodeIndex: 0, |
| 503 | ifNestLevel: 0, |
| 504 | moduleNameCount: make(map[string]int), |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 505 | variables: make(map[string]variable), |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 506 | dependentModules: make(map[string]*moduleInfo), |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 507 | soongNamespaces: make(map[string]map[string]bool), |
Cole Faust | 6c934f6 | 2022-01-06 15:51:12 -0800 | [diff] [blame] | 508 | includeTops: []string{}, |
Cole Faust | f92c9f2 | 2022-03-14 14:35:50 -0700 | [diff] [blame] | 509 | typeHints: make(map[string]starlarkType), |
| 510 | atTopOfMakefile: true, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 511 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 512 | for _, item := range predefined { |
| 513 | ctx.variables[item.name] = &predefinedVariable{ |
| 514 | baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString}, |
| 515 | value: &stringLiteralExpr{item.value}, |
| 516 | } |
| 517 | } |
| 518 | |
| 519 | return ctx |
| 520 | } |
| 521 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 522 | func (ctx *parseContext) hasNodes() bool { |
| 523 | return ctx.currentNodeIndex < len(ctx.nodes) |
| 524 | } |
| 525 | |
| 526 | func (ctx *parseContext) getNode() mkparser.Node { |
| 527 | if !ctx.hasNodes() { |
| 528 | return nil |
| 529 | } |
| 530 | node := ctx.nodes[ctx.currentNodeIndex] |
| 531 | ctx.currentNodeIndex++ |
| 532 | return node |
| 533 | } |
| 534 | |
| 535 | func (ctx *parseContext) backNode() { |
| 536 | if ctx.currentNodeIndex <= 0 { |
| 537 | panic("Cannot back off") |
| 538 | } |
| 539 | ctx.currentNodeIndex-- |
| 540 | } |
| 541 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 542 | func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) []starlarkNode { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 543 | // Handle only simple variables |
Cole Faust | 00afd4f | 2022-04-26 14:01:56 -0700 | [diff] [blame] | 544 | if !a.Name.Const() || a.Target != nil { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 545 | return []starlarkNode{ctx.newBadNode(a, "Only simple variables are handled")} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 546 | } |
| 547 | name := a.Name.Strings[0] |
Sasha Smundak | ea3bc3a | 2021-11-10 13:06:42 -0800 | [diff] [blame] | 548 | // The `override` directive |
| 549 | // override FOO := |
| 550 | // is parsed as an assignment to a variable named `override FOO`. |
| 551 | // There are very few places where `override` is used, just flag it. |
| 552 | if strings.HasPrefix(name, "override ") { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 553 | return []starlarkNode{ctx.newBadNode(a, "cannot handle override directive")} |
Sasha Smundak | ea3bc3a | 2021-11-10 13:06:42 -0800 | [diff] [blame] | 554 | } |
Cole Faust | 5d5fcc3 | 2022-04-26 18:02:05 -0700 | [diff] [blame] | 555 | if name == ".KATI_READONLY" { |
| 556 | // Skip assignments to .KATI_READONLY. If it was in the output file, it |
| 557 | // would be an error because it would be sorted before the definition of |
| 558 | // the variable it's trying to make readonly. |
| 559 | return []starlarkNode{} |
| 560 | } |
Sasha Smundak | ea3bc3a | 2021-11-10 13:06:42 -0800 | [diff] [blame] | 561 | |
Cole Faust | c00184e | 2021-11-08 12:08:57 -0800 | [diff] [blame] | 562 | // Soong configuration |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 563 | if strings.HasPrefix(name, soongNsPrefix) { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 564 | return ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a) |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 565 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 566 | lhs := ctx.addVariable(name) |
| 567 | if lhs == nil { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 568 | return []starlarkNode{ctx.newBadNode(a, "unknown variable %s", name)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 569 | } |
Cole Faust | 3c4fc99 | 2022-02-28 16:05:01 -0800 | [diff] [blame] | 570 | _, isTraced := ctx.tracedVariables[lhs.name()] |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 571 | asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 572 | if lhs.valueType() == starlarkTypeUnknown { |
| 573 | // Try to divine variable type from the RHS |
| 574 | asgn.value = ctx.parseMakeString(a, a.Value) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 575 | inferred_type := asgn.value.typ() |
| 576 | if inferred_type != starlarkTypeUnknown { |
Sasha Smundak | 9d011ab | 2021-07-09 16:00:57 -0700 | [diff] [blame] | 577 | lhs.setValueType(inferred_type) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 578 | } |
| 579 | } |
| 580 | if lhs.valueType() == starlarkTypeList { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 581 | xConcat, xBad := ctx.buildConcatExpr(a) |
| 582 | if xBad != nil { |
Cole Faust | 1e27586 | 2022-04-26 14:28:04 -0700 | [diff] [blame] | 583 | asgn.value = xBad |
| 584 | } else { |
| 585 | switch len(xConcat.items) { |
| 586 | case 0: |
| 587 | asgn.value = &listExpr{} |
| 588 | case 1: |
| 589 | asgn.value = xConcat.items[0] |
| 590 | default: |
| 591 | asgn.value = xConcat |
| 592 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 593 | } |
| 594 | } else { |
| 595 | asgn.value = ctx.parseMakeString(a, a.Value) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 596 | } |
| 597 | |
Cole Faust | 421a192 | 2022-03-16 14:35:45 -0700 | [diff] [blame] | 598 | if asgn.lhs.valueType() == starlarkTypeString && |
| 599 | asgn.value.typ() != starlarkTypeUnknown && |
| 600 | asgn.value.typ() != starlarkTypeString { |
| 601 | asgn.value = &toStringExpr{expr: asgn.value} |
| 602 | } |
| 603 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 604 | switch a.Type { |
| 605 | case "=", ":=": |
| 606 | asgn.flavor = asgnSet |
| 607 | case "+=": |
Cole Faust | e2a3798 | 2022-03-09 16:00:17 -0800 | [diff] [blame] | 608 | asgn.flavor = asgnAppend |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 609 | case "?=": |
| 610 | asgn.flavor = asgnMaybeSet |
| 611 | default: |
| 612 | panic(fmt.Errorf("unexpected assignment type %s", a.Type)) |
| 613 | } |
| 614 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 615 | return []starlarkNode{asgn} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 616 | } |
| 617 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 618 | func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) []starlarkNode { |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 619 | val := ctx.parseMakeString(asgn, asgn.Value) |
| 620 | if xBad, ok := val.(*badExpr); ok { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 621 | return []starlarkNode{&exprNode{expr: xBad}} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 622 | } |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 623 | |
| 624 | // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make |
| 625 | // variables instead of via add_soong_config_namespace + add_soong_config_var_value. |
| 626 | // Try to divine the call from the assignment as follows: |
| 627 | if name == "NAMESPACES" { |
| 628 | // Upon seeng |
| 629 | // SOONG_CONFIG_NAMESPACES += foo |
| 630 | // remember that there is a namespace `foo` and act as we saw |
| 631 | // $(call add_soong_config_namespace,foo) |
| 632 | s, ok := maybeString(val) |
| 633 | if !ok { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 634 | return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 635 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 636 | result := make([]starlarkNode, 0) |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 637 | for _, ns := range strings.Fields(s) { |
| 638 | ctx.addSoongNamespace(ns) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 639 | result = append(result, &exprNode{&callExpr{ |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 640 | name: baseName + ".soong_config_namespace", |
| 641 | args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}}, |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 642 | returnType: starlarkTypeVoid, |
| 643 | }}) |
| 644 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 645 | return result |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 646 | } else { |
| 647 | // Upon seeing |
| 648 | // SOONG_CONFIG_x_y = v |
| 649 | // find a namespace called `x` and act as if we encountered |
Cole Faust | c00184e | 2021-11-08 12:08:57 -0800 | [diff] [blame] | 650 | // $(call soong_config_set,x,y,v) |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 651 | // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in |
| 652 | // it. |
| 653 | // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz` |
| 654 | // and `foo` with a variable `bar_baz`. |
| 655 | namespaceName := "" |
| 656 | if ctx.hasSoongNamespace(name) { |
| 657 | namespaceName = name |
| 658 | } |
| 659 | var varName string |
| 660 | for pos, ch := range name { |
| 661 | if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) { |
| 662 | continue |
| 663 | } |
| 664 | if namespaceName != "" { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 665 | return []starlarkNode{ctx.newBadNode(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 666 | } |
| 667 | namespaceName = name[0:pos] |
| 668 | varName = name[pos+1:] |
| 669 | } |
| 670 | if namespaceName == "" { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 671 | return []starlarkNode{ctx.newBadNode(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 672 | } |
| 673 | if varName == "" { |
| 674 | // Remember variables in this namespace |
| 675 | s, ok := maybeString(val) |
| 676 | if !ok { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 677 | return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 678 | } |
| 679 | ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s)) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 680 | return []starlarkNode{} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 681 | } |
| 682 | |
| 683 | // Finally, handle assignment to a namespace variable |
| 684 | if !ctx.hasNamespaceVar(namespaceName, varName) { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 685 | return []starlarkNode{ctx.newBadNode(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 686 | } |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 687 | fname := baseName + "." + soongConfigAssign |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 688 | if asgn.Type == "+=" { |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 689 | fname = baseName + "." + soongConfigAppend |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 690 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 691 | return []starlarkNode{&exprNode{&callExpr{ |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 692 | name: fname, |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 693 | args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val}, |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 694 | returnType: starlarkTypeVoid, |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 695 | }}} |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 696 | } |
| 697 | } |
| 698 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 699 | func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) (*concatExpr, *badExpr) { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 700 | xConcat := &concatExpr{} |
| 701 | var xItemList *listExpr |
| 702 | addToItemList := func(x ...starlarkExpr) { |
| 703 | if xItemList == nil { |
| 704 | xItemList = &listExpr{[]starlarkExpr{}} |
| 705 | } |
| 706 | xItemList.items = append(xItemList.items, x...) |
| 707 | } |
| 708 | finishItemList := func() { |
| 709 | if xItemList != nil { |
| 710 | xConcat.items = append(xConcat.items, xItemList) |
| 711 | xItemList = nil |
| 712 | } |
| 713 | } |
| 714 | |
| 715 | items := a.Value.Words() |
| 716 | for _, item := range items { |
| 717 | // A function call in RHS is supposed to return a list, all other item |
| 718 | // expressions return individual elements. |
| 719 | switch x := ctx.parseMakeString(a, item).(type) { |
| 720 | case *badExpr: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 721 | return nil, x |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 722 | case *stringLiteralExpr: |
| 723 | addToItemList(maybeConvertToStringList(x).(*listExpr).items...) |
| 724 | default: |
| 725 | switch x.typ() { |
| 726 | case starlarkTypeList: |
| 727 | finishItemList() |
| 728 | xConcat.items = append(xConcat.items, x) |
| 729 | case starlarkTypeString: |
| 730 | finishItemList() |
| 731 | xConcat.items = append(xConcat.items, &callExpr{ |
| 732 | object: x, |
| 733 | name: "split", |
| 734 | args: nil, |
| 735 | returnType: starlarkTypeList, |
| 736 | }) |
| 737 | default: |
| 738 | addToItemList(x) |
| 739 | } |
| 740 | } |
| 741 | } |
| 742 | if xItemList != nil { |
| 743 | xConcat.items = append(xConcat.items, xItemList) |
| 744 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 745 | return xConcat, nil |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 746 | } |
| 747 | |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 748 | func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo { |
| 749 | modulePath := ctx.loadedModulePath(path) |
| 750 | if mi, ok := ctx.dependentModules[modulePath]; ok { |
Sasha Smundak | 868c5e3 | 2021-09-23 16:20:58 -0700 | [diff] [blame] | 751 | mi.optional = mi.optional && optional |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 752 | return mi |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 753 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 754 | moduleName := moduleNameForFile(path) |
| 755 | moduleLocalName := "_" + moduleName |
| 756 | n, found := ctx.moduleNameCount[moduleName] |
| 757 | if found { |
| 758 | moduleLocalName += fmt.Sprintf("%d", n) |
| 759 | } |
| 760 | ctx.moduleNameCount[moduleName] = n + 1 |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 761 | _, err := fs.Stat(ctx.script.sourceFS, path) |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 762 | mi := &moduleInfo{ |
| 763 | path: modulePath, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 764 | originalPath: path, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 765 | moduleLocalName: moduleLocalName, |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 766 | optional: optional, |
Sasha Smundak | 6bc132a | 2022-01-10 17:02:16 -0800 | [diff] [blame] | 767 | missing: err != nil, |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 768 | } |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 769 | ctx.dependentModules[modulePath] = mi |
| 770 | ctx.script.inherited = append(ctx.script.inherited, mi) |
| 771 | return mi |
| 772 | } |
| 773 | |
| 774 | func (ctx *parseContext) handleSubConfig( |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 775 | v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule) starlarkNode) []starlarkNode { |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 776 | |
Cole Faust | 62e0511 | 2022-04-05 17:56:11 -0700 | [diff] [blame] | 777 | // Allow seeing $(sort $(wildcard realPathExpr)) or $(wildcard realPathExpr) |
| 778 | // because those are functionally the same as not having the sort/wildcard calls. |
| 779 | if ce, ok := pathExpr.(*callExpr); ok && ce.name == "rblf.mksort" && len(ce.args) == 1 { |
| 780 | if ce2, ok2 := ce.args[0].(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 { |
| 781 | pathExpr = ce2.args[0] |
| 782 | } |
| 783 | } else if ce2, ok2 := pathExpr.(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 { |
| 784 | pathExpr = ce2.args[0] |
| 785 | } |
| 786 | |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 787 | // In a simple case, the name of a module to inherit/include is known statically. |
| 788 | if path, ok := maybeString(pathExpr); ok { |
Sasha Smundak | 868c5e3 | 2021-09-23 16:20:58 -0700 | [diff] [blame] | 789 | // Note that even if this directive loads a module unconditionally, a module may be |
| 790 | // absent without causing any harm if this directive is inside an if/else block. |
| 791 | moduleShouldExist := loadAlways && ctx.ifNestLevel == 0 |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 792 | if strings.Contains(path, "*") { |
| 793 | if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil { |
Cole Faust | 62e0511 | 2022-04-05 17:56:11 -0700 | [diff] [blame] | 794 | sort.Strings(paths) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 795 | result := make([]starlarkNode, 0) |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 796 | for _, p := range paths { |
Sasha Smundak | 868c5e3 | 2021-09-23 16:20:58 -0700 | [diff] [blame] | 797 | mi := ctx.newDependentModule(p, !moduleShouldExist) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 798 | result = append(result, processModule(inheritedStaticModule{mi, loadAlways})) |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 799 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 800 | return result |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 801 | } else { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 802 | return []starlarkNode{ctx.newBadNode(v, "cannot glob wildcard argument")} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 803 | } |
| 804 | } else { |
Sasha Smundak | 868c5e3 | 2021-09-23 16:20:58 -0700 | [diff] [blame] | 805 | mi := ctx.newDependentModule(path, !moduleShouldExist) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 806 | return []starlarkNode{processModule(inheritedStaticModule{mi, loadAlways})} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 807 | } |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 808 | } |
| 809 | |
| 810 | // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the |
| 811 | // source tree that may be a match and the corresponding variable values. For instance, if the source tree |
| 812 | // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when |
| 813 | // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def'). |
| 814 | // We then emit the code that loads all of them, e.g.: |
| 815 | // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init") |
| 816 | // load("//vendor2/foo/def/dev.rbc", _dev2_init="init") |
| 817 | // And then inherit it as follows: |
| 818 | // _e = { |
| 819 | // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init), |
| 820 | // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2)) |
| 821 | // if _e: |
| 822 | // rblf.inherit(handle, _e[0], _e[1]) |
| 823 | // |
| 824 | var matchingPaths []string |
Cole Faust | 9df1d73 | 2022-04-26 16:27:22 -0700 | [diff] [blame] | 825 | var needsWarning = false |
| 826 | if interpolate, ok := pathExpr.(*interpolateExpr); ok { |
| 827 | pathPattern := []string{interpolate.chunks[0]} |
| 828 | for _, chunk := range interpolate.chunks[1:] { |
| 829 | if chunk != "" { |
| 830 | pathPattern = append(pathPattern, chunk) |
| 831 | } |
| 832 | } |
| 833 | if pathPattern[0] == "" && len(ctx.includeTops) > 0 { |
| 834 | // If pattern starts from the top. restrict it to the directories where |
| 835 | // we know inherit-product uses dynamically calculated path. |
| 836 | for _, p := range ctx.includeTops { |
| 837 | pathPattern[0] = p |
| 838 | matchingPaths = append(matchingPaths, ctx.findMatchingPaths(pathPattern)...) |
| 839 | } |
| 840 | } else { |
| 841 | matchingPaths = ctx.findMatchingPaths(pathPattern) |
| 842 | } |
| 843 | needsWarning = pathPattern[0] == "" && len(ctx.includeTops) == 0 |
| 844 | } else if len(ctx.includeTops) > 0 { |
| 845 | for _, p := range ctx.includeTops { |
| 846 | matchingPaths = append(matchingPaths, ctx.findMatchingPaths([]string{p, ""})...) |
| 847 | } |
| 848 | } else { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 849 | return []starlarkNode{ctx.newBadNode(v, "inherit-product/include argument is too complex")} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 850 | } |
| 851 | |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 852 | // Safeguard against $(call inherit-product,$(PRODUCT_PATH)) |
Sasha Smundak | 90be8c5 | 2021-08-03 11:06:10 -0700 | [diff] [blame] | 853 | const maxMatchingFiles = 150 |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 854 | if len(matchingPaths) > maxMatchingFiles { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 855 | return []starlarkNode{ctx.newBadNode(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 856 | } |
Cole Faust | 93f8d39 | 2022-03-02 13:31:30 -0800 | [diff] [blame] | 857 | |
Cole Faust | 9df1d73 | 2022-04-26 16:27:22 -0700 | [diff] [blame] | 858 | res := inheritedDynamicModule{pathExpr, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning} |
Cole Faust | 93f8d39 | 2022-03-02 13:31:30 -0800 | [diff] [blame] | 859 | for _, p := range matchingPaths { |
| 860 | // A product configuration files discovered dynamically may attempt to inherit |
| 861 | // from another one which does not exist in this source tree. Prevent load errors |
| 862 | // by always loading the dynamic files as optional. |
| 863 | res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true)) |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 864 | } |
Cole Faust | 93f8d39 | 2022-03-02 13:31:30 -0800 | [diff] [blame] | 865 | return []starlarkNode{processModule(res)} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 866 | } |
| 867 | |
| 868 | func (ctx *parseContext) findMatchingPaths(pattern []string) []string { |
Cole Faust | 9b6111a | 2022-02-02 15:38:33 -0800 | [diff] [blame] | 869 | files := ctx.script.makefileFinder.Find(".") |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 870 | if len(pattern) == 0 { |
| 871 | return files |
| 872 | } |
| 873 | |
| 874 | // Create regular expression from the pattern |
| 875 | s_regexp := "^" + regexp.QuoteMeta(pattern[0]) |
| 876 | for _, s := range pattern[1:] { |
| 877 | s_regexp += ".*" + regexp.QuoteMeta(s) |
| 878 | } |
| 879 | s_regexp += "$" |
| 880 | rex := regexp.MustCompile(s_regexp) |
| 881 | |
| 882 | // Now match |
| 883 | var res []string |
| 884 | for _, p := range files { |
| 885 | if rex.MatchString(p) { |
| 886 | res = append(res, p) |
| 887 | } |
| 888 | } |
| 889 | return res |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 890 | } |
| 891 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 892 | type inheritProductCallParser struct { |
| 893 | loadAlways bool |
| 894 | } |
| 895 | |
| 896 | func (p *inheritProductCallParser) parse(ctx *parseContext, v mkparser.Node, args *mkparser.MakeString) []starlarkNode { |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 897 | args.TrimLeftSpaces() |
| 898 | args.TrimRightSpaces() |
| 899 | pathExpr := ctx.parseMakeString(v, args) |
| 900 | if _, ok := pathExpr.(*badExpr); ok { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 901 | return []starlarkNode{ctx.newBadNode(v, "Unable to parse argument to inherit")} |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 902 | } |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 903 | return ctx.handleSubConfig(v, pathExpr, p.loadAlways, func(im inheritedModule) starlarkNode { |
| 904 | return &inheritNode{im, p.loadAlways} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 905 | }) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 906 | } |
| 907 | |
Cole Faust | 2005298 | 2022-04-22 14:43:55 -0700 | [diff] [blame] | 908 | func (ctx *parseContext) handleInclude(v *mkparser.Directive) []starlarkNode { |
| 909 | loadAlways := v.Name[0] != '-' |
| 910 | return ctx.handleSubConfig(v, ctx.parseMakeString(v, v.Args), loadAlways, func(im inheritedModule) starlarkNode { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 911 | return &includeNode{im, loadAlways} |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 912 | }) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 913 | } |
| 914 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 915 | func (ctx *parseContext) handleVariable(v *mkparser.Variable) []starlarkNode { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 916 | // Handle: |
| 917 | // $(call inherit-product,...) |
| 918 | // $(call inherit-product-if-exists,...) |
| 919 | // $(info xxx) |
| 920 | // $(warning xxx) |
| 921 | // $(error xxx) |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 922 | // $(call other-custom-functions,...) |
| 923 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 924 | if name, args, ok := ctx.maybeParseFunctionCall(v, v.Name); ok { |
| 925 | if kf, ok := knownNodeFunctions[name]; ok { |
| 926 | return kf.parse(ctx, v, args) |
| 927 | } |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 928 | } |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 929 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 930 | return []starlarkNode{&exprNode{expr: ctx.parseReference(v, v.Name)}} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 931 | } |
| 932 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 933 | func (ctx *parseContext) maybeHandleDefine(directive *mkparser.Directive) starlarkNode { |
Sasha Smundak | f3e072a | 2021-07-14 12:50:28 -0700 | [diff] [blame] | 934 | macro_name := strings.Fields(directive.Args.Strings[0])[0] |
| 935 | // Ignore the macros that we handle |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 936 | _, ignored := ignoredDefines[macro_name] |
| 937 | _, known := knownFunctions[macro_name] |
| 938 | if !ignored && !known { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 939 | return ctx.newBadNode(directive, "define is not supported: %s", macro_name) |
Sasha Smundak | f3e072a | 2021-07-14 12:50:28 -0700 | [diff] [blame] | 940 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 941 | return nil |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 942 | } |
| 943 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 944 | func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) starlarkNode { |
| 945 | ssSwitch := &switchNode{ |
| 946 | ssCases: []*switchCase{ctx.processBranch(ifDirective)}, |
| 947 | } |
| 948 | for ctx.hasNodes() && ctx.fatalError == nil { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 949 | node := ctx.getNode() |
| 950 | switch x := node.(type) { |
| 951 | case *mkparser.Directive: |
| 952 | switch x.Name { |
| 953 | case "else", "elifdef", "elifndef", "elifeq", "elifneq": |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 954 | ssSwitch.ssCases = append(ssSwitch.ssCases, ctx.processBranch(x)) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 955 | case "endif": |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 956 | return ssSwitch |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 957 | default: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 958 | return ctx.newBadNode(node, "unexpected directive %s", x.Name) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 959 | } |
| 960 | default: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 961 | return ctx.newBadNode(ifDirective, "unexpected statement") |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 962 | } |
| 963 | } |
| 964 | if ctx.fatalError == nil { |
| 965 | ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump()) |
| 966 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 967 | return ctx.newBadNode(ifDirective, "no matching endif for %s", ifDirective.Dump()) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 968 | } |
| 969 | |
| 970 | // processBranch processes a single branch (if/elseif/else) until the next directive |
| 971 | // on the same level. |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 972 | func (ctx *parseContext) processBranch(check *mkparser.Directive) *switchCase { |
| 973 | block := &switchCase{gate: ctx.parseCondition(check)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 974 | defer func() { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 975 | ctx.ifNestLevel-- |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 976 | }() |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 977 | ctx.ifNestLevel++ |
| 978 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 979 | for ctx.hasNodes() { |
| 980 | node := ctx.getNode() |
Cole Faust | 591a1fe | 2021-11-08 15:37:57 -0800 | [diff] [blame] | 981 | if d, ok := node.(*mkparser.Directive); ok { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 982 | switch d.Name { |
| 983 | case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif": |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 984 | ctx.backNode() |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 985 | return block |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 986 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 987 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 988 | block.nodes = append(block.nodes, ctx.handleSimpleStatement(node)...) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 989 | } |
| 990 | ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump()) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 991 | return block |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 992 | } |
| 993 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 994 | func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode { |
| 995 | switch check.Name { |
| 996 | case "ifdef", "ifndef", "elifdef", "elifndef": |
Cole Faust | 71514c0 | 2022-01-27 17:21:41 -0800 | [diff] [blame] | 997 | if !check.Args.Const() { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 998 | return ctx.newBadNode(check, "ifdef variable ref too complex: %s", check.Args.Dump()) |
Cole Faust | 71514c0 | 2022-01-27 17:21:41 -0800 | [diff] [blame] | 999 | } |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1000 | v := NewVariableRefExpr(ctx.addVariable(check.Args.Strings[0])) |
Cole Faust | 71514c0 | 2022-01-27 17:21:41 -0800 | [diff] [blame] | 1001 | if strings.HasSuffix(check.Name, "ndef") { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1002 | v = ¬Expr{v} |
| 1003 | } |
| 1004 | return &ifNode{ |
| 1005 | isElif: strings.HasPrefix(check.Name, "elif"), |
| 1006 | expr: v, |
| 1007 | } |
| 1008 | case "ifeq", "ifneq", "elifeq", "elifneq": |
| 1009 | return &ifNode{ |
| 1010 | isElif: strings.HasPrefix(check.Name, "elif"), |
| 1011 | expr: ctx.parseCompare(check), |
| 1012 | } |
| 1013 | case "else": |
| 1014 | return &elseNode{} |
| 1015 | default: |
| 1016 | panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump())) |
| 1017 | } |
| 1018 | } |
| 1019 | |
| 1020 | func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1021 | if ctx.errorLogger != nil { |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 1022 | ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1023 | } |
| 1024 | ctx.script.hasErrors = true |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1025 | return &badExpr{errorLocation: ctx.errorLocation(node), message: fmt.Sprintf(text, args...)} |
| 1026 | } |
| 1027 | |
| 1028 | // records that the given node failed to be converted and includes an explanatory message |
| 1029 | func (ctx *parseContext) newBadNode(failedNode mkparser.Node, message string, args ...interface{}) starlarkNode { |
| 1030 | return &exprNode{ctx.newBadExpr(failedNode, message, args...)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1031 | } |
| 1032 | |
| 1033 | func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr { |
| 1034 | // Strip outer parentheses |
| 1035 | mkArg := cloneMakeString(cond.Args) |
| 1036 | mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ") |
| 1037 | n := len(mkArg.Strings) |
| 1038 | mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ") |
| 1039 | args := mkArg.Split(",") |
| 1040 | // TODO(asmundak): handle the case where the arguments are in quotes and space-separated |
| 1041 | if len(args) != 2 { |
| 1042 | return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump()) |
| 1043 | } |
| 1044 | args[0].TrimRightSpaces() |
| 1045 | args[1].TrimLeftSpaces() |
| 1046 | |
| 1047 | isEq := !strings.HasSuffix(cond.Name, "neq") |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1048 | xLeft := ctx.parseMakeString(cond, args[0]) |
| 1049 | xRight := ctx.parseMakeString(cond, args[1]) |
| 1050 | if bad, ok := xLeft.(*badExpr); ok { |
| 1051 | return bad |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1052 | } |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1053 | if bad, ok := xRight.(*badExpr); ok { |
| 1054 | return bad |
| 1055 | } |
| 1056 | |
| 1057 | if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok { |
| 1058 | return expr |
| 1059 | } |
| 1060 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1061 | var stringOperand string |
| 1062 | var otherOperand starlarkExpr |
| 1063 | if s, ok := maybeString(xLeft); ok { |
| 1064 | stringOperand = s |
| 1065 | otherOperand = xRight |
| 1066 | } else if s, ok := maybeString(xRight); ok { |
| 1067 | stringOperand = s |
| 1068 | otherOperand = xLeft |
| 1069 | } |
| 1070 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1071 | // If we've identified one of the operands as being a string literal, check |
| 1072 | // for some special cases we can do to simplify the resulting expression. |
| 1073 | if otherOperand != nil { |
| 1074 | if stringOperand == "" { |
| 1075 | if isEq { |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1076 | return negateExpr(otherOperand) |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1077 | } else { |
| 1078 | return otherOperand |
| 1079 | } |
| 1080 | } |
| 1081 | if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool { |
| 1082 | if !isEq { |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1083 | return negateExpr(otherOperand) |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1084 | } else { |
| 1085 | return otherOperand |
| 1086 | } |
| 1087 | } |
Cole Faust | a99afdf | 2022-04-26 12:06:49 -0700 | [diff] [blame] | 1088 | if otherOperand.typ() == starlarkTypeList { |
| 1089 | fields := strings.Fields(stringOperand) |
| 1090 | elements := make([]starlarkExpr, len(fields)) |
| 1091 | for i, s := range fields { |
| 1092 | elements[i] = &stringLiteralExpr{literal: s} |
| 1093 | } |
| 1094 | return &eqExpr{ |
| 1095 | left: otherOperand, |
| 1096 | right: &listExpr{elements}, |
| 1097 | isEq: isEq, |
| 1098 | } |
| 1099 | } |
Cole Faust | b1103e2 | 2022-01-06 15:22:05 -0800 | [diff] [blame] | 1100 | if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt { |
| 1101 | return &eqExpr{ |
| 1102 | left: otherOperand, |
| 1103 | right: &intLiteralExpr{literal: intOperand}, |
| 1104 | isEq: isEq, |
| 1105 | } |
| 1106 | } |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1107 | } |
| 1108 | |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1109 | return &eqExpr{left: xLeft, right: xRight, isEq: isEq} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1110 | } |
| 1111 | |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1112 | // Given an if statement's directive and the left/right starlarkExprs, |
| 1113 | // check if the starlarkExprs are one of a few hardcoded special cases |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1114 | // that can be converted to a simpler equality expression than simply comparing |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1115 | // the two. |
| 1116 | func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr, |
| 1117 | right starlarkExpr) (starlarkExpr, bool) { |
| 1118 | isEq := !strings.HasSuffix(directive.Name, "neq") |
| 1119 | |
| 1120 | // All the special cases require a call on one side and a |
| 1121 | // string literal/variable on the other. Turn the left/right variables into |
| 1122 | // call/value variables, and return false if that's not possible. |
| 1123 | var value starlarkExpr = nil |
| 1124 | call, ok := left.(*callExpr) |
| 1125 | if ok { |
| 1126 | switch right.(type) { |
| 1127 | case *stringLiteralExpr, *variableRefExpr: |
| 1128 | value = right |
| 1129 | } |
| 1130 | } else { |
| 1131 | call, _ = right.(*callExpr) |
| 1132 | switch left.(type) { |
| 1133 | case *stringLiteralExpr, *variableRefExpr: |
| 1134 | value = left |
| 1135 | } |
| 1136 | } |
| 1137 | |
| 1138 | if call == nil || value == nil { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1139 | return nil, false |
| 1140 | } |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1141 | |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1142 | switch call.name { |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1143 | case baseName + ".filter": |
| 1144 | return ctx.parseCompareFilterFuncResult(directive, call, value, isEq) |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1145 | case baseName + ".findstring": |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1146 | return ctx.parseCheckFindstringFuncResult(directive, call, value, !isEq), true |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1147 | case baseName + ".strip": |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1148 | return ctx.parseCompareStripFuncResult(directive, call, value, !isEq), true |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1149 | } |
Cole Faust | f832021 | 2021-11-10 15:05:07 -0800 | [diff] [blame] | 1150 | return nil, false |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1151 | } |
| 1152 | |
| 1153 | func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive, |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1154 | filterFuncCall *callExpr, xValue starlarkExpr, negate bool) (starlarkExpr, bool) { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1155 | // We handle: |
Sasha Smundak | 0554d76 | 2021-07-08 18:26:12 -0700 | [diff] [blame] | 1156 | // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...] |
| 1157 | // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...] |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1158 | if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" { |
| 1159 | return nil, false |
| 1160 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1161 | xPattern := filterFuncCall.args[0] |
| 1162 | xText := filterFuncCall.args[1] |
| 1163 | var xInList *stringLiteralExpr |
Sasha Smundak | 0554d76 | 2021-07-08 18:26:12 -0700 | [diff] [blame] | 1164 | var expr starlarkExpr |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1165 | var ok bool |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1166 | if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList { |
| 1167 | expr = xText |
| 1168 | } else if xInList, ok = xText.(*stringLiteralExpr); ok { |
| 1169 | expr = xPattern |
| 1170 | } else { |
| 1171 | return nil, false |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1172 | } |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1173 | slExpr := newStringListExpr(strings.Fields(xInList.literal)) |
| 1174 | // Generate simpler code for the common cases: |
| 1175 | if expr.typ() == starlarkTypeList { |
| 1176 | if len(slExpr.items) == 1 { |
| 1177 | // Checking that a string belongs to list |
| 1178 | return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}, true |
Sasha Smundak | 0554d76 | 2021-07-08 18:26:12 -0700 | [diff] [blame] | 1179 | } else { |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1180 | return nil, false |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1181 | } |
Cole Faust | 9932f75 | 2022-02-08 11:56:25 -0800 | [diff] [blame] | 1182 | } else if len(slExpr.items) == 1 { |
| 1183 | return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}, true |
| 1184 | } else { |
| 1185 | return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}, true |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1186 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1187 | } |
| 1188 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1189 | func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive, |
| 1190 | xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr { |
Sasha Smundak | 0554d76 | 2021-07-08 18:26:12 -0700 | [diff] [blame] | 1191 | if isEmptyString(xValue) { |
| 1192 | return &eqExpr{ |
| 1193 | left: &callExpr{ |
| 1194 | object: xCall.args[1], |
| 1195 | name: "find", |
| 1196 | args: []starlarkExpr{xCall.args[0]}, |
| 1197 | returnType: starlarkTypeInt, |
| 1198 | }, |
| 1199 | right: &intLiteralExpr{-1}, |
| 1200 | isEq: !negate, |
| 1201 | } |
Cole Faust | 0e9418c | 2021-12-13 16:33:25 -0800 | [diff] [blame] | 1202 | } else if s, ok := maybeString(xValue); ok { |
| 1203 | if s2, ok := maybeString(xCall.args[0]); ok && s == s2 { |
| 1204 | return &eqExpr{ |
| 1205 | left: &callExpr{ |
| 1206 | object: xCall.args[1], |
| 1207 | name: "find", |
| 1208 | args: []starlarkExpr{xCall.args[0]}, |
| 1209 | returnType: starlarkTypeInt, |
| 1210 | }, |
| 1211 | right: &intLiteralExpr{-1}, |
| 1212 | isEq: negate, |
| 1213 | } |
| 1214 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1215 | } |
Cole Faust | 0e9418c | 2021-12-13 16:33:25 -0800 | [diff] [blame] | 1216 | return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument") |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1217 | } |
| 1218 | |
| 1219 | func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive, |
| 1220 | xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr { |
| 1221 | if _, ok := xValue.(*stringLiteralExpr); !ok { |
| 1222 | return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue) |
| 1223 | } |
| 1224 | return &eqExpr{ |
| 1225 | left: &callExpr{ |
| 1226 | name: "strip", |
| 1227 | args: xCall.args, |
| 1228 | returnType: starlarkTypeString, |
| 1229 | }, |
| 1230 | right: xValue, isEq: !negate} |
| 1231 | } |
| 1232 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1233 | func (ctx *parseContext) maybeParseFunctionCall(node mkparser.Node, ref *mkparser.MakeString) (name string, args *mkparser.MakeString, ok bool) { |
| 1234 | ref.TrimLeftSpaces() |
| 1235 | ref.TrimRightSpaces() |
| 1236 | |
| 1237 | words := ref.SplitN(" ", 2) |
| 1238 | if !words[0].Const() { |
| 1239 | return "", nil, false |
| 1240 | } |
| 1241 | |
| 1242 | name = words[0].Dump() |
| 1243 | args = mkparser.SimpleMakeString("", words[0].Pos()) |
| 1244 | if len(words) >= 2 { |
| 1245 | args = words[1] |
| 1246 | } |
| 1247 | args.TrimLeftSpaces() |
| 1248 | if name == "call" { |
| 1249 | words = args.SplitN(",", 2) |
| 1250 | if words[0].Empty() || !words[0].Const() { |
| 1251 | return "", nil, false |
| 1252 | } |
| 1253 | name = words[0].Dump() |
| 1254 | if len(words) < 2 { |
Cole Faust | 6c41b8a | 2022-04-13 13:53:48 -0700 | [diff] [blame] | 1255 | args = mkparser.SimpleMakeString("", words[0].Pos()) |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1256 | } else { |
| 1257 | args = words[1] |
| 1258 | } |
| 1259 | } |
| 1260 | ok = true |
| 1261 | return |
| 1262 | } |
| 1263 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1264 | // parses $(...), returning an expression |
| 1265 | func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr { |
| 1266 | ref.TrimLeftSpaces() |
| 1267 | ref.TrimRightSpaces() |
| 1268 | refDump := ref.Dump() |
| 1269 | |
| 1270 | // Handle only the case where the first (or only) word is constant |
| 1271 | words := ref.SplitN(" ", 2) |
| 1272 | if !words[0].Const() { |
Cole Faust | 1323877 | 2022-04-28 14:29:57 -0700 | [diff] [blame^] | 1273 | if len(words) == 1 { |
| 1274 | expr := ctx.parseMakeString(node, ref) |
| 1275 | return &callExpr{ |
| 1276 | object: &identifierExpr{"cfg"}, |
| 1277 | name: "get", |
| 1278 | args: []starlarkExpr{ |
| 1279 | expr, |
| 1280 | &callExpr{ |
| 1281 | object: &identifierExpr{"g"}, |
| 1282 | name: "get", |
| 1283 | args: []starlarkExpr{ |
| 1284 | expr, |
| 1285 | &stringLiteralExpr{literal: ""}, |
| 1286 | }, |
| 1287 | returnType: starlarkTypeUnknown, |
| 1288 | }, |
| 1289 | }, |
| 1290 | returnType: starlarkTypeUnknown, |
| 1291 | } |
| 1292 | } else { |
| 1293 | return ctx.newBadExpr(node, "reference is too complex: %s", refDump) |
| 1294 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1295 | } |
| 1296 | |
Cole Faust | 1e27586 | 2022-04-26 14:28:04 -0700 | [diff] [blame] | 1297 | if name, _, ok := ctx.maybeParseFunctionCall(node, ref); ok { |
| 1298 | if _, unsupported := unsupportedFunctions[name]; unsupported { |
| 1299 | return ctx.newBadExpr(node, "%s is not supported", refDump) |
| 1300 | } |
| 1301 | } |
| 1302 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1303 | // If it is a single word, it can be a simple variable |
| 1304 | // reference or a function call |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1305 | if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" && refDump != "eval" { |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 1306 | if strings.HasPrefix(refDump, soongNsPrefix) { |
| 1307 | // TODO (asmundak): if we find many, maybe handle them. |
Cole Faust | c00184e | 2021-11-08 12:08:57 -0800 | [diff] [blame] | 1308 | return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump) |
Sasha Smundak | 65b547e | 2021-09-17 15:35:41 -0700 | [diff] [blame] | 1309 | } |
Cole Faust | c36c962 | 2021-12-07 15:20:45 -0800 | [diff] [blame] | 1310 | // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html |
| 1311 | if strings.Contains(refDump, ":") { |
| 1312 | parts := strings.SplitN(refDump, ":", 2) |
| 1313 | substParts := strings.SplitN(parts[1], "=", 2) |
| 1314 | if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 { |
| 1315 | return ctx.newBadExpr(node, "Invalid substitution reference") |
| 1316 | } |
| 1317 | if !strings.Contains(substParts[0], "%") { |
| 1318 | if strings.Contains(substParts[1], "%") { |
| 1319 | return ctx.newBadExpr(node, "A substitution reference must have a %% in the \"before\" part of the substitution if it has one in the \"after\" part.") |
| 1320 | } |
| 1321 | substParts[0] = "%" + substParts[0] |
| 1322 | substParts[1] = "%" + substParts[1] |
| 1323 | } |
| 1324 | v := ctx.addVariable(parts[0]) |
| 1325 | if v == nil { |
| 1326 | return ctx.newBadExpr(node, "unknown variable %s", refDump) |
| 1327 | } |
| 1328 | return &callExpr{ |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1329 | name: baseName + ".mkpatsubst", |
| 1330 | returnType: starlarkTypeString, |
Cole Faust | c36c962 | 2021-12-07 15:20:45 -0800 | [diff] [blame] | 1331 | args: []starlarkExpr{ |
| 1332 | &stringLiteralExpr{literal: substParts[0]}, |
| 1333 | &stringLiteralExpr{literal: substParts[1]}, |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1334 | NewVariableRefExpr(v), |
Cole Faust | c36c962 | 2021-12-07 15:20:45 -0800 | [diff] [blame] | 1335 | }, |
| 1336 | } |
| 1337 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1338 | if v := ctx.addVariable(refDump); v != nil { |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1339 | return NewVariableRefExpr(v) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1340 | } |
| 1341 | return ctx.newBadExpr(node, "unknown variable %s", refDump) |
| 1342 | } |
| 1343 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1344 | if name, args, ok := ctx.maybeParseFunctionCall(node, ref); ok { |
| 1345 | if kf, found := knownFunctions[name]; found { |
| 1346 | return kf.parse(ctx, node, args) |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 1347 | } else { |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1348 | return ctx.newBadExpr(node, "cannot handle invoking %s", name) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1349 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1350 | } |
Cole Faust | 1e27586 | 2022-04-26 14:28:04 -0700 | [diff] [blame] | 1351 | return ctx.newBadExpr(node, "cannot handle %s", refDump) |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1352 | } |
| 1353 | |
| 1354 | type simpleCallParser struct { |
| 1355 | name string |
| 1356 | returnType starlarkType |
| 1357 | addGlobals bool |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 1358 | addHandle bool |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1359 | } |
| 1360 | |
| 1361 | func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1362 | expr := &callExpr{name: p.name, returnType: p.returnType} |
| 1363 | if p.addGlobals { |
| 1364 | expr.args = append(expr.args, &globalsExpr{}) |
| 1365 | } |
Cole Faust | 1cc0885 | 2022-02-28 11:12:08 -0800 | [diff] [blame] | 1366 | if p.addHandle { |
| 1367 | expr.args = append(expr.args, &identifierExpr{name: "handle"}) |
| 1368 | } |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 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 |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1375 | } |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1376 | expr.args = append(expr.args, x) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1377 | } |
| 1378 | return expr |
| 1379 | } |
| 1380 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1381 | type makeControlFuncParser struct { |
| 1382 | name string |
| 1383 | } |
| 1384 | |
| 1385 | func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1386 | // Make control functions need special treatment as everything |
| 1387 | // after the name is a single text argument |
| 1388 | x := ctx.parseMakeString(node, args) |
| 1389 | if xBad, ok := x.(*badExpr); ok { |
| 1390 | return xBad |
| 1391 | } |
| 1392 | return &callExpr{ |
| 1393 | name: p.name, |
| 1394 | args: []starlarkExpr{ |
| 1395 | &stringLiteralExpr{ctx.script.mkFile}, |
| 1396 | x, |
| 1397 | }, |
| 1398 | returnType: starlarkTypeUnknown, |
| 1399 | } |
| 1400 | } |
| 1401 | |
| 1402 | type shellCallParser struct{} |
| 1403 | |
| 1404 | func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1405 | // Shell functions need special treatment as everything |
| 1406 | // after the name is a single text argument |
| 1407 | x := ctx.parseMakeString(node, args) |
| 1408 | if xBad, ok := x.(*badExpr); ok { |
| 1409 | return xBad |
| 1410 | } |
| 1411 | return &callExpr{ |
| 1412 | name: baseName + ".shell", |
| 1413 | args: []starlarkExpr{x}, |
| 1414 | returnType: starlarkTypeUnknown, |
| 1415 | } |
| 1416 | } |
| 1417 | |
| 1418 | type myDirCallParser struct{} |
| 1419 | |
| 1420 | func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1421 | if !args.Empty() { |
| 1422 | return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.") |
| 1423 | } |
Cole Faust | f5adedc | 2022-03-18 14:05:06 -0700 | [diff] [blame] | 1424 | return &stringLiteralExpr{literal: filepath.Dir(ctx.script.mkFile)} |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1425 | } |
| 1426 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1427 | type isProductInListCallParser struct{} |
| 1428 | |
| 1429 | func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1430 | if args.Empty() { |
| 1431 | return ctx.newBadExpr(node, "is-product-in-list requires an argument") |
| 1432 | } |
| 1433 | return &inExpr{ |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1434 | expr: NewVariableRefExpr(ctx.addVariable("TARGET_PRODUCT")), |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1435 | list: maybeConvertToStringList(ctx.parseMakeString(node, args)), |
| 1436 | isNot: false, |
| 1437 | } |
| 1438 | } |
| 1439 | |
| 1440 | type isVendorBoardPlatformCallParser struct{} |
| 1441 | |
| 1442 | func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1443 | if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) { |
| 1444 | return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform") |
| 1445 | } |
| 1446 | return &inExpr{ |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1447 | expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")), |
| 1448 | list: NewVariableRefExpr(ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS")), |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1449 | isNot: false, |
| 1450 | } |
| 1451 | } |
| 1452 | |
| 1453 | type isVendorBoardQcomCallParser struct{} |
| 1454 | |
| 1455 | func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1456 | if !args.Empty() { |
| 1457 | return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments") |
| 1458 | } |
| 1459 | return &inExpr{ |
Cole Faust | f063266 | 2022-04-07 13:59:24 -0700 | [diff] [blame] | 1460 | expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")), |
| 1461 | list: NewVariableRefExpr(ctx.addVariable("QCOM_BOARD_PLATFORMS")), |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1462 | isNot: false, |
| 1463 | } |
| 1464 | } |
| 1465 | |
| 1466 | type substCallParser struct { |
| 1467 | fname string |
| 1468 | } |
| 1469 | |
| 1470 | func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1471 | words := args.Split(",") |
| 1472 | if len(words) != 3 { |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1473 | return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1474 | } |
Sasha Smundak | 35434ed | 2021-11-05 16:29:56 -0700 | [diff] [blame] | 1475 | from := ctx.parseMakeString(node, words[0]) |
| 1476 | if xBad, ok := from.(*badExpr); ok { |
| 1477 | return xBad |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1478 | } |
Sasha Smundak | 35434ed | 2021-11-05 16:29:56 -0700 | [diff] [blame] | 1479 | to := ctx.parseMakeString(node, words[1]) |
| 1480 | if xBad, ok := to.(*badExpr); ok { |
| 1481 | return xBad |
| 1482 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1483 | words[2].TrimLeftSpaces() |
| 1484 | words[2].TrimRightSpaces() |
| 1485 | obj := ctx.parseMakeString(node, words[2]) |
Sasha Smundak | 9d011ab | 2021-07-09 16:00:57 -0700 | [diff] [blame] | 1486 | typ := obj.typ() |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1487 | if typ == starlarkTypeString && p.fname == "subst" { |
Sasha Smundak | 94b41c7 | 2021-07-12 18:30:42 -0700 | [diff] [blame] | 1488 | // Optimization: if it's $(subst from, to, string), emit string.replace(from, to) |
Sasha Smundak | 9d011ab | 2021-07-09 16:00:57 -0700 | [diff] [blame] | 1489 | return &callExpr{ |
| 1490 | object: obj, |
| 1491 | name: "replace", |
Sasha Smundak | 35434ed | 2021-11-05 16:29:56 -0700 | [diff] [blame] | 1492 | args: []starlarkExpr{from, to}, |
Sasha Smundak | 9d011ab | 2021-07-09 16:00:57 -0700 | [diff] [blame] | 1493 | returnType: typ, |
| 1494 | } |
| 1495 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1496 | return &callExpr{ |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1497 | name: baseName + ".mk" + p.fname, |
Sasha Smundak | 35434ed | 2021-11-05 16:29:56 -0700 | [diff] [blame] | 1498 | args: []starlarkExpr{from, to, obj}, |
Sasha Smundak | 9d011ab | 2021-07-09 16:00:57 -0700 | [diff] [blame] | 1499 | returnType: obj.typ(), |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1500 | } |
| 1501 | } |
| 1502 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1503 | type ifCallParser struct{} |
| 1504 | |
| 1505 | func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
Cole Faust | 4eadba7 | 2021-12-07 11:54:52 -0800 | [diff] [blame] | 1506 | words := args.Split(",") |
| 1507 | if len(words) != 2 && len(words) != 3 { |
| 1508 | return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words))) |
| 1509 | } |
| 1510 | condition := ctx.parseMakeString(node, words[0]) |
| 1511 | ifTrue := ctx.parseMakeString(node, words[1]) |
| 1512 | var ifFalse starlarkExpr |
| 1513 | if len(words) == 3 { |
| 1514 | ifFalse = ctx.parseMakeString(node, words[2]) |
| 1515 | } else { |
| 1516 | switch ifTrue.typ() { |
| 1517 | case starlarkTypeList: |
| 1518 | ifFalse = &listExpr{items: []starlarkExpr{}} |
| 1519 | case starlarkTypeInt: |
| 1520 | ifFalse = &intLiteralExpr{literal: 0} |
| 1521 | case starlarkTypeBool: |
| 1522 | ifFalse = &boolLiteralExpr{literal: false} |
| 1523 | default: |
| 1524 | ifFalse = &stringLiteralExpr{literal: ""} |
| 1525 | } |
| 1526 | } |
| 1527 | return &ifExpr{ |
| 1528 | condition, |
| 1529 | ifTrue, |
| 1530 | ifFalse, |
| 1531 | } |
| 1532 | } |
| 1533 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1534 | type ifCallNodeParser struct{} |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1535 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1536 | func (p *ifCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode { |
| 1537 | words := args.Split(",") |
| 1538 | if len(words) != 2 && len(words) != 3 { |
| 1539 | return []starlarkNode{ctx.newBadNode(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))} |
| 1540 | } |
| 1541 | |
| 1542 | ifn := &ifNode{expr: ctx.parseMakeString(node, words[0])} |
| 1543 | cases := []*switchCase{ |
| 1544 | { |
| 1545 | gate: ifn, |
| 1546 | nodes: ctx.parseNodeMakeString(node, words[1]), |
| 1547 | }, |
| 1548 | } |
| 1549 | if len(words) == 3 { |
| 1550 | cases = append(cases, &switchCase{ |
| 1551 | gate: &elseNode{}, |
| 1552 | nodes: ctx.parseNodeMakeString(node, words[2]), |
| 1553 | }) |
| 1554 | } |
| 1555 | if len(cases) == 2 { |
| 1556 | if len(cases[1].nodes) == 0 { |
| 1557 | // Remove else branch if it has no contents |
| 1558 | cases = cases[:1] |
| 1559 | } else if len(cases[0].nodes) == 0 { |
| 1560 | // If the if branch has no contents but the else does, |
| 1561 | // move them to the if and negate its condition |
| 1562 | ifn.expr = negateExpr(ifn.expr) |
| 1563 | cases[0].nodes = cases[1].nodes |
| 1564 | cases = cases[:1] |
| 1565 | } |
| 1566 | } |
| 1567 | |
| 1568 | return []starlarkNode{&switchNode{ssCases: cases}} |
| 1569 | } |
| 1570 | |
| 1571 | type foreachCallParser struct{} |
| 1572 | |
| 1573 | func (p *foreachCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
Cole Faust | b0d32ab | 2021-12-09 14:00:59 -0800 | [diff] [blame] | 1574 | words := args.Split(",") |
| 1575 | if len(words) != 3 { |
| 1576 | return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words))) |
| 1577 | } |
| 1578 | if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) { |
| 1579 | return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier") |
| 1580 | } |
| 1581 | loopVarName := words[0].Strings[0] |
| 1582 | list := ctx.parseMakeString(node, words[1]) |
| 1583 | action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr { |
| 1584 | if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName { |
| 1585 | return &identifierExpr{loopVarName} |
| 1586 | } |
| 1587 | return nil |
| 1588 | }) |
| 1589 | |
| 1590 | if list.typ() != starlarkTypeList { |
| 1591 | list = &callExpr{ |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1592 | name: baseName + ".words", |
| 1593 | returnType: starlarkTypeList, |
Cole Faust | b0d32ab | 2021-12-09 14:00:59 -0800 | [diff] [blame] | 1594 | args: []starlarkExpr{list}, |
| 1595 | } |
| 1596 | } |
| 1597 | |
Cole Faust | 72374fc | 2022-05-05 11:45:04 -0700 | [diff] [blame] | 1598 | var result starlarkExpr = &foreachExpr{ |
Cole Faust | b0d32ab | 2021-12-09 14:00:59 -0800 | [diff] [blame] | 1599 | varName: loopVarName, |
| 1600 | list: list, |
| 1601 | action: action, |
| 1602 | } |
Cole Faust | 72374fc | 2022-05-05 11:45:04 -0700 | [diff] [blame] | 1603 | |
| 1604 | if action.typ() == starlarkTypeList { |
| 1605 | result = &callExpr{ |
| 1606 | name: baseName + ".flatten_2d_list", |
| 1607 | args: []starlarkExpr{result}, |
| 1608 | returnType: starlarkTypeList, |
| 1609 | } |
| 1610 | } |
| 1611 | |
| 1612 | return result |
Cole Faust | b0d32ab | 2021-12-09 14:00:59 -0800 | [diff] [blame] | 1613 | } |
| 1614 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1615 | func transformNode(node starlarkNode, transformer func(expr starlarkExpr) starlarkExpr) { |
| 1616 | switch a := node.(type) { |
| 1617 | case *ifNode: |
| 1618 | a.expr = a.expr.transform(transformer) |
| 1619 | case *switchCase: |
| 1620 | transformNode(a.gate, transformer) |
| 1621 | for _, n := range a.nodes { |
| 1622 | transformNode(n, transformer) |
| 1623 | } |
| 1624 | case *switchNode: |
| 1625 | for _, n := range a.ssCases { |
| 1626 | transformNode(n, transformer) |
| 1627 | } |
| 1628 | case *exprNode: |
| 1629 | a.expr = a.expr.transform(transformer) |
| 1630 | case *assignmentNode: |
| 1631 | a.value = a.value.transform(transformer) |
| 1632 | case *foreachNode: |
| 1633 | a.list = a.list.transform(transformer) |
| 1634 | for _, n := range a.actions { |
| 1635 | transformNode(n, transformer) |
| 1636 | } |
Cole Faust | 9df1d73 | 2022-04-26 16:27:22 -0700 | [diff] [blame] | 1637 | case *inheritNode: |
| 1638 | if b, ok := a.module.(inheritedDynamicModule); ok { |
| 1639 | b.path = b.path.transform(transformer) |
| 1640 | a.module = b |
| 1641 | } |
| 1642 | case *includeNode: |
| 1643 | if b, ok := a.module.(inheritedDynamicModule); ok { |
| 1644 | b.path = b.path.transform(transformer) |
| 1645 | a.module = b |
| 1646 | } |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1647 | } |
| 1648 | } |
| 1649 | |
| 1650 | type foreachCallNodeParser struct{} |
| 1651 | |
| 1652 | func (p *foreachCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode { |
| 1653 | words := args.Split(",") |
| 1654 | if len(words) != 3 { |
| 1655 | return []starlarkNode{ctx.newBadNode(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))} |
| 1656 | } |
| 1657 | if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) { |
| 1658 | return []starlarkNode{ctx.newBadNode(node, "first argument to foreach function must be a simple string identifier")} |
| 1659 | } |
| 1660 | |
| 1661 | loopVarName := words[0].Strings[0] |
| 1662 | |
| 1663 | list := ctx.parseMakeString(node, words[1]) |
| 1664 | if list.typ() != starlarkTypeList { |
| 1665 | list = &callExpr{ |
| 1666 | name: baseName + ".words", |
| 1667 | returnType: starlarkTypeList, |
| 1668 | args: []starlarkExpr{list}, |
| 1669 | } |
| 1670 | } |
| 1671 | |
| 1672 | actions := ctx.parseNodeMakeString(node, words[2]) |
| 1673 | // TODO(colefaust): Replace transforming code with something more elegant |
| 1674 | for _, action := range actions { |
| 1675 | transformNode(action, func(expr starlarkExpr) starlarkExpr { |
| 1676 | if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName { |
| 1677 | return &identifierExpr{loopVarName} |
| 1678 | } |
| 1679 | return nil |
| 1680 | }) |
| 1681 | } |
| 1682 | |
| 1683 | return []starlarkNode{&foreachNode{ |
| 1684 | varName: loopVarName, |
| 1685 | list: list, |
| 1686 | actions: actions, |
| 1687 | }} |
| 1688 | } |
| 1689 | |
Cole Faust | 9ebf6e4 | 2021-12-13 14:08:34 -0800 | [diff] [blame] | 1690 | type wordCallParser struct{} |
| 1691 | |
| 1692 | func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1693 | words := args.Split(",") |
| 1694 | if len(words) != 2 { |
| 1695 | return ctx.newBadExpr(node, "word function should have 2 arguments") |
| 1696 | } |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 1697 | var index = 0 |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1698 | if words[0].Const() { |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 1699 | if i, err := strconv.Atoi(strings.TrimSpace(words[0].Strings[0])); err == nil { |
| 1700 | index = i |
| 1701 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1702 | } |
| 1703 | if index < 1 { |
| 1704 | return ctx.newBadExpr(node, "word index should be constant positive integer") |
| 1705 | } |
| 1706 | words[1].TrimLeftSpaces() |
| 1707 | words[1].TrimRightSpaces() |
| 1708 | array := ctx.parseMakeString(node, words[1]) |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 1709 | if bad, ok := array.(*badExpr); ok { |
| 1710 | return bad |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1711 | } |
| 1712 | if array.typ() != starlarkTypeList { |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 1713 | array = &callExpr{ |
| 1714 | name: baseName + ".words", |
| 1715 | args: []starlarkExpr{array}, |
| 1716 | returnType: starlarkTypeList, |
| 1717 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1718 | } |
Cole Faust | 94c4a9a | 2022-04-22 17:43:52 -0700 | [diff] [blame] | 1719 | return &indexExpr{array, &intLiteralExpr{index - 1}} |
| 1720 | } |
| 1721 | |
| 1722 | type wordsCallParser struct{} |
| 1723 | |
| 1724 | func (p *wordsCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1725 | args.TrimLeftSpaces() |
| 1726 | args.TrimRightSpaces() |
| 1727 | array := ctx.parseMakeString(node, args) |
| 1728 | if bad, ok := array.(*badExpr); ok { |
| 1729 | return bad |
| 1730 | } |
| 1731 | if array.typ() != starlarkTypeList { |
| 1732 | array = &callExpr{ |
| 1733 | name: baseName + ".words", |
| 1734 | args: []starlarkExpr{array}, |
| 1735 | returnType: starlarkTypeList, |
| 1736 | } |
| 1737 | } |
| 1738 | return &callExpr{ |
| 1739 | name: "len", |
| 1740 | args: []starlarkExpr{array}, |
| 1741 | returnType: starlarkTypeInt, |
| 1742 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1743 | } |
| 1744 | |
Cole Faust | b1103e2 | 2022-01-06 15:22:05 -0800 | [diff] [blame] | 1745 | func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) { |
| 1746 | parsedArgs := make([]starlarkExpr, 0) |
| 1747 | for _, arg := range args.Split(",") { |
| 1748 | expr := ctx.parseMakeString(node, arg) |
| 1749 | if expr.typ() == starlarkTypeList { |
| 1750 | return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int") |
| 1751 | } |
| 1752 | if s, ok := maybeString(expr); ok { |
| 1753 | intVal, err := strconv.Atoi(strings.TrimSpace(s)) |
| 1754 | if err != nil { |
| 1755 | return nil, err |
| 1756 | } |
| 1757 | expr = &intLiteralExpr{literal: intVal} |
| 1758 | } else if expr.typ() != starlarkTypeInt { |
| 1759 | expr = &callExpr{ |
| 1760 | name: "int", |
| 1761 | args: []starlarkExpr{expr}, |
| 1762 | returnType: starlarkTypeInt, |
| 1763 | } |
| 1764 | } |
| 1765 | parsedArgs = append(parsedArgs, expr) |
| 1766 | } |
| 1767 | if len(parsedArgs) != expectedArgs { |
| 1768 | return nil, fmt.Errorf("function should have %d arguments", expectedArgs) |
| 1769 | } |
| 1770 | return parsedArgs, nil |
| 1771 | } |
| 1772 | |
| 1773 | type mathComparisonCallParser struct { |
| 1774 | op string |
| 1775 | } |
| 1776 | |
| 1777 | func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1778 | parsedArgs, err := parseIntegerArguments(ctx, node, args, 2) |
| 1779 | if err != nil { |
| 1780 | return ctx.newBadExpr(node, err.Error()) |
| 1781 | } |
| 1782 | return &binaryOpExpr{ |
| 1783 | left: parsedArgs[0], |
| 1784 | right: parsedArgs[1], |
| 1785 | op: p.op, |
| 1786 | returnType: starlarkTypeBool, |
| 1787 | } |
| 1788 | } |
| 1789 | |
| 1790 | type mathMaxOrMinCallParser struct { |
| 1791 | function string |
| 1792 | } |
| 1793 | |
| 1794 | func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr { |
| 1795 | parsedArgs, err := parseIntegerArguments(ctx, node, args, 2) |
| 1796 | if err != nil { |
| 1797 | return ctx.newBadExpr(node, err.Error()) |
| 1798 | } |
| 1799 | return &callExpr{ |
| 1800 | object: nil, |
| 1801 | name: p.function, |
| 1802 | args: parsedArgs, |
| 1803 | returnType: starlarkTypeInt, |
| 1804 | } |
| 1805 | } |
| 1806 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1807 | type evalNodeParser struct{} |
| 1808 | |
| 1809 | func (p *evalNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode { |
| 1810 | parser := mkparser.NewParser("Eval expression", strings.NewReader(args.Dump())) |
| 1811 | nodes, errs := parser.Parse() |
| 1812 | if errs != nil { |
| 1813 | return []starlarkNode{ctx.newBadNode(node, "Unable to parse eval statement")} |
| 1814 | } |
| 1815 | |
| 1816 | if len(nodes) == 0 { |
| 1817 | return []starlarkNode{} |
| 1818 | } else if len(nodes) == 1 { |
| 1819 | switch n := nodes[0].(type) { |
| 1820 | case *mkparser.Assignment: |
| 1821 | if n.Name.Const() { |
| 1822 | return ctx.handleAssignment(n) |
| 1823 | } |
| 1824 | case *mkparser.Comment: |
| 1825 | return []starlarkNode{&commentNode{strings.TrimSpace("#" + n.Comment)}} |
Cole Faust | 2005298 | 2022-04-22 14:43:55 -0700 | [diff] [blame] | 1826 | case *mkparser.Directive: |
| 1827 | if n.Name == "include" || n.Name == "-include" { |
| 1828 | return ctx.handleInclude(n) |
| 1829 | } |
| 1830 | case *mkparser.Variable: |
| 1831 | // Technically inherit-product(-if-exists) don't need to be put inside |
| 1832 | // an eval, but some makefiles do it, presumably because they copy+pasted |
| 1833 | // from a $(eval include ...) |
| 1834 | if name, _, ok := ctx.maybeParseFunctionCall(n, n.Name); ok { |
| 1835 | if name == "inherit-product" || name == "inherit-product-if-exists" { |
| 1836 | return ctx.handleVariable(n) |
| 1837 | } |
| 1838 | } |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1839 | } |
| 1840 | } |
| 1841 | |
Cole Faust | 2005298 | 2022-04-22 14:43:55 -0700 | [diff] [blame] | 1842 | return []starlarkNode{ctx.newBadNode(node, "Eval expression too complex; only assignments, comments, includes, and inherit-products are supported")} |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1843 | } |
| 1844 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1845 | func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr { |
| 1846 | if mk.Const() { |
| 1847 | return &stringLiteralExpr{mk.Dump()} |
| 1848 | } |
| 1849 | if mkRef, ok := mk.SingleVariable(); ok { |
| 1850 | return ctx.parseReference(node, mkRef) |
| 1851 | } |
| 1852 | // If we reached here, it's neither string literal nor a simple variable, |
| 1853 | // we need a full-blown interpolation node that will generate |
| 1854 | // "a%b%c" % (X, Y) for a$(X)b$(Y)c |
Cole Faust | fc43868 | 2021-12-14 12:46:32 -0800 | [diff] [blame] | 1855 | parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings)) |
| 1856 | for i := 0; i < len(parts); i++ { |
| 1857 | if i%2 == 0 { |
| 1858 | parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]} |
| 1859 | } else { |
| 1860 | parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name) |
| 1861 | if x, ok := parts[i].(*badExpr); ok { |
| 1862 | return x |
| 1863 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1864 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1865 | } |
Cole Faust | fc43868 | 2021-12-14 12:46:32 -0800 | [diff] [blame] | 1866 | return NewInterpolateExpr(parts) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1867 | } |
| 1868 | |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1869 | func (ctx *parseContext) parseNodeMakeString(node mkparser.Node, mk *mkparser.MakeString) []starlarkNode { |
| 1870 | // Discard any constant values in the make string, as they would be top level |
| 1871 | // string literals and do nothing. |
| 1872 | result := make([]starlarkNode, 0, len(mk.Variables)) |
| 1873 | for i := range mk.Variables { |
| 1874 | result = append(result, ctx.handleVariable(&mk.Variables[i])...) |
| 1875 | } |
| 1876 | return result |
| 1877 | } |
| 1878 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1879 | // Handles the statements whose treatment is the same in all contexts: comment, |
| 1880 | // assignment, variable (which is a macro call in reality) and all constructs that |
| 1881 | // do not handle in any context ('define directive and any unrecognized stuff). |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1882 | func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) []starlarkNode { |
| 1883 | var result []starlarkNode |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1884 | switch x := node.(type) { |
| 1885 | case *mkparser.Comment: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1886 | if n, handled := ctx.maybeHandleAnnotation(x); handled && n != nil { |
| 1887 | result = []starlarkNode{n} |
| 1888 | } else if !handled { |
| 1889 | result = []starlarkNode{&commentNode{strings.TrimSpace("#" + x.Comment)}} |
Cole Faust | 7940c6a | 2022-01-31 15:54:05 -0800 | [diff] [blame] | 1890 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1891 | case *mkparser.Assignment: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1892 | result = ctx.handleAssignment(x) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1893 | case *mkparser.Variable: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1894 | result = ctx.handleVariable(x) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1895 | case *mkparser.Directive: |
| 1896 | switch x.Name { |
| 1897 | case "define": |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1898 | if res := ctx.maybeHandleDefine(x); res != nil { |
| 1899 | result = []starlarkNode{res} |
| 1900 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1901 | case "include", "-include": |
Cole Faust | 2005298 | 2022-04-22 14:43:55 -0700 | [diff] [blame] | 1902 | result = ctx.handleInclude(x) |
Cole Faust | 591a1fe | 2021-11-08 15:37:57 -0800 | [diff] [blame] | 1903 | case "ifeq", "ifneq", "ifdef", "ifndef": |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1904 | result = []starlarkNode{ctx.handleIfBlock(x)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1905 | default: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1906 | result = []starlarkNode{ctx.newBadNode(x, "unexpected directive %s", x.Name)} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1907 | } |
| 1908 | default: |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1909 | result = []starlarkNode{ctx.newBadNode(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))} |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1910 | } |
Cole Faust | 6c934f6 | 2022-01-06 15:51:12 -0800 | [diff] [blame] | 1911 | |
| 1912 | // Clear the includeTops after each non-comment statement |
| 1913 | // so that include annotations placed on certain statements don't apply |
| 1914 | // globally for the rest of the makefile was well. |
Cole Faust | f92c9f2 | 2022-03-14 14:35:50 -0700 | [diff] [blame] | 1915 | if _, wasComment := node.(*mkparser.Comment); !wasComment { |
| 1916 | ctx.atTopOfMakefile = false |
Cole Faust | 6c934f6 | 2022-01-06 15:51:12 -0800 | [diff] [blame] | 1917 | ctx.includeTops = []string{} |
| 1918 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1919 | |
| 1920 | if result == nil { |
| 1921 | result = []starlarkNode{} |
| 1922 | } |
Cole Faust | f035d40 | 2022-03-28 14:02:50 -0700 | [diff] [blame] | 1923 | |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1924 | return result |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1925 | } |
| 1926 | |
Cole Faust | f92c9f2 | 2022-03-14 14:35:50 -0700 | [diff] [blame] | 1927 | // The types allowed in a type_hint |
| 1928 | var typeHintMap = map[string]starlarkType{ |
| 1929 | "string": starlarkTypeString, |
| 1930 | "list": starlarkTypeList, |
| 1931 | } |
| 1932 | |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 1933 | // Processes annotation. An annotation is a comment that starts with #RBC# and provides |
| 1934 | // a conversion hint -- say, where to look for the dynamically calculated inherit/include |
Cole Faust | 7940c6a | 2022-01-31 15:54:05 -0800 | [diff] [blame] | 1935 | // paths. Returns true if the comment was a successfully-handled annotation. |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1936 | func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) (starlarkNode, bool) { |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 1937 | maybeTrim := func(s, prefix string) (string, bool) { |
| 1938 | if strings.HasPrefix(s, prefix) { |
| 1939 | return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true |
| 1940 | } |
| 1941 | return s, false |
| 1942 | } |
| 1943 | annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix) |
| 1944 | if !ok { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1945 | return nil, false |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 1946 | } |
| 1947 | if p, ok := maybeTrim(annotation, "include_top"); ok { |
Cole Faust | f7ed534 | 2021-12-21 14:15:12 -0800 | [diff] [blame] | 1948 | // Don't allow duplicate include tops, because then we will generate |
| 1949 | // invalid starlark code. (duplicate keys in the _entry dictionary) |
| 1950 | for _, top := range ctx.includeTops { |
| 1951 | if top == p { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1952 | return nil, true |
Cole Faust | f7ed534 | 2021-12-21 14:15:12 -0800 | [diff] [blame] | 1953 | } |
| 1954 | } |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 1955 | ctx.includeTops = append(ctx.includeTops, p) |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1956 | return nil, true |
Cole Faust | f92c9f2 | 2022-03-14 14:35:50 -0700 | [diff] [blame] | 1957 | } else if p, ok := maybeTrim(annotation, "type_hint"); ok { |
| 1958 | // Type hints must come at the beginning the file, to avoid confusion |
| 1959 | // if a type hint was specified later and thus only takes effect for half |
| 1960 | // of the file. |
| 1961 | if !ctx.atTopOfMakefile { |
| 1962 | return ctx.newBadNode(cnode, "type_hint annotations must come before the first Makefile statement"), true |
| 1963 | } |
| 1964 | |
| 1965 | parts := strings.Fields(p) |
| 1966 | if len(parts) <= 1 { |
| 1967 | return ctx.newBadNode(cnode, "Invalid type_hint annotation: %s. Must be a variable type followed by a list of variables of that type", p), true |
| 1968 | } |
| 1969 | |
| 1970 | var varType starlarkType |
| 1971 | if varType, ok = typeHintMap[parts[0]]; !ok { |
| 1972 | varType = starlarkTypeUnknown |
| 1973 | } |
| 1974 | if varType == starlarkTypeUnknown { |
| 1975 | return ctx.newBadNode(cnode, "Invalid type_hint annotation. Only list/string types are accepted, found %s", parts[0]), true |
| 1976 | } |
| 1977 | |
| 1978 | for _, name := range parts[1:] { |
| 1979 | // Don't allow duplicate type hints |
| 1980 | if _, ok := ctx.typeHints[name]; ok { |
| 1981 | return ctx.newBadNode(cnode, "Duplicate type hint for variable %s", name), true |
| 1982 | } |
| 1983 | ctx.typeHints[name] = varType |
| 1984 | } |
| 1985 | return nil, true |
Sasha Smundak | 6d852dd | 2021-09-27 20:34:39 -0700 | [diff] [blame] | 1986 | } |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 1987 | return ctx.newBadNode(cnode, "unsupported annotation %s", cnode.Comment), true |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 1988 | } |
| 1989 | |
| 1990 | func (ctx *parseContext) loadedModulePath(path string) string { |
| 1991 | // During the transition to Roboleaf some of the product configuration files |
| 1992 | // will be converted and checked in while the others will be generated on the fly |
| 1993 | // and run. The runner (rbcrun application) accommodates this by allowing three |
| 1994 | // different ways to specify the loaded file location: |
| 1995 | // 1) load(":<file>",...) loads <file> from the same directory |
| 1996 | // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree |
| 1997 | // 3) load("/absolute/path/to/<file> absolute path |
| 1998 | // If the file being generated and the file it wants to load are in the same directory, |
| 1999 | // generate option 1. |
| 2000 | // Otherwise, if output directory is not specified, generate 2) |
| 2001 | // Finally, if output directory has been specified and the file being generated and |
| 2002 | // the file it wants to load from are in the different directories, generate 2) or 3): |
| 2003 | // * if the file being loaded exists in the source tree, generate 2) |
| 2004 | // * otherwise, generate 3) |
| 2005 | // Finally, figure out the loaded module path and name and create a node for it |
| 2006 | loadedModuleDir := filepath.Dir(path) |
| 2007 | base := filepath.Base(path) |
| 2008 | loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix |
| 2009 | if loadedModuleDir == filepath.Dir(ctx.script.mkFile) { |
| 2010 | return ":" + loadedModuleName |
| 2011 | } |
| 2012 | if ctx.outputDir == "" { |
| 2013 | return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName) |
| 2014 | } |
| 2015 | if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil { |
| 2016 | return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName) |
| 2017 | } |
| 2018 | return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName) |
| 2019 | } |
| 2020 | |
Sasha Smundak | 3deb968 | 2021-07-26 18:42:25 -0700 | [diff] [blame] | 2021 | func (ctx *parseContext) addSoongNamespace(ns string) { |
| 2022 | if _, ok := ctx.soongNamespaces[ns]; ok { |
| 2023 | return |
| 2024 | } |
| 2025 | ctx.soongNamespaces[ns] = make(map[string]bool) |
| 2026 | } |
| 2027 | |
| 2028 | func (ctx *parseContext) hasSoongNamespace(name string) bool { |
| 2029 | _, ok := ctx.soongNamespaces[name] |
| 2030 | return ok |
| 2031 | } |
| 2032 | |
| 2033 | func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) { |
| 2034 | ctx.addSoongNamespace(namespaceName) |
| 2035 | vars := ctx.soongNamespaces[namespaceName] |
| 2036 | if replace { |
| 2037 | vars = make(map[string]bool) |
| 2038 | ctx.soongNamespaces[namespaceName] = vars |
| 2039 | } |
| 2040 | for _, v := range varNames { |
| 2041 | vars[v] = true |
| 2042 | } |
| 2043 | } |
| 2044 | |
| 2045 | func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool { |
| 2046 | vars, ok := ctx.soongNamespaces[namespaceName] |
| 2047 | if ok { |
| 2048 | _, ok = vars[varName] |
| 2049 | } |
| 2050 | return ok |
| 2051 | } |
| 2052 | |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 2053 | func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation { |
| 2054 | return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())} |
| 2055 | } |
| 2056 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2057 | func (ss *StarlarkScript) String() string { |
| 2058 | return NewGenerateContext(ss).emit() |
| 2059 | } |
| 2060 | |
| 2061 | func (ss *StarlarkScript) SubConfigFiles() []string { |
Sasha Smundak | 6609ba7 | 2021-07-22 18:32:56 -0700 | [diff] [blame] | 2062 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2063 | var subs []string |
| 2064 | for _, src := range ss.inherited { |
| 2065 | subs = append(subs, src.originalPath) |
| 2066 | } |
| 2067 | return subs |
| 2068 | } |
| 2069 | |
| 2070 | func (ss *StarlarkScript) HasErrors() bool { |
| 2071 | return ss.hasErrors |
| 2072 | } |
| 2073 | |
| 2074 | // Convert reads and parses a makefile. If successful, parsed tree |
| 2075 | // is returned and then can be passed to String() to get the generated |
| 2076 | // Starlark file. |
| 2077 | func Convert(req Request) (*StarlarkScript, error) { |
| 2078 | reader := req.Reader |
| 2079 | if reader == nil { |
| 2080 | mkContents, err := ioutil.ReadFile(req.MkFile) |
| 2081 | if err != nil { |
| 2082 | return nil, err |
| 2083 | } |
| 2084 | reader = bytes.NewBuffer(mkContents) |
| 2085 | } |
| 2086 | parser := mkparser.NewParser(req.MkFile, reader) |
| 2087 | nodes, errs := parser.Parse() |
| 2088 | if len(errs) > 0 { |
| 2089 | for _, e := range errs { |
| 2090 | fmt.Fprintln(os.Stderr, "ERROR:", e) |
| 2091 | } |
| 2092 | return nil, fmt.Errorf("bad makefile %s", req.MkFile) |
| 2093 | } |
| 2094 | starScript := &StarlarkScript{ |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 2095 | moduleName: moduleNameForFile(req.MkFile), |
| 2096 | mkFile: req.MkFile, |
Sasha Smundak | 422b614 | 2021-11-11 18:31:59 -0800 | [diff] [blame] | 2097 | traceCalls: req.TraceCalls, |
| 2098 | sourceFS: req.SourceFS, |
| 2099 | makefileFinder: req.MakefileFinder, |
| 2100 | nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line }, |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 2101 | nodes: make([]starlarkNode, 0), |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2102 | } |
| 2103 | ctx := newParseContext(starScript, nodes) |
| 2104 | ctx.outputSuffix = req.OutputSuffix |
| 2105 | ctx.outputDir = req.OutputDir |
| 2106 | ctx.errorLogger = req.ErrorLogger |
| 2107 | if len(req.TracedVariables) > 0 { |
| 2108 | ctx.tracedVariables = make(map[string]bool) |
| 2109 | for _, v := range req.TracedVariables { |
| 2110 | ctx.tracedVariables[v] = true |
| 2111 | } |
| 2112 | } |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2113 | for ctx.hasNodes() && ctx.fatalError == nil { |
Cole Faust | dd569ae | 2022-01-31 15:48:29 -0800 | [diff] [blame] | 2114 | starScript.nodes = append(starScript.nodes, ctx.handleSimpleStatement(ctx.getNode())...) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2115 | } |
| 2116 | if ctx.fatalError != nil { |
| 2117 | return nil, ctx.fatalError |
| 2118 | } |
| 2119 | return starScript, nil |
| 2120 | } |
| 2121 | |
Cole Faust | 864028a | 2021-12-01 13:43:17 -0800 | [diff] [blame] | 2122 | func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string { |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2123 | var buf bytes.Buffer |
| 2124 | fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName) |
Cole Faust | 864028a | 2021-12-01 13:43:17 -0800 | [diff] [blame] | 2125 | fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri) |
Sasha Smundak | d7d07ad | 2021-09-10 15:42:34 -0700 | [diff] [blame] | 2126 | fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri) |
Cole Faust | 864028a | 2021-12-01 13:43:17 -0800 | [diff] [blame] | 2127 | fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName) |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2128 | return buf.String() |
| 2129 | } |
| 2130 | |
Cole Faust | 6ed7cb4 | 2021-10-07 17:08:46 -0700 | [diff] [blame] | 2131 | func BoardLauncher(mainModuleUri string, inputVariablesUri string) string { |
| 2132 | var buf bytes.Buffer |
| 2133 | fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName) |
| 2134 | fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri) |
| 2135 | fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri) |
Cole Faust | a060466 | 2022-02-28 11:53:58 -0800 | [diff] [blame] | 2136 | fmt.Fprintf(&buf, "%s(%s(init, input_variables_init))\n", cfnPrintVars, cfnBoardMain) |
Cole Faust | 6ed7cb4 | 2021-10-07 17:08:46 -0700 | [diff] [blame] | 2137 | return buf.String() |
| 2138 | } |
| 2139 | |
Sasha Smundak | b051c4e | 2020-11-05 20:45:07 -0800 | [diff] [blame] | 2140 | func MakePath2ModuleName(mkPath string) string { |
| 2141 | return strings.TrimSuffix(mkPath, filepath.Ext(mkPath)) |
| 2142 | } |