[mojo] Allow bindings generation with explicit relative include paths

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 63 matching lines @@
   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)
+      return path, search_dir
+  return os.path.join(dir_name, file_name), None

[yzshen1, 2016/07/21 23:21:51]

According to our discussion, I wonder why this is necessary (instead of raising
an exception.)

If it is really needed, should we return dir_name instead of None?

[Luis Héctor Chávez, 2016/07/21 23:33:13]

Returning this will trigger L178 to print a nice include-chain to better
diagnose errors. Will change None to |dir_name| to remove L131-132.

 
 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)
+        filename, args.depth)
 
-  def _GenerateModule(self, args, remaining_args, generator_modules, filename):
+  def _GenerateModule(self, args, remaining_args, generator_modules, filename,
+                      source_root):
     # 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_filename, import_dir = FindImportFile(dirname,
+                                                   import_data['filename'],
+                                                   args.import_directories)
+      if import_dir is None:
+        import_dir = args.depth
       import_data['module'] = self._GenerateModule(
-          args, remaining_args, generator_modules, import_filename)
+          args, remaining_args, generator_modules, import_filename, import_dir)
 
     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))
+                                  os.path.abspath(source_root))
 
     # 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, bytecode_path=args.bytecode_path,
             for_blink=args.for_blink,
@@ skipping 30 matching lines @@
 
     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,
+      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 _Generate(args, remaining_args):
   if args.variant == "none":
     args.variant = None
@@ skipping 70 matching lines @@
       "-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())