Precompile mojom bindings generator jinja templates.

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
@@ skipping 20 matching lines @@
 # ignores, e.g., "--", but it's close enough.)
 if "--use_bundled_pylibs" in sys.argv[1:]:
   sys.path.insert(0, os.path.join(_GetDirAbove("mojo"), "third_party"))
 
 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.generate import template_expander
 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",
 }
 
@@ skipping 84 matching lines @@
     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 language, generator_module in generator_modules.iteritems():
         generator = generator_module.Generator(
             module, args.output_dir, typemap=self._typemap.get(language, {}),
-            variant=args.variant)
+            variant=args.variant, bytecode_path=args.bytecode_path)
         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 27 matching lines @@
     dirname = os.path.split(filename)[0]
     for imp_entry in tree.import_list:
       import_filename = FindImportFile(dirname,
           imp_entry.import_filename, import_directories)
       self._ParseFileAndImports(import_filename, import_directories,
           imported_filename_stack + [filename])
 
     self._parsed_files[filename] = tree
 
 
-def main():
-  parser = argparse.ArgumentParser(
-      description="Generate bindings from mojom files.")
-  parser.add_argument("filename", nargs="+",
-                      help="mojom input file")
-  parser.add_argument("-d", "--depth", dest="depth", default=".",
-                      help="depth from source root")
-  parser.add_argument("-o", "--output_dir", dest="output_dir", default=".",
-                      help="output directory for generated files")
-  parser.add_argument("-g", "--generators", dest="generators_string",
-                      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()
-
+def _Generate(args, remaining_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
 
 
+def _Precompile(args, _):
+  generator_modules = LoadGenerators(",".join(_BUILTIN_GENERATORS.keys()))
+
+  template_expander.PrecompileTemplates(generator_modules, args.output_dir)
+  return 0
+
+
+
+def main():
+  parser = argparse.ArgumentParser(
+      description="Generate bindings from mojom files.")
+  parser.add_argument("--use_bundled_pylibs", action="store_true",
+                      help="use Python modules bundled in the SDK")
+
+  subparsers = parser.add_subparsers()
+  generate_parser = subparsers.add_parser(
+      "generate", description="Generate bindings from mojom files.")
+  generate_parser.add_argument("filename", nargs="+",
+                               help="mojom input file")
+  generate_parser.add_argument("-d", "--depth", dest="depth", default=".",
+                               help="depth from source root")
+  generate_parser.add_argument("-o", "--output_dir", dest="output_dir",
+                               default=".",
+                               help="output directory for generated files")
+  generate_parser.add_argument("--debug_print_intermediate",
+                               action="store_true",
+                               help="print the intermediate representation")
+  generate_parser.add_argument("-g", "--generators", dest="generators_string",
+                      metavar="GENERATORS",

[yzshen1, 2016/01/14 01:32:47]

nit: the indent is a little unusual.

[Sam McNally, 2016/01/14 02:58:18]

Done.

+                      default="c++,javascript,java",
+                      help="comma-separated list of generators")
+  generate_parser.add_argument(
+      "-I", dest="import_directories", action="append", metavar="directory",
+      default=[], help="add a directory to be searched for import files")
+  generate_parser.add_argument("--typemap", action="append", metavar="TYPEMAP",
+                               default=[], dest="typemaps",
+                               help="apply TYPEMAP to generated output")
+  generate_parser.add_argument("--variant", dest="variant", default=None,
+                               help="output a named variant of the bindings")
+  generate_parser.add_argument("--bytecode_path", default=None, type=str,
+                               required=True)

[yzshen1, 2016/01/14 01:32:47]

please add "help".

[Sam McNally, 2016/01/14 02:58:19]

Done.

+  generate_parser.set_defaults(func=_Generate)
+
+  precompile_parser = subparsers.add_parser("precompile",
+      description="Precompile templates for the mojom bindings generator.")
+  precompile_parser.add_argument(
+      "-o", "--output_dir", dest="output_dir", default=".",
+      help="output directory for precompiled templates")
+  precompile_parser.set_defaults(func=_Precompile)
+
+  args, remaining_args = parser.parse_known_args()
+  return args.func(args, remaining_args)
+
+
 if __name__ == "__main__":
   sys.exit(main())