Adding attributes to module and struct in mojom.

mojo/public/tools/bindings/pylib/mojom/parse/translate.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Translates parse tree to Mojom IR."""
 
 
 import os.path
 import sys
@@ skipping 23 matching lines @@
                   'handle<data_pipe_consumer>': 'h:d:c',
                   'handle<data_pipe_producer>': 'h:d:p',
                   'handle<message_pipe>': 'h:m',
                   'handle<shared_buffer>': 'h:s'}
   if kind.endswith('[]'):
     return 'a:' + MapKind(kind[0:len(kind)-2])
   if kind in map_to_kind:
     return map_to_kind[kind]
   return 'x:' + kind
 
+def MapAttributes(attributes):
+  def _AttributeValueToString(v):

[qsr, 2014/04/30 13:03:45]

Not sure this is the best solution. If you think it is better, I can re work on
the lexer to add an attribute_value token which would be mostly anything but
comma. We would need to decide what to do with whitespace though...

[darin (slow to review), 2014/05/02 07:44:01]

Do you think that would help us catch syntactic errors earlier? If so, then we
should probably do it.

Also, I think it would be helpful to add a comment here describing the transform
MapAttributes is performing.

[qsr, 2014/05/05 12:40:05]

 Finally, I let the expression, and decided to use string literal if needed.
This solve the question we could have with whitespaces.
 I removed this also. I just keep the full expression, and let any user do what
it needs with it. This is because we might really have expression there someday,
as done as an example in sample_service.mojom

+    if isinstance(v, basestring):
+      return v
+    return ''.join(v[1])
+  if not attributes:
+    return {}
+  return dict([(attribute[1], _AttributeValueToString(attribute[2]))
+               for attribute in attributes if attribute[0] == 'ATTRIBUTE'])
+
 def GetAttribute(attributes, name):
   out = None
   if attributes:
     for attribute in attributes:
       if attribute[0] == 'ATTRIBUTE' and attribute[1] == name:
         out = attribute[2]
   return out
 
 def MapField(tree):
   assert type(tree[3]) is ast.Ordinal
@@ skipping 17 matching lines @@
     method['response_parameters'] = MapTree(MapParameter, tree[4], 'PARAM')
   return method
 
 def MapEnumField(tree):
   return {'name': tree[1],
           'value': tree[2]}
 
 def MapStruct(tree):
   struct = {}
   struct['name'] = tree[1]
-  # TODO(darin): Add support for |attributes|
-  #struct['attributes'] = MapAttributes(tree[2])
+  struct['attributes'] = MapAttributes(tree[2])
   struct['fields'] = MapTree(MapField, tree[3], 'FIELD')
   struct['enums'] = MapTree(MapEnum, tree[3], 'ENUM')
   return struct
 
 def MapInterface(tree):
   interface = {}
   interface['name'] = tree[1]
   interface['peer'] = GetAttribute(tree[2], 'Peer')
   interface['methods'] = MapTree(MapMethod, tree[3], 'METHOD')
   interface['enums'] = MapTree(MapEnum, tree[3], 'ENUM')
   return interface
 
 def MapEnum(tree):
   enum = {}
   enum['name'] = tree[1]
   enum['fields'] = MapTree(MapEnumField, tree[2], 'ENUM_FIELD')
   return enum
 
 def MapModule(tree, name):
   mojom = {}
   mojom['name'] = name
   mojom['namespace'] = tree[1]
-  mojom['structs'] = MapTree(MapStruct, tree[2], 'STRUCT')
-  mojom['interfaces'] = MapTree(MapInterface, tree[2], 'INTERFACE')
-  mojom['enums'] = MapTree(MapEnum, tree[2], 'ENUM')
+  mojom['attributes'] = MapAttributes(tree[2])
+  mojom['structs'] = MapTree(MapStruct, tree[3], 'STRUCT')
+  mojom['interfaces'] = MapTree(MapInterface, tree[3], 'INTERFACE')
+  mojom['enums'] = MapTree(MapEnum, tree[3], 'ENUM')
   return mojom
 
 def MapImport(tree):
   import_item = {}
   import_item['filename'] = tree[1]
   return import_item
 
 
 class MojomBuilder():
   def __init__(self):
@@ skipping 18 matching lines @@
     print("usage: %s filename" % (sys.argv[0]))
     sys.exit(1)
   tree = eval(open(sys.argv[1]).read())
   name = os.path.splitext(os.path.basename(sys.argv[1]))[0]
   result = Translate(tree, name)
   print(result)
 
 
 if __name__ == '__main__':
   Main()