aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xtests/runner.py4
-rw-r--r--tools/shared.py98
2 files changed, 52 insertions, 50 deletions
diff --git a/tests/runner.py b/tests/runner.py
index b2249dac..0baf79dc 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -7571,7 +7571,7 @@ f.close()
if 'error' in ret[1].lower():
print >> sys.stderr, 'Failed command: ' + ' '.join(cmd)
print >> sys.stderr, 'Result:\n' + ret[1]
- raise Exception('cmake call failed!') # cmake spams this silly message to stderr, so hide it: "Platform/Emscripten to use this system, please send your config file to cmake@www.cmake.org so it can be added to cmake"
+ raise Exception('cmake call failed!')
assert os.path.exists(tempdirname + '/Makefile'), 'CMake call did not produce a Makefile!'
# Build
@@ -8082,7 +8082,7 @@ f.close()
}
''')
output = Popen(['python', EMCC, os.path.join(self.get_dir(), 'main.cpp'), '-s', 'WARN_ON_UNDEFINED_SYMBOLS=1'], stderr=PIPE).communicate()
- self.assertContained('Unresolved symbol: _something\n', output[1])
+ self.assertContained('Unresolved symbol: _something', output[1])
output = Popen(['python', EMCC, os.path.join(self.get_dir(), 'main.cpp')], stderr=PIPE).communicate()
self.assertNotContained('Unresolved symbol: _something\n', output[1])
diff --git a/tools/shared.py b/tools/shared.py
index 9f170a58..19ba71bb 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -2,61 +2,63 @@ import shutil, time, os, sys, json, tempfile, copy, shlex, atexit, subprocess
from subprocess import Popen, PIPE, STDOUT
from tempfile import mkstemp
-# A helper class that is used on Windows to represent the subprocess object that is the return value of Popen.
-class MockPopen:
- def __init__(self, stdout, stderr, returncode):
- self.returncode = returncode
- self.output = (stdout, stderr)
- def communicate(self):
- return self.output
- def poll(self):
- return self.returncode
- def kill(self):
- return # We've already communicate()d the process (waited for its completion), so can't kill() anymore. Therefore this is a no-op.
-
# On Windows python suffers from a particularly nasty bug if python is spawning new processes while python itself is spawned from some other non-console process.
# Use a custom replacement for Popen on Windows to avoid the "WindowsError: [Error 6] The handle is invalid" errors when emcc is driven through cmake or mingw32-make.
# See http://bugs.python.org/issue3905
-def call_process(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False,
- shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0):
- # (stdin, stdout, stderr) store what the caller originally wanted to be done with the streams.
- # (stdin_, stdout_, stderr_) will store the fixed set of streams that workaround the bug.
- stdin_ = stdin
- stdout_ = stdout
- stderr_ = stderr
-
- # If the caller wants one of these PIPEd, we must PIPE them all to avoid the 'handle is invalid' bug.
- if stdin_ == PIPE or stdout_ == PIPE or stderr_ == PIPE:
- if stdin_ == None:
- stdin_ = PIPE
- if stdout_ == None:
- stdout_ = PIPE
- if stderr_ == None:
- stderr_ = PIPE
-
- # Call the process with fixed streams.
- process = subprocess.Popen(args, bufsize, executable, stdin_, stdout_, stderr_, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags)
- output = process.communicate()
-
- # If caller never wanted to PIPE stdout or stderr, route the output back to screen to avoid swallowing output.
- if stdout == None and stdout_ == PIPE and len(output[0].strip()) > 0:
- print >> sys.stdout, output[0]
- if stderr == None and stderr_ == PIPE and len(output[1].strip()) > 0:
- print >> sys.stderr, output[1]
+class WindowsPopen:
+ def __init__(self, args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False,
+ shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0):
+ self.stdin = stdin
+ self.stdout = stdout
+ self.stderr = stderr
+
+ # (stdin, stdout, stderr) store what the caller originally wanted to be done with the streams.
+ # (stdin_, stdout_, stderr_) will store the fixed set of streams that workaround the bug.
+ self.stdin_ = stdin
+ self.stdout_ = stdout
+ self.stderr_ = stderr
+
+ # If the caller wants one of these PIPEd, we must PIPE them all to avoid the 'handle is invalid' bug.
+ if self.stdin_ == PIPE or self.stdout_ == PIPE or self.stderr_ == PIPE:
+ if self.stdin_ == None:
+ self.stdin_ = PIPE
+ if self.stdout_ == None:
+ self.stdout_ = PIPE
+ if self.stderr_ == None:
+ self.stderr_ = PIPE
- # Return a mock object to the caller. This works as long as all emscripten code immediately .communicate()s the result, and doesn't
- # leave the process object around for longer/more exotic uses.
- if stdout == None and stderr == None:
- return MockPopen(None, None, process.returncode)
- if stdout == None:
- return MockPopen(None, output[1], process.returncode)
- if stderr == None:
- return MockPopen(output[0], None, process.returncode)
- return MockPopen(output[0], output[1], process.returncode)
+ # Call the process with fixed streams.
+ self.process = subprocess.Popen(args, bufsize, executable, self.stdin_, self.stdout_, self.stderr_, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags)
+
+ def communicate(self, input=None):
+ output = self.process.communicate(input)
+ self.returncode = self.process.returncode
+
+ # If caller never wanted to PIPE stdout or stderr, route the output back to screen to avoid swallowing output.
+ if self.stdout == None and self.stdout_ == PIPE and len(output[0].strip()) > 0:
+ print >> sys.stdout, output[0]
+ if self.stderr == None and self.stderr_ == PIPE and len(output[1].strip()) > 0:
+ print >> sys.stderr, output[1]
+
+ # Return a mock object to the caller. This works as long as all emscripten code immediately .communicate()s the result, and doesn't
+ # leave the process object around for longer/more exotic uses.
+ if self.stdout == None and self.stderr == None:
+ return (None, None)
+ if self.stdout == None:
+ return (None, output[1])
+ if self.stderr == None:
+ return (output[0], None)
+ return (output[0], output[1])
+
+ def poll(self):
+ return self.process.returncode
+
+ def kill(self):
+ return self.process.kill
# Install our replacement Popen handler if we are running on Windows to avoid python spawn process function.
if os.name == 'nt':
- Popen = call_process
+ Popen = WindowsPopen
import js_optimizer