Move //mojo/{public, edk} underneath //third_party

mojo/public/tools/bindings/mojom_bindings_generator.py

Index: mojo/public/tools/bindings/mojom_bindings_generator.py
diff --git a/mojo/public/tools/bindings/mojom_bindings_generator.py b/mojo/public/tools/bindings/mojom_bindings_generator.py
deleted file mode 100755
index 2d1802c05ac6ec723c86f8f6a312a03b97efcd98..0000000000000000000000000000000000000000
--- a/mojo/public/tools/bindings/mojom_bindings_generator.py
+++ /dev/null
@@ -1,218 +0,0 @@
-#!/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 os
-import pprint
-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:
-    path, tail = os.path.split(path)
-    assert tail
-    if tail == dirname:
-      return path
-
-# Manually check for the command-line flag. (This isn't quite right, since it
-# ignores, e.g., "--", but it's close enough.)
-if "--use_bundled_pylibs" in sys.argv[1:]:
-  sys.path.insert(0, os.path.join(_GetDirAbove("public"), "public/third_party"))
-
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
-                                "pylib"))
-
-from mojom.error import Error
-from mojom.generate.data import OrderedModuleFromData
-from mojom.parse.parser import Parse
-from mojom.parse.translate import Translate
-
-
-def LoadGenerators(generators_string):
-  if not generators_string:
-    return []  # No generators.
-
-  script_dir = os.path.dirname(os.path.abspath(__file__))
-  generators = []
-  for generator_name in [s.strip() for s in generators_string.split(",")]:
-    # "Built-in" generators:
-    if generator_name.lower() == "c++":
-      generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_cpp_generator.py")
-    if generator_name.lower() == "dart":
-      generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_dart_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")
-    elif generator_name.lower() == "python":
-      generator_name = os.path.join(script_dir, "generators",
-                                    "mojom_python_generator.py")
-    # Specified generator python module:
-    elif generator_name.endswith(".py"):
-      pass
-    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)
-  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 = {}
-
-  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:
-      return self._processed_files[filename]
-    tree = self._parsed_files[filename]
-
-    dirname, name = os.path.split(filename)
-    mojom = Translate(tree, name)
-    if args.debug_print_intermediate:
-      pprint.PrettyPrinter().pprint(mojom)
-
-    # Process all our imports first and collect the module object for each.
-    # We use these to generate proper type info.
-    for import_data in mojom['imports']:
-      import_filename = FindImportFile(dirname,
-                                       import_data['filename'],
-                                       args.import_directories)
-      import_data['module'] = self._GenerateModule(
-          args, remaining_args, generator_modules, import_filename)
-
-    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)
-        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
-
-  def _ParseFileAndImports(self, filename, import_directories,
-      imported_filename_stack):
-    # Ignore already-parsed files.
-    if filename in self._parsed_files:
-      return
-
-    if filename in imported_filename_stack:
-      print "%s: Error: Circular dependency" % filename + \
-          MakeImportStackMessage(imported_filename_stack + [filename])
-      sys.exit(1)
-
-    try:
-      with open(filename) as f:
-        source = f.read()
-    except IOError as e:
-      print "%s: Error: %s" % (e.filename, e.strerror) + \
-          MakeImportStackMessage(imported_filename_stack + [filename])
-      sys.exit(1)
-
-    try:
-      tree = Parse(source, filename)
-    except Error as e:
-      full_stack = imported_filename_stack + [filename]
-      print str(e) + MakeImportStackMessage(full_stack)
-      sys.exit(1)
-
-    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++,dart,javascript,java,python",
-                      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")
-  (args, remaining_args) = parser.parse_known_args()
-
-  generator_modules = LoadGenerators(args.generators_string)
-
-  if not os.path.exists(args.output_dir):
-    os.makedirs(args.output_dir)
-
-  processor = MojomProcessor(lambda filename: filename in args.filename)
-  for filename in args.filename:
-    processor.ProcessFile(args, remaining_args, generator_modules, filename)
-
-  return 0
-
-
-if __name__ == "__main__":
-  sys.exit(main())