Lil-Ran/pycdc_fork
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Activity

Use opcode mappings to keep things a bit cleaner and hopefully more sane

Browse Source
This commit is contained in:
Michael Hansen
2010-09-04 01:20:41 -07:00
parent ea615df200
commit 1161c8de26
22 changed files with 1870 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
ASTree.cpp
View File

@@ -2,12 +2,6 @@
#include "FastStack.h"
#include "bytecode.h"
// These are used to avoid writing code 3 times for each of
// the different python generations
#define PY_1000 0x1000
#define PY_2000 0x2000
#define PY_3000 0x3000
/* Use this to determine if an error occurred (and therefore, if we should
* avoid cleaning the output tree) */
static bool cleanBuild;
@@ -27,22 +21,11 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
int opcode, operand;
int pos = 0;
int opadd = 0;
if (mod->majorVer() == 1)
opadd = PY_1000;
else if (mod->majorVer() == 2)
opadd = PY_2000;
else if (mod->majorVer() == 3)
opadd = PY_3000;
while (!source.atEof()) {
bc_next(source, mod, opcode, operand, pos);
opcode |= opadd;
switch (opcode) {
case (PY_1000 | Py1k::BINARY_ADD):
case (PY_2000 | Py2k::BINARY_ADD):
case (PY_3000 | Py3k::BINARY_ADD):
case Pyc::BINARY_ADD:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -51,9 +34,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_ADD));
}
break;
case (PY_1000 | Py1k::BINARY_AND):
case (PY_2000 | Py2k::BINARY_AND):
case (PY_3000 | Py3k::BINARY_AND):
case Pyc::BINARY_AND:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -62,8 +43,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_AND));
}
break;
case (PY_1000 | Py1k::BINARY_DIVIDE):
case (PY_2000 | Py2k::BINARY_DIVIDE):
case Pyc::BINARY_DIVIDE:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -72,8 +52,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_DIVIDE));
}
break;
case (PY_2000 | Py2k::BINARY_FLOOR_DIVIDE):
case (PY_3000 | Py3k::BINARY_FLOOR_DIVIDE):
case Pyc::BINARY_FLOOR_DIVIDE:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -82,9 +61,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_FLOOR));
}
break;
case (PY_1000 | Py1k::BINARY_LSHIFT):
case (PY_2000 | Py2k::BINARY_LSHIFT):
case (PY_3000 | Py3k::BINARY_LSHIFT):
case Pyc::BINARY_LSHIFT:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -93,9 +70,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_LSHIFT));
}
break;
case (PY_1000 | Py1k::BINARY_MODULO):
case (PY_2000 | Py2k::BINARY_MODULO):
case (PY_3000 | Py3k::BINARY_MODULO):
case Pyc::BINARY_MODULO:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -104,9 +79,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_MODULO));
}
break;
case (PY_1000 | Py1k::BINARY_MULTIPLY):
case (PY_2000 | Py2k::BINARY_MULTIPLY):
case (PY_3000 | Py3k::BINARY_MULTIPLY):
case Pyc::BINARY_MULTIPLY:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -115,9 +88,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_SUBTRACT));
}
break;
case (PY_1000 | Py1k::BINARY_OR):
case (PY_2000 | Py2k::BINARY_OR):
case (PY_3000 | Py3k::BINARY_OR):
case Pyc::BINARY_OR:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -126,9 +97,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_OR));
}
break;
case (PY_1000 | Py1k::BINARY_POWER):
case (PY_2000 | Py2k::BINARY_POWER):
case (PY_3000 | Py3k::BINARY_POWER):
case Pyc::BINARY_POWER:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -137,9 +106,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_POWER));
}
break;
case (PY_1000 | Py1k::BINARY_RSHIFT):
case (PY_2000 | Py2k::BINARY_RSHIFT):
case (PY_3000 | Py3k::BINARY_RSHIFT):
case Pyc::BINARY_RSHIFT:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -148,9 +115,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_RSHIFT));
}
break;
case (PY_1000 | Py1k::BINARY_SUBSCR):
case (PY_2000 | Py2k::BINARY_SUBSCR):
case (PY_3000 | Py3k::BINARY_SUBSCR):
case Pyc::BINARY_SUBSCR:
{
PycRef<ASTNode> subscr = stack.top();
stack.pop();
@@ -159,9 +124,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTSubscr(src, subscr));
}
break;
case (PY_1000 | Py1k::BINARY_SUBTRACT):
case (PY_2000 | Py2k::BINARY_SUBTRACT):
case (PY_3000 | Py3k::BINARY_SUBTRACT):
case Pyc::BINARY_SUBTRACT:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -170,8 +133,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_SUBTRACT));
}
break;
case (PY_2000 | Py2k::BINARY_TRUE_DIVIDE):
case (PY_3000 | Py3k::BINARY_TRUE_DIVIDE):
case Pyc::BINARY_TRUE_DIVIDE:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -180,9 +142,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_DIVIDE));
}
break;
case (PY_1000 | Py1k::BINARY_XOR):
case (PY_2000 | Py2k::BINARY_XOR):
case (PY_3000 | Py3k::BINARY_XOR):
case Pyc::BINARY_XOR:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -191,8 +151,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(left, right, ASTBinary::BIN_XOR));
}
break;
case (PY_1000 | Py1k::BUILD_CLASS):
case (PY_2000 | Py2k::BUILD_CLASS):
case Pyc::BUILD_CLASS:
{
PycRef<ASTNode> code = stack.top();
stack.pop();
@@ -203,16 +162,14 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTClass(code, bases, name));
}
break;
case (PY_1000 | Py1k::BUILD_FUNCTION):
case Pyc::BUILD_FUNCTION:
{
PycRef<ASTNode> code = stack.top();
stack.pop();
stack.push(new ASTFunction(code, ASTFunction::defarg_t()));
}
break;
case (PY_1000 | Py1k::BUILD_LIST):
case (PY_2000 | Py2k::BUILD_LIST):
case (PY_3000 | Py3k::BUILD_LIST):
case Pyc::BUILD_LIST_A:
{
ASTList::value_t values;
for (int i=0; i<operand; i++) {
@@ -222,14 +179,10 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTList(values));
}
break;
case (PY_1000 | Py1k::BUILD_MAP):
case (PY_2000 | Py2k::BUILD_MAP):
case (PY_3000 | Py3k::BUILD_MAP):
case Pyc::BUILD_MAP_A:
stack.push(new ASTMap());
break;
case (PY_1000 | Py1k::BUILD_TUPLE):
case (PY_2000 | Py2k::BUILD_TUPLE):
case (PY_3000 | Py3k::BUILD_TUPLE):
case Pyc::BUILD_TUPLE_A:
{
ASTTuple::value_t values;
values.resize(operand);
@@ -240,9 +193,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTTuple(values));
}
break;
case (PY_1000 | Py1k::CALL_FUNCTION):
case (PY_2000 | Py2k::CALL_FUNCTION):
case (PY_3000 | Py3k::CALL_FUNCTION):
case Pyc::CALL_FUNCTION_A:
{
int kwparams = (operand & 0xFF00) >> 8;
int pparams = (operand & 0xFF);
@@ -264,9 +215,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTCall(func, pparamList, kwparamList));
}
break;
case (PY_1000 | Py1k::COMPARE_OP):
case (PY_2000 | Py2k::COMPARE_OP):
case (PY_3000 | Py3k::COMPARE_OP):
case Pyc::COMPARE_OP_A:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -275,41 +224,28 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTCompare(left, right, operand));
}
break;
case (PY_1000 | Py1k::DUP_TOP):
case (PY_2000 | Py2k::DUP_TOP):
case (PY_3000 | Py3k::DUP_TOP):
case Pyc::DUP_TOP:
stack.push(stack.top());
break;
case (PY_1000 | Py1k::IMPORT_NAME):
stack.push(new ASTImport(new ASTName(code->getName(operand)), Node_NULL));
break;
case (PY_2000 | Py2k::IMPORT_NAME):
{
case Pyc::IMPORT_NAME_A:
if (mod->majorVer() == 1) {
stack.push(new ASTImport(new ASTName(code->getName(operand)), Node_NULL));
} else {
PycRef<ASTNode> fromlist = stack.top();
stack.pop();
if (mod->minorVer() >= 5)
if (mod->majorVer() > 2 || mod->minorVer() >= 5)
stack.pop(); // Level -- we don't care
stack.push(new ASTImport(new ASTName(code->getName(operand)), fromlist));
}
break;
case (PY_3000 | Py3k::IMPORT_NAME):
{
PycRef<ASTNode> fromlist = stack.top();
stack.pop();
stack.pop(); // Level -- we don't care
stack.push(new ASTImport(new ASTName(code->getName(operand)), fromlist));
}
break;
case (PY_2000 | Py2k::IMPORT_STAR):
case (PY_3000 | Py3k::IMPORT_STAR):
case Pyc::IMPORT_STAR:
{
PycRef<ASTNode> import = stack.top();
stack.pop();
lines.push_back(new ASTStore(import, Node_NULL));
}
break;
case (PY_2000 | Py2k::INPLACE_ADD):
case (PY_3000 | Py3k::INPLACE_ADD):
case Pyc::INPLACE_ADD:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -319,8 +255,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(src, right, ASTBinary::BIN_AND));
}
break;
case (PY_2000 | Py2k::INPLACE_SUBTRACT):
case (PY_3000 | Py3k::INPLACE_SUBTRACT):
case Pyc::INPLACE_SUBTRACT:
{
PycRef<ASTNode> right = stack.top();
stack.pop();
@@ -330,72 +265,51 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTBinary(src, right, ASTBinary::BIN_SUBTRACT));
}
break;
case (PY_1000 | Py1k::JUMP_IF_FALSE):
case (PY_2000 | Py2k::JUMP_IF_FALSE):
case (PY_3000 | Py3k::JUMP_IF_FALSE):
case Pyc::JUMP_IF_FALSE_A:
{
PycRef<ASTNode> cond = stack.top();
stack.pop();
stack.push(new ASTJump(operand, ASTJump::JMP_FALSE, cond));
}
break;
case (PY_1000 | Py1k::JUMP_IF_TRUE):
case (PY_2000 | Py2k::JUMP_IF_TRUE):
case (PY_3000 | Py3k::JUMP_IF_TRUE):
case Pyc::JUMP_IF_TRUE_A:
{
PycRef<ASTNode> cond = stack.top();
stack.pop();
stack.push(new ASTJump(operand, ASTJump::JMP_TRUE, cond));
}
break;
case (PY_1000 | Py1k::JUMP_FORWARD):
case (PY_2000 | Py2k::JUMP_FORWARD):
case (PY_3000 | Py3k::JUMP_FORWARD):
case Pyc::JUMP_FORWARD_A:
{
stack.push(new ASTJump(operand, ASTJump::JUMP, NULL));
}
break;
case (PY_1000 | Py1k::LOAD_ATTR):
case (PY_2000 | Py2k::LOAD_ATTR):
case (PY_3000 | Py3k::LOAD_ATTR):
case Pyc::LOAD_ATTR_A:
{
PycRef<ASTNode> name = stack.top();
stack.pop();
stack.push(new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR));
}
break;
case (PY_1000 | Py1k::LOAD_CONST):
case (PY_2000 | Py2k::LOAD_CONST):
case (PY_3000 | Py3k::LOAD_CONST):
case Pyc::LOAD_CONST_A:
stack.push(new ASTObject(code->getConst(operand)));
break;
case (PY_1000 | Py1k::LOAD_FAST):
if (mod->minorVer() < 3)
case Pyc::LOAD_FAST_A:
if (mod->majorVer() == 1 && mod->minorVer() < 3)
stack.push(new ASTName(code->getName(operand)));
else
stack.push(new ASTName(code->getVarName(operand)));
break;
case (PY_2000 | Py2k::LOAD_FAST):
case (PY_3000 | Py3k::LOAD_FAST):
stack.push(new ASTName(code->getVarName(operand)));
break;
case (PY_1000 | Py1k::LOAD_GLOBAL):
case (PY_2000 | Py2k::LOAD_GLOBAL):
case (PY_3000 | Py3k::LOAD_GLOBAL):
case Pyc::LOAD_GLOBAL_A:
stack.push(new ASTName(code->getName(operand)));
break;
case (PY_1000 | Py1k::LOAD_LOCALS):
case (PY_2000 | Py2k::LOAD_LOCALS):
case Pyc::LOAD_LOCALS:
stack.push(new ASTNode(ASTNode::NODE_LOCALS));
break;
case (PY_1000 | Py1k::LOAD_NAME):
case (PY_2000 | Py2k::LOAD_NAME):
case (PY_3000 | Py3k::LOAD_NAME):
case Pyc::LOAD_NAME_A:
stack.push(new ASTName(code->getName(operand)));
break;
case (PY_1000 | Py1k::MAKE_FUNCTION):
case (PY_2000 | Py2k::MAKE_FUNCTION):
case (PY_3000 | Py3k::MAKE_FUNCTION):
case Pyc::MAKE_FUNCTION_A:
{
PycRef<ASTNode> code = stack.top();
stack.pop();
@@ -407,9 +321,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(new ASTFunction(code, defArgs));
}
break;
case (PY_1000 | Py1k::POP_TOP):
case (PY_2000 | Py2k::POP_TOP):
case (PY_3000 | Py3k::POP_TOP):
case Pyc::POP_TOP:
{
PycRef<ASTNode> value = stack.top();
stack.pop();
@@ -417,27 +329,21 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
lines.push_back(value);
}
break;
case (PY_1000 | Py1k::PRINT_ITEM):
case (PY_2000 | Py2k::PRINT_ITEM):
case Pyc::PRINT_ITEM:
lines.push_back(new ASTPrint(stack.top()));
stack.pop();
break;
case (PY_1000 | Py1k::PRINT_NEWLINE):
case (PY_2000 | Py2k::PRINT_NEWLINE):
case Pyc::PRINT_NEWLINE:
lines.push_back(new ASTPrint(Node_NULL));
break;
case (PY_1000 | Py1k::RETURN_VALUE):
case (PY_2000 | Py2k::RETURN_VALUE):
case (PY_3000 | Py3k::RETURN_VALUE):
case Pyc::RETURN_VALUE:
{
PycRef<ASTNode> value = stack.top();
stack.pop();
lines.push_back(new ASTReturn(value));
}
break;
case (PY_1000 | Py1k::ROT_THREE):
case (PY_2000 | Py2k::ROT_THREE):
case (PY_3000 | Py3k::ROT_THREE):
case Pyc::ROT_THREE:
{
PycRef<ASTNode> one = stack.top();
stack.pop();
@@ -450,13 +356,10 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
stack.push(two);
}
break;
case (PY_1000 | Py1k::SET_LINENO):
case (PY_2000 | Py2k::SET_LINENO):
case Pyc::SET_LINENO_A:
// Ignore
break;
case (PY_1000 | Py1k::STORE_ATTR):
case (PY_2000 | Py2k::STORE_ATTR):
case (PY_3000 | Py3k::STORE_ATTR):
case Pyc::STORE_ATTR_A:
{
PycRef<ASTNode> name = stack.top();
stack.pop();
@@ -466,30 +369,19 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
lines.push_back(new ASTStore(value, attr));
}
break;
case (PY_1000 | Py1k::STORE_FAST):
case Pyc::STORE_FAST_A:
{
PycRef<ASTNode> value = stack.top();
stack.pop();
PycRef<ASTNode> name;
if (mod->minorVer() < 3)
if (mod->majorVer() == 1 && mod->minorVer() < 3)
name = new ASTName(code->getName(operand));
else
name = new ASTName(code->getVarName(operand));
lines.push_back(new ASTStore(value, name));
}
break;
case (PY_2000 | Py2k::STORE_FAST):
case (PY_3000 | Py3k::STORE_FAST):
{
PycRef<ASTNode> value = stack.top();
stack.pop();
PycRef<ASTNode> name = new ASTName(code->getVarName(operand));
lines.push_back(new ASTStore(value, name));
}
break;
case (PY_1000 | Py1k::STORE_GLOBAL):
case (PY_2000 | Py2k::STORE_GLOBAL):
case (PY_3000 | Py3k::STORE_GLOBAL):
case Pyc::STORE_GLOBAL_A:
{
PycRef<ASTNode> value = stack.top();
stack.pop();
@@ -497,9 +389,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
lines.push_back(new ASTStore(value, name));
}
break;
case (PY_1000 | Py1k::STORE_NAME):
case (PY_2000 | Py2k::STORE_NAME):
case (PY_3000 | Py3k::STORE_NAME):
case Pyc::STORE_NAME_A:
{
PycRef<ASTNode> value = stack.top();
stack.pop();
@@ -507,9 +397,7 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
lines.push_back(new ASTStore(value, name));
}
break;
case (PY_1000 | Py1k::STORE_SUBSCR):
case (PY_2000 | Py2k::STORE_SUBSCR):
case (PY_3000 | Py3k::STORE_SUBSCR):
case Pyc::STORE_SUBSCR:
{
PycRef<ASTNode> subscr = stack.top();
stack.pop();
@@ -524,43 +412,35 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
}
}
break;
case (PY_1000 | Py1k::UNARY_CALL):
case Pyc::UNARY_CALL:
{
PycRef<ASTNode> func = stack.top();
stack.pop();
stack.push(new ASTCall(func, ASTCall::pparam_t(), ASTCall::kwparam_t()));
}
break;
case (PY_1000 | Py1k::UNARY_INVERT):
case (PY_2000 | Py2k::UNARY_INVERT):
case (PY_3000 | Py3k::UNARY_INVERT):
case Pyc::UNARY_INVERT:
{
PycRef<ASTNode> arg = stack.top();
stack.pop();
stack.push(new ASTUnary(arg, ASTUnary::UN_INVERT));
}
break;
case (PY_1000 | Py1k::UNARY_NEGATIVE):
case (PY_2000 | Py2k::UNARY_NEGATIVE):
case (PY_3000 | Py3k::UNARY_NEGATIVE):
case Pyc::UNARY_NEGATIVE:
{
PycRef<ASTNode> arg = stack.top();
stack.pop();
stack.push(new ASTUnary(arg, ASTUnary::UN_NEGATIVE));
}
break;
case (PY_1000 | Py1k::UNARY_NOT):
case (PY_2000 | Py2k::UNARY_NOT):
case (PY_3000 | Py3k::UNARY_NOT):
case Pyc::UNARY_NOT:
{
PycRef<ASTNode> arg = stack.top();
stack.pop();
stack.push(new ASTUnary(arg, ASTUnary::UN_NOT));
}
break;
case (PY_1000 | Py1k::UNARY_POSITIVE):
case (PY_2000 | Py2k::UNARY_POSITIVE):
case (PY_3000 | Py3k::UNARY_POSITIVE):
case Pyc::UNARY_POSITIVE:
{
PycRef<ASTNode> arg = stack.top();
stack.pop();
@@ -569,11 +449,11 @@ PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
break;
default:
if (mod->majorVer() == 1)
fprintf(stderr, "Unsupported opcode: %s\n", Py1k::OpcodeNames[opcode & 0xFF]);
fprintf(stderr, "Unsupported opcode: %s\n", Pyc::OpcodeName(opcode & 0xFF));
else if (mod->majorVer() == 2)
fprintf(stderr, "Unsupported opcode: %s\n", Py2k::OpcodeNames[opcode & 0xFF]);
fprintf(stderr, "Unsupported opcode: %s\n", Pyc::OpcodeName(opcode & 0xFF));
else if (mod->majorVer() == 3)
fprintf(stderr, "Unsupported opcode: %s\n", Py3k::OpcodeNames[opcode & 0xFF]);
fprintf(stderr, "Unsupported opcode: %s\n", Pyc::OpcodeName(opcode & 0xFF));
cleanBuild = false;
return new ASTNodeList(lines);
}

36
Makefile
View File

@@ -11,7 +11,25 @@ COMMON = \
out/sequence.o \
out/string.o \
out/ASTree.o \
out/ASTNode.o
out/ASTNode.o \
BYTES = \
out/python_10.o \
out/python_11.o \
out/python_13.o \
out/python_14.o \
out/python_15.o \
out/python_16.o \
out/python_20.o \
out/python_21.o \
out/python_22.o \
out/python_23.o \
out/python_24.o \
out/python_25.o \
out/python_26.o \
out/python_27.o \
out/python_30.o \
out/python_31.o
ALL = \
bin/pycdas \
@@ -22,17 +40,17 @@ PREFIX = /usr/local
all: $(ALL)
clean:
rm -f $(COMMON)
rm -f $(COMMON) $(BYTES)
install:
mkdir -p $(PREFIX)/bin
cp $(ALL) $(PREFIX)/bin
bin/pycdas: pycdas.cpp $(COMMON)
$(CXX) $(CXXFLAGS) $(COMMON) pycdas.cpp -o $@
bin/pycdas: pycdas.cpp $(COMMON) $(BYTES)
$(CXX) $(CXXFLAGS) $(COMMON) $(BYTES) pycdas.cpp -o $@
bin/pycdc: pycdc.cpp $(COMMON)
$(CXX) $(CXXFLAGS) $(COMMON) pycdc.cpp -o $@
bin/pycdc: pycdc.cpp $(COMMON) $(BYTES)
$(CXX) $(CXXFLAGS) $(COMMON) $(BYTES) pycdc.cpp -o $@
out/module.o: module.h module.cpp
$(CXX) $(CXXFLAGS) -c module.cpp -o $@
@@ -63,3 +81,9 @@ out/ASTree.o: ASTree.h ASTree.cpp
out/ASTNode.o: ASTNode.h ASTNode.cpp
$(CXX) $(CXXFLAGS) -c ASTNode.cpp -o $@
out/python_%.o: bytes/python_%.cpp
$(CXX) $(CXXFLAGS) -c $< -o $@
bytes/python_%.cpp: bytes/python_%.map
( cd bytes ; ./comp_map.py )

430
bytecode.cpp
View File

@@ -1,306 +1,144 @@
#include "bytecode.h"
#include "numeric.h"
const char* Py1k::OpcodeNames[256] = {
"STOP_CODE", "POP_TOP", "ROT_TWO", "ROT_THREE", "DUP_TOP",
"<5>", "<6>", "<7>", "<8>", "<9>",
"UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "UNARY_CONVERT",
"UNARY_CALL", "UNARY_INVERT", "<16>", "<17>", "<18>",
"BINARY_POWER", "BINARY_MULTIPLY", "BINARY_DIVIDE", "BINARY_MODULO",
"BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_CALL",
"<27>", "<28>", "<29>",
"SLICE+0", "SLICE+1", "SLICE+2", "SLICE+3",
"<34>", "<35>", "<36>", "<37>", "<38>", "<39>",
"STORE_SLICE+0", "STORE_SLICE+1", "STORE_SLICE+2", "STORE_SLICE+3",
"<44>", "<45>", "<46>", "<47>", "<48>", "<49>",
"DELETE_SLICE+0", "DELETE_SLICE+1", "DELETE_SLICE+2", "DELETE_SLICE+3",
"<54>", "<55>", "<56>", "<57>", "<58>", "<59>",
"STORE_SUBSCR", "DELETE_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT",
"BINARY_AND", "BINARY_XOR", "BINARY_OR", "<67>", "<68>", "<69>",
"PRINT_EXPR", "PRINT_ITEM", "PRINT_NEWLINE",
"<73>", "<74>", "<75>", "<76>", "<77>", "<78>", "<79>",
#define DECLARE_PYTHON(maj, min) \
extern int python_##maj##min##_map(int); \
extern int python_##maj##min##_unmap(int);
DECLARE_PYTHON(1, 0)
DECLARE_PYTHON(1, 1)
DECLARE_PYTHON(1, 3)
DECLARE_PYTHON(1, 4)
DECLARE_PYTHON(1, 5)
DECLARE_PYTHON(1, 6)
DECLARE_PYTHON(2, 0)
DECLARE_PYTHON(2, 1)
DECLARE_PYTHON(2, 2)
DECLARE_PYTHON(2, 3)
DECLARE_PYTHON(2, 4)
DECLARE_PYTHON(2, 5)
DECLARE_PYTHON(2, 6)
DECLARE_PYTHON(2, 7)
DECLARE_PYTHON(3, 0)
DECLARE_PYTHON(3, 1)
const char* Pyc::OpcodeName(int opcode)
{
static const char* opcode_names[] = {
"STOP_CODE", "POP_TOP", "ROT_TWO", "ROT_THREE", "DUP_TOP", "UNARY_POSITIVE",
"UNARY_NEGATIVE", "UNARY_NOT", "UNARY_CONVERT", "UNARY_CALL",
"UNARY_INVERT", "BINARY_POWER", "BINARY_MULTIPLY", "BINARY_DIVIDE",
"BINARY_MODULO", "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR",
"BINARY_CALL", "SLICE_0", "SLICE_1", "SLICE_2", "SLICE_3", "STORE_SLICE_0",
"STORE_SLICE_1", "STORE_SLICE_2", "STORE_SLICE_3", "DELETE_SLICE_0",
"DELETE_SLICE_1", "DELETE_SLICE_2", "DELETE_SLICE_3", "STORE_SUBSCR",
"DELETE_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT", "BINARY_AND",
"BINARY_XOR", "BINARY_OR", "PRINT_EXPR", "PRINT_ITEM", "PRINT_NEWLINE",
"BREAK_LOOP", "RAISE_EXCEPTION", "LOAD_LOCALS", "RETURN_VALUE",
"LOAD_GLOBALS", "EXEC_STMT", "BUILD_FUNCTION", "POP_BLOCK", "END_FINALLY",
"BUILD_CLASS",
"BUILD_CLASS", "ROT_FOUR", "NOP", "LIST_APPEND", "BINARY_FLOOR_DIVIDE",
"BINARY_TRUE_DIVIDE", "INPLACE_FLOOR_DIVIDE", "INPLACE_TRUE_DIVIDE",
"STORE_MAP", "INPLACE_ADD", "INPLACE_SUBTRACT", "INPLACE_MULTIPLY",
"INPLACE_DIVIDE", "INPLACE_MODULO", "INPLACE_POWER", "GET_ITER",
"PRINT_ITEM_TO", "PRINT_NEWLINE_TO", "INPLACE_LSHIFT", "INPLACE_RSHIFT",
"INPLACE_AND", "INPLACE_XOR", "INPLACE_OR", "WITH_CLEANUP", "IMPORT_STAR",
"YIELD_VALUE", "LOAD_BUILD_CLASS", "STORE_LOCALS", "POP_EXCEPT", "SET_ADD",
"STORE_NAME", "DELETE_NAME", "UNPACK_TUPLE", "UNPACK_LIST", "UNPACK_ARG",
"STORE_ATTR", "DELETE_ATTR", "STORE_GLOBAL", "DELETE_GLOBAL", "UNPACK_VARARG",
"LOAD_CONST", "LOAD_NAME", "BUILD_TUPLE", "BUILD_LIST", "BUILD_MAP",
"LOAD_ATTR", "COMPARE_OP", "IMPORT_NAME", "IMPORT_FROM", "<109>",
"JUMP_FORWARD", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_ABSOLUTE",
"FOR_LOOP", "LOAD_LOCAL", "LOAD_GLOBAL", "SET_FUNC_ARGS", "<118>", "<119>",
"SETUP_LOOP", "SETUP_EXCEPT", "SETUP_FINALLY", "RESERVE_FAST",
"LOAD_FAST", "STORE_FAST", "DELETE_FAST", "SET_LINENO", "<128>", "<129>",
"RAISE_VARARGS", "CALL_FUNCTION", "MAKE_FUNCTION", "BUILD_SLICE",
"<134>", "<135>", "<136>", "<137>", "<138>", "<139>",
"CALL_FUNCTION_VAR", "CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW", "<143>",
"<144>", "<145>", "<146>", "<147>", "<148>", "<149>", "<150>", "<151>",
"<152>", "<153>", "<154>", "<155>", "<156>", "<157>", "<158>", "<159>",
"<160>", "<161>", "<162>", "<163>", "<164>", "<165>", "<166>", "<167>",
"<168>", "<169>", "<170>", "<171>", "<172>", "<173>", "<174>", "<175>",
"<176>", "<177>", "<178>", "<179>", "<180>", "<181>", "<182>", "<183>",
"<184>", "<185>", "<186>", "<187>", "<188>", "<189>", "<190>", "<191>",
"<192>", "<193>", "<194>", "<195>", "<196>", "<197>", "<198>", "<199>",
"<200>", "<201>", "<202>", "<203>", "<204>", "<205>", "<206>", "<207>",
"<208>", "<209>", "<210>", "<211>", "<212>", "<213>", "<214>", "<215>",
"<216>", "<217>", "<218>", "<219>", "<220>", "<221>", "<222>", "<223>",
"<224>", "<225>", "<226>", "<227>", "<228>", "<229>", "<230>", "<231>",
"<232>", "<233>", "<234>", "<235>", "<236>", "<237>", "<238>", "<239>",
"<240>", "<241>", "<242>", "<243>", "<244>", "<245>", "<246>", "<247>",
"<248>", "<249>", "<250>", "<251>", "<252>", "<253>", "<254>", "<255>",
};
const char* Py2k::OpcodeNames[256] = {
"STOP_CODE", "POP_TOP", "ROT_TWO", "ROT_THREE", "DUP_TOP", "ROT_FOUR",
"<6>", "<7>", "<8>", "NOP",
"UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "UNARY_CONVERT",
"<14>", "UNARY_INVERT", "<16>", "<17>", "LIST_APPEND",
"BINARY_POWER", "BINARY_MULTIPLY", "BINARY_DIVIDE", "BINARY_MODULO",
"BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_FLOOR_DIVIDE",
"BINARY_TRUE_DIVIDE", "INPLACE_FLOOR_DIVIDE", "INPLACE_TRUE_DIVIDE",
"SLICE+0", "SLICE+1", "SLICE+2", "SLICE+3",
"<34>", "<35>", "<36>", "<37>", "<38>", "<39>",
"STORE_SLICE+0", "STORE_SLICE+1", "STORE_SLICE+2", "STORE_SLICE+3",
"<44>", "<45>", "<46>", "<47>", "<48>", "<49>",
"DELETE_SLICE+0", "DELETE_SLICE+1", "DELETE_SLICE+2", "DELETE_SLICE+3",
"STORE_MAP", "INPLACE_ADD", "INPLACE_SUBTRACT", "INPLACE_MULTIPLY",
"INPLACE_DIVIDE", "INPLACE_MODULO",
"STORE_SUBSCR", "DELETE_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT",
"BINARY_AND", "BINARY_XOR", "BINARY_OR", "INPLACE_POWER", "GET_ITER", "<69>",
"PRINT_EXPR", "PRINT_ITEM", "PRINT_NEWLINE", "PRINT_ITEM_TO",
"PRINT_NEWLINE_TO", "INPLACE_LSHIFT", "INPLACE_RSHIFT", "INPLACE_AND",
"INPLACE_XOR", "INPLACE_OR",
"BREAK_LOOP", "WITH_CLEANUP", "LOAD_LOCALS", "RETURN_VALUE",
"IMPORT_STAR", "EXEC_STMT", "YIELD_VALUE", "POP_BLOCK", "END_FINALLY",
"BUILD_CLASS",
"STORE_NAME", "DELETE_NAME", "UNPACK_SEQUENCE", "FOR_ITER", "<94>",
"STORE_ATTR", "DELETE_ATTR", "STORE_GLOBAL", "DELETE_GLOBAL", "DUP_TOPX",
"LOAD_CONST", "LOAD_NAME", "BUILD_TUPLE", "BUILD_LIST", "BUILD_MAP",
"LOAD_ATTR", "COMPARE_OP", "IMPORT_NAME", "IMPORT_FROM", "<109>",
"JUMP_FORWARD", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_ABSOLUTE",
"FOR_LOOP", "<115>", "LOAD_GLOBAL", "<117>", "<118>", "CONTINUE_LOOP",
"SETUP_LOOP", "SETUP_EXCEPT", "SETUP_FINALLY", "<123>",
"LOAD_FAST", "STORE_FAST", "DELETE_FAST", "SET_LINENO", "<128>", "<129>",
"RAISE_VARARGS", "CALL_FUNCTION", "MAKE_FUNCTION", "BUILD_SLICE",
"MAKE_CLOSURE", "LOAD_CLOSURE", "LOAD_DEREF", "STORE_DEREF", "<138>", "<139>",
"CALL_FUNCTION_VAR", "CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW", "EXTENDED_ARG",
"<144>", "<145>", "<146>", "<147>", "<148>", "<149>", "<150>", "<151>",
"<152>", "<153>", "<154>", "<155>", "<156>", "<157>", "<158>", "<159>",
"<160>", "<161>", "<162>", "<163>", "<164>", "<165>", "<166>", "<167>",
"<168>", "<169>", "<170>", "<171>", "<172>", "<173>", "<174>", "<175>",
"<176>", "<177>", "<178>", "<179>", "<180>", "<181>", "<182>", "<183>",
"<184>", "<185>", "<186>", "<187>", "<188>", "<189>", "<190>", "<191>",
"<192>", "<193>", "<194>", "<195>", "<196>", "<197>", "<198>", "<199>",
"<200>", "<201>", "<202>", "<203>", "<204>", "<205>", "<206>", "<207>",
"<208>", "<209>", "<210>", "<211>", "<212>", "<213>", "<214>", "<215>",
"<216>", "<217>", "<218>", "<219>", "<220>", "<221>", "<222>", "<223>",
"<224>", "<225>", "<226>", "<227>", "<228>", "<229>", "<230>", "<231>",
"<232>", "<233>", "<234>", "<235>", "<236>", "<237>", "<238>", "<239>",
"<240>", "<241>", "<242>", "<243>", "<244>", "<245>", "<246>", "<247>",
"<248>", "<249>", "<250>", "<251>", "<252>", "<253>", "<254>", "<255>",
};
const char* Py2k::OpcodeNames27[256] = {
"STOP_CODE", "POP_TOP", "ROT_TWO", "ROT_THREE", "DUP_TOP", "ROT_FOUR",
"<6>", "<7>", "<8>", "NOP",
"UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "UNARY_CONVERT",
"<14>", "UNARY_INVERT", "<16>", "<17>", "<18>",
"BINARY_POWER", "BINARY_MULTIPLY", "BINARY_DIVIDE", "BINARY_MODULO",
"BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_FLOOR_DIVIDE",
"BINARY_TRUE_DIVIDE", "INPLACE_FLOOR_DIVIDE", "INPLACE_TRUE_DIVIDE",
"SLICE+0", "SLICE+1", "SLICE+2", "SLICE+3",
"<34>", "<35>", "<36>", "<37>", "<38>", "<39>",
"STORE_SLICE+0", "STORE_SLICE+1", "STORE_SLICE+2", "STORE_SLICE+3",
"<44>", "<45>", "<46>", "<47>", "<48>", "<49>",
"DELETE_SLICE+0", "DELETE_SLICE+1", "DELETE_SLICE+2", "DELETE_SLICE+3",
"STORE_MAP", "INPLACE_ADD", "INPLACE_SUBTRACT", "INPLACE_MULTIPLY",
"INPLACE_DIVIDE", "INPLACE_MODULO",
"STORE_SUBSCR", "DELETE_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT",
"BINARY_AND", "BINARY_XOR", "BINARY_OR", "INPLACE_POWER", "GET_ITER", "<69>",
"PRINT_EXPR", "PRINT_ITEM", "PRINT_NEWLINE", "PRINT_ITEM_TO",
"PRINT_NEWLINE_TO", "INPLACE_LSHIFT", "INPLACE_RSHIFT", "INPLACE_AND",
"INPLACE_XOR", "INPLACE_OR",
"BREAK_LOOP", "WITH_CLEANUP", "LOAD_LOCALS", "RETURN_VALUE",
"IMPORT_STAR", "EXEC_STMT", "YIELD_VALUE", "POP_BLOCK", "END_FINALLY",
"BUILD_CLASS",
"STORE_NAME", "DELETE_NAME", "UNPACK_SEQUENCE", "FOR_ITER", "LIST_APPEND",
"STORE_ATTR", "DELETE_ATTR", "STORE_GLOBAL", "DELETE_GLOBAL", "DUP_TOPX",
"LOAD_CONST", "LOAD_NAME", "BUILD_TUPLE", "BUILD_LIST", "BUILD_SET",
"BUILD_MAP", "LOAD_ATTR", "COMPARE_OP", "IMPORT_NAME", "IMPORT_FROM",
"JUMP_FORWARD", "JUMP_IF_FALSE_OR_POP", "JUMP_IF_TRUE_OR_POP",
"JUMP_ABSOLUTE", "POP_JUMP_IF_FALSE", "POP_JUMP_IF_TRUE",
"LOAD_GLOBAL", "<117>", "<118>", "CONTINUE_LOOP",
"SETUP_LOOP", "SETUP_EXCEPT", "SETUP_FINALLY", "<123>",
"LOAD_FAST", "STORE_FAST", "DELETE_FAST", "SET_LINENO", "<128>", "<129>",
"RAISE_VARARGS", "CALL_FUNCTION", "MAKE_FUNCTION", "BUILD_SLICE",
"MAKE_CLOSURE", "LOAD_CLOSURE", "LOAD_DEREF", "STORE_DEREF", "<138>", "<139>",
"CALL_FUNCTION_VAR", "CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW", "SETUP_WITH",
"<144>", "EXTENDED_ARG", "SET_ADD", "MAP_ADD", "<148>", "<149>", "<150>", "<151>",
"<152>", "<153>", "<154>", "<155>", "<156>", "<157>", "<158>", "<159>",
"<160>", "<161>", "<162>", "<163>", "<164>", "<165>", "<166>", "<167>",
"<168>", "<169>", "<170>", "<171>", "<172>", "<173>", "<174>", "<175>",
"<176>", "<177>", "<178>", "<179>", "<180>", "<181>", "<182>", "<183>",
"<184>", "<185>", "<186>", "<187>", "<188>", "<189>", "<190>", "<191>",
"<192>", "<193>", "<194>", "<195>", "<196>", "<197>", "<198>", "<199>",
"<200>", "<201>", "<202>", "<203>", "<204>", "<205>", "<206>", "<207>",
"<208>", "<209>", "<210>", "<211>", "<212>", "<213>", "<214>", "<215>",
"<216>", "<217>", "<218>", "<219>", "<220>", "<221>", "<222>", "<223>",
"<224>", "<225>", "<226>", "<227>", "<228>", "<229>", "<230>", "<231>",
"<232>", "<233>", "<234>", "<235>", "<236>", "<237>", "<238>", "<239>",
"<240>", "<241>", "<242>", "<243>", "<244>", "<245>", "<246>", "<247>",
"<248>", "<249>", "<250>", "<251>", "<252>", "<253>", "<254>", "<255>",
};
const char* Py3k::OpcodeNames[256] = {
"STOP_CODE", "POP_TOP", "ROT_TWO", "ROT_THREE", "DUP_TOP", "ROT_FOUR",
"<6>", "<7>", "<8>", "NOP",
"UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "<13>", "<14>",
"UNARY_INVERT", "<16>", "SET_ADD", "LIST_APPEND",
"BINARY_POWER", "BINARY_MULTIPLY", "<21>", "BINARY_MODULO",
"BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_FLOOR_DIVIDE",
"BINARY_TRUE_DIVIDE", "INPLACE_FLOOR_DIVIDE", "INPLACE_TRUE_DIVIDE",
"<30>", "<31>", "<32>", "<33>", "<34>", "<35>", "<36>", "<37>", "<38>", "<39>",
"<40>", "<41>", "<42>", "<43>", "<44>", "<45>", "<46>", "<47>", "<48>", "<49>",
"<50>", "<51>", "<52>", "<53>",
"STORE_MAP", "INPLACE_ADD", "INPLACE_SUBTRACT", "INPLACE_MULTIPLY",
"<58>", "INPLACE_MODULO",
"STORE_SUBSCR", "DELETE_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT",
"BINARY_AND", "BINARY_XOR", "BINARY_OR", "INPLACE_POWER", "GET_ITER",
"STORE_LOCALS",
"PRINT_EXPR", "LOAD_BUILD_CLASS", "<72>", "<73>", "<74>",
"INPLACE_LSHIFT", "INPLACE_RSHIFT", "INPLACE_AND", "INPLACE_XOR",
"INPLACE_OR",
"BREAK_LOOP", "WITH_CLEANUP", "<82>", "RETURN_VALUE",
"IMPORT_STAR", "<85>", "YIELD_VALUE", "POP_BLOCK", "END_FINALLY",
"POP_EXCEPT",
"STORE_NAME", "DELETE_NAME", "UNPACK_SEQUENCE", "FOR_ITER", "UNPACK_EX",
"STORE_ATTR", "DELETE_ATTR", "STORE_GLOBAL", "DELETE_GLOBAL", "DUP_TOPX",
"LOAD_CONST", "LOAD_NAME", "BUILD_TUPLE", "BUILD_LIST", "BUILD_SET",
"STORE_ATTR", "DELETE_ATTR", "STORE_GLOBAL", "DELETE_GLOBAL",
"UNPACK_VARARG", "LOAD_CONST", "LOAD_NAME", "BUILD_TUPLE", "BUILD_LIST",
"BUILD_MAP", "LOAD_ATTR", "COMPARE_OP", "IMPORT_NAME", "IMPORT_FROM",
"JUMP_FORWARD", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_ABSOLUTE",
"POP_JUMP_IF_FALSE", "POP_JUMP_IF_TRUE", "LOAD_GLOBAL", "<117>", "<118>",
"CONTINUE_LOOP", "SETUP_LOOP", "SETUP_EXCEPT", "SETUP_FINALLY", "<123>",
"LOAD_FAST", "STORE_FAST", "DELETE_FAST", "<127>", "<128>", "<129>",
"RAISE_VARARGS", "CALL_FUNCTION", "MAKE_FUNCTION", "BUILD_SLICE",
"MAKE_CLOSURE", "LOAD_CLOSURE", "LOAD_DEREF", "STORE_DEREF", "<138>", "<139>",
"CALL_FUNCTION_VAR", "CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW",
"EXTENDED_ARG", "<144>", "LIST_APPEND", "SET_ADD", "MAP_ADD",
"<148>", "<149>", "<150>", "<151>",
"<152>", "<153>", "<154>", "<155>", "<156>", "<157>", "<158>", "<159>",
"<160>", "<161>", "<162>", "<163>", "<164>", "<165>", "<166>", "<167>",
"<168>", "<169>", "<170>", "<171>", "<172>", "<173>", "<174>", "<175>",
"<176>", "<177>", "<178>", "<179>", "<180>", "<181>", "<182>", "<183>",
"<184>", "<185>", "<186>", "<187>", "<188>", "<189>", "<190>", "<191>",
"<192>", "<193>", "<194>", "<195>", "<196>", "<197>", "<198>", "<199>",
"<200>", "<201>", "<202>", "<203>", "<204>", "<205>", "<206>", "<207>",
"<208>", "<209>", "<210>", "<211>", "<212>", "<213>", "<214>", "<215>",
"<216>", "<217>", "<218>", "<219>", "<220>", "<221>", "<222>", "<223>",
"<224>", "<225>", "<226>", "<227>", "<228>", "<229>", "<230>", "<231>",
"<232>", "<233>", "<234>", "<235>", "<236>", "<237>", "<238>", "<239>",
"<240>", "<241>", "<242>", "<243>", "<244>", "<245>", "<246>", "<247>",
"<248>", "<249>", "<250>", "<251>", "<252>", "<253>", "<254>", "<255>",
"FOR_LOOP", "LOAD_LOCAL", "LOAD_GLOBAL", "SET_FUNC_ARGS", "SETUP_LOOP",
"SETUP_EXCEPT", "SETUP_FINALLY", "RESERVE_FAST", "LOAD_FAST",
"STORE_FAST", "DELETE_FAST", "SET_LINENO", "RAISE_VARARGS",
"CALL_FUNCTION", "MAKE_FUNCTION", "BUILD_SLICE", "CALL_FUNCTION_VAR",
"CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW", "UNPACK_SEQUENCE", "FOR_ITER",
"DUP_TOPX", "BUILD_SET", "JUMP_IF_FALSE_OR_POP", "JUMP_IF_TRUE_OR_POP",
"POP_JUMP_IF_FALSE", "POP_JUMP_IF_TRUE", "CONTINUE_LOOP", "MAKE_CLOSURE",
"LOAD_CLOSURE", "LOAD_DEREF", "STORE_DEREF", "EXTENDED_ARG", "SETUP_WITH",
"SET_ADD", "MAP_ADD", "UNPACK_EX", "LIST_APPEND"
};
if (opcode < 0)
return "<INVALID>";
if (opcode < PYC_LAST_OPCODE)
return opcode_names[opcode];
static char badcode[10];
snprintf(badcode, 10, "<%d>", opcode);
return badcode;
};
bool Py1k::IsConstArg(int opcode)
int Pyc::ByteToOpcode(int maj, int min, int opcode)
{
return (opcode == Py1k::LOAD_CONST) || (opcode == Py1k::RESERVE_FAST);
}
bool Py1k::IsNameArg(int opcode)
{
return (opcode == Py1k::DELETE_ATTR) || (opcode == Py1k::DELETE_GLOBAL) ||
(opcode == Py1k::DELETE_NAME) || (opcode == Py1k::IMPORT_FROM) ||
(opcode == Py1k::IMPORT_NAME) || (opcode == Py1k::LOAD_ATTR) ||
(opcode == Py1k::LOAD_GLOBAL) || (opcode == Py1k::LOAD_LOCAL) ||
(opcode == Py1k::LOAD_NAME) || (opcode == Py1k::STORE_ATTR) ||
(opcode == Py1k::STORE_GLOBAL) || (opcode == Py1k::STORE_NAME);
}
bool Py1k::IsVarNameArg(int opcode)
{
return (opcode == Py1k::DELETE_FAST) || (opcode == Py1k::LOAD_FAST) ||
(opcode == Py1k::STORE_FAST);
}
bool Py1k::IsJumpOffsetArg(int opcode)
{
return (opcode == Py1k::JUMP_FORWARD) || (opcode == Py1k::JUMP_IF_FALSE) ||
(opcode == Py1k::JUMP_IF_TRUE);
}
bool Py2k::IsConstArg(int opcode)
{
return (opcode == Py2k::LOAD_CONST);
}
bool Py2k::IsNameArg(int opcode, int minorVer)
{
if (minorVer >= 7) {
return (opcode == Py2k::DELETE_ATTR) || (opcode == Py2k::DELETE_GLOBAL) ||
(opcode == Py2k::DELETE_NAME) || (opcode == Py2k::IMPORT_FROM_27) ||
(opcode == Py2k::IMPORT_NAME_27) || (opcode == Py2k::LOAD_ATTR_27) ||
(opcode == Py2k::LOAD_GLOBAL) || (opcode == Py2k::LOAD_NAME) ||
(opcode == Py2k::STORE_ATTR) || (opcode == Py2k::STORE_GLOBAL) ||
(opcode == Py2k::STORE_NAME);
} else {
return (opcode == Py2k::DELETE_ATTR) || (opcode == Py2k::DELETE_GLOBAL) ||
(opcode == Py2k::DELETE_NAME) || (opcode == Py2k::IMPORT_FROM) ||
(opcode == Py2k::IMPORT_NAME) || (opcode == Py2k::LOAD_ATTR) ||
(opcode == Py2k::LOAD_GLOBAL) || (opcode == Py2k::LOAD_NAME) ||
(opcode == Py2k::STORE_ATTR) || (opcode == Py2k::STORE_GLOBAL) ||
(opcode == Py2k::STORE_NAME);
switch (maj) {
case 1:
switch (min) {
case 0: return python_10_map(opcode);
case 1: return python_11_map(opcode);
case 3: return python_13_map(opcode);
case 4: return python_14_map(opcode);
case 5: return python_15_map(opcode);
case 6: return python_16_map(opcode);
}
break;
case 2:
switch (min) {
case 0: return python_20_map(opcode);
case 1: return python_21_map(opcode);
case 2: return python_22_map(opcode);
case 3: return python_23_map(opcode);
case 4: return python_24_map(opcode);
case 5: return python_25_map(opcode);
case 6: return python_26_map(opcode);
case 7: return python_27_map(opcode);
}
break;
case 3:
switch (min) {
case 0: return python_30_map(opcode);
case 1: return python_31_map(opcode);
}
break;
}
return PYC_INVALID_OPCODE;
}
bool Py2k::IsVarNameArg(int opcode)
bool Pyc::IsConstArg(int opcode)
{
return (opcode == Py2k::DELETE_FAST) || (opcode == Py2k::LOAD_FAST) ||
(opcode == Py2k::STORE_FAST);
return (opcode == Pyc::LOAD_CONST_A) || (opcode == Pyc::RESERVE_FAST_A);
}
bool Py2k::IsCellArg(int opcode)
bool Pyc::IsNameArg(int opcode)
{
return (opcode == Py2k::LOAD_CLOSURE) || (opcode == Py2k::LOAD_DEREF) ||
(opcode == Py2k::STORE_DEREF);
return (opcode == Pyc::DELETE_ATTR_A) || (opcode == Pyc::DELETE_GLOBAL_A) ||
(opcode == Pyc::DELETE_NAME_A) || (opcode == Pyc::IMPORT_FROM_A) ||
(opcode == Pyc::IMPORT_NAME_A) || (opcode == Pyc::LOAD_ATTR_A) ||
(opcode == Pyc::LOAD_GLOBAL_A) || (opcode == Pyc::LOAD_LOCAL_A) ||
(opcode == Pyc::LOAD_NAME_A) || (opcode == Pyc::STORE_ATTR_A) ||
(opcode == Pyc::STORE_GLOBAL_A) || (opcode == Pyc::STORE_NAME_A);
}
bool Py2k::IsJumpOffsetArg(int opcode)
bool Pyc::IsVarNameArg(int opcode)
{
return (opcode == Py2k::JUMP_FORWARD) || (opcode == Py2k::JUMP_IF_FALSE) ||
(opcode == Py2k::JUMP_IF_TRUE);
return (opcode == Pyc::DELETE_FAST_A) || (opcode == Pyc::LOAD_FAST_A) ||
(opcode == Pyc::STORE_FAST_A);
}
bool Py3k::IsConstArg(int opcode)
bool Pyc::IsCellArg(int opcode)
{
return (opcode == Py3k::LOAD_CONST);
return (opcode == Pyc::LOAD_CLOSURE_A) || (opcode == Pyc::LOAD_DEREF_A) ||
(opcode == Pyc::STORE_DEREF_A);
}
bool Py3k::IsNameArg(int opcode)
bool Pyc::IsJumpOffsetArg(int opcode)
{
return (opcode == Py3k::DELETE_ATTR) || (opcode == Py3k::DELETE_GLOBAL) ||
(opcode == Py3k::DELETE_NAME) || (opcode == Py3k::IMPORT_FROM) ||
(opcode == Py3k::IMPORT_NAME) || (opcode == Py3k::LOAD_ATTR) ||
(opcode == Py3k::LOAD_GLOBAL) || (opcode == Py3k::LOAD_NAME) ||
(opcode == Py3k::STORE_ATTR) || (opcode == Py3k::STORE_GLOBAL) ||
(opcode == Py3k::STORE_NAME);
}
bool Py3k::IsVarNameArg(int opcode)
{
return (opcode == Py3k::DELETE_FAST) || (opcode == Py3k::LOAD_FAST) ||
(opcode == Py3k::STORE_FAST);
}
bool Py3k::IsCellArg(int opcode)
{
return (opcode == Py3k::LOAD_CLOSURE) || (opcode == Py3k::LOAD_DEREF) ||
(opcode == Py3k::STORE_DEREF);
}
bool Py3k::IsJumpOffsetArg(int opcode)
{
return (opcode == Py3k::JUMP_FORWARD) || (opcode == Py3k::JUMP_IF_FALSE) ||
(opcode == Py3k::JUMP_IF_TRUE) || (opcode == Py3k::POP_JUMP_IF_FALSE) ||
(opcode == Py3k::POP_JUMP_IF_TRUE);
return (opcode == Pyc::JUMP_FORWARD_A) || (opcode == Pyc::JUMP_IF_FALSE_A) ||
(opcode == Pyc::JUMP_IF_TRUE_A) || (opcode == Pyc::JUMP_IF_FALSE_OR_POP_A) ||
(opcode == Pyc::JUMP_IF_TRUE_OR_POP_A) || (opcode == Pyc::POP_JUMP_IF_FALSE_A) ||
(opcode == Pyc::POP_JUMP_IF_TRUE_A);
}
@@ -420,20 +258,18 @@ void print_const(PycRef<PycObject> obj, PycModule* mod)
void bc_next(PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& pos)
{
opcode = source.getByte();
opcode = Pyc::ByteToOpcode(mod->majorVer(), mod->minorVer(), source.getByte());
operand = 0;
bool haveExtArg = false;
pos += 1;
if ((mod->majorVer() == 2 && ((mod->minorVer() < 7 && opcode == Py2k::EXTENDED_ARG) ||
(mod->minorVer() >= 7 && opcode == Py2k::EXTENDED_ARG_27))) ||
(mod->majorVer() == 3 && opcode == Py3k::EXTENDED_ARG)) {
if (opcode == Pyc::EXTENDED_ARG_A) {
operand = source.get16() << 16;
opcode = source.getByte();
haveExtArg = true;
pos += 3;
}
if (opcode >= HAVE_ARG) {
if (opcode >= Pyc::PYC_HAVE_ARG) {
// If we have an extended arg, we want to OR the lower part,
// else we want the whole thing (in case it's negative). We use
// the bool so that values between 0x8000 and 0xFFFF can be stored
@@ -458,38 +294,20 @@ void bc_disasm(PycRef<PycCode> code, PycModule* mod, int indent)
printf("%-7d ", pos); // Current bytecode position
bc_next(source, mod, opcode, operand, pos);
printf("%-24s", Pyc::OpcodeName(opcode));
if (mod->majorVer() == 1) {
printf("%-24s", Py1k::OpcodeNames[opcode]);
} else if (mod->majorVer() == 2 && mod->minorVer() < 7) {
printf("%-24s", Py2k::OpcodeNames[opcode]);
} else if (mod->majorVer() == 2 && mod->minorVer() >= 7) {
printf("%-24s", Py2k::OpcodeNames27[opcode]);
} else if (mod->majorVer() == 3) {
printf("%-24s", Py3k::OpcodeNames[opcode]);
}
if (opcode >= HAVE_ARG) {
if ((mod->majorVer() == 1 && Py1k::IsConstArg(opcode)) ||
(mod->majorVer() == 2 && Py2k::IsConstArg(opcode)) ||
(mod->majorVer() == 3 && Py3k::IsConstArg(opcode))) {
if (opcode >= Pyc::PYC_HAVE_ARG) {
if (Pyc::IsConstArg(opcode)) {
printf("%d: ", operand);
print_const(code->getConst(operand), mod);
} else if ((mod->majorVer() == 1 && Py1k::IsNameArg(opcode)) ||
(mod->majorVer() == 1 && mod->minorVer() < 3 && Py1k::IsVarNameArg(opcode)) ||
(mod->majorVer() == 2 && Py2k::IsNameArg(opcode, mod->minorVer())) ||
(mod->majorVer() == 3 && Py3k::IsNameArg(opcode))) {
} else if (Pyc::IsNameArg(opcode)) {
printf("%d: %s", operand, code->getName(operand)->value());
} else if ((mod->majorVer() == 1 && Py1k::IsVarNameArg(opcode)) ||
(mod->majorVer() == 2 && Py2k::IsVarNameArg(opcode)) ||
(mod->majorVer() == 3 && Py3k::IsVarNameArg(opcode))) {
} else if (Pyc::IsVarNameArg(opcode)) {
printf("%d: %s", operand, code->getVarName(operand)->value());
} else if ((mod->majorVer() == 2 && Py2k::IsCellArg(opcode)) ||
(mod->majorVer() == 3 && Py3k::IsCellArg(opcode))) {
} else if (Pyc::IsCellArg(opcode)) {
printf("%d: ", operand);
print_const(code->getConst(operand), mod);
} else if ((mod->majorVer() == 1 && Py1k::IsJumpOffsetArg(opcode)) ||
(mod->majorVer() == 2 && Py2k::IsJumpOffsetArg(opcode)) ||
(mod->majorVer() == 3 && Py3k::IsJumpOffsetArg(opcode))) {
} else if (Pyc::IsJumpOffsetArg(opcode)) {
printf("%d (to %d)", operand, pos+operand);
} else {
printf("%d", operand);

172
bytecode.h
View File

@@ -2,139 +2,53 @@
#include "module.h"
#include "data.h"
// Opcodes >= this value have an argument after the opcode
#define HAVE_ARG 90
namespace Pyc {
namespace Py1k {
enum Opcodes {
STOP_CODE = 0, POP_TOP, ROT_TWO, ROT_THREE, DUP_TOP,
UNARY_POSITIVE = 10, UNARY_NEGATIVE, UNARY_NOT, UNARY_CONVERT,
UNARY_CALL, UNARY_INVERT,
BINARY_POWER = 19, BINARY_MULTIPLY, BINARY_DIVIDE, BINARY_MODULO,
enum Opcode {
/* No parameter word */
STOP_CODE, POP_TOP, ROT_TWO, ROT_THREE, DUP_TOP, UNARY_POSITIVE,
UNARY_NEGATIVE, UNARY_NOT, UNARY_CONVERT, UNARY_CALL, UNARY_INVERT,
BINARY_POWER, BINARY_MULTIPLY, BINARY_DIVIDE, BINARY_MODULO,
BINARY_ADD, BINARY_SUBTRACT, BINARY_SUBSCR, BINARY_CALL,
SLICE_0 = 30, SLICE_1, SLICE_2, SLICE_3,
STORE_SLICE_0 = 40, STORE_SLICE_1, STORE_SLICE_2, STORE_SLICE_3,
DELETE_SLICE_0 = 50, DELETE_SLICE_1, DELETE_SLICE_2, DELETE_SLICE_3,
STORE_SUBSCR = 60, DELETE_SUBSCR, BINARY_LSHIFT, BINARY_RSHIFT,
BINARY_AND, BINARY_XOR, BINARY_OR,
PRINT_EXPR = 70, PRINT_ITEM, PRINT_NEWLINE,
BREAK_LOOP = 80, RAISE_EXCEPTION, LOAD_LOCALS, RETURN_VALUE,
LOAD_GLOBALS, EXEC_STMT, BUILD_FUNCTION, POP_BLOCK, END_FINALLY,
BUILD_CLASS,
STORE_NAME = 90, DELETE_NAME, UNPACK_TUPLE, UNPACK_LIST, UNPACK_ARG,
STORE_ATTR, DELETE_ATTR, STORE_GLOBAL, DELETE_GLOBAL, UNPACK_VARARG,
LOAD_CONST, LOAD_NAME, BUILD_TUPLE, BUILD_LIST, BUILD_MAP,
LOAD_ATTR, COMPARE_OP, IMPORT_NAME, IMPORT_FROM,
JUMP_FORWARD = 110, JUMP_IF_FALSE, JUMP_IF_TRUE, JUMP_ABSOLUTE,
FOR_LOOP, LOAD_LOCAL, LOAD_GLOBAL, SET_FUNC_ARGS,
SETUP_LOOP = 120, SETUP_EXCEPT, SETUP_FINALLY, RESERVE_FAST,
LOAD_FAST, STORE_FAST, DELETE_FAST, SET_LINENO,
RAISE_VARARGS = 130, CALL_FUNCTION, MAKE_FUNCTION, BUILD_SLICE,
CALL_FUNCTION_VAR = 140, CALL_FUNCTION_KW, CALL_FUNCTION_VAR_KW,
SLICE_0, SLICE_1, SLICE_2, SLICE_3, STORE_SLICE_0, STORE_SLICE_1,
STORE_SLICE_2, STORE_SLICE_3, DELETE_SLICE_0, DELETE_SLICE_1,
DELETE_SLICE_2, DELETE_SLICE_3, STORE_SUBSCR, DELETE_SUBSCR,
BINARY_LSHIFT, BINARY_RSHIFT, BINARY_AND, BINARY_XOR, BINARY_OR,
PRINT_EXPR, PRINT_ITEM, PRINT_NEWLINE, BREAK_LOOP, RAISE_EXCEPTION,
LOAD_LOCALS, RETURN_VALUE, LOAD_GLOBALS, EXEC_STMT, BUILD_FUNCTION,
POP_BLOCK, END_FINALLY, BUILD_CLASS, ROT_FOUR, NOP, LIST_APPEND,
BINARY_FLOOR_DIVIDE, BINARY_TRUE_DIVIDE, INPLACE_FLOOR_DIVIDE,
INPLACE_TRUE_DIVIDE, STORE_MAP, INPLACE_ADD, INPLACE_SUBTRACT,
INPLACE_MULTIPLY, INPLACE_DIVIDE, INPLACE_MODULO, INPLACE_POWER,
GET_ITER, PRINT_ITEM_TO, PRINT_NEWLINE_TO, INPLACE_LSHIFT,
INPLACE_RSHIFT, INPLACE_AND, INPLACE_XOR, INPLACE_OR, WITH_CLEANUP,
IMPORT_STAR, YIELD_VALUE, LOAD_BUILD_CLASS, STORE_LOCALS,
POP_EXCEPT, SET_ADD,
/* Has parameter word */
PYC_HAVE_ARG,
STORE_NAME_A = PYC_HAVE_ARG, DELETE_NAME_A, UNPACK_TUPLE_A,
UNPACK_LIST_A, UNPACK_ARG_A, STORE_ATTR_A, DELETE_ATTR_A,
STORE_GLOBAL_A, DELETE_GLOBAL_A, UNPACK_VARARG_A, LOAD_CONST_A,
LOAD_NAME_A, BUILD_TUPLE_A, BUILD_LIST_A, BUILD_MAP_A, LOAD_ATTR_A,
COMPARE_OP_A, IMPORT_NAME_A, IMPORT_FROM_A, JUMP_FORWARD_A,
JUMP_IF_FALSE_A, JUMP_IF_TRUE_A, JUMP_ABSOLUTE_A, FOR_LOOP_A,
LOAD_LOCAL_A, LOAD_GLOBAL_A, SET_FUNC_ARGS_A, SETUP_LOOP_A,
SETUP_EXCEPT_A, SETUP_FINALLY_A, RESERVE_FAST_A, LOAD_FAST_A,
STORE_FAST_A, DELETE_FAST_A, SET_LINENO_A, RAISE_VARARGS_A,
CALL_FUNCTION_A, MAKE_FUNCTION_A, BUILD_SLICE_A, CALL_FUNCTION_VAR_A,
CALL_FUNCTION_KW_A, CALL_FUNCTION_VAR_KW_A, UNPACK_SEQUENCE_A, FOR_ITER_A,
DUP_TOPX_A, BUILD_SET_A, JUMP_IF_FALSE_OR_POP_A, JUMP_IF_TRUE_OR_POP_A,
POP_JUMP_IF_FALSE_A, POP_JUMP_IF_TRUE_A, CONTINUE_LOOP_A, MAKE_CLOSURE_A,
LOAD_CLOSURE_A, LOAD_DEREF_A, STORE_DEREF_A, EXTENDED_ARG_A, SETUP_WITH_A,
SET_ADD_A, MAP_ADD_A, UNPACK_EX_A, LIST_APPEND_A,
PYC_LAST_OPCODE,
PYC_INVALID_OPCODE = -1,
};
extern const char* OpcodeNames[256];
bool IsConstArg(int opcode);
bool IsNameArg(int opcode);
bool IsVarNameArg(int opcode);
bool IsJumpOffsetArg(int opcode);
}
namespace Py2k {
enum Opcodes {
STOP_CODE = 0, POP_TOP, ROT_TWO, ROT_THREE, DUP_TOP, ROT_FOUR,
NOP = 9, UNARY_POSITIVE, UNARY_NEGATIVE, UNARY_NOT, UNARY_CONVERT,
UNARY_INVERT = 15, LIST_APPEND = 18,
BINARY_POWER = 19, BINARY_MULTIPLY, BINARY_DIVIDE, BINARY_MODULO,
BINARY_ADD, BINARY_SUBTRACT, BINARY_SUBSCR, BINARY_FLOOR_DIVIDE,
BINARY_TRUE_DIVIDE, INPLACE_FLOOR_DIVIDE, INPLACE_TRUE_DIVIDE,
SLICE_0 = 30, SLICE_1, SLICE_2, SLICE_3,
STORE_SLICE_0 = 40, STORE_SLICE_1, STORE_SLICE_2, STORE_SLICE_3,
DELETE_SLICE_0 = 50, DELETE_SLICE_1, DELETE_SLICE_2, DELETE_SLICE_3,
STORE_MAP = 54, INPLACE_ADD, INPLACE_SUBTRACT, INPLACE_MULTIPLY,
INPLACE_DIVIDE, INPLACE_MODULO,
STORE_SUBSCR = 60, DELETE_SUBSCR, BINARY_LSHIFT, BINARY_RSHIFT,
BINARY_AND, BINARY_XOR, BINARY_OR, INPLACE_POWER, GET_ITER,
PRINT_EXPR = 70, PRINT_ITEM, PRINT_NEWLINE, PRINT_ITEM_TO,
PRINT_NEWLINE_TO, INPLACE_LSHIFT, INPLACE_RSHIFT, INPLACE_AND,
INPLACE_XOR, INPLACE_OR,
BREAK_LOOP = 80, WITH_CLEANUP, LOAD_LOCALS, RETURN_VALUE,
IMPORT_STAR, EXEC_STMT, YIELD_VALUE, POP_BLOCK, END_FINALLY,
BUILD_CLASS,
STORE_NAME = 90, DELETE_NAME, UNPACK_SEQUENCE, FOR_ITER,
STORE_ATTR = 95, DELETE_ATTR, STORE_GLOBAL, DELETE_GLOBAL,
DUP_TOPX, LOAD_CONST, LOAD_NAME, BUILD_TUPLE, BUILD_LIST, BUILD_MAP,
LOAD_ATTR, COMPARE_OP, IMPORT_NAME, IMPORT_FROM,
JUMP_FORWARD = 110, JUMP_IF_FALSE, JUMP_IF_TRUE, JUMP_ABSOLUTE,
FOR_LOOP, LOAD_GLOBAL = 116,
CONTINUE_LOOP = 119, SETUP_LOOP, SETUP_EXCEPT, SETUP_FINALLY,
LOAD_FAST = 124, STORE_FAST, DELETE_FAST, SET_LINENO,
RAISE_VARARGS = 130, CALL_FUNCTION, MAKE_FUNCTION, BUILD_SLICE,
MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF,
CALL_FUNCTION_VAR = 140, CALL_FUNCTION_KW, CALL_FUNCTION_VAR_KW,
EXTENDED_ARG,
/* Different opcodes in Python 2.7. Boo! */
LIST_APPEND_27 = 94,
BUILD_SET_27 = BUILD_MAP, BUILD_MAP_27, LOAD_ATTR_27, COMPARE_OP_27,
IMPORT_NAME_27, IMPORT_FROM_27,
JUMP_IF_FALSE_OR_POP = JUMP_IF_FALSE,
JUMP_IF_TRUE_OR_POP = JUMP_IF_TRUE,
POP_JUMP_IF_FALSE = FOR_LOOP, POP_JUMP_IF_TRUE,
SETUP_WITH = EXTENDED_ARG, EXTENDED_ARG_27 = 145,
SET_ADD = 146, MAP_ADD,
};
extern const char* OpcodeNames[256];
extern const char* OpcodeNames27[256];
bool IsConstArg(int opcode);
bool IsNameArg(int opcode, int minorVer);
bool IsVarNameArg(int opcode);
bool IsCellArg(int opcode);
bool IsJumpOffsetArg(int opcode);
}
namespace Py3k {
enum Opcodes {
STOP_CODE = 0, POP_TOP, ROT_TWO, ROT_THREE, DUP_TOP, ROT_FOUR,
NOP = 9, UNARY_POSITIVE, UNARY_NEGATIVE, UNARY_NOT,
UNARY_INVERT = 15, SET_ADD = 17, LIST_APPEND,
BINARY_POWER = 19, BINARY_MULTIPLY, BINARY_MODULO = 22,
BINARY_ADD, BINARY_SUBTRACT, BINARY_SUBSCR, BINARY_FLOOR_DIVIDE,
BINARY_TRUE_DIVIDE, INPLACE_FLOOR_DIVIDE, INPLACE_TRUE_DIVIDE,
STORE_MAP = 54, INPLACE_ADD, INPLACE_SUBTRACT, INPLACE_MULTIPLY,
INPLACE_MODULO = 59,
STORE_SUBSCR = 60, DELETE_SUBSCR, BINARY_LSHIFT, BINARY_RSHIFT,
BINARY_AND, BINARY_XOR, BINARY_OR, INPLACE_POWER, GET_ITER,
STORE_LOCALS,
PRINT_EXPR = 70, LOAD_BUILD_CLASS,
INPLACE_LSHIFT = 75, INPLACE_RSHIFT, INPLACE_AND, INPLACE_XOR,
INPLACE_OR,
BREAK_LOOP = 80, WITH_CLEANUP, RETURN_VALUE = 83,
IMPORT_STAR, YIELD_VALUE = 86, POP_BLOCK, END_FINALLY, POP_EXCEPT,
STORE_NAME = 90, DELETE_NAME, UNPACK_SEQUENCE, FOR_ITER, UNPACK_EX,
STORE_ATTR, DELETE_ATTR, STORE_GLOBAL, DELETE_GLOBAL,
DUP_TOPX, LOAD_CONST, LOAD_NAME, BUILD_TUPLE, BUILD_LIST, BUILD_SET,
BUILD_MAP, LOAD_ATTR, COMPARE_OP, IMPORT_NAME, IMPORT_FROM,
JUMP_FORWARD = 110, JUMP_IF_FALSE, JUMP_IF_TRUE, JUMP_ABSOLUTE,
POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE, LOAD_GLOBAL,
CONTINUE_LOOP = 119, SETUP_LOOP, SETUP_EXCEPT, SETUP_FINALLY,
LOAD_FAST = 124, STORE_FAST, DELETE_FAST,
RAISE_VARARGS = 130, CALL_FUNCTION, MAKE_FUNCTION, BUILD_SLICE,
MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF,
CALL_FUNCTION_VAR = 140, CALL_FUNCTION_KW, CALL_FUNCTION_VAR_KW,
EXTENDED_ARG,
LIST_APPEND_A = 145, SET_ADD_A, MAP_ADD_A,
};
extern const char* OpcodeNames[256];
const char* OpcodeName(int opcode);
int ByteToOpcode(int maj, int min, int opcode);
bool IsConstArg(int opcode);
bool IsNameArg(int opcode);

51
bytes/comp_map.py Executable file
View File

@@ -0,0 +1,51 @@
#!/usr/bin/env python
# This file is part of pycdc.
#
# pycdc is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pycdc is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pycdc. If not, see <http://www.gnu.org/licenses/>.
maplist = [ 'python_10', 'python_11', 'python_13', 'python_14', 'python_15',
'python_16', 'python_20', 'python_21', 'python_22', 'python_23',
'python_24', 'python_25', 'python_26', 'python_27', 'python_30',
'python_31' ]
for mapfile in maplist:
infile = open(mapfile + '.map', 'rt')
outfile = open(mapfile + '.cpp', 'wb')
with infile and outfile:
idToOpcode = {}
opcodeToId = {}
for ln in infile.readlines():
fileid, code = ln.split()
idToOpcode[fileid] = code
opcodeToId[code] = fileid
outfile.write('/* This file was auto-generated with comp_map.py. DO NOT EDIT! */\n\n')
outfile.write('#include "../bytecode.h"\n\n')
outfile.write('int ' + mapfile + '_map(int id)\n')
outfile.write('{\n')
outfile.write(' switch (id) {\n')
for i in idToOpcode:
outfile.write(' case ' + i + ': return Pyc::' + idToOpcode[i] + ';\n')
outfile.write(' default: return Pyc::PYC_INVALID_OPCODE;\n')
outfile.write(' }\n')
outfile.write('}\n\n')
outfile.write('int ' + mapfile + '_unmap(int id)\n')
outfile.write('{\n')
outfile.write(' switch (id) {\n')
for i in opcodeToId:
outfile.write(' case Pyc::' + i + ': return ' + opcodeToId[i] + ';\n')
outfile.write(' default: return -1;\n')
outfile.write(' }\n')
outfile.write('}\n')

77
bytes/python_10.map Normal file
View File

@@ -0,0 +1,77 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
14 UNARY_CALL
15 UNARY_INVERT
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_CALL
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
81 RAISE_EXCEPTION
82 LOAD_LOCALS
83 RETURN_VALUE
86 BUILD_FUNCTION
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
94 UNPACK_ARG_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 UNPACK_VARARG_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
115 LOAD_LOCAL_A
116 LOAD_GLOBAL_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
123 RESERVE_FAST_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A

80
bytes/python_11.map Normal file
View File

@@ -0,0 +1,80 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
14 UNARY_CALL
15 UNARY_INVERT
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_CALL
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
81 RAISE_EXCEPTION
82 LOAD_LOCALS
83 RETURN_VALUE
84 LOAD_GLOBALS
85 EXEC_STMT
86 BUILD_FUNCTION
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
94 UNPACK_ARG_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 UNPACK_VARARG_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
115 LOAD_LOCAL_A
116 LOAD_GLOBAL_A
117 SET_FUNC_ARGS_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
123 RESERVE_FAST_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A

80
bytes/python_13.map Normal file
View File

@@ -0,0 +1,80 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
14 UNARY_CALL
15 UNARY_INVERT
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_CALL
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
81 RAISE_EXCEPTION
82 LOAD_LOCALS
83 RETURN_VALUE
84 LOAD_GLOBALS
85 EXEC_STMT
86 BUILD_FUNCTION
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
94 UNPACK_ARG_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 UNPACK_VARARG_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
115 LOAD_LOCAL_A
116 LOAD_GLOBAL_A
117 SET_FUNC_ARGS_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
123 RESERVE_FAST_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A

84
bytes/python_14.map Normal file
View File

@@ -0,0 +1,84 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
14 UNARY_CALL
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_CALL
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
81 RAISE_EXCEPTION
82 LOAD_LOCALS
83 RETURN_VALUE
85 EXEC_STMT
86 BUILD_FUNCTION
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
94 UNPACK_ARG_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 UNPACK_VARARG_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
115 LOAD_LOCAL_A
116 LOAD_GLOBAL_A
117 SET_FUNC_ARGS_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
123 RESERVE_FAST_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A

80
bytes/python_15.map Normal file
View File

@@ -0,0 +1,80 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
85 EXEC_STMT
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
116 LOAD_GLOBAL_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A

83
bytes/python_16.map Normal file
View File

@@ -0,0 +1,83 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
85 EXEC_STMT
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_TUPLE_A
93 UNPACK_LIST_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
116 LOAD_GLOBAL_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A

99
bytes/python_20.map Normal file
View File

@@ -0,0 +1,99 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
116 LOAD_GLOBAL_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

104
bytes/python_21.map Normal file
View File

@@ -0,0 +1,104 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

111
bytes/python_22.map Normal file
View File

@@ -0,0 +1,111 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 FOR_LOOP_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 SET_LINENO_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

109
bytes/python_23.map Normal file
View File

@@ -0,0 +1,109 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

111
bytes/python_24.map Normal file
View File

@@ -0,0 +1,111 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
18 LIST_APPEND
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

112
bytes/python_25.map Normal file
View File

@@ -0,0 +1,112 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
18 LIST_APPEND
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
81 WITH_CLEANUP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

113
bytes/python_26.map Normal file
View File

@@ -0,0 +1,113 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
18 LIST_APPEND
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
54 STORE_MAP
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
81 WITH_CLEANUP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_MAP_A
105 LOAD_ATTR_A
106 COMPARE_OP_A
107 IMPORT_NAME_A
108 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

119
bytes/python_27.map Normal file
View File

@@ -0,0 +1,119 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
13 UNARY_CONVERT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
21 BINARY_DIVIDE
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
30 SLICE_0
31 SLICE_1
32 SLICE_2
33 SLICE_3
40 STORE_SLICE_0
41 STORE_SLICE_1
42 STORE_SLICE_2
43 STORE_SLICE_3
50 DELETE_SLICE_0
51 DELETE_SLICE_1
52 DELETE_SLICE_2
53 DELETE_SLICE_3
54 STORE_MAP
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
58 INPLACE_DIVIDE
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
70 PRINT_EXPR
71 PRINT_ITEM
72 PRINT_NEWLINE
73 PRINT_ITEM_TO
74 PRINT_NEWLINE_TO
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
81 WITH_CLEANUP
82 LOAD_LOCALS
83 RETURN_VALUE
84 IMPORT_STAR
85 EXEC_STMT
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 BUILD_CLASS
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
94 LIST_APPEND_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_SET_A
105 BUILD_MAP_A
106 LOAD_ATTR_A
107 COMPARE_OP_A
108 IMPORT_NAME_A
109 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_OR_POP_A
112 JUMP_IF_TRUE_OR_POP_A
113 JUMP_ABSOLUTE_A
114 POP_JUMP_IF_FALSE_A
115 POP_JUMP_IF_TRUE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 SETUP_WITH_A
145 EXTENDED_ARG_A
146 SET_ADD_A
147 MAP_ADD_A

97
bytes/python_30.map Normal file
View File

@@ -0,0 +1,97 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
15 UNARY_INVERT
17 SET_ADD
18 LIST_APPEND
19 BINARY_POWER
20 BINARY_MULTIPLY
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
54 STORE_MAP
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
69 STORE_LOCALS
70 PRINT_EXPR
71 LOAD_BUILD_CLASS
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
81 WITH_CLEANUP
83 RETURN_VALUE
84 IMPORT_STAR
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 POP_EXCEPT
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
94 UNPACK_EX_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_SET_A
105 BUILD_MAP_A
106 LOAD_ATTR_A
107 COMPARE_OP_A
108 IMPORT_NAME_A
109 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A

100
bytes/python_31.map Normal file
View File

@@ -0,0 +1,100 @@
0 STOP_CODE
1 POP_TOP
2 ROT_TWO
3 ROT_THREE
4 DUP_TOP
5 ROT_FOUR
9 NOP
10 UNARY_POSITIVE
11 UNARY_NEGATIVE
12 UNARY_NOT
15 UNARY_INVERT
19 BINARY_POWER
20 BINARY_MULTIPLY
22 BINARY_MODULO
23 BINARY_ADD
24 BINARY_SUBTRACT
25 BINARY_SUBSCR
26 BINARY_FLOOR_DIVIDE
27 BINARY_TRUE_DIVIDE
28 INPLACE_FLOOR_DIVIDE
29 INPLACE_TRUE_DIVIDE
54 STORE_MAP
55 INPLACE_ADD
56 INPLACE_SUBTRACT
57 INPLACE_MULTIPLY
59 INPLACE_MODULO
60 STORE_SUBSCR
61 DELETE_SUBSCR
62 BINARY_LSHIFT
63 BINARY_RSHIFT
64 BINARY_AND
65 BINARY_XOR
66 BINARY_OR
67 INPLACE_POWER
68 GET_ITER
69 STORE_LOCALS
70 PRINT_EXPR
71 LOAD_BUILD_CLASS
75 INPLACE_LSHIFT
76 INPLACE_RSHIFT
77 INPLACE_AND
78 INPLACE_XOR
79 INPLACE_OR
80 BREAK_LOOP
81 WITH_CLEANUP
83 RETURN_VALUE
84 IMPORT_STAR
86 YIELD_VALUE
87 POP_BLOCK
88 END_FINALLY
89 POP_EXCEPT
90 STORE_NAME_A
91 DELETE_NAME_A
92 UNPACK_SEQUENCE_A
93 FOR_ITER_A
94 UNPACK_EX_A
95 STORE_ATTR_A
96 DELETE_ATTR_A
97 STORE_GLOBAL_A
98 DELETE_GLOBAL_A
99 DUP_TOPX_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_SET_A
105 BUILD_MAP_A
106 LOAD_ATTR_A
107 COMPARE_OP_A
108 IMPORT_NAME_A
109 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_A
112 JUMP_IF_TRUE_A
113 JUMP_ABSOLUTE_A
114 POP_JUMP_IF_FALSE_A
115 POP_JUMP_IF_TRUE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
134 MAKE_CLOSURE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
140 CALL_FUNCTION_VAR_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_VAR_KW_A
143 EXTENDED_ARG_A
145 LIST_APPEND_A
146 SET_ADD_A
147 MAP_ADD_A

2
module.h
View File

@@ -25,6 +25,8 @@ enum PycMagic {
MAGIC_3_1 = 0x0A0D0C4E,
};
#define PYC_VERSION(maj, min) MAGIC_##maj##_##min
class PycModule {
public:
PycModule();