import shutil, time, os, sys, json, tempfile, copy, shlex, atexit, subprocess, hashlib, cPickle, re, errno

from subprocess import Popen, PIPE, STDOUT

from tempfile import mkstemp

from distutils.spawn import find_executable

import jsrun, cache, tempfiles

import response_file

import logging, platform

def listify(x):

if type(x) is not list: return [x]

return x

from tempfiles import try_delete

class WindowsPopen:

return self.process.kill()

__rootpath__ = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

def path_from_root(*pathelems):

return os.path.join(__rootpath__, *pathelems)

def add_coloring_to_emit_windows(fn):

return new

def add_coloring_to_emit_ansi(fn):

return new

WINDOWS = sys.platform.startswith('win')

if WINDOWS:

logging.StreamHandler.emit = add_coloring_to_emit_windows(logging.StreamHandler.emit)

else:

logging.StreamHandler.emit = add_coloring_to_emit_ansi(logging.StreamHandler.emit)

try:

EM_CONFIG = sys.argv[sys.argv.index('--em-config')+1]

# Emscripten compiler spawns other processes, which can reimport shared.py, so make sure that

# those child processes get the same configuration file by setting it to the currently active environment.

os.environ['EM_CONFIG'] = EM_CONFIG

except:

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

if EM_CONFIG and not os.path.isfile(EM_CONFIG):

if EM_CONFIG.startswith('-'):

raise Exception('Passed --em-config without an argument. Usage: --em-config /path/to/.emscripten or --em-config EMSCRIPTEN_ROOT=/path/;LLVM_ROOT=/path;...')

if not '=' in EM_CONFIG:

raise Exception('File ' + EM_CONFIG + ' passed to --em-config does not exist!')

else:

EM_CONFIG = EM_CONFIG.replace(';', '\n') + '\n'

if not EM_CONFIG:

EM_CONFIG = '~/.emscripten'

if '\n' in EM_CONFIG:

CONFIG_FILE = None

else:

CONFIG_FILE = os.path.expanduser(EM_CONFIG)

if not os.path.exists(CONFIG_FILE):

# Note: repr is used to ensure the paths are escaped correctly on Windows.

# The full string is replaced so that the template stays valid Python.

config_file = open(path_from_root('tools', 'settings_template_readonly.py')).read().split('\n')

config_file = config_file[1:] # remove "this file will be copied..."

config_file = '\n'.join(config_file)

# autodetect some default paths

config_file = config_file.replace('\'{{{ EMSCRIPTEN_ROOT }}}\'', repr(__rootpath__))

llvm_root = os.path.dirname(find_executable('llvm-dis') or '/usr/bin/llvm-dis')

config_file = config_file.replace('\'{{{ LLVM_ROOT }}}\'', repr(llvm_root))

node = find_executable('node') or find_executable('nodejs') or 'node'

config_file = config_file.replace('\'{{{ NODE }}}\'', repr(node))

python = find_executable('python2') or find_executable('python') or \

sys.executable or 'python'

config_file = config_file.replace('\'{{{ PYTHON }}}\'', repr(python))

if WINDOWS:

tempdir = os.environ.get('TEMP') or os.environ.get('TMP') or 'c:\\temp'

else:

tempdir = '/tmp'

config_file = config_file.replace('\'{{{ TEMP }}}\'', repr(tempdir))

# write

open(CONFIG_FILE, 'w').write(config_file)

print >> sys.stderr, '''

''' % (EM_CONFIG, CONFIG_FILE, llvm_root, python, node, __rootpath__)

sys.exit(0)

try:

config_text = open(CONFIG_FILE, 'r').read() if CONFIG_FILE else EM_CONFIG

exec(config_text)

except Exception, e:

logging.error('Error in evaluating %s (at %s): %s, text: %s' % (EM_CONFIG, CONFIG_FILE, str(e), config_text))

sys.exit(1)

try:

EM_POPEN_WORKAROUND

except:

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

if EM_POPEN_WORKAROUND and os.name == 'nt':

logging.debug('Installing Popen workaround handler to avoid bug http://bugs.python.org/issue3905')

Popen = WindowsPopen

EXPECTED_LLVM_VERSION = (3,3)

actual_clang_version = None

def get_clang_version():

return actual_clang_version

def check_clang_version():

return False

def check_llvm_version():

logging.warning('Could not verify LLVM version: %s' % str(e))

def check_fastcomp():

return True

EXPECTED_NODE_VERSION = (0,8,0)

def check_node_version():

return False

def find_temp_directory():

return '/tmp'

try:

EMSCRIPTEN_VERSION = open(path_from_root('emscripten-version.txt')).read().strip()

except Exception, e:

logging.error('cannot find emscripten version ' + str(e))

EMSCRIPTEN_VERSION = 'unknown'

def generate_sanity():

return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT + '|' + get_clang_version()

def check_sanity(force=False):

print 'WARNING: sanity check failed to run', e

try:

LLVM_ADD_VERSION

except NameError:

LLVM_ADD_VERSION = os.getenv('LLVM_ADD_VERSION')

try:

CLANG_ADD_VERSION

except NameError:

CLANG_ADD_VERSION = os.getenv('CLANG_ADD_VERSION')

USING_PNACL_TOOLCHAIN = os.path.exists(os.path.join(LLVM_ROOT, 'pnacl-clang'))

def modify_prefix(tool):

return tool

def build_llvm_tool_path(tool):

return os.path.join(LLVM_ROOT, tool)

def build_clang_tool_path(tool):

return os.path.join(LLVM_ROOT, tool)

def osx_find_native_sdk_path():

return None

def get_clang_native_args():

return CACHED_CLANG_NATIVE_ARGS

CLANG_CC=os.path.expanduser(build_clang_tool_path('clang'))

CLANG_CPP=os.path.expanduser(build_clang_tool_path('clang++'))

if USING_PNACL_TOOLCHAIN:

# The PNaCl toolchain doesn't have llvm-link, but we can fake it

LINK_CMD = [build_llvm_tool_path('llvm-ld'), '-nostdlib', '-r']

else:

LINK_CMD = [build_llvm_tool_path('llvm-link')]

LLVM_AR=build_llvm_tool_path('llvm-ar')

LLVM_OPT=os.path.expanduser(build_llvm_tool_path('opt'))

LLVM_AS=os.path.expanduser(build_llvm_tool_path('llvm-as'))

LLVM_DIS=os.path.expanduser(build_llvm_tool_path('llvm-dis'))

LLVM_NM=os.path.expanduser(build_llvm_tool_path('llvm-nm'))

LLVM_INTERPRETER=os.path.expanduser(build_llvm_tool_path('lli'))

LLVM_COMPILER=os.path.expanduser(build_llvm_tool_path('llc'))

EMSCRIPTEN = path_from_root('emscripten.py')

DEMANGLER = path_from_root('third_party', 'demangler.py')

NAMESPACER = path_from_root('tools', 'namespacer.py')

EMCC = path_from_root('emcc')

EMXX = path_from_root('em++')

EMAR = path_from_root('emar')

EMRANLIB = path_from_root('emranlib')

EMCONFIG = path_from_root('em-config')

EMLINK = path_from_root('emlink.py')

EMMAKEN = path_from_root('tools', 'emmaken.py')

AUTODEBUGGER = path_from_root('tools', 'autodebugger.py')

BINDINGS_GENERATOR = path_from_root('tools', 'bindings_generator.py')

EXEC_LLVM = path_from_root('tools', 'exec_llvm.py')

FILE_PACKAGER = path_from_root('tools', 'file_packager.py')

def safe_ensure_dirs(dirname):

# There is an additional option for Python 3.x, though.

class Configuration:

save_debug_files=os.environ.get('EMCC_DEBUG_SAVE'))

def apply_configuration():

TEMP_DIR = configuration.TEMP_DIR

apply_configuration()

logging.basicConfig(format='%(levelname)-8s %(name)s: %(message)s')

def set_logging():

logger = logging.getLogger()

logger.setLevel(logging.DEBUG if os.environ.get('EMCC_DEBUG') else logging.INFO)

set_logging()

if not EMSCRIPTEN_TEMP_DIR:

EMSCRIPTEN_TEMP_DIR = tempfile.mkdtemp(prefix='emscripten_temp_', dir=configuration.TEMP_DIR)

def prepare_to_clean_temp(d):

def clean_temp():

try_delete(d)

atexit.register(clean_temp)

prepare_to_clean_temp(EMSCRIPTEN_TEMP_DIR) # this global var might change later

try:

JS_ENGINES

except:

try:

JS_ENGINES = [JS_ENGINE]

except Exception, e:

print 'ERROR: %s does not seem to have JS_ENGINES or JS_ENGINE set up' % EM_CONFIG

raise

try:

CLOSURE_COMPILER

except:

CLOSURE_COMPILER = path_from_root('third_party', 'closure-compiler', 'compiler.jar')

try:

PYTHON

except:

logging.debug('PYTHON not defined in ~/.emscripten, using "python"')

PYTHON = 'python'

try:

JAVA

except:

logging.debug('JAVA not defined in ~/.emscripten, using "java"')

JAVA = 'java'

def get_llvm_target():

return os.environ.get('EMCC_LLVM_TARGET') or 'asmjs-unknown-emscripten'

LLVM_TARGET = get_llvm_target()

try:

COMPILER_OPTS # Can be set in EM_CONFIG, optionally

except:

COMPILER_OPTS = []

COMPILER_OPTS = COMPILER_OPTS + [#'-fno-threadsafe-statics', # disabled due to issue 1289

'-target', LLVM_TARGET]

COMPILER_STANDARDIZATION_OPTS = []

if LLVM_TARGET != 'asmjs-unknown-emscripten' and LLVM_TARGET != 'le32-unknown-nacl':

COMPILER_OPTS += ['-m32']

COMPILER_STANDARDIZATION_OPTS += ['-U__i386__', '-U__i386', '-Ui386',

'-U__SSE__', '-U__SSE_MATH__', '-U__SSE2__', '-U__SSE2_MATH__', '-U__MMX__',

'-U__APPLE__', '-U__linux__']

if LLVM_TARGET != 'asmjs-unknown-emscripten':

COMPILER_OPTS += ['-fno-math-errno']

COMPILER_STANDARDIZATION_OPTS += ['-D__IEEE_LITTLE_ENDIAN']

COMPILER_OPTS += ['-DEMSCRIPTEN', '-D__EMSCRIPTEN__', '-fno-math-errno',

'-U__native_client__', '-U__pnacl__', '-U__ELF__']

if LLVM_TARGET == 'asmjs-unknown-emscripten' or LLVM_TARGET == 'le32-unknown-nacl':

# Implicit functions can cause horribly confusing asm.js function pointer type errors, see #2175

# If your codebase really needs them - very unrecommended! - you can disable the error with

# -Wno-error=implicit-function-declaration

# or disable even a warning about it with

# -Wno-implicit-function-declaration

COMPILER_OPTS += ['-Werror=implicit-function-declaration']

USE_EMSDK = not os.environ.get('EMMAKEN_NO_SDK')

if USE_EMSDK:

# Disable system C and C++ include directories, and add our own (using -idirafter so they are last, like system dirs, which

# allows projects to override them)

C_INCLUDE_PATHS = [path_from_root('system', 'local', 'include'),

path_from_root('system', 'include', 'compat'),

path_from_root('system', 'include'),

path_from_root('system', 'include', 'emscripten'),

path_from_root('system', 'include', 'libc'),

path_from_root('system', 'include', 'gfx'),

path_from_root('system', 'include', 'SDL'),

]

CXX_INCLUDE_PATHS = [path_from_root('system', 'include', 'libcxx')

]

C_OPTS = ['-nostdinc', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc',

]

def include_directive(paths):

return result

EMSDK_OPTS = C_OPTS + include_directive(C_INCLUDE_PATHS) + include_directive(CXX_INCLUDE_PATHS)

EMSDK_OPTS += COMPILER_STANDARDIZATION_OPTS

# For temporary compatibility, treat 'le32-unknown-nacl' as 'asmjs-unknown-emscripten'.

if LLVM_TARGET != 'asmjs-unknown-emscripten' and \

LLVM_TARGET != 'le32-unknown-pnacl':

EMSDK_CXX_OPTS = ['-nostdinc++'] # asmjs-unknown-emscripten target does not need -nostdinc++

else:

EMSDK_CXX_OPTS = []

COMPILER_OPTS += EMSDK_OPTS

else:

EMSDK_OPTS = []

EMSDK_CXX_OPTS = []

COMPILER_OPTS += COMPILER_STANDARDIZATION_OPTS

try:

if SPIDERMONKEY_ENGINE:

new_spidermonkey = listify(SPIDERMONKEY_ENGINE)

if 'gcparam' not in str(new_spidermonkey):

new_spidermonkey += ['-e', "gcparam('maxBytes', 1024*1024*1024);"] # Our very large files need lots of gc heap

if '-w' not in str(new_spidermonkey):

new_spidermonkey += ['-w']

JS_ENGINES = map(lambda x: new_spidermonkey if x == SPIDERMONKEY_ENGINE else x, JS_ENGINES)

SPIDERMONKEY_ENGINE = new_spidermonkey

except NameError:

pass

ENV_PREFIX = []

if not WINDOWS:

try:

assert 'Python' in Popen(['env', 'python', '-V'], stdout=PIPE, stderr=STDOUT).communicate()[0]

ENV_PREFIX = ['env']

except:

pass

def check_engine(engine):

return False

def run_js(filename, engine=None, *args, **kw):

if engine is None:

engine = JS_ENGINES[0]

return jsrun.run_js(filename, engine, *args, **kw)

def to_cc(cxx):

# By default, LLVM_GCC and CLANG are really the C++ versions. This gets an explicit C version

return cxx.replace('clang++', 'clang').replace('g++', 'gcc')

def line_splitter(data):

return out

def limit_size(string, MAX=800*20):

if len(string) < MAX: return string

return string[0:MAX/2] + '\n[..]\n' + string[-MAX/2:]

def read_pgo_data(filename):

}

def unique_ordered(values): # return a list of unique values in an input list, without changing order (list(set(.)) would change order randomly)

return filter(check, values)

def expand_response(data):

if type(data) == str and data[0] == '@':

return json.loads(open(data[1:]).read())

return data

class Settings2(type):

return setattr(self.instance(), attr, value)

class Settings(object):

__metaclass__ = Settings2

class Building: