518 lines
13 KiB
Go
518 lines
13 KiB
Go
|
// Copyright 2020 Google Inc. All rights reserved.
|
||
|
|
//
|
||
|
|
// 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.
|
||
|
|
|
||
|
|
package soongconfig
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"io"
|
||
|
|
"reflect"
|
||
|
|
"sort"
|
||
|
|
"strings"
|
||
|
|
|
||
|
|
"github.com/google/blueprint"
|
||
|
|
"github.com/google/blueprint/parser"
|
||
|
|
"github.com/google/blueprint/proptools"
|
||
|
|
)
|
||
|
|
|
||
|
|
var soongConfigProperty = proptools.FieldNameForProperty("soong_config_variables")
|
||
|
|
|
||
|
|
// loadSoongConfigModuleTypeDefinition loads module types from an Android.bp file. It caches the
|
||
|
|
// result so each file is only parsed once.
|
||
|
|
func Parse(r io.Reader, from string) (*SoongConfigDefinition, []error) {
|
||
|
|
scope := parser.NewScope(nil)
|
||
|
|
file, errs := parser.ParseAndEval(from, r, scope)
|
||
|
|
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return nil, errs
|
||
|
|
}
|
||
|
|
|
||
|
|
mtDef := &SoongConfigDefinition{
|
||
|
|
ModuleTypes: make(map[string]*ModuleType),
|
||
|
|
variables: make(map[string]soongConfigVariable),
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, def := range file.Defs {
|
||
|
|
switch def := def.(type) {
|
||
|
|
case *parser.Module:
|
||
|
|
newErrs := processImportModuleDef(mtDef, def)
|
||
|
|
|
||
|
|
if len(newErrs) > 0 {
|
||
|
|
errs = append(errs, newErrs...)
|
||
|
|
}
|
||
|
|
|
||
|
|
case *parser.Assignment:
|
||
|
|
// Already handled via Scope object
|
||
|
|
default:
|
||
|
|
panic("unknown definition type")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return nil, errs
|
||
|
|
}
|
||
|
|
|
||
|
|
for name, moduleType := range mtDef.ModuleTypes {
|
||
|
|
for _, varName := range moduleType.variableNames {
|
||
|
|
if v, ok := mtDef.variables[varName]; ok {
|
||
|
|
moduleType.Variables = append(moduleType.Variables, v)
|
||
|
|
} else {
|
||
|
|
return nil, []error{
|
||
|
|
fmt.Errorf("unknown variable %q in module type %q", varName, name),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return mtDef, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func processImportModuleDef(v *SoongConfigDefinition, def *parser.Module) (errs []error) {
|
||
|
|
switch def.Type {
|
||
|
|
case "soong_config_module_type":
|
||
|
|
return processModuleTypeDef(v, def)
|
||
|
|
case "soong_config_string_variable":
|
||
|
|
return processStringVariableDef(v, def)
|
||
|
|
case "soong_config_bool_variable":
|
||
|
|
return processBoolVariableDef(v, def)
|
||
|
|
default:
|
||
|
|
// Unknown module types will be handled when the file is parsed as a normal
|
||
|
|
// Android.bp file.
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type ModuleTypeProperties struct {
|
||
|
|
// the name of the new module type. Unlike most modules, this name does not need to be unique,
|
||
|
|
// although only one module type with any name will be importable into an Android.bp file.
|
||
|
|
Name string
|
||
|
|
|
||
|
|
// the module type that this module type will extend.
|
||
|
|
Module_type string
|
||
|
|
|
||
|
|
// the SOONG_CONFIG_NAMESPACE value from a BoardConfig.mk that this module type will read
|
||
|
|
// configuration variables from.
|
||
|
|
Config_namespace string
|
||
|
|
|
||
|
|
// the list of SOONG_CONFIG variables that this module type will read
|
||
|
|
Variables []string
|
||
|
|
|
||
|
|
// the list of properties that this module type will extend.
|
||
|
|
Properties []string
|
||
|
|
}
|
||
|
|
|
||
|
|
func processModuleTypeDef(v *SoongConfigDefinition, def *parser.Module) (errs []error) {
|
||
|
|
|
||
|
|
props := &ModuleTypeProperties{}
|
||
|
|
|
||
|
|
_, errs = proptools.UnpackProperties(def.Properties, props)
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return errs
|
||
|
|
}
|
||
|
|
|
||
|
|
if props.Name == "" {
|
||
|
|
errs = append(errs, fmt.Errorf("name property must be set"))
|
||
|
|
}
|
||
|
|
|
||
|
|
if props.Config_namespace == "" {
|
||
|
|
errs = append(errs, fmt.Errorf("config_namespace property must be set"))
|
||
|
|
}
|
||
|
|
|
||
|
|
if props.Module_type == "" {
|
||
|
|
errs = append(errs, fmt.Errorf("module_type property must be set"))
|
||
|
|
}
|
||
|
|
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return errs
|
||
|
|
}
|
||
|
|
|
||
|
|
mt := &ModuleType{
|
||
|
|
affectableProperties: props.Properties,
|
||
|
|
ConfigNamespace: props.Config_namespace,
|
||
|
|
BaseModuleType: props.Module_type,
|
||
|
|
variableNames: props.Variables,
|
||
|
|
}
|
||
|
|
v.ModuleTypes[props.Name] = mt
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type VariableProperties struct {
|
||
|
|
Name string
|
||
|
|
}
|
||
|
|
|
||
|
|
type StringVariableProperties struct {
|
||
|
|
Values []string
|
||
|
|
}
|
||
|
|
|
||
|
|
func processStringVariableDef(v *SoongConfigDefinition, def *parser.Module) (errs []error) {
|
||
|
|
stringProps := &StringVariableProperties{}
|
||
|
|
|
||
|
|
base, errs := processVariableDef(def, stringProps)
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return errs
|
||
|
|
}
|
||
|
|
|
||
|
|
if len(stringProps.Values) == 0 {
|
||
|
|
return []error{fmt.Errorf("values property must be set")}
|
||
|
|
}
|
||
|
|
|
||
|
|
v.variables[base.variable] = &stringVariable{
|
||
|
|
baseVariable: base,
|
||
|
|
values: CanonicalizeToProperties(stringProps.Values),
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func processBoolVariableDef(v *SoongConfigDefinition, def *parser.Module) (errs []error) {
|
||
|
|
base, errs := processVariableDef(def)
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return errs
|
||
|
|
}
|
||
|
|
|
||
|
|
v.variables[base.variable] = &boolVariable{
|
||
|
|
baseVariable: base,
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func processVariableDef(def *parser.Module,
|
||
|
|
extraProps ...interface{}) (cond baseVariable, errs []error) {
|
||
|
|
|
||
|
|
props := &VariableProperties{}
|
||
|
|
|
||
|
|
allProps := append([]interface{}{props}, extraProps...)
|
||
|
|
|
||
|
|
_, errs = proptools.UnpackProperties(def.Properties, allProps...)
|
||
|
|
if len(errs) > 0 {
|
||
|
|
return baseVariable{}, errs
|
||
|
|
}
|
||
|
|
|
||
|
|
if props.Name == "" {
|
||
|
|
return baseVariable{}, []error{fmt.Errorf("name property must be set")}
|
||
|
|
}
|
||
|
|
|
||
|
|
return baseVariable{
|
||
|
|
variable: props.Name,
|
||
|
|
}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type SoongConfigDefinition struct {
|
||
|
|
ModuleTypes map[string]*ModuleType
|
||
|
|
|
||
|
|
variables map[string]soongConfigVariable
|
||
|
|
}
|
||
|
|
|
||
|
|
// CreateProperties returns a reflect.Value of a newly constructed type that contains the desired
|
||
|
|
// property layout for the Soong config variables, with each possible value an interface{} that
|
||
|
|
// contains a nil pointer to another newly constructed type that contains the affectable properties.
|
||
|
|
// The reflect.Value will be cloned for each call to the Soong config module type's factory method.
|
||
|
|
//
|
||
|
|
// For example, the acme_cc_defaults example above would
|
||
|
|
// produce a reflect.Value whose type is:
|
||
|
|
// *struct {
|
||
|
|
// Soong_config_variables struct {
|
||
|
|
// Board struct {
|
||
|
|
// Soc_a interface{}
|
||
|
|
// Soc_b interface{}
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// And whose value is:
|
||
|
|
// &{
|
||
|
|
// Soong_config_variables: {
|
||
|
|
// Board: {
|
||
|
|
// Soc_a: (*struct{ Cflags []string })(nil),
|
||
|
|
// Soc_b: (*struct{ Cflags []string })(nil),
|
||
|
|
// },
|
||
|
|
// },
|
||
|
|
// }
|
||
|
|
func CreateProperties(factory blueprint.ModuleFactory, moduleType *ModuleType) reflect.Value {
|
||
|
|
var fields []reflect.StructField
|
||
|
|
|
||
|
|
_, factoryProps := factory()
|
||
|
|
affectablePropertiesType := createAffectablePropertiesType(moduleType.affectableProperties, factoryProps)
|
||
|
|
if affectablePropertiesType == nil {
|
||
|
|
return reflect.Value{}
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, c := range moduleType.Variables {
|
||
|
|
fields = append(fields, reflect.StructField{
|
||
|
|
Name: proptools.FieldNameForProperty(c.variableProperty()),
|
||
|
|
Type: c.variableValuesType(),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
typ := reflect.StructOf([]reflect.StructField{{
|
||
|
|
Name: soongConfigProperty,
|
||
|
|
Type: reflect.StructOf(fields),
|
||
|
|
}})
|
||
|
|
|
||
|
|
props := reflect.New(typ)
|
||
|
|
structConditions := props.Elem().FieldByName(soongConfigProperty)
|
||
|
|
|
||
|
|
for i, c := range moduleType.Variables {
|
||
|
|
c.initializeProperties(structConditions.Field(i), affectablePropertiesType)
|
||
|
|
}
|
||
|
|
|
||
|
|
return props
|
||
|
|
}
|
||
|
|
|
||
|
|
// createAffectablePropertiesType creates a reflect.Type of a struct that has a field for each affectable property
|
||
|
|
// that exists in factoryProps.
|
||
|
|
func createAffectablePropertiesType(affectableProperties []string, factoryProps []interface{}) reflect.Type {
|
||
|
|
affectableProperties = append([]string(nil), affectableProperties...)
|
||
|
|
sort.Strings(affectableProperties)
|
||
|
|
|
||
|
|
var recurse func(prefix string, aps []string) ([]string, reflect.Type)
|
||
|
|
recurse = func(prefix string, aps []string) ([]string, reflect.Type) {
|
||
|
|
var fields []reflect.StructField
|
||
|
|
|
||
|
|
for len(affectableProperties) > 0 {
|
||
|
|
p := affectableProperties[0]
|
||
|
|
if !strings.HasPrefix(affectableProperties[0], prefix) {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
affectableProperties = affectableProperties[1:]
|
||
|
|
|
||
|
|
nestedProperty := strings.TrimPrefix(p, prefix)
|
||
|
|
if i := strings.IndexRune(nestedProperty, '.'); i >= 0 {
|
||
|
|
var nestedType reflect.Type
|
||
|
|
nestedPrefix := nestedProperty[:i+1]
|
||
|
|
|
||
|
|
affectableProperties, nestedType = recurse(prefix+nestedPrefix, affectableProperties)
|
||
|
|
|
||
|
|
if nestedType != nil {
|
||
|
|
nestedFieldName := proptools.FieldNameForProperty(strings.TrimSuffix(nestedPrefix, "."))
|
||
|
|
|
||
|
|
fields = append(fields, reflect.StructField{
|
||
|
|
Name: nestedFieldName,
|
||
|
|
Type: nestedType,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
typ := typeForPropertyFromPropertyStructs(factoryProps, p)
|
||
|
|
if typ != nil {
|
||
|
|
fields = append(fields, reflect.StructField{
|
||
|
|
Name: proptools.FieldNameForProperty(nestedProperty),
|
||
|
|
Type: typ,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var typ reflect.Type
|
||
|
|
if len(fields) > 0 {
|
||
|
|
typ = reflect.StructOf(fields)
|
||
|
|
}
|
||
|
|
return affectableProperties, typ
|
||
|
|
}
|
||
|
|
|
||
|
|
affectableProperties, typ := recurse("", affectableProperties)
|
||
|
|
if len(affectableProperties) > 0 {
|
||
|
|
panic(fmt.Errorf("didn't handle all affectable properties"))
|
||
|
|
}
|
||
|
|
|
||
|
|
if typ != nil {
|
||
|
|
return reflect.PtrTo(typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func typeForPropertyFromPropertyStructs(psList []interface{}, property string) reflect.Type {
|
||
|
|
for _, ps := range psList {
|
||
|
|
if typ := typeForPropertyFromPropertyStruct(ps, property); typ != nil {
|
||
|
|
return typ
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func typeForPropertyFromPropertyStruct(ps interface{}, property string) reflect.Type {
|
||
|
|
v := reflect.ValueOf(ps)
|
||
|
|
for len(property) > 0 {
|
||
|
|
if !v.IsValid() {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
if v.Kind() == reflect.Interface {
|
||
|
|
if v.IsNil() {
|
||
|
|
return nil
|
||
|
|
} else {
|
||
|
|
v = v.Elem()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if v.Kind() == reflect.Ptr {
|
||
|
|
if v.IsNil() {
|
||
|
|
v = reflect.Zero(v.Type().Elem())
|
||
|
|
} else {
|
||
|
|
v = v.Elem()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if v.Kind() != reflect.Struct {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
if index := strings.IndexRune(property, '.'); index >= 0 {
|
||
|
|
prefix := property[:index]
|
||
|
|
property = property[index+1:]
|
||
|
|
|
||
|
|
v = v.FieldByName(proptools.FieldNameForProperty(prefix))
|
||
|
|
} else {
|
||
|
|
f := v.FieldByName(proptools.FieldNameForProperty(property))
|
||
|
|
if !f.IsValid() {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
return f.Type()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// PropertiesToApply returns the applicable properties from a ModuleType that should be applied
|
||
|
|
// based on SoongConfig values.
|
||
|
|
func PropertiesToApply(moduleType *ModuleType, props reflect.Value, config SoongConfig) []interface{} {
|
||
|
|
var ret []interface{}
|
||
|
|
props = props.Elem().FieldByName(soongConfigProperty)
|
||
|
|
for i, c := range moduleType.Variables {
|
||
|
|
if ps := c.PropertiesToApply(config, props.Field(i)); ps != nil {
|
||
|
|
ret = append(ret, ps)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return ret
|
||
|
|
}
|
||
|
|
|
||
|
|
type ModuleType struct {
|
||
|
|
BaseModuleType string
|
||
|
|
ConfigNamespace string
|
||
|
|
Variables []soongConfigVariable
|
||
|
|
|
||
|
|
affectableProperties []string
|
||
|
|
variableNames []string
|
||
|
|
}
|
||
|
|
|
||
|
|
type soongConfigVariable interface {
|
||
|
|
// variableProperty returns the name of the variable.
|
||
|
|
variableProperty() string
|
||
|
|
|
||
|
|
// conditionalValuesType returns a reflect.Type that contains an interface{} for each possible value.
|
||
|
|
variableValuesType() reflect.Type
|
||
|
|
|
||
|
|
// initializeProperties is passed a reflect.Value of the reflect.Type returned by conditionalValuesType and a
|
||
|
|
// reflect.Type of the affectable properties, and should initialize each interface{} in the reflect.Value with
|
||
|
|
// the zero value of the affectable properties type.
|
||
|
|
initializeProperties(v reflect.Value, typ reflect.Type)
|
||
|
|
|
||
|
|
// PropertiesToApply should return one of the interface{} values set by initializeProperties to be applied
|
||
|
|
// to the module.
|
||
|
|
PropertiesToApply(config SoongConfig, values reflect.Value) interface{}
|
||
|
|
}
|
||
|
|
|
||
|
|
type baseVariable struct {
|
||
|
|
variable string
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c *baseVariable) variableProperty() string {
|
||
|
|
return CanonicalizeToProperty(c.variable)
|
||
|
|
}
|
||
|
|
|
||
|
|
type stringVariable struct {
|
||
|
|
baseVariable
|
||
|
|
values []string
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stringVariable) variableValuesType() reflect.Type {
|
||
|
|
var fields []reflect.StructField
|
||
|
|
|
||
|
|
for _, v := range s.values {
|
||
|
|
fields = append(fields, reflect.StructField{
|
||
|
|
Name: proptools.FieldNameForProperty(v),
|
||
|
|
Type: emptyInterfaceType,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
return reflect.StructOf(fields)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stringVariable) initializeProperties(v reflect.Value, typ reflect.Type) {
|
||
|
|
for i := range s.values {
|
||
|
|
v.Field(i).Set(reflect.Zero(typ))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stringVariable) PropertiesToApply(config SoongConfig, values reflect.Value) interface{} {
|
||
|
|
for j, v := range s.values {
|
||
|
|
if config.String(s.variable) == v {
|
||
|
|
return values.Field(j).Interface()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type boolVariable struct {
|
||
|
|
baseVariable
|
||
|
|
}
|
||
|
|
|
||
|
|
func (b boolVariable) variableValuesType() reflect.Type {
|
||
|
|
return emptyInterfaceType
|
||
|
|
}
|
||
|
|
|
||
|
|
func (b boolVariable) initializeProperties(v reflect.Value, typ reflect.Type) {
|
||
|
|
v.Set(reflect.Zero(typ))
|
||
|
|
}
|
||
|
|
|
||
|
|
func (b boolVariable) PropertiesToApply(config SoongConfig, values reflect.Value) interface{} {
|
||
|
|
if config.Bool(b.variable) {
|
||
|
|
return values.Interface()
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func CanonicalizeToProperty(v string) string {
|
||
|
|
return strings.Map(func(r rune) rune {
|
||
|
|
switch {
|
||
|
|
case r >= 'A' && r <= 'Z',
|
||
|
|
r >= 'a' && r <= 'z',
|
||
|
|
r >= '0' && r <= '9',
|
||
|
|
r == '_':
|
||
|
|
return r
|
||
|
|
default:
|
||
|
|
return '_'
|
||
|
|
}
|
||
|
|
}, v)
|
||
|
|
}
|
||
|
|
|
||
|
|
func CanonicalizeToProperties(values []string) []string {
|
||
|
|
ret := make([]string, len(values))
|
||
|
|
for i, v := range values {
|
||
|
|
ret[i] = CanonicalizeToProperty(v)
|
||
|
|
}
|
||
|
|
return ret
|
||
|
|
}
|
||
|
|
|
||
|
|
type emptyInterfaceStruct struct {
|
||
|
|
i interface{}
|
||
|
|
}
|
||
|
|
|
||
|
|
var emptyInterfaceType = reflect.TypeOf(emptyInterfaceStruct{}).Field(0).Type
|