From 4f2feeee508bf95b0793393c2aceb02600b53fa1 Mon Sep 17 00:00:00 2001 From: Jeff Gaston Date: Wed, 1 Feb 2017 14:47:30 -0800 Subject: [PATCH] Have AndroidMk skip emitting LOCAL_MODULE_TAGS="optional" Also somewhat consolidate the way in which properties are converted Bug: 34671474 Test: make blueprint_tools Change-Id: Idf0d6d63b8539ab6e514a6043d1f88836899864b --- androidmk/cmd/androidmk/android.go | 305 +++++++++++++--------- androidmk/cmd/androidmk/androidmk.go | 16 +- androidmk/cmd/androidmk/androidmk_test.go | 28 ++ 3 files changed, 218 insertions(+), 131 deletions(-) diff --git a/androidmk/cmd/androidmk/android.go b/androidmk/cmd/androidmk/android.go index 8f0ebdfdc..8d46a78ef 100644 --- a/androidmk/cmd/androidmk/android.go +++ b/androidmk/cmd/androidmk/android.go @@ -12,88 +12,115 @@ const ( clear_vars = "__android_mk_clear_vars" ) -var standardProperties = map[string]struct { - string - bpparser.Type -}{ - // String properties - "LOCAL_MODULE": {"name", bpparser.StringType}, - "LOCAL_MODULE_CLASS": {"class", bpparser.StringType}, - "LOCAL_CXX_STL": {"stl", bpparser.StringType}, - "LOCAL_STRIP_MODULE": {"strip", bpparser.StringType}, - "LOCAL_MULTILIB": {"compile_multilib", bpparser.StringType}, - "LOCAL_ARM_MODE_HACK": {"instruction_set", bpparser.StringType}, - "LOCAL_SDK_VERSION": {"sdk_version", bpparser.StringType}, - "LOCAL_NDK_STL_VARIANT": {"stl", bpparser.StringType}, - "LOCAL_JAR_MANIFEST": {"manifest", bpparser.StringType}, - "LOCAL_JARJAR_RULES": {"jarjar_rules", bpparser.StringType}, - "LOCAL_CERTIFICATE": {"certificate", bpparser.StringType}, - "LOCAL_PACKAGE_NAME": {"name", bpparser.StringType}, - "LOCAL_MODULE_RELATIVE_PATH": {"relative_install_path", bpparser.StringType}, - "LOCAL_PROTOC_OPTIMIZE_TYPE": {"proto.type", bpparser.StringType}, - - // List properties - "LOCAL_SRC_FILES_EXCLUDE": {"exclude_srcs", bpparser.ListType}, - "LOCAL_SHARED_LIBRARIES": {"shared_libs", bpparser.ListType}, - "LOCAL_STATIC_LIBRARIES": {"static_libs", bpparser.ListType}, - "LOCAL_WHOLE_STATIC_LIBRARIES": {"whole_static_libs", bpparser.ListType}, - "LOCAL_SYSTEM_SHARED_LIBRARIES": {"system_shared_libs", bpparser.ListType}, - "LOCAL_HEADER_LIBRARIES": {"header_libs", bpparser.ListType}, - "LOCAL_ASFLAGS": {"asflags", bpparser.ListType}, - "LOCAL_CLANG_ASFLAGS": {"clang_asflags", bpparser.ListType}, - "LOCAL_CFLAGS": {"cflags", bpparser.ListType}, - "LOCAL_CONLYFLAGS": {"conlyflags", bpparser.ListType}, - "LOCAL_CPPFLAGS": {"cppflags", bpparser.ListType}, - "LOCAL_REQUIRED_MODULES": {"required", bpparser.ListType}, - "LOCAL_MODULE_TAGS": {"tags", bpparser.ListType}, - "LOCAL_LDLIBS": {"host_ldlibs", bpparser.ListType}, - "LOCAL_CLANG_CFLAGS": {"clang_cflags", bpparser.ListType}, - "LOCAL_YACCFLAGS": {"yaccflags", bpparser.ListType}, - "LOCAL_SANITIZE_RECOVER": {"sanitize.recover", bpparser.ListType}, - "LOCAL_LOGTAGS_FILES": {"logtags", bpparser.ListType}, - "LOCAL_EXPORT_SHARED_LIBRARY_HEADERS": {"export_shared_lib_headers", bpparser.ListType}, - "LOCAL_EXPORT_STATIC_LIBRARY_HEADERS": {"export_static_lib_headers", bpparser.ListType}, - "LOCAL_INIT_RC": {"init_rc", bpparser.ListType}, - "LOCAL_TIDY_FLAGS": {"tidy_flags", bpparser.ListType}, - // TODO: This is comma-seperated, not space-separated - "LOCAL_TIDY_CHECKS": {"tidy_checks", bpparser.ListType}, - - "LOCAL_JAVA_RESOURCE_DIRS": {"java_resource_dirs", bpparser.ListType}, - "LOCAL_JAVACFLAGS": {"javacflags", bpparser.ListType}, - "LOCAL_DX_FLAGS": {"dxflags", bpparser.ListType}, - "LOCAL_JAVA_LIBRARIES": {"java_libs", bpparser.ListType}, - "LOCAL_STATIC_JAVA_LIBRARIES": {"java_static_libs", bpparser.ListType}, - "LOCAL_AIDL_INCLUDES": {"aidl_includes", bpparser.ListType}, - "LOCAL_AAPT_FLAGS": {"aaptflags", bpparser.ListType}, - "LOCAL_PACKAGE_SPLITS": {"package_splits", bpparser.ListType}, - - // Bool properties - "LOCAL_IS_HOST_MODULE": {"host", bpparser.BoolType}, - "LOCAL_CLANG": {"clang", bpparser.BoolType}, - "LOCAL_FORCE_STATIC_EXECUTABLE": {"static_executable", bpparser.BoolType}, - "LOCAL_NATIVE_COVERAGE": {"native_coverage", bpparser.BoolType}, - "LOCAL_NO_CRT": {"nocrt", bpparser.BoolType}, - "LOCAL_ALLOW_UNDEFINED_SYMBOLS": {"allow_undefined_symbols", bpparser.BoolType}, - "LOCAL_RTTI_FLAG": {"rtti", bpparser.BoolType}, - "LOCAL_NO_STANDARD_LIBRARIES": {"no_standard_libraries", bpparser.BoolType}, - "LOCAL_PACK_MODULE_RELOCATIONS": {"pack_relocations", bpparser.BoolType}, - "LOCAL_TIDY": {"tidy", bpparser.BoolType}, - "LOCAL_USE_VNDK": {"use_vndk", bpparser.BoolType}, - "LOCAL_PROPRIETARY_MODULE": {"proprietary", bpparser.BoolType}, - - "LOCAL_EXPORT_PACKAGE_RESOURCES": {"export_package_resources", bpparser.BoolType}, +type bpVariable struct { + name string + variableType bpparser.Type } -var rewriteProperties = map[string]struct { - f func(file *bpFile, prefix string, value *mkparser.MakeString, append bool) error -}{ - "LOCAL_C_INCLUDES": {localIncludeDirs}, - "LOCAL_EXPORT_C_INCLUDE_DIRS": {exportIncludeDirs}, - "LOCAL_MODULE_STEM": {stem}, - "LOCAL_MODULE_HOST_OS": {hostOs}, - "LOCAL_SRC_FILES": {srcFiles}, - "LOCAL_SANITIZE": {sanitize}, - "LOCAL_LDFLAGS": {ldflags}, +type variableAssignmentContext struct { + file *bpFile + prefix string + mkvalue *mkparser.MakeString + append bool +} + +var rewriteProperties = map[string](func(variableAssignmentContext) error){ + // custom functions + "LOCAL_C_INCLUDES": localIncludeDirs, + "LOCAL_EXPORT_C_INCLUDE_DIRS": exportIncludeDirs, + "LOCAL_LDFLAGS": ldflags, + "LOCAL_MODULE_STEM": stem, + "LOCAL_MODULE_HOST_OS": hostOs, + "LOCAL_SRC_FILES": srcFiles, + "LOCAL_SANITIZE": sanitize, + + // composite functions + "LOCAL_MODULE_TAGS": includeVariableIf(bpVariable{"tags", bpparser.ListType}, not(valueDumpEquals("optional"))), + + // skip functions + "LOCAL_ADDITIONAL_DEPENDENCIES": skip, // TODO: check for only .mk files? + "LOCAL_CPP_EXTENSION": skip, + "LOCAL_PATH": skip, // Nothing to do, except maybe avoid the "./" in paths? +} + +// adds a group of properties all having the same type +func addStandardProperties(propertyType bpparser.Type, properties map[string]string) { + for key, val := range properties { + rewriteProperties[key] = includeVariable(bpVariable{val, propertyType}) + } +} + +func init() { + addStandardProperties(bpparser.StringType, + map[string]string{ + "LOCAL_MODULE": "name", + "LOCAL_MODULE_CLASS": "class", + "LOCAL_CXX_STL": "stl", + "LOCAL_STRIP_MODULE": "strip", + "LOCAL_MULTILIB": "compile_multilib", + "LOCAL_ARM_MODE_HACK": "instruction_set", + "LOCAL_SDK_VERSION": "sdk_version", + "LOCAL_NDK_STL_VARIANT": "stl", + "LOCAL_JAR_MANIFEST": "manifest", + "LOCAL_JARJAR_RULES": "jarjar_rules", + "LOCAL_CERTIFICATE": "certificate", + "LOCAL_PACKAGE_NAME": "name", + "LOCAL_MODULE_RELATIVE_PATH": "relative_install_path", + "LOCAL_PROTOC_OPTIMIZE_TYPE": "proto.type", + "LOCAL_HEADER_LIBRARIES": "header_libs", + }) + addStandardProperties(bpparser.ListType, + map[string]string{ + "LOCAL_SRC_FILES_EXCLUDE": "exclude_srcs", + "LOCAL_SHARED_LIBRARIES": "shared_libs", + "LOCAL_STATIC_LIBRARIES": "static_libs", + "LOCAL_WHOLE_STATIC_LIBRARIES": "whole_static_libs", + "LOCAL_SYSTEM_SHARED_LIBRARIES": "system_shared_libs", + "LOCAL_ASFLAGS": "asflags", + "LOCAL_CLANG_ASFLAGS": "clang_asflags", + "LOCAL_CFLAGS": "cflags", + "LOCAL_CONLYFLAGS": "conlyflags", + "LOCAL_CPPFLAGS": "cppflags", + "LOCAL_REQUIRED_MODULES": "required", + "LOCAL_LDLIBS": "host_ldlibs", + "LOCAL_CLANG_CFLAGS": "clang_cflags", + "LOCAL_YACCFLAGS": "yaccflags", + "LOCAL_SANITIZE_RECOVER": "sanitize.recover", + "LOCAL_LOGTAGS_FILES": "logtags", + "LOCAL_EXPORT_SHARED_LIBRARY_HEADERS": "export_shared_lib_headers", + "LOCAL_EXPORT_STATIC_LIBRARY_HEADERS": "export_static_lib_headers", + "LOCAL_INIT_RC": "init_rc", + "LOCAL_TIDY_FLAGS": "tidy_flags", + // TODO: This is comma-separated, not space-separated + "LOCAL_TIDY_CHECKS": "tidy_checks", + + "LOCAL_JAVA_RESOURCE_DIRS": "java_resource_dirs", + "LOCAL_JAVACFLAGS": "javacflags", + "LOCAL_DX_FLAGS": "dxflags", + "LOCAL_JAVA_LIBRARIES": "java_libs", + "LOCAL_STATIC_JAVA_LIBRARIES": "java_static_libs", + "LOCAL_AIDL_INCLUDES": "aidl_includes", + "LOCAL_AAPT_FLAGS": "aaptflags", + "LOCAL_PACKAGE_SPLITS": "package_splits", + }) + addStandardProperties(bpparser.BoolType, + map[string]string{ + // Bool properties + "LOCAL_IS_HOST_MODULE": "host", + "LOCAL_CLANG": "clang", + "LOCAL_FORCE_STATIC_EXECUTABLE": "static_executable", + "LOCAL_NATIVE_COVERAGE": "native_coverage", + "LOCAL_NO_CRT": "nocrt", + "LOCAL_ALLOW_UNDEFINED_SYMBOLS": "allow_undefined_symbols", + "LOCAL_RTTI_FLAG": "rtti", + "LOCAL_NO_STANDARD_LIBRARIES": "no_standard_libraries", + "LOCAL_PACK_MODULE_RELOCATIONS": "pack_relocations", + "LOCAL_TIDY": "tidy", + "LOCAL_USE_VNDK": "use_vndk", + "LOCAL_PROPRIETARY_MODULE": "proprietary", + + "LOCAL_EXPORT_PACKAGE_RESOURCES": "export_package_resources", + }) } type listSplitFunc func(bpparser.Expression) (string, bpparser.Expression, error) @@ -220,8 +247,8 @@ func splitLocalGlobalPath(value bpparser.Expression) (string, bpparser.Expressio } } -func localIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, value, bpparser.ListType) +func localIncludeDirs(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -232,14 +259,14 @@ func localIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, a } if global, ok := lists["global"]; ok && !emptyList(global) { - err = setVariable(file, appendVariable, prefix, "include_dirs", global, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "include_dirs", global, true) if err != nil { return err } } if local, ok := lists["local"]; ok && !emptyList(local) { - err = setVariable(file, appendVariable, prefix, "local_include_dirs", local, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "local_include_dirs", local, true) if err != nil { return err } @@ -248,8 +275,8 @@ func localIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, a return nil } -func exportIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, value, bpparser.ListType) +func exportIncludeDirs(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -260,17 +287,17 @@ func exportIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, } if local, ok := lists["local"]; ok && !emptyList(local) { - err = setVariable(file, appendVariable, prefix, "export_include_dirs", local, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "export_include_dirs", local, true) if err != nil { return err } - appendVariable = true + ctx.append = true } // Add any paths that could not be converted to local relative paths to export_include_dirs // anyways, they will cause an error if they don't exist and can be fixed manually. if global, ok := lists["global"]; ok && !emptyList(global) { - err = setVariable(file, appendVariable, prefix, "export_include_dirs", global, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "export_include_dirs", global, true) if err != nil { return err } @@ -279,8 +306,8 @@ func exportIncludeDirs(file *bpFile, prefix string, value *mkparser.MakeString, return nil } -func stem(file *bpFile, prefix string, value *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, value, bpparser.StringType) +func stem(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.StringType) if err != nil { return err } @@ -293,11 +320,11 @@ func stem(file *bpFile, prefix string, value *mkparser.MakeString, appendVariabl } } - return setVariable(file, appendVariable, prefix, varName, val, true) + return setVariable(ctx.file, ctx.append, ctx.prefix, varName, val, true) } -func hostOs(file *bpFile, prefix string, value *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, value, bpparser.ListType) +func hostOs(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -320,15 +347,15 @@ func hostOs(file *bpFile, prefix string, value *mkparser.MakeString, appendVaria } if inList("windows") { - err = setVariable(file, appendVariable, "target.windows", "enabled", trueValue, true) + err = setVariable(ctx.file, ctx.append, "target.windows", "enabled", trueValue, true) } if !inList("linux") && err == nil { - err = setVariable(file, appendVariable, "target.linux", "enabled", falseValue, true) + err = setVariable(ctx.file, ctx.append, "target.linux", "enabled", falseValue, true) } if !inList("darwin") && err == nil { - err = setVariable(file, appendVariable, "target.darwin", "enabled", falseValue, true) + err = setVariable(ctx.file, ctx.append, "target.darwin", "enabled", falseValue, true) } return err @@ -353,8 +380,8 @@ func splitSrcsLogtags(value bpparser.Expression) (string, bpparser.Expression, e } -func srcFiles(file *bpFile, prefix string, value *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, value, bpparser.ListType) +func srcFiles(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -362,14 +389,14 @@ func srcFiles(file *bpFile, prefix string, value *mkparser.MakeString, appendVar lists, err := splitBpList(val, splitSrcsLogtags) if srcs, ok := lists["srcs"]; ok && !emptyList(srcs) { - err = setVariable(file, appendVariable, prefix, "srcs", srcs, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "srcs", srcs, true) if err != nil { return err } } if logtags, ok := lists["logtags"]; ok && !emptyList(logtags) { - err = setVariable(file, true, prefix, "logtags", logtags, true) + err = setVariable(ctx.file, true, ctx.prefix, "logtags", logtags, true) if err != nil { return err } @@ -378,8 +405,8 @@ func srcFiles(file *bpFile, prefix string, value *mkparser.MakeString, appendVar return nil } -func sanitize(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, mkvalue, bpparser.ListType) +func sanitize(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -389,7 +416,7 @@ func sanitize(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendV case *bpparser.Variable: return "vars", value, nil case *bpparser.Operator: - file.errorf(mkvalue, "unknown sanitize expression") + ctx.file.errorf(ctx.mkvalue, "unknown sanitize expression") return "unknown", value, nil case *bpparser.String: switch v.Value { @@ -399,7 +426,7 @@ func sanitize(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendV } return v.Value, bpTrue, nil default: - file.errorf(mkvalue, "unknown sanitize argument: %s", v.Value) + ctx.file.errorf(ctx.mkvalue, "unknown sanitize argument: %s", v.Value) return "unknown", value, nil } default: @@ -417,13 +444,13 @@ func sanitize(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendV switch k { case "never", "address", "coverage", "integer", "thread", "undefined": - err = setVariable(file, false, prefix, "sanitize."+k, lists[k].(*bpparser.List).Values[0], true) + err = setVariable(ctx.file, false, ctx.prefix, "sanitize."+k, lists[k].(*bpparser.List).Values[0], true) case "unknown": - // Nothing, we already added the error above + // Nothing, we already added the error above case "vars": fallthrough default: - err = setVariable(file, true, prefix, "sanitize", v, true) + err = setVariable(ctx.file, true, ctx.prefix, "sanitize", v, true) } if err != nil { @@ -434,8 +461,8 @@ func sanitize(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendV return err } -func ldflags(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVariable bool) error { - val, err := makeVariableToBlueprint(file, mkvalue, bpparser.ListType) +func ldflags(ctx variableAssignmentContext) error { + val, err := makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpparser.ListType) if err != nil { return err } @@ -457,13 +484,13 @@ func ldflags(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVa } if v, ok := exp2.Args[1].(*bpparser.Variable); !ok || v.Name != "LOCAL_PATH" { - file.errorf(mkvalue, "Unrecognized version-script") + ctx.file.errorf(ctx.mkvalue, "Unrecognized version-script") return "ldflags", value, nil } s, ok := exp1.Args[1].(*bpparser.String) if !ok { - file.errorf(mkvalue, "Unrecognized version-script") + ctx.file.errorf(ctx.mkvalue, "Unrecognized version-script") return "ldflags", value, nil } @@ -476,7 +503,7 @@ func ldflags(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVa } if ldflags, ok := lists["ldflags"]; ok && !emptyList(ldflags) { - err = setVariable(file, appendVariable, prefix, "ldflags", ldflags, true) + err = setVariable(ctx.file, ctx.append, ctx.prefix, "ldflags", ldflags, true) if err != nil { return err } @@ -484,9 +511,9 @@ func ldflags(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVa if version_script, ok := lists["version"]; ok && !emptyList(version_script) { if len(version_script.(*bpparser.List).Values) > 1 { - file.errorf(mkvalue, "multiple version scripts found?") + ctx.file.errorf(ctx.mkvalue, "multiple version scripts found?") } - err = setVariable(file, false, prefix, "version_script", version_script.(*bpparser.List).Values[0], true) + err = setVariable(ctx.file, false, ctx.prefix, "version_script", version_script.(*bpparser.List).Values[0], true) if err != nil { return err } @@ -495,8 +522,52 @@ func ldflags(file *bpFile, prefix string, mkvalue *mkparser.MakeString, appendVa return nil } -var deleteProperties = map[string]struct{}{ - "LOCAL_CPP_EXTENSION": struct{}{}, +// given a conditional, returns a function that will insert a variable assignment or not, based on the conditional +func includeVariableIf(bpVar bpVariable, conditional func(ctx variableAssignmentContext) bool) func(ctx variableAssignmentContext) error { + return func(ctx variableAssignmentContext) error { + var err error + if conditional(ctx) { + err = includeVariableNow(bpVar, ctx) + } + return err + } +} + +// given a variable, returns a function that will always insert a variable assignment +func includeVariable(bpVar bpVariable) func(ctx variableAssignmentContext) error { + return includeVariableIf(bpVar, always) +} + +func includeVariableNow(bpVar bpVariable, ctx variableAssignmentContext) error { + var val bpparser.Expression + var err error + val, err = makeVariableToBlueprint(ctx.file, ctx.mkvalue, bpVar.variableType) + if err == nil { + err = setVariable(ctx.file, ctx.append, ctx.prefix, bpVar.name, val, true) + } + return err +} + +// given a function that returns a bool, returns a function that returns the opposite +func not(conditional func(ctx variableAssignmentContext) bool) func(ctx variableAssignmentContext) bool { + return func(ctx variableAssignmentContext) bool { + return !conditional(ctx) + } +} + +// returns a function that tells whether mkvalue.Dump equals the given query string +func valueDumpEquals(textToMatch string) func(ctx variableAssignmentContext) bool { + return func(ctx variableAssignmentContext) bool { + return (ctx.mkvalue.Dump() == textToMatch) + } +} + +func always(ctx variableAssignmentContext) bool { + return true +} + +func skip(ctx variableAssignmentContext) error { + return nil } // Shorter suffixes of other suffixes must be at the end of the list diff --git a/androidmk/cmd/androidmk/androidmk.go b/androidmk/cmd/androidmk/androidmk.go index 729e4f2a4..1d94b65e8 100644 --- a/androidmk/cmd/androidmk/androidmk.go +++ b/androidmk/cmd/androidmk/androidmk.go @@ -233,28 +233,16 @@ func handleAssignment(file *bpFile, assignment *mkparser.Assignment, c *conditio appendVariable := assignment.Type == "+=" var err error - if prop, ok := standardProperties[name]; ok { - var val bpparser.Expression - val, err = makeVariableToBlueprint(file, assignment.Value, prop.Type) - if err == nil { - err = setVariable(file, appendVariable, prefix, prop.string, val, true) - } - } else if prop, ok := rewriteProperties[name]; ok { - err = prop.f(file, prefix, assignment.Value, appendVariable) - } else if _, ok := deleteProperties[name]; ok { - return + if prop, ok := rewriteProperties[name]; ok { + err = prop(variableAssignmentContext{file, prefix, assignment.Value, appendVariable}) } else { switch { - case name == "LOCAL_PATH": - // Nothing to do, except maybe avoid the "./" in paths? case name == "LOCAL_ARM_MODE": // This is a hack to get the LOCAL_ARM_MODE value inside // of an arch: { arm: {} } block. armModeAssign := assignment armModeAssign.Name = mkparser.SimpleMakeString("LOCAL_ARM_MODE_HACK_arm", assignment.Name.Pos()) handleAssignment(file, armModeAssign, c) - case name == "LOCAL_ADDITIONAL_DEPENDENCIES": - // TODO: check for only .mk files? case strings.HasPrefix(name, "LOCAL_"): file.errorf(assignment, "unsupported assignment to %s", name) return diff --git a/androidmk/cmd/androidmk/androidmk_test.go b/androidmk/cmd/androidmk/androidmk_test.go index 2f4daf774..0c44ea72a 100644 --- a/androidmk/cmd/androidmk/androidmk_test.go +++ b/androidmk/cmd/androidmk/androidmk_test.go @@ -355,6 +355,34 @@ include $(BUILD_SHARED_LIBRARY) cc_library_shared { include_dirs: ["system/core/include", "."], } +`, + }, + { + desc: "Remove LOCAL_MODULE_TAGS optional", + in: ` +include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := optional +include $(BUILD_SHARED_LIBRARY) +`, + + expected: ` +cc_library_shared { + +} +`, + }, + { + desc: "Keep LOCAL_MODULE_TAGS non-optional", + in: ` +include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := debug +include $(BUILD_SHARED_LIBRARY) +`, + + expected: ` +cc_library_shared { + tags: ["debug"], +} `, }, }