Make HtmlFrogSystem and NativeImplementationSystem the backends for HtmlInterfacesSystem and remove…

lib/dom/scripts/dartdomgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This is the entry point to create Dart APIs from the IDL database."""
 
 import dartgenerator
 import database
 import logging.config
 import multiemitter
 import optparse
 import os
 import shutil
 import subprocess
 import sys
 from systemfrog import FrogSystem
-from systemhtml import HtmlInterfacesSystem, HtmlFrogSystem, HtmlDartiumSystem
+from systemhtml import HtmlInterfacesSystem, HtmlFrogSystem
 from systeminterface import InterfacesSystem
 from systemnative import NativeImplementationSystem
 from templateloader import TemplateLoader
 
 _logger = logging.getLogger('dartdomgenerator')
 
 _webkit_renames = {
     # W3C -> WebKit name conversion
     # TODO(vsm): Maybe Store these renames in the IDLs.
     'ApplicationCache': 'DOMApplicationCache',
     'BarProp': 'BarInfo',
     'DedicatedWorkerGlobalScope': 'DedicatedWorkerContext',
     'FormData': 'DOMFormData',
     'Selection': 'DOMSelection',
     'SharedWorkerGlobalScope': 'SharedWorkerContext',
     'Window': 'DOMWindow',
     'WorkerGlobalScope': 'WorkerContext'}
 
-def Generate(systems, database_dir, use_database_cache, dom_output_dir,
+def Generate(system_names, database_dir, use_database_cache, dom_output_dir,
              html_output_dir):
   current_dir = os.path.dirname(__file__)
   auxiliary_dir = os.path.join(current_dir, '..', 'src')
   template_dir = os.path.join(current_dir, '..', 'templates')
 
   generator = dartgenerator.DartGenerator()
   generator.LoadAuxiliary(auxiliary_dir)
 
   common_database = database.Database(database_dir)
   if use_database_cache:
     common_database.LoadFromCache()
   else:
     common_database.Load()
 
   generator.FilterMembersWithUnidentifiedTypes(common_database)
   webkit_database = common_database.Clone()
 
   # Generate Dart interfaces for the WebKit DOM.
   generator.FilterInterfaces(database = webkit_database,
                              or_annotations = ['WebKit', 'Dart'],
                              exclude_displaced = ['WebKit'],
                              exclude_suppressed = ['WebKit', 'Dart'])
   generator.RenameTypes(webkit_database, _webkit_renames, True)
   generator.FixEventTargets(webkit_database)
 
+  def Generate(system):
+    generator.Generate(webkit_database, system,
+                       super_database=common_database,
+                       webkit_renames=_webkit_renames)
+
   emitters = multiemitter.MultiEmitter()
 
-  for system in systems:
-    if system in ['htmlfrog', 'htmldartium']:
-
+  systems = []

[Anton Muhin, 2012/06/27 19:06:28]

is it used?

[podivilov, 2012/06/29 10:01:52]

Done.

+  for system_name in system_names:
+    if system_name in ['htmlfrog', 'htmldartium']:
       output_dir = html_output_dir
-      interface_system = HtmlInterfacesSystem(
+      if system_name == 'htmlfrog':
+        backend = HtmlFrogSystem(
+            TemplateLoader(template_dir,
+                           ['html/frog', 'html/impl', 'html', ''],
+                           {'DARTIUM': False, 'FROG': True}),
+            webkit_database, emitters, output_dir)
+      else:
+        backend = NativeImplementationSystem(
+            TemplateLoader(template_dir, ['dom/native', 'html/dartium',
+                                          'html/impl', ''],
+                           {'DARTIUM': True, 'FROG': False}),
+            webkit_database, emitters, output_dir, auxiliary_dir)
+      html_system = HtmlInterfacesSystem(
           TemplateLoader(template_dir, ['html/interface', 'html', '']),
-          webkit_database, emitters, output_dir)
+          webkit_database, emitters, output_dir, backend)
+      Generate(html_system)
     else:
       output_dir = dom_output_dir
       interface_system = InterfacesSystem(
           TemplateLoader(template_dir, ['dom/interface', 'dom', '']),
           webkit_database, emitters, output_dir)
+      if system_name == 'dummy':
+        implementation_system = dartgenerator.DummyImplementationSystem(
+            TemplateLoader(template_dir, ['dom/dummy', 'dom', '']),
+            webkit_database, emitters, output_dir)
+      elif system_name == 'frog':
+        implementation_system = FrogSystem(
+            TemplateLoader(template_dir, ['dom/frog', 'dom', '']),
+            webkit_database, emitters, output_dir)
+      else:
+        raise Exception('Unsupported system_name %s' % system_name)
 
-    if system == 'dummy':
-      implementation_system = dartgenerator.DummyImplementationSystem(
-          TemplateLoader(template_dir, ['dom/dummy', 'dom', '']),
-          webkit_database, emitters, output_dir)
-    elif system == 'frog':
-      implementation_system = FrogSystem(
-          TemplateLoader(template_dir, ['dom/frog', 'dom', '']),
-          webkit_database, emitters, output_dir)
-    elif system == 'htmlfrog':
-      implementation_system = HtmlFrogSystem(
-          TemplateLoader(template_dir,
-                         ['html/frog', 'html/impl', 'html', ''],
-                         {'DARTIUM': False, 'FROG': True}),
-          webkit_database, emitters, output_dir)
-    elif system == 'htmldartium':
-      # Generate native wrappers.
-      native_system = NativeImplementationSystem(
-          TemplateLoader(template_dir, ['dom/native', 'html/dartium',
-                                        'html/impl', ''],
-                         {'DARTIUM': True, 'FROG': False}),
-          webkit_database, emitters, output_dir)
-      generator.Generate(webkit_database, native_system,
-                         super_database=common_database,
-                         webkit_renames=_webkit_renames)
-      dom_implementation_classes = native_system.DartImplementationFiles()
-      implementation_system = HtmlDartiumSystem(
-          TemplateLoader(template_dir,
-                         ['html/dartium', 'html/impl', 'html', ''],
-                         {'DARTIUM': True, 'FROG': False}),
-          webkit_database, emitters, auxiliary_dir, dom_implementation_classes,
-          output_dir)
-    else:
-      raise Exception('Unsupported system %s' % system)
-
-    # Makes interface files available for listing in the library for the
-    # implementation system.
-    implementation_system._interface_system = interface_system
-
-    for system in [interface_system, implementation_system]:
-      generator.Generate(webkit_database, system,
-                         super_database=common_database,
-                         webkit_renames=_webkit_renames)
+      # Makes interface files available for listing in the library for the
+      # implementation system.
+      implementation_system._interface_system = interface_system
+      Generate(interface_system)
+      Generate(implementation_system)
 
   _logger.info('Flush...')
   emitters.Flush()
 
 def GenerateSingleFile(systems):
   if 'frog' in systems:
     _logger.info('Copy dom_frog to frog/')
     subprocess.call(['cd ../generated ; '
                      '../../../tools/copy_dart.py ../frog dom_frog.dart'],
                     shell=True);
@@ skipping 44 matching lines @@
   dom_output_dir = options.output_dir or os.path.join(current_dir,
       '../generated')
   html_output_dir = options.output_dir or os.path.join(current_dir,
       '../../html/generated')
   Generate(systems, database_dir, options.use_database_cache,
               dom_output_dir, html_output_dir)
   GenerateSingleFile(systems)
 
 if __name__ == '__main__':
   sys.exit(main())