Add support for enums within structs and interfaces to mojom.

mojo/public/bindings/parse/mojo_translate.py

 #!/usr/bin/env python
 # Copyright 2013 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.
 
 """Translate parse tree to Mojom IR"""
 
 
 import os
 import sys
@@ skipping 57 matching lines @@
 
 def MapMethods(methods):
   out = []
   for method in methods:
     if method[0] == 'METHOD':
       out.append({'name': method[1],
                   'parameters': MapParameters(method[2]),
                   'ordinal': MapOrdinal(method[3])})
   return out
 
+
 def MapEnumFields(fields):
   out = []
   for field in fields:
     if field[0] == 'ENUM_FIELD':
       out.append({'name': field[1],
                   'value': field[2]})
   return out
 
+
+def MapEnums(enums):
+  out = []
+  for enum in enums:
+    if enum[0] == 'ENUM':
+      out.append({'name': enum[1],
+                  'fields': MapEnumFields(enum[2])})
+  return out
+
+
 class MojomBuilder():
 
   def __init__(self):
     self.mojom = {}
 
-  def AddStruct(self, name, attributes, fields):
+  def AddStruct(self, name, attributes, body):
     struct = {}
     struct['name'] = name
     # TODO(darin): Add support for |attributes|
     #struct['attributes'] = MapAttributes(attributes)
-    struct['fields'] = MapFields(fields)
+    struct['fields'] = MapFields(body)
+    struct['enums'] = MapEnums(body)
     self.mojom['structs'].append(struct)
 
-  def AddInterface(self, name, attributes, methods):
+  def AddInterface(self, name, attributes, body):
     interface = {}
     interface['name'] = name
     interface['peer'] = GetAttribute(attributes, 'Peer')
-    interface['methods'] = MapMethods(methods)
+    interface['methods'] = MapMethods(body)
+    interface['enums'] = MapEnums(body)
     self.mojom['interfaces'].append(interface)
 
   def AddEnum(self, name, fields):
     # TODO(mpcomplete): add support for specifying enums as types. Right now
     # we just use int32.
     enum = {}
     enum['name'] = name
     enum['fields'] = MapEnumFields(fields)
     self.mojom['enums'].append(enum)
 
   def AddModule(self, name, namespace, contents):
     self.mojom['name'] = name
     self.mojom['namespace'] = namespace
     self.mojom['structs'] = []
     self.mojom['interfaces'] = []
     self.mojom['enums'] = []
     for item in contents:
       if item[0] == 'STRUCT':
-        self.AddStruct(name=item[1], attributes=item[2], fields=item[3])
+        self.AddStruct(name=item[1], attributes=item[2], body=item[3])
       elif item[0] == 'INTERFACE':
-        self.AddInterface(name=item[1], attributes=item[2], methods=item[3])
+        self.AddInterface(name=item[1], attributes=item[2], body=item[3])
       elif item[0] == 'ENUM':
         self.AddEnum(name=item[1], fields=item[2])
 
   def Build(self, tree, name):
     if tree[0] == 'MODULE':
       self.AddModule(name=name, namespace=tree[1], contents=tree[2])
     return self.mojom
 
 
 def Translate(tree, name):
   return MojomBuilder().Build(tree, name)
 
 
 def Main():
   if len(sys.argv) < 2:
     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()