// handle the [x] syntax

// e.g [1], ["key"], [1:2:3], [1:,:2,(3,4)]

var to_process = [];

if (object.type === "tuple") {

to_process = object.children;

} else {

to_process.push(object);

}

var reprs = [];

for (var i = 0; i < to_process.length; ++i) {

var entry = to_process[i];

if (entry.type === "slice") {

let start_repr = entry.start === None ? "" : real_repr(entry.start);

let stop_repr = entry.stop === None ? "" : real_repr(entry.stop);

let step_repr = entry.step === None ? "" : (":" + real_repr(entry.step));

reprs.push(`${start_repr}:${stop_repr}${step_repr}`);

} else {

reprs.push(real_repr(entry));

}

}

return `${reprs.join(", ")}`;

var {version, argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames, freevars, cellvars, localsplusnames, localspluskinds, filename, name, qualname, firstlineno, lnotab, linetable, exceptiontable} = code_dict;

let lines = [];

let compiler_flag_names = {1: "OPTIMIZED", 2: "NEWLOCALS", 4: "VARARGS", 8: "VARKEYWORDS", 16: "NESTED", 32: "GENERATOR", 64: "NOFREE", 128: "COROUTINE", 256: "ITERABLE_COROUTINE", 512: "ASYNC_GENERATOR"};

let flag_names = [];

lines.push(" Show Code");

lines.push("------------------------------");

let remaining_flag = flags;

for (let i = 0; i < 32; ++i) {

let flag = 1 << i;

if (remaining_flag & flag) {

let flag_name = compiler_flag_names[flag];

flag_names.push(flag_name === undefined ? flag.toString(16) : flag_name);

remaining_flag ^= flag

if (remaining_flag === 0) break;

}

}

if (remaining_flag) {

flag_names.push(remaining_flag.toString(16));

}

if (flag_names.length === 0) {

flag_names.push("0x0");

}

lines.push("Name: " + name.str);

if (array_compare(version, [3]) >= 0) { // str

lines.push("Filename: " + filename.str);

} else { // bytes

lines.push("Filename: " + filename.str);

}

lines.push("Argument count: " + argcount);

if (array_compare(version, [3, 8]) >= 0) {

lines.push("Positional-only arguments: " + posonlyargcount);

};

if (array_compare(version, [3]) >= 0) {

lines.push("Kw-only arguments: " + kwonlyargcount);

};

lines.push("Number of locals: " + nlocals);

lines.push("Stack size: " + stacksize);

lines.push("Flags: " + flag_names.join(", "));

if (consts.children.length) {

lines.push("Constants:");

consts.children.forEach((item, index) => {

lines.push(`${index.toString().padStart(4)}: ${item.repr}`);

})

}

if (names.children.length) {

lines.push("Names:");

names.children.forEach((item, index) => {

lines.push(`${index.toString().padStart(4)}: ${item.str}`);

})

}

if (varnames.children.length) {

lines.push("Variable names:");

varnames.children.forEach((item, index) => {

lines.push(`${index.toString().padStart(4)}: ${item.str}`);

})

}

if (freevars.children.length) {

lines.push("Free variables:");

freevars.children.forEach((item, index) => {

lines.push(`${index.toString().padStart(4)}: ${item.str}`);

})

}

if (cellvars.children.length) {

lines.push("Cell variables:");

cellvars.children.forEach((item, index) => {

lines.push(`${index.toString().padStart(4)}: ${item.str}`);

})

}

lines.push("==============================");

lines.push(" Disassembly");

lines.push("------------------------------");

var unsupported_opcodes = new Set();

var source_code = [];

var scope_entries = [

/*

];

if (array_compare(version, [2, 6]) >= 0 && array_compare(version, [3, 13]) <= 0) { // opargs

let opargs = [];

let version_str = version.join(".");

let opcode_list = opcodes[version_str] ?? null;

let inline_cache_entries = _inline_cache_entries[version_str] ?? null;

if (opcode_list === null) {

lines.push("Currently Not Supported");

}

// _unpack_opargs

if (opcode_list !== null) {

let extended_arg = 0;

let arg;

if (array_compare(version, [3, 6]) >= 0) {

for (let i = 0; i < code.value.length; i += 2) {

let op = code.value[i];

if (op >= opcode_list["HAVE_ARGUMENT"]) {

arg = code.value[i + 1] | extended_arg;

extended_arg = op === opcode_list["EXTENDED_ARG"] ? arg << 8 : 0;

} else {

arg = null;

if (array_compare(version, [3, 10]) >= 0) {

extended_arg = 0;

}

}

opargs.push({"offset": i, "opcode": op, "arg": arg});

}

} else {

for (let i = 0; i < code.value.length;) {

let offset = i;

let op = code.value[i];

++i;

if (op >= opcode_list["HAVE_ARGUMENT"]) {

arg = code.value[i] + code.value[i + 1] * 256 + extended_arg;

extended_arg = 0;

i += 2;

if (op === opcode_list["EXTENDED_ARG"]) {

extended_arg = arg << 16;

}

}

opargs.push({"offset": offset, "opcode": op, "arg": arg});

}

}

}

// lines.push(JSON.stringify(opargs));

// findlinestarts

let linestarts = {};

if (array_compare(version, [3, 11]) >= 0) {

// co_lines from codeobject.c

let lastlineno = null;

let lineno = firstlineno;

let addr = 0;

let byte_incr = null;

let line_incr = null;

let shift = -1;

let varint = 0;

// lineiter_next

var cursor = 0;

while (cursor < linetable.value.length) {

var incr = linetable.value[cursor];

line_incr = {

15: 0, // PY_CODE_LOCATION_INFO_NONE

13: 3, // PY_CODE_LOCATION_INFO_NO_COLUMNS,

14: 3, // PY_CODE_LOCATION_INFO_LONG

10: 0, // PY_CODE_LOCATION_INFO_ONE_LINE0

11: 1, // PY_CODE_LOCATION_INFO_ONE_LINE1

12: 2, // PY_CODE_LOCATION_INFO_ONE_LINE2

}[(incr >> 3) & 15] ?? 0; // Same line

if (line_incr === 3) {

var cursor2 = cursor + 1;

shift = 0; // scan_signed_varint

var read = linetable.value[cursor2++];

line_incr = read & 63;

while (read & 64) {

read = linetable.value[cursor2++];

shift += 6;

line_incr |= (read & 63) << shift;

};

if (line_incr & 1) {

line_incr = -(line_incr >> 1);

} else {

line_incr = line_incr >> 1;

}

}

lineno += line_incr;

// is_no_line_marker: (incr >> 3) === 0x1f

if (!((incr >> 3) === 0x1f)) {

if (lineno !== lastlineno) {

linestarts[addr] = lineno;

lastlineno = lineno;

}

}

// next_code_delta

addr += ((incr & 7) + 1) * 2; // sizeof(CODEUNIT);

++cursor;

while (cursor < linetable.value.length && (linetable.value[cursor] & 128) === 0) {

++cursor;

}

}

// console.log(linestarts);

} else if (array_compare(version, [3, 10]) >= 0) {

// co_lines from codeobject.c

let lastlineno = null;

let lineno = firstlineno;

let addr = 0;

let loc = false; // delta, ldelta

let byte_incr = null;

// lineiter_next

linetable.value.forEach(line_incr => {

loc = !loc;

if (loc) {

byte_incr = line_incr;

} else {

// line_incr

if (line_incr !== 0x80) {

lineno += line_incr - (line_incr >= 0x80 ? 0x100 : 0);

if (byte_incr) {

if (lastlineno !== lineno) {

linestarts[addr] = lineno;

lastlineno = lineno;

}

}

}

addr += byte_incr;

}

})

// console.log(linestarts);

} else {

let lastlineno = null;

let lineno = firstlineno;

let addr = 0;

let loc = false; // byte_incr, line_incr

let byte_incr = null;

lnotab.value.forEach(line_incr => {

loc = !loc;

if (loc) {

byte_incr = line_incr;

} else {

// byte_incr

if (byte_incr) {

if (lineno !== lastlineno) {

linestarts[addr] = lineno;

lastlineno = lineno;

}

}

addr += byte_incr;

// line_incr

if (array_compare(version, [3, 6]) >= 0) {

lineno += line_incr - (line_incr >= 0x80 ? 0x100 : 0);

} else {

lineno += line_incr;

}

}

})

if (lineno !== lastlineno) {

linestarts[addr] = lineno;

}

// console.log(linestarts);

}

// lines.push(JSON.stringify(linestarts));

// findlabels

var directed_graph = [];

var graph_wait = [0];

let labels = new Set();

let label;

var last_offset = null;

var connected = true;

opargs.forEach(item => {

if (connected && last_offset !== null) {

directed_graph.push([last_offset, item.offset]);

}

connected = true;

last_offset = item.offset;

let opcode = opcode_list["opmap"][item.opcode] ?? `<${item.opcode}>`;

if (item.arg !== null) {

if (opcode_list["hasjrel"].includes(item.opcode)) {

// relative jump

var signed_arg = item.arg;

if (array_compare(version, [3, 10]) >= 0) {

if (array_compare(version, [3, 11]) >= 0) {

if (opcode.indexOf("JUMP_BACKWARD") === 0) {

signed_arg = -signed_arg;

}

}

label = item.offset + 2 + signed_arg * 2;

if (array_compare(version, [3, 12]) >= 0) {

label += 2 * (inline_cache_entries[opcode] ?? 0);

}

} else if (array_compare(version, [3, 6]) >= 0) {

label = item.offset + 2 + signed_arg;

} else {

label = item.offset + 3 + signed_arg;

}

} else if (opcode_list["hasjabs"].includes(item.opcode)) {

// absolute jump

if (array_compare(version, [3, 10]) >= 0) {

label = item.arg * 2;

} else {

label = item.arg;

}

} else {

return;

}

// set can handle duplicates

labels.add(label);

directed_graph.push([item.offset, label]);

if (opcode.indexOf("IF") === -1) { // unconditional jumps

connected = false;

}

}

})

directed_graph.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);

console.log("digraph{\n" + directed_graph.map(x => `"${x[0]}"->"${x[1]}"`).join("\n") + "\n}");

// lines.push(JSON.stringify(labels));

// _parse_exception_table

var exception_entries = [];

if (exceptiontable !== null) {

var cursor = 0;

function _parse_varint() {

var b = exceptiontable.value[cursor++];

var val = b & 63;

while (b & 64) {

val <<= 6;

b = exceptiontable.value[cursor++];

val |= b & 63;

}

return val;

}

while (cursor < exceptiontable.value.length) {

var start = _parse_varint() * 2;

var length = _parse_varint() * 2;

var end = start + length;

var target = _parse_varint() * 2;

var dl = _parse_varint();

var depth = dl >> 1;

var lasti = (dl & 1) === 1;

exception_entries.push({

"start": start,

"end": end,

"target": target,

"depth": depth,

"lasti": lasti

});

}

exception_entries.forEach(entry => {

for (let i = entry.start; i < entry.end; i++) {

labels.add(entry.target);

}

})

}

// _disassemble_bytes

let max_offset = code.value.length - 2;

let offset_width = max_offset >= 10000 ? max_offset.toString().length : 4;

// line lookup

let final_object = opargs.slice(-1)[0].offset;

let line_map = {};

{

let last_offset = 0;

let last_line = firstlineno;

Object.entries(linestarts).forEach(linestart => {

for (let offset = last_offset; offset < linestart[0]; offset++) {

line_map[offset] = last_line;

};

last_offset = linestart[0];

last_line = linestart[1];

})

for (let offset = last_offset; offset <= final_object; offset++) {

line_map[offset] = last_line;

};

}

// print dis

let source_code_stack = [];

let module_counter = 0;

// opcode process

function op1(symbol, TOS, priority) {

let TOS_repr = real_repr(TOS);

if (get_priority(TOS) > priority){

TOS_repr = `(${TOS_repr})`;

}

let expr = `${symbol}${TOS_repr}`;

return {"type": "expression", "repr": expr, "priority": priority};

}

function op2(TOS1, symbol, TOS, priority, right_asso=false) {

let cond;

let TOS1_repr = real_repr(TOS1);

let TOS_repr = real_repr(TOS);

if (right_asso) {

if (get_priority(TOS1) >= priority) {

TOS1_repr = `(${TOS1_repr})`;

}

if (get_priority(TOS) > priority) {

TOS_repr = `(${TOS_repr})`;

}

} else {

if (get_priority(TOS1) > priority) {

TOS1_repr = `(${TOS1_repr})`;

}

if (get_priority(TOS) >= priority) {

TOS_repr = `(${TOS_repr})`;

}

}

if (cond){

expr = `(${expr})`;

}

let expr = `${TOS1_repr} ${symbol} ${TOS_repr}`;

return {"type": "expression", "repr": expr, "priority": priority};

}

function add_scope(type, start, end, istart, iend) {

scope_entries.push({

"type": type,

"start": start,

"end": end,

"istart": istart,

"iend": iend,

})

}

function process_name(offset, item, lvalue) {

// console.debug("process_name", offset, item, varname);

// processing varname = item

if (item.type === "module") {

if (item.import_name === null) {

add_expression(offset, {

"type": "statement",

"repr": `import ${item.module_name}${item.module_name !== lvalue ? ` as ${lvalue}` : ""}`

});

} else {

let module = source_code_stack.pop();

// peek

let peek = null;

if (source_code.length) {

peek = source_code.pop();

}

if (peek !== null && peek.entry.type === "import_statement" && peek.entry.module_id === item.module_id) {

// merge

add_expression(offset, {

"type": "import_statement",

"repr": `${real_repr(peek.entry)}, ${item.import_name}${item.import_name !== lvalue ? ` as ${lvalue}` : ""}`, "module_id": item.module_id

});

} else {

if (peek !== null) {

// return

add_expression(peek.offset, peek.entry);

}

add_expression(offset, {

"type": "import_statement",

"repr": `from ${item.module_name} import ${item.import_name}${item.import_name !== lvalue ? ` as ${lvalue}` : ""}`,

"module_id": item.module_id

});

}

source_code_stack.push(module);

}

} else if (item.type === "function") {

add_expression(offset, {

"type": "statement",

"repr": `def ${lvalue}(???):`

});

} else if (item.type === "unpacked_expression") {

item.children.push(lvalue);

if (item.children.length === item.num) {

if (item.ex) {

item.children.pop();

item.children.push("*" + lvalue);

} else {

add_expression(offset, {

"type": "statement",

"repr": `${item.children.join(", ")} = ${real_repr(item)}`

});

}

} else {

// not fully fed

source_code_stack.push(item);

}

} else if (item.type === "inplace_expression") {

add_expression(offset, {

"type": "statement",

"repr": real_repr(item)

});

} else if (item.type === "for_expression") {

add_expression(offset, {

"type": "statement",

"repr": `for ${lvalue} in ${real_repr(item)}:`

});

add_scope("for", item.start, item.end, offset + 1, item.end);

} else {

add_expression(offset, {

"type": "statement",

"repr": `${lvalue} = ${real_repr(item)}`

});

}

}

function add_expression(offset, expression) {

let line_number = (Object.entries(linestarts).filter(x => offset >= x[0]).slice(-1)[0] ?? [null, null])[1];

source_code.push({

"lineno": line_number,

"offset": offset,

"entry": expression

});

}

opargs.forEach(item => {

// _get_instructions_bytes

let starts_line = linestarts[item.offset] ?? null;

let line_number = (Object.entries(linestarts).filter(x => item.offset >= x[0]).slice(-1)[0] ?? [null, null])[1];

if (starts_line !== null && item.offset > 0) {

// extra line break in opcode

lines.push("");

}

let opcode = opcode_list["opmap"][item.opcode] ?? `<${item.opcode}>`;

console.debug(line_number, opcode, item);

let arg = item.arg;

let argrepr = "";

if (item.arg !== null) {

if (opcode_list["hasconst"].includes(item.opcode)) {

if (arg >= 0 && arg < consts.children.length) {

argrepr = consts.children[arg].repr;

}

} else if (opcode_list["hasname"].includes(item.opcode)) {

if (array_compare(version, [3, 11]) >= 0 && opcode === "LOAD_GLOBAL") {

if (arg >= 0 && (arg >> 1) < names.children.length) {

argrepr = names.children[arg >> 1].str;

} else {

argrepr = (arg >> 1).toString();

}

if (arg & 1) {

if (array_compare(version, [3, 13]) >= 0) {

argrepr = argrepr + " + NULL";

} else {

argrepr = "NULL + " + argrepr;

}

}

} else if (array_compare(version, [3, 12]) >= 0 && opcode === "LOAD_ATTR") {

if (arg >= 0 && (arg >> 1) < names.children.length) {

argrepr = names.children[arg >> 1].str;

} else {

argrepr = (arg >> 1).toString();

}

if (arg & 1) {

if (array_compare(version, [3, 13]) >= 0) {

argrepr = argrepr + " + NULL|self";

} else {

argrepr = "NULL|self + " + argrepr;

}

}

} else if (array_compare(version, [3, 12]) >= 0 && opcode === "LOAD_SUPER_ATTR") {

if (arg >= 0 && (arg >> 2) < names.children.length) {

argrepr = names.children[arg >> 2].str;

} else {

argrepr = (arg >> 2).toString();

}

if (arg & 1) {

if (array_compare(version, [3, 13]) >= 0) {

argrepr = argrepr + " + NULL|self";

} else {

argrepr = "NULL|self + " + argrepr;

}

}

} else {

if (arg >= 0 && arg < names.children.length) {

argrepr = names.children[arg].str;

} else {

argrepr = arg.toString();

}

}

} else if (array_compare(version, [3, 10]) >= 0 && opcode_list["hasjabs"].includes(item.opcode)) {

argrepr = `to ${arg * 2}`;

} else if (opcode_list["hasjrel"].includes(item.opcode)) {

var signed_arg = arg;

if (array_compare(version, [3, 11]) >= 0) {

if (opcode.indexOf('JUMP_BACKWARD') >= 0) {

signed_arg = -signed_arg;

}

}

if (array_compare(version, [3, 10]) >= 0) {

var argval = item.offset + 2 + signed_arg * 2;

if (array_compare(version, [3, 12]) >= 0) {

argval += 2 * (inline_cache_entries[opcode] ?? 0);

}

argrepr = `to ${argval}`;

} else if (array_compare(version, [3, 6]) >= 0) {

argrepr = `to ${item.offset + 2 + signed_arg}`;

} else {

argrepr = `to ${item.offset + 3 + signed_arg}`;

}

} else if (array_compare(version, [3, 13]) >= 0 && ["LOAD_FAST_LOAD_FAST", "STORE_FAST_LOAD_FAST", "STORE_FAST_STORE_FAST"].includes(opcode)) {

var arg1 = arg >> 4;

var arg2 = arg & 15;

var argrepr1, argrepr2;

if (arg1 >= 0 && arg1 < localsplusnames.children.length) {

argrepr1 = localsplusnames.children[arg1].str;

} else {

argrepr1 = arg1.toString();

}

if (arg2 >= 0 && arg2 < localsplusnames.children.length) {

argrepr2 = localsplusnames.children[arg2].str;

} else {

argrepr2 = arg2.toString();

}

argrepr = argrepr1 + ", " + argrepr2;

} else if (opcode_list["haslocal"].includes(item.opcode)) {

if (array_compare(version, [3, 11]) >= 0) {

if (arg >= 0 && arg < localsplusnames.children.length) {

argrepr = localsplusnames.children[arg].str;

} else {

argrepr = arg.toString();

}

} else {

if (arg >= 0 && arg < varnames.children.length) {

argrepr = varnames.children[arg].str;

} else {

argrepr = arg.toString();

}

}

} else if (opcode_list["hascompare"].includes(item.opcode)) {

let actual_arg;

let to_bool = false;

if (array_compare(version, [3, 13]) >= 0) {

actual_arg = arg >> 5;

to_bool = (arg & 16) === 16;

} else if (array_compare(version, [3, 12]) >= 0) {

actual_arg = arg >> 4;

} else {

actual_arg = arg;

}

if (array_compare(version, [3, 12]) >= 0) {

argrepr = ['<', '<=', '==', '!=', '>', '>='][actual_arg] ?? `<${arg}>`;

} else {

argrepr = ['<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is', 'is not', 'exception match', 'BAD'][actual_arg] ?? `<${arg}>`; // only up to >= for 3.9 thereafter

}

if (to_bool) {

argrepr = `bool(${argrepr})`;

}

} else if (opcode_list["hasfree"].includes(item.opcode)) {

if (array_compare(version, [3, 11] >= 0)) {

if (arg >= 0 && arg < localsplusnames.children.length) {

argrepr = localsplusnames.children[arg].str;