Merge pull request #5915 from kripken/eval1-followups

Followups for eval-removal 1 (#5751)

Author: kripken

emcc.py

@@ -107,6 +107,12 @@ def exit_with_error(message):
 
 class Intermediate(object):
   counter = 0
+# this method uses the global 'final' variable, which contains the current
+# final output file. if a method alters final, and calls this method, then it
+# must modify final globally (i.e. it can't receive final as a param and
+# return it)
+# TODO: refactor all this, a singleton that abstracts over the final output
+#       and saving of intermediates
 def save_intermediate(name=None, suffix='js'):
   name = os.path.join(shared.get_emscripten_temp_dir(), 'emcc-%d%s.%s' % (Intermediate.counter, '' if name is None else '-' + name, suffix))
   if isinstance(final, list):
@@ -1633,49 +1639,14 @@ def get_final():
           if options.post_js:
             options.post_js = options.post_js.replace('\r\n', '\n')
         outfile = open(final, 'w')
-        outfile.write(options.pre_js)
-        outfile.write(src) # this may be large, don't join it to others
+        # pre-js code goes right after the Module integration code (so it
+        # can use Module), we have a marker for it
+        outfile.write(src.replace('// {{PRE_JSES}}', options.pre_js))
         outfile.write(options.post_js)
         outfile.close()
         options.pre_js = src = options.post_js = None
         if DEBUG: save_intermediate('pre-post')
 
-      if not shared.Settings.SIDE_MODULE:
-        # The Module object: Our interface to the outside world. We import
-        # and export values on it. There are various ways Module can be used:
-        # 1. Not defined. We create it here
-        # 2. A function parameter, function(Module) { ..generated code.. }
-        # 3. pre-run appended it, var Module = {}; ..generated code..
-        # 4. External script tag defines var Module.
-        # We need to check if Module already exists (e.g. case 3 above).
-        # Substitution will be replaced with actual code on later stage of the build,
-        # this way Closure Compiler will not mangle it (e.g. case 4. above).
-        # Note that if you want to run closure, and also to use Module
-        # after the generated code, you will need to define   var Module = {};
-        # before the code. Then that object will be used in the code, and you
-        # can continue to use Module afterwards as well.
-        if options.use_closure_compiler:
-          # `if (!Module)` is crucial for Closure Compiler here as it will otherwise replace every `Module` occurrence with a string
-          module_header = '''
-var Module;
-if (!Module) Module = %s;
-''' % shared.JS.module_export_name_substitution_pattern
-        else:
-          module_header = '''
-var Module = typeof %(EXPORT_NAME)s !== 'undefined' ? %(EXPORT_NAME)s : {};
-''' % {"EXPORT_NAME": shared.Settings.EXPORT_NAME}
-
-        # Append module header now as --pre-js is already added
-        logging.debug('Appending module header')
-        src = open(final).read()
-        final += '.wh.js'
-        outfile = open(final, 'w')
-        outfile.write(module_header)
-        outfile.write(src)
-        outfile.close()
-        src = None
-        if DEBUG: save_intermediate('with-header')
-
       # Apply a source code transformation, if requested
       if options.js_transform:
         shutil.copyfile(final, final + '.tr.js')
@@ -1869,9 +1840,9 @@ def get_eliminate():
                     wasm_text_target, misc_temp_files, optimizer)
 
       if shared.Settings.MODULARIZE:
-        final = modularize(final)
+        modularize()
 
-      final = module_export_name_substitution(final)
+      module_export_name_substitution()
 
       # The JS is now final. Move it to its final location
       shutil.move(final, js_target)
@@ -2433,7 +2404,8 @@ def do_binaryen(target, asm_target, options, memfile, wasm_binary_target,
     f.close()
 
 
-def modularize(final):
+def modularize():
+  global final
   logging.debug('Modularizing, assigning to var ' + shared.Settings.EXPORT_NAME)
   src = open(final).read()
   final = final + '.modular.js'
@@ -2453,10 +2425,10 @@ def modularize(final):
 ''' % {"EXPORT_NAME": shared.Settings.EXPORT_NAME, "src": src})
   f.close()
   if DEBUG: save_intermediate('modularized', 'js')
-  return final
 
 
-def module_export_name_substitution(final):
+def module_export_name_substitution():
+  global final
   logging.debug('Private module export name substitution with ' + shared.Settings.EXPORT_NAME)
   src = open(final).read()
   final = final + '.module_export_name_substitution.js'
@@ -2465,7 +2437,6 @@ def module_export_name_substitution(final):
   f.write(src.replace(shared.JS.module_export_name_substitution_pattern, replacement))
   f.close()
   if DEBUG: save_intermediate('module_export_name_substitution', 'js')
-  return final
 
 
 def generate_html(target, options, js_target, target_basename,

src/shell.js

@@ -1,3 +1,30 @@
+#if SIDE_MODULE == 0
+// The Module object: Our interface to the outside world. We import
+// and export values on it. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to check if Module already exists (e.g. case 3 above).
+// Substitution will be replaced with actual code on later stage of the build,
+// this way Closure Compiler will not mangle it (e.g. case 4. above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define   var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+#if USE_CLOSURE_COMPILER
+// if (!Module)` is crucial for Closure Compiler here as it will otherwise replace every `Module` occurrence with a string
+var Module;
+if (!Module) Module = "__EMSCRIPTEN_PRIVATE_MODULE_EXPORT_NAME_SUBSTITUTION__";
+#else
+var Module = typeof {{{ EXPORT_NAME }}} !== 'undefined' ? {{{ EXPORT_NAME }}} : {};
+#endif // USE_CLOSURE_COMPILER
+#endif // SIDE_MODULE
+
+// --pre-jses are emitted after the Module integration code, so that they can
+// refer to Module (if they choose; they can also define Module)
+// {{PRE_JSES}}
+
 // Sometimes an existing Module object exists with properties
 // meant to overwrite the default module functionality. Here
 // we collect those properties and reapply _after_ we configure

tests/test_core.py

@@ -6761,8 +6761,7 @@ def test_modularize_closure_pre(self):
       '--pre-js', path_from_root('tests', 'core', 'modularize_closure_pre.js'),
       '--closure', '1',
       '-s', 'MODULARIZE=1',
-      '-g1',
-      '-O2'
+      '-g1'
     ]
     def post(filename):
       src = open(filename, 'a')