/* * Copyright (c) 2023 Ross Cunniff * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ namespace oadlmach { // OADL opcodes const // Miscellaneous group OP_NOP = 0x00, // Do nothing OP_POP = 0x01, // val pop OP_DUP = 0x02, // val dup => val val OP_EXCH = 0x03, // v1 v2 exch => v2 v1 OP_DUPN = 0x04, // v0 v1 ... vn n dupn => v0 v1 ... vn v0 OP_INC = 0x05, // v0 => v0 + 1 (without promotion) OP_DEC = 0x06, // v0 => v0 - 1 (without promotion) // Unused: 0x07 // Arithmetic OP_ADD = 0x08, // op1 op2 add => (op1 + op2) OP_SUB = 0x09, // op1 op2 sub => (op1 - op2) OP_MUL = 0x0A, // op1 op2 mul => (op1 * op2) OP_DIV = 0x0B, // op1 op2 div => (op1 / op2) OP_MOD = 0x0C, // op1 op2 mod => (op1 % op2) OP_NEG = 0x0D, // op1 neg => (-op1) OP_POW = 0x0E, // op1 op2 pow => (op1 ** op2) // Unused: 0x0F // Boolean OP_AND = 0x10, // op1 op2 and => (op1 & op2) OP_OR = 0x11, // op1 op2 or => (op1 | op2) OP_XOR = 0x12, // op1 op2 xor => (op1 ^ op2) OP_NOT = 0x13, // op1 not => (~op1) OP_LOGNOT = 0x14, // op1 lognot => (~op1) OP_LSHIFT = 0x15, // op1 op2 lshift => (op1 << op2) OP_RSHIFT = 0x16, // op1 op2 rshift => (op1 >> op2) // Unused: 0x17 // Comparison OP_LT = 0x18, // op1 op2 lt => (op1 < op2) OP_GT = 0x19, // op1 op2 gt => (op1 > op2) OP_LE = 0x1A, // op1 op2 le => (op1 <= op2) OP_GE = 0x1B, // op1 op2 ge => (op1 >= op2) // Unused: 0x1C - 0x1F // Equivalence OP_EQ = 0x20, // op1 op2 eq => (op1 == op2) OP_NE = 0x21, // op1 op2 ne => (op1 != op2) OP_ARR_EQ = 0x22, // op1 op2 arreq => (op1 #= op2) // Unused: 0x23 - 0x27 // String matching OP_MATCH = 0x28, // str patt comp MATCH => new match env OP_ENDMATCH = 0x29, // ENDMATCH => pop match env OP_NMATCH = 0x2A, // NMATCH => # of matches OP_MATCHN = 0x2B, // N MATCHN => (match #N) // Unused: 0x2C - 0x2F // Execution flow OP_CALL = 0x30, // arg1 arg2 ... argN N addr call OP_RET = 0x31, // retval ret OP_MCALL = 0x32, // arg1 arg2 ... argN N obj public mcall OP_JMP = 0x33, // addr jmp OP_JMPZ = 0x34, // val addr jmpz OP_LOCALS = 0x35, // Allocate locals on the stack OP_TRY = 0x36, // addr try OP_ENDTRY = 0x37, // endtry OP_THROW = 0x38, // excepnum throw OP_PROC = 0x39, // PROC => current executing proc OP_ARR_CALL = 0x3A, // arr addr arrcall OP_ARR_MCALL = 0x3B, // arr obj public arrmcall // Unused: 0x3C - 0x3F // Get/set global, local, arg, index OP_GETG = 0x40, // global getg => (*global) OP_SETG = 0x41, // global val setg OP_SETG_TC = 0x42, // type global val setg_tc OP_GETL = 0x43, // local getl => (*local) OP_SETL = 0x44, // local val setl OP_SETL_TC = 0x45, // type local val setl_tc OP_GETA = 0x46, // arg geta => (*arg) OP_SETA = 0x47, // arg val seta OP_SETA_TC = 0x48, // type arg val seta_tc OP_GETP = 0x49, // prop getp => (self.prop) OP_SETP = 0x4A, // prop val setp OP_SETP_TC = 0x4B, // type prop val setp_tc OP_GETPK = 0x4C, // prop getpk => prop (self.prop) OP_GETI = 0x4D, // arr index geti => (arr[index]) OP_GETI_M = 0x4E, // arr i0 i1 ... n geti_m => arr[i0,i1,...] OP_SETI = 0x4F, // arr index val seti OP_SETI_M = 0x50, // arr i0 i1 ... n val seti_m OP_GETIK = 0x51, // arr index getik => arr index arr[index] OP_GETIK_M = 0x52, // arr i0 i1 ... n getik_m => arr i0 ... a[i] OP_GETPUB = 0x53, // obj pub getpub => obj.pub OP_SETPUB = 0x54, // obj pub val setpub OP_GETPUBK = 0x55, // obj pub getpubk => obj pub obj.pub OP_SELF = 0x56, // self => self OP_LOOPINIT = 0x57, // vbase expr num ishash loopinit => stop? OP_LOOPINCR = 0x58, // vbase num ishash loopincr => stop? OP_GETI_X = 0x59, // arr index geti_x => arr#[index] OP_GETI_XK = 0x5A, // arr index geti_xk => arr index arr#[index] OP_SETI_X = 0x5B, // arr index val seti_x OP_SETSUBR = 0x5C, // arr s0 e0 s1 e1 ... n val setsubr OP_GETSUB_K = 0x5D, // arr s0 e0 ... n getsub_k arr s0 .. arr[..] // Unused: 0x5E - 0x5F // Debugging ops OP_BREAKPOINT = 0x60, // Break and exec OP_DEBUG_POP = 0x61, // Pop debug name stack OP_LINE = 0x62, // linenum line OP_DEBUG_PRINT = 0x63, // var DEBUG_PRINT OP_BREAK_HALT = 0x64, // Break and halt // Unused: 0x64 - 0x6F // Push instructions - 0 extra bytes OP_NIL = 0x70, // Push nil - 0xFFFFFFFF OP_FLT_0 = 0x71, // Push 0.0 OP_INT_0 = 0x72, // Push 0 OP_DBL_0 = 0x73, // Push 0.d (only OADL64) OP_I64_0 = 0x74, // Push 0L (only OADL64) OP_WCH_0 = 0x75, // Push '\x0'L OP_F16_0 = 0x76, // Push 0.0h OP_U16_0 = 0x77, // Push 0us OP_I16_0 = 0x78, // Push 0s OP_U8_0 = 0x79, // Push 0ub OP_I8_0 = 0x7A, // Push 0b OP_CHR_0 = 0x7B, // Push '\x0' OP_FALSE = 0x7C, // Push false OP_TRUE = 0x7D, // Push true OP_ARG_0 = 0x7E, // Push address of arg 0 // Unused: 0x7F // Unused: 0x80 - 0x8F // Push instructions - 1 extra byte OP_INT_8 = 0x90, // Push -128 to 127 OP_I64_8 = 0x91, // Push -128l to 127l (OADL64) OP_WCH_8 = 0x92, // Push '\x0'L to '\xFF'L OP_U16_8 = 0x93, // Push 0us to 255us OP_I16_8 = 0x94, // Push -128s to 127s OP_U8_8 = 0x95, // Push 0ub to 255ub OP_I8_8 = 0x96, // Push -128b to 127b OP_CHR_8 = 0x97, // Push Char OP_TYP_8 = 0x98, // Push 8-bit Type OP_EXCP_8 = 0x99, // Push 8-bit Exception OP_LOCAL_8 = 0x9A, // next byte is local var offs OP_ARG_8 = 0x9B, // next byte is arg offs OP_BUILTIN = 0x9C, // next byte is builtin number from builtin.h OP_FILE_8 = 0x9D, // Push 8-bit File // Unused: 0x9E - 0x9F // Multibyte instructions - 2 extra bytes OP_INT_16 = 0xA0, // Push -32768 to 32767 OP_FLT_16 = 0xA1, // next 2 bytes are upper bits of float OP_I64_16 = 0xA2, // Push -32768l to 32767l (OADL64) OP_DBL_16 = 0xA3, // next 2 bytes are upper bits of dbl (OADL64) OP_WCH_16 = 0xA4, // Push '\x0800'L to '\xFFFF'L OP_F16_16 = 0xA5, // Push Half OP_U16_16 = 0xA6, // Push 0us to 65535us OP_I16_16 = 0xA7, // Push -32768s to 32767s OP_LOCAL_16 = 0xA8, // next 2 bytes are local var offs OP_ARG_16 = 0xA9, // next 2 bytes are arg offs OP_DEBUG_PUSH = 0xAA, // next 2 bytes are unique ID // Unused: 0xAB - 0xAF // Multibyte instructions - various extra bytes OP_FLT_24 = 0xB0, // next 3 bytes are upper 3 of float OP_DBL_24 = 0xB1, // next 3 bytes are upper 3 of dbl (OADL64) OP_WCH_24 = 0xB2, // Push '\x080000'L to '\xFFFFFF'L OP_ADDRESS = 0xB3, // next 3 bytes are code address offset // Unused: 0xB4 - 0xB7 // next 3 bytes... OP_PARENT = 0xB8, // next 4 bytes are parent object OP_DBL_32 = 0xB9, // next 4 bytes are upper 4 of Double (OADL64) OP_I64_32 = 0xBA, // next 4 bytes are lower 4 of Long (OADL64) OP_DEBUG_VAR = 0xBB, // next 4 bytes are name for debugging OP_FILE = 0xBC, // next 4 bytes are array ID of filename OP_DEBUG_PUSH_NS = 0xBD, // next 4 bytes are namespace name ID // Unused: 0xBE // next 4 bytes... OP_VAR_64 = 0xBF, // next 8 bytes are 64-bit Var (OADL64 only) // Multibyte instructions - 4 extra bytes OP_PUSH_32 = 0xC0; // Lower 6 bits of opcode are type. // Next 4 bytes are value. // Builtins const // Procedure argument builtins BI_ARG = 0x00, // arg(n) => argument #n BI_NARGS = 0x01, // nargs() => number of arguments BI_ARGVEC = 0x02, // argvec() => array of arguments BI_GETLOCAL = 0x03, // getlocal(offs) => local at stack[offs] BI_SETLOCAL = 0x04, // setlocal(offs,val) => stack[offs] = val // Unused: 0x05 - 0x0F // Type utilities BI_TYPEOF = 0x10, // typeof(v) => type of v BI_TYPECHECK = 0x11,// typecheck(v,typ) => NIL (raise $TYPECHECK if fail) BI_IS_A = 0x12, // is_a(a,b) - true iff b is a parent of a BI_ISARRAY = 0x13, // isarray(v) => true iff a is an array BI_ISINT = 0x14, // a.isint() = true iff a has an integral type BI_ISFLOAT = 0x15, // a.isfloat() = true iff a has a floating pt type BI_ISCHAR = 0x16, // a.ischar() = true iff a has a character type BI_ISSTRING = 0x17, // a.isstring() = true iff is a string or lstring BI_ARRBASE = 0x18, // a.arrbase() => base tyhpe of a, or Array if het BI_ISNUMERIC = 0x19,// a.isnumeric() = true iff a has a numeric type BI_PROMOTE = 0x1A, // a.promote(b) => promoted type of a op b BI_PACKTYPE = 0x1B, // a.packtype(opt-rank) => packed arr type of base a // Unused: 0x1C - 0x1F // Memory management utilities BI_COPY = 0x20, // copy(v) => copy of (possibly read-only) v BI_PERM = 0x21, // perm(a) => permanent copy of a BI_GC = 0x22, // gc() => nil - collect garbage BI_PROTECT = 0x23, // protect(a) => write-protected version of a BI_DEEP_COPY = 0x24,// deepcopy(v) => recursive copy of v BI_READONLY = 0x25, // readonly(a) or readonly(a,b) => true iff so BI_TRANSIENT = 0x26,// transient(a) => true iff array a can go away // Unused: 0x27 - 0x2F // Control flow BI_SETJMP = 0x30, // setjmp(a) => nil on set, lonjump v on jump BI_LONGJMP = 0x31, // longjmp(a,v) => does not return BI_HALT = 0x32, // halt() - does not return (halts current thread) BI_SAVE = 0x33, // save(v) - returns true/false/nil dep on restore BI_RESTORE = 0x34, // restore(v) - does not return if successful BI_RESTART = 0x35, // restart() - does not return if successful // Unused: 0x36 - 0x3F // Misc numerics BI_FIX2FLT = 0x40, // fix2flt(a,typ) => (a / (tmax(typeof(a)))) => typ BI_FLT2FIX = 0x41, // flt2fix(a,typ) => (a * tmax(typ)) => typ BI_MIN = 0x42, // min(a,b) => (a < b) ? a : b BI_MAX = 0x43, // max(a,b) => (a > b) ? a : b BI_CLAMP = 0x44, // clamp(a,mn,mx) => (a<mn) ? mn : ((a>mx) : mx : a) BI_LERP = 0x45, // lerp(a,mn,mx) => (1-a)*mn + a*mx (a clamped 0..1) BI_SATADD = 0x46, // satadd(a,b,mn,mx) => clamp(a+b,mn,mx) BI_SATSUB = 0x47, // satsub(a,b,mn,mx) => clamp(a-b,mn,mx) BI_ABS = 0x48, // abs(a) => absolute value of a BI_SIGNUM = 0x49, // signum(a) => signum of a (-1, 0, 1) // Unused: 0x4A - 0x4F // Internal variables // Unused 0x50 // Unused 0x51 BI_INTR_PUSH = 0x52,// intrpush() - returns depth of intrinsic stack BI_INTR_POP = 0x53, // intrpop() - pops the intrinsic stack BI_INTR_EXIT = 0x54,// intrexit() - resets the intrinsic stack // Unused: 0x55 - 0x5F // Array / dict handling BI_ARRAY = 0x60, // array(shape) => n-element array BI_PACKED = 0x61, // packed(type,shape) => shaped packed array of type BI_STRING = 0x62, // string(n) => n-element string BI_LSTRING = 0x63, // lstring(n) => n-element wide string BI_PACK = 0x64, // pack(a) => packed version of array a BI_UNPACK = 0x65, // unpack(a) => generic array version of packed a BI_LENGTH = 0x66, // length(a) => length of array a (elem 0 of shape) BI_SHAPE = 0x67, // shape(a) => shape of array a BI_RANK = 0x68, // rank(a) => shape of array a BI_CONCAT = 0x69, // concat(a,b) => a ## b BI_SUBR = 0x6A, // subr(val,i1,i2,...,in) => val[i1:i2,...,in-1,in] BI_ITERATE = 0x6B, // iterate(shape) => {0,1,2,3,...,n-1} BI_RESHAPE = 0x6C, // reshape(v,shape) => reshaped copy of v BI_DICT = 0x6D, // dict(n) => dictionary of size n BI_SIZEOF = 0x6E, // sizeof(arr) => total # of elements of arr // Unused: 0x6F // More array operations BI_REDUCE = 0x70, // arr.reduce(op,ax) BI_ACCUM = 0x71, // arr.accum(op,ax) BI_INNER = 0x72, // arr1.inner(op,arr2) BI_ENCLOSE = 0x73, // arr.enclose(ax) BI_OUTER = 0x74, // arr1.outer(op1,op2,arr2) BI_REPLICATE = 0x75,// arr1.replicate(vec,ax) // Unused 0x76 BI_REVERSE = 0x77, // arr.reverse(ax) BI_ROTATE = 0x78, // arr.rotate(ax) BI_TRANSPOSE = 0x79,// arr.transpose(ax) BI_TAKE = 0x7A, // arr.take(num,ax) BI_DROP = 0x7B, // arr.drop(num,ax) BI_UNRAVEL = 0x7C, // arr.unravel(ax) BI_LAMINATE = 0x7D, // arr1.laminate(arr2,ax) BI_MEMBER = 0x7E, // arr1.member(arr2) BI_POSITION = 0x7F, // arr1.position(arr2) // Even more array operations BI_ENCODE = 0x80, // arr1.encode(arr2) BI_DECODE = 0x81, // arr1.decode(arr2) BI_SORT = 0x82, BI_UNIQUE = 0x83, // arr.unique() BI_UNION = 0x84, // arr1.union(arr2) BI_INTERSECT = 0x85,// arr1.intersect(arr2) BI_WITHOUT = 0x86, // arr1.without(arr2) BI_INCREMENT = 0x87,// arr1.increment(arr2) - odometer function BI_STRIDE = 0x88, // arr.stride() - return the array stride // Unused 0x89 BI_GETIDX = 0x8A, BI_SETIDX = 0x8B, BI_ARRCMP = 0x8C, BI_FLATTEN = 0x8D, // Unused: 0x8E - 0xCF // I/O builtins BI_SAY = 0xD0, // say(a,b,c,...) or f.say(a,b,c,...) BI_CLOSE = 0xD1, // f.close() BI_READSTR = 0xD2, // a = readstr() or a = f.readstr() BI_PRINT = 0xD3, // print(fmt,a,b,c,...) or f..print(fmt,a,b,c,...) BI_READ = 0xD4, // arr = f.read(fmt,t,...) or arr = f.read(t,...) BI_WRITE = 0xD5, // f.write(a,b,c,...) BI_FORMAT = 0xD6, // a = format(fmt, a, b, c) BI_REWIND = 0xD7, // f.rewind() BI_FSEEK = 0xD8, // f.fseek(pos) BI_GETCHAR = 0xD9, // c = f.getchar() BI_PUTCHAR = 0xDA, // f.putchar(c) BI_FFLUSH = 0xDB, // f.fflush() // Unused: 0xDC - 0xDF BI_FERROR = 0xE0, // err = f.ferror() BI_FEOF = 0xE1, // tf = f.feof() BI_FTELL = 0xE2, // pos = f.ftell() BI_BINARY = 0xE3, // tf = f.binary() BI_ISPIPE = 0xE4, // tf = f.ispipe() BI_GETSWAB = 0xE5, // tf = f.getswab() BI_SETSWAB = 0xE6, // f.setswab(tf) BI_CLEARERR = 0xE7, // f.clearerr() // Other attribute builtins BI_MINVAL = 0xE8, // typ.minval() => minimum value of typ BI_MAXVAL = 0xE9, // typ.maxval() => maximum value of typ // Unused: 0xEA - 0xEF // Pseudo-builtins - not directly callable with procedure syntax BI_NEW = 0xF0, // new(cls,obj) - create object with given class BI_TYPECONV = 0xF1, // typeconv(val,typ) => (val => typ) BI_ASSERT = 0xF2, // assert(expr) => nil (throws $ASSERT$ if false) BI_MKLIST = 0xF3, // mklist(v0,v1,...,vn) => {v0,v1,...,vn} BI_MKDICT = 0xF4, // mkdict(v0,v1,...,v2n+1) => <<<v0,v1,...,v2n+1>>> BI_MKARR = 0xF5, // mkarr(rank,s0,..,v0,...) => [[v0,...],[...],...] BI_MIN_N = 0xF6, // min(a,b,...,z) => minimum value of elements BI_MAX_N = 0xF7, // max(a,b,...,z) => maximum value of elements BI_CONCAT_N = 0xF8, // concat(a,b,...,z) => a ## b ## ... ## z BI_ITERATOR = 0xF9, // [a:b:c] => a b c iterator BI_MKSUBARR = 0xFA, // var num mksubarr => num-dimensioned array BI_OBJPROP = 0xFB, // obj offs objprop => obj[objprop] - for debugger BI_SETOBJPROP = 0xFC; // obj offs val setobjprop - for debugger // Unused: 0xFD - 0xFF #if(#defined(OADLMACH_DEFINE_EXTERNS)) // [ var OADL_OpcodeSizes = [ 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x00 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x10 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x20 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x30 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x40 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x50 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x60 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x70 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, 1b, // 0x80 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, 2b, // 0x90 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, 3b, // 0xA0 4b, 4b, 4b, 4b, 4b, 4b, 4b, 4b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 9b, // 0xB0 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, // 0xC0 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, // 0xD0 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, // 0xE0 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b, 5b // 0xF0 ]; var OADL_op0types = <<< 0, "Null", 1, "Float", 2, "Int", 3, "Double", 4, "Long", 5, "WideChar", 6, "Half", 7, "Ushort", 8, "Short", 9, "Ubyte", 10, "Byte", 11, "Char", 12, "Bool", 13, "Bool", 14, "$ARG$" >>>; var OADL_op8types = <<< 0, "Int", 1, "Long", 2, "WideChar", 3, "Ushort", 4, "Short", 5, "Ubyte", 6, "Byte", 7, "Char", 8, "Type", 9, "Except", 10, "$LOCAL$", 11, "$ARG$", 12, "$INTR$", 13, "File" >>>; var OADL_op16types = <<< 0, "Int", 1, "Float", 2, "Long", 3, "Double", 4, "WideChar", 5, "Half", 6, "Ushort", 7, "Short", 8, "$LOCAL$", 9, "$ARG$" >>>; proc OADL_InstrCount(op) { return Int(OADL_OpcodeSizes[op]); } proc OADL_Decode(ip, o, op, args : PackUint) { var size; args[0] = 0; args[1] = 0; size = OADL_InstrCount(op); switch (size) { case 2 : args[0] = ip[o+1]; case 3 : args[0] = (ip[o+2]<<8) | ip[o+1]; case 4 : args[0] = (ip[o+3]<<16) | (ip[o+2]<<8) | ip[o+1]; case 5 : args[0] = (ip[o+4]<<24u) | (ip[o+3]<<16) | (ip[o+2]<<8) | ip[o+1]; case 9 : args[0] = (ip[o+4]<<24u) | (ip[o+3]<<16) | (ip[o+2]<<8) | ip[o+1]; args[1] = (ip[o+8]<<24u) | (ip[o+7]<<16) | (ip[o+6]<<8) | ip[o+5]; } return size; } var opcodeTab = <<< OP_NOP, "NOP", OP_POP, "POP", OP_DUP, "DUP", OP_EXCH, "EXCH", OP_DUPN, "DUPN", OP_INC, "INC", OP_DEC, "DEC", OP_ADD, "ADD", OP_SUB, "SUB", OP_MUL, "MUL", OP_DIV, "DIV", OP_MOD, "MOD", OP_NEG, "NEG", OP_POW, "POW", OP_AND, "AND", OP_OR, "OR", OP_XOR, "XOR", OP_NOT, "NOT", OP_LOGNOT, "LOGNOT", OP_LSHIFT, "LSHIFT", OP_RSHIFT, "RSHIFT", OP_LT, "LT", OP_GT, "GT", OP_LE, "LE", OP_GE, "GE", OP_EQ, "EQ", OP_NE, "NE", OP_ARR_EQ, "ARR_EQ", OP_MATCH, "MATCH", OP_ENDMATCH, "ENDMATCH", OP_NMATCH, "NMATCH", OP_MATCHN, "MATCHN", OP_CALL, "CALL", OP_RET, "RET", OP_MCALL, "MCALL", OP_JMP, "JMP", OP_JMPZ, "JMPZ", OP_LOCALS, "LOCALS", OP_TRY, "TRY", OP_ENDTRY, "ENDTRY", OP_THROW, "THROW", OP_PROC, "PROC", OP_ARR_CALL, "ARR_CALL", OP_ARR_MCALL, "ARR_MCALL", OP_GETG, "GETG", OP_SETG, "SETG", OP_SETG_TC, "SETG_TC", OP_GETL, "GETL", OP_SETL, "SETL", OP_SETL_TC, "SETL_TC", OP_GETA, "GETA", OP_SETA, "SETA", OP_SETA_TC, "SETA_TC", OP_GETP, "GETP", OP_SETP, "SETP", OP_SETP_TC, "SETP_TC", OP_GETPK, "GETPK", OP_GETI, "GETI", OP_GETI_M, "GETI_M", OP_SETI, "SETI", OP_SETI_M, "SETI_M", OP_GETIK, "GETIK", OP_GETIK_M, "GETIK_M", OP_GETPUB, "GETPUB", OP_SETPUB, "SETPUB", OP_GETPUBK, "GETPUBK", OP_SELF, "SELF", OP_LOOPINIT, "LOOPINIT", OP_LOOPINCR, "LOOPINCR", OP_GETI_X, "GETI_X", OP_GETI_XK, "GETI_XK", OP_SETI_X, "SETI_X", OP_BREAKPOINT, "BREAKPOINT", OP_DEBUG_POP, "DEBUG_POP", OP_LINE, "LINE", OP_DEBUG_PRINT, "DEBUG_PRINT", OP_BREAK_HALT, "BREAK_HALT", OP_NIL, "NIL", OP_FLT_0, "FLT_0", OP_INT_0, "INT_0", OP_DBL_0, "DBL_0", OP_I64_0, "I64_0", OP_WCH_0, "WCH_0", OP_F16_0, "F16_0", OP_U16_0, "U16_0", OP_I16_0, "I16_0", OP_U8_0, "U8_0", OP_I8_0, "I8_0", OP_CHR_0, "CHR_0", OP_FALSE, "FALSE", OP_TRUE, "TRUE", OP_ARG_0, "ARG_0", OP_INT_8, "INT_8", OP_I64_8, "I64_8", OP_WCH_8, "WCH_8", OP_U16_8, "U16_8", OP_I16_8, "I16_8", OP_U8_8, "U8_8", OP_I8_8, "I8_8", OP_CHR_8, "CHR_8", OP_TYP_8, "TYP_8", OP_EXCP_8, "EXCP_8", OP_LOCAL_8, "LOCAL_8", OP_ARG_8, "ARG_8", OP_BUILTIN, "BUILTIN", OP_FILE_8, "FILE_8", OP_INT_16, "INT_16", OP_FLT_16, "FLT_16", OP_I64_16, "I64_16", OP_DBL_16, "DBL_16", OP_WCH_16, "WCH_16", OP_F16_16, "F16_16", OP_U16_16, "U16_16", OP_I16_16, "I16_16", OP_LOCAL_16, "LOCAL_16", OP_ARG_16, "ARG_16", OP_DEBUG_PUSH, "DEBUG_PUSH", OP_FLT_24, "FLT_24", OP_DBL_24, "DBL_24", OP_WCH_24, "WCH_24", OP_ADDRESS, "ADDRESS", OP_PARENT, "PARENT", OP_DBL_32, "DBL_32", OP_I64_32, "I64_32", OP_DEBUG_VAR, "DEBUG_VAR", OP_FILE, "FILE", OP_DEBUG_PUSH_NS, "DEBUG_PUSH_NS", OP_VAR_64, "VAR_64" >>>; var typeTab = <<< #if(oadl::MAXINT <= 0x1FFFFFFF) // 32-bit 0, "Float", 1, "Int", 2, "Double", 3, "Long", #else // 64-bit 0, "Double", 1, "Long", 2, "Float", 3, "Int", #endif 4, "Ulong", 5, "Uint", 6, "Array", 7, "Object", 16, "Pointer", 17, "Dict", 18, "Proc", 19, "Extern", 20, "Public", 21, "Except", 22, "File", 23, "ArrayType", 32, "$GLOBAL$", 33, "$LOCAL$", 34, "$ARG$", 35, "$PROP$", 36, "$INTR$", 54, "WideChar", 55, "Half", 56, "Ushort", 57, "Short", 58, "Ubyte", 59, "Byte", 60, "Char", 61, "Type", 62, "Bool", 63, "Null" >>>; var builtinTab = <<< BI_ARG, "ARG", BI_NARGS, "NARGS", BI_ARGVEC, "ARGVEC", BI_GETLOCAL, "GETLOCAL", BI_SETLOCAL, "SETLOCAL", BI_TYPEOF, "TYPEOF", BI_TYPECHECK, "TYPECHECK", BI_IS_A, "IS_A", BI_ISARRAY, "ISARRAY", BI_ISINT, "ISINT", BI_ISFLOAT, "ISFLOAT", BI_ISCHAR, "ISCHAR", BI_ISSTRING, "ISSTRING", BI_COPY, "COPY", BI_PERM, "PERM", BI_GC, "GC", BI_PROTECT, "PROTECT", BI_DEEP_COPY, "DEEP_COPY", BI_READONLY, "READONLY", BI_TRANSIENT, "TRANSIENT", BI_SETJMP, "SETJMP", BI_LONGJMP, "LONGJMP", BI_HALT, "HALT", BI_SAVE, "SAVE", BI_RESTORE, "RESTORE", BI_RESTART, "RESTART", BI_FIX2FLT, "FIX2FLT", BI_FLT2FIX, "FLT2FIX", BI_MIN, "MIN", BI_MAX, "MAX", BI_CLAMP, "CLAMP", BI_LERP, "LERP", BI_SATADD, "SATADD", BI_SATSUB, "SATSUB", BI_ABS, "ABS", BI_SIGNUM, "SIGNUM", BI_INTR_PUSH, "INTR_PUSH", BI_INTR_POP, "INTR_POP", BI_INTR_EXIT, "INTR_EXIT", BI_ARRAY, "ARRAY", BI_PACKED, "PACKED", BI_STRING, "STRING", BI_LSTRING, "LSTRING", BI_PACK, "PACK", BI_UNPACK, "UNPACK", BI_ISARRAY, "ISARRAY", BI_LENGTH, "LENGTH", BI_SHAPE, "SHAPE", BI_RANK, "RANK", BI_CONCAT, "CONCAT", BI_SUBR, "SUBR", BI_ITERATE, "ITERATE", BI_RESHAPE, "RESHAPE", BI_DICT, "DICT", BI_SIZEOF, "SIZEOF", BI_REDUCE, "REDUCE", BI_ACCUM, "ACCUM", BI_INNER, "INNER", BI_ENCLOSE, "ENCLOSE", BI_OUTER, "OUTER", BI_REPLICATE, "REPLICATE", BI_REVERSE, "REVERSE", BI_ROTATE, "ROTATE", BI_TRANSPOSE, "TRANSPOSE", BI_TAKE, "TAKE", BI_DROP, "DROP", BI_UNRAVEL, "UNRAVEL", BI_LAMINATE, "LAMINATE", BI_MEMBER, "MEMBER", BI_POSITION, "POSITION", BI_ENCODE, "ENCODE", BI_DECODE, "DECODE", BI_SORT, "SORT", BI_UNIQUE, "UNIQUE", BI_UNION, "UNION", BI_INTERSECT, "INTERSECT", BI_WITHOUT, "WITHOUT", BI_INCREMENT, "INCREMENT", BI_STRIDE, "STRIDE", BI_GETIDX, "GETIDX", BI_SETIDX, "SETIDX", BI_ARRCMP, "ARRCMP", BI_FLATTEN, "FLATTEN", BI_SAY, "SAY", BI_CLOSE, "CLOSE", BI_READSTR, "READSTR", BI_PRINT, "PRINT", BI_READ, "READ", BI_WRITE, "WRITE", BI_FORMAT, "FORMAT", BI_REWIND, "REWIND", BI_FSEEK, "FSEEK", BI_GETCHAR, "GETCHAR", BI_PUTCHAR, "PUTCHAR", BI_FFLUSH, "FFLUSH", BI_FERROR, "FERROR", BI_FEOF, "FEOF", BI_FTELL, "FTELL", BI_BINARY, "BINARY", BI_ISPIPE, "ISPIPE", BI_GETSWAB, "GETSWAB", BI_SETSWAB, "SETSWAB", BI_CLEARERR, "CLEARERR", BI_NEW, "NEW", BI_TYPECONV, "TYPECONV", BI_ASSERT, "ASSERT", BI_MKLIST, "MKLIST", BI_MKDICT, "MKDICT", BI_MKARR, "MKARR", BI_MIN_N, "MIN_N", BI_MAX_N, "MAX_N", BI_CONCAT_N, "CONCAT_N", BI_ITERATOR, "ITERATOR", BI_MKSUBARR, "MKSUBARR" >>>; #else // ] [ var OADL_OpcodeSizes; var OADL_op0types, OADL_op8types, OADL_op16types; proc OADL_InstrCount, OADL_Decode; var opcodeTab, typeTab, builtinTab; #endif // ] }