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.response_file import read_response_file

CXX_SUFFIXES = ('.cpp', '.cxx', '.cc')

SOURCE_SUFFIXES = ('.c', '.cpp', '.cxx', '.cc', '.m', '.mm')

BITCODE_SUFFIXES = ('.bc', '.o', '.obj')

DYNAMICLIB_SUFFIXES = ('.dylib', '.so', '.dll')

STATICLIB_SUFFIXES = ('.a',)

ASSEMBLY_SUFFIXES = ('.ll',)

LIB_PREFIXES = ('', 'lib')

JS_CONTAINING_SUFFIXES = ('js', 'html')

LLVM_OPT_LEVEL = {

}

DEBUG = os.environ.get('EMCC_DEBUG')

if DEBUG == "0":

DEBUG = None

TEMP_DIR = os.environ.get('EMCC_TEMP_DIR')

LEAVE_INPUTS_RAW = os.environ.get('EMCC_LEAVE_INPUTS_RAW') # Do not compile .ll files into .bc, just compile them with emscripten directly

# Not recommended, this is mainly for the test runner, or if you have some other

# specific need.

# One major limitation with this mode is that libc and libc++ cannot be

# added in. Also, LLVM optimizations will not be done, nor dead code elimination

AUTODEBUG = os.environ.get('EMCC_AUTODEBUG') # If set to 1, we will run the autodebugger (the automatic debugging tool, see tools/autodebugger).

# Note that this will disable inclusion of libraries. This is useful because including

# dlmalloc makes it hard to compare native and js builds

EMCC_CFLAGS = os.environ.get('EMCC_CFLAGS') # Additional compiler flags that we treat as if they were passed to us on the commandline

logging.debug('invocation: ' + ' '.join(sys.argv) + (' + ' + EMCC_CFLAGS if EMCC_CFLAGS else ''))

if EMCC_CFLAGS: sys.argv.append(EMCC_CFLAGS)

if DEBUG and LEAVE_INPUTS_RAW: logging.warning('leaving inputs raw')

stdout = PIPE if not DEBUG else None # suppress output of child processes

stderr = PIPE if not DEBUG else None # unless we are in DEBUG mode

shared.check_sanity(force=DEBUG)

if len(sys.argv) == 1:

logging.warning('no input files')

exit(1)

response_file = True

while response_file:

response_file = None

for index in range(1, len(sys.argv)):

if sys.argv[index][0] == '@':

# found one, loop again next time

response_file = True

extra_args = read_response_file(sys.argv[index])

# slice in extra_args in place of the response file arg

sys.argv[index:index+1] = extra_args

break

if len(sys.argv) == 1 or '--help' in sys.argv:

this = os.path.basename('em++' if os.environ.get('EMMAKEN_CXX') else 'emcc')

print '''%s [options] file...

''' % (this, this, this)

exit(0)

elif sys.argv[1] == '--version':

revision = '(unknown revision)'

here = os.getcwd()

os.chdir(shared.path_from_root())

try:

revision = execute(['git', 'show'], stdout=PIPE, stderr=PIPE)[0].split('\n')[0]

except:

pass

finally:

os.chdir(here)

print '''emcc (Emscripten GCC-like replacement) %s (%s)

''' % (shared.EMSCRIPTEN_VERSION, revision)

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'

exit(subprocess.call([shared.CLANG, '-v']))

def is_minus_s_for_emcc(newargs,i):

return False

CONFIGURE_CONFIG = (os.environ.get('EMMAKEN_JUST_CONFIGURE') or 'conftest.c' in sys.argv) and not os.environ.get('EMMAKEN_JUST_CONFIGURE_RECURSE')

CMAKE_CONFIG = 'CMakeFiles/cmTryCompileExec.dir' in ' '.join(sys.argv)# or 'CMakeCCompilerId' in ' '.join(sys.argv)

if CONFIGURE_CONFIG or CMAKE_CONFIG:

debug_configure = 0 # XXX use this to debug configure stuff. ./configure's generally hide our normal output including stderr so we write to a file

use_js = os.environ.get('EMCONFIGURE_JS') # whether we fake configure tests using clang - the local, native compiler - or not. if not we generate JS and use node with a shebang

# neither approach is perfect, you can try both, but may need to edit configure scripts in some cases

# XXX False is not fully tested yet

if debug_configure:

tempout = '/tmp/emscripten_temp/out'

if not os.path.exists(tempout):

open(tempout, 'w').write('//\n')

src = None

for arg in sys.argv:

if arg.endswith('.c'):

try:

src = open(arg).read()

if debug_configure: open(tempout, 'a').write('============= ' + arg + '\n' + src + '\n=============\n\n')

except:

pass

elif arg.endswith('.s'):

if debug_configure: open(tempout, 'a').write('(compiling .s assembly, must use clang\n')

use_js = 0

elif arg == '-E':

use_js = 0

if src:

if 'fopen' in src and '"w"' in src:

use_js = 0 # we cannot write to files from js!

if debug_configure: open(tempout, 'a').write('Forcing clang since uses fopen to write\n')

compiler = os.environ.get('CONFIGURE_CC') or (shared.CLANG if not use_js else shared.EMCC) # if CONFIGURE_CC is defined, use that. let's you use local gcc etc. if you need that

if not ('CXXCompiler' in ' '.join(sys.argv) or os.environ.get('EMMAKEN_CXX')):

compiler = shared.to_cc(compiler)

def filter_emscripten_options(argv):

idx += 1

cmd = [compiler] + list(filter_emscripten_options(sys.argv[1:]))

if not use_js: cmd += shared.EMSDK_OPTS + ['-DEMSCRIPTEN']

if use_js: cmd += ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=1'] # configure tests should fail when an undefined symbol exists

logging.debug('just configuring: ' + ' '.join(cmd))

if debug_configure: open(tempout, 'a').write('emcc, just configuring: ' + ' '.join(cmd) + '\n\n')

if not use_js:

exit(subprocess.call(cmd))

else:

only_object = '-c' in cmd

target = None

for i in range(len(cmd)-1):

if cmd[i] == '-o':

if not only_object:

cmd[i+1] += '.js'

target = cmd[i+1]

break

print 't1', target

if not target:

target = 'a.out.js'

print 't2', target, only_object

os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = '1'

ret = subprocess.call(cmd)

os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = ''

if not os.path.exists(target): exit(1)

if target.endswith('.js'):

shutil.copyfile(target, target[:-3])

target = target[:-3]

src = open(target).read()

full_node = ' '.join(shared.listify(shared.NODE_JS))

if os.path.sep not in full_node:

full_node = '/usr/bin/' + full_node # TODO: use whereis etc. And how about non-*NIX?

open(target, 'w').write('#!' + full_node + '\n' + src) # add shebang

import stat

os.chmod(target, stat.S_IMODE(os.stat(target).st_mode) | stat.S_IXUSR) # make executable

exit(ret)

if os.environ.get('EMMAKEN_COMPILER'):

CXX = os.environ['EMMAKEN_COMPILER']

else:

CXX = shared.CLANG

CC = shared.to_cc(CXX)

if os.environ.get('EMMAKEN_CXX'):

CC = CXX

CC_ADDITIONAL_ARGS = shared.COMPILER_OPTS

EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')

if EMMAKEN_CFLAGS: CC_ADDITIONAL_ARGS += shlex.split(EMMAKEN_CFLAGS)

seen_names = {}

def uniquename(name):

if name not in seen_names:

seen_names[name] = str(len(seen_names))

return unsuffixed(name) + '_' + seen_names[name] + (('.' + suffix(name)) if suffix(name) else '')

if len(sys.argv) == 1 or sys.argv[1] in ['x', 't']:

# noop ar

logging.debug('just ar')

sys.exit(0)

use_cxx = True

header = False # pre-compiled headers. We fake that by just copying the file

for i in range(1, len(sys.argv)):

arg = sys.argv[i]

if not arg.startswith('-'):

if arg.endswith(('.c','.m')):

use_cxx = False

if arg.endswith('.h') and sys.argv[i-1] != '-include':

header = True

if '-M' in sys.argv or '-MM' in sys.argv:

# Just output dependencies, do not compile. Warning: clang and gcc behave differently with -MF! (clang seems to not recognize it)

cmd = [CC] + shared.COMPILER_OPTS + sys.argv[1:]

logging.debug('just dependencies: ' + ' '.join(cmd))

exit(subprocess.call(cmd))

if '-E' in sys.argv:

# Just run the preprocessor

cmd = [CC] + sys.argv[1:]

logging.debug('just preprocessor ' + ' '.join(cmd))

exit(subprocess.call(cmd))

target = None

for i in range(len(sys.argv)-1):

if sys.argv[i].startswith('-o='):

raise Exception('Invalid syntax: do not use -o=X, use -o X')

if sys.argv[i] == '-o':

target = sys.argv[i+1]

sys.argv = sys.argv[:i] + sys.argv[i+2:]

break

specified_target = target

target = specified_target if specified_target is not None else 'a.out.js' # specified_target is the user-specified one, target is what we will generate

target_basename = unsuffixed_basename(target)

if '.' in target:

final_suffix = target.split('.')[-1]

else:

final_suffix = ''

if header: # header or such

if len(sys.argv) >= 3: # if there is a source and a target, then copy, otherwise do nothing

sys.argv = filter(lambda arg: not arg.startswith('-I'), sys.argv)

logging.debug('Just copy:' + sys.argv[-1] + target)

shutil.copy(sys.argv[-1], target)

else:

logging.debug('No-op.')

exit(0)

if TEMP_DIR:

temp_dir = TEMP_DIR

if os.path.exists(temp_dir):

shutil.rmtree(temp_dir) # clear it

os.makedirs(temp_dir)

else:

temp_root = shared.TEMP_DIR

if not os.path.exists(temp_root):

os.makedirs(temp_root)

temp_dir = tempfile.mkdtemp(dir=temp_root)

def in_temp(name):

return os.path.join(temp_dir, os.path.basename(name))

def filename_type_suffix(filename):

return ''

try:

call = CXX if use_cxx else CC

## Parse args

newargs = sys.argv[1:]

opt_level = 0

debug_level = 0

js_opts = None

llvm_opts = None

llvm_lto = None

closure = None

js_transform = None

pre_js = ''

post_js = ''

split_js_file = None

preload_files = []

embed_files = []

compression = None

ignore_dynamic_linking = False

shell_path = shared.path_from_root('src', 'shell.html')

js_libraries = []

bind = False

jcache = False

save_bc = False

memory_init_file = False

use_preload_cache = False

proxy_to_worker = False

if use_cxx:

default_cxx_std = '-std=c++03' # Enforce a consistent C++ standard when compiling .cpp files, if user does not specify one on the cmdline.

else:

default_cxx_std = '' # Compiling C code with .c files, don't enforce a default C++ std.

def check_bad_eq(arg):

assert '=' not in arg, 'Invalid parameter (do not use "=" with "--" options)'

absolute_warning_shown = False

# Scan for warning suppression message in advance from other cmdline flags, so that it works even if -I or -L directives are present before this.

for i in range(len(newargs)):

if newargs[i] == '-Wno-warn-absolute-paths':

newargs[i] = ''

absolute_warning_shown = True

settings_changes = []

def validate_arg_level(level_string, max_level, err_msg):

return level

for i in range(len(newargs)):

newargs[i] = newargs[i].strip() # On Windows Vista (and possibly others), excessive spaces in the command line leak into the items in this array, so trim e.g. 'foo.cpp ' -> 'foo.cpp'

if newargs[i].startswith('-O'):

# Let -O default to -O2, which is what gcc does.

requested_level = newargs[i][2:] or '2'

if requested_level == 's':

requested_level = 2

settings_changes.append('INLINING_LIMIT=50')

opt_level = validate_arg_level(requested_level, 3, 'Invalid optimization level: ' + newargs[i])

newargs[i] = ''

elif newargs[i].startswith('--js-opts'):

check_bad_eq(newargs[i])

js_opts = eval(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--llvm-opts'):

check_bad_eq(newargs[i])

llvm_opts = eval(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--llvm-lto'):

check_bad_eq(newargs[i])

llvm_lto = eval(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--closure'):

check_bad_eq(newargs[i])

closure = int(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--js-transform'):

check_bad_eq(newargs[i])

js_transform = newargs[i+1]

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--pre-js'):

check_bad_eq(newargs[i])

pre_js += open(newargs[i+1]).read() + '\n'

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--post-js'):

check_bad_eq(newargs[i])

post_js += open(newargs[i+1]).read() + '\n'

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--minify'):

check_bad_eq(newargs[i])

assert newargs[i+1] == '0', '0 is the only supported option for --minify; 1 has been deprecated'

debug_level = max(1, debug_level)

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--split'):

check_bad_eq(newargs[i])

split_js_file = int(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('-g'):

requested_level = newargs[i][2:] or '3'

debug_level = validate_arg_level(requested_level, 4, 'Invalid debug level: ' + newargs[i])

newargs[i] = '-g' # we'll need this to get LLVM debug info

elif newargs[i] == '--bind':

bind = True

newargs[i] = ''

if default_cxx_std:

default_cxx_std = '-std=c++11' # Force C++11 for embind code, but only if user has not explicitly overridden a standard.

elif newargs[i].startswith('-std='):

default_cxx_std = '' # User specified a standard to use, clear Emscripten from specifying it.

elif newargs[i].startswith('--embed-file'):

check_bad_eq(newargs[i])

embed_files.append(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--preload-file'):

check_bad_eq(newargs[i])

preload_files.append(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--compression'):

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]

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

Compression.on = True

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--use-preload-cache'):

use_preload_cache = True

newargs[i] = ''

elif newargs[i] == '--ignore-dynamic-linking':

ignore_dynamic_linking = True

newargs[i] = ''

elif newargs[i] == '-v':

shared.COMPILER_OPTS += ['-v']

os.environ['EMCC_DEBUG'] = '1' # send to child processes too

if DEBUG != 1:

# swap in debug logging

DEBUG = 1

shared.set_logging()

logging.debug('invocation: ' + ' '.join(sys.argv))

shared.apply_configuration() # reset config to pick up change

newargs[i] = ''

elif newargs[i].startswith('--shell-file'):

check_bad_eq(newargs[i])

shell_path = newargs[i+1]

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i].startswith('--js-library'):

check_bad_eq(newargs[i])

js_libraries.append(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i] == '--remove-duplicates':

logging.warning ('--remove-duplicates is deprecated as it is no longer needed. If you cannot link without it, file a bug with a testcase')

newargs[i] = ''

elif newargs[i] == '--jcache':

jcache = True

newargs[i] = ''

elif newargs[i] == '--clear-cache':

newargs[i] = ''

logging.warning('clearing cache')

shared.Cache.erase()

sys.exit(0)

elif newargs[i] == '--save-bc':

check_bad_eq(newargs[i])

save_bc = newargs[i+1]

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i] == '--memory-init-file':

check_bad_eq(newargs[i])

memory_init_file = int(newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

elif newargs[i] == '--proxy-to-worker':

proxy_to_worker = True

newargs[i] = ''

elif newargs[i].startswith(('-I', '-L')):

path_name = newargs[i][2:]

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

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 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

if opt_level == 0: debug_level = 4

if closure is None and opt_level == 3: closure = True

if llvm_lto is None and bind:

logging.debug('running lto for embind') # XXX this is a workaround for a pointer issue

llvm_lto = 1

# TODO: support source maps with js_transform

if js_transform and debug_level >= 4:

logging.warning('disabling source maps because a js transform is being done')

debug_level = 3

if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state

if closure:

assert os.path.exists(shared.CLOSURE_COMPILER), logging.error('fatal: Closure compiler (%s) does not exist' % shared.CLOSURE_COMPILER)

for i in range(len(newargs)):

if newargs[i] == '-s':

if is_minus_s_for_emcc(newargs, i):

settings_changes.append(newargs[i+1])

newargs[i] = newargs[i+1] = ''

elif newargs[i].startswith('--typed-arrays'):

assert '=' not in newargs[i], 'Invalid typed arrays parameter (do not use "=")'

settings_changes.append('USE_TYPED_ARRAYS=' + newargs[i+1])

newargs[i] = ''

newargs[i+1] = ''

newargs = [ arg for arg in newargs if arg is not '' ]

if split_js_file:

settings_changes.append("PRINT_SPLIT_FILE_MARKER=1")

# Find input files

input_files = []

has_source_inputs = False

lib_dirs = [shared.path_from_root('system', 'local', 'lib'),

shared.path_from_root('system', 'lib')]

libs = []

for i in range(len(newargs)): # find input files XXX this a simple heuristic. we should really analyze based on a full understanding of gcc params,

# right now we just assume that what is left contains no more |-x OPT| things

arg = newargs[i]

if i > 0:

prev = newargs[i-1]

if prev in ['-MT', '-MF', '-MQ', '-D', '-U', '-o', '-x', '-Xpreprocessor', '-include', '-imacros', '-idirafter', '-iprefix', '-iwithprefix', '-iwithprefixbefore', '-isysroot', '-imultilib', '-A', '-isystem', '-iquote', '-install_name', '-compatibility_version', '-current_version', '-I', '-L']: continue # ignore this gcc-style argument