remove node.js dependency by running the frog compiler in

tools/testing/frogpad/frogpad.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 # Copyright (c) 2012, 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.
 #
 
 """
 Frogpad is used to compile .dart files to javascript.
 
 This is accomplished by first creating an html file (usually called
@@ skipping 88 matching lines @@
   </script>
 </body>
 </html>
 """
 
 # This finds everything after the word "Output:" in the html page.
 # (Note, because the javascript we're fishing out spans multiple lines
 # we need to use the DOTALL switch here.)
 OUTPUT_JAVASCRIPT_REGEX = re.compile(".*\nOutput:(.*)#EOF", re.DOTALL)
 
+# If the frogpad.dart encounters a compilation error, the generated
+# javascript will start with the word 'throw'.
+COMPILATION_ERROR_REGEX = re.compile(r"\s*throw\s")
+
 # We use "application/inert" here to make the browser ignore the
 # these script tags.  (frogpad.dart will fish out the contents as needed.)
 #
 SCRIPT_TAG = """<script type="application/inert" id="{{id}}">
 {{contents}}
 </script>
 """
 
 # Regex that finds #import, #source and #native directives in .dart files.
 #   match.group(1) = "import", "source" or "native"
 #   match.group(2) = url of file being imported
 DIRECTIVE_RE = re.compile(r"^#(import|source|native)\([\"']([^\"']*)[\"']")
 
 # id of script tag that holds name of the top dart file to be compiled,
 # (This file name passed will be passed to the frog compiler by frogpad.dart.)
 MAIN_ID = "main_id"
 
 DART_LIBRARIES = {
     "core": "lib/corelib.dart",
     "coreimpl": "lib/corelib_impl.dart",
     "dom": "../client/dom/frog/dom_frog.dart",
     "html": "../client/html/release/html.dart",
     "htmlimpl": "../client/html/release/htmlimpl.dart",
+    "isolate": "../lib/isolate/isolate_frog.dart",
     "json": "../lib/json/json_frog.dart"
 }
 
 
 class Pad(object):
   """
   Accumulates all source files that are needed to compile a dart program,
   and places them in <script> tags on an html page.
   """
 
   def __init__(self, argv):
     parser = optparse.OptionParser(usage=
       "%prog [options] file_to_compile.dart"
     )
-    parser.add_option("-r", "--rebuild",  action="store_true",
-        help="forces rebuild of the frogpad javascript")
+    parser.add_option("-f", "--frogpad_js",
+        help="location of frogpad.js file")
     parser.add_option("-o", "--out",
         help="name of javascript output file")
     parser.add_option("-v", "--verbose", action="store_true",
         help="more verbose logging")
     (options, args) = parser.parse_args(argv)
 
     log_level = logging.INFO
     if options.verbose:
       log_level = logging.DEBUG
     logging.basicConfig(level=log_level)
@@ skipping 11 matching lines @@
     self.dart_dir = os.path.dirname(os.path.dirname(os.path.dirname(
         self.frogpad_dir)))
 
     # directory of frog compiler source code
     self.frog_dir = os.path.join(self.dart_dir, "frog")
 
     logging.debug("dartdir_dir: '%s'" % self.dart_dir)
     logging.debug("frog_dir: '%s'" % self.frog_dir)
     logging.debug("frogpad_dir: '%s'" % self.frogpad_dir)
 
-    # name of frogpad_js file
-    self.frogpad_js = os.path.join(self.frogpad_dir, FROGPAD_JS)
+    # location frogpad.js file
+    if not options.frogpad_js:
+      raise Exception("--frogpad_js is required")
+
+    if not os.path.exists(options.frogpad_js):
+      raise FileNotFoundException(options.frogpad_js)
+
+    self.frogpad_js = options.frogpad_js
 
     if options.out:
       # user has specified an output file
       self.js_file = os.path.abspath(options.out)
     else:
       # user didn't specify an output file, so base the name on the
       # input file
       self.js_file = self.main_file + ".frogpad.js"
 
     logging.debug("js_file: '%s" % self.js_file)
 
     # this is the html file that we pass to DumpRenderTree
     self.html_file = self.js_file + ".frogpad.html"
     logging.debug("html_file: '%s'" % self.html_file)
 
     # map from file name to File object (contains entries for all corelib
     # and all other dart files needed to compile main_file)
     self.name_to_file = {}
 
     # map from script tag id to File object
     self.id_to_file = {}
 
-    if not os.path.exists(self.frogpad_js):
-      options.rebuild = True
-
-    if options.rebuild:
-      self.build_frogpad_js()
-
     self.load_libraries()
     self.load_file(self.main_file)
 
     html = self.generate_html()
     write_file(self.html_file, html)
 
     js = self.generate_js()
     write_file(self.js_file, js)
 
     line_count = len(js.splitlines())
-    logging.info("generated '%s' (%d lines)", self.js_file, line_count)
+    logging.debug("generated '%s' (%d lines)", self.js_file, line_count)
 
-  def build_frogpad_js(self):
-    dart_vm = os.path.join(self.dart_dir, "out/Release_ia32/dart")
-    check_exists(dart_vm)
-
-    frogc_dart = os.path.join(self.frog_dir, "frogc.dart")
-    frogpad_dart = os.path.join(self.frogpad_dir, "frogpad.dart")
-    check_exists(frogc_dart)
-    check_exists(frogpad_dart)
-
-    args = []
-    args.append(dart_vm)
-
-    # command line arguments for the dart vm
-
-    # We leave out --enable_type_checks here for speed.
-    #    args.append("--enable_type_checks")
-
-    args.append("--enable_asserts")
-
-    # The dart program we're going to run on the dart vm.
-    args.append(frogc_dart)
-
-    # Command line arguments for frogc.dart
-    args.append("--libdir=%s/lib" % self.frog_dir)
-    args.append("--compile-only")
-    args.append("--enable_type_checks")
-    args.append("--enable_asserts")
-    args.append("--out=%s" % self.frogpad_js)
-
-    # The dart program that we want frogc.dart to compile.
-    args.append(frogpad_dart)
-    logging.info("generating '%s'" % self.frogpad_js)
-
-    run_command(args)
-    check_exists(self.frogpad_js)
+    match = COMPILATION_ERROR_REGEX.match(js)
+    if match:
+      sys.exit(1)
 
   def generate_html(self):
     tags = []
     for f in self.id_to_file.values():
       tags.append(self._create_tag(f.id, f.contents))
     tags.append(self._create_tag(MAIN_ID, self.main_file))
     html = HTML.replace("{{script_tags}}", "".join(tags))
     html = html.replace("{{FROGPAD_JS}}", read_file(self.frogpad_js))
     return html
 
@@ skipping 125 matching lines @@
     raise CommandFailedException(msg)
   logging.debug("SUCCEEDED (%d bytes)" % len(stdout))
   return stdout
 
 
 def main(argv):
   Pad(argv)
 
 if __name__ == "__main__":
   sys.exit(main(sys.argv))