http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json new file mode 100644 index 0000000..41de1c2 --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json @@ -0,0 +1,1497 @@ +{ + "opcodes": [ + { + "args": [ + "A_R", + "BC_R" + ], + "name": "LDREG" + }, + { + "args": [ + "A_R", + "BC_R" + ], + "name": "STREG" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "LDCONST" + }, + { + "args": [ + "A_R", + "BC_LDINT" + ], + "name": "LDINT" + }, + { + "args": [ + "A_R", + "BC_LDINTX" + ], + "name": "LDINTX" + }, + { + "args": [ + "A_R", + "B_R", + "C_I" + ], + "name": "MPUTOBJ" + }, + { + "args": [ + "A_R", + "B_RI", + "C_I" + ], + "name": "MPUTOBJI" + }, + { + "args": [ + "A_R", + "B_R", + "C_I" + ], + "name": "MPUTARR" + }, + { + "args": [ + "A_R", + "B_RI", + "C_I" + ], + "name": "MPUTARRI" + }, + { + "args": [ + "B_R", + "C_I" + ], + "name": "NEW" + }, + { + "args": [ + "B_RI", + "C_I" + ], + "name": "NEWI" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "REGEXP" + }, + { + "args": [ + "A_R", + "B_R" + ], + "name": "CSREG" + }, + { + "args": [ + "A_RI", + "B_R" + ], + "name": "CSREGI" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "GETVAR" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "PUTVAR" + }, + { + "args": [ + "A_H", + "B_RC", + "C_RC" + ], + "flags": [ + { + "mask": 64, + "name": "writable" + }, + { + "mask": 128, + "name": "enumerable" + }, + { + "mask": 256, + "name": "configurable" + }, + { + "mask": 512, + "name": "accessor" + }, + { + "mask": 1024, + "name": "undef_value" + }, + { + "mask": 2048, + "name": "func_decl" + } + ], + "name": "DECLVAR" + }, + { + "args": [ + "A_R", + "B_RC" + ], + "name": "DELVAR" + }, + { + "args": [ + "A_R", + "B_RC" + ], + "name": "CSVAR" + }, + { + "args": [ + "A_RI", + "B_RC" + ], + "name": "CSVARI" + }, + { + "args": [ + "A_R", + "BC_I" + ], + "name": "CLOSURE" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "GETPROP" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "PUTPROP" + }, + { + "args": [ + "A_R", + "B_R", + "C_RC" + ], + "name": "DELPROP" + }, + { + "args": [ + "A_R", + "B_R", + "C_RC" + ], + "name": "CSPROP" + }, + { + "args": [ + "A_RI", + "B_R", + "C_RC" + ], + "name": "CSPROPI" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "ADD" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "SUB" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "MUL" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "DIV" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "MOD" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BAND" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BOR" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BXOR" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BASL" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BLSR" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "BASR" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "EQ" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "NEQ" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "SEQ" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "SNEQ" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "GT" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "GE" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "LT" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "LE" + }, + { + "args": [ + "A_B", + "B_RC" + ], + "name": "IF" + }, + { + "args": [ + "ABC_JUMP" + ], + "name": "JUMP" + }, + { + "args": [ + "A_H", + "B_RC" + ], + "flags": [ + { + "mask": 64, + "name": "have_retval" + } + ], + "name": "RETURN" + }, + { + "args": [ + "A_H", + "B_R", + "C_I" + ], + "flags": [ + { + "mask": 64, + "name": "tailcall" + }, + { + "mask": 128, + "name": "evalcall" + } + ], + "name": "CALL" + }, + { + "args": [ + "A_H", + "B_RI", + "C_I" + ], + "name": "CALLI" + }, + { + "args": [ + "A_H", + "BC_R" + ], + "flags": [ + { + "mask": 64, + "name": "have_catch" + }, + { + "mask": 128, + "name": "have_finally" + }, + { + "mask": 256, + "name": "catch_binding" + }, + { + "mask": 512, + "name": "with_binding" + } + ], + "name": "TRYCATCH" + }, + { + "name": "EXTRA", + "extra": true + }, + { + "args": [ + "A_R", + "BC_R" + ], + "name": "PREINCR" + }, + { + "args": [ + "A_R", + "BC_R" + ], + "name": "PREDECR" + }, + { + "args": [ + "A_R", + "BC_R" + ], + "name": "POSTINCR" + }, + { + "args": [ + "A_R", + "BC_R" + ], + "name": "POSTDECR" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "PREINCV" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "PREDECV" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "POSTINCV" + }, + { + "args": [ + "A_R", + "BC_C" + ], + "name": "POSTDECV" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "PREINCP" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "PREDECP" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "POSTINCP" + }, + { + "args": [ + "A_R", + "B_RC", + "C_RC" + ], + "name": "POSTDECP" + } + ], + "client_commands": [ + "Reserved_0", + "Status", + "Print", + "Alert", + "Log", + "Throw", + "Detaching", + "AppNotify" + ], + "extra": [ + { + "name": "NOP" + }, + { + "args": [ + "BC_I" + ], + "name": "INVALID" + }, + { + "args": [ + "BC_R" + ], + "name": "LDTHIS" + }, + { + "args": [ + "BC_R" + ], + "name": "LDUNDEF" + }, + { + "args": [ + "BC_R" + ], + "name": "LDNULL" + }, + { + "args": [ + "BC_R" + ], + "name": "LDTRUE" + }, + { + "args": [ + "BC_R" + ], + "name": "LDFALSE" + }, + { + "args": [ + "B_R" + ], + "name": "NEWOBJ" + }, + { + "args": [ + "B_R" + ], + "name": "NEWARR" + }, + { + "args": [ + "B_R", + "C_R" + ], + "name": "SETALEN" + }, + { + "args": [ + "BC_R" + ], + "name": "TYPEOF" + }, + { + "args": [ + "B_R", + "C_RC" + ], + "name": "TYPEOFID" + }, + { + "args": [ + "B_R", + "C_R" + ], + "name": "INITENUM" + }, + { + "args": [ + "B_R", + "C_R" + ], + "name": "NEXTENUM" + }, + { + "args": [ + "B_R", + "C_R" + ], + "name": "INITSET" + }, + { + "args": [ + "B_R", + "C_RI" + ], + "name": "INITSETI" + }, + { + "args": [ + "B_R", + "C_RI" + ], + "name": "INITGET" + }, + { + "args": [ + "B_R", + "C_RI" + ], + "name": "INITGETI" + }, + { + "name": "ENDTRY" + }, + { + "name": "ENDCATCH" + }, + { + "name": "ENDFIN" + }, + { + "args": [ + "BC_R" + ], + "name": "THROW" + }, + { + "name": "INVLHS" + }, + { + "args": [ + "BC_R" + ], + "name": "UNM" + }, + { + "args": [ + "BC_R" + ], + "name": "UNP" + }, + { + "name": "DEBUGGER" + }, + { + "args": [ + "BC_I" + ], + "name": "BREAK" + }, + { + "args": [ + "BC_I" + ], + "name": "CONTINUE" + }, + { + "args": [ + "BC_R" + ], + "name": "BNOT" + }, + { + "args": [ + "BC_R" + ], + "name": "LNOT" + }, + { + "args": [ + "B_R", + "C_RC" + ], + "name": "INSTOF" + }, + { + "args": [ + "B_R", + "C_RC" + ], + "name": "IN" + }, + { + "args": [ + "BC_I" + ], + "name": "LABEL" + }, + { + "args": [ + "BC_I" + ], + "name": "ENDLABEL" + }, + { + "name": "EXTRA34" + }, + { + "name": "EXTRA35" + }, + { + "name": "EXTRA36" + }, + { + "name": "EXTRA37" + }, + { + "name": "EXTRA38" + }, + { + "name": "EXTRA39" + }, + { + "name": "EXTRA40" + }, + { + "name": "EXTRA41" + }, + { + "name": "EXTRA42" + }, + { + "name": "EXTRA43" + }, + { + "name": "EXTRA44" + }, + { + "name": "EXTRA45" + }, + { + "name": "EXTRA46" + }, + { + "name": "EXTRA47" + }, + { + "name": "EXTRA48" + }, + { + "name": "EXTRA49" + }, + { + "name": "EXTRA50" + }, + { + "name": "EXTRA51" + }, + { + "name": "EXTRA52" + }, + { + "name": "EXTRA53" + }, + { + "name": "EXTRA54" + }, + { + "name": "EXTRA55" + }, + { + "name": "EXTRA56" + }, + { + "name": "EXTRA57" + }, + { + "name": "EXTRA58" + }, + { + "name": "EXTRA59" + }, + { + "name": "EXTRA60" + }, + { + "name": "EXTRA61" + }, + { + "name": "EXTRA62" + }, + { + "name": "EXTRA63" + }, + { + "name": "EXTRA64" + }, + { + "name": "EXTRA65" + }, + { + "name": "EXTRA66" + }, + { + "name": "EXTRA67" + }, + { + "name": "EXTRA68" + }, + { + "name": "EXTRA69" + }, + { + "name": "EXTRA70" + }, + { + "name": "EXTRA71" + }, + { + "name": "EXTRA72" + }, + { + "name": "EXTRA73" + }, + { + "name": "EXTRA74" + }, + { + "name": "EXTRA75" + }, + { + "name": "EXTRA76" + }, + { + "name": "EXTRA77" + }, + { + "name": "EXTRA78" + }, + { + "name": "EXTRA79" + }, + { + "name": "EXTRA80" + }, + { + "name": "EXTRA81" + }, + { + "name": "EXTRA82" + }, + { + "name": "EXTRA83" + }, + { + "name": "EXTRA84" + }, + { + "name": "EXTRA85" + }, + { + "name": "EXTRA86" + }, + { + "name": "EXTRA87" + }, + { + "name": "EXTRA88" + }, + { + "name": "EXTRA89" + }, + { + "name": "EXTRA90" + }, + { + "name": "EXTRA91" + }, + { + "name": "EXTRA92" + }, + { + "name": "EXTRA93" + }, + { + "name": "EXTRA94" + }, + { + "name": "EXTRA95" + }, + { + "name": "EXTRA96" + }, + { + "name": "EXTRA97" + }, + { + "name": "EXTRA98" + }, + { + "name": "EXTRA99" + }, + { + "name": "EXTRA100" + }, + { + "name": "EXTRA101" + }, + { + "name": "EXTRA102" + }, + { + "name": "EXTRA103" + }, + { + "name": "EXTRA104" + }, + { + "name": "EXTRA105" + }, + { + "name": "EXTRA106" + }, + { + "name": "EXTRA107" + }, + { + "name": "EXTRA108" + }, + { + "name": "EXTRA109" + }, + { + "name": "EXTRA110" + }, + { + "name": "EXTRA111" + }, + { + "name": "EXTRA112" + }, + { + "name": "EXTRA113" + }, + { + "name": "EXTRA114" + }, + { + "name": "EXTRA115" + }, + { + "name": "EXTRA116" + }, + { + "name": "EXTRA117" + }, + { + "name": "EXTRA118" + }, + { + "name": "EXTRA119" + }, + { + "name": "EXTRA120" + }, + { + "name": "EXTRA121" + }, + { + "name": "EXTRA122" + }, + { + "name": "EXTRA123" + }, + { + "name": "EXTRA124" + }, + { + "name": "EXTRA125" + }, + { + "name": "EXTRA126" + }, + { + "name": "EXTRA127" + }, + { + "name": "EXTRA128" + }, + { + "name": "EXTRA129" + }, + { + "name": "EXTRA130" + }, + { + "name": "EXTRA131" + }, + { + "name": "EXTRA132" + }, + { + "name": "EXTRA133" + }, + { + "name": "EXTRA134" + }, + { + "name": "EXTRA135" + }, + { + "name": "EXTRA136" + }, + { + "name": "EXTRA137" + }, + { + "name": "EXTRA138" + }, + { + "name": "EXTRA139" + }, + { + "name": "EXTRA140" + }, + { + "name": "EXTRA141" + }, + { + "name": "EXTRA142" + }, + { + "name": "EXTRA143" + }, + { + "name": "EXTRA144" + }, + { + "name": "EXTRA145" + }, + { + "name": "EXTRA146" + }, + { + "name": "EXTRA147" + }, + { + "name": "EXTRA148" + }, + { + "name": "EXTRA149" + }, + { + "name": "EXTRA150" + }, + { + "name": "EXTRA151" + }, + { + "name": "EXTRA152" + }, + { + "name": "EXTRA153" + }, + { + "name": "EXTRA154" + }, + { + "name": "EXTRA155" + }, + { + "name": "EXTRA156" + }, + { + "name": "EXTRA157" + }, + { + "name": "EXTRA158" + }, + { + "name": "EXTRA159" + }, + { + "name": "EXTRA160" + }, + { + "name": "EXTRA161" + }, + { + "name": "EXTRA162" + }, + { + "name": "EXTRA163" + }, + { + "name": "EXTRA164" + }, + { + "name": "EXTRA165" + }, + { + "name": "EXTRA166" + }, + { + "name": "EXTRA167" + }, + { + "name": "EXTRA168" + }, + { + "name": "EXTRA169" + }, + { + "name": "EXTRA170" + }, + { + "name": "EXTRA171" + }, + { + "name": "EXTRA172" + }, + { + "name": "EXTRA173" + }, + { + "name": "EXTRA174" + }, + { + "name": "EXTRA175" + }, + { + "name": "EXTRA176" + }, + { + "name": "EXTRA177" + }, + { + "name": "EXTRA178" + }, + { + "name": "EXTRA179" + }, + { + "name": "EXTRA180" + }, + { + "name": "EXTRA181" + }, + { + "name": "EXTRA182" + }, + { + "name": "EXTRA183" + }, + { + "name": "EXTRA184" + }, + { + "name": "EXTRA185" + }, + { + "name": "EXTRA186" + }, + { + "name": "EXTRA187" + }, + { + "name": "EXTRA188" + }, + { + "name": "EXTRA189" + }, + { + "name": "EXTRA190" + }, + { + "name": "EXTRA191" + }, + { + "name": "EXTRA192" + }, + { + "name": "EXTRA193" + }, + { + "name": "EXTRA194" + }, + { + "name": "EXTRA195" + }, + { + "name": "EXTRA196" + }, + { + "name": "EXTRA197" + }, + { + "name": "EXTRA198" + }, + { + "name": "EXTRA199" + }, + { + "name": "EXTRA200" + }, + { + "name": "EXTRA201" + }, + { + "name": "EXTRA202" + }, + { + "name": "EXTRA203" + }, + { + "name": "EXTRA204" + }, + { + "name": "EXTRA205" + }, + { + "name": "EXTRA206" + }, + { + "name": "EXTRA207" + }, + { + "name": "EXTRA208" + }, + { + "name": "EXTRA209" + }, + { + "name": "EXTRA210" + }, + { + "name": "EXTRA211" + }, + { + "name": "EXTRA212" + }, + { + "name": "EXTRA213" + }, + { + "name": "EXTRA214" + }, + { + "name": "EXTRA215" + }, + { + "name": "EXTRA216" + }, + { + "name": "EXTRA217" + }, + { + "name": "EXTRA218" + }, + { + "name": "EXTRA219" + }, + { + "name": "EXTRA220" + }, + { + "name": "EXTRA221" + }, + { + "name": "EXTRA222" + }, + { + "name": "EXTRA223" + }, + { + "name": "EXTRA224" + }, + { + "name": "EXTRA225" + }, + { + "name": "EXTRA226" + }, + { + "name": "EXTRA227" + }, + { + "name": "EXTRA228" + }, + { + "name": "EXTRA229" + }, + { + "name": "EXTRA230" + }, + { + "name": "EXTRA231" + }, + { + "name": "EXTRA232" + }, + { + "name": "EXTRA233" + }, + { + "name": "EXTRA234" + }, + { + "name": "EXTRA235" + }, + { + "name": "EXTRA236" + }, + { + "name": "EXTRA237" + }, + { + "name": "EXTRA238" + }, + { + "name": "EXTRA239" + }, + { + "name": "EXTRA240" + }, + { + "name": "EXTRA241" + }, + { + "name": "EXTRA242" + }, + { + "name": "EXTRA243" + }, + { + "name": "EXTRA244" + }, + { + "name": "EXTRA245" + }, + { + "name": "EXTRA246" + }, + { + "name": "EXTRA247" + }, + { + "name": "EXTRA248" + }, + { + "name": "EXTRA249" + }, + { + "name": "EXTRA250" + }, + { + "name": "EXTRA251" + }, + { + "name": "EXTRA252" + }, + { + "name": "EXTRA253" + }, + { + "name": "EXTRA254" + }, + { + "name": "EXTRA255" + } + ], + "target_commands": [ + "Reserved_0", + "Reserved_1", + "Reserved_2", + "Reserved_3", + "Reserved_4", + "Reserved_5", + "Reserved_6", + "Reserved_7", + "Reserved_8", + "Reserved_9", + "Reserved_10", + "Reserved_11", + "Reserved_12", + "Reserved_13", + "Reserved_14", + "Reserved_15", + "BasicInfo", + "TriggerStatus", + "Pause", + "Resume", + "StepInto", + "StepOver", + "StepOut", + "ListBreak", + "AddBreak", + "DelBreak", + "GetVar", + "PutVar", + "GetCallStack", + "GetLocals", + "Eval", + "Detach", + "DumpHeap", + "GetBytecode", + "AppRequest", + "GetHeapObjInfo", + "GetObjPropDesc", + "GetObjPropDescRange" + ], + "error_codes": [ + "Unknown", + "UnsupportedCommand", + "TooMany", + "NotFound", + "ApplicationError" + ], + "class_names": [ + "unused", + "Arguments", + "Array", + "Boolean", + "Date", + "Error", + "Function", + "JSON", + "Math", + "Number", + "Object", + "RegExp", + "String", + "global", + "ObjEnv", + "DecEnv", + "Buffer", + "Pointer", + "Thread", + "ArrayBuffer", + "DataView", + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Uint16Array", + "Int32Array", + "Uint32Array", + "Float32Array", + "Float64Array" + ] +}
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js new file mode 100644 index 0000000..10ba614 --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js @@ -0,0 +1,1029 @@ +/* + * JSON debug proxy written in DukLuv + * + * This single file JSON debug proxy implementation is an alternative to the + * Node.js-based proxy in duk_debug.js. DukLuv is a much smaller dependency + * than Node.js so embedding DukLuv in a debug client is easier. + */ + +'use strict'; + +// XXX: Code assumes uv.write() will write fully. This is not necessarily +// true; should add support for partial writes (or at least failing when +// a partial write occurs). + +var log = new Duktape.Logger('Proxy'); // default logger +//log.l = 0; // enable debug and trace logging + +/* + * Config + */ + +var serverHost = '0.0.0.0'; +var serverPort = 9093; +var targetHost = '127.0.0.1'; +var targetPort = 9091; +var singleConnection = false; +var readableNumberValue = false; +var lenientJsonParse = false; +var jxParse = false; +var metadataFile = null; +var metadata = {}; +var TORTURE = false; // for manual testing of binary/json parsing robustness + +/* + * Detect missing 'var' declarations + */ + +// Prevent new bindings on global object. This detects missing 'var' +// declarations, e.g. "x = 123;" in a function without declaring it. +var global = new Function('return this;')(); +log.debug('Preventing extensions on global object'); +log.debug('Global is extensible:', Object.isExtensible(global)); +Object.preventExtensions(global); +log.debug('Global is extensible:', Object.isExtensible(global)); + +/* + * Misc helpers + */ + +function plainBufferCopy(typedarray) { + // This is still pretty awkward in Duktape 1.4.x. + // Argument may be a "slice" and we want a copy of the slice + // (not the full underlying buffer). + + var u8 = new Uint8Array(typedarray.length); + u8.set(typedarray); // make a copy, ensuring there's no slice offset + return Duktape.Buffer(u8); // get underlying plain buffer +} + +function isObject(x) { + // Note that typeof null === 'object'. + return (typeof x === 'object' && x !== null); +} + +function readFully(filename, cb) { + uv.fs_open(metadataFile, 'r', 0, function (handle, err) { + var fileOff = 0; + var data = new Uint8Array(256); + var dataOff = 0; + + if (err) { + return cb(null, err); + } + function readCb(buf, err) { + var res; + var newData; + + log.debug('Read callback:', buf.length, err); + if (err) { + uv.fs_close(handle); + return cb(null, err); + } + if (buf.length == 0) { + uv.fs_close(handle); + res = new Uint8Array(dataOff); + res.set(data.subarray(0, dataOff)); + res = Duktape.Buffer(res); // plain buffer + log.debug('Read', res.length, 'bytes from', filename); + return cb(res, null); + } + while (data.length - dataOff < buf.length) { + log.debug('Resize file read buffer:', data.length, '->', data.length * 2); + newData = new Uint8Array(data.length * 2); + newData.set(data); + data = newData; + } + data.set(new Uint8Array(buf), dataOff); + dataOff += buf.length; + fileOff += buf.length; + uv.fs_read(handle, 4096, fileOff, readCb); + } + uv.fs_read(handle, 4096, fileOff, readCb); + }); +} + +/* + * JSON proxy server + * + * Accepts an incoming JSON proxy client and connects to a debug target, + * tying the two connections together. Supports both a single connection + * and a persistent mode. + */ + +function JsonProxyServer(host, port) { + this.name = 'JsonProxyServer'; + this.handle = uv.new_tcp(); + uv.tcp_bind(this.handle, host, port); + uv.listen(this.handle, 128, this.onConnection.bind(this)); +} + +JsonProxyServer.prototype.onConnection = function onConnection(err) { + if (err) { + log.error('JSON proxy onConnection error:', err); + return; + } + log.info('JSON proxy client connected'); // XXX: it'd be nice to log remote peer host:port + + var jsonSock = new JsonConnHandler(this); + var targSock = new TargetConnHandler(this); + jsonSock.targetHandler = targSock; + targSock.jsonHandler = jsonSock; + uv.accept(this.handle, jsonSock.handle); + + log.info('Connecting to debug target at', targetHost + ':' + targetPort); + jsonSock.writeJson({ notify: '_TargetConnecting', args: [ targetHost, targetPort ] }); + uv.tcp_connect(targSock.handle, targetHost, targetPort, targSock.onConnect.bind(targSock)); + + if (singleConnection) { + log.info('Single connection mode, stop listening for more connections'); + uv.shutdown(this.handle); + uv.read_stop(this.handle); // unnecessary but just in case + uv.close(this.handle); + this.handle = null; + } +}; + +JsonProxyServer.prototype.onProxyClientDisconnected = function onProxyClientDisconnected() { + // When this is invoked the proxy connection and the target connection + // have both been closed. + if (singleConnection) { + log.info('Proxy connection finished (single connection mode: we should be exiting now)'); + } else { + log.info('Proxy connection finished (persistent mode: wait for more connections)'); + } +}; + +/* + * JSON connection handler + */ + +function JsonConnHandler(server) { + var i, n; + + this.name = 'JsonConnHandler'; + this.server = server; + this.handle = uv.new_tcp(); + this.incoming = new Uint8Array(4096); + this.incomingOffset = 0; + this.targetHandler = null; + + this.commandNumberLookup = {}; + if (metadata && metadata.target_commands) { + for (i = 0, n = metadata.target_commands.length; i < n; i++) { + this.commandNumberLookup[metadata.target_commands[i]] = i; + } + } +} + +JsonConnHandler.prototype.finish = function finish(msg) { + var args; + + if (!this.handle) { + log.info('JsonConnHandler already disconnected, ignore finish()'); + return; + } + log.info('JsonConnHandler finished:', msg); + try { + args = msg ? [ msg ] : void 0; + this.writeJson({ notify: '_Disconnecting', args: args }); + } catch (e) { + log.info('Failed to write _Disconnecting notify, ignoring:', e); + } + uv.shutdown(this.handle); + uv.read_stop(this.handle); + uv.close(this.handle); + this.handle = null; + + this.targetHandler.finish(msg); // disconnect target too (if not already disconnected) + + this.server.onProxyClientDisconnected(); +}; + +JsonConnHandler.prototype.onRead = function onRead(err, data) { + var newIncoming; + var msg; + var errmsg; + var tmpBuf; + + log.trace('Received data from JSON socket, err:', err, 'data length:', data ? data.length : 'null'); + + if (err) { + errmsg = 'Error reading data from JSON debug client: ' + err; + this.finish(errmsg); + return; + } + if (data) { + // Feed the data one byte at a time when torture testing. + if (TORTURE && data.length > 1) { + for (var i = 0; i < data.length; i++) { + tmpBuf = Duktape.Buffer(1); + tmpBuf[0] = data[i]; + this.onRead(null, tmpBuf); + } + return; + } + + // Receive data into 'incoming', resizing as necessary. + while (data.length > this.incoming.length - this.incomingOffset) { + newIncoming = new Uint8Array(this.incoming.length * 1.3 + 16); + newIncoming.set(this.incoming); + this.incoming = newIncoming; + log.debug('Resize incoming JSON buffer to ' + this.incoming.length); + } + this.incoming.set(new Uint8Array(data), this.incomingOffset); + this.incomingOffset += data.length; + + // Trial parse JSON message(s). + while (true) { + msg = this.trialParseJsonMessage(); + if (!msg) { + break; + } + try { + this.dispatchJsonMessage(msg); + } catch (e) { + errmsg = 'JSON message dispatch failed: ' + e; + this.writeJson({ notify: '_Error', args: [ errmsg ] }); + if (lenientJsonParse) { + log.warn('JSON message dispatch failed (lenient mode, ignoring):', e); + } else { + log.warn('JSON message dispatch failed (dropping connection):', e); + this.finish(errmsg); + } + } + } + } else { + this.finish('JSON proxy client disconnected'); + } +}; + +JsonConnHandler.prototype.writeJson = function writeJson(msg) { + log.info('PROXY --> CLIENT:', JSON.stringify(msg)); + if (this.handle) { + uv.write(this.handle, JSON.stringify(msg) + '\n'); + } +}; + +JsonConnHandler.prototype.handleDebugMessage = function handleDebugMessage(dvalues) { + var msg = {}; + var idx = 0; + var cmd; + + if (dvalues.length <= 0) { + throw new Error('invalid dvalues list: length <= 0'); + } + var x = dvalues[idx++]; + if (!isObject(x)) { + throw new Error('invalid initial dvalue: ' + Duktape.enc('jx', dvalues)); + } + if (x.type === 'req') { + cmd = dvalues[idx++]; + if (typeof cmd !== 'number') { + throw new Error('invalid command: ' + Duktape.enc('jx', cmd)); + } + msg.request = this.determineCommandName(cmd) || true; + msg.command = cmd; + } else if (x.type === 'rep') { + msg.reply = true; + } else if (x.type === 'err') { + msg.error = true; + } else if (x.type === 'nfy') { + cmd = dvalues[idx++]; + if (typeof cmd !== 'number') { + throw new Error('invalid command: ' + Duktape.enc('jx', cmd)); + } + msg.notify = this.determineCommandName(cmd) || true; + msg.command = cmd; + } else { + throw new Error('invalid initial dvalue: ' + Duktape.enc('jx', dvalues)); + } + + for (; idx < dvalues.length - 1; idx++) { + if (!msg.args) { + msg.args = []; + } + msg.args.push(dvalues[idx]); + } + + if (!isObject(dvalues[idx]) || dvalues[idx].type !== 'eom') { + throw new Error('invalid final dvalue: ' + Duktape.enc('jx', dvalues)); + } + + this.writeJson(msg); +}; + +JsonConnHandler.prototype.determineCommandName = function determineCommandName(cmd) { + if (!(metadata && metadata.client_commands)) { + return; + } + return metadata.client_commands[cmd]; +}; + +JsonConnHandler.prototype.trialParseJsonMessage = function trialParseJsonMessage() { + var buf = this.incoming; + var avail = this.incomingOffset; + var i; + var msg, str, errmsg; + + for (i = 0; i < avail; i++) { + if (buf[i] == 0x0a) { + str = String(plainBufferCopy(buf.subarray(0, i))); + try { + if (jxParse) { + msg = Duktape.dec('jx', str); + } else { + msg = JSON.parse(str); + } + } catch (e) { + // In lenient mode if JSON parse fails just send back an _Error + // and ignore the line (useful for initial development). + // + // In non-lenient mode drop the connection here; if the failed line + // was a request the client is expecting a reply/error message back + // (otherwise it may go out of sync) but we can't send a synthetic + // one (as we can't parse the request). + errmsg = 'JSON parse failed for: ' + JSON.stringify(str) + ': ' + e; + this.writeJson({ notify: '_Error', args: [ errmsg ] }); + if (lenientJsonParse) { + log.warn('JSON parse failed (lenient mode, ignoring):', e); + } else { + log.warn('JSON parse failed (dropping connection):', e); + this.finish(errmsg); + } + } + + this.incoming.set(this.incoming.subarray(i + 1)); + this.incomingOffset -= i + 1; + return msg; + } + } +}; + +JsonConnHandler.prototype.dispatchJsonMessage = function dispatchJsonMessage(msg) { + var cmd; + var dvalues = []; + var i, n; + + log.info('PROXY <-- CLIENT:', JSON.stringify(msg)); + + // Parse message type, determine initial marker for binary message. + if (msg.request) { + cmd = this.determineCommandNumber(msg.request, msg.command); + dvalues.push(new Uint8Array([ 0x01 ])); + dvalues.push(this.encodeJsonDvalue(cmd)); + } else if (msg.reply) { + dvalues.push(new Uint8Array([ 0x02 ])); + } else if (msg.notify) { + cmd = this.determineCommandNumber(msg.notify, msg.command); + dvalues.push(new Uint8Array([ 0x04 ])); + dvalues.push(this.encodeJsonDvalue(cmd)); + } else if (msg.error) { + dvalues.push(new Uint8Array([ 0x03 ])); + } else { + throw new Error('invalid input JSON message: ' + JSON.stringify(msg)); + } + + // Encode arguments into dvalues. + for (i = 0, n = (msg.args ? msg.args.length : 0); i < n; i++) { + dvalues.push(this.encodeJsonDvalue(msg.args[i])); + } + + // Add an EOM, and write out the dvalues to the debug target. + dvalues.push(new Uint8Array([ 0x00 ])); + for (i = 0, n = dvalues.length; i < n; i++) { + this.targetHandler.writeBinary(dvalues[i]); + } +}; + +JsonConnHandler.prototype.determineCommandNumber = function determineCommandNumber(name, val) { + var res; + + if (typeof name === 'string') { + res = this.commandNumberLookup[name]; + if (!res) { + log.info('Unknown command name: ' + name + ', command number: ' + val); + } + } else if (typeof name === 'number') { + res = name; + } else if (name !== true) { + throw new Error('invalid command name (must be string, number, or "true"): ' + name); + } + if (typeof res === 'undefined' && typeof val === 'undefined') { + throw new Error('cannot determine command number from name: ' + name); + } + if (typeof val !== 'number' && typeof val !== 'undefined') { + throw new Error('invalid command number: ' + val); + } + res = res || val; + return res; +}; + +JsonConnHandler.prototype.writeDebugStringToBuffer = function writeDebugStringToBuffer(v, buf, off) { + var i, n; + + for (i = 0, n = v.length; i < n; i++) { + buf[off + i] = v.charCodeAt(i) & 0xff; // truncate higher bits + } +}; + +JsonConnHandler.prototype.encodeJsonDvalue = function encodeJsonDvalue(v) { + var buf, dec, len, dv; + + if (isObject(v)) { + if (v.type === 'eom') { + return new Uint8Array([ 0x00 ]); + } else if (v.type === 'req') { + return new Uint8Array([ 0x01 ]); + } else if (v.type === 'rep') { + return new Uint8Array([ 0x02 ]); + } else if (v.type === 'err') { + return new Uint8Array([ 0x03 ]); + } else if (v.type === 'nfy') { + return new Uint8Array([ 0x04 ]); + } else if (v.type === 'unused') { + return new Uint8Array([ 0x15 ]); + } else if (v.type === 'undefined') { + return new Uint8Array([ 0x16 ]); + } else if (v.type === 'number') { + dec = Duktape.dec('hex', v.data); + len = dec.length; + if (len !== 8) { + throw new TypeError('value cannot be converted to dvalue: ' + JSON.stringify(v)); + } + buf = new Uint8Array(1 + len); + buf[0] = 0x1a; + buf.set(new Uint8Array(dec), 1); + return buf; + } else if (v.type === 'buffer') { + dec = Duktape.dec('hex', v.data); + len = dec.length; + if (len <= 0xffff) { + buf = new Uint8Array(3 + len); + buf[0] = 0x14; + buf[1] = (len >> 8) & 0xff; + buf[2] = (len >> 0) & 0xff; + buf.set(new Uint8Arrau(dec), 3); + return buf; + } else { + buf = new Uint8Array(5 + len); + buf[0] = 0x13; + buf[1] = (len >> 24) & 0xff; + buf[2] = (len >> 16) & 0xff; + buf[3] = (len >> 8) & 0xff; + buf[4] = (len >> 0) & 0xff; + buf.set(new Uint8Array(dec), 5); + return buf; + } + } else if (v.type === 'object') { + dec = Duktape.dec('hex', v.pointer); + len = dec.length; + buf = new Uint8Array(3 + len); + buf[0] = 0x1b; + buf[1] = v.class; + buf[2] = len; + buf.set(new Uint8Array(dec), 3); + return buf; + } else if (v.type === 'pointer') { + dec = Duktape.dec('hex', v.pointer); + len = dec.length; + buf = new Uint8Array(2 + len); + buf[0] = 0x1c; + buf[1] = len; + buf.set(new Uint8Array(dec), 2); + return buf; + } else if (v.type === 'lightfunc') { + dec = Duktape.dec('hex', v.pointer); + len = dec.length; + buf = new Uint8Array(4 + len); + buf[0] = 0x1d; + buf[1] = (v.flags >> 8) & 0xff; + buf[2] = v.flags & 0xff; + buf[3] = len; + buf.set(new Uint8Array(dec), 4); + return buf; + } else if (v.type === 'heapptr') { + dec = Duktape.dec('hex', v.pointer); + len = dec.length; + buf = new Uint8Array(2 + len); + buf[0] = 0x1e; + buf[1] = len; + buf.set(new Uint8Array(dec), 2); + return buf; + } + } else if (v === null) { + return new Uint8Array([ 0x17 ]); + } else if (typeof v === 'boolean') { + return new Uint8Array([ v ? 0x18 : 0x19 ]); + } else if (typeof v === 'number') { + if (Math.floor(v) === v && /* whole */ + (v !== 0 || 1 / v > 0) && /* not negative zero */ + v >= -0x80000000 && v <= 0x7fffffff) { + // Represented signed 32-bit integers as plain integers. + // Debugger code expects this for all fields that are not + // duk_tval representations (e.g. command numbers and such). + if (v >= 0x00 && v <= 0x3f) { + return new Uint8Array([ 0x80 + v ]); + } else if (v >= 0x0000 && v <= 0x3fff) { + return new Uint8Array([ 0xc0 + (v >> 8), v & 0xff ]); + } else if (v >= -0x80000000 && v <= 0x7fffffff) { + return new Uint8Array([ 0x10, + (v >> 24) & 0xff, + (v >> 16) & 0xff, + (v >> 8) & 0xff, + (v >> 0) & 0xff ]); + } else { + throw new Error('internal error when encoding integer to dvalue: ' + v); + } + } else { + // Represent non-integers as IEEE double dvalues. + buf = new Uint8Array(1 + 8); + buf[0] = 0x1a; + new DataView(buf).setFloat64(1, v, false); + return buf; + } + } else if (typeof v === 'string') { + if (v.length < 0 || v.length > 0xffffffff) { + // Not possible in practice. + throw new TypeError('cannot convert to dvalue, invalid string length: ' + v.length); + } + if (v.length <= 0x1f) { + buf = new Uint8Array(1 + v.length); + buf[0] = 0x60 + v.length; + this.writeDebugStringToBuffer(v, buf, 1); + return buf; + } else if (v.length <= 0xffff) { + buf = new Uint8Array(3 + v.length); + buf[0] = 0x12; + buf[1] = (v.length >> 8) & 0xff; + buf[2] = (v.length >> 0) & 0xff; + this.writeDebugStringToBuffer(v, buf, 3); + return buf; + } else { + buf = new Uint8Array(5 + v.length); + buf[0] = 0x11; + buf[1] = (v.length >> 24) & 0xff; + buf[2] = (v.length >> 16) & 0xff; + buf[3] = (v.length >> 8) & 0xff; + buf[4] = (v.length >> 0) & 0xff; + this.writeDebugStringToBuffer(v, buf, 5); + return buf; + } + } + + throw new TypeError('value cannot be converted to dvalue: ' + JSON.stringify(v)); +}; + +/* + * Target binary connection handler + */ + +function TargetConnHandler(server) { + this.name = 'TargetConnHandler'; + this.server = server; + this.handle = uv.new_tcp(); + this.jsonHandler = null; + this.incoming = new Uint8Array(4096); + this.incomingOffset = 0; + this.dvalues = []; +} + +TargetConnHandler.prototype.finish = function finish(msg) { + if (!this.handle) { + log.info('TargetConnHandler already disconnected, ignore finish()'); + return; + } + log.info('TargetConnHandler finished:', msg); + + this.jsonHandler.writeJson({ notify: '_TargetDisconnected' }); + + // XXX: write a notify to target? + + uv.shutdown(this.handle); + uv.read_stop(this.handle); + uv.close(this.handle); + this.handle = null; + + this.jsonHandler.finish(msg); // disconnect JSON client too (if not already disconnected) +}; + +TargetConnHandler.prototype.onConnect = function onConnect(err) { + var errmsg; + + if (err) { + errmsg = 'Failed to connect to target: ' + err; + log.warn(errmsg); + this.jsonHandler.writeJson({ notify: '_Error', args: [ String(err) ] }); + this.finish(errmsg); + return; + } + + // Once we're connected to the target, start read both binary and JSON + // input. We don't want to read JSON input before this so that we can + // always translate incoming messages to dvalues and write them out + // without queueing. Any pending JSON messages will be queued by the + // OS instead. + + log.info('Connected to debug target at', targetHost + ':' + targetPort); + uv.read_start(this.jsonHandler.handle, this.jsonHandler.onRead.bind(this.jsonHandler)); + uv.read_start(this.handle, this.onRead.bind(this)); +}; + +TargetConnHandler.prototype.writeBinary = function writeBinary(buf) { + var plain = plainBufferCopy(buf); + log.info('PROXY --> TARGET:', Duktape.enc('jx', plain)); + if (this.handle) { + uv.write(this.handle, plain); + } +}; + +TargetConnHandler.prototype.onRead = function onRead(err, data) { + var res; + var errmsg; + var tmpBuf; + var newIncoming; + + log.trace('Received data from target socket, err:', err, 'data length:', data ? data.length : 'null'); + + if (err) { + errmsg = 'Error reading data from debug target: ' + err; + this.finish(errmsg); + return; + } + + if (data) { + // Feed the data one byte at a time when torture testing. + if (TORTURE && data.length > 1) { + for (var i = 0; i < data.length; i++) { + tmpBuf = Duktape.Buffer(1); + tmpBuf[0] = data[i]; + this.onRead(null, tmpBuf); + } + return; + } + + // Receive data into 'incoming', resizing as necessary. + while (data.length > this.incoming.length - this.incomingOffset) { + newIncoming = new Uint8Array(this.incoming.length * 1.3 + 16); + newIncoming.set(this.incoming); + this.incoming = newIncoming; + log.debug('Resize incoming binary buffer to ' + this.incoming.length); + } + this.incoming.set(new Uint8Array(data), this.incomingOffset); + this.incomingOffset += data.length; + + // Trial parse handshake unless done. + if (!this.handshake) { + this.trialParseHandshake(); + } + + // Trial parse dvalue(s) and debug messages. + if (this.handshake) { + for (;;) { + res = this.trialParseDvalue(); + if (!res) { + break; + } + log.trace('Got dvalue:', Duktape.enc('jx', res.dvalue)); + this.dvalues.push(res.dvalue); + if (isObject(res.dvalue) && res.dvalue.type === 'eom') { + try { + this.jsonHandler.handleDebugMessage(this.dvalues); + this.dvalues = []; + } catch (e) { + errmsg = 'JSON message handling failed: ' + e; + this.jsonHandler.writeJson({ notify: '_Error', args: [ errmsg ] }); + if (lenientJsonParse) { + log.warn('JSON message handling failed (lenient mode, ignoring):', e); + } else { + log.warn('JSON message handling failed (dropping connection):', e); + this.finish(errmsg); + } + } + } + } + } + } else { + log.info('Target disconnected'); + this.finish('Target disconnected'); + } +}; + +TargetConnHandler.prototype.trialParseHandshake = function trialParseHandshake() { + var buf = this.incoming; + var avail = this.incomingOffset; + var i; + var msg; + var m; + var protocolVersion; + + for (i = 0; i < avail; i++) { + if (buf[i] == 0x0a) { + msg = String(plainBufferCopy(buf.subarray(0, i))); + this.incoming.set(this.incoming.subarray(i + 1)); + this.incomingOffset -= i + 1; + + // Generic handshake format: only relies on initial version field. + m = /^(\d+) (.*)$/.exec(msg) || {}; + protocolVersion = +m[1]; + this.handshake = { + line: msg, + protocolVersion: protocolVersion, + text: m[2] + }; + + // More detailed v1 handshake line. + if (protocolVersion === 1) { + m = /^(\d+) (\d+) (.*?) (.*?) (.*)$/.exec(msg) || {}; + this.handshake.dukVersion = m[1]; + this.handshake.dukGitDescribe = m[2]; + this.handshake.targetString = m[3]; + } + + this.jsonHandler.writeJson({ notify: '_TargetConnected', args: [ msg ] }); + + log.info('Target handshake: ' + JSON.stringify(this.handshake)); + return; + } + } +}; + +TargetConnHandler.prototype.bufferToDebugString = function bufferToDebugString(buf) { + return String.fromCharCode.apply(null, buf); +}; + +TargetConnHandler.prototype.trialParseDvalue = function trialParseDvalue() { + var _this = this; + var buf = this.incoming; + var avail = this.incomingOffset; + var v; + var gotValue = false; // explicit flag for e.g. v === undefined + var dv = new DataView(buf); + var tmp; + var x; + var len; + + function consume(n) { + log.info('PROXY <-- TARGET:', Duktape.enc('jx', _this.incoming.subarray(0, n))); + _this.incoming.set(_this.incoming.subarray(n)); + _this.incomingOffset -= n; + } + + x = buf[0]; + if (avail <= 0) { + ; + } else if (x >= 0xc0) { + // 0xc0...0xff: integers 0-16383 + if (avail >= 2) { + v = ((x - 0xc0) << 8) + buf[1]; + consume(2); + } + } else if (x >= 0x80) { + // 0x80...0xbf: integers 0-63 + v = x - 0x80; + consume(1); + } else if (x >= 0x60) { + // 0x60...0x7f: strings with length 0-31 + len = x - 0x60; + if (avail >= 1 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(1, 1 + len)); + v = this.bufferToDebugString(v); + consume(1 + len); + } + } else { + switch (x) { + case 0x00: consume(1); v = { type: 'eom' }; break; + case 0x01: consume(1); v = { type: 'req' }; break; + case 0x02: consume(1); v = { type: 'rep' }; break; + case 0x03: consume(1); v = { type: 'err' }; break; + case 0x04: consume(1); v = { type: 'nfy' }; break; + case 0x10: // 4-byte signed integer + if (avail >= 5) { + v = dv.getInt32(1, false); + consume(5); + } + break; + case 0x11: // 4-byte string + if (avail >= 5) { + len = dv.getUint32(1, false); + if (avail >= 5 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(5, 5 + len)); + v = this.bufferToDebugString(v); + consume(5 + len); + } + } + break; + case 0x12: // 2-byte string + if (avail >= 3) { + len = dv.getUint16(1, false); + if (avail >= 3 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(3, 3 + len)); + v = this.bufferToDebugString(v); + consume(3 + len); + } + } + break; + case 0x13: // 4-byte buffer + if (avail >= 5) { + len = dv.getUint32(1, false); + if (avail >= 5 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(5, 5 + len)); + v = { type: 'buffer', data: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(5 + len); + } + } + break; + case 0x14: // 2-byte buffer + if (avail >= 3) { + len = dv.getUint16(1, false); + if (avail >= 3 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(3, 3 + len)); + v = { type: 'buffer', data: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(3 + len); + } + } + break; + case 0x15: // unused/none + v = { type: 'unused' }; + consume(1); + break; + case 0x16: // undefined + v = { type: 'undefined' }; + gotValue = true; // indicate 'v' is actually set + consume(1); + break; + case 0x17: // null + v = null; + gotValue = true; // indicate 'v' is actually set + consume(1); + break; + case 0x18: // true + v = true; + consume(1); + break; + case 0x19: // false + v = false; + consume(1); + break; + case 0x1a: // number (IEEE double), big endian + if (avail >= 9) { + tmp = new Uint8Array(8); + tmp.set(buf.subarray(1, 9)); + v = { type: 'number', data: Duktape.enc('hex', Duktape.Buffer(tmp)) }; + if (readableNumberValue) { + // The value key should not be used programmatically, + // it is just there to make the dumps more readable. + v.value = new DataView(tmp.buffer).getFloat64(0, false); + } + consume(9); + } + break; + case 0x1b: // object + if (avail >= 3) { + len = buf[2]; + if (avail >= 3 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(3, 3 + len)); + v = { type: 'object', 'class': buf[1], pointer: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(3 + len); + } + } + break; + case 0x1c: // pointer + if (avail >= 2) { + len = buf[1]; + if (avail >= 2 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(2, 2 + len)); + v = { type: 'pointer', pointer: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(2 + len); + } + } + break; + case 0x1d: // lightfunc + if (avail >= 4) { + len = buf[3]; + if (avail >= 4 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(4, 4 + len)); + v = { type: 'lightfunc', flags: dv.getUint16(1, false), pointer: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(4 + len); + } + } + break; + case 0x1e: // heapptr + if (avail >= 2) { + len = buf[1]; + if (avail >= 2 + len) { + v = new Uint8Array(len); + v.set(buf.subarray(2, 2 + len)); + v = { type: 'heapptr', pointer: Duktape.enc('hex', Duktape.Buffer(v)) }; + consume(2 + len); + } + } + break; + default: + throw new Error('failed parse initial byte: ' + buf[0]); + } + } + + if (typeof v !== 'undefined' || gotValue) { + return { dvalue: v }; + } +}; + +/* + * Main + */ + +function main() { + var argv = typeof uv.argv === 'function' ? uv.argv() : []; + var i; + for (i = 2; i < argv.length; i++) { // skip dukluv and script name + if (argv[i] == '--help') { + print('Usage: dukluv ' + argv[1] + ' [option]+'); + print(''); + print(' --server-host HOST JSON proxy server listen address'); + print(' --server-port PORT JSON proxy server listen port'); + print(' --target-host HOST Debug target address'); + print(' --target-port PORT Debug target port'); + print(' --metadata FILE Proxy metadata file (usually named duk_debug_meta.json)'); + print(' --log-level LEVEL Set log level, default is 2; 0=trace, 1=debug, 2=info, 3=warn, etc'); + print(' --single Run a single proxy connection and exit (default: persist for multiple connections)'); + print(' --readable-numbers Add a non-programmatic "value" key for IEEE doubles help readability'); + print(' --lenient Ignore (with warning) invalid JSON without dropping connection'); + print(' --jx-parse Parse JSON proxy input with JX, useful when testing manually'); + print(''); + return; // don't register any sockets/timers etc to exit + } else if (argv[i] == '--single') { + singleConnection = true; + continue; + } else if (argv[i] == '--readable-numbers') { + readableNumberValue = true; + continue; + } else if (argv[i] == '--lenient') { + lenientJsonParse = true; + continue; + } else if (argv[i] == '--jx-parse') { + jxParse = true; + continue; + } + if (i >= argv.length - 1) { + throw new Error('missing option value for ' + argv[i]); + } + if (argv[i] == '--server-host') { + serverHost = argv[i + 1]; + i++; + } else if (argv[i] == '--server-port') { + serverPort = Math.floor(+argv[i + 1]); + i++; + } else if (argv[i] == '--target-host') { + targetHost = argv[i + 1]; + i++; + } else if (argv[i] == '--target-port') { + targetPort = Math.floor(+argv[i + 1]); + i++; + } else if (argv[i] == '--metadata') { + metadataFile = argv[i + 1]; + i++; + } else if (argv[i] == '--log-level') { + log.l = Math.floor(+argv[i + 1]); + i++; + } else { + throw new Error('invalid option ' + argv[i]); + } + } + + function runServer() { + var serverSocket = new JsonProxyServer(serverHost, serverPort); + var connMode = singleConnection ? 'single connection mode' : 'persistent connection mode'; + log.info('Listening for incoming JSON debug connection on ' + serverHost + ':' + serverPort + + ', target is ' + targetHost + ':' + targetPort + ', ' + connMode); + } + + if (metadataFile) { + log.info('Read proxy metadata from', metadataFile); + readFully(metadataFile, function (data, err) { + if (err) { + log.error('Failed to load metadata:', err); + throw err; + } + try { + metadata = JSON.parse(String(data)); + } catch (e) { + log.error('Failed to parse JSON metadata from ' + metadataFile + ': ' + e); + throw e; + } + runServer(); + }); + } else { + runServer(); + } +} + +main(); http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml new file mode 100644 index 0000000..14555c1 --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml @@ -0,0 +1,52 @@ +# Debug request/notify command names provided by the debug client. +# These are concretely notify names now. +client_commands: + - Reserved_0 + - Status + - Print + - Alert + - Log + - Throw + - Detaching + - AppNotify + +# Debug request/notify command names provided by the debug target (Duktape). +target_commands: + - Reserved_0 + - Reserved_1 + - Reserved_2 + - Reserved_3 + - Reserved_4 + - Reserved_5 + - Reserved_6 + - Reserved_7 + - Reserved_8 + - Reserved_9 + - Reserved_10 + - Reserved_11 + - Reserved_12 + - Reserved_13 + - Reserved_14 + - Reserved_15 + - BasicInfo + - TriggerStatus + - Pause + - Resume + - StepInto + - StepOver + - StepOut + - ListBreak + - AddBreak + - DelBreak + - GetVar + - PutVar + - GetCallStack + - GetLocals + - Eval + - Detach + - DumpHeap + - GetBytecode + - AppRequest + - GetHeapObjInfo + - GetObjPropDesc + - GetObjPropDescRange http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml new file mode 100644 index 0000000..500265f --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml @@ -0,0 +1,6 @@ +error_codes: + - Unknown + - UnsupportedCommand + - TooMany + - NotFound + - ApplicationError http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml new file mode 100644 index 0000000..67dbefb --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml @@ -0,0 +1,658 @@ +# Duktape opcode metadata for debugger. +# - See duk_debug.js for the argument formats (A_R etc). +# - Flag bits are for the whole instruction as a 32-bit integer, +# they are not field shifted +# +# NOTE: Use YAML comments only on comment-only lines (not trailing content): +# Node.js 'yamljs' seems to refuse parsing trailing comments in some cases. + +opcodes: + - name: LDREG + args: + - A_R + - BC_R + - name: STREG + args: + - A_R + - BC_R + - name: LDCONST + args: + - A_R + - BC_C + - name: LDINT + args: + - A_R + - BC_LDINT + - name: LDINTX + args: + - A_R + - BC_LDINTX + - name: MPUTOBJ + args: + - A_R + - B_R + - C_I + - name: MPUTOBJI + args: + - A_R + - B_RI + - C_I + - name: MPUTARR + args: + - A_R + - B_R + - C_I + - name: MPUTARRI + args: + - A_R + - B_RI + - C_I + - name: NEW + args: + - B_R + - C_I + - name: NEWI + args: + - B_RI + - C_I + - name: REGEXP + args: + - A_R + - B_RC + - C_RC + - name: CSREG + args: + - A_R + - B_R + - name: CSREGI + args: + - A_RI + - B_R + - name: GETVAR + args: + - A_R + - BC_C + - name: PUTVAR + args: + - A_R + - BC_C + - name: DECLVAR + args: + - A_H + - B_RC + - C_RC + flags: + - mask: 0x40 + name: writable + - mask: 0x80 + name: enumerable + - mask: 0x100 + name: configurable + - mask: 0x200 + name: accessor + - mask: 0x400 + name: undef_value + - mask: 0x800 + name: func_decl + - name: DELVAR + args: + - A_R + - B_RC + - name: CSVAR + args: + - A_R + - B_RC + - name: CSVARI + args: + - A_RI + - B_RC + - name: CLOSURE + args: + - A_R + - BC_I + - name: GETPROP + args: + - A_R + - B_RC + - C_RC + - name: PUTPROP + args: + - A_R + - B_RC + - C_RC + - name: DELPROP + args: + - A_R + - B_R + - C_RC + - name: CSPROP + args: + - A_R + - B_R + - C_RC + - name: CSPROPI + args: + - A_RI + - B_R + - C_RC + - name: ADD + args: + - A_R + - B_RC + - C_RC + - name: SUB + args: + - A_R + - B_RC + - C_RC + - name: MUL + args: + - A_R + - B_RC + - C_RC + - name: DIV + args: + - A_R + - B_RC + - C_RC + - name: MOD + args: + - A_R + - B_RC + - C_RC + - name: BAND + args: + - A_R + - B_RC + - C_RC + - name: BOR + args: + - A_R + - B_RC + - C_RC + - name: BXOR + args: + - A_R + - B_RC + - C_RC + - name: BASL + args: + - A_R + - B_RC + - C_RC + - name: BLSR + args: + - A_R + - B_RC + - C_RC + - name: BASR + args: + - A_R + - B_RC + - C_RC + - name: EQ + args: + - A_R + - B_RC + - C_RC + - name: NEQ + args: + - A_R + - B_RC + - C_RC + - name: SEQ + args: + - A_R + - B_RC + - C_RC + - name: SNEQ + args: + - A_R + - B_RC + - C_RC + - name: GT + args: + - A_R + - B_RC + - C_RC + - name: GE + args: + - A_R + - B_RC + - C_RC + - name: LT + args: + - A_R + - B_RC + - C_RC + - name: LE + args: + - A_R + - B_RC + - C_RC + - name: IF + args: + - A_B + - B_RC + - name: JUMP + args: + - ABC_JUMP + - name: RETURN + args: + - A_H + - B_RC + flags: + - mask: 0x40 + name: have_retval + - name: CALL + args: + - A_H + - B_R + - C_I + flags: + - mask: 0x40 + name: tailcall + - mask: 0x80 + name: evalcall + - name: CALLI + args: + - A_H + - B_RI + - C_I + - name: TRYCATCH + args: + - A_H + # base register for two consecutive regs (base_reg + 0, base_reg + 1) used for two things: + # - input: either 'with' target register or catch varname constant (base_reg + 0), depending on flags + # - output: when caught, catch value (base_reg + 0) and type (base_reg + 1) + - BC_R + flags: + - mask: 0x40 + name: have_catch + - mask: 0x80 + name: have_finally + - mask: 0x100 + name: catch_binding + - mask: 0x200 + name: with_binding + - name: EXTRA + extra: true + - name: PREINCR + args: + - A_R + - BC_R + - name: PREDECR + args: + - A_R + - BC_R + - name: POSTINCR + args: + - A_R + - BC_R + - name: POSTDECR + args: + - A_R + - BC_R + - name: PREINCV + args: + - A_R + - BC_C + - name: PREDECV + args: + - A_R + - BC_C + - name: POSTINCV + args: + - A_R + - BC_C + - name: POSTDECV + args: + - A_R + - BC_C + - name: PREINCP + args: + - A_R + - B_RC + - C_RC + - name: PREDECP + args: + - A_R + - B_RC + - C_RC + - name: POSTINCP + args: + - A_R + - B_RC + - C_RC + - name: POSTDECP + args: + - A_R + - B_RC + - C_RC + +extra: + - name: NOP + - name: INVALID + args: + - BC_I + - name: LDTHIS + args: + - BC_R + - name: LDUNDEF + args: + - BC_R + - name: LDNULL + args: + - BC_R + - name: LDTRUE + args: + - BC_R + - name: LDFALSE + args: + - BC_R + - name: NEWOBJ + args: + # XXX: extend to BC? + - B_R + - name: NEWARR + args: + # XXX: extend to BC? + - B_R + - name: SETALEN + args: + - B_R + - C_R + - name: TYPEOF + args: + - BC_R + - name: TYPEOFID + args: + - B_R + # maybe changed to C_C later + - C_RC + - name: INITENUM + args: + - B_R + - C_R + - name: NEXTENUM + args: + - B_R + - C_R + - name: INITSET + args: + - B_R + - C_R + - name: INITSETI + args: + - B_R + - C_RI + - name: INITGET + args: + - B_R + - C_RI + - name: INITGETI + args: + - B_R + - C_RI + - name: ENDTRY + - name: ENDCATCH + - name: ENDFIN + - name: THROW + args: + - BC_R + - name: INVLHS + - name: UNM + args: + - BC_R + - name: UNP + args: + - BC_R + - name: DEBUGGER + - name: BREAK + args: + - BC_I + - name: CONTINUE + args: + - BC_I + - name: BNOT + args: + - BC_R + - name: LNOT + args: + - BC_R + - name: INSTOF + args: + - B_R + - C_RC + - name: IN + args: + - B_R + - C_RC + - name: LABEL + args: + - BC_I + - name: ENDLABEL + args: + - BC_I + - name: EXTRA34 + - name: EXTRA35 + - name: EXTRA36 + - name: EXTRA37 + - name: EXTRA38 + - name: EXTRA39 + - name: EXTRA40 + - name: EXTRA41 + - name: EXTRA42 + - name: EXTRA43 + - name: EXTRA44 + - name: EXTRA45 + - name: EXTRA46 + - name: EXTRA47 + - name: EXTRA48 + - name: EXTRA49 + - name: EXTRA50 + - name: EXTRA51 + - name: EXTRA52 + - name: EXTRA53 + - name: EXTRA54 + - name: EXTRA55 + - name: EXTRA56 + - name: EXTRA57 + - name: EXTRA58 + - name: EXTRA59 + - name: EXTRA60 + - name: EXTRA61 + - name: EXTRA62 + - name: EXTRA63 + - name: EXTRA64 + - name: EXTRA65 + - name: EXTRA66 + - name: EXTRA67 + - name: EXTRA68 + - name: EXTRA69 + - name: EXTRA70 + - name: EXTRA71 + - name: EXTRA72 + - name: EXTRA73 + - name: EXTRA74 + - name: EXTRA75 + - name: EXTRA76 + - name: EXTRA77 + - name: EXTRA78 + - name: EXTRA79 + - name: EXTRA80 + - name: EXTRA81 + - name: EXTRA82 + - name: EXTRA83 + - name: EXTRA84 + - name: EXTRA85 + - name: EXTRA86 + - name: EXTRA87 + - name: EXTRA88 + - name: EXTRA89 + - name: EXTRA90 + - name: EXTRA91 + - name: EXTRA92 + - name: EXTRA93 + - name: EXTRA94 + - name: EXTRA95 + - name: EXTRA96 + - name: EXTRA97 + - name: EXTRA98 + - name: EXTRA99 + - name: EXTRA100 + - name: EXTRA101 + - name: EXTRA102 + - name: EXTRA103 + - name: EXTRA104 + - name: EXTRA105 + - name: EXTRA106 + - name: EXTRA107 + - name: EXTRA108 + - name: EXTRA109 + - name: EXTRA110 + - name: EXTRA111 + - name: EXTRA112 + - name: EXTRA113 + - name: EXTRA114 + - name: EXTRA115 + - name: EXTRA116 + - name: EXTRA117 + - name: EXTRA118 + - name: EXTRA119 + - name: EXTRA120 + - name: EXTRA121 + - name: EXTRA122 + - name: EXTRA123 + - name: EXTRA124 + - name: EXTRA125 + - name: EXTRA126 + - name: EXTRA127 + - name: EXTRA128 + - name: EXTRA129 + - name: EXTRA130 + - name: EXTRA131 + - name: EXTRA132 + - name: EXTRA133 + - name: EXTRA134 + - name: EXTRA135 + - name: EXTRA136 + - name: EXTRA137 + - name: EXTRA138 + - name: EXTRA139 + - name: EXTRA140 + - name: EXTRA141 + - name: EXTRA142 + - name: EXTRA143 + - name: EXTRA144 + - name: EXTRA145 + - name: EXTRA146 + - name: EXTRA147 + - name: EXTRA148 + - name: EXTRA149 + - name: EXTRA150 + - name: EXTRA151 + - name: EXTRA152 + - name: EXTRA153 + - name: EXTRA154 + - name: EXTRA155 + - name: EXTRA156 + - name: EXTRA157 + - name: EXTRA158 + - name: EXTRA159 + - name: EXTRA160 + - name: EXTRA161 + - name: EXTRA162 + - name: EXTRA163 + - name: EXTRA164 + - name: EXTRA165 + - name: EXTRA166 + - name: EXTRA167 + - name: EXTRA168 + - name: EXTRA169 + - name: EXTRA170 + - name: EXTRA171 + - name: EXTRA172 + - name: EXTRA173 + - name: EXTRA174 + - name: EXTRA175 + - name: EXTRA176 + - name: EXTRA177 + - name: EXTRA178 + - name: EXTRA179 + - name: EXTRA180 + - name: EXTRA181 + - name: EXTRA182 + - name: EXTRA183 + - name: EXTRA184 + - name: EXTRA185 + - name: EXTRA186 + - name: EXTRA187 + - name: EXTRA188 + - name: EXTRA189 + - name: EXTRA190 + - name: EXTRA191 + - name: EXTRA192 + - name: EXTRA193 + - name: EXTRA194 + - name: EXTRA195 + - name: EXTRA196 + - name: EXTRA197 + - name: EXTRA198 + - name: EXTRA199 + - name: EXTRA200 + - name: EXTRA201 + - name: EXTRA202 + - name: EXTRA203 + - name: EXTRA204 + - name: EXTRA205 + - name: EXTRA206 + - name: EXTRA207 + - name: EXTRA208 + - name: EXTRA209 + - name: EXTRA210 + - name: EXTRA211 + - name: EXTRA212 + - name: EXTRA213 + - name: EXTRA214 + - name: EXTRA215 + - name: EXTRA216 + - name: EXTRA217 + - name: EXTRA218 + - name: EXTRA219 + - name: EXTRA220 + - name: EXTRA221 + - name: EXTRA222 + - name: EXTRA223 + - name: EXTRA224 + - name: EXTRA225 + - name: EXTRA226 + - name: EXTRA227 + - name: EXTRA228 + - name: EXTRA229 + - name: EXTRA230 + - name: EXTRA231 + - name: EXTRA232 + - name: EXTRA233 + - name: EXTRA234 + - name: EXTRA235 + - name: EXTRA236 + - name: EXTRA237 + - name: EXTRA238 + - name: EXTRA239 + - name: EXTRA240 + - name: EXTRA241 + - name: EXTRA242 + - name: EXTRA243 + - name: EXTRA244 + - name: EXTRA245 + - name: EXTRA246 + - name: EXTRA247 + - name: EXTRA248 + - name: EXTRA249 + - name: EXTRA250 + - name: EXTRA251 + - name: EXTRA252 + - name: EXTRA253 + - name: EXTRA254 + - name: EXTRA255 http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py new file mode 100644 index 0000000..ba9b38e --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python2 +# +# Merge debugger YAML metadata files and output a merged JSON metadata file. +# + +import os, sys, json, yaml +import optparse + +if __name__ == '__main__': + parser = optparse.OptionParser() + parser.add_option('--output', dest='output', default=None, help='output JSON filename') + parser.add_option('--class-names', dest='class_names', help='YAML metadata for class names') + parser.add_option('--debug-commands', dest='debug_commands', help='YAML metadata for debug commands') + parser.add_option('--debug-errors', dest='debug_errors', help='YAML metadata for debug protocol error codes') + parser.add_option('--opcodes', dest='opcodes', help='YAML metadata for opcodes') + (opts, args) = parser.parse_args() + + res = {} + def merge(fn): + with open(fn, 'rb') as f: + doc = yaml.load(f) + for k in doc.keys(): + res[k] = doc[k] + + merge(opts.class_names) + merge(opts.debug_commands) + merge(opts.debug_errors) + merge(opts.opcodes) + + with open(opts.output, 'wb') as f: + f.write(json.dumps(res, indent=4) + '\n') + print('Wrote merged debugger metadata to ' + str(opts.output)) http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/package.json ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/package.json b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/package.json new file mode 100644 index 0000000..9616574 --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/package.json @@ -0,0 +1,27 @@ +{ + "name": "duk-debug", + "version": "0.1.0", + "description": "Duktape debugger", + "author": { + "name": "Sami Vaarala", + "email": "[email protected]" + }, + "dependencies": { + "bluebird": "~2.6.4", + "minimist": "~1.1.0", + "express": "~4.10.1", + "body-parser": "~1.9.3", + "socket.io": "~1.2.1", + "utf8": "~2.0.0", + "wrench": "~1.5.8", + "sprintf": "~0.1.5", + "events": "~1.0.2", + "stream": "0.0.2", + "readline": "0.0.5", + "util": "~0.10.3", + "http": "0.0.0", + "yamljs": "~0.2.1", + "byline": "~4.2.1" + }, + "main": "duk_debug.js" +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/a9485aeb/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/static/index.html ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/static/index.html b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/static/index.html new file mode 100644 index 0000000..5e5e2e0 --- /dev/null +++ b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/debugger/static/index.html @@ -0,0 +1,96 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8" /> +<link rel="stylesheet" href="reset.css" type="text/css" /> +<link rel="stylesheet" href="jquery-ui.min.css" type="text/css" /> +<link rel="stylesheet" href="style.css" type="text/css" /> +<title>Duktape debugger</title> +</head> +<body> + +<div id="part-header"> +((o) Duktape debugger +</div> <!-- #part-header --> + +<div id="part-middle"> + +<div id="left-area"> +<button id="stepinto-button">Step into</button> +<button id="stepover-button">Step over</button> +<button id="stepout-button">Step out</button> +<button id="resume-button">Resume</button> +<button id="pause-button">Pause</button> +<br /> +<br /> +<br /> +<br /> +<button id="attach-button">Attach</button> +<button id="detach-button">Detach</button> +<button id="about-button">About</button> +<button id="heap-dump-download-button"><a id="heap-dump-download" href="/heapDump.json" target="_blank">Dump heap</a></button> +<button id="show-bytecode-button">Show bytecode</button> +</div> <!-- #left-area --> + +<div id="center-area"> +<pre id="source-pre" class="sourcecode"><code id="source-code" class="sourcecode"> +// No source loaded +</code></pre> +<div> +<select id="source-select"></select><br /> +<!-- <span id="source-filename">?</span> --> +</div> +<div id="exec-status"> +<div id="exec-state"><span id="current-state">?</span></div> +<div id="exec-other"><span id="current-fileline">?</span><br /><span id="current-funcpc">?</span></div> +</div> <!-- #exec-status --> +<div id="output"> +<div style="color: #dddddd">(output from script, print() and alert() calls)</div> +</div> +</div> <!-- #center-area --> + +<div id="right-area"> +<div id="callstack"> +<div style="color: #dddddd">(callstack)</div> +</div> +<div id="locals"> +<div style="color: #dddddd">(locals)</div> +</div> +<div id="breakpoints"> +<div style="color: #dddddd">(breakpoints)</div> +</div> +<div id="eval"> +<input id="eval-input" value="print('hello world'); 1+2" /><button id="eval-button">Eval</button><input id="eval-watch" type="checkbox" /> watch (eval on pause) +<div id="eval-output"></div> +<button id="putvar-button">PutVar</button><button id="getvar-button">GetVar</button><input id="varname-input" value="varname" /><input id="varvalue-input" value="varvalue" /> +<div id="var-output"></div> +</div> +</div> <!-- #right-area --> + +</div> <!-- #part-middle --> + +<div id="part-footer"> +<div>DUK_VERSION: <span id="duk-version">?</span>, DUK_GIT_DESCRIBE: <span id="duk-git-describe">?</span>, Target info: <span id="target-info">?</span>, Endianness: <span id="endianness">?</span><br /> +Debug protocol stats: +recv <span id="debug-rx-bytes">?</span> (<span id="debug-rx-kbrate">?</span> kB/s), <span id="debug-rx-dvalues">?</span> dvalues, <span id="debug-rx-messages">?</span> messages; +send <span id="debug-tx-bytes">?</span> (<span id="debug-tx-kbrate">?</span> kB/s), <span id="debug-tx-dvalues">?</span> dvalues, <span id="debug-tx-messages">?</span> messages +</div> +</div> <!-- #part-footer --> + +<div id="about-dialog" title="About Duktape debugger"> +<p>Duktape debugger is a web UI for debugging Ecmascript on a target device.</p> +<p>This web UI talks to a NodeJS debug server using <a href="http://socket.io/"; target="_blank">socket.io</a>. +The debug server talks to the target device using the Duktape debug protocol +(see <a href="https://github.com/svaarala/duktape/blob/master/doc/debugger.rst"; target="_blank">debugger.rst</a>).</p> +</div> <!-- #about-dialog --> + +<div id="bytecode-dialog" title="Bytecode for current function"> +<pre id="bytecode-preformatted"></pre> +</div> + +<script src="jquery-1.11.1.min.js" type="text/javascript"></script> +<script src="jquery-ui.min.js" type="text/javascript"></script> +<script src="socket.io-1.2.0.js" type="text/javascript"></script> +<script src="webui.js" type="text/javascript"></script> +</body> +</html>
