~ubuntu-branches/ubuntu/trusty/emscripten/trusty-proposed

from subprocess import Popen, PIPE, STDOUT

from tempfile import mkstemp

from distutils.spawn import find_executable

import jsrun, cache, tempfiles

import logging, platform

 

def listify(x):

    # emscripten.py supports reading args from a response file instead of cmdline.

    # Use .rsp to avoid cmdline length limitations on Windows.

    if len(args) >= 2 and args[1].endswith("emscripten.py"):

      

    try:

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

    except Exception, e:

      logging.error('\nsubprocess.Popen(args=%s) failed! Exception %s\n' % (' '.join(args), str(e)))

      raise e

  def kill(self):

    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)

else:

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

 

# Emscripten.  Otherwise, the string is understood to be a path to a settings

# file that contains the required definitions.

 

if not EM_CONFIG:

  EM_CONFIG = '~/.emscripten'

if '\n' in EM_CONFIG:

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

  sys.exit(1)

 

# Expectations

 

EXPECTED_LLVM_VERSION = (3,2)

 

def check_clang_version():

  if expected in actual:

    return True

  logging.warning('LLVM version appears incorrect (seeing "%s", expected "%s")' % (actual, expected))

  except Exception, e:

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

 

EXPECTED_NODE_VERSION = (0,8,0)

 

def check_node_version():

  try:

    node = listify(NODE_JS)

    actual = Popen(node + ['--version'], stdout=PIPE).communicate()[0].strip()

    if version >= EXPECTED_NODE_VERSION:

      return True

    logging.warning('node version appears too old (seeing "%s", expected "%s")' % (actual, 'v' + ('.'.join(map(str, EXPECTED_NODE_VERSION)))))

# we re-check sanity when the settings are changed)

# We also re-check sanity and clear the cache when the version changes

 

 

def generate_sanity():

 

def check_sanity(force=False):

  try:

    reason = None

    if not CONFIG_FILE:

    else:

      settings_mtime = os.stat(CONFIG_FILE).st_mtime

      sanity_file = CONFIG_FILE + '_sanity'

      Cache.erase()

      force = False # the check actually failed, so definitely write out the sanity file, to avoid others later seeing failures too

 

    check_llvm_version()

    check_node_version()

 

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

      logging.info('EM_IGNORE_SANITY set, ignoring sanity checks')

        logging.critical('Node.js (%s) does not seem to work, check the paths in %s' % (NODE_JS, EM_CONFIG))

        sys.exit(1)

 

      if not os.path.exists(cmd) and not os.path.exists(cmd + '.exe'): # .exe extension required for Windows

        logging.critical('Cannot find %s, check the paths in %s' % (cmd, EM_CONFIG))

        sys.exit(1)

 

    try:

      subprocess.call([JAVA, '-version'], stdout=PIPE, stderr=PIPE)

    except:

 

# Temp dir. Create a random one, unless EMCC_DEBUG is set, in which case use TEMP_DIR/emscripten_temp

 

class Configuration:

  def __init__(self, environ=os.environ):

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

    if self.DEBUG:

      try:

        self.EMSCRIPTEN_TEMP_DIR = self.CANONICAL_TEMP_DIR

      except Exception, e:

 

  def get_temp_files(self):

    return tempfiles.TempFiles(

  try:

    if not CONFIG_FILE:

      return True # config stored directly in EM_CONFIG => skip engine check

  except Exception, e:

    print 'Checking JS engine %s failed. Check %s. Details: %s' % (str(engine), EM_CONFIG, str(e))

    return False

 

  return out

 

  if len(string) < MAX: return string

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

 

        self.attrs['ASM_JS'] = 1

        self.attrs['ASSERTIONS'] = 0

        self.attrs['DISABLE_EXCEPTION_CATCHING'] = 1

        self.attrs['RELOOP'] = 1

        self.attrs['ALIASING_FUNCTION_POINTERS'] = 1

      if opt_level >= 3:

 

 

  @staticmethod

    ''' Build a library into a .bc file. We build the .bc file once and cache it for all our tests. (We cache in

        memory since the test directory is destroyed and recreated for each test. Note that we cache separately

        for different compilers).

 

    if type(generated_libs) is not list: generated_libs = [generated_libs]

    if source_dir is None: source_dir = path_from_root('tests', name.replace('_native', ''))

 

    temp_dir = build_dir

    if copy_project:

        try:

          temp_dir = os.path.join(EMSCRIPTEN_TEMP_DIR, 'ar_output_' + str(os.getpid()) + '_' + str(len(temp_dirs)))

          temp_dirs.append(temp_dir)

          os.chdir(temp_dir)

          contents = filter(lambda x: len(x) > 0, Popen([LLVM_AR, 't', f], stdout=PIPE).communicate()[0].split('\n'))

          #print >> sys.stderr, '  considering archive', f, ':', contents

          else:

            for content in contents: # ar will silently fail if the directory for the file does not exist, so make all the necessary directories

              dirname = os.path.dirname(content)

            contents = map(lambda content: os.path.join(temp_dir, content), contents)

            contents = filter(os.path.exists, map(os.path.abspath, contents))

            added_contents = set()

    # 8k is a bit of an arbitrary limit, but a reasonable one

    # for max command line size before we use a respose file

    response_file = None

      logging.debug('using response file for llvm-link')

      [response_fd, response_file] = mkstemp(suffix='.response', dir=TEMP_DIR)

 

  # @param opt Either an integer, in which case it is the optimization level (-O1, -O2, etc.), or a list of raw

  #            optimization passes passed to llvm opt

  @staticmethod

    if type(opts) is int:

      opts = Building.pick_llvm_opts(opts)

    #opts += ['-debug-pass=Arguments']

    logging.debug('emcc: LLVM opts: ' + str(opts))

 

  @staticmethod

  def llvm_opts(filename): # deprecated version, only for test runner. TODO: remove

    # Run Emscripten

    Settings.RELOOPER = Cache.get_path('relooper.js')

    settings = Settings.serialize()

    #print compiler_output

 

    # Detect compilation crashes and errors

    if not os.path.exists(CLOSURE_COMPILER):

      raise Exception('Closure compiler appears to be missing, looked at: ' + str(CLOSURE_COMPILER))

 

    # Something like this (adjust memory as needed):

    #   java -Xmx1024m -jar CLOSURE_COMPILER --compilation_level ADVANCED_OPTIMIZATIONS --variable_map_output_file src.cpp.o.js.vars --js src.cpp.o.js --js_output_file src.cpp.o.cc.js

    args = [JAVA,

            '-jar', CLOSURE_COMPILER,

            '--compilation_level', 'ADVANCED_OPTIMIZATIONS',

            '--language_in', 'ECMASCRIPT5',

            #'--variable_map_output_file', filename + '.vars',

            '--js', filename, '--js_output_file', filename + '.cc.js']

    if pretty: args += ['--formatting', 'PRETTY_PRINT']

  @staticmethod

  def ensure_relooper(relooper):

    if os.path.exists(relooper): return

    Cache.ensure()

    curr = os.getcwd()

    try:

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

      if emcc_debug: del os.environ['EMCC_DEBUG']

 

        raw = relooper + '.raw.js'

        Building.emcc(os.path.join('relooper', 'Relooper.cpp'), ['-I' + os.path.join('relooper'), '--post-js',

          os.path.join('relooper', 'emscripten', 'glue.js'),

          '-s', 'EXPORTED_FUNCTIONS=["_rl_set_output_buffer","_rl_make_output_buffer","_rl_new_block","_rl_delete_block","_rl_block_add_branch_to","_rl_new_relooper","_rl_delete_relooper","_rl_relooper_add_block","_rl_relooper_calculate","_rl_relooper_render", "_rl_set_asm_js_mode"]',

          '-s', 'DEFAULT_LIBRARY_FUNCS_TO_INCLUDE=["memcpy", "memset", "malloc", "free", "puts"]',

          '-s', 'RELOOPER="' + relooper + '"',

          '-O' + str(opt_level), '--closure', '0'], raw)

        f = open(relooper, 'w')

        f.write("// Relooper, (C) 2012 Alon Zakai, MIT license, https://github.com/kripken/Relooper\n")

        f.write(open(raw).read())

        f.write('\n  return Module.Relooper;\n')

        f.close()

 

      # bootstrap phase 1: generate unrelooped relooper, for which we do not need a relooper (so we cannot recurse infinitely in this function)

      logging.info('  bootstrap phase 1')

      # bootstrap phase 2: generate relooped relooper, using the unrelooped relooper (we see relooper.js exists so we cannot recurse infinitely in this function)

      logging.info('  bootstrap phase 2')

      logging.info('bootstrapping relooper succeeded')

      logging.info('=======================================')

      ok = True

    finally:

      os.chdir(curr)

      if emcc_debug: os.environ['EMCC_DEBUG'] = emcc_debug

      if not ok:

        logging.error('bootstrapping relooper failed. You may need to manually create relooper.js by compiling it, see src/relooper/emscripten')

        1/0

  @staticmethod

  def preprocess(infile, outfile):

    '''

      text = m.groups(0)[0]

      assert text.count('(') == 1 and text.count(')') == 1, 'must have simple expressions in emscripten_jcache_printf calls, no parens'

      assert text.count('"') == 2, 'must have simple expressions in emscripten_jcache_printf calls, no strings as varargs parameters'

      start = text.index('(')

      end = text.rindex(')')

      args = text[start+1:end].split(',')

 

  @staticmethod

  def to_nice_ident(ident): # limited version of the JS function toNiceIdent

 

  @staticmethod

  def make_extcall(sig, named=True):