webruby 0.2.2 → 0.2.4

data/modules/emscripten/emcc

@@ -50,11 +50,12 @@ emcc can be influenced by a few environment variables:
 import os, sys, shutil, tempfile, subprocess, shlex, time, re, logging
 from subprocess import PIPE, STDOUT
 from tools import shared, jsrun
-from tools.shared import Compression, execute, suffix, unsuffixed, unsuffixed_basename
+from tools.shared import Compression, execute, suffix, unsuffixed, unsuffixed_basename, WINDOWS
 from tools.response_file import read_response_file
 
-CXX_SUFFIXES = ('.cpp', '.cxx', '.cc')
-SOURCE_SUFFIXES = ('.c', '.cpp', '.cxx', '.cc', '.m', '.mm')
+C_SUFFIXES = ('.c', '.C')
+CXX_SUFFIXES = ('.cpp', '.cxx', '.cc', '.CPP', '.CXX', '.CC')
+SOURCE_SUFFIXES = C_SUFFIXES + CXX_SUFFIXES + ('.m', '.mm')
 BITCODE_SUFFIXES = ('.bc', '.o', '.obj')
 DYNAMICLIB_SUFFIXES = ('.dylib', '.so', '.dll')
 STATICLIB_SUFFIXES = ('.a',)
@@ -397,7 +398,8 @@ Options that are modified or new in %s include:
   --shell-file <path>      The path name to a skeleton HTML file used
                            when generating HTML output. The shell file
                            used needs to have this token inside it:
-                           {{{ SCRIPT_CODE }}}
+                           {{{ SCRIPT }}}
+                           (see src/shell.html for an example)
                            Note that this argument is ignored if a
                            target other than HTML is specified using
                            the -o option.
@@ -497,11 +499,23 @@ Options that are modified or new in %s include:
   --proxy-to-worker        Generates both html and js files. The main
                            program is in js, and the html proxies to/from it.
 
+  --emrun                  Enables the generated output to be aware of the
+                           emrun command line tool. This allows stdout, stderr
+                           and exit(returncode) capture when running the
+                           generated application through emrun.
+
+  --em-config              Specifies the location of the .emscripten configuration
+                           file for the current compiler run. If not specified,
+                           the environment variable EM_CONFIG is read for this
+                           file, and if that is not set, the default location
+                           ~/.emscripten is assumed.
+
 The target file, if specified (-o <target>), defines what will
 be generated:
 
   <name>.js                JavaScript
-  <name>.html              HTML with embedded JavaScript
+  <name>.html              HTML + side JavaScript file (<name>.js)
+                             (JS on the side improves page load time)
   <name>.bc                LLVM bitcode (default)
   <name>.o                 LLVM bitcode (same as .bc)
 
@@ -542,7 +556,7 @@ There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR P
   exit(0)  
 
 elif len(sys.argv) == 2 and sys.argv[1] == '-v': # -v with no inputs
-  print 'emcc (Emscripten GCC-like replacement + linker emulating GNU ld ) 2.0'
+  print 'emcc (Emscripten GCC-like replacement + linker emulating GNU ld ) %s' % shared.EMSCRIPTEN_VERSION
   exit(subprocess.call([shared.CLANG, '-v']))
 
 def is_minus_s_for_emcc(newargs,i):
@@ -771,10 +785,12 @@ try:
   shell_path = shared.path_from_root('src', 'shell.html')
   js_libraries = []
   bind = False
+  emrun = False
   jcache = False
   save_bc = False
   memory_init_file = False
   use_preload_cache = False
+  no_heap_copy = False
   proxy_to_worker = False
 
   if use_cxx:
@@ -884,8 +900,17 @@ try:
       check_bad_eq(newargs[i])
       parts = newargs[i+1].split(',')
       assert len(parts) == 3, '--compression requires specifying    native_encoder,js_decoder,js_name  - see emcc --help. got: %s' % newargs[i+1]
-      Compression.encoder = parts[0]
-      Compression.decoder = parts[1]
+      def locate(tool):
+        if WINDOWS:
+          if os.path.exists(tool+'.exe'):
+            return tool+'.exe'
+          if os.path.exists(tool+'.bat'):
+            return tool+'.bat'
+          if os.path.exists(tool+'.cmd'):
+            return tool+'.cmd'
+        return tool
+      Compression.encoder = locate(parts[0])
+      Compression.decoder = locate(parts[1])
       Compression.js_name = parts[2]
       assert os.path.exists(Compression.encoder), 'native encoder %s does not exist' % Compression.encoder
       assert os.path.exists(Compression.decoder), 'js decoder %s does not exist' % Compression.decoder
@@ -895,6 +920,9 @@ try:
     elif newargs[i].startswith('--use-preload-cache'):
       use_preload_cache = True
       newargs[i] = ''
+    elif newargs[i].startswith('--no-heap-copy'):
+      no_heap_copy = True
+      newargs[i] = ''
     elif newargs[i] == '--ignore-dynamic-linking':
       ignore_dynamic_linking = True
       newargs[i] = ''
@@ -947,12 +975,23 @@ try:
       if not absolute_warning_shown and os.path.isabs(path_name):
         logging.warning ('-I or -L of an absolute path "' + newargs[i] + '" encountered. If this is to a local system header/library, it may cause problems (local system files make sense for compiling natively on your system, but not necessarily to JavaScript). Pass \'-Wno-warn-absolute-paths\' to emcc to hide this warning.') # Of course an absolute path to a non-system-specific library or header is fine, and you can ignore this warning. The danger are system headers that are e.g. x86 specific and nonportable. The emscripten bundled headers are modified to be portable, local system ones are generally not
         absolute_warning_shown = True
+    elif newargs[i] == '--emrun':
+      emrun = True
+      newargs[i] = ''
+    elif newargs[i] == '--em-config':
+      # This option is parsed in tools/shared.py, here only clean it up from being passed to clang.
+      newargs[i] = ''
+      newargs[i+1] = ''
+
   newargs = [ arg for arg in newargs if arg is not '' ]
 
   # If user did not specify a default -std for C++ code, specify the emscripten default.
   if default_cxx_std:
     newargs = newargs + [default_cxx_std]
 
+  if emrun:
+    post_js += open(shared.path_from_root('src', 'emrun_postjs.js')).read() + '\n'
+
   if js_opts is None: js_opts = opt_level >= 2
   if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level]
   if llvm_lto is None and opt_level >= 3: llvm_lto = 3
@@ -1127,7 +1166,7 @@ try:
 
     heap = 4096
     while heap < shared.Settings.TOTAL_MEMORY:
-      if heap <= 16*1024*1024:
+      if heap < 16*1024*1024:
         heap *= 2
       else:
         heap += 16*1024*1024
@@ -1258,7 +1297,16 @@ try:
         shutil.move(in_temp(unsuffixed(uniquename(input_file)) + '.o'), unsuffixed_basename(input_file) + '.' + final_suffix)
     else:
       if len(input_files) == 1:
-        shutil.move(in_temp(unsuffixed(uniquename(input_files[0])) + '.o'), specified_target)
+        temp_output_base = in_temp(unsuffixed(uniquename(input_files[0])))
+        shutil.move(temp_output_base + '.o', specified_target)
+        if os.path.exists(temp_output_base + '.d'):
+          # There was a .d file generated, from -MD or -MMD and friends, save a copy of it to where the output resides,
+          # adjusting the target name away from the temporary file name to the specified target.
+          # It will be deleted with the rest of the temporary directory.
+          deps = open(temp_output_base + '.d').read()
+          deps = deps.replace(temp_output_base + '.o', specified_target)
+          with open(os.path.join(os.path.dirname(specified_target), os.path.basename(unsuffixed(input_files[0]) + '.d')), "w") as out_dep:
+            out_dep.write(deps)
       else:
         assert len(original_input_files) == 1 or not has_dash_c, 'fatal error: cannot specify -o with -c with multiple files' + str(sys.argv) + ':' + str(original_input_files)
         # We have a specified target (-o <target>), which is not JavaScript or HTML, and
@@ -1423,6 +1471,12 @@ try:
           'wctob.c',
           'wctomb.c',
          ]],
+         ['regex', [
+          'regcomp.c',
+          'regerror.c',
+          'regexec.c',
+          'tre-mem.c',
+         ]],
          ['stdio', [
           'fwprintf.c',
           'swprintf.c',
@@ -1625,18 +1679,26 @@ try:
     else:
       # At minimum remove dead functions etc., this potentially saves a lot in the size of the generated code (and the time to compile it)
       link_opts += shared.Building.get_safe_internalize() + ['-globaldce']
-    shared.Building.llvm_opt(in_temp(target_basename + '.bc'), link_opts)
-    if DEBUG: save_intermediate('linktime', 'bc')
+    if not save_bc:
+      # let llvm opt directly emit ll, to skip writing and reading all the bitcode
+      link_opts += ['-S']
+      shared.Building.llvm_opt(final, link_opts, final + '.link.ll')
+      final = final + '.link.ll'
+      if DEBUG: save_intermediate('linktime', 'll')
+    else:
+      shared.Building.llvm_opt(final, link_opts)
+      if DEBUG: save_intermediate('linktime', 'bc')
 
   if save_bc:
     shutil.copyfile(final, save_bc)
 
   # Prepare .ll for Emscripten
   if not LEAVE_INPUTS_RAW:
-    final = shared.Building.llvm_dis(final, final + '.ll')
+    if save_bc:
+      final = shared.Building.llvm_dis(final, final + '.ll')
   else:
     assert len(input_files) == 1
-  if DEBUG: save_intermediate('ll', 'll')
+  if DEBUG and save_bc: save_intermediate('ll', 'll')
 
   if AUTODEBUG:
     logging.debug('autodebug')
@@ -1654,7 +1716,7 @@ try:
   # Embed and preload files
   if len(preload_files) + len(embed_files) > 0:
     logging.debug('setting up files')
-    file_args = []
+    file_args = ['--pre-run']
     if len(preload_files) > 0:
       file_args.append('--preload')
       file_args += preload_files
@@ -1665,11 +1727,10 @@ try:
       file_args += ['--compress', Compression.encoder, Compression.decoder, Compression.js_name]
     if use_preload_cache:
       file_args.append('--use-preload-cache')
-    code = execute([shared.PYTHON, shared.FILE_PACKAGER, unsuffixed(target) + '.data'] + file_args, stdout=PIPE)[0]
-    src = open(final).read().replace('// {{PRE_RUN_ADDITIONS}}', '// {{PRE_RUN_ADDITIONS}}\n' + code)
-    final += '.files.js'
-    open(final, 'w').write(src)
-    if DEBUG: save_intermediate('files')
+    if no_heap_copy:
+      file_args.append('--no-heap-copy')
+    file_code = execute([shared.PYTHON, shared.FILE_PACKAGER, unsuffixed(target) + '.data'] + file_args, stdout=PIPE)[0]
+    pre_js = file_code + pre_js
 
   # Apply pre and postjs files
   if pre_js or post_js:
@@ -1821,22 +1882,21 @@ try:
   if final_suffix == 'html':
     logging.debug('generating HTML')
     shell = open(shell_path).read()
+    assert '{{{ SCRIPT }}}' in shell, 'HTML shell must contain  {{{ SCRIPT }}}  , see src/shell.html for an example'
     html = open(target, 'w')
+    js_target = unsuffixed(target) + '.js'
+    base_js_target = os.path.basename(js_target)
     if proxy_to_worker:
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(shared.path_from_root('src', 'proxyClient.js')).read().replace('{{{ filename }}}', target_basename)))
-      js_target = unsuffixed(target) + '.js'
-      shutil.copyfile(final, js_target)
+      html.write(shell.replace('{{{ SCRIPT }}}', '<script>' + open(shared.path_from_root('src', 'proxyClient.js')).read().replace('{{{ filename }}}', target_basename) + '</script>'))
+      shutil.move(final, js_target)
     elif not Compression.on:
       if debug_level >= 4:
-        match = re.match('.*?<script[^>]*>{{{ SCRIPT_CODE }}}</script>', shell,
-            re.DOTALL)
-        if match is None:
-          raise RuntimeError('''Could not find script insertion point - make sure you have   <script type='text/javascript'>{{{ SCRIPT_CODE }}}</script>   in your HTML file (with no newlines)''')
-        generate_source_map(target, match.group().count('\n'))
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read()))
+        generate_source_map(target)
+      shutil.move(final, js_target)
+      script_tag = '''<script async type="text/javascript" src="%s"></script>''' % base_js_target
+      html.write(shell.replace('{{{ SCRIPT }}}', script_tag))
     else:
       # Compress the main code
-      js_target = unsuffixed(target) + '.js'
       shutil.move(final, js_target)
       Compression.compress(js_target)
 
@@ -1884,8 +1944,8 @@ try:
           });
         };
         compiledCodeXHR.send(null);
-''' % Compression.compressed_name(js_target)
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', decoding))
+''' % Compression.compressed_name(base_js_target)
+      html.write(shell.replace('{{{ SCRIPT }}}', '<script>' + decoding + '</script>'))
 
       # Add decompressor with web worker glue code
       decompressor = open('decompress.js', 'w')

data/modules/emscripten/emlink.py

@@ -10,21 +10,24 @@ import sys
 from tools import shared
 from tools.asm_module import AsmModule
 
-try:
-  me, main, side, out = sys.argv[:4]
-except:
-  print >> sys.stderr, 'usage: emlink.py [main module] [side module] [output name]'
-  sys.exit(1)
+def run():
+  try:
+    me, main, side, out = sys.argv[:4]
+  except:
+    print >> sys.stderr, 'usage: emlink.py [main module] [side module] [output name]'
+    sys.exit(1)
 
-print 'Main module:', main
-print 'Side module:', side
-print 'Output:', out
+  print 'Main module:', main
+  print 'Side module:', side
+  print 'Output:', out
 
-shared.try_delete(out)
+  shared.try_delete(out)
 
-main = AsmModule(main)
-side = AsmModule(side)
+  main = AsmModule(main)
+  side = AsmModule(side)
 
-side.relocate_into(main)
-main.write(out)
+  side.relocate_into(main)
+  main.write(out)
 
+if __name__ == '__main__':
+  run()

data/modules/emscripten/emmake

@@ -6,7 +6,7 @@ the environment variables to use emcc and so forth. Usage:
 
   emmake make [FLAGS]
 
-Not that if you ran configure with emconfigure, then
+Note that if you ran configure with emconfigure, then
 the environment variables have already been detected
 and set. This script is useful if you have no configure
 step, and your Makefile uses the environment vars