Convert DOM and HTML frog to dart2js.

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 generator import TypeRegistry
 from htmlrenamer import HtmlRenamer
 from systembase import GeneratorOptions
-from systemfrog import FrogSystem
-from systemhtml import HtmlInterfacesSystem, HtmlFrogSystem
+from systemdart2js import Dart2JSSystem
+from systemhtml import HtmlInterfacesSystem, HtmlDart2JSSystem
 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',
@@ skipping 39 matching lines @@
         output_dir)
 
   def Generate(system):
     generator.Generate(webkit_database, system,
                        super_database=common_database,
                        webkit_renames=_webkit_renames)
 
   emitters = multiemitter.MultiEmitter()
 
   for system_name in system_names:
-    if system_name in ['htmlfrog', 'htmldartium']:
+    if system_name in ['htmldart2js', 'htmldartium']:
       renamer = HtmlRenamer(webkit_database)
       type_registry = TypeRegistry(webkit_database, renamer)
-      if system_name == 'htmlfrog':
+      if system_name == 'htmldart2js':
         options = CreateGeneratorOptions(
-            ['html/frog', 'html/impl', 'html', ''],
-            {'DARTIUM': False, 'FROG': True},
+            ['html/dart2js', 'html/impl', 'html', ''],
+            {'DARTIUM': False, 'DART2JS': True},
             type_registry, html_output_dir, renamer)
-        backend = HtmlFrogSystem(options)
+        backend = HtmlDart2JSSystem(options)
       else:
         options = CreateGeneratorOptions(
             ['dom/native', 'html/dartium', 'html/impl', ''],
-            {'DARTIUM': True, 'FROG': False},
+            {'DARTIUM': True, 'DART2JS': False},
             type_registry, html_output_dir, renamer)
         backend = NativeImplementationSystem(options, auxiliary_dir)
       options = CreateGeneratorOptions(
           ['html/interface', 'html/impl', 'html', ''], {},
           type_registry, html_output_dir, renamer)
       html_system = HtmlInterfacesSystem(options, backend)
       Generate(html_system)
     else:
       type_registry = TypeRegistry(webkit_database)
       options = CreateGeneratorOptions(
           ['dom/interface', 'dom', ''], {}, type_registry, dom_output_dir)
       interface_system = InterfacesSystem(options)
       if system_name == 'dummy':
         options = CreateGeneratorOptions(
             ['dom/dummy', 'dom', ''], {}, type_registry, dom_output_dir)
         implementation_system = dartgenerator.DummyImplementationSystem(
             options)
-      elif system_name == 'frog':
+      elif system_name == 'dart2js':
         options = CreateGeneratorOptions(
-            ['dom/frog', 'dom', ''], {}, type_registry, dom_output_dir)
-        implementation_system = FrogSystem(options)
+            ['dom/dart2js', 'dom', ''], {}, type_registry, dom_output_dir)
+        implementation_system = Dart2JSSystem(options)
       else:
         raise Exception('Unsupported system_name %s' % system_name)
 
       # 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/')
+  if 'dart2js' in systems:
+    _logger.info('Copy dom_dart2js to dart2js/')
     subprocess.call(['cd ../generated ; '
-                     '../../../tools/copy_dart.py ../frog dom_frog.dart'],
+                     '../../../tools/copy_dart.py ../dart2js dom_dart2js.dart'],
                     shell=True)
 
-  if 'htmlfrog' in systems:
-    _logger.info('Copy html_frog to ../html/frog/')
+  if 'htmldart2js' in systems:
+    _logger.info('Copy html_dart2js to ../html/dart2js/')
     subprocess.call(['cd ../../html/generated ; '
-                     '../../../tools/copy_dart.py ../frog html_frog.dart'],
+                     '../../../tools/copy_dart.py ../dart2js html_dart2js.dart'],
                     shell=True)
 
   if 'htmldartium' in systems:
     _logger.info('Copy html_dartium to ../html/dartium/')
     subprocess.call(['cd ../../html/generated ; '
                      '../../../tools/copy_dart.py ../dartium html_dartium.dart'],
                     shell=True)
 
   # Copy dummy DOM where dartc build expects it.
   if 'dummy' in systems:
     _logger.info('Copy dom_dummy to dom.dart')
     subprocess.call(['cd ../generated ; '
                      '../../../tools/copy_dart.py dummy dom_dummy.dart ;'
                      'cp dummy/dom_dummy.dart ../dom.dart'],
                     shell=True)
 
 def main():
   parser = optparse.OptionParser()
   parser.add_option('--systems', dest='systems',
                     action='store', type='string',
-                    default='frog,dummy,htmlfrog,htmldartium',
-                    help='Systems to generate (frog, dummy, '
-                         'htmlfrog, htmldartium)')
+                    default='dart2js,dummy,htmldart2js,htmldartium',
+                    help='Systems to generate (dart2js, dummy, '
+                         'htmldart2js, htmldartium)')
   parser.add_option('--output-dir', dest='output_dir',
                     action='store', type='string',
                     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(',')
 
   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())