Support --frog flag in htmlconverter.py

client/tools/htmlconverter.py

 # 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.
 
 #!/usr/bin/env python
 #
 
 """Rewrites HTML files, converting Dart script sections into JavaScript.
 
 Process HTML files, and internally changes script sections that use Dart code
@@ skipping 17 matching lines @@
 LIBRARY_PATTERN = "^#library\(.*\);"
 IMPORT_SOURCE_MATCHER = re.compile(
     r"^ *(#import|#source)(\(['\"])([^'\"]*)(.*\);)", re.MULTILINE)
 DOM_IMPORT_MATCHER = re.compile(
     r"^#import\(['\"]dart\:dom['\"].*\);", re.MULTILINE)
 HTML_NO_PREFIX_IMPORT_MATCHER = re.compile(
     r"^#import.*(dart:html|html.dart)['\"]\);", re.MULTILINE)
 JSON_IMPORT_MATCHER = re.compile(
     r"^#import\(['\"]dart:json['\"].*\);", re.MULTILINE)
 
-COMPILER_NOT_FOUND_ERROR = (
+DARTC_NOT_FOUND_ERROR = (
 """Couldn't find compiler: please run the following commands:
    $ cd %s
    $ ./tools/build.py --arch=ia32""")
 
+FROG_NOT_FOUND_ERROR = (
+"""Couldn't find compiler: please run the following commands:
+   $ cd %s/frog
+   $ ./tools/build.py -m release""")
+
 ENTRY_POINT = """
 #library('entry');
 #import('dart:dom');
 #import('%s', prefix: 'original');
 main() {
   window.addEventListener('DOMContentLoaded', (e) => original.main(), false);
 }
 """
 
 CSS_TEMPLATE = '<style type="text/css">%s</style>'
@@ skipping 20 matching lines @@
   def repl(matchobj):
     path = matchobj.group(3)
     if not path.startswith('dart:'):
       path = abspath(path)
     return (matchobj.group(1) + matchobj.group(2) + path + matchobj.group(4))
   return IMPORT_SOURCE_MATCHER.sub(repl, contents)
 
 class DartCompiler(object):
   """ Common code for compiling Dart script tags in an HTML file. """
 
-  def __init__(self, optimize=False, verbose=False, extra_flags=""):
+  def __init__(self, optimize=False, use_frog=False, verbose=False,
+      extra_flags=""):
     self.optimize = optimize
     self.verbose = verbose
     self.extra_flags = extra_flags
+    self.use_frog = use_frog
 
   def compileCode(self, src=None, body=None):
     """ Compile the given source code.
 
       Either the script tag has a src attribute or a non-empty body (one of the
       arguments will be none, the other is not).
 
       Args:
         src: a string pointing to a Dart script file.
         body: a string containing Dart code.
@@ skipping 60 matching lines @@
     with open(self.outputFileName(wrappedfile, outdir), 'r') as f:
       res = f.read()
 
     # Cleanup
     if indir is not None:
       shutil.rmtree(indir)
     shutil.rmtree(outdir)
     return CHROMIUM_SCRIPT_TEMPLATE % res
 
   def compileCommand(self, inputfile, outdir):
-    binary = abspath(join(DART_PATH,
-        # TODO(sigmund): support also mode = release
-        utils.GetBuildRoot(utils.GuessOS(), 'debug', 'ia32'),
-        'dartc'))
-    if not exists(binary):
-      raise ConverterException(COMPILER_NOT_FOUND_ERROR % DART_PATH)
-    cmd = [binary,
-           '-noincremental',
-           '--work', outdir,
-           '--out', self.outputFileName(inputfile, outdir)]
-    if self.optimize:
-      cmd.append('--optimize')
-    cmd.append(self.extra_flags);
+    if not self.use_frog:
+      binary = abspath(join(DART_PATH,
+          # TODO(sigmund): support also mode = release
+          utils.GetBuildRoot(utils.GuessOS(), 'debug', 'ia32'),
+          'dartc'))
+      if not exists(binary):
+        raise ConverterException(DARTC_NOT_FOUND_ERROR % DART_PATH)
+      cmd = [binary,
+             '-noincremental',
+             '--work', outdir,
+             '--out', self.outputFileName(inputfile, outdir)]
+      if self.optimize:
+        cmd.append('--optimize')
+    else:
+      binary = abspath(join(DART_PATH, 'frog',
+          utils.GetBuildRoot(utils.GuessOS(), 'release', 'ia32'),
+          'frog', 'bin', 'frogsh'))
+      if not exists(binary):
+        raise ConverterException(FROG_NOT_FOUND_ERROR % DART_PATH)
+      cmd = [binary, '--compile-only',
+             '--out=' + self.outputFileName(inputfile, outdir)]
+    if self.extra_flags != "":
+      cmd.append(self.extra_flags);
     cmd.append(inputfile)
     return cmd
 
   def outputFileName(self, inputfile, outdir):
     return join(outdir, basename(inputfile) + '.js')
 
 def execute(cmd, verbose=False):
   """Execute a command in a subprocess. """
   if verbose: print 'Executing: ' + ' '.join(cmd)
   try:
@@ skipping 271 matching lines @@
   """ An exception encountered during the convertion process """
   pass
 
 def Flags():
   """ Constructs a parser for extracting flags from the command line. """
   result = optparse.OptionParser()
   result.add_option("--optimize",
       help="Use optimizer in dartc",
       default=False,
       action="store_true")
+  result.add_option("--frog",
+      help="Use the frog compiler",
+      default=False,
+      action="store_true")
   result.add_option("--verbose",
       help="Print verbose output",
       default=False,
       action="store_true")
   result.add_option("-o", "--out",
       help="Output directory",
       type="string",
       default=None,
       action="store")
   result.add_option("-t", "--target",
@@ skipping 20 matching lines @@
     contents = f.read()
   prefix_path = dirname(filename)
 
   # outdirBase is the directory to place all subdirectories for other dart files
   # and resources.
   converter = DartToDartHTMLConverter(prefix_path, outdirBase, verbose)
   converter.feed(contents)
   converter.close()
   writeOut(converter.getResult(), outfile)
 
-def convertForChromium(filename, optimize, extra_flags, outfile, verbose):
+def convertForChromium(
+    filename, optimize, use_frog, extra_flags, outfile, verbose):
   """ Converts a file for a chromium target. """
   with open(filename, 'r') as f:
     contents = f.read()
   prefix_path = dirname(filename)
-  converter = DartHTMLConverter(DartCompiler(optimize, verbose, extra_flags),
-                                prefix_path)
+  converter = DartHTMLConverter(
+      DartCompiler(optimize, use_frog, verbose, extra_flags), prefix_path)
   converter.feed(contents)
   converter.close()
   writeOut(converter.getResult(), outfile)
 
 def convertForOffline(filename, outfile, verbose, encode_images):
   """ Converts a file for offline use. """
   with codecs.open(filename, 'r', 'utf-8') as f:
     contents = f.read()
   converter = OfflineHTMLConverter(dirname(filename),
                                    dirname(outfile),
@@ skipping 19 matching lines @@
     return 1
 
   try:
     filename = args[0]
     extension = filename[filename.rfind('.'):]
     if extension != '.html' and extension != '.htm':
       print "Invalid input file extension: %s" % extension
       return 1
     outfile = join(options.out, filename)
     if 'chromium' in options.target or 'js' in options.target:
-      convertForChromium(filename, options.optimize, options.extra_flags,
+      convertForChromium(filename, options.optimize,
+          options.frog, options.extra_flags,
           outfile.replace(extension, '-js' + extension), options.verbose)
     if 'dartium' in options.target:
       convertForDartium(filename, options.out,
           outfile.replace(extension, '-dart' + extension), options.verbose)
   except Exception as e:
     print "%sERROR%s: %s" % (RED_COLOR, NO_COLOR, str(e))
     return 1
   return 0
 
 if __name__ == '__main__':
   sys.exit(main())