Fixes to allow natives in copy_dart.py.

client/tools/copy_dart.py

 #!/usr/bin/env 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.
 """Used to merge and copy dart source files for deployment to AppEngine"""
 
 import fileinput
 import sys
 import shutil
 import os
 import re
 from os.path import abspath, basename, dirname, exists, isabs, join
 from glob import glob
 
-re_library = re.compile(r'^#library\([\'"](.*)[\'"]\);$')
-re_import = re.compile(r'^#import\([\'"](.*)[\'"]\);$')
-re_source = re.compile(r'^#source\([\'"](.*)[\'"]\);$')
+re_directive = re.compile(
+    r'^#(library|import|source|native|resource)\([\'"]([^\'"]*)[\'"](.*)\);$')

[vsm, 2011/10/26 19:52:29]

Is "resource" standard?

[Siggi Cherem (dart-lang), 2011/10/26 20:03:12]

yes - is not used extensively, but it is supported by the vm and dartc.

 
 class Library(object):
-  def __init__(self, name, imports, sources, code):
+  def __init__(self, name, imports, sources, natives, code):
     self.name = name
     self.imports = imports
     self.sources = sources
+    self.natives = natives
     self.code = code
 
 def parseLibrary(library):
   """ Parses a .dart source file that is the root of a library, and returns
       information about it: the name, the imports, included sources, and any
       code in the file.
   """
   libraryname = None
   imports = []
   sources = []
+  natives = []
   inlinecode = []
   if exists(library):
     # TODO(sigmund): stop parsing when import/source
     for line in fileinput.input(library):
-      match = re_import.match(line)
+      match = re_directive.match(line)
       if match:
-        imports.append(match.group(1))
+        directive = match.group(1)
+        if directive == 'library':
+          assert libraryname is None
+          libraryname = match.group(2)
+        elif directive == 'source':
+          sources.append(match.group(2))
+        elif directive == 'import':
+          imports.append((match.group(2), match.group(3)))
+        elif directive == 'native':
+          natives.append(match.group(2))
+        elif directive == 'resource':
+          # currently ignored
+          pass
+        else:
+          raise 'unknown directive %s' % directive
       else:
-        match = re_source.match(line)
-        if match:
-          sources.append(match.group(1))
-        else:
-          match = re_library.match(line)
-          if match:
-            assert libraryname is None
-            libraryname = match.group(1)
-          else:
-            inlinecode.append(line)
-
+        inlinecode.append(line)
     fileinput.close()
-  return Library(libraryname, imports, sources, inlinecode)
+  return Library(libraryname, imports, sources, natives, inlinecode)
 
 def normjoin(*args):
   return os.path.normpath(os.path.join(*args))
 
 def mergefiles(srcs, dstfile):
   for src in srcs:
     with open(src, 'r') as s:
       dstfile.write(s.read())
 
+def copyfile(src, dst):
+  if not exists(dirname(dst)):
+    os.makedirs(dirname(dst))
+  with open(src, 'r') as s:
+    with open(dst, 'w') as d:
+      d.write(s.read())
+
 def main(outdir = None, *inputs):
   if not outdir or not inputs:
     print "Usage: %s OUTDIR INPUTS" % args[0]
     print "  OUTDIR is the war directory to copy to"
     print "  INPUTS is a list of files or patterns used to specify the input"
     print "   .dart files"
     print "This script should be run from the client root directory."
     print "Files will be merged and copied to: OUTDIR/relative-path-of-file,"
     print "except for dart files with absolute paths, which will be copied to"
     print " OUTDIR/absolute-path-as-directories"
@@ skipping 35 matching lines @@
       if not exists(dstpath):
         os.makedirs(dstpath)
 
 
       # Create file containing all imports, and inlining all sources
       with open(outpath, 'w') as f:
         if library.name:
           f.write("#library('%s');\n\n" % library.name)
         else:
           f.write("#library('%s');\n\n" % basename(lib))
-        for importfile in library.imports:
-          f.write("#import('%s');\n" % importfile)
+        for (importfile, optional_prefix) in library.imports:
+          f.write("#import('%s'%s);\n" % (importfile, optional_prefix))
+        for native in library.natives:
+          if isabs(native):
+            npath = native[1:]
+          else:
+            npath = native
+          f.write("#native('%s');\n" % npath)
+          copyfile(normjoin(dirname(lib), native),
+              join(dirname(outpath), npath))
         f.write('%s' % (''.join(library.code)))
         mergefiles([normjoin(dirname(lib), s) for s in library.sources], f)
 
-      worklist.extend([normjoin(dirname(lib), i) for i in library.imports])
+      for (i, prefix) in library.imports:
+        if not i.startswith('dart:'):
+          worklist.append(normjoin(dirname(lib), i));
 
   return 0
 
 if __name__ == '__main__':
   sys.exit(main(*sys.argv[1:]))