[mojo] Add typemap and variant support to generators

mojo/public/tools/bindings/mojom_bindings_generator.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.
 
 """The frontend for the Mojo bindings system."""
 
 
 import argparse
 import imp
+import json
 import os
 import pprint
+import re
 import sys
 
 # Disable lint check for finding modules:
 # pylint: disable=F0401
 
 def _GetDirAbove(dirname):
   """Returns the directory "above" this file containing |dirname| (which must
   also be "above" this file)."""
   path = os.path.abspath(__file__)
   while True:
@@ skipping 10 matching lines @@
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                 "pylib"))
 
 from mojom.error import Error
 import mojom.fileutil as fileutil
 from mojom.generate.data import OrderedModuleFromData
 from mojom.parse.parser import Parse
 from mojom.parse.translate import Translate
 
 
+_BUILTIN_GENERATORS = {
+  "c++": "mojom_cpp_generator.py",
+  "javascript": "mojom_js_generator.py",
+  "java": "mojom_java_generator.py",
+}
+
 def LoadGenerators(generators_string):
   if not generators_string:
     return []  # No generators.
 
   script_dir = os.path.dirname(os.path.abspath(__file__))
-  generators = []
+  generators = {}
   for generator_name in [s.strip() for s in generators_string.split(",")]:
-    # "Built-in" generators:
-    if generator_name.lower() == "c++":
+    language = generator_name.lower()
+    if language in _BUILTIN_GENERATORS:
       generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_cpp_generator.py")
-    elif generator_name.lower() == "javascript":
-      generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_js_generator.py")
-    elif generator_name.lower() == "java":
-      generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_java_generator.py")
-    # Specified generator python module:
-    elif generator_name.endswith(".py"):
-      pass
+                                    _BUILTIN_GENERATORS[language])
     else:
       print "Unknown generator name %s" % generator_name
       sys.exit(1)
     generator_module = imp.load_source(os.path.basename(generator_name)[:-3],
                                        generator_name)
-    generators.append(generator_module)
+    generators[language] = generator_module
   return generators
 
 
 def MakeImportStackMessage(imported_filename_stack):
   """Make a (human-readable) message listing a chain of imports. (Returned
   string begins with a newline (if nonempty) and does not end with one.)"""
   return ''.join(
       reversed(["\n  %s was imported by %s" % (a, b) for (a, b) in \
                     zip(imported_filename_stack[1:], imported_filename_stack)]))
 
 
 def FindImportFile(dir_name, file_name, search_dirs):
   for search_dir in [dir_name] + search_dirs:
     path = os.path.join(search_dir, file_name)
     if os.path.isfile(path):
       return path
   return os.path.join(dir_name, file_name)
 
 class MojomProcessor(object):
   def __init__(self, should_generate):
     self._should_generate = should_generate
     self._processed_files = {}
     self._parsed_files = {}
+    self._typemap = {}
+
+  def LoadTypemaps(self, typemaps):
+    # Support some very simple single-line comments in typemap JSON.
+    comment_expr = r"^\s*//.*$"
+    def no_comments(line):
+      return not re.match(comment_expr, line)
+    for filename in typemaps:
+      with open(filename) as f:
+        typemaps = json.loads("".join(filter(no_comments, f.readlines())))
+        for language, typemap in typemaps.iteritems():
+          language_map = self._typemap.get(language, {})
+          language_map.update(typemap)
+          self._typemap[language] = language_map
 
   def ProcessFile(self, args, remaining_args, generator_modules, filename):
     self._ParseFileAndImports(filename, args.import_directories, [])
 
     return self._GenerateModule(args, remaining_args, generator_modules,
         filename)
 
   def _GenerateModule(self, args, remaining_args, generator_modules, filename):
     # Return the already-generated module.
     if filename in self._processed_files:
@@ skipping 17 matching lines @@
     module = OrderedModuleFromData(mojom)
 
     # Set the path as relative to the source root.
     module.path = os.path.relpath(os.path.abspath(filename),
                                   os.path.abspath(args.depth))
 
     # Normalize to unix-style path here to keep the generators simpler.
     module.path = module.path.replace('\\', '/')
 
     if self._should_generate(filename):
-      for generator_module in generator_modules:
-        generator = generator_module.Generator(module, args.output_dir)
+      for language, generator_module in generator_modules.iteritems():
+        generator = generator_module.Generator(
+            module, args.output_dir, typemap=self._typemap.get(language, {}),
+            variant=args.variant)
         filtered_args = []
         if hasattr(generator_module, 'GENERATOR_PREFIX'):
           prefix = '--' + generator_module.GENERATOR_PREFIX + '_'
           filtered_args = [arg for arg in remaining_args
                            if arg.startswith(prefix)]
         generator.GenerateFiles(filtered_args)
 
     # Save result.
     self._processed_files[filename] = module
     return module
@@ skipping 47 matching lines @@
                       metavar="GENERATORS",
                       default="c++,javascript,java",
                       help="comma-separated list of generators")
   parser.add_argument("--debug_print_intermediate", action="store_true",
                       help="print the intermediate representation")
   parser.add_argument("-I", dest="import_directories", action="append",
                       metavar="directory", default=[],
                       help="add a directory to be searched for import files")
   parser.add_argument("--use_bundled_pylibs", action="store_true",
                       help="use Python modules bundled in the SDK")
+  parser.add_argument("--typemap", action="append", metavar="TYPEMAP",
+                      default=[], dest="typemaps",
+                      help="apply TYPEMAP to generated output")
+  parser.add_argument("--variant", dest="variant", default=None,
+                      help="output a named variant of the bindings")
   (args, remaining_args) = parser.parse_known_args()
 
+  if args.variant == "none":
+    args.variant = None
+
   generator_modules = LoadGenerators(args.generators_string)
 
   fileutil.EnsureDirectoryExists(args.output_dir)
 
   processor = MojomProcessor(lambda filename: filename in args.filename)
+  processor.LoadTypemaps(set(args.typemaps))
   for filename in args.filename:
     processor.ProcessFile(args, remaining_args, generator_modules, filename)
 
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(main())