123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148 |
- // Copyright 2021 Google LLC
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
- // Convert makefile containing device configuration to Starlark file
- // The conversion can handle the following constructs in a makefile:
- // - comments
- // - simple variable assignments
- // - $(call init-product,<file>)
- // - $(call inherit-product-if-exists
- // - if directives
- //
- // All other constructs are carried over to the output starlark file as comments.
- package mk2rbc
- import (
- "bytes"
- "fmt"
- "io"
- "io/fs"
- "io/ioutil"
- "os"
- "path/filepath"
- "regexp"
- "sort"
- "strconv"
- "strings"
- "text/scanner"
- mkparser "android/soong/androidmk/parser"
- )
- const (
- annotationCommentPrefix = "RBC#"
- baseUri = "//build/make/core:product_config.rbc"
- // The name of the struct exported by the product_config.rbc
- // that contains the functions and variables available to
- // product configuration Starlark files.
- baseName = "rblf"
- soongNsPrefix = "SOONG_CONFIG_"
- // And here are the functions and variables:
- cfnGetCfg = baseName + ".cfg"
- cfnMain = baseName + ".product_configuration"
- cfnBoardMain = baseName + ".board_configuration"
- cfnPrintVars = baseName + ".printvars"
- cfnInherit = baseName + ".inherit"
- cfnSetListDefault = baseName + ".setdefault"
- )
- const (
- soongConfigAppend = "soong_config_append"
- soongConfigAssign = "soong_config_set"
- )
- var knownFunctions = map[string]interface {
- parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr
- }{
- "abspath": &simpleCallParser{name: baseName + ".abspath", returnType: starlarkTypeString},
- "add-product-dex-preopt-module-config": &simpleCallParser{name: baseName + ".add_product_dex_preopt_module_config", returnType: starlarkTypeString, addHandle: true},
- "add_soong_config_namespace": &simpleCallParser{name: baseName + ".soong_config_namespace", returnType: starlarkTypeVoid, addGlobals: true},
- "add_soong_config_var_value": &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
- soongConfigAssign: &simpleCallParser{name: baseName + ".soong_config_set", returnType: starlarkTypeVoid, addGlobals: true},
- soongConfigAppend: &simpleCallParser{name: baseName + ".soong_config_append", returnType: starlarkTypeVoid, addGlobals: true},
- "soong_config_get": &simpleCallParser{name: baseName + ".soong_config_get", returnType: starlarkTypeString, addGlobals: true},
- "add-to-product-copy-files-if-exists": &simpleCallParser{name: baseName + ".copy_if_exists", returnType: starlarkTypeList},
- "addprefix": &simpleCallParser{name: baseName + ".addprefix", returnType: starlarkTypeList},
- "addsuffix": &simpleCallParser{name: baseName + ".addsuffix", returnType: starlarkTypeList},
- "copy-files": &simpleCallParser{name: baseName + ".copy_files", returnType: starlarkTypeList},
- "dir": &simpleCallParser{name: baseName + ".dir", returnType: starlarkTypeString},
- "dist-for-goals": &simpleCallParser{name: baseName + ".mkdist_for_goals", returnType: starlarkTypeVoid, addGlobals: true},
- "enforce-product-packages-exist": &simpleCallParser{name: baseName + ".enforce_product_packages_exist", returnType: starlarkTypeVoid, addHandle: true},
- "error": &makeControlFuncParser{name: baseName + ".mkerror"},
- "findstring": &simpleCallParser{name: baseName + ".findstring", returnType: starlarkTypeInt},
- "find-copy-subdir-files": &simpleCallParser{name: baseName + ".find_and_copy", returnType: starlarkTypeList},
- "filter": &simpleCallParser{name: baseName + ".filter", returnType: starlarkTypeList},
- "filter-out": &simpleCallParser{name: baseName + ".filter_out", returnType: starlarkTypeList},
- "firstword": &simpleCallParser{name: baseName + ".first_word", returnType: starlarkTypeString},
- "foreach": &foreachCallParser{},
- "if": &ifCallParser{},
- "info": &makeControlFuncParser{name: baseName + ".mkinfo"},
- "is-board-platform": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
- "is-board-platform2": &simpleCallParser{name: baseName + ".board_platform_is", returnType: starlarkTypeBool, addGlobals: true},
- "is-board-platform-in-list": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
- "is-board-platform-in-list2": &simpleCallParser{name: baseName + ".board_platform_in", returnType: starlarkTypeBool, addGlobals: true},
- "is-product-in-list": &isProductInListCallParser{},
- "is-vendor-board-platform": &isVendorBoardPlatformCallParser{},
- "is-vendor-board-qcom": &isVendorBoardQcomCallParser{},
- "lastword": &simpleCallParser{name: baseName + ".last_word", returnType: starlarkTypeString},
- "notdir": &simpleCallParser{name: baseName + ".notdir", returnType: starlarkTypeString},
- "math_max": &mathMaxOrMinCallParser{function: "max"},
- "math_min": &mathMaxOrMinCallParser{function: "min"},
- "math_gt_or_eq": &mathComparisonCallParser{op: ">="},
- "math_gt": &mathComparisonCallParser{op: ">"},
- "math_lt": &mathComparisonCallParser{op: "<"},
- "my-dir": &myDirCallParser{},
- "patsubst": &substCallParser{fname: "patsubst"},
- "product-copy-files-by-pattern": &simpleCallParser{name: baseName + ".product_copy_files_by_pattern", returnType: starlarkTypeList},
- "require-artifacts-in-path": &simpleCallParser{name: baseName + ".require_artifacts_in_path", returnType: starlarkTypeVoid, addHandle: true},
- "require-artifacts-in-path-relaxed": &simpleCallParser{name: baseName + ".require_artifacts_in_path_relaxed", returnType: starlarkTypeVoid, addHandle: true},
- // TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
- "shell": &shellCallParser{},
- "sort": &simpleCallParser{name: baseName + ".mksort", returnType: starlarkTypeList},
- "strip": &simpleCallParser{name: baseName + ".mkstrip", returnType: starlarkTypeString},
- "subst": &substCallParser{fname: "subst"},
- "warning": &makeControlFuncParser{name: baseName + ".mkwarning"},
- "word": &wordCallParser{},
- "words": &wordsCallParser{},
- "wildcard": &simpleCallParser{name: baseName + ".expand_wildcard", returnType: starlarkTypeList},
- }
- // The same as knownFunctions, but returns a []starlarkNode instead of a starlarkExpr
- var knownNodeFunctions = map[string]interface {
- parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode
- }{
- "eval": &evalNodeParser{},
- "if": &ifCallNodeParser{},
- "inherit-product": &inheritProductCallParser{loadAlways: true},
- "inherit-product-if-exists": &inheritProductCallParser{loadAlways: false},
- "foreach": &foreachCallNodeParser{},
- }
- // These look like variables, but are actually functions, and would give
- // undefined variable errors if we converted them as variables. Instead,
- // emit an error instead of converting them.
- var unsupportedFunctions = map[string]bool{
- "local-generated-sources-dir": true,
- "local-intermediates-dir": true,
- }
- // These are functions that we don't implement conversions for, but
- // we allow seeing their definitions in the product config files.
- var ignoredDefines = map[string]bool{
- "find-word-in-list": true, // internal macro
- "get-vendor-board-platforms": true, // internal macro, used by is-board-platform, etc.
- "is-android-codename": true, // unused by product config
- "is-android-codename-in-list": true, // unused by product config
- "is-chipset-in-board-platform": true, // unused by product config
- "is-chipset-prefix-in-board-platform": true, // unused by product config
- "is-not-board-platform": true, // defined but never used
- "is-platform-sdk-version-at-least": true, // unused by product config
- "match-prefix": true, // internal macro
- "match-word": true, // internal macro
- "match-word-in-list": true, // internal macro
- "tb-modules": true, // defined in hardware/amlogic/tb_modules/tb_detect.mk, unused
- }
- var identifierFullMatchRegex = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
- // Conversion request parameters
- type Request struct {
- MkFile string // file to convert
- Reader io.Reader // if set, read input from this stream instead
- OutputSuffix string // generated Starlark files suffix
- OutputDir string // if set, root of the output hierarchy
- ErrorLogger ErrorLogger
- TracedVariables []string // trace assignment to these variables
- TraceCalls bool
- SourceFS fs.FS
- MakefileFinder MakefileFinder
- }
- // ErrorLogger prints errors and gathers error statistics.
- // Its NewError function is called on every error encountered during the conversion.
- type ErrorLogger interface {
- NewError(el ErrorLocation, node mkparser.Node, text string, args ...interface{})
- }
- type ErrorLocation struct {
- MkFile string
- MkLine int
- }
- func (el ErrorLocation) String() string {
- return fmt.Sprintf("%s:%d", el.MkFile, el.MkLine)
- }
- // Derives module name for a given file. It is base name
- // (file name without suffix), with some characters replaced to make it a Starlark identifier
- func moduleNameForFile(mkFile string) string {
- base := strings.TrimSuffix(filepath.Base(mkFile), filepath.Ext(mkFile))
- // TODO(asmundak): what else can be in the product file names?
- return strings.NewReplacer("-", "_", ".", "_").Replace(base)
- }
- func cloneMakeString(mkString *mkparser.MakeString) *mkparser.MakeString {
- r := &mkparser.MakeString{StringPos: mkString.StringPos}
- r.Strings = append(r.Strings, mkString.Strings...)
- r.Variables = append(r.Variables, mkString.Variables...)
- return r
- }
- func isMakeControlFunc(s string) bool {
- return s == "error" || s == "warning" || s == "info"
- }
- // varAssignmentScope points to the last assignment for each variable
- // in the current block. It is used during the parsing to chain
- // the assignments to a variable together.
- type varAssignmentScope struct {
- outer *varAssignmentScope
- vars map[string]bool
- }
- // Starlark output generation context
- type generationContext struct {
- buf strings.Builder
- starScript *StarlarkScript
- indentLevel int
- inAssignment bool
- tracedCount int
- varAssignments *varAssignmentScope
- }
- func NewGenerateContext(ss *StarlarkScript) *generationContext {
- return &generationContext{
- starScript: ss,
- varAssignments: &varAssignmentScope{
- outer: nil,
- vars: make(map[string]bool),
- },
- }
- }
- func (gctx *generationContext) pushVariableAssignments() {
- va := &varAssignmentScope{
- outer: gctx.varAssignments,
- vars: make(map[string]bool),
- }
- gctx.varAssignments = va
- }
- func (gctx *generationContext) popVariableAssignments() {
- gctx.varAssignments = gctx.varAssignments.outer
- }
- func (gctx *generationContext) hasBeenAssigned(v variable) bool {
- for va := gctx.varAssignments; va != nil; va = va.outer {
- if _, ok := va.vars[v.name()]; ok {
- return true
- }
- }
- return false
- }
- func (gctx *generationContext) setHasBeenAssigned(v variable) {
- gctx.varAssignments.vars[v.name()] = true
- }
- // emit returns generated script
- func (gctx *generationContext) emit() string {
- ss := gctx.starScript
- // The emitted code has the following layout:
- // <initial comments>
- // preamble, i.e.,
- // load statement for the runtime support
- // load statement for each unique submodule pulled in by this one
- // def init(g, handle):
- // cfg = rblf.cfg(handle)
- // <statements>
- // <warning if conversion was not clean>
- iNode := len(ss.nodes)
- for i, node := range ss.nodes {
- if _, ok := node.(*commentNode); !ok {
- iNode = i
- break
- }
- node.emit(gctx)
- }
- gctx.emitPreamble()
- gctx.newLine()
- // The arguments passed to the init function are the global dictionary
- // ('g') and the product configuration dictionary ('cfg')
- gctx.write("def init(g, handle):")
- gctx.indentLevel++
- if gctx.starScript.traceCalls {
- gctx.newLine()
- gctx.writef(`print(">%s")`, gctx.starScript.mkFile)
- }
- gctx.newLine()
- gctx.writef("cfg = %s(handle)", cfnGetCfg)
- for _, node := range ss.nodes[iNode:] {
- node.emit(gctx)
- }
- if gctx.starScript.traceCalls {
- gctx.newLine()
- gctx.writef(`print("<%s")`, gctx.starScript.mkFile)
- }
- gctx.indentLevel--
- gctx.write("\n")
- return gctx.buf.String()
- }
- func (gctx *generationContext) emitPreamble() {
- gctx.newLine()
- gctx.writef("load(%q, %q)", baseUri, baseName)
- // Emit exactly one load statement for each URI.
- loadedSubConfigs := make(map[string]string)
- for _, mi := range gctx.starScript.inherited {
- uri := mi.path
- if m, ok := loadedSubConfigs[uri]; ok {
- // No need to emit load statement, but fix module name.
- mi.moduleLocalName = m
- continue
- }
- if mi.optional || mi.missing {
- uri += "|init"
- }
- gctx.newLine()
- gctx.writef("load(%q, %s = \"init\")", uri, mi.entryName())
- loadedSubConfigs[uri] = mi.moduleLocalName
- }
- gctx.write("\n")
- }
- func (gctx *generationContext) emitPass() {
- gctx.newLine()
- gctx.write("pass")
- }
- func (gctx *generationContext) write(ss ...string) {
- for _, s := range ss {
- gctx.buf.WriteString(s)
- }
- }
- func (gctx *generationContext) writef(format string, args ...interface{}) {
- gctx.write(fmt.Sprintf(format, args...))
- }
- func (gctx *generationContext) newLine() {
- if gctx.buf.Len() == 0 {
- return
- }
- gctx.write("\n")
- gctx.writef("%*s", 2*gctx.indentLevel, "")
- }
- func (gctx *generationContext) emitConversionError(el ErrorLocation, message string) {
- gctx.writef(`rblf.mk2rbc_error("%s", %q)`, el, message)
- }
- func (gctx *generationContext) emitLoadCheck(im inheritedModule) {
- if !im.needsLoadCheck() {
- return
- }
- gctx.newLine()
- gctx.writef("if not %s:", im.entryName())
- gctx.indentLevel++
- gctx.newLine()
- gctx.write(`rblf.mkerror("`, gctx.starScript.mkFile, `", "Cannot find %s" % (`)
- im.pathExpr().emit(gctx)
- gctx.write("))")
- gctx.indentLevel--
- }
- type knownVariable struct {
- name string
- class varClass
- valueType starlarkType
- }
- type knownVariables map[string]knownVariable
- func (pcv knownVariables) NewVariable(name string, varClass varClass, valueType starlarkType) {
- v, exists := pcv[name]
- if !exists {
- pcv[name] = knownVariable{name, varClass, valueType}
- return
- }
- // Conflict resolution:
- // * config class trumps everything
- // * any type trumps unknown type
- match := varClass == v.class
- if !match {
- if varClass == VarClassConfig {
- v.class = VarClassConfig
- match = true
- } else if v.class == VarClassConfig {
- match = true
- }
- }
- if valueType != v.valueType {
- if valueType != starlarkTypeUnknown {
- if v.valueType == starlarkTypeUnknown {
- v.valueType = valueType
- } else {
- match = false
- }
- }
- }
- if !match {
- fmt.Fprintf(os.Stderr, "cannot redefine %s as %v/%v (already defined as %v/%v)\n",
- name, varClass, valueType, v.class, v.valueType)
- }
- }
- // All known product variables.
- var KnownVariables = make(knownVariables)
- func init() {
- for _, kv := range []string{
- // Kernel-related variables that we know are lists.
- "BOARD_VENDOR_KERNEL_MODULES",
- "BOARD_VENDOR_RAMDISK_KERNEL_MODULES",
- "BOARD_VENDOR_RAMDISK_KERNEL_MODULES_LOAD",
- "BOARD_RECOVERY_KERNEL_MODULES",
- // Other variables we knwo are lists
- "ART_APEX_JARS",
- } {
- KnownVariables.NewVariable(kv, VarClassSoong, starlarkTypeList)
- }
- }
- // Information about the generated Starlark script.
- type StarlarkScript struct {
- mkFile string
- moduleName string
- mkPos scanner.Position
- nodes []starlarkNode
- inherited []*moduleInfo
- hasErrors bool
- traceCalls bool // print enter/exit each init function
- sourceFS fs.FS
- makefileFinder MakefileFinder
- nodeLocator func(pos mkparser.Pos) int
- }
- // parseContext holds the script we are generating and all the ephemeral data
- // needed during the parsing.
- type parseContext struct {
- script *StarlarkScript
- nodes []mkparser.Node // Makefile as parsed by mkparser
- currentNodeIndex int // Node in it we are processing
- ifNestLevel int
- moduleNameCount map[string]int // count of imported modules with given basename
- fatalError error
- outputSuffix string
- errorLogger ErrorLogger
- tracedVariables map[string]bool // variables to be traced in the generated script
- variables map[string]variable
- outputDir string
- dependentModules map[string]*moduleInfo
- soongNamespaces map[string]map[string]bool
- includeTops []string
- typeHints map[string]starlarkType
- atTopOfMakefile bool
- }
- func newParseContext(ss *StarlarkScript, nodes []mkparser.Node) *parseContext {
- predefined := []struct{ name, value string }{
- {"SRC_TARGET_DIR", filepath.Join("build", "make", "target")},
- {"LOCAL_PATH", filepath.Dir(ss.mkFile)},
- {"MAKEFILE_LIST", ss.mkFile},
- {"TOPDIR", ""}, // TOPDIR is just set to an empty string in cleanbuild.mk and core.mk
- // TODO(asmundak): maybe read it from build/make/core/envsetup.mk?
- {"TARGET_COPY_OUT_SYSTEM", "system"},
- {"TARGET_COPY_OUT_SYSTEM_OTHER", "system_other"},
- {"TARGET_COPY_OUT_DATA", "data"},
- {"TARGET_COPY_OUT_ASAN", filepath.Join("data", "asan")},
- {"TARGET_COPY_OUT_OEM", "oem"},
- {"TARGET_COPY_OUT_RAMDISK", "ramdisk"},
- {"TARGET_COPY_OUT_DEBUG_RAMDISK", "debug_ramdisk"},
- {"TARGET_COPY_OUT_VENDOR_DEBUG_RAMDISK", "vendor_debug_ramdisk"},
- {"TARGET_COPY_OUT_TEST_HARNESS_RAMDISK", "test_harness_ramdisk"},
- {"TARGET_COPY_OUT_ROOT", "root"},
- {"TARGET_COPY_OUT_RECOVERY", "recovery"},
- {"TARGET_COPY_OUT_VENDOR_RAMDISK", "vendor_ramdisk"},
- // TODO(asmundak): to process internal config files, we need the following variables:
- // TARGET_VENDOR
- // target_base_product
- //
- // the following utility variables are set in build/make/common/core.mk:
- {"empty", ""},
- {"space", " "},
- {"comma", ","},
- {"newline", "\n"},
- {"pound", "#"},
- {"backslash", "\\"},
- }
- ctx := &parseContext{
- script: ss,
- nodes: nodes,
- currentNodeIndex: 0,
- ifNestLevel: 0,
- moduleNameCount: make(map[string]int),
- variables: make(map[string]variable),
- dependentModules: make(map[string]*moduleInfo),
- soongNamespaces: make(map[string]map[string]bool),
- includeTops: []string{},
- typeHints: make(map[string]starlarkType),
- atTopOfMakefile: true,
- }
- for _, item := range predefined {
- ctx.variables[item.name] = &predefinedVariable{
- baseVariable: baseVariable{nam: item.name, typ: starlarkTypeString},
- value: &stringLiteralExpr{item.value},
- }
- }
- return ctx
- }
- func (ctx *parseContext) hasNodes() bool {
- return ctx.currentNodeIndex < len(ctx.nodes)
- }
- func (ctx *parseContext) getNode() mkparser.Node {
- if !ctx.hasNodes() {
- return nil
- }
- node := ctx.nodes[ctx.currentNodeIndex]
- ctx.currentNodeIndex++
- return node
- }
- func (ctx *parseContext) backNode() {
- if ctx.currentNodeIndex <= 0 {
- panic("Cannot back off")
- }
- ctx.currentNodeIndex--
- }
- func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) []starlarkNode {
- // Handle only simple variables
- if !a.Name.Const() || a.Target != nil {
- return []starlarkNode{ctx.newBadNode(a, "Only simple variables are handled")}
- }
- name := a.Name.Strings[0]
- // The `override` directive
- // override FOO :=
- // is parsed as an assignment to a variable named `override FOO`.
- // There are very few places where `override` is used, just flag it.
- if strings.HasPrefix(name, "override ") {
- return []starlarkNode{ctx.newBadNode(a, "cannot handle override directive")}
- }
- if name == ".KATI_READONLY" {
- // Skip assignments to .KATI_READONLY. If it was in the output file, it
- // would be an error because it would be sorted before the definition of
- // the variable it's trying to make readonly.
- return []starlarkNode{}
- }
- // Soong configuration
- if strings.HasPrefix(name, soongNsPrefix) {
- return ctx.handleSoongNsAssignment(strings.TrimPrefix(name, soongNsPrefix), a)
- }
- lhs := ctx.addVariable(name)
- if lhs == nil {
- return []starlarkNode{ctx.newBadNode(a, "unknown variable %s", name)}
- }
- _, isTraced := ctx.tracedVariables[lhs.name()]
- asgn := &assignmentNode{lhs: lhs, mkValue: a.Value, isTraced: isTraced, location: ctx.errorLocation(a)}
- if lhs.valueType() == starlarkTypeUnknown {
- // Try to divine variable type from the RHS
- asgn.value = ctx.parseMakeString(a, a.Value)
- inferred_type := asgn.value.typ()
- if inferred_type != starlarkTypeUnknown {
- lhs.setValueType(inferred_type)
- }
- }
- if lhs.valueType() == starlarkTypeList {
- xConcat, xBad := ctx.buildConcatExpr(a)
- if xBad != nil {
- asgn.value = xBad
- } else {
- switch len(xConcat.items) {
- case 0:
- asgn.value = &listExpr{}
- case 1:
- asgn.value = xConcat.items[0]
- default:
- asgn.value = xConcat
- }
- }
- } else {
- asgn.value = ctx.parseMakeString(a, a.Value)
- }
- if asgn.lhs.valueType() == starlarkTypeString &&
- asgn.value.typ() != starlarkTypeUnknown &&
- asgn.value.typ() != starlarkTypeString {
- asgn.value = &toStringExpr{expr: asgn.value}
- }
- switch a.Type {
- case "=", ":=":
- asgn.flavor = asgnSet
- case "+=":
- asgn.flavor = asgnAppend
- case "?=":
- asgn.flavor = asgnMaybeSet
- default:
- panic(fmt.Errorf("unexpected assignment type %s", a.Type))
- }
- return []starlarkNode{asgn}
- }
- func (ctx *parseContext) handleSoongNsAssignment(name string, asgn *mkparser.Assignment) []starlarkNode {
- val := ctx.parseMakeString(asgn, asgn.Value)
- if xBad, ok := val.(*badExpr); ok {
- return []starlarkNode{&exprNode{expr: xBad}}
- }
- // Unfortunately, Soong namespaces can be set up by directly setting corresponding Make
- // variables instead of via add_soong_config_namespace + add_soong_config_var_value.
- // Try to divine the call from the assignment as follows:
- if name == "NAMESPACES" {
- // Upon seeng
- // SOONG_CONFIG_NAMESPACES += foo
- // remember that there is a namespace `foo` and act as we saw
- // $(call add_soong_config_namespace,foo)
- s, ok := maybeString(val)
- if !ok {
- return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_NAMESPACES assignment, please use add_soong_config_namespace instead")}
- }
- result := make([]starlarkNode, 0)
- for _, ns := range strings.Fields(s) {
- ctx.addSoongNamespace(ns)
- result = append(result, &exprNode{&callExpr{
- name: baseName + ".soong_config_namespace",
- args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{ns}},
- returnType: starlarkTypeVoid,
- }})
- }
- return result
- } else {
- // Upon seeing
- // SOONG_CONFIG_x_y = v
- // find a namespace called `x` and act as if we encountered
- // $(call soong_config_set,x,y,v)
- // or check that `x_y` is a namespace, and then add the RHS of this assignment as variables in
- // it.
- // Emit an error in the ambiguous situation (namespaces `foo_bar` with a variable `baz`
- // and `foo` with a variable `bar_baz`.
- namespaceName := ""
- if ctx.hasSoongNamespace(name) {
- namespaceName = name
- }
- var varName string
- for pos, ch := range name {
- if !(ch == '_' && ctx.hasSoongNamespace(name[0:pos])) {
- continue
- }
- if namespaceName != "" {
- return []starlarkNode{ctx.newBadNode(asgn, "ambiguous soong namespace (may be either `%s` or `%s`)", namespaceName, name[0:pos])}
- }
- namespaceName = name[0:pos]
- varName = name[pos+1:]
- }
- if namespaceName == "" {
- return []starlarkNode{ctx.newBadNode(asgn, "cannot figure out Soong namespace, please use add_soong_config_var_value macro instead")}
- }
- if varName == "" {
- // Remember variables in this namespace
- s, ok := maybeString(val)
- if !ok {
- return []starlarkNode{ctx.newBadNode(asgn, "cannot handle variables in SOONG_CONFIG_ assignment, please use add_soong_config_var_value instead")}
- }
- ctx.updateSoongNamespace(asgn.Type != "+=", namespaceName, strings.Fields(s))
- return []starlarkNode{}
- }
- // Finally, handle assignment to a namespace variable
- if !ctx.hasNamespaceVar(namespaceName, varName) {
- return []starlarkNode{ctx.newBadNode(asgn, "no %s variable in %s namespace, please use add_soong_config_var_value instead", varName, namespaceName)}
- }
- fname := baseName + "." + soongConfigAssign
- if asgn.Type == "+=" {
- fname = baseName + "." + soongConfigAppend
- }
- return []starlarkNode{&exprNode{&callExpr{
- name: fname,
- args: []starlarkExpr{&globalsExpr{}, &stringLiteralExpr{namespaceName}, &stringLiteralExpr{varName}, val},
- returnType: starlarkTypeVoid,
- }}}
- }
- }
- func (ctx *parseContext) buildConcatExpr(a *mkparser.Assignment) (*concatExpr, *badExpr) {
- xConcat := &concatExpr{}
- var xItemList *listExpr
- addToItemList := func(x ...starlarkExpr) {
- if xItemList == nil {
- xItemList = &listExpr{[]starlarkExpr{}}
- }
- xItemList.items = append(xItemList.items, x...)
- }
- finishItemList := func() {
- if xItemList != nil {
- xConcat.items = append(xConcat.items, xItemList)
- xItemList = nil
- }
- }
- items := a.Value.Words()
- for _, item := range items {
- // A function call in RHS is supposed to return a list, all other item
- // expressions return individual elements.
- switch x := ctx.parseMakeString(a, item).(type) {
- case *badExpr:
- return nil, x
- case *stringLiteralExpr:
- addToItemList(maybeConvertToStringList(x).(*listExpr).items...)
- default:
- switch x.typ() {
- case starlarkTypeList:
- finishItemList()
- xConcat.items = append(xConcat.items, x)
- case starlarkTypeString:
- finishItemList()
- xConcat.items = append(xConcat.items, &callExpr{
- object: x,
- name: "split",
- args: nil,
- returnType: starlarkTypeList,
- })
- default:
- addToItemList(x)
- }
- }
- }
- if xItemList != nil {
- xConcat.items = append(xConcat.items, xItemList)
- }
- return xConcat, nil
- }
- func (ctx *parseContext) newDependentModule(path string, optional bool) *moduleInfo {
- modulePath := ctx.loadedModulePath(path)
- if mi, ok := ctx.dependentModules[modulePath]; ok {
- mi.optional = mi.optional && optional
- return mi
- }
- moduleName := moduleNameForFile(path)
- moduleLocalName := "_" + moduleName
- n, found := ctx.moduleNameCount[moduleName]
- if found {
- moduleLocalName += fmt.Sprintf("%d", n)
- }
- ctx.moduleNameCount[moduleName] = n + 1
- _, err := fs.Stat(ctx.script.sourceFS, path)
- mi := &moduleInfo{
- path: modulePath,
- originalPath: path,
- moduleLocalName: moduleLocalName,
- optional: optional,
- missing: err != nil,
- }
- ctx.dependentModules[modulePath] = mi
- ctx.script.inherited = append(ctx.script.inherited, mi)
- return mi
- }
- func (ctx *parseContext) handleSubConfig(
- v mkparser.Node, pathExpr starlarkExpr, loadAlways bool, processModule func(inheritedModule) starlarkNode) []starlarkNode {
- // Allow seeing $(sort $(wildcard realPathExpr)) or $(wildcard realPathExpr)
- // because those are functionally the same as not having the sort/wildcard calls.
- if ce, ok := pathExpr.(*callExpr); ok && ce.name == "rblf.mksort" && len(ce.args) == 1 {
- if ce2, ok2 := ce.args[0].(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
- pathExpr = ce2.args[0]
- }
- } else if ce2, ok2 := pathExpr.(*callExpr); ok2 && ce2.name == "rblf.expand_wildcard" && len(ce2.args) == 1 {
- pathExpr = ce2.args[0]
- }
- // In a simple case, the name of a module to inherit/include is known statically.
- if path, ok := maybeString(pathExpr); ok {
- // Note that even if this directive loads a module unconditionally, a module may be
- // absent without causing any harm if this directive is inside an if/else block.
- moduleShouldExist := loadAlways && ctx.ifNestLevel == 0
- if strings.Contains(path, "*") {
- if paths, err := fs.Glob(ctx.script.sourceFS, path); err == nil {
- sort.Strings(paths)
- result := make([]starlarkNode, 0)
- for _, p := range paths {
- mi := ctx.newDependentModule(p, !moduleShouldExist)
- result = append(result, processModule(inheritedStaticModule{mi, loadAlways}))
- }
- return result
- } else {
- return []starlarkNode{ctx.newBadNode(v, "cannot glob wildcard argument")}
- }
- } else {
- mi := ctx.newDependentModule(path, !moduleShouldExist)
- return []starlarkNode{processModule(inheritedStaticModule{mi, loadAlways})}
- }
- }
- // If module path references variables (e.g., $(v1)/foo/$(v2)/device-config.mk), find all the paths in the
- // source tree that may be a match and the corresponding variable values. For instance, if the source tree
- // contains vendor1/foo/abc/dev.mk and vendor2/foo/def/dev.mk, the first one will be inherited when
- // (v1, v2) == ('vendor1', 'abc'), and the second one when (v1, v2) == ('vendor2', 'def').
- // We then emit the code that loads all of them, e.g.:
- // load("//vendor1/foo/abc:dev.rbc", _dev1_init="init")
- // load("//vendor2/foo/def/dev.rbc", _dev2_init="init")
- // And then inherit it as follows:
- // _e = {
- // "vendor1/foo/abc/dev.mk": ("vendor1/foo/abc/dev", _dev1_init),
- // "vendor2/foo/def/dev.mk": ("vendor2/foo/def/dev", _dev_init2) }.get("%s/foo/%s/dev.mk" % (v1, v2))
- // if _e:
- // rblf.inherit(handle, _e[0], _e[1])
- //
- var matchingPaths []string
- var needsWarning = false
- if interpolate, ok := pathExpr.(*interpolateExpr); ok {
- pathPattern := []string{interpolate.chunks[0]}
- for _, chunk := range interpolate.chunks[1:] {
- if chunk != "" {
- pathPattern = append(pathPattern, chunk)
- }
- }
- if len(pathPattern) == 1 {
- pathPattern = append(pathPattern, "")
- }
- matchingPaths = ctx.findMatchingPaths(pathPattern)
- needsWarning = pathPattern[0] == "" && len(ctx.includeTops) == 0
- } else if len(ctx.includeTops) > 0 {
- matchingPaths = append(matchingPaths, ctx.findMatchingPaths([]string{"", ""})...)
- } else {
- return []starlarkNode{ctx.newBadNode(v, "inherit-product/include argument is too complex")}
- }
- // Safeguard against $(call inherit-product,$(PRODUCT_PATH))
- const maxMatchingFiles = 150
- if len(matchingPaths) > maxMatchingFiles {
- return []starlarkNode{ctx.newBadNode(v, "there are >%d files matching the pattern, please rewrite it", maxMatchingFiles)}
- }
- res := inheritedDynamicModule{pathExpr, []*moduleInfo{}, loadAlways, ctx.errorLocation(v), needsWarning}
- for _, p := range matchingPaths {
- // A product configuration files discovered dynamically may attempt to inherit
- // from another one which does not exist in this source tree. Prevent load errors
- // by always loading the dynamic files as optional.
- res.candidateModules = append(res.candidateModules, ctx.newDependentModule(p, true))
- }
- return []starlarkNode{processModule(res)}
- }
- func (ctx *parseContext) findMatchingPaths(pattern []string) []string {
- files := ctx.script.makefileFinder.Find(".")
- if len(pattern) == 0 {
- return files
- }
- // Create regular expression from the pattern
- regexString := "^" + regexp.QuoteMeta(pattern[0])
- for _, s := range pattern[1:] {
- regexString += ".*" + regexp.QuoteMeta(s)
- }
- regexString += "$"
- rex := regexp.MustCompile(regexString)
- includeTopRegexString := ""
- if len(ctx.includeTops) > 0 {
- for i, top := range ctx.includeTops {
- if i > 0 {
- includeTopRegexString += "|"
- }
- includeTopRegexString += "^" + regexp.QuoteMeta(top)
- }
- } else {
- includeTopRegexString = ".*"
- }
- includeTopRegex := regexp.MustCompile(includeTopRegexString)
- // Now match
- var res []string
- for _, p := range files {
- if rex.MatchString(p) && includeTopRegex.MatchString(p) {
- res = append(res, p)
- }
- }
- return res
- }
- type inheritProductCallParser struct {
- loadAlways bool
- }
- func (p *inheritProductCallParser) parse(ctx *parseContext, v mkparser.Node, args *mkparser.MakeString) []starlarkNode {
- args.TrimLeftSpaces()
- args.TrimRightSpaces()
- pathExpr := ctx.parseMakeString(v, args)
- if _, ok := pathExpr.(*badExpr); ok {
- return []starlarkNode{ctx.newBadNode(v, "Unable to parse argument to inherit")}
- }
- return ctx.handleSubConfig(v, pathExpr, p.loadAlways, func(im inheritedModule) starlarkNode {
- return &inheritNode{im, p.loadAlways}
- })
- }
- func (ctx *parseContext) handleInclude(v *mkparser.Directive) []starlarkNode {
- loadAlways := v.Name[0] != '-'
- return ctx.handleSubConfig(v, ctx.parseMakeString(v, v.Args), loadAlways, func(im inheritedModule) starlarkNode {
- return &includeNode{im, loadAlways}
- })
- }
- func (ctx *parseContext) handleVariable(v *mkparser.Variable) []starlarkNode {
- // Handle:
- // $(call inherit-product,...)
- // $(call inherit-product-if-exists,...)
- // $(info xxx)
- // $(warning xxx)
- // $(error xxx)
- // $(call other-custom-functions,...)
- if name, args, ok := ctx.maybeParseFunctionCall(v, v.Name); ok {
- if kf, ok := knownNodeFunctions[name]; ok {
- return kf.parse(ctx, v, args)
- }
- }
- return []starlarkNode{&exprNode{expr: ctx.parseReference(v, v.Name)}}
- }
- func (ctx *parseContext) maybeHandleDefine(directive *mkparser.Directive) starlarkNode {
- macro_name := strings.Fields(directive.Args.Strings[0])[0]
- // Ignore the macros that we handle
- _, ignored := ignoredDefines[macro_name]
- _, known := knownFunctions[macro_name]
- if !ignored && !known {
- return ctx.newBadNode(directive, "define is not supported: %s", macro_name)
- }
- return nil
- }
- func (ctx *parseContext) handleIfBlock(ifDirective *mkparser.Directive) starlarkNode {
- ssSwitch := &switchNode{
- ssCases: []*switchCase{ctx.processBranch(ifDirective)},
- }
- for ctx.hasNodes() && ctx.fatalError == nil {
- node := ctx.getNode()
- switch x := node.(type) {
- case *mkparser.Directive:
- switch x.Name {
- case "else", "elifdef", "elifndef", "elifeq", "elifneq":
- ssSwitch.ssCases = append(ssSwitch.ssCases, ctx.processBranch(x))
- case "endif":
- return ssSwitch
- default:
- return ctx.newBadNode(node, "unexpected directive %s", x.Name)
- }
- default:
- return ctx.newBadNode(ifDirective, "unexpected statement")
- }
- }
- if ctx.fatalError == nil {
- ctx.fatalError = fmt.Errorf("no matching endif for %s", ifDirective.Dump())
- }
- return ctx.newBadNode(ifDirective, "no matching endif for %s", ifDirective.Dump())
- }
- // processBranch processes a single branch (if/elseif/else) until the next directive
- // on the same level.
- func (ctx *parseContext) processBranch(check *mkparser.Directive) *switchCase {
- block := &switchCase{gate: ctx.parseCondition(check)}
- defer func() {
- ctx.ifNestLevel--
- }()
- ctx.ifNestLevel++
- for ctx.hasNodes() {
- node := ctx.getNode()
- if d, ok := node.(*mkparser.Directive); ok {
- switch d.Name {
- case "else", "elifdef", "elifndef", "elifeq", "elifneq", "endif":
- ctx.backNode()
- return block
- }
- }
- block.nodes = append(block.nodes, ctx.handleSimpleStatement(node)...)
- }
- ctx.fatalError = fmt.Errorf("no matching endif for %s", check.Dump())
- return block
- }
- func (ctx *parseContext) parseCondition(check *mkparser.Directive) starlarkNode {
- switch check.Name {
- case "ifdef", "ifndef", "elifdef", "elifndef":
- if !check.Args.Const() {
- return ctx.newBadNode(check, "ifdef variable ref too complex: %s", check.Args.Dump())
- }
- v := NewVariableRefExpr(ctx.addVariable(check.Args.Strings[0]))
- if strings.HasSuffix(check.Name, "ndef") {
- v = ¬Expr{v}
- }
- return &ifNode{
- isElif: strings.HasPrefix(check.Name, "elif"),
- expr: v,
- }
- case "ifeq", "ifneq", "elifeq", "elifneq":
- return &ifNode{
- isElif: strings.HasPrefix(check.Name, "elif"),
- expr: ctx.parseCompare(check),
- }
- case "else":
- return &elseNode{}
- default:
- panic(fmt.Errorf("%s: unknown directive: %s", ctx.script.mkFile, check.Dump()))
- }
- }
- func (ctx *parseContext) newBadExpr(node mkparser.Node, text string, args ...interface{}) starlarkExpr {
- if ctx.errorLogger != nil {
- ctx.errorLogger.NewError(ctx.errorLocation(node), node, text, args...)
- }
- ctx.script.hasErrors = true
- return &badExpr{errorLocation: ctx.errorLocation(node), message: fmt.Sprintf(text, args...)}
- }
- // records that the given node failed to be converted and includes an explanatory message
- func (ctx *parseContext) newBadNode(failedNode mkparser.Node, message string, args ...interface{}) starlarkNode {
- return &exprNode{ctx.newBadExpr(failedNode, message, args...)}
- }
- func (ctx *parseContext) parseCompare(cond *mkparser.Directive) starlarkExpr {
- // Strip outer parentheses
- mkArg := cloneMakeString(cond.Args)
- mkArg.Strings[0] = strings.TrimLeft(mkArg.Strings[0], "( ")
- n := len(mkArg.Strings)
- mkArg.Strings[n-1] = strings.TrimRight(mkArg.Strings[n-1], ") ")
- args := mkArg.Split(",")
- // TODO(asmundak): handle the case where the arguments are in quotes and space-separated
- if len(args) != 2 {
- return ctx.newBadExpr(cond, "ifeq/ifneq len(args) != 2 %s", cond.Dump())
- }
- args[0].TrimRightSpaces()
- args[1].TrimLeftSpaces()
- isEq := !strings.HasSuffix(cond.Name, "neq")
- xLeft := ctx.parseMakeString(cond, args[0])
- xRight := ctx.parseMakeString(cond, args[1])
- if bad, ok := xLeft.(*badExpr); ok {
- return bad
- }
- if bad, ok := xRight.(*badExpr); ok {
- return bad
- }
- if expr, ok := ctx.parseCompareSpecialCases(cond, xLeft, xRight); ok {
- return expr
- }
- var stringOperand string
- var otherOperand starlarkExpr
- if s, ok := maybeString(xLeft); ok {
- stringOperand = s
- otherOperand = xRight
- } else if s, ok := maybeString(xRight); ok {
- stringOperand = s
- otherOperand = xLeft
- }
- // If we've identified one of the operands as being a string literal, check
- // for some special cases we can do to simplify the resulting expression.
- if otherOperand != nil {
- if stringOperand == "" {
- if isEq {
- return negateExpr(otherOperand)
- } else {
- return otherOperand
- }
- }
- if stringOperand == "true" && otherOperand.typ() == starlarkTypeBool {
- if !isEq {
- return negateExpr(otherOperand)
- } else {
- return otherOperand
- }
- }
- if otherOperand.typ() == starlarkTypeList {
- fields := strings.Fields(stringOperand)
- elements := make([]starlarkExpr, len(fields))
- for i, s := range fields {
- elements[i] = &stringLiteralExpr{literal: s}
- }
- return &eqExpr{
- left: otherOperand,
- right: &listExpr{elements},
- isEq: isEq,
- }
- }
- if intOperand, err := strconv.Atoi(strings.TrimSpace(stringOperand)); err == nil && otherOperand.typ() == starlarkTypeInt {
- return &eqExpr{
- left: otherOperand,
- right: &intLiteralExpr{literal: intOperand},
- isEq: isEq,
- }
- }
- }
- return &eqExpr{left: xLeft, right: xRight, isEq: isEq}
- }
- // Given an if statement's directive and the left/right starlarkExprs,
- // check if the starlarkExprs are one of a few hardcoded special cases
- // that can be converted to a simpler equality expression than simply comparing
- // the two.
- func (ctx *parseContext) parseCompareSpecialCases(directive *mkparser.Directive, left starlarkExpr,
- right starlarkExpr) (starlarkExpr, bool) {
- isEq := !strings.HasSuffix(directive.Name, "neq")
- // All the special cases require a call on one side and a
- // string literal/variable on the other. Turn the left/right variables into
- // call/value variables, and return false if that's not possible.
- var value starlarkExpr = nil
- call, ok := left.(*callExpr)
- if ok {
- switch right.(type) {
- case *stringLiteralExpr, *variableRefExpr:
- value = right
- }
- } else {
- call, _ = right.(*callExpr)
- switch left.(type) {
- case *stringLiteralExpr, *variableRefExpr:
- value = left
- }
- }
- if call == nil || value == nil {
- return nil, false
- }
- switch call.name {
- case baseName + ".filter":
- return ctx.parseCompareFilterFuncResult(directive, call, value, isEq)
- case baseName + ".findstring":
- return ctx.parseCheckFindstringFuncResult(directive, call, value, !isEq), true
- case baseName + ".strip":
- return ctx.parseCompareStripFuncResult(directive, call, value, !isEq), true
- }
- return nil, false
- }
- func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
- filterFuncCall *callExpr, xValue starlarkExpr, negate bool) (starlarkExpr, bool) {
- // We handle:
- // * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
- // * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
- if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" {
- return nil, false
- }
- xPattern := filterFuncCall.args[0]
- xText := filterFuncCall.args[1]
- var xInList *stringLiteralExpr
- var expr starlarkExpr
- var ok bool
- if xInList, ok = xPattern.(*stringLiteralExpr); ok && !strings.ContainsRune(xInList.literal, '%') && xText.typ() == starlarkTypeList {
- expr = xText
- } else if xInList, ok = xText.(*stringLiteralExpr); ok {
- expr = xPattern
- } else {
- return nil, false
- }
- slExpr := newStringListExpr(strings.Fields(xInList.literal))
- // Generate simpler code for the common cases:
- if expr.typ() == starlarkTypeList {
- if len(slExpr.items) == 1 {
- // Checking that a string belongs to list
- return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}, true
- } else {
- return nil, false
- }
- } else if len(slExpr.items) == 1 {
- return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}, true
- } else {
- return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}, true
- }
- }
- func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
- xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
- if isEmptyString(xValue) {
- return &eqExpr{
- left: &callExpr{
- object: xCall.args[1],
- name: "find",
- args: []starlarkExpr{xCall.args[0]},
- returnType: starlarkTypeInt,
- },
- right: &intLiteralExpr{-1},
- isEq: !negate,
- }
- } else if s, ok := maybeString(xValue); ok {
- if s2, ok := maybeString(xCall.args[0]); ok && s == s2 {
- return &eqExpr{
- left: &callExpr{
- object: xCall.args[1],
- name: "find",
- args: []starlarkExpr{xCall.args[0]},
- returnType: starlarkTypeInt,
- },
- right: &intLiteralExpr{-1},
- isEq: negate,
- }
- }
- }
- return ctx.newBadExpr(directive, "$(findstring) can only be compared to nothing or its first argument")
- }
- func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,
- xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
- if _, ok := xValue.(*stringLiteralExpr); !ok {
- return ctx.newBadExpr(directive, "strip result can be compared only to string: %s", xValue)
- }
- return &eqExpr{
- left: &callExpr{
- name: "strip",
- args: xCall.args,
- returnType: starlarkTypeString,
- },
- right: xValue, isEq: !negate}
- }
- func (ctx *parseContext) maybeParseFunctionCall(node mkparser.Node, ref *mkparser.MakeString) (name string, args *mkparser.MakeString, ok bool) {
- ref.TrimLeftSpaces()
- ref.TrimRightSpaces()
- words := ref.SplitN(" ", 2)
- if !words[0].Const() {
- return "", nil, false
- }
- name = words[0].Dump()
- args = mkparser.SimpleMakeString("", words[0].Pos())
- if len(words) >= 2 {
- args = words[1]
- }
- args.TrimLeftSpaces()
- if name == "call" {
- words = args.SplitN(",", 2)
- if words[0].Empty() || !words[0].Const() {
- return "", nil, false
- }
- name = words[0].Dump()
- if len(words) < 2 {
- args = mkparser.SimpleMakeString("", words[0].Pos())
- } else {
- args = words[1]
- }
- }
- ok = true
- return
- }
- // parses $(...), returning an expression
- func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeString) starlarkExpr {
- ref.TrimLeftSpaces()
- ref.TrimRightSpaces()
- refDump := ref.Dump()
- // Handle only the case where the first (or only) word is constant
- words := ref.SplitN(" ", 2)
- if !words[0].Const() {
- if len(words) == 1 {
- expr := ctx.parseMakeString(node, ref)
- return &callExpr{
- object: &identifierExpr{"cfg"},
- name: "get",
- args: []starlarkExpr{
- expr,
- &callExpr{
- object: &identifierExpr{"g"},
- name: "get",
- args: []starlarkExpr{
- expr,
- &stringLiteralExpr{literal: ""},
- },
- returnType: starlarkTypeUnknown,
- },
- },
- returnType: starlarkTypeUnknown,
- }
- } else {
- return ctx.newBadExpr(node, "reference is too complex: %s", refDump)
- }
- }
- if name, _, ok := ctx.maybeParseFunctionCall(node, ref); ok {
- if _, unsupported := unsupportedFunctions[name]; unsupported {
- return ctx.newBadExpr(node, "%s is not supported", refDump)
- }
- }
- // If it is a single word, it can be a simple variable
- // reference or a function call
- if len(words) == 1 && !isMakeControlFunc(refDump) && refDump != "shell" && refDump != "eval" {
- if strings.HasPrefix(refDump, soongNsPrefix) {
- // TODO (asmundak): if we find many, maybe handle them.
- return ctx.newBadExpr(node, "SOONG_CONFIG_ variables cannot be referenced, use soong_config_get instead: %s", refDump)
- }
- // Handle substitution references: https://www.gnu.org/software/make/manual/html_node/Substitution-Refs.html
- if strings.Contains(refDump, ":") {
- parts := strings.SplitN(refDump, ":", 2)
- substParts := strings.SplitN(parts[1], "=", 2)
- if len(substParts) < 2 || strings.Count(substParts[0], "%") > 1 {
- return ctx.newBadExpr(node, "Invalid substitution reference")
- }
- if !strings.Contains(substParts[0], "%") {
- if strings.Contains(substParts[1], "%") {
- 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.")
- }
- substParts[0] = "%" + substParts[0]
- substParts[1] = "%" + substParts[1]
- }
- v := ctx.addVariable(parts[0])
- if v == nil {
- return ctx.newBadExpr(node, "unknown variable %s", refDump)
- }
- return &callExpr{
- name: baseName + ".mkpatsubst",
- returnType: starlarkTypeString,
- args: []starlarkExpr{
- &stringLiteralExpr{literal: substParts[0]},
- &stringLiteralExpr{literal: substParts[1]},
- NewVariableRefExpr(v),
- },
- }
- }
- if v := ctx.addVariable(refDump); v != nil {
- return NewVariableRefExpr(v)
- }
- return ctx.newBadExpr(node, "unknown variable %s", refDump)
- }
- if name, args, ok := ctx.maybeParseFunctionCall(node, ref); ok {
- if kf, found := knownFunctions[name]; found {
- return kf.parse(ctx, node, args)
- } else {
- return ctx.newBadExpr(node, "cannot handle invoking %s", name)
- }
- }
- return ctx.newBadExpr(node, "cannot handle %s", refDump)
- }
- type simpleCallParser struct {
- name string
- returnType starlarkType
- addGlobals bool
- addHandle bool
- }
- func (p *simpleCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- expr := &callExpr{name: p.name, returnType: p.returnType}
- if p.addGlobals {
- expr.args = append(expr.args, &globalsExpr{})
- }
- if p.addHandle {
- expr.args = append(expr.args, &identifierExpr{name: "handle"})
- }
- for _, arg := range args.Split(",") {
- arg.TrimLeftSpaces()
- arg.TrimRightSpaces()
- x := ctx.parseMakeString(node, arg)
- if xBad, ok := x.(*badExpr); ok {
- return xBad
- }
- expr.args = append(expr.args, x)
- }
- return expr
- }
- type makeControlFuncParser struct {
- name string
- }
- func (p *makeControlFuncParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- // Make control functions need special treatment as everything
- // after the name is a single text argument
- x := ctx.parseMakeString(node, args)
- if xBad, ok := x.(*badExpr); ok {
- return xBad
- }
- return &callExpr{
- name: p.name,
- args: []starlarkExpr{
- &stringLiteralExpr{ctx.script.mkFile},
- x,
- },
- returnType: starlarkTypeUnknown,
- }
- }
- type shellCallParser struct{}
- func (p *shellCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- // Shell functions need special treatment as everything
- // after the name is a single text argument
- x := ctx.parseMakeString(node, args)
- if xBad, ok := x.(*badExpr); ok {
- return xBad
- }
- return &callExpr{
- name: baseName + ".shell",
- args: []starlarkExpr{x},
- returnType: starlarkTypeUnknown,
- }
- }
- type myDirCallParser struct{}
- func (p *myDirCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- if !args.Empty() {
- return ctx.newBadExpr(node, "my-dir function cannot have any arguments passed to it.")
- }
- return &stringLiteralExpr{literal: filepath.Dir(ctx.script.mkFile)}
- }
- type isProductInListCallParser struct{}
- func (p *isProductInListCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- if args.Empty() {
- return ctx.newBadExpr(node, "is-product-in-list requires an argument")
- }
- return &inExpr{
- expr: NewVariableRefExpr(ctx.addVariable("TARGET_PRODUCT")),
- list: maybeConvertToStringList(ctx.parseMakeString(node, args)),
- isNot: false,
- }
- }
- type isVendorBoardPlatformCallParser struct{}
- func (p *isVendorBoardPlatformCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- if args.Empty() || !identifierFullMatchRegex.MatchString(args.Dump()) {
- return ctx.newBadExpr(node, "cannot handle non-constant argument to is-vendor-board-platform")
- }
- return &inExpr{
- expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
- list: NewVariableRefExpr(ctx.addVariable(args.Dump() + "_BOARD_PLATFORMS")),
- isNot: false,
- }
- }
- type isVendorBoardQcomCallParser struct{}
- func (p *isVendorBoardQcomCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- if !args.Empty() {
- return ctx.newBadExpr(node, "is-vendor-board-qcom does not accept any arguments")
- }
- return &inExpr{
- expr: NewVariableRefExpr(ctx.addVariable("TARGET_BOARD_PLATFORM")),
- list: NewVariableRefExpr(ctx.addVariable("QCOM_BOARD_PLATFORMS")),
- isNot: false,
- }
- }
- type substCallParser struct {
- fname string
- }
- func (p *substCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- words := args.Split(",")
- if len(words) != 3 {
- return ctx.newBadExpr(node, "%s function should have 3 arguments", p.fname)
- }
- from := ctx.parseMakeString(node, words[0])
- if xBad, ok := from.(*badExpr); ok {
- return xBad
- }
- to := ctx.parseMakeString(node, words[1])
- if xBad, ok := to.(*badExpr); ok {
- return xBad
- }
- words[2].TrimLeftSpaces()
- words[2].TrimRightSpaces()
- obj := ctx.parseMakeString(node, words[2])
- typ := obj.typ()
- if typ == starlarkTypeString && p.fname == "subst" {
- // Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
- return &callExpr{
- object: obj,
- name: "replace",
- args: []starlarkExpr{from, to},
- returnType: typ,
- }
- }
- return &callExpr{
- name: baseName + ".mk" + p.fname,
- args: []starlarkExpr{from, to, obj},
- returnType: obj.typ(),
- }
- }
- type ifCallParser struct{}
- func (p *ifCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- words := args.Split(",")
- if len(words) != 2 && len(words) != 3 {
- return ctx.newBadExpr(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))
- }
- condition := ctx.parseMakeString(node, words[0])
- ifTrue := ctx.parseMakeString(node, words[1])
- var ifFalse starlarkExpr
- if len(words) == 3 {
- ifFalse = ctx.parseMakeString(node, words[2])
- } else {
- switch ifTrue.typ() {
- case starlarkTypeList:
- ifFalse = &listExpr{items: []starlarkExpr{}}
- case starlarkTypeInt:
- ifFalse = &intLiteralExpr{literal: 0}
- case starlarkTypeBool:
- ifFalse = &boolLiteralExpr{literal: false}
- default:
- ifFalse = &stringLiteralExpr{literal: ""}
- }
- }
- return &ifExpr{
- condition,
- ifTrue,
- ifFalse,
- }
- }
- type ifCallNodeParser struct{}
- func (p *ifCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
- words := args.Split(",")
- if len(words) != 2 && len(words) != 3 {
- return []starlarkNode{ctx.newBadNode(node, "if function should have 2 or 3 arguments, found "+strconv.Itoa(len(words)))}
- }
- ifn := &ifNode{expr: ctx.parseMakeString(node, words[0])}
- cases := []*switchCase{
- {
- gate: ifn,
- nodes: ctx.parseNodeMakeString(node, words[1]),
- },
- }
- if len(words) == 3 {
- cases = append(cases, &switchCase{
- gate: &elseNode{},
- nodes: ctx.parseNodeMakeString(node, words[2]),
- })
- }
- if len(cases) == 2 {
- if len(cases[1].nodes) == 0 {
- // Remove else branch if it has no contents
- cases = cases[:1]
- } else if len(cases[0].nodes) == 0 {
- // If the if branch has no contents but the else does,
- // move them to the if and negate its condition
- ifn.expr = negateExpr(ifn.expr)
- cases[0].nodes = cases[1].nodes
- cases = cases[:1]
- }
- }
- return []starlarkNode{&switchNode{ssCases: cases}}
- }
- type foreachCallParser struct{}
- func (p *foreachCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- words := args.Split(",")
- if len(words) != 3 {
- return ctx.newBadExpr(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))
- }
- if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
- return ctx.newBadExpr(node, "first argument to foreach function must be a simple string identifier")
- }
- loopVarName := words[0].Strings[0]
- list := ctx.parseMakeString(node, words[1])
- action := ctx.parseMakeString(node, words[2]).transform(func(expr starlarkExpr) starlarkExpr {
- if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
- return &identifierExpr{loopVarName}
- }
- return nil
- })
- if list.typ() != starlarkTypeList {
- list = &callExpr{
- name: baseName + ".words",
- returnType: starlarkTypeList,
- args: []starlarkExpr{list},
- }
- }
- var result starlarkExpr = &foreachExpr{
- varName: loopVarName,
- list: list,
- action: action,
- }
- if action.typ() == starlarkTypeList {
- result = &callExpr{
- name: baseName + ".flatten_2d_list",
- args: []starlarkExpr{result},
- returnType: starlarkTypeList,
- }
- }
- return result
- }
- func transformNode(node starlarkNode, transformer func(expr starlarkExpr) starlarkExpr) {
- switch a := node.(type) {
- case *ifNode:
- a.expr = a.expr.transform(transformer)
- case *switchCase:
- transformNode(a.gate, transformer)
- for _, n := range a.nodes {
- transformNode(n, transformer)
- }
- case *switchNode:
- for _, n := range a.ssCases {
- transformNode(n, transformer)
- }
- case *exprNode:
- a.expr = a.expr.transform(transformer)
- case *assignmentNode:
- a.value = a.value.transform(transformer)
- case *foreachNode:
- a.list = a.list.transform(transformer)
- for _, n := range a.actions {
- transformNode(n, transformer)
- }
- case *inheritNode:
- if b, ok := a.module.(inheritedDynamicModule); ok {
- b.path = b.path.transform(transformer)
- a.module = b
- }
- case *includeNode:
- if b, ok := a.module.(inheritedDynamicModule); ok {
- b.path = b.path.transform(transformer)
- a.module = b
- }
- }
- }
- type foreachCallNodeParser struct{}
- func (p *foreachCallNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
- words := args.Split(",")
- if len(words) != 3 {
- return []starlarkNode{ctx.newBadNode(node, "foreach function should have 3 arguments, found "+strconv.Itoa(len(words)))}
- }
- if !words[0].Const() || words[0].Empty() || !identifierFullMatchRegex.MatchString(words[0].Strings[0]) {
- return []starlarkNode{ctx.newBadNode(node, "first argument to foreach function must be a simple string identifier")}
- }
- loopVarName := words[0].Strings[0]
- list := ctx.parseMakeString(node, words[1])
- if list.typ() != starlarkTypeList {
- list = &callExpr{
- name: baseName + ".words",
- returnType: starlarkTypeList,
- args: []starlarkExpr{list},
- }
- }
- actions := ctx.parseNodeMakeString(node, words[2])
- // TODO(colefaust): Replace transforming code with something more elegant
- for _, action := range actions {
- transformNode(action, func(expr starlarkExpr) starlarkExpr {
- if varRefExpr, ok := expr.(*variableRefExpr); ok && varRefExpr.ref.name() == loopVarName {
- return &identifierExpr{loopVarName}
- }
- return nil
- })
- }
- return []starlarkNode{&foreachNode{
- varName: loopVarName,
- list: list,
- actions: actions,
- }}
- }
- type wordCallParser struct{}
- func (p *wordCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- words := args.Split(",")
- if len(words) != 2 {
- return ctx.newBadExpr(node, "word function should have 2 arguments")
- }
- var index = 0
- if words[0].Const() {
- if i, err := strconv.Atoi(strings.TrimSpace(words[0].Strings[0])); err == nil {
- index = i
- }
- }
- if index < 1 {
- return ctx.newBadExpr(node, "word index should be constant positive integer")
- }
- words[1].TrimLeftSpaces()
- words[1].TrimRightSpaces()
- array := ctx.parseMakeString(node, words[1])
- if bad, ok := array.(*badExpr); ok {
- return bad
- }
- if array.typ() != starlarkTypeList {
- array = &callExpr{
- name: baseName + ".words",
- args: []starlarkExpr{array},
- returnType: starlarkTypeList,
- }
- }
- return &indexExpr{array, &intLiteralExpr{index - 1}}
- }
- type wordsCallParser struct{}
- func (p *wordsCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- args.TrimLeftSpaces()
- args.TrimRightSpaces()
- array := ctx.parseMakeString(node, args)
- if bad, ok := array.(*badExpr); ok {
- return bad
- }
- if array.typ() != starlarkTypeList {
- array = &callExpr{
- name: baseName + ".words",
- args: []starlarkExpr{array},
- returnType: starlarkTypeList,
- }
- }
- return &callExpr{
- name: "len",
- args: []starlarkExpr{array},
- returnType: starlarkTypeInt,
- }
- }
- func parseIntegerArguments(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString, expectedArgs int) ([]starlarkExpr, error) {
- parsedArgs := make([]starlarkExpr, 0)
- for _, arg := range args.Split(",") {
- expr := ctx.parseMakeString(node, arg)
- if expr.typ() == starlarkTypeList {
- return nil, fmt.Errorf("argument to math argument has type list, which cannot be converted to int")
- }
- if s, ok := maybeString(expr); ok {
- intVal, err := strconv.Atoi(strings.TrimSpace(s))
- if err != nil {
- return nil, err
- }
- expr = &intLiteralExpr{literal: intVal}
- } else if expr.typ() != starlarkTypeInt {
- expr = &callExpr{
- name: "int",
- args: []starlarkExpr{expr},
- returnType: starlarkTypeInt,
- }
- }
- parsedArgs = append(parsedArgs, expr)
- }
- if len(parsedArgs) != expectedArgs {
- return nil, fmt.Errorf("function should have %d arguments", expectedArgs)
- }
- return parsedArgs, nil
- }
- type mathComparisonCallParser struct {
- op string
- }
- func (p *mathComparisonCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
- if err != nil {
- return ctx.newBadExpr(node, err.Error())
- }
- return &binaryOpExpr{
- left: parsedArgs[0],
- right: parsedArgs[1],
- op: p.op,
- returnType: starlarkTypeBool,
- }
- }
- type mathMaxOrMinCallParser struct {
- function string
- }
- func (p *mathMaxOrMinCallParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
- parsedArgs, err := parseIntegerArguments(ctx, node, args, 2)
- if err != nil {
- return ctx.newBadExpr(node, err.Error())
- }
- return &callExpr{
- object: nil,
- name: p.function,
- args: parsedArgs,
- returnType: starlarkTypeInt,
- }
- }
- type evalNodeParser struct{}
- func (p *evalNodeParser) parse(ctx *parseContext, node mkparser.Node, args *mkparser.MakeString) []starlarkNode {
- parser := mkparser.NewParser("Eval expression", strings.NewReader(args.Dump()))
- nodes, errs := parser.Parse()
- if errs != nil {
- return []starlarkNode{ctx.newBadNode(node, "Unable to parse eval statement")}
- }
- if len(nodes) == 0 {
- return []starlarkNode{}
- } else if len(nodes) == 1 {
- switch n := nodes[0].(type) {
- case *mkparser.Assignment:
- if n.Name.Const() {
- return ctx.handleAssignment(n)
- }
- case *mkparser.Comment:
- return []starlarkNode{&commentNode{strings.TrimSpace("#" + n.Comment)}}
- case *mkparser.Directive:
- if n.Name == "include" || n.Name == "-include" {
- return ctx.handleInclude(n)
- }
- case *mkparser.Variable:
- // Technically inherit-product(-if-exists) don't need to be put inside
- // an eval, but some makefiles do it, presumably because they copy+pasted
- // from a $(eval include ...)
- if name, _, ok := ctx.maybeParseFunctionCall(n, n.Name); ok {
- if name == "inherit-product" || name == "inherit-product-if-exists" {
- return ctx.handleVariable(n)
- }
- }
- }
- }
- return []starlarkNode{ctx.newBadNode(node, "Eval expression too complex; only assignments, comments, includes, and inherit-products are supported")}
- }
- func (ctx *parseContext) parseMakeString(node mkparser.Node, mk *mkparser.MakeString) starlarkExpr {
- if mk.Const() {
- return &stringLiteralExpr{mk.Dump()}
- }
- if mkRef, ok := mk.SingleVariable(); ok {
- return ctx.parseReference(node, mkRef)
- }
- // If we reached here, it's neither string literal nor a simple variable,
- // we need a full-blown interpolation node that will generate
- // "a%b%c" % (X, Y) for a$(X)b$(Y)c
- parts := make([]starlarkExpr, len(mk.Variables)+len(mk.Strings))
- for i := 0; i < len(parts); i++ {
- if i%2 == 0 {
- parts[i] = &stringLiteralExpr{literal: mk.Strings[i/2]}
- } else {
- parts[i] = ctx.parseReference(node, mk.Variables[i/2].Name)
- if x, ok := parts[i].(*badExpr); ok {
- return x
- }
- }
- }
- return NewInterpolateExpr(parts)
- }
- func (ctx *parseContext) parseNodeMakeString(node mkparser.Node, mk *mkparser.MakeString) []starlarkNode {
- // Discard any constant values in the make string, as they would be top level
- // string literals and do nothing.
- result := make([]starlarkNode, 0, len(mk.Variables))
- for i := range mk.Variables {
- result = append(result, ctx.handleVariable(&mk.Variables[i])...)
- }
- return result
- }
- // Handles the statements whose treatment is the same in all contexts: comment,
- // assignment, variable (which is a macro call in reality) and all constructs that
- // do not handle in any context ('define directive and any unrecognized stuff).
- func (ctx *parseContext) handleSimpleStatement(node mkparser.Node) []starlarkNode {
- var result []starlarkNode
- switch x := node.(type) {
- case *mkparser.Comment:
- if n, handled := ctx.maybeHandleAnnotation(x); handled && n != nil {
- result = []starlarkNode{n}
- } else if !handled {
- result = []starlarkNode{&commentNode{strings.TrimSpace("#" + x.Comment)}}
- }
- case *mkparser.Assignment:
- result = ctx.handleAssignment(x)
- case *mkparser.Variable:
- result = ctx.handleVariable(x)
- case *mkparser.Directive:
- switch x.Name {
- case "define":
- if res := ctx.maybeHandleDefine(x); res != nil {
- result = []starlarkNode{res}
- }
- case "include", "-include":
- result = ctx.handleInclude(x)
- case "ifeq", "ifneq", "ifdef", "ifndef":
- result = []starlarkNode{ctx.handleIfBlock(x)}
- default:
- result = []starlarkNode{ctx.newBadNode(x, "unexpected directive %s", x.Name)}
- }
- default:
- result = []starlarkNode{ctx.newBadNode(x, "unsupported line %s", strings.ReplaceAll(x.Dump(), "\n", "\n#"))}
- }
- // Clear the includeTops after each non-comment statement
- // so that include annotations placed on certain statements don't apply
- // globally for the rest of the makefile was well.
- if _, wasComment := node.(*mkparser.Comment); !wasComment {
- ctx.atTopOfMakefile = false
- ctx.includeTops = []string{}
- }
- if result == nil {
- result = []starlarkNode{}
- }
- return result
- }
- // The types allowed in a type_hint
- var typeHintMap = map[string]starlarkType{
- "string": starlarkTypeString,
- "list": starlarkTypeList,
- }
- // Processes annotation. An annotation is a comment that starts with #RBC# and provides
- // a conversion hint -- say, where to look for the dynamically calculated inherit/include
- // paths. Returns true if the comment was a successfully-handled annotation.
- func (ctx *parseContext) maybeHandleAnnotation(cnode *mkparser.Comment) (starlarkNode, bool) {
- maybeTrim := func(s, prefix string) (string, bool) {
- if strings.HasPrefix(s, prefix) {
- return strings.TrimSpace(strings.TrimPrefix(s, prefix)), true
- }
- return s, false
- }
- annotation, ok := maybeTrim(cnode.Comment, annotationCommentPrefix)
- if !ok {
- return nil, false
- }
- if p, ok := maybeTrim(annotation, "include_top"); ok {
- // Don't allow duplicate include tops, because then we will generate
- // invalid starlark code. (duplicate keys in the _entry dictionary)
- for _, top := range ctx.includeTops {
- if top == p {
- return nil, true
- }
- }
- ctx.includeTops = append(ctx.includeTops, p)
- return nil, true
- } else if p, ok := maybeTrim(annotation, "type_hint"); ok {
- // Type hints must come at the beginning the file, to avoid confusion
- // if a type hint was specified later and thus only takes effect for half
- // of the file.
- if !ctx.atTopOfMakefile {
- return ctx.newBadNode(cnode, "type_hint annotations must come before the first Makefile statement"), true
- }
- parts := strings.Fields(p)
- if len(parts) <= 1 {
- 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
- }
- var varType starlarkType
- if varType, ok = typeHintMap[parts[0]]; !ok {
- varType = starlarkTypeUnknown
- }
- if varType == starlarkTypeUnknown {
- return ctx.newBadNode(cnode, "Invalid type_hint annotation. Only list/string types are accepted, found %s", parts[0]), true
- }
- for _, name := range parts[1:] {
- // Don't allow duplicate type hints
- if _, ok := ctx.typeHints[name]; ok {
- return ctx.newBadNode(cnode, "Duplicate type hint for variable %s", name), true
- }
- ctx.typeHints[name] = varType
- }
- return nil, true
- }
- return ctx.newBadNode(cnode, "unsupported annotation %s", cnode.Comment), true
- }
- func (ctx *parseContext) loadedModulePath(path string) string {
- // During the transition to Roboleaf some of the product configuration files
- // will be converted and checked in while the others will be generated on the fly
- // and run. The runner (rbcrun application) accommodates this by allowing three
- // different ways to specify the loaded file location:
- // 1) load(":<file>",...) loads <file> from the same directory
- // 2) load("//path/relative/to/source/root:<file>", ...) loads <file> source tree
- // 3) load("/absolute/path/to/<file> absolute path
- // If the file being generated and the file it wants to load are in the same directory,
- // generate option 1.
- // Otherwise, if output directory is not specified, generate 2)
- // Finally, if output directory has been specified and the file being generated and
- // the file it wants to load from are in the different directories, generate 2) or 3):
- // * if the file being loaded exists in the source tree, generate 2)
- // * otherwise, generate 3)
- // Finally, figure out the loaded module path and name and create a node for it
- loadedModuleDir := filepath.Dir(path)
- base := filepath.Base(path)
- loadedModuleName := strings.TrimSuffix(base, filepath.Ext(base)) + ctx.outputSuffix
- if loadedModuleDir == filepath.Dir(ctx.script.mkFile) {
- return ":" + loadedModuleName
- }
- if ctx.outputDir == "" {
- return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
- }
- if _, err := os.Stat(filepath.Join(loadedModuleDir, loadedModuleName)); err == nil {
- return fmt.Sprintf("//%s:%s", loadedModuleDir, loadedModuleName)
- }
- return filepath.Join(ctx.outputDir, loadedModuleDir, loadedModuleName)
- }
- func (ctx *parseContext) addSoongNamespace(ns string) {
- if _, ok := ctx.soongNamespaces[ns]; ok {
- return
- }
- ctx.soongNamespaces[ns] = make(map[string]bool)
- }
- func (ctx *parseContext) hasSoongNamespace(name string) bool {
- _, ok := ctx.soongNamespaces[name]
- return ok
- }
- func (ctx *parseContext) updateSoongNamespace(replace bool, namespaceName string, varNames []string) {
- ctx.addSoongNamespace(namespaceName)
- vars := ctx.soongNamespaces[namespaceName]
- if replace {
- vars = make(map[string]bool)
- ctx.soongNamespaces[namespaceName] = vars
- }
- for _, v := range varNames {
- vars[v] = true
- }
- }
- func (ctx *parseContext) hasNamespaceVar(namespaceName string, varName string) bool {
- vars, ok := ctx.soongNamespaces[namespaceName]
- if ok {
- _, ok = vars[varName]
- }
- return ok
- }
- func (ctx *parseContext) errorLocation(node mkparser.Node) ErrorLocation {
- return ErrorLocation{ctx.script.mkFile, ctx.script.nodeLocator(node.Pos())}
- }
- func (ss *StarlarkScript) String() string {
- return NewGenerateContext(ss).emit()
- }
- func (ss *StarlarkScript) SubConfigFiles() []string {
- var subs []string
- for _, src := range ss.inherited {
- subs = append(subs, src.originalPath)
- }
- return subs
- }
- func (ss *StarlarkScript) HasErrors() bool {
- return ss.hasErrors
- }
- // Convert reads and parses a makefile. If successful, parsed tree
- // is returned and then can be passed to String() to get the generated
- // Starlark file.
- func Convert(req Request) (*StarlarkScript, error) {
- reader := req.Reader
- if reader == nil {
- mkContents, err := ioutil.ReadFile(req.MkFile)
- if err != nil {
- return nil, err
- }
- reader = bytes.NewBuffer(mkContents)
- }
- parser := mkparser.NewParser(req.MkFile, reader)
- nodes, errs := parser.Parse()
- if len(errs) > 0 {
- for _, e := range errs {
- fmt.Fprintln(os.Stderr, "ERROR:", e)
- }
- return nil, fmt.Errorf("bad makefile %s", req.MkFile)
- }
- starScript := &StarlarkScript{
- moduleName: moduleNameForFile(req.MkFile),
- mkFile: req.MkFile,
- traceCalls: req.TraceCalls,
- sourceFS: req.SourceFS,
- makefileFinder: req.MakefileFinder,
- nodeLocator: func(pos mkparser.Pos) int { return parser.Unpack(pos).Line },
- nodes: make([]starlarkNode, 0),
- }
- ctx := newParseContext(starScript, nodes)
- ctx.outputSuffix = req.OutputSuffix
- ctx.outputDir = req.OutputDir
- ctx.errorLogger = req.ErrorLogger
- if len(req.TracedVariables) > 0 {
- ctx.tracedVariables = make(map[string]bool)
- for _, v := range req.TracedVariables {
- ctx.tracedVariables[v] = true
- }
- }
- for ctx.hasNodes() && ctx.fatalError == nil {
- starScript.nodes = append(starScript.nodes, ctx.handleSimpleStatement(ctx.getNode())...)
- }
- if ctx.fatalError != nil {
- return nil, ctx.fatalError
- }
- return starScript, nil
- }
- func Launcher(mainModuleUri, inputVariablesUri, mainModuleName string) string {
- var buf bytes.Buffer
- fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
- fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
- fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
- fmt.Fprintf(&buf, "%s(%s(%q, init, input_variables_init))\n", cfnPrintVars, cfnMain, mainModuleName)
- return buf.String()
- }
- func BoardLauncher(mainModuleUri string, inputVariablesUri string) string {
- var buf bytes.Buffer
- fmt.Fprintf(&buf, "load(%q, %q)\n", baseUri, baseName)
- fmt.Fprintf(&buf, "load(%q, \"init\")\n", mainModuleUri)
- fmt.Fprintf(&buf, "load(%q, input_variables_init = \"init\")\n", inputVariablesUri)
- fmt.Fprintf(&buf, "%s(%s(init, input_variables_init))\n", cfnPrintVars, cfnBoardMain)
- return buf.String()
- }
- func MakePath2ModuleName(mkPath string) string {
- return strings.TrimSuffix(mkPath, filepath.Ext(mkPath))
- }
|