bp.go 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  1. // Copyright (C) 2019 The Android Open Source Project
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package sdk
  15. import (
  16. "fmt"
  17. "reflect"
  18. "strings"
  19. "android/soong/android"
  20. )
  21. type bpPropertySet struct {
  22. properties map[string]interface{}
  23. tags map[string]android.BpPropertyTag
  24. comments map[string]string
  25. order []string
  26. }
  27. var _ android.BpPropertySet = (*bpPropertySet)(nil)
  28. func (s *bpPropertySet) init() {
  29. s.properties = make(map[string]interface{})
  30. s.tags = make(map[string]android.BpPropertyTag)
  31. }
  32. // Converts the given value, which is assumed to be a struct, to a
  33. // bpPropertySet.
  34. func convertToPropertySet(value reflect.Value) *bpPropertySet {
  35. res := newPropertySet()
  36. structType := value.Type()
  37. for i := 0; i < structType.NumField(); i++ {
  38. field := structType.Field(i)
  39. fieldVal := value.Field(i)
  40. switch fieldVal.Type().Kind() {
  41. case reflect.Ptr:
  42. if fieldVal.IsNil() {
  43. continue // nil pointer means the property isn't set.
  44. }
  45. fieldVal = fieldVal.Elem()
  46. case reflect.Slice:
  47. if fieldVal.IsNil() {
  48. continue // Ignore a nil slice (but not one with length zero).
  49. }
  50. }
  51. if fieldVal.Type().Kind() == reflect.Struct {
  52. fieldVal = fieldVal.Addr() // Avoid struct copy below.
  53. }
  54. res.AddProperty(strings.ToLower(field.Name), fieldVal.Interface())
  55. }
  56. return res
  57. }
  58. // Converts the given value to something that can be set in a property.
  59. func coercePropertyValue(value interface{}) interface{} {
  60. val := reflect.ValueOf(value)
  61. switch val.Kind() {
  62. case reflect.Struct:
  63. // convertToPropertySet requires an addressable struct, and this is probably
  64. // a mistake.
  65. panic(fmt.Sprintf("Value is a struct, not a pointer to one: %v", value))
  66. case reflect.Ptr:
  67. if _, ok := value.(*bpPropertySet); !ok {
  68. derefValue := reflect.Indirect(val)
  69. if derefValue.Kind() != reflect.Struct {
  70. panic(fmt.Sprintf("A pointer must be to a struct, got: %v", value))
  71. }
  72. return convertToPropertySet(derefValue)
  73. }
  74. }
  75. return value
  76. }
  77. // Merges the fields of the given property set into s.
  78. func (s *bpPropertySet) mergePropertySet(propSet *bpPropertySet) {
  79. for _, name := range propSet.order {
  80. if tag, ok := propSet.tags[name]; ok {
  81. s.AddPropertyWithTag(name, propSet.properties[name], tag)
  82. } else {
  83. s.AddProperty(name, propSet.properties[name])
  84. }
  85. }
  86. }
  87. func (s *bpPropertySet) AddProperty(name string, value interface{}) {
  88. value = coercePropertyValue(value)
  89. if propSetValue, ok := value.(*bpPropertySet); ok {
  90. if curValue, ok := s.properties[name]; ok {
  91. if curSet, ok := curValue.(*bpPropertySet); ok {
  92. curSet.mergePropertySet(propSetValue)
  93. return
  94. }
  95. // If the current value isn't a property set we got conflicting types.
  96. // Continue down to the check below to complain about it.
  97. }
  98. }
  99. if s.properties[name] != nil {
  100. panic(fmt.Sprintf("Property %q already exists in property set", name))
  101. }
  102. s.properties[name] = value
  103. s.order = append(s.order, name)
  104. }
  105. func (s *bpPropertySet) AddPropertyWithTag(name string, value interface{}, tag android.BpPropertyTag) {
  106. s.AddProperty(name, value)
  107. s.tags[name] = tag
  108. }
  109. func (s *bpPropertySet) AddPropertySet(name string) android.BpPropertySet {
  110. s.AddProperty(name, newPropertySet())
  111. return s.properties[name].(android.BpPropertySet)
  112. }
  113. func (s *bpPropertySet) getValue(name string) interface{} {
  114. return s.properties[name]
  115. }
  116. func (s *bpPropertySet) getOptionalValue(name string) (interface{}, bool) {
  117. value, ok := s.properties[name]
  118. return value, ok
  119. }
  120. func (s *bpPropertySet) getTag(name string) interface{} {
  121. return s.tags[name]
  122. }
  123. func (s *bpPropertySet) AddCommentForProperty(name, text string) {
  124. if s.comments == nil {
  125. s.comments = map[string]string{}
  126. }
  127. s.comments[name] = strings.TrimSpace(text)
  128. }
  129. func (s *bpPropertySet) transformContents(transformer bpPropertyTransformer) {
  130. var newOrder []string
  131. for _, name := range s.order {
  132. value := s.properties[name]
  133. tag := s.tags[name]
  134. var newValue interface{}
  135. var newTag android.BpPropertyTag
  136. if propertySet, ok := value.(*bpPropertySet); ok {
  137. var newPropertySet *bpPropertySet
  138. newPropertySet, newTag = transformPropertySet(transformer, name, propertySet, tag)
  139. if newPropertySet == nil {
  140. newValue = nil
  141. } else {
  142. newValue = newPropertySet
  143. }
  144. } else {
  145. newValue, newTag = transformer.transformProperty(name, value, tag)
  146. }
  147. if newValue == nil {
  148. // Delete the property from the map and exclude it from the new order.
  149. delete(s.properties, name)
  150. } else {
  151. // Update the property in the map and add the name to the new order list.
  152. s.properties[name] = newValue
  153. s.tags[name] = newTag
  154. newOrder = append(newOrder, name)
  155. }
  156. }
  157. s.order = newOrder
  158. }
  159. func transformPropertySet(transformer bpPropertyTransformer, name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
  160. newPropertySet, newTag := transformer.transformPropertySetBeforeContents(name, propertySet, tag)
  161. if newPropertySet != nil {
  162. newPropertySet.transformContents(transformer)
  163. newPropertySet, newTag = transformer.transformPropertySetAfterContents(name, newPropertySet, newTag)
  164. }
  165. return newPropertySet, newTag
  166. }
  167. func (s *bpPropertySet) setProperty(name string, value interface{}) {
  168. if s.properties[name] == nil {
  169. s.AddProperty(name, value)
  170. } else {
  171. s.properties[name] = value
  172. s.tags[name] = nil
  173. }
  174. }
  175. func (s *bpPropertySet) removeProperty(name string) {
  176. delete(s.properties, name)
  177. delete(s.tags, name)
  178. _, s.order = android.RemoveFromList(name, s.order)
  179. }
  180. func (s *bpPropertySet) insertAfter(position string, name string, value interface{}) {
  181. if s.properties[name] != nil {
  182. panic("Property %q already exists in property set")
  183. }
  184. // Add the name to the end of the order, to ensure it has necessary capacity
  185. // and to handle the case when the position does not exist.
  186. s.order = append(s.order, name)
  187. // Search through the order for the item that matches supplied position. If
  188. // found then insert the name of the new property after it.
  189. for i, v := range s.order {
  190. if v == position {
  191. // Copy the items after the one where the new property should be inserted.
  192. copy(s.order[i+2:], s.order[i+1:])
  193. // Insert the item in the list.
  194. s.order[i+1] = name
  195. }
  196. }
  197. s.properties[name] = value
  198. }
  199. type bpModule struct {
  200. *bpPropertySet
  201. moduleType string
  202. }
  203. func (m *bpModule) ModuleType() string {
  204. return m.moduleType
  205. }
  206. func (m *bpModule) Name() string {
  207. name, hasName := m.getOptionalValue("name")
  208. if hasName {
  209. return name.(string)
  210. } else {
  211. return ""
  212. }
  213. }
  214. var _ android.BpModule = (*bpModule)(nil)
  215. type bpPropertyTransformer interface {
  216. // Transform the property set, returning the new property set/tag to insert back into the
  217. // parent property set (or module if this is the top level property set).
  218. //
  219. // This will be called before transforming the properties in the supplied set.
  220. //
  221. // The name will be "" for the top level property set.
  222. //
  223. // Returning (nil, ...) will cause the property set to be removed.
  224. transformPropertySetBeforeContents(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag)
  225. // Transform the property set, returning the new property set/tag to insert back into the
  226. // parent property set (or module if this is the top level property set).
  227. //
  228. // This will be called after transforming the properties in the supplied set.
  229. //
  230. // The name will be "" for the top level property set.
  231. //
  232. // Returning (nil, ...) will cause the property set to be removed.
  233. transformPropertySetAfterContents(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag)
  234. // Transform a property, return the new value/tag to insert back into the property set.
  235. //
  236. // Returning (nil, ...) will cause the property to be removed.
  237. transformProperty(name string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag)
  238. }
  239. // Interface for transforming bpModule objects.
  240. type bpTransformer interface {
  241. // Transform the module, returning the result.
  242. //
  243. // The method can either create a new module and return that, or modify the supplied module
  244. // in place and return that.
  245. //
  246. // After this returns the transformer is applied to the contents of the returned module.
  247. transformModule(module *bpModule) *bpModule
  248. bpPropertyTransformer
  249. }
  250. type identityTransformation struct{}
  251. var _ bpTransformer = (*identityTransformation)(nil)
  252. func (t identityTransformation) transformModule(module *bpModule) *bpModule {
  253. return module
  254. }
  255. func (t identityTransformation) transformPropertySetBeforeContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
  256. return propertySet, tag
  257. }
  258. func (t identityTransformation) transformPropertySetAfterContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
  259. return propertySet, tag
  260. }
  261. func (t identityTransformation) transformProperty(_ string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) {
  262. return value, tag
  263. }
  264. func (m *bpModule) deepCopy() *bpModule {
  265. return transformModule(m, deepCopyTransformer)
  266. }
  267. func transformModule(m *bpModule, transformer bpTransformer) *bpModule {
  268. transformedModule := transformer.transformModule(m)
  269. if transformedModule != nil {
  270. // Copy the contents of the returned property set into the module and then transform that.
  271. transformedModule.bpPropertySet, _ = transformPropertySet(transformer, "", transformedModule.bpPropertySet, nil)
  272. }
  273. return transformedModule
  274. }
  275. type deepCopyTransformation struct {
  276. identityTransformation
  277. }
  278. func (t deepCopyTransformation) transformModule(module *bpModule) *bpModule {
  279. // Take a shallow copy of the module. Any mutable property values will be copied by the
  280. // transformer.
  281. moduleCopy := *module
  282. return &moduleCopy
  283. }
  284. func (t deepCopyTransformation) transformPropertySetBeforeContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
  285. // Create a shallow copy of the properties map. Any mutable property values will be copied by the
  286. // transformer.
  287. propertiesCopy := make(map[string]interface{})
  288. for propertyName, value := range propertySet.properties {
  289. propertiesCopy[propertyName] = value
  290. }
  291. // Ditto for tags map.
  292. tagsCopy := make(map[string]android.BpPropertyTag)
  293. for propertyName, propertyTag := range propertySet.tags {
  294. tagsCopy[propertyName] = propertyTag
  295. }
  296. // Create a new property set.
  297. return &bpPropertySet{
  298. properties: propertiesCopy,
  299. tags: tagsCopy,
  300. order: append([]string(nil), propertySet.order...),
  301. }, tag
  302. }
  303. func (t deepCopyTransformation) transformProperty(_ string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) {
  304. // Copy string slice, otherwise return value.
  305. if values, ok := value.([]string); ok {
  306. valuesCopy := make([]string, len(values))
  307. copy(valuesCopy, values)
  308. return valuesCopy, tag
  309. }
  310. return value, tag
  311. }
  312. var deepCopyTransformer bpTransformer = deepCopyTransformation{}
  313. // A .bp file
  314. type bpFile struct {
  315. modules map[string]*bpModule
  316. order []*bpModule
  317. }
  318. // AddModule adds a module to this.
  319. //
  320. // The module must have had its "name" property set to a string value that
  321. // is unique within this file.
  322. func (f *bpFile) AddModule(module android.BpModule) {
  323. m := module.(*bpModule)
  324. moduleType := module.ModuleType()
  325. name := m.Name()
  326. hasName := true
  327. if name == "" {
  328. // Use a prefixed module type as the name instead just in case this is something like a package
  329. // of namespace module which does not require a name.
  330. name = "#" + moduleType
  331. hasName = false
  332. }
  333. if f.modules[name] != nil {
  334. if hasName {
  335. panic(fmt.Sprintf("Module %q already exists in bp file", name))
  336. } else {
  337. panic(fmt.Sprintf("Unnamed module type %q already exists in bp file", moduleType))
  338. }
  339. }
  340. f.modules[name] = m
  341. f.order = append(f.order, m)
  342. }
  343. func (f *bpFile) newModule(moduleType string) *bpModule {
  344. return newModule(moduleType)
  345. }
  346. func newModule(moduleType string) *bpModule {
  347. module := &bpModule{
  348. moduleType: moduleType,
  349. bpPropertySet: newPropertySet(),
  350. }
  351. return module
  352. }
  353. func newPropertySet() *bpPropertySet {
  354. set := &bpPropertySet{}
  355. set.init()
  356. return set
  357. }