diff options
Diffstat (limited to 'demos/lua.js')
| -rw-r--r-- | demos/lua.js | 58562 |
1 files changed, 58562 insertions, 0 deletions
diff --git a/demos/lua.js b/demos/lua.js new file mode 100644 index 00000000..8eba36f5 --- /dev/null +++ b/demos/lua.js @@ -0,0 +1,58562 @@ +// LLVM_STYLE: new + +// Capture the output of this into a variable, if you want +//(function(Module, args) { +// Module = Module || {}; +// args = args || []; + +// Runs much faster, for some reason +var Module = {}; +// XXX manually added for demo // var args = arguments; + // === Auto-generated preamble library stuff === + + Runtime = { + stackAlloc: function stackAlloc(size) { var ret = STACKTOP; STACKTOP += size;STACKTOP = Math.ceil(STACKTOP/4)*4;; return ret; }, + staticAlloc: function staticAlloc(size) { var ret = STATICTOP; STATICTOP += size;STATICTOP = Math.ceil(STATICTOP/4)*4;; return ret; }, + alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil(size/(quantum ? quantum : 4))*(quantum ? quantum : 4);; return ret; }, + getFunctionIndex: function getFunctionIndex(func, ident) { + var key = FUNCTION_TABLE.length; + FUNCTION_TABLE[key] = func; + FUNCTION_TABLE[key+1] = null; // Need to have keys be even numbers, see |polymorph| test + Module[ident] = func; // Export using full name, for Closure Compiler + return key; + }, + isNumberType: function (type) { + return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES; + }, + isPointerType: function isPointerType(type) { + return pointingLevels(type) > 0; + }, + isStructType: function isStructType(type) { + if (isPointerType(type)) return false; + if (new RegExp(/^\[\d+\ x\ (.*)\]/g).test(type)) return true; // [15 x ?] blocks. Like structs + // See comment in isStructPointerType() + return !Runtime.isNumberType(type) && type[0] == '%'; + }, + INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0}, + FLOAT_TYPES: {"float":0,"double":0}, + getNativeFieldSize: function getNativeFieldSize(field, alone) { + var size; + if (4 > 1) { + size = { + 'i1': alone ? 1 : 4, // inside a struct, aligned to 4, + 'i8': alone ? 1 : 4, // most likely...? XXX + 'i16': alone ? 2 : 4, // ditto + 'i32': 4, + 'i64': 8, + 'float': 4, + 'double':8 + }[field]; // XXX 32/64 bit stuff + if (!size) { + size = 4; // Must be a pointer XXX 32/64 + } + } else { + size = 1; + } + return size; + }, + dedup: function dedup(items, ident) { + var seen = {}; + if (ident) { + return items.filter(function(item) { + if (seen[item[ident]]) return false; + seen[item[ident]] = true; + return true; + }); + } else { + return items.filter(function(item) { + if (seen[item]) return false; + seen[item] = true; + return true; + }); + } + }, + calculateStructAlignment: function calculateStructAlignment(type, otherTypes) { + type.flatSize = 0; + var diffs = []; + var prev = -1, maxSize = -1; + type.flatIndexes = type.fields.map(function(field) { + var size; + if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) { + size = Runtime.getNativeFieldSize(field, true); // pack char; char; in structs, also char[X]s. + maxSize = Math.max(maxSize, size); + } else if (Runtime.isStructType(field)) { + size = otherTypes[field].flatSize; + maxSize = Math.max(maxSize, 4); + } else { + dprint('Unclear type in struct: ' + field + ', in ' + type.name_); + assert(0); + } + var curr = Runtime.alignMemory(type.flatSize, Math.min(4, size)); // if necessary, place this on aligned memory + type.flatSize = curr + size; + if (prev >= 0) { + diffs.push(curr-prev); + } + prev = curr; + return curr; + }); + type.flatSize = Runtime.alignMemory(type.flatSize, maxSize); + if (diffs.length == 0) { + type.flatFactor = type.flatSize; + } else if (Runtime.dedup(diffs).length == 1) { + type.flatFactor = diffs[0]; + } + type.needsFlattening = (type.flatFactor != 1); + return type.flatIndexes; + }, + __dummy__: 0 + } + + + function __globalConstructor__() { + } + + // Maps ints ==> functions. This lets us pass around ints, which are + // actually pointers to functions, and we convert at call()time + var FUNCTION_TABLE = []; + + var __THREW__ = false; // Used in checking for thrown exceptions. + + var __ATEXIT__ = []; + + + + + var ABORT = false; + + var undef = 0; + + function assert(condition, text) { + if (!condition) { + var text = "Assertion failed: " + text; + print(text + ':\n' + (new Error).stack); + ABORT = true; + throw "Assertion: " + text; + } + } + + function Pointer_niceify(ptr) { + return { slab: IHEAP, pos: ptr }; + } + + // Creates a pointer for a certain slab and a certain address in that slab. + // If just a slab is given, will allocate room for it and copy it there. In + // other words, do whatever is necessary in order to return a pointer, that + // points to the slab (and possibly position) we are given. + + var ALLOC_NORMAL = 0; // Tries to use _malloc() + var ALLOC_STACK = 1; // Lives for the duration of the current function call + var ALLOC_STATIC = 2; // Cannot be freed + + function Pointer_make(slab, pos, allocator) { + pos = pos ? pos : 0; + assert(pos === 0); // TODO: remove 'pos' + if (slab === HEAP) return pos; + var size = 0; + + // The slab may contain arrays, which we basically need to 'flatten' out + // into one long slab. We do that by traversing it, and not by creating + // a new slab, to save time and memory + var stack = [[slab, 0]], top, curr; + while(1) { + top = stack[stack.length-1]; + if (top[1] >= top[0].length) { + stack.pop(); + if (stack.length === 0) break; + top = stack[stack.length-1]; + top[1]++; + continue; + } + var curr = top[0][top[1]]; + if (curr === undefined) + throw 'Invalid element in slab'; // This can be caught, and you can try again to allocate later, see globalFuncs in run() + if (curr.length) { + stack.push([curr,0]); + continue; + } + size++; + top[1]++; + } + + // Finalize + var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator ? allocator : ALLOC_STATIC](Math.max(size, 1)); + + stack = [[slab, 0]]; + var i = 0; + while(1) { + top = stack[stack.length-1]; + if (top[1] >= top[0].length) { + stack.pop(); + if (stack.length === 0) break; + top = stack[stack.length-1]; + top[1]++; + continue; + } + var curr = top[0][top[1]]; + if (curr.length) { + stack.push([curr,0]); + continue; + } + + if (typeof curr === 'function') { + curr = Runtime.getFunctionIndex(curr); + } + // TODO: Check - also in non-typedarray case - for functions, and if so add |.__index__| + if (typeof curr === 'number' || typeof curr === 'boolean') { + IHEAP[ret + i] = curr; // TODO: optimize. Can easily detect floats, but 1.0 might look like an int... + FHEAP[ret + i] = curr; + } else { + HEAP[ret + i] = curr; + } + + top[1]++; + i++; + } + + return ret; + } + + function Pointer_stringify(ptr) { + ptr = Pointer_niceify(ptr); + + var ret = ""; + var i = 0; + var t; + while (1) { + // if ((ptr.pos + i) >= ptr.slab.length) { return "<< Invalid read: " + (ptr.pos+i) + " : " + ptr.slab.length + " >>"; } else {} + if ((ptr.pos+i) >= ptr.slab.length) { break; } else {} + t = String.fromCharCode(ptr.slab[ptr.pos + i]); + if (t == "\0") { break; } else {} + ret += t; + i += 1; + } + return ret; + } + + // Memory management + + var PAGE_SIZE = 4096; + function alignMemoryPage(x) { + return Math.ceil(x/PAGE_SIZE)*PAGE_SIZE; + } + + var HEAP, IHEAP, FHEAP; + var STACK_ROOT, STACKTOP, STACK_MAX; + var STATICTOP; + + // Mangled |new| and |free| (various manglings, for int, long params; new and new[], etc. + var _malloc, _free, __Znwj, __Znaj, __Znam, __Znwm, __ZdlPv, __ZdaPv; + + function __initializeRuntime__() { + // If we don't have malloc/free implemented, use a simple implementation. + Module['_malloc'] = _malloc = __Znwj = __Znaj = __Znam = __Znwm = Module['_malloc'] ? Module['_malloc'] : Runtime.staticAlloc; + Module['_free'] = _free = __ZdlPv = __ZdaPv = Module['_free'] ? Module['_free'] : function() { }; + + HEAP = intArrayFromString('(null)'); // So printing %s of NULL gives '(null)' + // Also this ensures we leave 0 as an invalid address, 'NULL' + if (!this['TOTAL_MEMORY']) TOTAL_MEMORY = 50*1024*1024; + if (this['Int32Array']) { // check for engine support + IHEAP = new Int32Array(TOTAL_MEMORY); + for (var i = 0; i < HEAP.length; i++) { + IHEAP[i] = HEAP[i]; + } + } else { + IHEAP = HEAP; // fallback + } + if (this['Float64Array']) { // check for engine support + FHEAP = new Float64Array(TOTAL_MEMORY); + } else { + FHEAP = HEAP; // fallback + } + + Module['HEAP'] = HEAP; + Module['IHEAP'] = IHEAP; + Module['FHEAP'] = FHEAP; + + STACK_ROOT = STACKTOP = alignMemoryPage(10); + if (!this['TOTAL_STACK']) TOTAL_STACK = 1024*1024; // Reserved room for stack + STACK_MAX = STACK_ROOT + TOTAL_STACK; + + STATICTOP = alignMemoryPage(STACK_MAX); + } + + function __shutdownRuntime__() { + while( __ATEXIT__.length > 0) { + var func = __ATEXIT__.pop(); + if (typeof func === 'number') { + func = FUNCTION_TABLE[func]; + } + func(); + } + } + + // stdio.h + + // C-style: we work on ints on the HEAP. + function __formatString() { + var textIndex = arguments[0]; + var argIndex = 1; + var ret = []; + var curr = -1; + while (curr) { // Note: should be curr != 0, technically. But this helps catch bugs with undefineds + curr = IHEAP[textIndex]; + next = IHEAP[textIndex+1]; + if (curr == '%'.charCodeAt(0) && ['d', 'u', 'f', '.'].indexOf(String.fromCharCode(next)) != -1) { + var argText = String(+arguments[argIndex]); // +: boolean=>int + // Handle very very simply formatting, namely only %.Xf + if (next == '.'.charCodeAt(0)) { + var limit = 0; + while(1) { + var limitChr = IHEAP[textIndex+2]; + if (!(limitChr >= '0'.charCodeAt(0) && limitChr <= '9'.charCodeAt(0))) break; + limit *= 10; + limit += limitChr - '0'.charCodeAt(0); + textIndex++; + } + textIndex--; + var dotIndex = argText.indexOf('.'); + if (dotIndex == -1) { + dotIndex = argText.length; + argText += '.'; + } + argText += '00000000000'; // padding + argText = argText.substr(0, dotIndex+1+limit); + textIndex += 2; + } else if (next == 'u'.charCodeAt(0)) { + argText = String(unSign(arguments[argIndex], 32)); + } + argText.split('').forEach(function(chr) { + ret.push(chr.charCodeAt(0)); + }); + argIndex += 1; + textIndex += 2; + } else if (curr == '%'.charCodeAt(0) && next == 's'.charCodeAt(0)) { + ret = ret.concat(String_copy(arguments[argIndex])); + argIndex += 1; + textIndex += 2; + } else if (curr == '%'.charCodeAt(0) && next == 'c'.charCodeAt(0)) { + ret = ret.concat(arguments[argIndex]); + argIndex += 1; + textIndex += 2; + } else { + ret.push(curr); + textIndex += 1; + } + } + return Pointer_make(ret, 0, ALLOC_STACK); // NB: Stored on the stack + } + + // Copies a list of num items on the HEAP into a + // a normal JavaScript array of numbers + function Array_copy(ptr, num) { + return Array.prototype.slice.call(IHEAP.slice(ptr, ptr+num)); // Make a normal array out of the typed one + } + + // Copies a C-style string, terminated by a zero, from the HEAP into + // a normal JavaScript array of numbers + function String_copy(ptr, addZero) { + return Array_copy(ptr, _strlen(ptr)).concat(addZero ? [0] : []); + } + + // stdlib.h + + // Get a pointer, return int value of the string it points to + function _atoi(s) { + return Math.floor(Number(Pointer_stringify(s))); + } + + function _llvm_memcpy_i32(dest, src, num, idunno) { + var curr; + for (var i = 0; i < num; i++) { + curr = HEAP[src + i] || 0; // memcpy sometimes copies uninitialized areas XXX: Investigate why initializing alloc'ed memory does not fix that too + HEAP[dest + i] = curr; + // TODO: optimize somehow - this is slower than without typed arrays + IHEAP[dest + i] = IHEAP[src + i]; + FHEAP[dest + i] = FHEAP[src + i]; + } + } + _memcpy = _llvm_memcpy_i64 = _llvm_memcpy_p0i8_p0i8_i32 = _llvm_memcpy_p0i8_p0i8_i64 = _llvm_memcpy_i32; + + function llvm_memset_i32(ptr, value, num) { + for (var i = 0; i < num; i++) { + HEAP[ptr+i] = IHEAP[ptr+i] = FHEAP[ptr+i] = value; + } + } + _llvm_memset_p0i8_i64 = _llvm_memset_p0i8_i32 = llvm_memset_i32; + + function _strlen(ptr) { + var i = 0; + while (IHEAP[ptr+i]) i++; // Note: should be IHEAP[ptr+i] != 0, technically. But this helps catch bugs with undefineds + return i; + } + + // Tools + + PRINTBUFFER = ''; + function __print__(text) { + if (text === null) { + // Flush + print(PRINTBUFFER); + PRINTBUFFER = ''; + return; + } + // We print only when we see a '\n', as console JS engines always add + // one anyhow. + PRINTBUFFER = PRINTBUFFER + text; + var endIndex; + while ((endIndex = PRINTBUFFER.indexOf('\n')) != -1) { + print(PRINTBUFFER.substr(0, endIndex)); + PRINTBUFFER = PRINTBUFFER.substr(endIndex + 1); + } + } + + function jrint(label, obj) { // XXX manual debugging + if (!obj) { + obj = label; + label = ''; + } else + label = label + ' : '; + print(label + JSON.stringify(obj)); + } + + // This processes a 'normal' string into a C-line array of numbers. + // For LLVM-originating strings, see parser.js:parseLLVMString function + function intArrayFromString(stringy) { + var ret = []; + var t; + var i = 0; + while (i < stringy.length) { + ret.push(stringy.charCodeAt(i)); + i = i + 1; + } + ret.push(0); + return ret; + } + + // Converts a value we have as signed, into an unsigned value. For + // example, -1 in int32 would be a very large number as unsigned. + function unSign(value, bits) { + if (value >= 0) return value; + return 2*Math.abs(1 << (bits-1)) + value; + } + + // === Body === + + var $0___SIZE = 12; // %0 + + var $1___SIZE = 16; // %1 + var $1___FLATTENER = [0,8,12]; + var $2___SIZE = 8; // %2 + + var $3___SIZE = 8; // %3 + + var $4___SIZE = 20; // %4 + var $4___FLATTENER = [0,4,5,8,12,16]; + var $5___SIZE = 8; // %5 + + var $6___SIZE = 16; // %6 + + var $7___SIZE = 12; // %7 + + var $8___SIZE = 8; // %8 + + var $9___SIZE = 28; // %9 + + var $10___SIZE = 16; // %10 + + var $11___SIZE = 16; // %11 + var $11___FLATTENER = [0,8,12]; + var $12___SIZE = 20; // %12 + + var $13___SIZE = 8; // %13 + + var $14___SIZE = 16; // %14 + + var $enum_BinOpr___SIZE = 4; // %enum.BinOpr + + var $enum_OpArgMask___SIZE = 4; // %enum.OpArgMask + + var $enum_OpMode___SIZE = 4; // %enum.OpMode + + var $enum_UnOpr___SIZE = 4; // %enum.UnOpr + + var $enum_anon___SIZE = 4; // %enum.anon + + var $struct_BlockCnt___SIZE = 12; // %struct.BlockCnt + var $struct_BlockCnt___FLATTENER = [0,4,8,9,10]; + var $struct_CCallS___SIZE = 8; // %struct.CCallS + + var $struct_CClosure___SIZE = 32; // %struct.CClosure + var $struct_CClosure___FLATTENER = [0,4,5,6,7,8,12,16,20]; + var $struct_CallInfo___SIZE = 24; // %struct.CallInfo + + var $struct_CallS___SIZE = 8; // %struct.CallS + + var $struct_ConsControl___SIZE = 36; // %struct.ConsControl + var $struct_ConsControl___FLATTENER = [0,20,24,28,32]; + var $struct_FuncState___SIZE = 572; // %struct.FuncState + var $struct_FuncState___FLATTENER = [0,4,8,12,16,20,24,28,32,36,40,44,48,50,52,172]; + var $struct_GCheader___SIZE = 8; // %struct.GCheader + var $struct_GCheader___FLATTENER = [0,4,5]; + var $struct_LClosure___SIZE = 24; // %struct.LClosure + var $struct_LClosure___FLATTENER = [0,4,5,6,7,8,12,16,20]; + var $struct_LG___SIZE = 348; // %struct.LG + + var $struct_LHS_assign___SIZE = 24; // %struct.LHS_assign + + var $struct_LexState___SIZE = 60; // %struct.LexState + var $struct_LexState___FLATTENER = [0,4,8,12,24,36,40,44,48,52,56]; + var $struct_LoadF___SIZE = 8200; // %struct.LoadF + + var $struct_LoadS___SIZE = 8; // %struct.LoadS + + var $struct_LocVar___SIZE = 12; // %struct.LocVar + + var $struct_MatchState___SIZE = 272; // %struct.MatchState + + var $struct_Mbuffer___SIZE = 12; // %struct.Mbuffer + + var $struct_Node___SIZE = 28; // %struct.Node + + var $struct_Proto___SIZE = 76; // %struct.Proto + var $struct_Proto___FLATTENER = [0,4,5,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,73,74,75]; + var $struct_SParser___SIZE = 20; // %struct.SParser + var $struct_SParser___FLATTENER = [0,4,16]; + var $struct_Smain___SIZE = 12; // %struct.Smain + + var $struct_Table___SIZE = 32; // %struct.Table + var $struct_Table___FLATTENER = [0,4,5,6,7,8,12,16,20,24,28]; + var $struct_Token___SIZE = 12; // %struct.Token + + var $struct_UpVal___SIZE = 24; // %struct.UpVal + var $struct_UpVal___FLATTENER = [0,4,5,8,12]; + var $struct_Zio___SIZE = 20; // %struct.Zio + + var $struct__IO_FILE___SIZE = 152; // %struct._IO_FILE + var $struct__IO_FILE___FLATTENER = [0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,70,71,72,76,84,88,92,96,100,104,108]; + var $struct__IO_marker___SIZE = 12; // %struct._IO_marker + + var $struct_anon___SIZE = 16; // %struct.anon + var $struct_anon___FLATTENER = [0,4,5,6,8,12]; + var $struct_expdesc___SIZE = 20; // %struct.expdesc + var $struct_expdesc___FLATTENER = [0,4,12,16]; + var $struct_global_State___SIZE = 236; // %struct.global_State + var $struct_global_State___FLATTENER = [0,12,16,20,21,24,28,32,36,40,44,48,52,64,68,72,76,80,84,88,92,104,108,132,168]; + var $struct_lconv___SIZE = 56; // %struct.lconv + var $struct_lconv___FLATTENER = [0,4,8,12,16,20,24,28,32,36,40,41,42,43,44,45,46,47,48,49,50,51,52,53]; + var $struct_luaL_Buffer___SIZE = 8204; // %struct.luaL_Buffer + + var $struct_luaL_Reg___SIZE = 8; // %struct.luaL_Reg + + var $struct_lua_Debug___SIZE = 100; // %struct.lua_Debug + var $struct_lua_Debug___FLATTENER = [0,4,8,12,16,20,24,28,32,36,96]; + var $struct_lua_State___SIZE = 112; // %struct.lua_State + var $struct_lua_State___FLATTENER = [0,4,5,6,8,12,16,20,24,28,32,36,40,44,48,52,54,56,57,60,64,68,72,84,96,100,104,108]; + var $struct_lua_TValue___SIZE = 12; // %struct.lua_TValue + + var $struct_lua_longjmp___SIZE = 12; // %struct.lua_longjmp + + var $struct_stringtable___SIZE = 12; // %struct.stringtable + + var $struct_tm___SIZE = 44; // %struct.tm + + var $struct_upvaldesc___SIZE = 2; // %struct.upvaldesc + + var $union_Closure___SIZE = 32; // %union.Closure + + var $union_GCObject___SIZE = 112; // %union.GCObject + + var $union_TKey___SIZE = 16; // %union.TKey + + var $union_TString___SIZE = 16; // %union.TString + + var $union_Udata___SIZE = 20; // %union.Udata + + var $union_anon___SIZE = 8; // %union.anon + + var __ZL7globalL; + var __str; + var __str1; + var __ZL8progname; + var __str2; + var __str3; + var __str4; + var __str5; + var _stdout; + var __str6; + var __str7; + var __str8; + var __str9; + var __str10; + var _stdin; + var __str11; + var __str12; + var __str13; + var __str14; + var __str15; + var __str16; + var __str17; + var __str18; + var __str19; + var __str20; + var __str21; + var __str22; + var _stderr; + var __str23; + var __str24; + var __str25; + var __str26; + var __str27; + var __str28; + var __str129; + var __str230; + var __str331; + var __str432; + var __str1533; + var __str2634; + var __str37; + var __str835; + var __str1936; + var __str210; + var __str311; + var __str412; + var __str537; + var __str638; + var __str739; + var __str813; + var __str940; + var __str1041; + var __str1142; + var __str1243; + var __str1344; + var __str1445; + var __str1514; + var __str1646; + var __str1747; + var __str1848; + var __str1915; + var __str2049; + var __str2150; + var __str122; + var __ZTVN10__cxxabiv119__pointer_type_infoE; + var __ZTSP11lua_longjmp; + var __ZTVN10__cxxabiv117__class_type_infoE; + var __ZTS11lua_longjmp; + var __ZTI11lua_longjmp; + var __ZTIP11lua_longjmp; + var __str223; + var __str324; + var __str425; + var __str526; + var __str627; + var __str728; + var __str829; + var __str47; + var __str148; + var __str249; + var __str350; + var __str451; + var __str552; + var __str653; + var __str754; + var __str855; + var __str956; + var __str1057; + var __str1158; + var __str1259; + var __str1360; + var __str1461; + var __str1562; + var __str1663; + var __str1764; + var __str1865; + var __str1966; + var __str2067; + var __str2168; + var __str2251; + var __str2352; + var __str2453; + var __str2554; + var __str2669; + var __str2755; + var __str2856; + var __str29; + var __str30; + var _luaX_tokens; + var __str31; + var __str32; + var __str33; + var __str34; + var __str35; + var __str36; + var __str3770; + var __str38; + var __str39; + var __str40; + var __str41; + var __str42; + var __str43; + var __str44; + var __str45; + var __str46; + var __str72; + var _luaO_nilobject_; + var __ZZ9luaO_log2jE5log_2; + var __str77; + var __str178; + var __str279; + var __str380; + var __str481; + var __str582; + var __str683; + var __str784; + var __str90; + var __str191; + var __str292; + var __str393; + var __str494; + var __str595; + var __str696; + var __str797; + var __str898; + var __str999; + var __str10100; + var __str11101; + var __str12102; + var __str13103; + var __str14104; + var __str15105; + var __str16106; + var __str17107; + var __str18108; + var __str19109; + var __str20110; + var __str21111; + var __str22112; + var __str23113; + var __str24114; + var __str25115; + var __str26116; + var __str27117; + var __str28118; + var __str29119; + var __str30120; + var __str31121; + var __str32122; + var __str33123; + var __str34124; + var __str35125; + var __str36126; + var __str37127; + var _luaP_opnames; + var _luaP_opmodes; + var __str12957; + var __str1130; + var __ZL8priority; + var __str2131; + var __str3132; + var __str4133; + var __str5134; + var __str6135; + var __str7136; + var __str8137; + var __str9138; + var __str10139; + var __str11140; + var __str12141; + var __str13142; + var __str14143; + var __str15144; + var __str16145; + var __str17146; + var __str18147; + var __str19148; + var __str20149; + var __str21150; + var __str22151; + var __str23152; + var __str24153; + var __str25154; + var __str26155; + var __str27156; + var __str158; + var __ZL10dummynode_; + var __str164; + var __str1165; + var __str2166; + var __str3167; + var __str177; + var __str1178; + var __str2179; + var __str3180; + var __str4181; + var __str5182; + var __str6183; + var __str7184; + var __str8185; + var __str9186; + var _luaT_typenames; + var __ZZ9luaT_initP9lua_StateE14luaT_eventname; + var __str10188; + var __str11189; + var __str12190; + var __str13191; + var __str14192; + var __str15193; + var __str16194; + var __str17195; + var __str18196; + var __str19197; + var __str20198; + var __str21199; + var __str22200; + var __str23201; + var __str24202; + var __str25203; + var __str26204; + var __str208; + var __str1209; + var __str2210; + var __str3211; + var __str4212; + var __str5213; + var __str6214; + var __str7215; + var __str8216; + var __str9217; + var __str220; + var __str1221; + var __str2222; + var __str3223; + var __str4224; + var __str5225; + var __str6226; + var __str7227; + var __str8228; + var __str242; + var __str124358; + var __str2244; + var __str3245; + var __str4246; + var __str5247; + var __str6248; + var __str7249; + var __str8250; + var __str9251; + var __str10252; + var __str11253; + var __str12254; + var __str13255; + var __str14256; + var __str15257; + var __str16258; + var __str17259; + var __str18260; + var __str19261; + var __str20262; + var __str21263; + var __str22264; + var __str23265; + var __str24266; + var __str25267; + var __str268; + var __str1269; + var __str2270; + var __str3271; + var __str4272; + var __str5273; + var __str6274; + var __str7275; + var __str8276; + var __str9277; + var __str10278; + var __str11279; + var __str12280; + var __str13281; + var __str14282; + var __str15283; + var __str16284; + var __str17285; + var __str18286; + var __str19287; + var __str20288; + var __str21289; + var __str22290; + var __str23291; + var __ZL10base_funcs; + var __str24292; + var __str25293; + var __str26294; + var __str27295; + var __str28296; + var __str29297; + var __ZL8co_funcs; + var __str30298; + var __str31299; + var __str32300; + var __str33301; + var __str34302; + var __str35303; + var __str36304; + var __str37305; + var __str38306; + var __str39307; + var __str40308; + var __str41309; + var __ZL9statnames; + var __str42310; + var __str43311; + var __str44312; + var __str45313; + var __str46314; + var __str47315; + var __str48; + var __str49; + var __str50; + var __str51; + var __str52; + var __str53; + var __str54; + var __str55; + var __str56; + var __str57; + var __str58; + var __str59; + var __str60; + var __str61; + var __str62; + var __str63; + var __str64; + var __str65; + var __str66; + var __str67; + var __str68; + var __str69; + var __ZZ19luaB_collectgarbageP9lua_StateE4opts; + var __str70; + var __str71; + var __str72316; + var __str73; + var __str74; + var __str75; + var __str76; + var __ZZ19luaB_collectgarbageP9lua_StateE7optsnum; + var __str77317; + var __str78; + var __str318; + var __str1319; + var __str2320; + var __str3321; + var __str4322; + var __str5323; + var __str6324; + var __str7325; + var __str8326; + var __str9327; + var __str10328; + var __str11329; + var __str12330; + var __str13331; + var __ZL5dblib; + var __str14332; + var __str15333; + var __str16334; + var __str17335; + var __str18336; + var __str19337; + var __str20338; + var __str21339; + var __str22340; + var __str23341; + var __str24342; + var __str25343; + var __str26344; + var __str27345; + var __ZL8KEY_HOOK; + var __ZZ5hookfP9lua_StateP9lua_DebugE9hooknames; + var __str28346; + var __str29347; + var __str30348; + var __str31349; + var __str32350; + var __str33351; + var __str34352; + var __str35353; + var __str36354; + var __str37355; + var __str38356; + var __str39357; + var __str40358; + var __str41359; + var __str42360; + var __str43361; + var __str44362; + var __str45363; + var __str46364; + var __str47365; + var __str48366; + var __str49367; + var __str50368; + var __str51369; + var __str52370; + var __str371; + var __str1372; + var __str2373; + var __str3374; + var __str4375; + var __str5376; + var __str6377; + var __str7378; + var __str8379; + var __str9380; + var __str10381; + var __ZL5iolib; + var __str11382; + var __str12383; + var __str13384; + var __str14385; + var __ZL4flib; + var __str15386; + var __str16387; + var __str17388; + var __str18389; + var __str19390; + var __str20391; + var __str21392; + var __str22393; + var __str23394; + var __str24395; + var __str25396; + var __str26397; + var __str27398; + var __str28399; + var __ZZ9f_setvbufP9lua_StateE4mode; + var __ZZ9f_setvbufP9lua_StateE9modenames; + var __str29400; + var __str30401; + var __str31402; + var __ZZ6f_seekP9lua_StateE4mode; + var __ZZ6f_seekP9lua_StateE9modenames; + var __str32403; + var __str33404; + var __str34405; + var __str35406; + var __str36407; + var __str37408; + var __str38409; + var __str39410; + var __str40411; + var __ZL6fnames; + var __str41412; + var __str42413; + var __str43414; + var __str44415; + var __str45416; + var __str417; + var __str1418; + var __str2419; + var __str3420; + var __str4421; + var __str5422; + var __str6423; + var __str7424; + var __str8425; + var __str9426; + var __str10427; + var __str11428; + var __str12429; + var __str13430; + var __str14431; + var __str15432; + var __str16433; + var __str17434; + var __str18435; + var __str19436; + var __str20437; + var __str21438; + var __str22439; + var __str23440; + var __str24441; + var __str25442; + var __str26443; + var __str27444; + var __ZL7mathlib; + var __str28445; + var __str29446; + var __str30447; + var __str31448; + var __str32449; + var __str33450; + var __str452; + var __str1453; + var __str2454; + var __str3455; + var __str4456; + var __str5457; + var __str6458; + var __str7459; + var __str8460; + var __str9461; + var __str10462; + var __ZL6syslib; + var __str11463; + var __str12464; + var __str13465; + var __str14466; + var __str15467; + var __str16468; + var __str17469; + var __str18470; + var __str19471; + var __str20472; + var __ZZ12os_setlocaleP9lua_StateE3cat; + var __ZZ12os_setlocaleP9lua_StateE8catnames; + var __str21473; + var __str22474; + var __str23475; + var __str24476; + var __str25477; + var __str26478; + var __str27479; + var __str28480; + var __str29481; + var __str30482; + var __str483; + var __str1484; + var __str2485; + var __str3486; + var __str4487; + var __str5488; + var __str6489; + var __str7490; + var __str8491; + var __ZL9tab_funcs; + var __str9492; + var __str10493; + var __str11494; + var __str12495; + var __str13496; + var __str14497; + var __str498; + var __str1499; + var __str2500; + var __str3501; + var __str4502; + var __str5503; + var __str6504; + var __str7505; + var __str8506; + var __str9507; + var __str10508; + var __str11509; + var __str12510; + var __str13511; + var __str14512; + var __ZL6strlib; + var __str15513; + var __str16514; + var __str17515; + var __str18516; + var __str19517; + var __str20518; + var __str21519; + var __str22520; + var __str23521; + var __str24522; + var __str25523; + var __str26524; + var __str27525; + var __str28526; + var __str29527; + var __str30528; + var __str31529; + var __str32530; + var __str33531; + var __str34532; + var __str35533; + var __str36534; + var __str37535; + var __str38536; + var __str39537; + var __str538; + var __str1539; + var __ZL8pk_funcs; + var __str2540; + var __str3541; + var __ZL8ll_funcs; + var __ZL7loaders; + var __str4542; + var __str5543; + var __str6544; + var __str7545; + var __str8546; + var __str9547; + var __str10548; + var __str11549; + var __str12550; + var __str13551; + var __str14552; + var __str15553; + var __str16554; + var __str17555; + var __str18556; + var __str19557; + var __str20558; + var __str21559; + var __str22560; + var __str23561; + var __str24562; + var __str25563; + var __str26564; + var __str27565; + var __str28566; + var __str29567; + var __str30568; + var __str31569; + var __str32570; + var __str33571; + var __str34572; + var __str35573; + var __str36574; + var __str37575; + var __str38576; + var __str39577; + var __ZL9sentinel_; + var __str40578; + var __str41579; + var __str42580; + var __str43581; + var __str44582; + var __str45583; + var __str46584; + var __str47585; + var __str48586; + var __str49587; + var __str50588; + var __str51589; + var __str590; + var __str1591; + var __str2592; + var __str3593; + var __str4594; + var __str5595; + var __str6596; + var __str7597; + var __ZL7lualibs; + + _fputs = function (p, stream) { + var str = Pointer_stringify(p); if (str == '\n') return; // XXX manually added for demo, suppress unneeded newlines + __print__(str + '\n'); + } + _fflush = function (file) { + __print__(null); + } + _signal = function (sig, func) { + // TODO + return 0; + } + // s |