webruby 0.1.0

data/modules/emscripten/tools/node_modules/source-map/test/source-map/util.js

@@ -0,0 +1,152 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module);
+}
+define(function (require, exports, module) {
+
+  var util = require('../../lib/source-map/util');
+
+  // This is a test mapping which maps functions from two different files
+  // (one.js and two.js) to a minified generated source.
+  //
+  // Here is one.js:
+  //
+  //   ONE.foo = function (bar) {
+  //     return baz(bar);
+  //   };
+  //
+  // Here is two.js:
+  //
+  //   TWO.inc = function (n) {
+  //     return n + 1;
+  //   };
+  //
+  // And here is the generated code (min.js):
+  //
+  //   ONE.foo=function(a){return baz(a);};
+  //   TWO.inc=function(a){return a+1;};
+  exports.testGeneratedCode = " ONE.foo=function(a){return baz(a);};\n"+
+                              " TWO.inc=function(a){return a+1;};";
+  exports.testMap = {
+    version: 3,
+    file: 'min.js',
+    names: ['bar', 'baz', 'n'],
+    sources: ['one.js', 'two.js'],
+    sourceRoot: '/the/root',
+    mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+  };
+  exports.testMapWithSourcesContent = {
+    version: 3,
+    file: 'min.js',
+    names: ['bar', 'baz', 'n'],
+    sources: ['one.js', 'two.js'],
+    sourcesContent: [
+      ' ONE.foo = function (bar) {\n' +
+      '   return baz(bar);\n' +
+      ' };',
+      ' TWO.inc = function (n) {\n' +
+      '   return n + 1;\n' +
+      ' };'
+    ],
+    sourceRoot: '/the/root',
+    mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+  };
+
+  function assertMapping(generatedLine, generatedColumn, originalSource,
+                         originalLine, originalColumn, name, map, assert,
+                         dontTestGenerated, dontTestOriginal) {
+    if (!dontTestOriginal) {
+      var origMapping = map.originalPositionFor({
+        line: generatedLine,
+        column: generatedColumn
+      });
+      assert.equal(origMapping.name, name,
+                   'Incorrect name, expected ' + JSON.stringify(name)
+                   + ', got ' + JSON.stringify(origMapping.name));
+      assert.equal(origMapping.line, originalLine,
+                   'Incorrect line, expected ' + JSON.stringify(originalLine)
+                   + ', got ' + JSON.stringify(origMapping.line));
+      assert.equal(origMapping.column, originalColumn,
+                   'Incorrect column, expected ' + JSON.stringify(originalColumn)
+                   + ', got ' + JSON.stringify(origMapping.column));
+
+      var expectedSource;
+
+      if (originalSource && map.sourceRoot && originalSource.indexOf(map.sourceRoot) === 0) {
+        expectedSource = originalSource;
+      } else if (originalSource) {
+        expectedSource = map.sourceRoot
+          ? util.join(map.sourceRoot, originalSource)
+          : originalSource;
+      } else {
+        expectedSource = null;
+      }
+
+      assert.equal(origMapping.source, expectedSource,
+                   'Incorrect source, expected ' + JSON.stringify(expectedSource)
+                   + ', got ' + JSON.stringify(origMapping.source));
+    }
+
+    if (!dontTestGenerated) {
+      var genMapping = map.generatedPositionFor({
+        source: originalSource,
+        line: originalLine,
+        column: originalColumn
+      });
+      assert.equal(genMapping.line, generatedLine,
+                   'Incorrect line, expected ' + JSON.stringify(generatedLine)
+                   + ', got ' + JSON.stringify(genMapping.line));
+      assert.equal(genMapping.column, generatedColumn,
+                   'Incorrect column, expected ' + JSON.stringify(generatedColumn)
+                   + ', got ' + JSON.stringify(genMapping.column));
+    }
+  }
+  exports.assertMapping = assertMapping;
+
+  function assertEqualMaps(assert, actualMap, expectedMap) {
+    assert.equal(actualMap.version, expectedMap.version, "version mismatch");
+    assert.equal(actualMap.file, expectedMap.file, "file mismatch");
+    assert.equal(actualMap.names.length,
+                 expectedMap.names.length,
+                 "names length mismatch: " +
+                   actualMap.names.join(", ") + " != " + expectedMap.names.join(", "));
+    for (var i = 0; i < actualMap.names.length; i++) {
+      assert.equal(actualMap.names[i],
+                   expectedMap.names[i],
+                   "names[" + i + "] mismatch: " +
+                     actualMap.names.join(", ") + " != " + expectedMap.names.join(", "));
+    }
+    assert.equal(actualMap.sources.length,
+                 expectedMap.sources.length,
+                 "sources length mismatch: " +
+                   actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", "));
+    for (var i = 0; i < actualMap.sources.length; i++) {
+      assert.equal(actualMap.sources[i],
+                   expectedMap.sources[i],
+                   "sources[" + i + "] length mismatch: " +
+                   actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", "));
+    }
+    assert.equal(actualMap.sourceRoot,
+                 expectedMap.sourceRoot,
+                 "sourceRoot mismatch: " +
+                   actualMap.sourceRoot + " != " + expectedMap.sourceRoot);
+    assert.equal(actualMap.mappings, expectedMap.mappings, "mappings mismatch");
+    if (actualMap.sourcesContent) {
+      assert.equal(actualMap.sourcesContent.length,
+                   expectedMap.sourcesContent.length,
+                   "sourcesContent length mismatch");
+      for (var i = 0; i < actualMap.sourcesContent.length; i++) {
+        assert.equal(actualMap.sourcesContent[i],
+                     expectedMap.sourcesContent[i],
+                     "sourcesContent[" + i + "] mismatch");
+      }
+    }
+  }
+  exports.assertEqualMaps = assertEqualMaps;
+
+});

data/modules/emscripten/tools/reproduceriter.js

@@ -0,0 +1,216 @@
+
+var Recorder = (function() {
+  var recorder;
+  var init = 'reproduce=';
+  var initLocation = window.location.search.indexOf(init);
+  var replaying = initLocation >= 0;
+  var raf = window['requestAnimationFrame'] ||
+            window['mozRequestAnimationFrame'] ||
+            window['webkitRequestAnimationFrame'] ||
+            window['msRequestAnimationFrame'] ||
+            window['oRequestAnimationFrame'];
+  if (!replaying) {
+    // Prepare to record
+    recorder = {};
+    // Start
+    recorder.frameCounter = 0; // the frame counter is used to know when to replay events
+    recorder.start = function() {
+      alert("Starting recording! Don't forget to Recorder.finish() afterwards!");
+      function count() {
+        recorder.frameCounter++;
+        raf(count);
+      }
+      count();
+      recorder.started = true;
+    };
+    // Math.random
+    recorder.randoms = [];
+    recorder.random = Math.random;
+    Math.random = function() {
+      var ret = recorder.random();
+      recorder.randoms.push(ret);
+      return ret;
+    };
+    // Date.now, performance.now
+    recorder.dnows = [];
+    recorder.dnow = Date.now;
+    Date.now = function() {
+      var ret = recorder.dnow();
+      recorder.dnows.push(ret);
+      return ret;
+    };
+    recorder.pnows = [];
+    var pnow = performance.now || performance.webkitNow || performance.mozNow || performance.oNow || performance.msNow;
+    recorder.pnow = function() { return pnow.call(performance) };
+    performance.now = function() {
+      var ret = recorder.pnow();
+      recorder.pnows.push(ret);
+      return ret;
+    };
+    // Events
+    recorder.devents = []; // document events
+    recorder.onEvent = function(which, callback) {
+      document['on' + which] = function(event) {
+        if (!recorder.started) return true;
+        event.frameCounter = recorder.frameCounter;
+        recorder.devents.push(event);
+        return callback(event); // XXX do we need to record the return value?
+      };
+    };
+    recorder.tevents = []; // custom-target events. Currently we assume a single such custom target (aside from document), e.g., a canvas for the game.
+    recorder.addListener = function(target, which, callback, arg) {
+      target.addEventListener(which, function(event) {
+        if (!recorder.started) return true;
+        event.frameCounter = recorder.frameCounter;
+        recorder.tevents.push(event);
+        return callback(event); // XXX do we need to record the return value?
+      }, arg);
+    };
+    // Finish
+    recorder.finish = function() {
+      // Reorder data because pop() is faster than shift()
+      recorder.randoms.reverse();
+      recorder.dnows.reverse();
+      recorder.pnows.reverse();
+      recorder.devents.reverse();
+      recorder.tevents.reverse();
+      // Make JSON.stringify work on data from native event objects (and only store relevant ones)
+      var importantProperties = {
+        type: 1,
+        movementX: 1, mozMovementX: 1, webkitMovementX: 1,
+        movementY: 1, mozMovementY: 1, webkitMovementY: 1,
+        detail: 1,
+        wheelDelta: 1,
+        pageX: 1,
+        pageY: 1,
+        button: 1,
+        keyCode: 1,
+        frameCounter: 1
+      };
+      function importantize(event) {
+        var ret = {};
+        for (var prop in importantProperties) {
+          if (prop in event) {
+            ret[prop] = event[prop];
+          }
+        }
+        return ret;
+      }
+      recorder.devents = recorder.devents.map(importantize);
+      recorder.tevents = recorder.tevents.map(importantize);
+      // Write out
+      alert('Writing out data, remember to save!');
+      setTimeout(function() {
+        document.open();
+        document.write(JSON.stringify(recorder));
+        document.close();
+      }, 0);
+      return '.';
+    };
+  } else {
+    // Load recording
+    var dataPath = window.location.search.substring(initLocation + init.length);
+    var baseURL = window.location.toString().replace('://', 'cheez999').split('?')[0].split('/').slice(0, -1).join('/').replace('cheez999', '://');
+    if (baseURL[baseURL.length-1] != '/') baseURL += '/';
+    var path = baseURL + dataPath;
+    alert('Loading replay from ' + path);
+    var request = new XMLHttpRequest();
+    request.open('GET', path, false);
+    request.send();
+    var raw = request.responseText;
+    raw = raw.substring(raw.indexOf('{'), raw.lastIndexOf('}')+1); // remove <html> etc
+    recorder = JSON.parse(raw);
+    // prepare to replay
+    // Start
+    recorder.frameCounter = 0; // the frame counter is used to know when to replay events
+    recorder.start = function() {
+      function count() {
+        recorder.frameCounter++;
+        raf(count);
+        // replay relevant events for this frame
+        while (recorder.devents.length && recorder.devents[recorder.devents.length-1].frameCounter <= recorder.frameCounter) {
+          var event = recorder.devents.pop();
+          recorder['on' + event.type](event);
+        }
+        while (recorder.tevents.length && recorder.tevents[recorder.tevents.length-1].frameCounter <= recorder.frameCounter) {
+          var event = recorder.tevents.pop();
+          recorder['event' + event.type](event);
+        }
+      }
+      count();
+    };
+    // Math.random
+    recorder.random = Math.random;
+    Math.random = function() {
+      if (recorder.randoms.length > 0) {
+        return recorder.randoms.pop();
+      } else {
+        recorder.finish();
+        throw 'consuming too many random values!';
+      }
+    };
+    // Date.now, performance.now
+    recorder.dnow = Date.now;
+    Date.now = function() {
+      if (recorder.dnows.length > 0) {
+        return recorder.dnows.pop();
+      } else {
+        recorder.finish();
+        throw 'consuming too many Date.now values!';
+      }
+    };
+    var pnow = performance.now || performance.webkitNow || performance.mozNow || performance.oNow || performance.msNow;
+    recorder.pnow = function() { return pnow.call(performance) };
+    performance.now = function() {
+      if (recorder.pnows.length > 0) {
+        return recorder.pnows.pop();
+      } else {
+        recorder.finish();
+        throw 'consuming too many performance.now values!';
+      }
+    };
+    // Events
+    recorder.onEvent = function(which, callback) {
+      recorder['on' + which] = callback;
+    };
+    recorder.eventCallbacks = {};
+    recorder.addListener = function(target, which, callback, arg) {
+      recorder['event' + which] = callback;
+    };
+    recorder.onFinish = [];
+    // Benchmarking hooks - emscripten specific
+    setTimeout(function() {
+      var totalTime = 0;
+      var totalSquared = 0;
+      var iterations = 0;
+      var maxTime = 0;
+      var curr = 0;
+      Module.preMainLoop = function() {
+        curr = recorder.pnow();
+      }
+      Module.postMainLoop = function() {
+        var time = recorder.pnow() - curr;
+        totalTime += time;
+        totalSquared += time*time;
+        maxTime = Math.max(maxTime, time);
+        iterations++;
+      };
+      recorder.onFinish.push(function() {
+        var mean = totalTime / iterations;
+        var meanSquared = totalSquared / iterations;
+        console.log('mean frame   : ' + mean + ' ms');
+        console.log('frame std dev: ' + Math.sqrt(meanSquared - (mean*mean)) + ' ms');
+        console.log('max frame    : ' + maxTime + ' ms');
+      });    
+    });
+    // Finish
+    recorder.finish = function() {
+      recorder.onFinish.forEach(function(finish) {
+        finish();
+      });
+    };
+  }
+  recorder.replaying = replaying;
+  return recorder;
+})();
+

data/modules/emscripten/tools/reproduceriter.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python2
+
+'''
+Reproducer Rewriter
+===================
+
+Processes a project and rewrites it so as to generate deterministic,
+reproducible automatic results. For example, you can run this on a
+game, and then when the game is run it will record user input and
+sources of nondeterminism like Math.random(). You can then run
+that recording as a benchmark or as a demo, it should give nearly
+identical results every time it is run to the data that was
+recorded.
+
+Usage:
+
+1. Run this script as
+
+    reproduceriter.py IN_DIR OUT_DIR FIRST_JS [WINDOW_LOCATION] [ON_IDLE]
+
+   IN_DIR should be the project directory, and OUT_DIR will be
+   created with the instrumented code (OUT_DIR will be overwritten
+   if it exists). FIRST_JS should be a path (relative to IN_DIR) to
+   the first JavaScript file loaded by the project (this tool
+   will add code to that). The last two parameters, WINDOW_LOCATION
+   and ON_IDLE, are relevant for shell builds. If WINDOW_LOCATION is
+   specified, we will make a build that runs in the shell and not in
+   a browser. WINDOW_LOCATION is the fake window.location we set in the
+   fake DOM, and ON_IDLE is code that runs when the fake main browser
+   event loop runs out of actions. (Note that only a browser build can
+   do recording, shell builds just replay.)
+
+   You will need to call
+
+    Recorder.start();
+
+   at the right time to start the relevant event loop. For
+   example, if your application is a game that starts receiving
+   events when in fullscreen, add something like
+
+    if (typeof Recorder != 'undefined') Recorder.start();
+
+   in the button that launches fullscreen. start() will start
+   either recording when in record mode, or replaying when
+   in replay mode, so you need this in both modes.
+
+2. Run the instrumented project in OUR_DIR and interact with
+   the program. When you are done recording, open the web
+   console and run
+
+    Recorder.finish();
+
+   This will write out the recorded data into the current tab.
+   Save it as
+
+    repro.data
+
+   in OUT_DIR.
+
+3. To re-play the recorded data, run the instrumented build
+   with
+
+    &reproduce=repro.data
+
+   Note that as mentioned above you need to call
+
+    Recorder.start();
+
+   when the recorded event loop should start to replay.
+
+Notes:
+
+ * When we start to replay events, the assumption is that
+   there is nothing asynchronous that affects execution. So
+   asynchronous loading of files should have already
+   completed.
+
+   TODO: start running recorded events with some trigger, for example the fullscreen button in BananaBread
+
+Examples
+
+ * BananaBread: Unpack into a directory called bb, then one
+   directory up, run
+
+    emscripten/tools/reproduceriter.py bb bench js/game-setup.js game.html?low,low,reproduce=repro.data "function(){ print('triggering click'); document.querySelector('.fullscreen-button.low-res').callEventListeners('click'); window.onIdle = null; }"
+
+   for a shell build, or
+
+    emscripten/tools/reproduceriter.py bb bench js/game-setup.js 
+
+   for a browser build. Since only a browser build can do recording, you would normally
+   make a browser build, record a trace, then make a shell build and copy the trace
+   there so you can run it.
+
+   The last parameter specifies what to do when the event loop is idle: We fire an event and then set onIdle (which was this function) to null, so this is a one-time occurence.
+
+Notes
+
+ * Replay can depend on browser state. One case is if you are replaying a fullscreen
+   game with pointer lock, then you will need to manually allow pointer lock if it
+   isn't already on for the machine. If you do it too early or too late, the replay
+   can be different, since mousemove events mean different things depending on
+   whether the pointer is locked or not.
+
+'''
+
+import os, sys, shutil, re
+
+assert len(sys.argv) >= 4, 'Usage: reproduceriter.py IN_DIR OUT_DIR FIRST_JS [WINDOW_LOCATION]'
+
+# Process input args
+
+in_dir = sys.argv[1]
+out_dir = sys.argv[2]
+first_js = sys.argv[3]
+window_location = sys.argv[4] if len(sys.argv) >= 5 else ''
+on_idle = sys.argv[5] if len(sys.argv) >= 6 else ''
+
+shell = not not window_location
+
+dirs_to_drop = 0 if not os.path.dirname(first_js) else len(os.path.dirname(first_js).split('/'))
+
+if os.path.exists(out_dir):
+  shutil.rmtree(out_dir)
+assert os.path.exists(os.path.join(in_dir, first_js))
+
+# Copy project
+
+print 'copying tree...'
+
+shutil.copytree(in_dir, out_dir)
+
+# Add customizations in all JS files
+
+print 'add customizations...'
+
+for parent, dirs, files in os.walk(out_dir):
+  for filename in files:
+    if filename.endswith('.js'):
+      fullname = os.path.join(parent, filename)
+      print '   ', fullname
+      js = open(fullname).read()
+      js = re.sub('document\.on(\w+) ?= ?([\w.$]+)', lambda m: 'Recorder.onEvent("' + m.group(1) + '", ' + m.group(2) + ')', js)
+      js = re.sub('''([\w.'"\[\]]+)\.addEventListener\(([\w,. $]+)\)''', lambda m: 'Recorder.addListener(' + m.group(1) + ', ' + m.group(2) + ')', js)
+      open(fullname, 'w').write(js)
+
+# Add our boilerplate
+
+print 'add boilerplate...'
+
+open(os.path.join(out_dir, first_js), 'w').write(
+  (open(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src', 'headless.js')).read() % (
+    window_location, window_location.split('?')[-1], on_idle or 'null', dirs_to_drop
+  ) if shell else '') +
+  open(os.path.join(os.path.dirname(__file__), 'reproduceriter.js')).read() +
+  open(os.path.join(in_dir, first_js)).read() + ('\nwindow.runEventLoop();\n' if shell else '')
+)
+
+print 'done!'
+

data/modules/emscripten/tools/response_file.py

@@ -0,0 +1,28 @@
+import tempfile, os, sys, shlex
+
+# Routes the given cmdline param list in args into a new response file and returns the filename to it.
+# The returned filename has a suffix '.rsp'.
+def create_response_file(args, directory):
+  (response_fd, response_filename) = tempfile.mkstemp(prefix='emscripten_', suffix='.rsp', dir=directory, text=True)
+  response_fd = os.fdopen(response_fd, "w")
+  #print >> sys.stderr, "Creating response file '%s'" % response_filename
+  args = map(lambda p: p.replace(' ', '').replace('\\', '\\\\').replace('"', '\\"'), args)
+  response_fd.write(' '.join(args))
+  response_fd.close()
+  return response_filename
+
+# Reads a response file, and returns the list of cmdline params found in the file.
+# The parameter response_filename may start with '@'.
+def read_response_file(response_filename):
+  if response_filename.startswith('@'):
+    response_filename = response_filename[1:]
+
+  #print >> sys.stderr, "Using response file '%s'" % response_filename
+  if not os.path.exists(response_filename):
+    raise Exception("Response file '%s' not found!" % response_filename)
+
+  response_fd = open(response_filename, 'r')
+  args = response_fd.read()
+  response_fd.close()
+  args = shlex.split(args)
+  return args

data/modules/emscripten/tools/scan_js.py

@@ -0,0 +1,20 @@
+'''
+Finds why a .js file is large by printing functions by size
+'''
+
+import os, sys
+
+funcs = []
+i = 0
+inside = None
+for line in open(sys.argv[1]):
+  i += 1
+  if line.startswith('function _'):
+    inside = line.replace('function ', '').replace('\n', '')
+    start = i
+  elif inside and line.startswith('}'):
+    funcs.append((inside, i-start))
+    inside = None
+
+print '\n'.join(map(lambda func: str(func[1]) + ':' + func[0], sorted(funcs, key=lambda func: -func[1])))
+

data/modules/emscripten/tools/scan_ll.py

@@ -0,0 +1,18 @@
+'''
+Finds why an .ll file is large by printing functions by size
+'''
+
+import os, sys
+
+funcs = []
+i = 0
+for line in open(sys.argv[1]):
+  i += 1
+  if line.startswith('define '):
+    inside = line.replace('define ', '').replace('\n', '')
+    start = i
+  elif line.startswith('}'):
+    funcs.append((inside, i-start))
+
+print '\n'.join(map(lambda func: str(func[1]) + ':' + func[0], sorted(funcs, key=lambda func: -func[1])))
+

data/modules/emscripten/tools/scons/site_scons/site_tools/emscripten/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python2
+
+from emscripten import exists, generate

data/modules/emscripten/tools/scons/site_scons/site_tools/emscripten/emscripten.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python2
+
+import os
+
+def generate(env, emscripten_path=None, **kw):
+	""" SCons tool entry point """
+
+	if emscripten_path is None:
+		# Try to find emscripten
+		# Use same method as Emscripten's shared.py
+		EM_CONFIG = os.environ.get('EM_CONFIG')
+		if not EM_CONFIG:
+			EM_CONFIG = '~/.emscripten'
+		
+		CONFIG_FILE = os.path.expanduser(EM_CONFIG)
+		try:
+			exec(open(CONFIG_FILE, 'r').read())
+		except Exception, e:
+  			print >> sys.stderr, 'Error in evaluating %s (at %s): %s' % (EM_CONFIG, CONFIG_FILE, str(e))
+  			sys.exit(1)
+  		
+  		emscripten_path = EMSCRIPTEN_ROOT
+
+	env['EMSCRIPTEN_ROOT'] = emscripten_path
+	
+	try:
+		emscPath = emscripten_path.abspath
+	except:
+		emscPath = emscripten_path
+	
+	env.Replace(CC     = os.path.join(emscPath, "emcc"    ))
+	env.Replace(CXX    = os.path.join(emscPath, "em++"    ))
+	env.Replace(LINK   = os.path.join(emscPath, "emcc"    ))
+	# SHLINK and LDMODULE should use LINK so no
+	# need to change them here
+    
+	env.Replace(AR     = os.path.join(emscPath, "emar"    ))
+	env.Replace(RANLIB = os.path.join(emscPath, "emranlib"))
+
+ 	env.Replace(OBJSUFFIX  = [".js", ".bc", ".o"][2])
+ 	env.Replace(LIBSUFFIX  = [".js", ".bc", ".o"][2])
+ 	env.Replace(PROGSUFFIX = [".html", ".js"    ][1])
+
+def exists(env):
+	""" NOOP method required by SCons """
+	return 1