Roll IDL to multivm@1316

core/scripts/name_macros.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 49 matching lines @@
 
 #endif // %(class_name)sInterfaces_h
 """
 
 
 def _to_macro_style(name):
     s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
     return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).upper()
 
 
-def _name_for_entry(entry):
-    if entry['interfaceName']:
-        return entry['interfaceName']
-    return os.path.basename(entry['name'])
-
 class Writer(in_generator.Writer):
     def __init__(self, in_file_path, enabled_conditions):
         super(Writer, self).__init__(in_file_path, enabled_conditions)
         self.class_name = self.in_file.parameters['namespace'].strip('"')
         self._entries_by_conditional = {}
         self._unconditional_entries = []
         self._sort_entries_by_conditional()
         self._outputs = {(self.class_name + "Headers.h"): self.generate_headers_header,
                          (self.class_name + "Interfaces.h"): self.generate_interfaces_header,
                         }
 
     def _sort_entries_by_conditional(self):
         unconditional_names = set()
         for entry in self.in_file.name_dictionaries:
             conditional = entry['conditional']
             if not conditional:
-                name = _name_for_entry(entry)
+                name = self._class_name_for_entry(entry)
                 if name in unconditional_names:
                     continue
                 unconditional_names.add(name)
                 self._unconditional_entries.append(entry)
                 continue
         for entry in self.in_file.name_dictionaries:
-            name = _name_for_entry(entry)
+            name = self._class_name_for_entry(entry)
             if name in unconditional_names:
                 continue
             conditional = entry['conditional']
             if not conditional in self._entries_by_conditional:
                 self._entries_by_conditional[conditional] = []
             self._entries_by_conditional[conditional].append(entry)
 
-    def _headers_header_include(self, entry):
-        path = entry['name']
-        name = _name_for_entry(entry)
-        if entry['interfaceName']:
-            path = entry['interfaceName']  # FIXME: This seems wrong
-        include = '#include "%(path)s.h"\n#include "V8%(name)s.h"' % {
-            'path': path,
-            'name': name,
-        }
-        return self.wrap_with_condition(include, entry['conditional'])
+    def _class_name_for_entry(self, entry):
+        if entry['implementedAs']:
+            return entry['implementedAs']
+        return os.path.basename(entry['name'])
+
+    def _headers_header_include_path(self, entry):
+        if entry['implementedAs']:
+            path = os.path.dirname(entry['name'])
+            if len(path):
+                path += '/'
+            path += entry['implementedAs']
+        else:
+            path = entry['name']
+        return path + '.h'
+
+    def _headers_header_includes(self, entries):
+        includes = dict()
+        for entry in entries:
+            class_name = self._class_name_for_entry(entry)
+            # Avoid duplicate includes.
+            if class_name in includes:
+                continue
+            include = '#include "%(path)s"\n#include "V8%(js_name)s.h"' % {
+                'path': self._headers_header_include_path(entry),
+                'js_name': os.path.basename(entry['name']),
+            }
+            includes[class_name] = self.wrap_with_condition(include, entry['conditional'])
+        return includes.values()
 
     def generate_headers_header(self):
         return HEADER_TEMPLATE % {
             'license': license.license_for_generated_cpp(),
             'class_name': self.class_name,
-            'includes': '\n'.join(map(self._headers_header_include, self.in_file.name_dictionaries)),
+            'includes': '\n'.join(self._headers_header_includes(self.in_file.name_dictionaries)),
         }
 
     def _declare_one_conditional_macro(self, conditional, entries):
         macro_name = '%(macro_style_name)s_INTERFACES_FOR_EACH_%(conditional)s' % {
             'macro_style_name': _to_macro_style(self.class_name),
             'conditional': conditional,
         }
         return self.wrap_with_condition("""#define %(macro_name)s(macro) \\
 %(declarations)s
 
 #else
 #define %(macro_name)s(macro)""" % {
             'macro_name': macro_name,
             'declarations': '\n'.join(sorted(set([
-                '    macro(%(name)s) \\' % {'name': _name_for_entry(entry)}
+                '    macro(%(name)s) \\' % {'name': self._class_name_for_entry(entry)}
                 for entry in entries]))),
         }, conditional)
 
     def _declare_conditional_macros(self):
         return '\n'.join([
             self._declare_one_conditional_macro(conditional, entries)
             for conditional, entries in self._entries_by_conditional.items()])
 
     def _unconditional_macro(self, entry):
-        return '    macro(%(name)s) \\' % {'name': _name_for_entry(entry)}
+        return '    macro(%(name)s) \\' % {'name': self._class_name_for_entry(entry)}
 
     def _conditional_macros(self, conditional):
         return '    %(macro_style_name)s_INTERFACES_FOR_EACH_%(conditional)s(macro) \\' % {
             'macro_style_name': _to_macro_style(self.class_name),
             'conditional': conditional,
         }
 
     def generate_interfaces_header(self):
         return INTERFACES_HEADER_TEMPLATE % {
             'license': license.license_for_generated_cpp(),
             'class_name': self.class_name,
             'macro_style_name': _to_macro_style(self.class_name),
             'declare_conditional_macros': self._declare_conditional_macros(),
             'unconditional_macros': '\n'.join(sorted(set(map(self._unconditional_macro, self._unconditional_entries)))),
             'conditional_macros': '\n'.join(map(self._conditional_macros, self._entries_by_conditional.keys())),
         }