Move systems creation to dartdomgenerator.py.

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 systembase import *

[Anton Muhin, 2012/05/17 15:46:24]

do we care about more specific imports?

[podivilov, 2012/05/17 17:44:01]

Done.

+from systemfrog import *
+from systemhtml import *
+from systeminterface import *
+from systemnative import *
+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',
@@ skipping 37 matching lines @@
     html_renames['WebKit' + subclass] = subclass
 
   # TODO(jacobr): we almost want to add this commented out line back.
   #    html_renames['HTMLCollection'] = 'ElementList'
   #    html_renames['NodeList'] = 'ElementList'
   #    html_renames['HTMLOptionsCollection'] = 'ElementList'
   html_renames['DOMWindow'] = 'Window'
 
   return html_renames
 
-def GenerateDOM(systems, generate_html_systems, output_dir,
-                database_dir, use_database_cache):
+def Generate(system_name, database_dir, use_database_cache, output_dir=None):
   current_dir = os.path.dirname(__file__)
+  auxiliary_dir=os.path.join(current_dir, '..', 'src')

[Anton Muhin, 2012/05/17 15:46:24]

nit: spaces around = here and below

[podivilov, 2012/05/17 17:44:01]

Done.

+  template_dir=os.path.join(current_dir, '..', 'templates')
 
-  generator = dartgenerator.DartGenerator(
-      auxiliary_dir=os.path.join(current_dir, '..', 'src'),
-      template_dir=os.path.join(current_dir, '..', 'templates'),
-      base_package='')
-  generator.LoadAuxiliary()
+  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)
 
+  emitters = multiemitter.MultiEmitter()
   html_renames = _MakeHtmlRenames(common_database)
-  if generate_html_systems:
+
+  if system_name in ['htmlfrog', 'htmldartium']:
     generator.RenameTypes(webkit_database, html_renames, False)
+    if not output_dir:
+      output_dir = os.path.join(current_dir, '../../html/generated')
+    interface_system = HtmlInterfacesSystem(
+        TemplateLoader(template_dir, ['html/interface', 'html', '']),
+        webkit_database, emitters, output_dir)
+  else:
+    if not output_dir:
+      output_dir = os.path.join(current_dir, '../generated')
+    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)
+  elif system_name == 'htmlfrog':
+    implementation_system = HtmlFrogSystem(
+        TemplateLoader(template_dir,
+                       ['html/frog', 'html/impl', 'html', ''],
+                       {'DARTIUM': False, 'FROG': True}),
+        webkit_database, emitters, output_dir)
+  elif system_name == 'htmldartium':
+    implementation_system = HtmlDartiumSystem(
+        TemplateLoader(template_dir,
+                       ['html/dartium', 'html/impl', 'html', ''],
+                       {'DARTIUM': True, 'FROG': False}),
+        webkit_database, emitters, auxiliary_dir,
+        output_dir)      
+  elif system_name == 'native':
+    implementation_system = NativeImplementationSystem(
+        TemplateLoader(template_dir, ['dom/native', 'dom', '']),
+        webkit_database, html_renames, emitters, auxiliary_dir,
+        output_dir)
+  else:
+    raise Exception('Unsupported system %s' % system_name)
 
-  generator.Generate(database = webkit_database,
-                     output_dir = output_dir,
-                     lib_dir = output_dir,
-                     module_source_preference = ['WebKit', 'Dart'],
-                     source_filter = ['WebKit', 'Dart'],
-                     super_database = common_database,
-                     common_prefix = 'common',
-                     webkit_renames = _webkit_renames,
-                     html_renames = html_renames,
-                     systems = systems)
+  # Makes interface files available for listing in the library for the
+  # implementation system.
+  implementation_system._interface_system = interface_system
 
-  generator.Flush()
+  for system in [interface_system, implementation_system]:
+    generator.Generate(webkit_database, system,
+                       source_filter=['WebKit', 'Dart'],
+                       super_database=common_database,
+                       common_prefix='common',
+                       webkit_renames=_webkit_renames,
+                       html_renames=html_renames)
+
+  _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);
 
   if 'htmlfrog' in systems:
     _logger.info('Copy html_frog to ../html/frog/')
@@ skipping 27 matching lines @@
                     default=None,
                     help='Directory to put the generated files')
   parser.add_option('--use-database-cache', dest='use_database_cache',
                     action='store_true',
                     default=False,
                     help='''Use the cached database from the previous run to
                     improve startup performance''')
   (options, args) = parser.parse_args()
 
   current_dir = os.path.dirname(__file__)
+  database_dir = os.path.join(current_dir, '..', 'database')
+  logging.config.fileConfig(os.path.join(current_dir, 'logging.conf'))
   systems = options.systems.split(',')
-  html_system_names = ['htmldartium', 'htmlfrog']
-  html_systems = [s for s in systems if s in html_system_names]
-  dom_systems = [s for s in systems if s not in html_system_names]
 
-  database_dir = os.path.join(current_dir, '..', 'database')
-  use_database_cache = options.use_database_cache
-  logging.config.fileConfig(os.path.join(current_dir, 'logging.conf'))
-
-  if dom_systems:
-    output_dir = options.output_dir or os.path.join(current_dir,
-        '../generated')
-    GenerateDOM(dom_systems, False, output_dir,
-                database_dir, use_database_cache)
-    GenerateSingleFile(dom_systems)
-
-  if html_systems:
-    output_dir = options.output_dir or os.path.join(current_dir,
-        '../../html/generated')
-    GenerateDOM(html_systems, True, output_dir,
-                database_dir, use_database_cache or dom_systems)
-    GenerateSingleFile(html_systems)
+  for system in systems:
+    Generate(system, database_dir, options.use_database_cache,
+             options.output_dir)
+  GenerateSingleFile(systems)
 
 if __name__ == '__main__':
   sys.exit(main())