diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..ded941cfd --- /dev/null +++ b/.clang-format @@ -0,0 +1,31 @@ +BasedOnStyle: LLVM +AccessModifierOffset: -4 +AlignAfterOpenBracket: DontAlign +AlignEscapedNewlines: LeftWithLastLine +AlignTrailingComments: Leave +AllowShortCaseExpressionOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortIfStatementsOnASingleLine: Never +BreakAfterReturnType: ExceptShortType +BreakBeforeBraces: Custom +BreakConstructorInitializers: AfterColon +BreakStringLiterals: false +BraceWrapping: + AfterCaseLabel: true + AfterFunction: true + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterNamespace: false + BeforeElse: true + IndentBraces: false +ColumnLimit: 80 +Cpp11BracedListStyle: False +IndentCaseLabels: false +IndentCaseBlocks: true +IndentPPDirectives: BeforeHash +IndentWidth: 4 +PointerAlignment: Left +ReflowComments: IndentOnly +SpaceInEmptyBlock: true +SpacesBeforeTrailingComments: 3 diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 000000000..bef0c1166 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,12 @@ +Checks: > + -*, + bugprone-*, + modernize-use-override, + clang-analyzer-*, + -bugprone-easily-swappable-parameters, + -clang-diagnostic-error, + -clang-analyzer-cplusplus.NewDelete, + +WarningsAsErrors: '' # keep warnings first, promote to errors later +HeaderFilterRegex: 'src/.*' +FormatStyle: none diff --git a/ASTNode.cpp b/ASTNode.cpp index b93a405ca..760bf6a6e 100644 --- a/ASTNode.cpp +++ b/ASTNode.cpp @@ -14,24 +14,19 @@ void ASTNodeList::removeFirst() m_nodes.erase(m_nodes.begin()); } - /* ASTUnary */ const char* ASTUnary::op_str() const { - static const char* s_op_strings[] = { - "+", "-", "~", "not " - }; + static const char* s_op_strings[] = { "+", "-", "~", "not " }; return s_op_strings[op()]; } - /* ASTBinary */ const char* ASTBinary::op_str() const { - static const char* s_op_strings[] = { - ".", " ** ", " * ", " / ", " // ", " % ", " + ", " - ", - " << ", " >> ", " & ", " ^ ", " | ", " and ", " or ", " @ ", - " += ", " -= ", " *= ", " /= ", " %= ", " **= ", " <<= ", + static const char* s_op_strings[] = { ".", " ** ", " * ", " / ", " // ", + " % ", " + ", " - ", " << ", " >> ", " & ", " ^ ", " | ", " and ", + " or ", " @ ", " += ", " -= ", " *= ", " /= ", " %= ", " **= ", " <<= ", " >>= ", " &= ", " ^= ", " |= ", " //= ", " @= ", " " }; @@ -162,28 +157,22 @@ ASTBinary::BinOp ASTBinary::from_binary_op(int operand) } } - /* ASTCompare */ const char* ASTCompare::op_str() const { - static const char* s_cmp_strings[] = { - " < ", " <= ", " == ", " != ", " > ", " >= ", " in ", " not in ", " is ", " is not ", - "", "" - }; + static const char* s_cmp_strings[] = { " < ", " <= ", " == ", " != ", " > ", + " >= ", " in ", " not in ", " is ", " is not ", "", + "" }; return s_cmp_strings[op()]; } - /* ASTKeyword */ const char* ASTKeyword::word_str() const { - static const char* s_word_strings[] = { - "pass", "break", "continue" - }; + static const char* s_word_strings[] = { "pass", "break", "continue" }; return s_word_strings[key()]; } - /* ASTBlock */ void ASTBlock::removeLast() { @@ -199,9 +188,7 @@ void ASTBlock::removeFirst() const char* ASTBlock::type_str() const { - static const char* s_type_strings[] = { - "", "if", "else", "elif", "try", "CONTAINER", "except", - "finally", "while", "for", "with", "async for" - }; + static const char* s_type_strings[] = { "", "if", "else", "elif", "try", + "CONTAINER", "except", "finally", "while", "for", "with", "async for" }; return s_type_strings[blktype()]; } diff --git a/ASTNode.h b/ASTNode.h index 98760dbf5..b40bba7e7 100644 --- a/ASTNode.h +++ b/ASTNode.h @@ -1,23 +1,50 @@ -#ifndef _PYC_ASTNODE_H -#define _PYC_ASTNODE_H +#ifndef PYC_ASTNODE_H +#define PYC_ASTNODE_H #include "pyc_module.h" -#include #include +#include /* Similar interface to PycObject, so PycRef can work on it... * * However, this does *NOT* mean the two are interchangeable! */ class ASTNode { public: enum Type { - NODE_INVALID, NODE_NODELIST, NODE_OBJECT, NODE_UNARY, NODE_BINARY, - NODE_COMPARE, NODE_SLICE, NODE_STORE, NODE_RETURN, NODE_NAME, - NODE_DELETE, NODE_FUNCTION, NODE_CLASS, NODE_CALL, NODE_IMPORT, - NODE_TUPLE, NODE_LIST, NODE_SET, NODE_MAP, NODE_SUBSCR, NODE_PRINT, - NODE_CONVERT, NODE_KEYWORD, NODE_RAISE, NODE_EXEC, NODE_BLOCK, - NODE_COMPREHENSION, NODE_LOADBUILDCLASS, NODE_AWAITABLE, - NODE_FORMATTEDVALUE, NODE_JOINEDSTR, NODE_CONST_MAP, - NODE_ANNOTATED_VAR, NODE_CHAINSTORE, NODE_TERNARY, + NODE_INVALID, + NODE_NODELIST, + NODE_OBJECT, + NODE_UNARY, + NODE_BINARY, + NODE_COMPARE, + NODE_SLICE, + NODE_STORE, + NODE_RETURN, + NODE_NAME, + NODE_DELETE, + NODE_FUNCTION, + NODE_CLASS, + NODE_CALL, + NODE_IMPORT, + NODE_TUPLE, + NODE_LIST, + NODE_SET, + NODE_MAP, + NODE_SUBSCR, + NODE_PRINT, + NODE_CONVERT, + NODE_KEYWORD, + NODE_RAISE, + NODE_EXEC, + NODE_BLOCK, + NODE_COMPREHENSION, + NODE_LOADBUILDCLASS, + NODE_AWAITABLE, + NODE_FORMATTEDVALUE, + NODE_JOINEDSTR, + NODE_CONST_MAP, + NODE_ANNOTATED_VAR, + NODE_CHAINSTORE, + NODE_TERNARY, NODE_KW_NAMES_MAP, // Empty node types @@ -38,18 +65,18 @@ class ASTNode { bool m_processed; // Hack to make clang happy :( - static int internalGetType(const ASTNode *node) + static int internalGetType(const ASTNode* node) { return node ? node->m_type : NODE_INVALID; } - static void internalAddRef(ASTNode *node) + static void internalAddRef(ASTNode* node) { if (node) ++node->m_refs; } - static void internalDelRef(ASTNode *node) + static void internalDelRef(ASTNode* node) { if (node && --node->m_refs == 0) delete node; @@ -60,13 +87,14 @@ class ASTNode { void delRef() { internalDelRef(this); } }; - class ASTNodeList : public ASTNode { public: typedef std::list> list_t; - ASTNodeList(list_t nodes) - : ASTNode(NODE_NODELIST), m_nodes(std::move(nodes)) { } + ASTNodeList(list_t nodes) : + ASTNode(NODE_NODELIST), m_nodes(std::move(nodes)) + { + } const list_t& nodes() const { return m_nodes; } void removeFirst(); @@ -74,30 +102,34 @@ class ASTNodeList : public ASTNode { void append(PycRef node) { m_nodes.emplace_back(std::move(node)); } protected: - ASTNodeList(list_t nodes, ASTNode::Type type) - : ASTNode(type), m_nodes(std::move(nodes)) { } + ASTNodeList(list_t nodes, ASTNode::Type type) : + ASTNode(type), m_nodes(std::move(nodes)) + { + } private: list_t m_nodes; }; - class ASTChainStore : public ASTNodeList { public: - ASTChainStore(list_t nodes, PycRef src) - : ASTNodeList(nodes, NODE_CHAINSTORE), m_src(std::move(src)) { } - + ASTChainStore(list_t nodes, PycRef src) : + ASTNodeList(nodes, NODE_CHAINSTORE), m_src(std::move(src)) + { + } + PycRef src() const { return m_src; } private: PycRef m_src; }; - class ASTObject : public ASTNode { public: - ASTObject(PycRef obj) - : ASTNode(NODE_OBJECT), m_obj(std::move(obj)) { } + ASTObject(PycRef obj) : + ASTNode(NODE_OBJECT), m_obj(std::move(obj)) + { + } PycRef object() const { return m_obj; } @@ -105,15 +137,14 @@ class ASTObject : public ASTNode { PycRef m_obj; }; - class ASTUnary : public ASTNode { public: - enum UnOp { - UN_POSITIVE, UN_NEGATIVE, UN_INVERT, UN_NOT - }; + enum UnOp { UN_POSITIVE, UN_NEGATIVE, UN_INVERT, UN_NOT }; - ASTUnary(PycRef operand, int op) - : ASTNode(NODE_UNARY), m_op(op), m_operand(std::move(operand)) { } + ASTUnary(PycRef operand, int op) : + ASTNode(NODE_UNARY), m_op(op), m_operand(std::move(operand)) + { + } PycRef operand() const { return m_operand; } int op() const { return m_op; } @@ -126,24 +157,49 @@ class ASTUnary : public ASTNode { PycRef m_operand; }; - class ASTBinary : public ASTNode { public: enum BinOp { - BIN_ATTR, BIN_POWER, BIN_MULTIPLY, BIN_DIVIDE, BIN_FLOOR_DIVIDE, - BIN_MODULO, BIN_ADD, BIN_SUBTRACT, BIN_LSHIFT, BIN_RSHIFT, BIN_AND, - BIN_XOR, BIN_OR, BIN_LOG_AND, BIN_LOG_OR, BIN_MAT_MULTIPLY, + BIN_ATTR, + BIN_POWER, + BIN_MULTIPLY, + BIN_DIVIDE, + BIN_FLOOR_DIVIDE, + BIN_MODULO, + BIN_ADD, + BIN_SUBTRACT, + BIN_LSHIFT, + BIN_RSHIFT, + BIN_AND, + BIN_XOR, + BIN_OR, + BIN_LOG_AND, + BIN_LOG_OR, + BIN_MAT_MULTIPLY, /* Inplace operations */ - BIN_IP_ADD, BIN_IP_SUBTRACT, BIN_IP_MULTIPLY, BIN_IP_DIVIDE, - BIN_IP_MODULO, BIN_IP_POWER, BIN_IP_LSHIFT, BIN_IP_RSHIFT, BIN_IP_AND, - BIN_IP_XOR, BIN_IP_OR, BIN_IP_FLOOR_DIVIDE, BIN_IP_MAT_MULTIPLY, + BIN_IP_ADD, + BIN_IP_SUBTRACT, + BIN_IP_MULTIPLY, + BIN_IP_DIVIDE, + BIN_IP_MODULO, + BIN_IP_POWER, + BIN_IP_LSHIFT, + BIN_IP_RSHIFT, + BIN_IP_AND, + BIN_IP_XOR, + BIN_IP_OR, + BIN_IP_FLOOR_DIVIDE, + BIN_IP_MAT_MULTIPLY, /* Error Case */ BIN_INVALID }; ASTBinary(PycRef left, PycRef right, int op, - int type = NODE_BINARY) - : ASTNode(type), m_op(op), m_left(std::move(left)), m_right(std::move(right)) { } + int type = NODE_BINARY) : + ASTNode(type), m_op(op), m_left(std::move(left)), + m_right(std::move(right)) + { + } PycRef left() const { return m_left; } PycRef right() const { return m_right; } @@ -162,37 +218,47 @@ class ASTBinary : public ASTNode { PycRef m_right; }; - class ASTCompare : public ASTBinary { public: enum CompareOp { - CMP_LESS, CMP_LESS_EQUAL, CMP_EQUAL, CMP_NOT_EQUAL, CMP_GREATER, - CMP_GREATER_EQUAL, CMP_IN, CMP_NOT_IN, CMP_IS, CMP_IS_NOT, - CMP_EXCEPTION, CMP_BAD + CMP_LESS, + CMP_LESS_EQUAL, + CMP_EQUAL, + CMP_NOT_EQUAL, + CMP_GREATER, + CMP_GREATER_EQUAL, + CMP_IN, + CMP_NOT_IN, + CMP_IS, + CMP_IS_NOT, + CMP_EXCEPTION, + CMP_BAD }; - ASTCompare(PycRef left, PycRef right, int op) - : ASTBinary(std::move(left), std::move(right), op, NODE_COMPARE) { } + ASTCompare(PycRef left, PycRef right, int op) : + ASTBinary(std::move(left), std::move(right), op, NODE_COMPARE) + { + } const char* op_str() const override; }; - class ASTSlice : public ASTBinary { public: - enum SliceOp { - SLICE0, SLICE1, SLICE2, SLICE3 - }; + enum SliceOp { SLICE0, SLICE1, SLICE2, SLICE3 }; - ASTSlice(int op, PycRef left = {}, PycRef right = {}) - : ASTBinary(std::move(left), std::move(right), op, NODE_SLICE) { } + ASTSlice(int op, PycRef left = {}, PycRef right = {}) : + ASTBinary(std::move(left), std::move(right), op, NODE_SLICE) + { + } }; - class ASTStore : public ASTNode { public: - ASTStore(PycRef src, PycRef dest) - : ASTNode(NODE_STORE), m_src(std::move(src)), m_dest(std::move(dest)) { } + ASTStore(PycRef src, PycRef dest) : + ASTNode(NODE_STORE), m_src(std::move(src)), m_dest(std::move(dest)) + { + } PycRef src() const { return m_src; } PycRef dest() const { return m_dest; } @@ -202,15 +268,14 @@ class ASTStore : public ASTNode { PycRef m_dest; }; - class ASTReturn : public ASTNode { public: - enum RetType { - RETURN, YIELD, YIELD_FROM - }; + enum RetType { RETURN, YIELD, YIELD_FROM }; - ASTReturn(PycRef value, RetType rettype = RETURN) - : ASTNode(NODE_RETURN), m_value(std::move(value)), m_rettype(rettype) { } + ASTReturn(PycRef value, RetType rettype = RETURN) : + ASTNode(NODE_RETURN), m_value(std::move(value)), m_rettype(rettype) + { + } PycRef value() const { return m_value; } RetType rettype() const { return m_rettype; } @@ -220,11 +285,12 @@ class ASTReturn : public ASTNode { RetType m_rettype; }; - class ASTName : public ASTNode { public: - ASTName(PycRef name) - : ASTNode(NODE_NAME), m_name(std::move(name)) { } + ASTName(PycRef name) : + ASTNode(NODE_NAME), m_name(std::move(name)) + { + } PycRef name() const { return m_name; } @@ -232,11 +298,12 @@ class ASTName : public ASTNode { PycRef m_name; }; - class ASTDelete : public ASTNode { public: - ASTDelete(PycRef value) - : ASTNode(NODE_DELETE), m_value(std::move(value)) { } + ASTDelete(PycRef value) : + ASTNode(NODE_DELETE), m_value(std::move(value)) + { + } PycRef value() const { return m_value; } @@ -244,14 +311,15 @@ class ASTDelete : public ASTNode { PycRef m_value; }; - class ASTFunction : public ASTNode { public: typedef std::list> defarg_t; - ASTFunction(PycRef code, defarg_t defArgs, defarg_t kwDefArgs) - : ASTNode(NODE_FUNCTION), m_code(std::move(code)), - m_defargs(std::move(defArgs)), m_kwdefargs(std::move(kwDefArgs)) { } + ASTFunction(PycRef code, defarg_t defArgs, defarg_t kwDefArgs) : + ASTNode(NODE_FUNCTION), m_code(std::move(code)), + m_defargs(std::move(defArgs)), m_kwdefargs(std::move(kwDefArgs)) + { + } PycRef code() const { return m_code; } const defarg_t& defargs() const { return m_defargs; } @@ -263,12 +331,14 @@ class ASTFunction : public ASTNode { defarg_t m_kwdefargs; }; - class ASTClass : public ASTNode { public: - ASTClass(PycRef code, PycRef bases, PycRef name) - : ASTNode(NODE_CLASS), m_code(std::move(code)), m_bases(std::move(bases)), - m_name(std::move(name)) { } + ASTClass( + PycRef code, PycRef bases, PycRef name) : + ASTNode(NODE_CLASS), m_code(std::move(code)), m_bases(std::move(bases)), + m_name(std::move(name)) + { + } PycRef code() const { return m_code; } PycRef bases() const { return m_bases; } @@ -280,15 +350,16 @@ class ASTClass : public ASTNode { PycRef m_name; }; - class ASTCall : public ASTNode { public: typedef std::list> pparam_t; typedef std::list, PycRef>> kwparam_t; - ASTCall(PycRef func, pparam_t pparams, kwparam_t kwparams) - : ASTNode(NODE_CALL), m_func(std::move(func)), m_pparams(std::move(pparams)), - m_kwparams(std::move(kwparams)) { } + ASTCall(PycRef func, pparam_t pparams, kwparam_t kwparams) : + ASTNode(NODE_CALL), m_func(std::move(func)), + m_pparams(std::move(pparams)), m_kwparams(std::move(kwparams)) + { + } PycRef func() const { return m_func; } const pparam_t& pparams() const { return m_pparams; } @@ -310,17 +381,22 @@ class ASTCall : public ASTNode { PycRef m_kw; }; - class ASTImport : public ASTNode { public: typedef std::list> list_t; - ASTImport(PycRef name, PycRef fromlist) - : ASTNode(NODE_IMPORT), m_name(std::move(name)), m_fromlist(std::move(fromlist)) { } + ASTImport(PycRef name, PycRef fromlist) : + ASTNode(NODE_IMPORT), m_name(std::move(name)), + m_fromlist(std::move(fromlist)) + { + } PycRef name() const { return m_name; } list_t stores() const { return m_stores; } - void add_store(PycRef store) { m_stores.emplace_back(std::move(store)); } + void add_store(PycRef store) + { + m_stores.emplace_back(std::move(store)); + } PycRef fromlist() const { return m_fromlist; } @@ -331,14 +407,14 @@ class ASTImport : public ASTNode { PycRef m_fromlist; }; - class ASTTuple : public ASTNode { public: typedef std::vector> value_t; - ASTTuple(value_t values) - : ASTNode(NODE_TUPLE), m_values(std::move(values)), - m_requireParens(true) { } + ASTTuple(value_t values) : + ASTNode(NODE_TUPLE), m_values(std::move(values)), m_requireParens(true) + { + } const value_t& values() const { return m_values; } void add(PycRef name) { m_values.emplace_back(std::move(name)); } @@ -351,13 +427,12 @@ class ASTTuple : public ASTNode { bool m_requireParens; }; - class ASTList : public ASTNode { public: typedef std::list> value_t; - ASTList(value_t values) - : ASTNode(NODE_LIST), m_values(std::move(values)) { } + ASTList(value_t values) : + ASTNode(NODE_LIST), m_values(std::move(values)) { } const value_t& values() const { return m_values; } @@ -369,8 +444,7 @@ class ASTSet : public ASTNode { public: typedef std::deque> value_t; - ASTSet(value_t values) - : ASTNode(NODE_SET), m_values(std::move(values)) { } + ASTSet(value_t values) : ASTNode(NODE_SET), m_values(std::move(values)) { } const value_t& values() const { return m_values; } @@ -416,8 +490,11 @@ class ASTConstMap : public ASTNode { public: typedef std::vector> values_t; - ASTConstMap(PycRef keys, const values_t& values) - : ASTNode(NODE_CONST_MAP), m_keys(std::move(keys)), m_values(std::move(values)) { } + ASTConstMap(PycRef keys, const values_t& values) : + ASTNode(NODE_CONST_MAP), m_keys(std::move(keys)), + m_values(std::move(values)) + { + } const PycRef& keys() const { return m_keys; } const values_t& values() const { return m_values; } @@ -427,11 +504,12 @@ class ASTConstMap : public ASTNode { values_t m_values; }; - class ASTSubscr : public ASTNode { public: - ASTSubscr(PycRef name, PycRef key) - : ASTNode(NODE_SUBSCR), m_name(std::move(name)), m_key(std::move(key)) { } + ASTSubscr(PycRef name, PycRef key) : + ASTNode(NODE_SUBSCR), m_name(std::move(name)), m_key(std::move(key)) + { + } PycRef name() const { return m_name; } PycRef key() const { return m_key; } @@ -441,13 +519,12 @@ class ASTSubscr : public ASTNode { PycRef m_key; }; - class ASTPrint : public ASTNode { public: typedef std::list> values_t; - ASTPrint(PycRef value, PycRef stream = {}) - : ASTNode(NODE_PRINT), m_stream(std::move(stream)), m_eol() + ASTPrint(PycRef value, PycRef stream = {}) : + ASTNode(NODE_PRINT), m_stream(std::move(stream)), m_eol() { if (value != nullptr) m_values.emplace_back(std::move(value)); @@ -468,11 +545,12 @@ class ASTPrint : public ASTNode { bool m_eol; }; - class ASTConvert : public ASTNode { public: - ASTConvert(PycRef name) - : ASTNode(NODE_CONVERT), m_name(std::move(name)) { } + ASTConvert(PycRef name) : + ASTNode(NODE_CONVERT), m_name(std::move(name)) + { + } PycRef name() const { return m_name; } @@ -480,12 +558,9 @@ class ASTConvert : public ASTNode { PycRef m_name; }; - class ASTKeyword : public ASTNode { public: - enum Word { - KW_PASS, KW_BREAK, KW_CONTINUE - }; + enum Word { KW_PASS, KW_BREAK, KW_CONTINUE }; ASTKeyword(Word key) : ASTNode(NODE_KEYWORD), m_key(key) { } @@ -496,12 +571,13 @@ class ASTKeyword : public ASTNode { Word m_key; }; - class ASTRaise : public ASTNode { public: typedef std::list> param_t; - ASTRaise(param_t params) : ASTNode(NODE_RAISE), m_params(std::move(params)) { } + ASTRaise(param_t params) : ASTNode(NODE_RAISE), m_params(std::move(params)) + { + } const param_t& params() const { return m_params; } @@ -509,12 +585,13 @@ class ASTRaise : public ASTNode { param_t m_params; }; - class ASTExec : public ASTNode { public: - ASTExec(PycRef stmt, PycRef glob, PycRef loc) - : ASTNode(NODE_EXEC), m_stmt(std::move(stmt)), m_glob(std::move(glob)), - m_loc(std::move(loc)) { } + ASTExec(PycRef stmt, PycRef glob, PycRef loc) : + ASTNode(NODE_EXEC), m_stmt(std::move(stmt)), m_glob(std::move(glob)), + m_loc(std::move(loc)) + { + } PycRef statement() const { return m_stmt; } PycRef globals() const { return m_glob; } @@ -526,19 +603,29 @@ class ASTExec : public ASTNode { PycRef m_loc; }; - class ASTBlock : public ASTNode { public: typedef std::list> list_t; enum BlkType { - BLK_MAIN, BLK_IF, BLK_ELSE, BLK_ELIF, BLK_TRY, - BLK_CONTAINER, BLK_EXCEPT, BLK_FINALLY, - BLK_WHILE, BLK_FOR, BLK_WITH, BLK_ASYNCFOR + BLK_MAIN, + BLK_IF, + BLK_ELSE, + BLK_ELIF, + BLK_TRY, + BLK_CONTAINER, + BLK_EXCEPT, + BLK_FINALLY, + BLK_WHILE, + BLK_FOR, + BLK_WITH, + BLK_ASYNCFOR }; - ASTBlock(BlkType blktype, int end = 0, int inited = 0) - : ASTNode(NODE_BLOCK), m_blktype(blktype), m_end(end), m_inited(inited) { } + ASTBlock(BlkType blktype, int end = 0, int inited = 0) : + ASTNode(NODE_BLOCK), m_blktype(blktype), m_end(end), m_inited(inited) + { + } BlkType blktype() const { return m_blktype; } int end() const { return m_end; } @@ -564,16 +651,15 @@ class ASTBlock : public ASTNode { int m_inited; /* Is the block's definition "complete" */ }; - class ASTCondBlock : public ASTBlock { public: - enum InitCond { - UNINITED, POPPED, PRE_POPPED - }; + enum InitCond { UNINITED, POPPED, PRE_POPPED }; ASTCondBlock(ASTBlock::BlkType blktype, int end, PycRef cond, - bool negative = false) - : ASTBlock(blktype, end), m_cond(std::move(cond)), m_negative(negative) { } + bool negative = false) : + ASTBlock(blktype, end), m_cond(std::move(cond)), m_negative(negative) + { + } PycRef cond() const { return m_cond; } bool negative() const { return m_negative; } @@ -583,11 +669,14 @@ class ASTCondBlock : public ASTBlock { bool m_negative; }; - class ASTIterBlock : public ASTBlock { public: - ASTIterBlock(ASTBlock::BlkType blktype, int start, int end, PycRef iter) - : ASTBlock(blktype, end), m_iter(std::move(iter)), m_idx(), m_comp(), m_start(start) { } + ASTIterBlock( + ASTBlock::BlkType blktype, int start, int end, PycRef iter) : + ASTBlock(blktype, end), m_iter(std::move(iter)), m_idx(), m_comp(), + m_start(start) + { + } PycRef iter() const { return m_iter; } PycRef index() const { return m_idx; } @@ -595,7 +684,11 @@ class ASTIterBlock : public ASTBlock { bool isComprehension() const { return m_comp; } int start() const { return m_start; } - void setIndex(PycRef idx) { m_idx = std::move(idx); init(); } + void setIndex(PycRef idx) + { + m_idx = std::move(idx); + init(); + } void setCondition(PycRef cond) { m_cond = std::move(cond); } void setComprehension(bool comp) { m_comp = comp; } @@ -609,8 +702,11 @@ class ASTIterBlock : public ASTBlock { class ASTContainerBlock : public ASTBlock { public: - ASTContainerBlock(int finally, int except = 0) - : ASTBlock(ASTBlock::BLK_CONTAINER, 0), m_finally(finally), m_except(except) { } + ASTContainerBlock(int finally, int except = 0) : + ASTBlock(ASTBlock::BLK_CONTAINER, 0), m_finally(finally), + m_except(except) + { + } bool hasFinally() const { return m_finally != 0; } bool hasExcept() const { return m_except != 0; } @@ -626,13 +722,16 @@ class ASTContainerBlock : public ASTBlock { class ASTWithBlock : public ASTBlock { public: - ASTWithBlock(int end) - : ASTBlock(ASTBlock::BLK_WITH, end) { } + ASTWithBlock(int end) : ASTBlock(ASTBlock::BLK_WITH, end) { } PycRef expr() const { return m_expr; } PycRef var() const { return m_var; } - void setExpr(PycRef expr) { m_expr = std::move(expr); init(); } + void setExpr(PycRef expr) + { + m_expr = std::move(expr); + init(); + } void setVar(PycRef var) { m_var = std::move(var); } private: @@ -644,26 +743,30 @@ class ASTComprehension : public ASTNode { public: typedef std::list> generator_t; - ASTComprehension(PycRef result) - : ASTNode(NODE_COMPREHENSION), m_result(std::move(result)) { } + ASTComprehension(PycRef result) : + ASTNode(NODE_COMPREHENSION), m_result(std::move(result)) + { + } PycRef result() const { return m_result; } generator_t generators() const { return m_generators; } - void addGenerator(PycRef gen) { + void addGenerator(PycRef gen) + { m_generators.emplace_front(std::move(gen)); } private: PycRef m_result; generator_t m_generators; - }; class ASTLoadBuildClass : public ASTNode { public: - ASTLoadBuildClass(PycRef obj) - : ASTNode(NODE_LOADBUILDCLASS), m_obj(std::move(obj)) { } + ASTLoadBuildClass(PycRef obj) : + ASTNode(NODE_LOADBUILDCLASS), m_obj(std::move(obj)) + { + } PycRef object() const { return m_obj; } @@ -673,8 +776,10 @@ class ASTLoadBuildClass : public ASTNode { class ASTAwaitable : public ASTNode { public: - ASTAwaitable(PycRef expr) - : ASTNode(NODE_AWAITABLE), m_expr(std::move(expr)) { } + ASTAwaitable(PycRef expr) : + ASTNode(NODE_AWAITABLE), m_expr(std::move(expr)) + { + } PycRef expression() const { return m_expr; } @@ -695,12 +800,11 @@ class ASTFormattedValue : public ASTNode { }; ASTFormattedValue(PycRef val, ConversionFlag conversion, - PycRef format_spec) - : ASTNode(NODE_FORMATTEDVALUE), - m_val(std::move(val)), - m_conversion(conversion), - m_format_spec(std::move(format_spec)) - { } + PycRef format_spec) : + ASTNode(NODE_FORMATTEDVALUE), m_val(std::move(val)), + m_conversion(conversion), m_format_spec(std::move(format_spec)) + { + } PycRef val() const { return m_val; } ConversionFlag conversion() const { return m_conversion; } @@ -717,8 +821,10 @@ class ASTJoinedStr : public ASTNode { public: typedef std::list> value_t; - ASTJoinedStr(value_t values) - : ASTNode(NODE_JOINEDSTR), m_values(std::move(values)) { } + ASTJoinedStr(value_t values) : + ASTNode(NODE_JOINEDSTR), m_values(std::move(values)) + { + } const value_t& values() const { return m_values; } @@ -728,8 +834,11 @@ class ASTJoinedStr : public ASTNode { class ASTAnnotatedVar : public ASTNode { public: - ASTAnnotatedVar(PycRef name, PycRef type) - : ASTNode(NODE_ANNOTATED_VAR), m_name(std::move(name)), m_type(std::move(type)) { } + ASTAnnotatedVar(PycRef name, PycRef type) : + ASTNode(NODE_ANNOTATED_VAR), m_name(std::move(name)), + m_type(std::move(type)) + { + } PycRef name() const noexcept { return m_name; } PycRef annotation() const noexcept { return m_type; } @@ -739,13 +848,14 @@ class ASTAnnotatedVar : public ASTNode { PycRef m_type; }; -class ASTTernary : public ASTNode -{ +class ASTTernary : public ASTNode { public: ASTTernary(PycRef if_block, PycRef if_expr, - PycRef else_expr) - : ASTNode(NODE_TERNARY), m_if_block(std::move(if_block)), - m_if_expr(std::move(if_expr)), m_else_expr(std::move(else_expr)) { } + PycRef else_expr) : + ASTNode(NODE_TERNARY), m_if_block(std::move(if_block)), + m_if_expr(std::move(if_expr)), m_else_expr(std::move(else_expr)) + { + } PycRef if_block() const noexcept { return m_if_block; } PycRef if_expr() const noexcept { return m_if_expr; } diff --git a/ASTree.cpp b/ASTree.cpp index 6635808e1..64a8ec693 100644 --- a/ASTree.cpp +++ b/ASTree.cpp @@ -1,11 +1,11 @@ -#include -#include -#include -#include #include "ASTree.h" #include "FastStack.h" -#include "pyc_numeric.h" #include "bytecode.h" +#include "pyc_numeric.h" +#include +#include +#include +#include // This must be a triple quote (''' or """), to handle interpolated string literals containing the opposite quote style. // E.g. f'''{"interpolated "123' literal"}''' -> valid. @@ -16,7 +16,7 @@ #define F_STRING_QUOTE "'''" static void append_to_chain_store(const PycRef& chainStore, - PycRef item, FastStack& stack, const PycRef& curblock); + PycRef item, FastStack& stack, const PycRef& curblock); /* Use this to determine if an error occurred (and therefore, if we should * avoid cleaning the output tree) */ @@ -70,7 +70,8 @@ static void CheckIfExpr(FastStack& stack, PycRef curblock) auto if_block = curblock->nodes().back(); auto if_expr = StackPopTop(stack); curblock->removeLast(); - stack.push(new ASTTernary(std::move(if_block), std::move(if_expr), std::move(else_expr))); + stack.push(new ASTTernary( + std::move(if_block), std::move(if_expr), std::move(else_expr))); } PycRef BuildFromCode(PycRef code, PycModule* mod) @@ -80,7 +81,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) FastStack stack((mod->majorVer() == 1) ? 20 : code->stackSize()); stackhist_t stack_hist; - std::stack > blocks; + std::stack> blocks; PycRef defblock = new ASTBlock(ASTBlock::BLK_MAIN); defblock->init(); PycRef curblock = defblock; @@ -116,25 +117,23 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) /* Store the current stack for the except/finally statement(s) */ stack_hist.push(stack); - PycRef tryblock = new ASTBlock(ASTBlock::BLK_TRY, curblock->end(), true); + PycRef tryblock = + new ASTBlock(ASTBlock::BLK_TRY, curblock->end(), true); blocks.push(tryblock); curblock = blocks.top(); - } else if (else_pop - && opcode != Pyc::JUMP_FORWARD_A - && opcode != Pyc::JUMP_IF_FALSE_A - && opcode != Pyc::JUMP_IF_FALSE_OR_POP_A - && opcode != Pyc::POP_JUMP_IF_FALSE_A - && opcode != Pyc::POP_JUMP_FORWARD_IF_FALSE_A - && opcode != Pyc::JUMP_IF_TRUE_A - && opcode != Pyc::JUMP_IF_TRUE_OR_POP_A - && opcode != Pyc::POP_JUMP_IF_TRUE_A - && opcode != Pyc::POP_JUMP_FORWARD_IF_TRUE_A - && opcode != Pyc::POP_BLOCK) { - else_pop = false; - + } + else if (else_pop && opcode != Pyc::JUMP_FORWARD_A && + opcode != Pyc::JUMP_IF_FALSE_A && + opcode != Pyc::JUMP_IF_FALSE_OR_POP_A && + opcode != Pyc::POP_JUMP_IF_FALSE_A && + opcode != Pyc::POP_JUMP_FORWARD_IF_FALSE_A && + opcode != Pyc::JUMP_IF_TRUE_A && + opcode != Pyc::JUMP_IF_TRUE_OR_POP_A && + opcode != Pyc::POP_JUMP_IF_TRUE_A && + opcode != Pyc::POP_JUMP_FORWARD_IF_TRUE_A && + opcode != Pyc::POP_BLOCK) { PycRef prev = curblock; - while (prev->end() < pos - && prev->blktype() != ASTBlock::BLK_MAIN) { + while (prev->end() < pos && prev->blktype() != ASTBlock::BLK_MAIN) { if (prev->blktype() != ASTBlock::BLK_CONTAINER) { if (prev->end() == 0) { break; @@ -142,7 +141,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) /* We want to keep the stack the same, but we need to pop * a level off the history. */ - //stack = stack_hist.top(); + // stack = stack_hist.top(); if (!stack_hist.empty()) stack_hist.pop(); } @@ -165,7 +164,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { ASTBinary::BinOp op = ASTBinary::from_binary_op(operand); if (op == ASTBinary::BIN_INVALID) - fprintf(stderr, "Unsupported `BINARY_OP` operand value: %d\n", operand); + fprintf(stderr, + "Unsupported `BINARY_OP` operand value: %d\n", operand); PycRef right = stack.top(); stack.pop(); PycRef left = stack.top(); @@ -204,7 +204,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { ASTBinary::BinOp op = ASTBinary::from_opcode(opcode); if (op == ASTBinary::BIN_INVALID) - throw std::runtime_error("Unhandled opcode from ASTBinary::from_opcode"); + throw std::runtime_error( + "Unhandled opcode from ASTBinary::from_opcode"); PycRef right = stack.top(); stack.pop(); PycRef left = stack.top(); @@ -245,7 +246,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::BUILD_LIST_A: { ASTList::value_t values; - for (int i=0; i BuildFromCode(PycRef code, PycModule* mod) case Pyc::BUILD_SET_A: { ASTSet::value_t values; - for (int i=0; i BuildFromCode(PycRef code, PycModule* mod) case Pyc::BUILD_MAP_A: if (mod->verCompare(3, 5) >= 0) { auto map = new ASTMap; - for (int i=0; i value = stack.top(); stack.pop(); PycRef key = stack.top(); @@ -273,7 +274,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) map->add(key, value); } stack.push(map); - } else { + } + else { if (stack.top().type() == ASTNode::NODE_CHAINSTORE) { stack.pop(); } @@ -316,26 +318,30 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef start = stack.top(); stack.pop(); - if (start.type() == ASTNode::NODE_OBJECT - && start.cast()->object() == Pyc_None) { + if (start.type() == ASTNode::NODE_OBJECT && + start.cast()->object() == Pyc_None) { start = NULL; } - if (end.type() == ASTNode::NODE_OBJECT - && end.cast()->object() == Pyc_None) { + if (end.type() == ASTNode::NODE_OBJECT && + end.cast()->object() == Pyc_None) { end = NULL; } if (start == NULL && end == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE0)); - } else if (start == NULL) { + } + else if (start == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE2, start, end)); - } else if (end == NULL) { + } + else if (end == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE1, start, end)); - } else { + } + else { stack.push(new ASTSlice(ASTSlice::SLICE3, start, end)); } - } else if (operand == 3) { + } + else if (operand == 3) { PycRef step = stack.top(); stack.pop(); PycRef end = stack.top(); @@ -343,18 +349,18 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef start = stack.top(); stack.pop(); - if (start.type() == ASTNode::NODE_OBJECT - && start.cast()->object() == Pyc_None) { + if (start.type() == ASTNode::NODE_OBJECT && + start.cast()->object() == Pyc_None) { start = NULL; } - if (end.type() == ASTNode::NODE_OBJECT - && end.cast()->object() == Pyc_None) { + if (end.type() == ASTNode::NODE_OBJECT && + end.cast()->object() == Pyc_None) { end = NULL; } - if (step.type() == ASTNode::NODE_OBJECT - && step.cast()->object() == Pyc_None) { + if (step.type() == ASTNode::NODE_OBJECT && + step.cast()->object() == Pyc_None) { step = NULL; } @@ -363,11 +369,14 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (start == NULL && end == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE0)); - } else if (start == NULL) { + } + else if (start == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE2, start, end)); - } else if (end == NULL) { + } + else if (end == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE1, start, end)); - } else { + } + else { stack.push(new ASTSlice(ASTSlice::SLICE3, start, end)); } @@ -376,7 +385,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (step == NULL) { stack.push(new ASTSlice(ASTSlice::SLICE1, lhs, step)); - } else { + } + else { stack.push(new ASTSlice(ASTSlice::SLICE3, lhs, step)); } } @@ -403,8 +413,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) ASTTuple::value_t values; values.resize(operand); - for (int i=0; i BuildFromCode(PycRef code, PycModule* mod) int kwparams = code->getConst(operand).cast()->size(); ASTKwNamesMap kwparamList; - std::vector> keys = code->getConst(operand).cast()->values(); + std::vector> keys = + code->getConst(operand).cast()->values(); for (int i = 0; i < kwparams; i++) { - kwparamList.add(new ASTObject(keys[kwparams - i - 1]), stack.top()); + kwparamList.add( + new ASTObject(keys[kwparams - i - 1]), stack.top()); stack.pop(); } stack.push(new ASTKwNamesMap(kwparamList)); @@ -440,7 +452,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef TOS = stack.top(); int TOS_type = TOS.type(); // bases are NODE_NAME and NODE_BINARY at TOS - while (TOS_type == ASTNode::NODE_NAME || TOS_type == ASTNode::NODE_BINARY) { + while (TOS_type == ASTNode::NODE_NAME || + TOS_type == ASTNode::NODE_BINARY) { bases.resize(basecnt + 1); bases[basecnt] = TOS; basecnt++; @@ -457,13 +470,13 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); int loadbuild_type = loadbuild.type(); if (loadbuild_type == ASTNode::NODE_LOADBUILDCLASS) { - PycRef call = new ASTCall(function, pparamList, kwparamList); + PycRef call = + new ASTCall(function, pparamList, kwparamList); stack.push(new ASTClass(call, new ASTTuple(bases), name)); stack_hist.pop(); break; } - else - { + else { stack = stack_hist.top(); stack_hist.pop(); } @@ -478,9 +491,13 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef object_or_map = stack.top(); if (object_or_map.type() == ASTNode::NODE_KW_NAMES_MAP) { stack.pop(); - PycRef kwparams_map = object_or_map.cast(); - for (ASTKwNamesMap::map_t::const_iterator it = kwparams_map->values().begin(); it != kwparams_map->values().end(); it++) { - kwparamList.push_front(std::make_pair(it->first, it->second)); + PycRef kwparams_map = + object_or_map.cast(); + for (ASTKwNamesMap::map_t::const_iterator it = + kwparams_map->values().begin(); + it != kwparams_map->values().end(); it++) { + kwparamList.push_front( + std::make_pair(it->first, it->second)); pparams -= 1; } } @@ -494,30 +511,37 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) kwparamList.push_front(std::make_pair(key, val)); } } - for (int i=0; i param = stack.top(); stack.pop(); if (param.type() == ASTNode::NODE_FUNCTION) { - PycRef fun_code = param.cast()->code(); - PycRef code_src = fun_code.cast()->object().cast(); + PycRef fun_code = + param.cast()->code(); + PycRef code_src = fun_code.cast() + ->object() + .cast(); PycRef function_name = code_src->name(); if (function_name->isEqual("")) { pparamList.push_front(param); - } else { + } + else { // Decorator used - PycRef decor_name = new ASTName(function_name); + PycRef decor_name = + new ASTName(function_name); curblock->append(new ASTStore(param, decor_name)); pparamList.push_front(decor_name); } - } else { + } + else { pparamList.push_front(param); } } PycRef func = stack.top(); stack.pop(); - if ((opcode == Pyc::CALL_A || opcode == Pyc::INSTRUMENTED_CALL_A) && - stack.top() == nullptr) { + if ((opcode == Pyc::CALL_A || + opcode == Pyc::INSTRUMENTED_CALL_A) && + stack.top() == nullptr) { stack.pop(); } @@ -532,21 +556,22 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) int pparams = (operand & 0xFF); ASTCall::kwparam_t kwparamList; ASTCall::pparam_t pparamList; - for (int i=0; i val = stack.top(); stack.pop(); PycRef key = stack.top(); stack.pop(); kwparamList.push_front(std::make_pair(key, val)); } - for (int i=0; i func = stack.top(); stack.pop(); - PycRef call = new ASTCall(func, pparamList, kwparamList); + PycRef call = + new ASTCall(func, pparamList, kwparamList); call.cast()->setVar(var); stack.push(call); } @@ -559,21 +584,22 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) int pparams = (operand & 0xFF); ASTCall::kwparam_t kwparamList; ASTCall::pparam_t pparamList; - for (int i=0; i val = stack.top(); stack.pop(); PycRef key = stack.top(); stack.pop(); kwparamList.push_front(std::make_pair(key, val)); } - for (int i=0; i func = stack.top(); stack.pop(); - PycRef call = new ASTCall(func, pparamList, kwparamList); + PycRef call = + new ASTCall(func, pparamList, kwparamList); call.cast()->setKW(kw); stack.push(call); } @@ -588,21 +614,22 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) int pparams = (operand & 0xFF); ASTCall::kwparam_t kwparamList; ASTCall::pparam_t pparamList; - for (int i=0; i val = stack.top(); stack.pop(); PycRef key = stack.top(); stack.pop(); kwparamList.push_front(std::make_pair(key, val)); } - for (int i=0; i func = stack.top(); stack.pop(); - PycRef call = new ASTCall(func, pparamList, kwparamList); + PycRef call = + new ASTCall(func, pparamList, kwparamList); call.cast()->setKW(kw); call.cast()->setVar(var); stack.push(call); @@ -615,19 +642,25 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef param = stack.top(); stack.pop(); if (param.type() == ASTNode::NODE_FUNCTION) { - PycRef fun_code = param.cast()->code(); - PycRef code_src = fun_code.cast()->object().cast(); + PycRef fun_code = + param.cast()->code(); + PycRef code_src = fun_code.cast() + ->object() + .cast(); PycRef function_name = code_src->name(); if (function_name->isEqual("")) { pparamList.push_front(param); - } else { + } + else { // Decorator used - PycRef decor_name = new ASTName(function_name); + PycRef decor_name = + new ASTName(function_name); curblock->append(new ASTStore(param, decor_name)); pparamList.push_front(decor_name); } - } else { + } + else { pparamList.push_front(param); } } @@ -647,7 +680,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); auto arg = operand; if (mod->verCompare(3, 12) == 0) - arg >>= 4; // changed under GH-100923 + arg >>= 4; // changed under GH-100923 else if (mod->verCompare(3, 13) >= 0) arg >>= 5; stack.push(new ASTCompare(left, right, arg)); @@ -660,14 +693,16 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef left = stack.top(); stack.pop(); // The operand will be 0 for 'in' and 1 for 'not in'. - stack.push(new ASTCompare(left, right, operand ? ASTCompare::CMP_NOT_IN : ASTCompare::CMP_IN)); + stack.push(new ASTCompare(left, right, + operand ? ASTCompare::CMP_NOT_IN : ASTCompare::CMP_IN)); } break; case Pyc::DELETE_ATTR_A: { PycRef name = stack.top(); stack.pop(); - curblock->append(new ASTDelete(new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR))); + curblock->append(new ASTDelete(new ASTBinary(name, + new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR))); } break; case Pyc::DELETE_GLOBAL_A: @@ -677,8 +712,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { PycRef varname = code->getName(operand); - if (varname->length() >= 2 && varname->value()[0] == '_' - && varname->value()[1] == '[') { + if (varname->length() >= 2 && varname->value()[0] == '_' && + varname->value()[1] == '[') { /* Don't show deletes that are a result of list comps. */ break; } @@ -696,8 +731,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) else name = new ASTName(code->getLocal(operand)); - if (name.cast()->name()->value()[0] == '_' - && name.cast()->name()->value()[1] == '[') { + if (name.cast()->name()->value()[0] == '_' && + name.cast()->name()->value()[1] == '[') { /* Don't show deletes that are a result of list comps. */ break; } @@ -710,7 +745,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - curblock->append(new ASTDelete(new ASTSubscr(name, new ASTSlice(ASTSlice::SLICE0)))); + curblock->append(new ASTDelete( + new ASTSubscr(name, new ASTSlice(ASTSlice::SLICE0)))); } break; case Pyc::DELETE_SLICE_1: @@ -720,7 +756,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - curblock->append(new ASTDelete(new ASTSubscr(name, new ASTSlice(ASTSlice::SLICE1, upper)))); + curblock->append(new ASTDelete(new ASTSubscr( + name, new ASTSlice(ASTSlice::SLICE1, upper)))); } break; case Pyc::DELETE_SLICE_2: @@ -730,7 +767,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - curblock->append(new ASTDelete(new ASTSubscr(name, new ASTSlice(ASTSlice::SLICE2, NULL, lower)))); + curblock->append(new ASTDelete(new ASTSubscr( + name, new ASTSlice(ASTSlice::SLICE2, NULL, lower)))); } break; case Pyc::DELETE_SLICE_3: @@ -742,7 +780,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - curblock->append(new ASTDelete(new ASTSubscr(name, new ASTSlice(ASTSlice::SLICE3, upper, lower)))); + curblock->append(new ASTDelete(new ASTSubscr( + name, new ASTSlice(ASTSlice::SLICE3, upper, lower)))); } break; case Pyc::DELETE_SUBSCR: @@ -759,12 +798,14 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { if (stack.top().type() == PycObject::TYPE_NULL) { stack.push(stack.top()); - } else if (stack.top().type() == ASTNode::NODE_CHAINSTORE) { + } + else if (stack.top().type() == ASTNode::NODE_CHAINSTORE) { auto chainstore = stack.top(); stack.pop(); stack.push(stack.top()); stack.push(chainstore); - } else { + } + else { stack.push(stack.top()); ASTNodeList::list_t targets; stack.push(new ASTChainStore(targets, stack.top())); @@ -784,8 +825,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::DUP_TOPX_A: { - std::stack > first; - std::stack > second; + std::stack> first; + std::stack> second; for (int i = 0; i < operand; i++) { PycRef node = stack.top(); @@ -818,7 +859,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) curblock = blocks.top(); curblock->append(final.cast()); isFinally = true; - } else if (curblock->blktype() == ASTBlock::BLK_EXCEPT) { + } + else if (curblock->blktype() == ASTBlock::BLK_EXCEPT) { blocks.pop(); PycRef prev = curblock; @@ -827,21 +869,30 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) auto container = blocks.top(); blocks.pop(); auto asyncForBlock = blocks.top(); - isUninitAsyncFor = asyncForBlock->blktype() == ASTBlock::BLK_ASYNCFOR && !asyncForBlock->inited(); + isUninitAsyncFor = asyncForBlock->blktype() == + ASTBlock::BLK_ASYNCFOR && + !asyncForBlock->inited(); if (isUninitAsyncFor) { - auto tryBlock = container->nodes().front().cast(); - if (!tryBlock->nodes().empty() && tryBlock->blktype() == ASTBlock::BLK_TRY) { - auto store = tryBlock->nodes().front().try_cast(); + auto tryBlock = + container->nodes().front().cast(); + if (!tryBlock->nodes().empty() && + tryBlock->blktype() == ASTBlock::BLK_TRY) { + auto store = tryBlock->nodes() + .front() + .try_cast(); if (store) { - asyncForBlock.cast()->setIndex(store->dest()); + asyncForBlock.cast() + ->setIndex(store->dest()); } } curblock = blocks.top(); stack = stack_hist.top(); stack_hist.pop(); if (!curblock->inited()) - fprintf(stderr, "Error when decompiling 'async for'.\n"); - } else { + fprintf(stderr, + "Error when decompiling 'async for'.\n"); + } + else { blocks.push(container); } } @@ -854,8 +905,10 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) curblock = blocks.top(); /* Turn it into an else statement. */ - if (curblock->end() != pos || curblock.cast()->hasFinally()) { - PycRef elseblk = new ASTBlock(ASTBlock::BLK_ELSE, prev->end()); + if (curblock->end() != pos || + curblock.cast()->hasFinally()) { + PycRef elseblk = + new ASTBlock(ASTBlock::BLK_ELSE, prev->end()); elseblk->init(); blocks.push(elseblk); curblock = blocks.top(); @@ -869,7 +922,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (curblock->blktype() == ASTBlock::BLK_CONTAINER) { /* This marks the end of the except block(s). */ - PycRef cont = curblock.cast(); + PycRef cont = + curblock.cast(); if (!cont->hasFinally() || isFinally) { /* If there's no finally block, pop the container. */ blocks.pop(); @@ -897,7 +951,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::FOR_ITER_A: case Pyc::INSTRUMENTED_FOR_ITER_A: { - PycRef iter = stack.top(); // Iterable + PycRef iter = stack.top(); // Iterable if (mod->verCompare(3, 12) < 0) { // Do not pop the iterator for py 3.12+ stack.pop(); @@ -913,20 +967,24 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (mod->majorVer() == 3 && mod->minorVer() >= 8) { end = operand; if (mod->verCompare(3, 10) >= 0) - end *= sizeof(uint16_t); // // BPO-27129 + end *= sizeof(uint16_t); // // BPO-27129 end += pos; - comprehension = strcmp(code->name()->value(), "") == 0; - } else { + comprehension = + strcmp(code->name()->value(), "") == 0; + } + else { PycRef top = blocks.top(); - end = top->end(); // block end position from SETUP_LOOP + end = top->end(); // block end position from SETUP_LOOP if (top->blktype() == ASTBlock::BLK_WHILE) { blocks.pop(); - } else { + } + else { comprehension = true; } } - PycRef forblk = new ASTIterBlock(ASTBlock::BLK_FOR, curpos, end, iter); + PycRef forblk = + new ASTIterBlock(ASTBlock::BLK_FOR, curpos, end, iter); forblk->setComprehension(comprehension); blocks.push(forblk.cast()); curblock = blocks.top(); @@ -936,19 +994,21 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::FOR_LOOP_A: { - PycRef curidx = stack.top(); // Current index + PycRef curidx = stack.top(); // Current index stack.pop(); - PycRef iter = stack.top(); // Iterable + PycRef iter = stack.top(); // Iterable stack.pop(); bool comprehension = false; PycRef top = blocks.top(); if (top->blktype() == ASTBlock::BLK_WHILE) { blocks.pop(); - } else { + } + else { comprehension = true; } - PycRef forblk = new ASTIterBlock(ASTBlock::BLK_FOR, curpos, top->end(), iter); + PycRef forblk = new ASTIterBlock( + ASTBlock::BLK_FOR, curpos, top->end(), iter); forblk->setComprehension(comprehension); blocks.push(forblk.cast()); curblock = blocks.top(); @@ -958,24 +1018,27 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) and the current item onto the stack." */ stack.push(iter); stack.push(curidx); - stack.push(NULL); // We can totally hack this >_> + stack.push(NULL); // We can totally hack this >_> } break; case Pyc::GET_AITER: { // Logic similar to FOR_ITER_A - PycRef iter = stack.top(); // Iterable + PycRef iter = stack.top(); // Iterable stack.pop(); PycRef top = blocks.top(); if (top->blktype() == ASTBlock::BLK_WHILE) { blocks.pop(); - PycRef forblk = new ASTIterBlock(ASTBlock::BLK_ASYNCFOR, curpos, top->end(), iter); + PycRef forblk = new ASTIterBlock( + ASTBlock::BLK_ASYNCFOR, curpos, top->end(), iter); blocks.push(forblk.cast()); curblock = blocks.top(); stack.push(nullptr); - } else { - fprintf(stderr, "Unsupported use of GET_AITER outside of SETUP_LOOP\n"); + } + else { + fprintf(stderr, + "Unsupported use of GET_AITER outside of SETUP_LOOP\n"); } } break; @@ -983,7 +1046,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::FORMAT_VALUE_A: { - auto conversion_flag = static_cast(operand); + auto conversion_flag = + static_cast(operand); PycRef format_spec = nullptr; if (conversion_flag & ASTFormattedValue::HAVE_FMT_SPEC) { format_spec = stack.top(); @@ -991,7 +1055,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) } auto val = stack.top(); stack.pop(); - stack.push(new ASTFormattedValue(val, conversion_flag, format_spec)); + stack.push( + new ASTFormattedValue(val, conversion_flag, format_spec)); } break; case Pyc::GET_AWAITABLE: @@ -1007,13 +1072,16 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::IMPORT_NAME_A: if (mod->majorVer() == 1) { - stack.push(new ASTImport(new ASTName(code->getName(operand)), NULL)); - } else { + stack.push( + new ASTImport(new ASTName(code->getName(operand)), NULL)); + } + else { PycRef fromlist = stack.top(); stack.pop(); if (mod->verCompare(2, 5) >= 0) - stack.pop(); // Level -- we don't care - stack.push(new ASTImport(new ASTName(code->getName(operand)), fromlist)); + stack.pop(); // Level -- we don't care + stack.push(new ASTImport( + new ASTName(code->getName(operand)), fromlist)); } break; case Pyc::IMPORT_FROM_A: @@ -1033,7 +1101,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef left = stack.top(); stack.pop(); // The operand will be 0 for 'is' and 1 for 'is not'. - stack.push(new ASTCompare(left, right, operand ? ASTCompare::CMP_IS_NOT : ASTCompare::CMP_IS)); + stack.push(new ASTCompare(left, right, + operand ? ASTCompare::CMP_IS_NOT : ASTCompare::CMP_IS)); } break; case Pyc::JUMP_IF_FALSE_A: @@ -1051,12 +1120,12 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef ifblk; int popped = ASTCondBlock::UNINITED; - if (opcode == Pyc::POP_JUMP_IF_FALSE_A - || opcode == Pyc::POP_JUMP_IF_TRUE_A - || opcode == Pyc::POP_JUMP_FORWARD_IF_FALSE_A - || opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A - || opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_FALSE_A - || opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_TRUE_A) { + if (opcode == Pyc::POP_JUMP_IF_FALSE_A || + opcode == Pyc::POP_JUMP_IF_TRUE_A || + opcode == Pyc::POP_JUMP_FORWARD_IF_FALSE_A || + opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A || + opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_FALSE_A || + opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_TRUE_A) { /* Pop condition before the jump */ stack.pop(); popped = ASTCondBlock::PRE_POPPED; @@ -1065,52 +1134,57 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) /* Store the current stack for the else statement(s) */ stack_hist.push(stack); - if (opcode == Pyc::JUMP_IF_FALSE_OR_POP_A - || opcode == Pyc::JUMP_IF_TRUE_OR_POP_A) { + if (opcode == Pyc::JUMP_IF_FALSE_OR_POP_A || + opcode == Pyc::JUMP_IF_TRUE_OR_POP_A) { /* Pop condition only if condition is met */ stack.pop(); popped = ASTCondBlock::POPPED; } /* "Jump if true" means "Jump if not false" */ - bool neg = opcode == Pyc::JUMP_IF_TRUE_A - || opcode == Pyc::JUMP_IF_TRUE_OR_POP_A - || opcode == Pyc::POP_JUMP_IF_TRUE_A - || opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A - || opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_TRUE_A; + bool neg = opcode == Pyc::JUMP_IF_TRUE_A || + opcode == Pyc::JUMP_IF_TRUE_OR_POP_A || + opcode == Pyc::POP_JUMP_IF_TRUE_A || + opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A || + opcode == Pyc::INSTRUMENTED_POP_JUMP_IF_TRUE_A; int offs = operand; if (mod->verCompare(3, 10) >= 0) - offs *= sizeof(uint16_t); // // BPO-27129 - if (mod->verCompare(3, 12) >= 0 - || opcode == Pyc::JUMP_IF_FALSE_A - || opcode == Pyc::JUMP_IF_TRUE_A - || opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A - || opcode == Pyc::POP_JUMP_FORWARD_IF_FALSE_A) { + offs *= sizeof(uint16_t); // // BPO-27129 + if (mod->verCompare(3, 12) >= 0 || + opcode == Pyc::JUMP_IF_FALSE_A || + opcode == Pyc::JUMP_IF_TRUE_A || + opcode == Pyc::POP_JUMP_FORWARD_IF_TRUE_A || + opcode == Pyc::POP_JUMP_FORWARD_IF_FALSE_A) { /* Offset is relative in these cases */ offs += pos; } - if (cond.type() == ASTNode::NODE_COMPARE - && cond.cast()->op() == ASTCompare::CMP_EXCEPTION) { - if (curblock->blktype() == ASTBlock::BLK_EXCEPT - && curblock.cast()->cond() == NULL) { + if (cond.type() == ASTNode::NODE_COMPARE && + cond.cast()->op() == + ASTCompare::CMP_EXCEPTION) { + if (curblock->blktype() == ASTBlock::BLK_EXCEPT && + curblock.cast()->cond() == NULL) { blocks.pop(); curblock = blocks.top(); stack_hist.pop(); } - ifblk = new ASTCondBlock(ASTBlock::BLK_EXCEPT, offs, cond.cast()->right(), false); - } else if (curblock->blktype() == ASTBlock::BLK_ELSE - && curblock->size() == 0) { + ifblk = new ASTCondBlock(ASTBlock::BLK_EXCEPT, offs, + cond.cast()->right(), false); + } + else if (curblock->blktype() == ASTBlock::BLK_ELSE && + curblock->size() == 0) { /* Collapse into elif statement */ blocks.pop(); stack = stack_hist.top(); stack_hist.pop(); - ifblk = new ASTCondBlock(ASTBlock::BLK_ELIF, offs, cond, neg); - } else if (curblock->size() == 0 && !curblock->inited() - && curblock->blktype() == ASTBlock::BLK_WHILE) { + ifblk = + new ASTCondBlock(ASTBlock::BLK_ELIF, offs, cond, neg); + } + else if (curblock->size() == 0 && !curblock->inited() && + curblock->blktype() == ASTBlock::BLK_WHILE) { /* The condition for a while loop */ PycRef top = blocks.top(); blocks.pop(); @@ -1118,10 +1192,11 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) /* We don't store the stack for loops! Pop it! */ stack_hist.pop(); - } else if (curblock->size() == 0 && curblock->end() <= offs - && (curblock->blktype() == ASTBlock::BLK_IF - || curblock->blktype() == ASTBlock::BLK_ELIF - || curblock->blktype() == ASTBlock::BLK_WHILE)) { + } + else if (curblock->size() == 0 && curblock->end() <= offs && + (curblock->blktype() == ASTBlock::BLK_IF || + curblock->blktype() == ASTBlock::BLK_ELIF || + curblock->blktype() == ASTBlock::BLK_WHILE)) { PycRef newcond; PycRef top = curblock.cast(); PycRef cond1 = top->cond(); @@ -1129,32 +1204,39 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (curblock->blktype() == ASTBlock::BLK_WHILE) { stack_hist.pop(); - } else { + } + else { FastStack s_top = stack_hist.top(); stack_hist.pop(); stack_hist.pop(); stack_hist.push(s_top); } - if (curblock->end() == offs - || (curblock->end() == curpos && !top->negative())) { + if (curblock->end() == offs || + (curblock->end() == curpos && !top->negative())) { /* if blah and blah */ - newcond = new ASTBinary(cond1, cond, ASTBinary::BIN_LOG_AND); - } else { + newcond = + new ASTBinary(cond1, cond, ASTBinary::BIN_LOG_AND); + } + else { /* if blah or blah */ - newcond = new ASTBinary(cond1, cond, ASTBinary::BIN_LOG_OR); + newcond = + new ASTBinary(cond1, cond, ASTBinary::BIN_LOG_OR); } - ifblk = new ASTCondBlock(top->blktype(), offs, newcond, neg); - } else if (curblock->blktype() == ASTBlock::BLK_FOR - && curblock.cast()->isComprehension() - && mod->verCompare(2, 7) >= 0) { + ifblk = + new ASTCondBlock(top->blktype(), offs, newcond, neg); + } + else if (curblock->blktype() == ASTBlock::BLK_FOR && + curblock.cast()->isComprehension() && + mod->verCompare(2, 7) >= 0) { /* Comprehension condition */ curblock.cast()->setCondition(cond); stack_hist.pop(); // TODO: Handle older python versions, where condition // is laid out a little differently. break; - } else { + } + else { /* Plain old if statement */ ifblk = new ASTCondBlock(ASTBlock::BLK_IF, offs, cond, neg); } @@ -1173,22 +1255,29 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { int offs = operand; if (mod->verCompare(3, 10) >= 0) - offs *= sizeof(uint16_t); // // BPO-27129 + offs *= sizeof(uint16_t); // // BPO-27129 if (offs < pos) { if (curblock->blktype() == ASTBlock::BLK_FOR) { - bool is_jump_to_start = offs == curblock.cast()->start(); - bool should_pop_for_block = curblock.cast()->isComprehension(); + bool is_jump_to_start = + offs == curblock.cast()->start(); + bool should_pop_for_block = + curblock.cast()->isComprehension(); // in v3.8, SETUP_LOOP is deprecated and for blocks aren't terminated by POP_BLOCK, so we add them here - bool should_add_for_block = mod->majorVer() == 3 && mod->minorVer() >= 8 && is_jump_to_start && !curblock.cast()->isComprehension(); + bool should_add_for_block = + mod->majorVer() == 3 && mod->minorVer() >= 8 && + is_jump_to_start && + !curblock.cast()->isComprehension(); if (should_pop_for_block || should_add_for_block) { PycRef top = stack.top(); if (top.type() == ASTNode::NODE_COMPREHENSION) { - PycRef comp = top.cast(); + PycRef comp = + top.cast(); - comp->addGenerator(curblock.cast()); + comp->addGenerator( + curblock.cast()); } PycRef tmp = curblock; @@ -1198,7 +1287,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) curblock->append(tmp.cast()); } } - } else if (curblock->blktype() == ASTBlock::BLK_ELSE) { + } + else if (curblock->blktype() == ASTBlock::BLK_ELSE) { stack = stack_hist.top(); stack_hist.pop(); @@ -1206,25 +1296,29 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) blocks.top()->append(curblock.cast()); curblock = blocks.top(); - if (curblock->blktype() == ASTBlock::BLK_CONTAINER - && !curblock.cast()->hasFinally()) { + if (curblock->blktype() == ASTBlock::BLK_CONTAINER && + !curblock.cast()->hasFinally()) { blocks.pop(); blocks.top()->append(curblock.cast()); curblock = blocks.top(); } - } else { - curblock->append(new ASTKeyword(ASTKeyword::KW_CONTINUE)); + } + else { + curblock->append( + new ASTKeyword(ASTKeyword::KW_CONTINUE)); } /* We're in a loop, this jumps back to the start */ /* I think we'll just ignore this case... */ - break; // Bad idea? Probably! + break; // Bad idea? Probably! } if (curblock->blktype() == ASTBlock::BLK_CONTAINER) { - PycRef cont = curblock.cast(); + PycRef cont = + curblock.cast(); if (cont->hasExcept() && pos < cont->except()) { - PycRef except = new ASTCondBlock(ASTBlock::BLK_EXCEPT, 0, NULL, false); + PycRef except = new ASTCondBlock( + ASTBlock::BLK_EXCEPT, 0, NULL, false); except->init(); blocks.push(except); curblock = blocks.top(); @@ -1235,8 +1329,10 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (!stack_hist.empty()) { stack = stack_hist.top(); stack_hist.pop(); - } else { - fprintf(stderr, "Warning: Stack history is empty, something wrong might have happened\n"); + } + else { + fprintf(stderr, + "Warning: Stack history is empty, something wrong might have happened\n"); } PycRef prev = curblock; @@ -1248,28 +1344,33 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) blocks.top()->append(prev.cast()); - if (prev->blktype() == ASTBlock::BLK_IF - || prev->blktype() == ASTBlock::BLK_ELIF) { + if (prev->blktype() == ASTBlock::BLK_IF || + prev->blktype() == ASTBlock::BLK_ELIF) { if (push) { stack_hist.push(stack); } - PycRef next = new ASTBlock(ASTBlock::BLK_ELSE, blocks.top()->end()); + PycRef next = new ASTBlock( + ASTBlock::BLK_ELSE, blocks.top()->end()); if (prev->inited() == ASTCondBlock::PRE_POPPED) { next->init(ASTCondBlock::PRE_POPPED); } blocks.push(next.cast()); prev = nil; - } else if (prev->blktype() == ASTBlock::BLK_EXCEPT) { + } + else if (prev->blktype() == ASTBlock::BLK_EXCEPT) { if (push) { stack_hist.push(stack); } - PycRef next = new ASTCondBlock(ASTBlock::BLK_EXCEPT, blocks.top()->end(), NULL, false); + PycRef next = + new ASTCondBlock(ASTBlock::BLK_EXCEPT, + blocks.top()->end(), NULL, false); next->init(); blocks.push(next.cast()); prev = nil; - } else if (prev->blktype() == ASTBlock::BLK_ELSE) { + } + else if (prev->blktype() == ASTBlock::BLK_ELSE) { /* Special case */ prev = blocks.top(); if (!push) { @@ -1277,7 +1378,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack_hist.pop(); } push = false; - } else { + } + else { prev = nil; } @@ -1291,15 +1393,17 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { int offs = operand; if (mod->verCompare(3, 10) >= 0) - offs *= sizeof(uint16_t); // // BPO-27129 + offs *= sizeof(uint16_t); // // BPO-27129 if (curblock->blktype() == ASTBlock::BLK_CONTAINER) { - PycRef cont = curblock.cast(); + PycRef cont = + curblock.cast(); if (cont->hasExcept()) { stack_hist.push(stack); - curblock->setEnd(pos+offs); - PycRef except = new ASTCondBlock(ASTBlock::BLK_EXCEPT, pos+offs, NULL, false); + curblock->setEnd(pos + offs); + PycRef except = new ASTCondBlock( + ASTBlock::BLK_EXCEPT, pos + offs, NULL, false); except->init(); blocks.push(except); curblock = blocks.top(); @@ -1308,7 +1412,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) } if (!stack_hist.empty()) { - if (stack.empty()) // if it's part of if-expression, TOS at the moment is the result of "if" part + if (stack + .empty()) // if it's part of if-expression, TOS at the moment is the result of "if" part stack = stack_hist.top(); stack_hist.pop(); } @@ -1323,8 +1428,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (!blocks.empty()) blocks.top()->append(prev.cast()); - if (prev->blktype() == ASTBlock::BLK_IF - || prev->blktype() == ASTBlock::BLK_ELIF) { + if (prev->blktype() == ASTBlock::BLK_IF || + prev->blktype() == ASTBlock::BLK_ELIF) { if (offs == 0) { prev = nil; continue; @@ -1333,14 +1438,16 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (push) { stack_hist.push(stack); } - PycRef next = new ASTBlock(ASTBlock::BLK_ELSE, pos+offs); + PycRef next = + new ASTBlock(ASTBlock::BLK_ELSE, pos + offs); if (prev->inited() == ASTCondBlock::PRE_POPPED) { next->init(ASTCondBlock::PRE_POPPED); } blocks.push(next.cast()); prev = nil; - } else if (prev->blktype() == ASTBlock::BLK_EXCEPT) { + } + else if (prev->blktype() == ASTBlock::BLK_EXCEPT) { if (offs == 0) { prev = nil; continue; @@ -1349,12 +1456,14 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (push) { stack_hist.push(stack); } - PycRef next = new ASTCondBlock(ASTBlock::BLK_EXCEPT, pos+offs, NULL, false); + PycRef next = new ASTCondBlock( + ASTBlock::BLK_EXCEPT, pos + offs, NULL, false); next->init(); blocks.push(next.cast()); prev = nil; - } else if (prev->blktype() == ASTBlock::BLK_ELSE) { + } + else if (prev->blktype() == ASTBlock::BLK_ELSE) { /* Special case */ prev = blocks.top(); if (!push) { @@ -1367,28 +1476,35 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) /* Something went out of control! */ prev = nil; } - } else if (prev->blktype() == ASTBlock::BLK_TRY - && prev->end() < pos+offs) { + } + else if (prev->blktype() == ASTBlock::BLK_TRY && + prev->end() < pos + offs) { /* Need to add an except/finally block */ stack = stack_hist.top(); stack.pop(); - if (blocks.top()->blktype() == ASTBlock::BLK_CONTAINER) { - PycRef cont = blocks.top().cast(); + if (blocks.top()->blktype() == + ASTBlock::BLK_CONTAINER) { + PycRef cont = + blocks.top().cast(); if (cont->hasExcept()) { if (push) { stack_hist.push(stack); } - PycRef except = new ASTCondBlock(ASTBlock::BLK_EXCEPT, pos+offs, NULL, false); + PycRef except = + new ASTCondBlock(ASTBlock::BLK_EXCEPT, + pos + offs, NULL, false); except->init(); blocks.push(except); } - } else { + } + else { fprintf(stderr, "Something TERRIBLE happened!!\n"); } prev = nil; - } else { + } + else { prev = nil; } @@ -1397,7 +1513,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (!blocks.empty()) { curblock = blocks.top(); if (curblock->blktype() == ASTBlock::BLK_EXCEPT) - curblock->setEnd(pos+offs); + curblock->setEnd(pos + offs); } } break; @@ -1409,12 +1525,12 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef list = stack.top(); - - if (curblock->blktype() == ASTBlock::BLK_FOR - && curblock.cast()->isComprehension()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + curblock.cast()->isComprehension()) { stack.pop(); stack.push(new ASTComprehension(value)); - } else { + } + else { stack.push(new ASTSubscr(list, value)); /* Total hack */ } } @@ -1427,14 +1543,16 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); if (rhs.type() != ASTNode::NODE_OBJECT) { - fprintf(stderr, "Unsupported argument found for SET_UPDATE\n"); + fprintf( + stderr, "Unsupported argument found for SET_UPDATE\n"); break; } // I've only ever seen this be a TYPE_FROZENSET, but let's be careful... PycRef obj = rhs.cast()->object(); if (obj->type() != PycObject::TYPE_FROZENSET) { - fprintf(stderr, "Unsupported argument type found for SET_UPDATE\n"); + fprintf(stderr, + "Unsupported argument type found for SET_UPDATE\n"); break; } @@ -1454,14 +1572,17 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); if (rhs.type() != ASTNode::NODE_OBJECT) { - fprintf(stderr, "Unsupported argument found for LIST_EXTEND\n"); + fprintf( + stderr, "Unsupported argument found for LIST_EXTEND\n"); break; } // I've only ever seen this be a SMALL_TUPLE, but let's be careful... PycRef obj = rhs.cast()->object(); - if (obj->type() != PycObject::TYPE_TUPLE && obj->type() != PycObject::TYPE_SMALL_TUPLE) { - fprintf(stderr, "Unsupported argument type found for LIST_EXTEND\n"); + if (obj->type() != PycObject::TYPE_TUPLE && + obj->type() != PycObject::TYPE_SMALL_TUPLE) { + fprintf(stderr, + "Unsupported argument type found for LIST_EXTEND\n"); break; } @@ -1489,7 +1610,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) operand >>= 1; } - stack.push(new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR)); + stack.push( + new ASTBinary(name, new ASTName(code->getName(operand)), + ASTBinary::BIN_ATTR)); } } break; @@ -1505,12 +1628,14 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if ((t_ob->object().type() == PycObject::TYPE_TUPLE || t_ob->object().type() == PycObject::TYPE_SMALL_TUPLE) && - !t_ob->object().cast()->values().size()) { + !t_ob->object().cast()->values().size()) { ASTTuple::value_t values; stack.push(new ASTTuple(values)); - } else if (t_ob->object().type() == PycObject::TYPE_NONE) { + } + else if (t_ob->object().type() == PycObject::TYPE_NONE) { stack.push(NULL); - } else { + } + else { stack.push(t_ob.cast()); } } @@ -1533,8 +1658,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (mod->verCompare(3, 11) >= 0) { // Loads the global named co_names[namei>>1] onto the stack. if (operand & 1) { - /* Changed in version 3.11: - If the low bit of "NAMEI" (operand) is set, + /* Changed in version 3.11: + If the low bit of "NAMEI" (operand) is set, then a NULL is pushed to the stack before the global variable. */ stack.push(nullptr); } @@ -1553,7 +1678,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) // Behave like LOAD_ATTR PycRef name = stack.top(); stack.pop(); - stack.push(new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR)); + stack.push(new ASTBinary(name, + new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR)); } break; case Pyc::LOAD_NAME_A: @@ -1592,7 +1718,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::POP_BLOCK: { if (curblock->blktype() == ASTBlock::BLK_CONTAINER || - curblock->blktype() == ASTBlock::BLK_FINALLY) { + curblock->blktype() == ASTBlock::BLK_FINALLY) { /* These should only be popped by an END_FINALLY */ break; } @@ -1603,21 +1729,23 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) } if (curblock->nodes().size() && - curblock->nodes().back().type() == ASTNode::NODE_KEYWORD) { + curblock->nodes().back().type() == ASTNode::NODE_KEYWORD) { curblock->removeLast(); } - if (curblock->blktype() == ASTBlock::BLK_IF - || curblock->blktype() == ASTBlock::BLK_ELIF - || curblock->blktype() == ASTBlock::BLK_ELSE - || curblock->blktype() == ASTBlock::BLK_TRY - || curblock->blktype() == ASTBlock::BLK_EXCEPT - || curblock->blktype() == ASTBlock::BLK_FINALLY) { + if (curblock->blktype() == ASTBlock::BLK_IF || + curblock->blktype() == ASTBlock::BLK_ELIF || + curblock->blktype() == ASTBlock::BLK_ELSE || + curblock->blktype() == ASTBlock::BLK_TRY || + curblock->blktype() == ASTBlock::BLK_EXCEPT || + curblock->blktype() == ASTBlock::BLK_FINALLY) { if (!stack_hist.empty()) { stack = stack_hist.top(); stack_hist.pop(); - } else { - fprintf(stderr, "Warning: Stack history is empty, something wrong might have happened\n"); + } + else { + fprintf(stderr, + "Warning: Stack history is empty, something wrong might have happened\n"); } } PycRef tmp = curblock; @@ -1626,23 +1754,24 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (!blocks.empty()) curblock = blocks.top(); - if (!(tmp->blktype() == ASTBlock::BLK_ELSE - && tmp->nodes().size() == 0)) { + if (!(tmp->blktype() == ASTBlock::BLK_ELSE && + tmp->nodes().size() == 0)) { curblock->append(tmp.cast()); } if (tmp->blktype() == ASTBlock::BLK_FOR && tmp->end() >= pos) { stack_hist.push(stack); - PycRef blkelse = new ASTBlock(ASTBlock::BLK_ELSE, tmp->end()); + PycRef blkelse = + new ASTBlock(ASTBlock::BLK_ELSE, tmp->end()); blocks.push(blkelse); curblock = blocks.top(); } - if (curblock->blktype() == ASTBlock::BLK_TRY - && tmp->blktype() != ASTBlock::BLK_FOR - && tmp->blktype() != ASTBlock::BLK_ASYNCFOR - && tmp->blktype() != ASTBlock::BLK_WHILE) { + if (curblock->blktype() == ASTBlock::BLK_TRY && + tmp->blktype() != ASTBlock::BLK_FOR && + tmp->blktype() != ASTBlock::BLK_ASYNCFOR && + tmp->blktype() != ASTBlock::BLK_WHILE) { stack = stack_hist.top(); stack_hist.pop(); @@ -1650,36 +1779,42 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) blocks.pop(); curblock = blocks.top(); - if (!(tmp->blktype() == ASTBlock::BLK_ELSE - && tmp->nodes().size() == 0)) { + if (!(tmp->blktype() == ASTBlock::BLK_ELSE && + tmp->nodes().size() == 0)) { curblock->append(tmp.cast()); } } if (curblock->blktype() == ASTBlock::BLK_CONTAINER) { - PycRef cont = curblock.cast(); + PycRef cont = + curblock.cast(); - if (tmp->blktype() == ASTBlock::BLK_ELSE && !cont->hasFinally()) { + if (tmp->blktype() == ASTBlock::BLK_ELSE && + !cont->hasFinally()) { /* Pop the container */ blocks.pop(); curblock = blocks.top(); curblock->append(cont.cast()); - - } else if ((tmp->blktype() == ASTBlock::BLK_ELSE && cont->hasFinally()) - || (tmp->blktype() == ASTBlock::BLK_TRY && !cont->hasExcept())) { + } + else if ((tmp->blktype() == ASTBlock::BLK_ELSE && + cont->hasFinally()) || + (tmp->blktype() == ASTBlock::BLK_TRY && + !cont->hasExcept())) { /* Add the finally block */ stack_hist.push(stack); - PycRef final = new ASTBlock(ASTBlock::BLK_FINALLY, 0, true); + PycRef final = + new ASTBlock(ASTBlock::BLK_FINALLY, 0, true); blocks.push(final); curblock = blocks.top(); } } - if ((curblock->blktype() == ASTBlock::BLK_FOR || curblock->blktype() == ASTBlock::BLK_ASYNCFOR) - && curblock->end() == pos) { + if ((curblock->blktype() == ASTBlock::BLK_FOR || + curblock->blktype() == ASTBlock::BLK_ASYNCFOR) && + curblock->end() == pos) { blocks.pop(); blocks.top()->append(curblock.cast()); curblock = blocks.top(); @@ -1693,13 +1828,14 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { stack.pop(); - if ((opcode == Pyc::END_FOR) && (mod->majorVer() == 3) && (mod->minorVer() == 12)) { + if ((opcode == Pyc::END_FOR) && (mod->majorVer() == 3) && + (mod->minorVer() == 12)) { // one additional pop for python 3.12 stack.pop(); } // end for loop here - /* TODO : Ensure that FOR loop ends here. + /* TODO : Ensure that FOR loop ends here. Due to CACHE instructions at play, the end indicated in the for loop by pycdas is not correct, it is off by some small amount. */ @@ -1711,7 +1847,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) curblock->append(prev.cast()); } else { - fprintf(stderr, "Wrong block type %i for END_FOR\n", curblock->blktype()); + fprintf(stderr, "Wrong block type %i for END_FOR\n", + curblock->blktype()); } } break; @@ -1723,18 +1860,20 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (!curblock->inited()) { if (curblock->blktype() == ASTBlock::BLK_WITH) { curblock.cast()->setExpr(value); - } else { + } + else { curblock->init(); } break; - } else if (value == nullptr || value->processed()) { + } + else if (value == nullptr || value->processed()) { break; } curblock->append(value); - if (curblock->blktype() == ASTBlock::BLK_FOR - && curblock.cast()->isComprehension()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + curblock.cast()->isComprehension()) { /* This relies on some really uncertain logic... * If it's a comprehension, the only POP_TOP should be * a call to append the iter to the list. @@ -1752,9 +1891,11 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::PRINT_ITEM: { PycRef printNode; - if (curblock->size() > 0 && curblock->nodes().back().type() == ASTNode::NODE_PRINT) + if (curblock->size() > 0 && + curblock->nodes().back().type() == ASTNode::NODE_PRINT) printNode = curblock->nodes().back().try_cast(); - if (printNode && printNode->stream() == nullptr && !printNode->eol()) + if (printNode && printNode->stream() == nullptr && + !printNode->eol()) printNode->add(stack.top()); else curblock->append(new ASTPrint(stack.top())); @@ -1767,9 +1908,11 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); PycRef printNode; - if (curblock->size() > 0 && curblock->nodes().back().type() == ASTNode::NODE_PRINT) + if (curblock->size() > 0 && + curblock->nodes().back().type() == ASTNode::NODE_PRINT) printNode = curblock->nodes().back().try_cast(); - if (printNode && printNode->stream() == stream && !printNode->eol()) + if (printNode && printNode->stream() == stream && + !printNode->eol()) printNode->add(stack.top()); else curblock->append(new ASTPrint(stack.top(), stream)); @@ -1781,9 +1924,11 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::PRINT_NEWLINE: { PycRef printNode; - if (curblock->size() > 0 && curblock->nodes().back().type() == ASTNode::NODE_PRINT) + if (curblock->size() > 0 && + curblock->nodes().back().type() == ASTNode::NODE_PRINT) printNode = curblock->nodes().back().try_cast(); - if (printNode && printNode->stream() == nullptr && !printNode->eol()) + if (printNode && printNode->stream() == nullptr && + !printNode->eol()) printNode->setEol(true); else curblock->append(new ASTPrint(nullptr)); @@ -1796,9 +1941,11 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); PycRef printNode; - if (curblock->size() > 0 && curblock->nodes().back().type() == ASTNode::NODE_PRINT) + if (curblock->size() > 0 && + curblock->nodes().back().type() == ASTNode::NODE_PRINT) printNode = curblock->nodes().back().try_cast(); - if (printNode && printNode->stream() == stream && !printNode->eol()) + if (printNode && printNode->stream() == stream && + !printNode->eol()) printNode->setEol(true); else curblock->append(new ASTPrint(nullptr, stream)); @@ -1816,10 +1963,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) } curblock->append(new ASTRaise(paramList)); - if ((curblock->blktype() == ASTBlock::BLK_IF - || curblock->blktype() == ASTBlock::BLK_ELSE) - && stack_hist.size() - && (mod->verCompare(2, 6) >= 0)) { + if ((curblock->blktype() == ASTBlock::BLK_IF || + curblock->blktype() == ASTBlock::BLK_ELSE) && + stack_hist.size() && (mod->verCompare(2, 6) >= 0)) { stack = stack_hist.top(); stack_hist.pop(); @@ -1837,10 +1983,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); curblock->append(new ASTReturn(value)); - if ((curblock->blktype() == ASTBlock::BLK_IF - || curblock->blktype() == ASTBlock::BLK_ELSE) - && stack_hist.size() - && (mod->verCompare(2, 6) >= 0)) { + if ((curblock->blktype() == ASTBlock::BLK_IF || + curblock->blktype() == ASTBlock::BLK_ELSE) && + stack_hist.size() && (mod->verCompare(2, 6) >= 0)) { stack = stack_hist.top(); stack_hist.pop(); @@ -1856,7 +2001,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::RETURN_CONST_A: case Pyc::INSTRUMENTED_RETURN_CONST_A: { - PycRef value = new ASTObject(code->getConst(operand)); + PycRef value = + new ASTObject(code->getConst(operand)); curblock->append(new ASTReturn(value.cast())); } break; @@ -1915,7 +2061,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::SETUP_WITH_A: case Pyc::WITH_EXCEPT_START: { - PycRef withblock = new ASTWithBlock(pos+operand); + PycRef withblock = new ASTWithBlock(pos + operand); blocks.push(withblock); curblock = blocks.top(); } @@ -1932,15 +2078,17 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; } - if (curblock->blktype() == ASTBlock::BLK_WITH - && curblock->end() == curpos) { + if (curblock->blktype() == ASTBlock::BLK_WITH && + curblock->end() == curpos) { PycRef with = curblock; blocks.pop(); curblock = blocks.top(); curblock->append(with.cast()); } else { - fprintf(stderr, "Something TERRIBLE happened! No matching with block found for WITH_CLEANUP at %d\n", curpos); + fprintf(stderr, + "Something TERRIBLE happened! No matching with block found for WITH_CLEANUP at %d\n", + curpos); } } break; @@ -1950,15 +2098,19 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::SETUP_EXCEPT_A: { if (curblock->blktype() == ASTBlock::BLK_CONTAINER) { - curblock.cast()->setExcept(pos+operand); - } else { - PycRef next = new ASTContainerBlock(0, pos+operand); + curblock.cast()->setExcept( + pos + operand); + } + else { + PycRef next = + new ASTContainerBlock(0, pos + operand); blocks.push(next.cast()); } /* Store the current stack for the except/finally statement(s) */ stack_hist.push(stack); - PycRef tryblock = new ASTBlock(ASTBlock::BLK_TRY, pos+operand, true); + PycRef tryblock = + new ASTBlock(ASTBlock::BLK_TRY, pos + operand, true); blocks.push(tryblock.cast()); curblock = blocks.top(); @@ -1967,7 +2119,7 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::SETUP_FINALLY_A: { - PycRef next = new ASTContainerBlock(pos+operand); + PycRef next = new ASTContainerBlock(pos + operand); blocks.push(next.cast()); curblock = blocks.top(); @@ -1976,7 +2128,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) break; case Pyc::SETUP_LOOP_A: { - PycRef next = new ASTCondBlock(ASTBlock::BLK_WHILE, pos+operand, NULL, false); + PycRef next = new ASTCondBlock( + ASTBlock::BLK_WHILE, pos + operand, NULL, false); blocks.push(next.cast()); curblock = blocks.top(); } @@ -2008,7 +2161,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - PycRef slice = new ASTSlice(ASTSlice::SLICE2, NULL, upper); + PycRef slice = + new ASTSlice(ASTSlice::SLICE2, NULL, upper); stack.push(new ASTSubscr(name, slice)); } break; @@ -2021,7 +2175,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef name = stack.top(); stack.pop(); - PycRef slice = new ASTSlice(ASTSlice::SLICE3, lower, upper); + PycRef slice = + new ASTSlice(ASTSlice::SLICE3, lower, upper); stack.push(new ASTSubscr(name, slice)); } break; @@ -2030,7 +2185,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (unpack) { PycRef name = stack.top(); stack.pop(); - PycRef attr = new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR); + PycRef attr = + new ASTBinary(name, new ASTName(code->getName(operand)), + ASTBinary::BIN_ATTR); PycRef tup = stack.top(); if (tup.type() == ASTNode::NODE_TUPLE) @@ -2044,19 +2201,24 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef name = stack.top(); stack.pop(); PycRef value = stack.top(); stack.pop(); - PycRef attr = new ASTBinary(name, new ASTName(code->getName(operand)), ASTBinary::BIN_ATTR); + PycRef attr = + new ASTBinary(name, new ASTName(code->getName(operand)), + ASTBinary::BIN_ATTR); if (value.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(value, attr, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(value, attr)); } } @@ -2065,7 +2227,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::STORE_DEREF_A: { if (unpack) { - PycRef name = new ASTName(code->getCellVar(mod, operand)); + PycRef name = + new ASTName(code->getCellVar(mod, operand)); PycRef tup = stack.top(); if (tup.type() == ASTNode::NODE_TUPLE) @@ -2080,18 +2243,22 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef value = stack.top(); stack.pop(); - PycRef name = new ASTName(code->getCellVar(mod, operand)); + PycRef name = + new ASTName(code->getCellVar(mod, operand)); if (value.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(value, name, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(value, name)); } } @@ -2118,19 +2285,22 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef seq = stack.top(); stack.pop(); - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { PycRef tuple = tup.try_cast(); if (tuple != NULL) tuple->setRequireParens(false); curblock.cast()->setIndex(tup); - } else if (seq.type() == ASTNode::NODE_CHAINSTORE) { + } + else if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef value = stack.top(); stack.pop(); PycRef name; @@ -2140,22 +2310,25 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) else name = new ASTName(code->getLocal(operand)); - if (name.cast()->name()->value()[0] == '_' - && name.cast()->name()->value()[1] == '[') { + if (name.cast()->name()->value()[0] == '_' && + name.cast()->name()->value()[1] == '[') { /* Don't show stores of list comp append objects. */ break; } - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { curblock.cast()->setIndex(name); - } else if (curblock->blktype() == ASTBlock::BLK_WITH - && !curblock->inited()) { + } + else if (curblock->blktype() == ASTBlock::BLK_WITH && + !curblock->inited()) { curblock.cast()->setExpr(value); curblock.cast()->setVar(name); - } else if (value.type() == ASTNode::NODE_CHAINSTORE) { + } + else if (value.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(value, name, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(value, name)); } } @@ -2177,24 +2350,28 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef seq = stack.top(); stack.pop(); - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { PycRef tuple = tup.try_cast(); if (tuple != NULL) tuple->setRequireParens(false); curblock.cast()->setIndex(tup); - } else if (seq.type() == ASTNode::NODE_CHAINSTORE) { + } + else if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef value = stack.top(); stack.pop(); if (value.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(value, name, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(value, name)); } } @@ -2219,50 +2396,60 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef seq = stack.top(); stack.pop(); - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { PycRef tuple = tup.try_cast(); if (tuple != NULL) tuple->setRequireParens(false); curblock.cast()->setIndex(tup); - } else if (seq.type() == ASTNode::NODE_CHAINSTORE) { + } + else if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef value = stack.top(); stack.pop(); PycRef varname = code->getName(operand); - if (varname->length() >= 2 && varname->value()[0] == '_' - && varname->value()[1] == '[') { + if (varname->length() >= 2 && varname->value()[0] == '_' && + varname->value()[1] == '[') { /* Don't show stores of list comp append objects. */ break; } // Return private names back to their original name - const std::string class_prefix = std::string("_") + code->name()->strValue(); + const std::string class_prefix = + std::string("_") + code->name()->strValue(); if (varname->startsWith(class_prefix + std::string("__"))) - varname->setValue(varname->strValue().substr(class_prefix.size())); + varname->setValue( + varname->strValue().substr(class_prefix.size())); PycRef name = new ASTName(varname); - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { curblock.cast()->setIndex(name); - } else if (stack.top().type() == ASTNode::NODE_IMPORT) { - PycRef import = stack.top().cast(); + } + else if (stack.top().type() == ASTNode::NODE_IMPORT) { + PycRef import = + stack.top().cast(); import->add_store(new ASTStore(value, name)); - } else if (curblock->blktype() == ASTBlock::BLK_WITH - && !curblock->inited()) { + } + else if (curblock->blktype() == ASTBlock::BLK_WITH && + !curblock->inited()) { curblock.cast()->setExpr(value); curblock.cast()->setVar(name); - } else if (value.type() == ASTNode::NODE_CHAINSTORE) { + } + else if (value.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(value, name, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(value, name)); if (value.type() == ASTNode::NODE_INVALID) @@ -2278,7 +2465,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef value = stack.top(); stack.pop(); - curblock->append(new ASTStore(value, new ASTSubscr(dest, new ASTSlice(ASTSlice::SLICE0)))); + curblock->append(new ASTStore(value, + new ASTSubscr(dest, new ASTSlice(ASTSlice::SLICE0)))); } break; case Pyc::STORE_SLICE_1: @@ -2290,7 +2478,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef value = stack.top(); stack.pop(); - curblock->append(new ASTStore(value, new ASTSubscr(dest, new ASTSlice(ASTSlice::SLICE1, upper)))); + curblock->append(new ASTStore( + value, new ASTSubscr( + dest, new ASTSlice(ASTSlice::SLICE1, upper)))); } break; case Pyc::STORE_SLICE_2: @@ -2302,7 +2492,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef value = stack.top(); stack.pop(); - curblock->append(new ASTStore(value, new ASTSubscr(dest, new ASTSlice(ASTSlice::SLICE2, NULL, lower)))); + curblock->append(new ASTStore( + value, new ASTSubscr(dest, + new ASTSlice(ASTSlice::SLICE2, NULL, lower)))); } break; case Pyc::STORE_SLICE_3: @@ -2316,7 +2508,9 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef value = stack.top(); stack.pop(); - curblock->append(new ASTStore(value, new ASTSubscr(dest, new ASTSlice(ASTSlice::SLICE3, upper, lower)))); + curblock->append(new ASTStore( + value, new ASTSubscr(dest, + new ASTSlice(ASTSlice::SLICE3, upper, lower)))); } break; case Pyc::STORE_SUBSCR: @@ -2341,11 +2535,13 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) stack.pop(); if (seq.type() == ASTNode::NODE_CHAINSTORE) { append_to_chain_store(seq, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(seq, tup)); } } - } else { + } + else { PycRef subscr = stack.top(); stack.pop(); PycRef dest = stack.top(); @@ -2356,28 +2552,40 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) // If variable annotations are enabled, we'll need to check for them here. // Python handles a varaible annotation by setting: // __annotations__['var-name'] = type - const bool found_annotated_var = (variable_annotations && dest->type() == ASTNode::Type::NODE_NAME - && dest.cast()->name()->isEqual("__annotations__")); + const bool found_annotated_var = + (variable_annotations && + dest->type() == ASTNode::Type::NODE_NAME && + dest.cast()->name()->isEqual( + "__annotations__")); if (found_annotated_var) { // Annotations can be done alone or as part of an assignment. // In the case of an assignment, we'll see a NODE_STORE on the stack. - if (!curblock->nodes().empty() && curblock->nodes().back()->type() == ASTNode::Type::NODE_STORE) { + if (!curblock->nodes().empty() && + curblock->nodes().back()->type() == + ASTNode::Type::NODE_STORE) { // Replace the existing NODE_STORE with a new one that includes the annotation. - PycRef store = curblock->nodes().back().cast(); + PycRef store = + curblock->nodes().back().cast(); curblock->removeLast(); curblock->append(new ASTStore(store->src(), - new ASTAnnotatedVar(subscr, src))); - } else { + new ASTAnnotatedVar(subscr, src))); + } + else { curblock->append(new ASTAnnotatedVar(subscr, src)); } - } else { + } + else { if (dest.type() == ASTNode::NODE_MAP) { dest.cast()->add(subscr, src); - } else if (src.type() == ASTNode::NODE_CHAINSTORE) { - append_to_chain_store(src, new ASTSubscr(dest, subscr), stack, curblock); - } else { - curblock->append(new ASTStore(src, new ASTSubscr(dest, subscr))); + } + else if (src.type() == ASTNode::NODE_CHAINSTORE) { + append_to_chain_store(src, + new ASTSubscr(dest, subscr), stack, curblock); + } + else { + curblock->append( + new ASTStore(src, new ASTSubscr(dest, subscr))); } } } @@ -2387,7 +2595,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) { PycRef func = stack.top(); stack.pop(); - stack.push(new ASTCall(func, ASTCall::pparam_t(), ASTCall::kwparam_t())); + stack.push(new ASTCall( + func, ASTCall::pparam_t(), ASTCall::kwparam_t())); } break; case Pyc::UNARY_CONVERT: @@ -2433,20 +2642,23 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) if (unpack > 0) { ASTTuple::value_t vals; stack.push(new ASTTuple(vals)); - } else { + } + else { // Unpack zero values and assign it to top of stack or for loop variable. // E.g. [] = TOS / for [] in X ASTTuple::value_t vals; auto tup = new ASTTuple(vals); - if (curblock->blktype() == ASTBlock::BLK_FOR - && !curblock->inited()) { + if (curblock->blktype() == ASTBlock::BLK_FOR && + !curblock->inited()) { tup->setRequireParens(true); curblock.cast()->setIndex(tup); - } else if (stack.top().type() == ASTNode::NODE_CHAINSTORE) { + } + else if (stack.top().type() == ASTNode::NODE_CHAINSTORE) { auto chainStore = stack.top(); stack.pop(); append_to_chain_store(chainStore, tup, stack, curblock); - } else { + } + else { curblock->append(new ASTStore(stack.top(), tup)); stack.pop(); } @@ -2461,7 +2673,8 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef value = stack.top(); if (value) { value->setProcessed(); - curblock->append(new ASTReturn(value, ASTReturn::YIELD_FROM)); + curblock->append( + new ASTReturn(value, ASTReturn::YIELD_FROM)); } } break; @@ -2480,7 +2693,6 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) case Pyc::RESUME_A: case Pyc::INSTRUMENTED_RESUME_A: /* We just entirely ignore this / no-op */ - break; case Pyc::CACHE: /* These "fake" opcodes are used as placeholders for optimizing certain opcodes in Python 3.11+. Since we have no need for @@ -2520,24 +2732,27 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef dest = stack.top(); stack.pop(); - if (start.type() == ASTNode::NODE_OBJECT - && start.cast()->object() == Pyc_None) { + if (start.type() == ASTNode::NODE_OBJECT && + start.cast()->object() == Pyc_None) { start = NULL; } - if (end.type() == ASTNode::NODE_OBJECT - && end.cast()->object() == Pyc_None) { + if (end.type() == ASTNode::NODE_OBJECT && + end.cast()->object() == Pyc_None) { end = NULL; } PycRef slice; if (start == NULL && end == NULL) { slice = new ASTSlice(ASTSlice::SLICE0); - } else if (start == NULL) { + } + else if (start == NULL) { slice = new ASTSlice(ASTSlice::SLICE2, start, end); - } else if (end == NULL) { + } + else if (end == NULL) { slice = new ASTSlice(ASTSlice::SLICE1, start, end); - } else { + } + else { slice = new ASTSlice(ASTSlice::SLICE3, start, end); } stack.push(new ASTSubscr(dest, slice)); @@ -2554,28 +2769,32 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) PycRef values = stack.top(); stack.pop(); - if (start.type() == ASTNode::NODE_OBJECT - && start.cast()->object() == Pyc_None) { + if (start.type() == ASTNode::NODE_OBJECT && + start.cast()->object() == Pyc_None) { start = NULL; } - if (end.type() == ASTNode::NODE_OBJECT - && end.cast()->object() == Pyc_None) { + if (end.type() == ASTNode::NODE_OBJECT && + end.cast()->object() == Pyc_None) { end = NULL; } PycRef slice; if (start == NULL && end == NULL) { slice = new ASTSlice(ASTSlice::SLICE0); - } else if (start == NULL) { + } + else if (start == NULL) { slice = new ASTSlice(ASTSlice::SLICE2, start, end); - } else if (end == NULL) { + } + else if (end == NULL) { slice = new ASTSlice(ASTSlice::SLICE1, start, end); - } else { + } + else { slice = new ASTSlice(ASTSlice::SLICE3, start, end); } - curblock->append(new ASTStore(values, new ASTSubscr(dest, slice))); + curblock->append( + new ASTStore(values, new ASTSubscr(dest, slice))); } break; case Pyc::COPY_A: @@ -2585,15 +2804,16 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) } break; default: - fprintf(stderr, "Unsupported opcode: %s (%d)\n", Pyc::OpcodeName(opcode), opcode); + fprintf(stderr, "Unsupported opcode: %s (%d)\n", + Pyc::OpcodeName(opcode), opcode); cleanBuild = false; return new ASTNodeList(defblock->nodes()); } - else_pop = ( (curblock->blktype() == ASTBlock::BLK_ELSE) - || (curblock->blktype() == ASTBlock::BLK_IF) - || (curblock->blktype() == ASTBlock::BLK_ELIF) ) - && (curblock->end() == pos); + else_pop = ((curblock->blktype() == ASTBlock::BLK_ELSE) || + (curblock->blktype() == ASTBlock::BLK_IF) || + (curblock->blktype() == ASTBlock::BLK_ELIF)) && + (curblock->end() == pos); } if (stack_hist.size()) { @@ -2619,14 +2839,15 @@ PycRef BuildFromCode(PycRef code, PycModule* mod) return new ASTNodeList(defblock->nodes()); } -static void append_to_chain_store(const PycRef &chainStore, - PycRef item, FastStack& stack, const PycRef& curblock) +static void append_to_chain_store(const PycRef& chainStore, + PycRef item, FastStack& stack, const PycRef& curblock) { - stack.pop(); // ignore identical source object. + stack.pop(); // ignore identical source object. chainStore.cast()->append(item); if (stack.top().type() == PycObject::TYPE_NULL) { curblock->append(chainStore); - } else { + } + else { stack.push(chainStore); } } @@ -2638,31 +2859,37 @@ static int cmp_prec(PycRef parent, PycRef child) Else we'd have expressions like (((a + b) + c) + d) when therefore equivalent, a + b + c + d would suffice. */ - if (parent.type() == ASTNode::NODE_UNARY && parent.cast()->op() == ASTUnary::UN_NOT) + if (parent.type() == ASTNode::NODE_UNARY && + parent.cast()->op() == ASTUnary::UN_NOT) return 1; // Always parenthesize not(x) if (child.type() == ASTNode::NODE_BINARY) { PycRef binChild = child.cast(); if (parent.type() == ASTNode::NODE_BINARY) { PycRef binParent = parent.cast(); if (binParent->right() == child) { - if (binParent->op() == ASTBinary::BIN_SUBTRACT && - binChild->op() == ASTBinary::BIN_ADD) - return 1; - else if (binParent->op() == ASTBinary::BIN_DIVIDE && - binChild->op() == ASTBinary::BIN_MULTIPLY) + if ((binParent->op() == ASTBinary::BIN_SUBTRACT && + binChild->op() == ASTBinary::BIN_ADD) || + (binParent->op() == ASTBinary::BIN_DIVIDE && + binChild->op() == ASTBinary::BIN_MULTIPLY)) return 1; } return binChild->op() - binParent->op(); } else if (parent.type() == ASTNode::NODE_COMPARE) return (binChild->op() == ASTBinary::BIN_LOG_AND || - binChild->op() == ASTBinary::BIN_LOG_OR) ? 1 : -1; + binChild->op() == ASTBinary::BIN_LOG_OR) + ? 1 + : -1; else if (parent.type() == ASTNode::NODE_UNARY) return (binChild->op() == ASTBinary::BIN_POWER) ? -1 : 1; - } else if (child.type() == ASTNode::NODE_UNARY) { + } + else if (child.type() == ASTNode::NODE_UNARY) { PycRef unChild = child.cast(); if (parent.type() == ASTNode::NODE_BINARY) { PycRef binParent = parent.cast(); + + // NOLINTBEGIN(bugprone-branch-clone)f + // Not sure if reordering the branches could lead to some bugs if (binParent->op() == ASTBinary::BIN_LOG_AND || binParent->op() == ASTBinary::BIN_LOG_OR) return -1; @@ -2672,16 +2899,22 @@ static int cmp_prec(PycRef parent, PycRef child) return 1; else return -1; - } else if (parent.type() == ASTNode::NODE_COMPARE) { + // NOLINTEND(bugprone-branch-clone) + } + else if (parent.type() == ASTNode::NODE_COMPARE) { return (unChild->op() == ASTUnary::UN_NOT) ? 1 : -1; - } else if (parent.type() == ASTNode::NODE_UNARY) { + } + else if (parent.type() == ASTNode::NODE_UNARY) { return unChild->op() - parent.cast()->op(); } - } else if (child.type() == ASTNode::NODE_COMPARE) { + } + else if (child.type() == ASTNode::NODE_COMPARE) { PycRef cmpChild = child.cast(); if (parent.type() == ASTNode::NODE_BINARY) return (parent.cast()->op() == ASTBinary::BIN_LOG_AND || - parent.cast()->op() == ASTBinary::BIN_LOG_OR) ? -1 : 1; + parent.cast()->op() == ASTBinary::BIN_LOG_OR) + ? -1 + : 1; else if (parent.type() == ASTNode::NODE_COMPARE) return cmpChild->op() - parent.cast()->op(); else if (parent.type() == ASTNode::NODE_UNARY) @@ -2693,26 +2926,21 @@ static int cmp_prec(PycRef parent, PycRef child) } static void print_ordered(PycRef parent, PycRef child, - PycModule* mod, std::ostream& pyc_output) + PycModule* mod, std::ostream& pyc_output) { if (child.type() == ASTNode::NODE_BINARY || - child.type() == ASTNode::NODE_COMPARE) { + child.type() == ASTNode::NODE_COMPARE || + child.type() == ASTNode::NODE_UNARY) { if (cmp_prec(parent, child) > 0) { pyc_output << "("; print_src(child, mod, pyc_output); pyc_output << ")"; - } else { - print_src(child, mod, pyc_output); } - } else if (child.type() == ASTNode::NODE_UNARY) { - if (cmp_prec(parent, child) > 0) { - pyc_output << "("; - print_src(child, mod, pyc_output); - pyc_output << ")"; - } else { + else { print_src(child, mod, pyc_output); } - } else { + } + else { print_src(child, mod, pyc_output); } } @@ -2721,7 +2949,7 @@ static void start_line(int indent, std::ostream& pyc_output) { if (inLambda) return; - for (int i=0; i blk, PycModule* mod, - std::ostream& pyc_output) +static void print_block( + PycRef blk, PycModule* mod, std::ostream& pyc_output) { ASTBlock::list_t lines = blk->nodes(); @@ -2755,13 +2983,14 @@ static void print_block(PycRef blk, PycModule* mod, } } -void print_formatted_value(PycRef formatted_value, PycModule* mod, - std::ostream& pyc_output) +void print_formatted_value(PycRef formatted_value, + PycModule* mod, std::ostream& pyc_output) { pyc_output << "{"; print_src(formatted_value->val(), mod, pyc_output); - switch (formatted_value->conversion() & ASTFormattedValue::CONVERSION_MASK) { + switch ( + formatted_value->conversion() & ASTFormattedValue::CONVERSION_MASK) { case ASTFormattedValue::NONE: break; case ASTFormattedValue::STR: @@ -2773,14 +3002,22 @@ void print_formatted_value(PycRef formatted_value, PycModule* case ASTFormattedValue::ASCII: pyc_output << "!a"; break; + default: + // error case + break; } if (formatted_value->conversion() & ASTFormattedValue::HAVE_FMT_SPEC) { - pyc_output << ":" << formatted_value->format_spec().cast()->object().cast()->value(); + pyc_output << ":" + << formatted_value->format_spec() + .cast() + ->object() + .cast() + ->value(); } pyc_output << "}"; } -static std::unordered_set node_seen; +static std::unordered_set node_seen; void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) { @@ -2790,11 +3027,11 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) return; } - if (node_seen.find((ASTNode *)node) != node_seen.end()) { + if (node_seen.find((ASTNode*)node) != node_seen.end()) { fputs("WARNING: Circular reference detected\n", stderr); return; } - node_seen.insert((ASTNode *)node); + node_seen.insert((ASTNode*)node); switch (node->type()) { case ASTNode::NODE_BINARY: @@ -2829,9 +3066,13 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) if (!first) pyc_output << ", "; if (param.first.type() == ASTNode::NODE_NAME) { - pyc_output << param.first.cast()->name()->value() << " = "; - } else { - PycRef str_name = param.first.cast()->object().cast(); + pyc_output << param.first.cast()->name()->value() + << " = "; + } + else { + PycRef str_name = param.first.cast() + ->object() + .cast(); pyc_output << str_name->value() << " = "; } print_src(param.second, mod, pyc_output); @@ -2849,7 +3090,6 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) pyc_output << ", "; pyc_output << "**"; print_src(call->kw(), mod, pyc_output); - first = false; } pyc_output << ")"; } @@ -2870,8 +3110,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) pyc_output << " in "; print_src(exec->globals(), mod, pyc_output); - if (exec->locals() != NULL - && exec->globals() != exec->locals()) { + if (exec->locals() != NULL && + exec->globals() != exec->locals()) { pyc_output << ", "; print_src(exec->locals(), mod, pyc_output); } @@ -2888,15 +3128,18 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) for (const auto& val : node.cast()->values()) { switch (val.type()) { case ASTNode::NODE_FORMATTEDVALUE: - print_formatted_value(val.cast(), mod, pyc_output); + print_formatted_value( + val.cast(), mod, pyc_output); break; case ASTNode::NODE_OBJECT: // When printing a piece of the f-string, keep the quote style consistent. // This avoids problems when ''' or """ is part of the string. - print_const(pyc_output, val.cast()->object(), mod, F_STRING_QUOTE); + print_const(pyc_output, val.cast()->object(), mod, + F_STRING_QUOTE); break; default: - fprintf(stderr, "Unsupported node type %d in NODE_JOINEDSTR\n", val.type()); + fprintf(stderr, "Unsupported node type %d in NODE_JOINEDSTR\n", + val.type()); } } pyc_output << F_STRING_QUOTE; @@ -2983,7 +3226,11 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) case ASTNode::NODE_CONST_MAP: { PycRef const_map = node.cast(); - PycTuple::value_t keys = const_map->keys().cast()->object().cast()->values(); + PycTuple::value_t keys = const_map->keys() + .cast() + ->object() + .cast() + ->values(); ASTConstMap::values_t values = const_map->values(); auto map = new ASTMap; @@ -3028,25 +3275,29 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) } pyc_output << blk->type_str(); - if (blk->blktype() == ASTBlock::BLK_IF - || blk->blktype() == ASTBlock::BLK_ELIF - || blk->blktype() == ASTBlock::BLK_WHILE) { + if (blk->blktype() == ASTBlock::BLK_IF || + blk->blktype() == ASTBlock::BLK_ELIF || + blk->blktype() == ASTBlock::BLK_WHILE) { if (blk.cast()->negative()) pyc_output << " not "; else pyc_output << " "; print_src(blk.cast()->cond(), mod, pyc_output); - } else if (blk->blktype() == ASTBlock::BLK_FOR || blk->blktype() == ASTBlock::BLK_ASYNCFOR) { + } + else if (blk->blktype() == ASTBlock::BLK_FOR || + blk->blktype() == ASTBlock::BLK_ASYNCFOR) { pyc_output << " "; print_src(blk.cast()->index(), mod, pyc_output); pyc_output << " in "; print_src(blk.cast()->iter(), mod, pyc_output); - } else if (blk->blktype() == ASTBlock::BLK_EXCEPT && - blk.cast()->cond() != NULL) { + } + else if (blk->blktype() == ASTBlock::BLK_EXCEPT && + blk.cast()->cond() != NULL) { pyc_output << " "; print_src(blk.cast()->cond(), mod, pyc_output); - } else if (blk->blktype() == ASTBlock::BLK_WITH) { + } + else if (blk->blktype() == ASTBlock::BLK_WITH) { pyc_output << " "; print_src(blk.cast()->expr(), mod, pyc_output); PycRef var = blk.try_cast()->var(); @@ -3068,7 +3319,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) if (obj.type() == PycObject::TYPE_CODE) { PycRef code = obj.cast(); decompyle(code, mod, pyc_output); - } else { + } + else { print_const(pyc_output, obj, mod); } } @@ -3122,7 +3374,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) if (value.type() == ASTNode::NODE_AWAITABLE) { pyc_output << "await "; value = value.cast()->expression(); - } else { + } + else { pyc_output << "yield from "; } break; @@ -3152,7 +3405,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) pyc_output << "from "; if (import->name().type() == ASTNode::NODE_IMPORT) - print_src(import->name().cast()->name(), mod, pyc_output); + print_src(import->name().cast()->name(), mod, + pyc_output); else print_src(import->name(), mod, pyc_output); pyc_output << " import "; @@ -3162,11 +3416,13 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) auto dest = stores.front()->dest(); print_src(src, mod, pyc_output); - if (src.cast()->name()->value() != dest.cast()->name()->value()) { + if (src.cast()->name()->value() != + dest.cast()->name()->value()) { pyc_output << " as "; print_src(dest, mod, pyc_output); } - } else { + } + else { bool first = true; for (const auto& st : stores) { if (!first) @@ -3174,13 +3430,15 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) print_src(st->src(), mod, pyc_output); first = false; - if (st->src().cast()->name()->value() != st->dest().cast()->name()->value()) { + if (st->src().cast()->name()->value() != + st->dest().cast()->name()->value()) { pyc_output << " as "; print_src(st->dest(), mod, pyc_output); } } } - } else { + } + else { pyc_output << "import "; print_src(import->name(), mod, pyc_output); } @@ -3191,12 +3449,14 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) /* Actual named functions are NODE_STORE with a name */ pyc_output << "(lambda "; PycRef code = node.cast()->code(); - PycRef code_src = code.cast()->object().cast(); + PycRef code_src = + code.cast()->object().cast(); ASTFunction::defarg_t defargs = node.cast()->defargs(); - ASTFunction::defarg_t kwdefargs = node.cast()->kwdefargs(); + ASTFunction::defarg_t kwdefargs = + node.cast()->kwdefargs(); auto da = defargs.cbegin(); int narg = 0; - for (int i=0; iargCount(); i++) { + for (int i = 0; i < code_src->argCount(); i++) { if (narg) pyc_output << ", "; pyc_output << code_src->getLocal(narg++)->value(); @@ -3211,7 +3471,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) for (int i = 0; i < code_src->argCount(); i++) { pyc_output << ", "; pyc_output << code_src->getLocal(narg++)->value(); - if ((code_src->kwOnlyArgCount() - i) <= (int)kwdefargs.size()) { + if ((code_src->kwOnlyArgCount() - i) <= + (int)kwdefargs.size()) { pyc_output << " = "; print_src(*da++, mod, pyc_output); } @@ -3232,7 +3493,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) PycRef dest = node.cast()->dest(); if (src.type() == ASTNode::NODE_FUNCTION) { PycRef code = src.cast()->code(); - PycRef code_src = code.cast()->object().cast(); + PycRef code_src = + code.cast()->object().cast(); bool isLambda = false; if (strcmp(code_src->name()->value(), "") == 0) { @@ -3241,7 +3503,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) print_src(dest, mod, pyc_output); pyc_output << " = lambda "; isLambda = true; - } else { + } + else { pyc_output << "\n"; start_line(cur_indent, pyc_output); if (code_src->flags() & PycCode::CO_COROUTINE) @@ -3251,8 +3514,10 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) pyc_output << "("; } - ASTFunction::defarg_t defargs = src.cast()->defargs(); - ASTFunction::defarg_t kwdefargs = src.cast()->kwdefargs(); + ASTFunction::defarg_t defargs = + src.cast()->defargs(); + ASTFunction::defarg_t kwdefargs = + src.cast()->kwdefargs(); auto da = defargs.cbegin(); int narg = 0; for (int i = 0; i < code_src->argCount(); ++i) { @@ -3270,7 +3535,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) for (int i = 0; i < code_src->kwOnlyArgCount(); ++i) { pyc_output << ", "; pyc_output << code_src->getLocal(narg++)->value(); - if ((code_src->kwOnlyArgCount() - i) <= (int)kwdefargs.size()) { + if ((code_src->kwOnlyArgCount() - i) <= + (int)kwdefargs.size()) { pyc_output << " = "; print_src(*da++, mod, pyc_output); } @@ -3289,7 +3555,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) if (isLambda) { pyc_output << ": "; - } else { + } + else { pyc_output << "):\n"; printDocstringAndGlobals = true; } @@ -3300,12 +3567,14 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) print_src(code, mod, pyc_output); inLambda = preLambda; - } else if (src.type() == ASTNode::NODE_CLASS) { + } + else if (src.type() == ASTNode::NODE_CLASS) { pyc_output << "\n"; start_line(cur_indent, pyc_output); pyc_output << "class "; print_src(dest, mod, pyc_output); - PycRef bases = src.cast()->bases().cast(); + PycRef bases = + src.cast()->bases().cast(); if (bases->values().size() > 0) { pyc_output << "("; bool first = true; @@ -3316,54 +3585,71 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) first = false; } pyc_output << "):\n"; - } else { + } + else { // Don't put parens if there are no base classes pyc_output << ":\n"; } printClassDocstring = true; - PycRef code = src.cast()->code().cast() - ->func().cast()->code(); + PycRef code = src.cast() + ->code() + .cast() + ->func() + .cast() + ->code(); print_src(code, mod, pyc_output); - } else if (src.type() == ASTNode::NODE_IMPORT) { + } + else if (src.type() == ASTNode::NODE_IMPORT) { PycRef import = src.cast(); if (import->fromlist() != NULL) { - PycRef fromlist = import->fromlist().cast()->object(); + PycRef fromlist = + import->fromlist().cast()->object(); if (fromlist != Pyc_None) { pyc_output << "from "; if (import->name().type() == ASTNode::NODE_IMPORT) - print_src(import->name().cast()->name(), mod, pyc_output); + print_src(import->name().cast()->name(), + mod, pyc_output); else print_src(import->name(), mod, pyc_output); pyc_output << " import "; if (fromlist.type() == PycObject::TYPE_TUPLE || - fromlist.type() == PycObject::TYPE_SMALL_TUPLE) { + fromlist.type() == PycObject::TYPE_SMALL_TUPLE) { bool first = true; - for (const auto& val : fromlist.cast()->values()) { + for (const auto& val : + fromlist.cast()->values()) { if (!first) pyc_output << ", "; pyc_output << val.cast()->value(); first = false; } - } else { + } + else { pyc_output << fromlist.cast()->value(); } - } else { + } + else { pyc_output << "import "; print_src(import->name(), mod, pyc_output); } - } else { + } + else { pyc_output << "import "; PycRef import_name = import->name(); print_src(import_name, mod, pyc_output); - if (!dest.cast()->name()->isEqual(import_name.cast()->name().cast())) { + if (!dest.cast()->name()->isEqual( + import_name.cast() + ->name() + .cast())) { pyc_output << " as "; print_src(dest, mod, pyc_output); } } - } else if (src.type() == ASTNode::NODE_BINARY - && src.cast()->is_inplace()) { + } + else if (src.type() == ASTNode::NODE_BINARY && + src.cast()->is_inplace()) { print_src(src, mod, pyc_output); - } else { + } + else { print_src(dest, mod, pyc_output); pyc_output << " = "; print_src(src, mod, pyc_output); @@ -3415,7 +3701,8 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) break; case ASTNode::NODE_ANNOTATED_VAR: { - PycRef annotated_var = node.cast(); + PycRef annotated_var = + node.cast(); PycRef name = annotated_var->name().cast(); PycRef annotation = annotated_var->annotation(); @@ -3427,15 +3714,15 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) case ASTNode::NODE_TERNARY: { /* parenthesis might be needed - * + * * when if-expr is part of numerical expression, ternary has the LOWEST precedence * print(a + b if False else c) * output is c, not a+c (a+b is calculated first) - * + * * but, let's not add parenthesis - to keep the source as close to original as possible in most cases */ PycRef ternary = node.cast(); - //pyc_output << "("; + // pyc_output << "("; print_src(ternary->if_expr(), mod, pyc_output); const auto if_block = ternary->if_block().cast(); pyc_output << " if "; @@ -3444,23 +3731,23 @@ void print_src(PycRef node, PycModule* mod, std::ostream& pyc_output) print_src(if_block->cond(), mod, pyc_output); pyc_output << " else "; print_src(ternary->else_expr(), mod, pyc_output); - //pyc_output << ")"; + // pyc_output << ")"; } break; default: pyc_output << "type() << ">"; fprintf(stderr, "Unsupported Node type: %d\n", node->type()); cleanBuild = false; - node_seen.erase((ASTNode *)node); + node_seen.erase((ASTNode*)node); return; } cleanBuild = true; - node_seen.erase((ASTNode *)node); + node_seen.erase((ASTNode*)node); } -bool print_docstring(PycRef obj, int indent, PycModule* mod, - std::ostream& pyc_output) +bool print_docstring( + PycRef obj, int indent, PycModule* mod, std::ostream& pyc_output) { // docstrings are translated from the bytecode __doc__ = 'string' to simply '''string''' auto doc = obj.try_cast(); @@ -3473,15 +3760,15 @@ bool print_docstring(PycRef obj, int indent, PycModule* mod, return false; } -static std::unordered_set code_seen; +static std::unordered_set code_seen; void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) { - if (code_seen.find((PycCode *)code) != code_seen.end()) { + if (code_seen.find((PycCode*)code) != code_seen.end()) { fputs("WARNING: Circular reference detected\n", stderr); return; } - code_seen.insert((PycCode *)code); + code_seen.insert((PycCode*)code); PycRef source = BuildFromCode(code, mod); @@ -3493,12 +3780,12 @@ void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) // if the cleaned up code is empty if (clean->nodes().front().type() == ASTNode::NODE_STORE) { PycRef store = clean->nodes().front().cast(); - if (store->src().type() == ASTNode::NODE_NAME - && store->dest().type() == ASTNode::NODE_NAME) { + if (store->src().type() == ASTNode::NODE_NAME && + store->dest().type() == ASTNode::NODE_NAME) { PycRef src = store->src().cast(); PycRef dest = store->dest().cast(); - if (src->name()->isEqual("__name__") - && dest->name()->isEqual("__module__")) { + if (src->name()->isEqual("__name__") && + dest->name()->isEqual("__module__")) { // __module__ = __name__ // Automatically added by Python 2.2.1 and later clean->removeFirst(); @@ -3507,10 +3794,11 @@ void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) } if (clean->nodes().front().type() == ASTNode::NODE_STORE) { PycRef store = clean->nodes().front().cast(); - if (store->src().type() == ASTNode::NODE_OBJECT - && store->dest().type() == ASTNode::NODE_NAME) { + if (store->src().type() == ASTNode::NODE_OBJECT && + store->dest().type() == ASTNode::NODE_NAME) { PycRef src = store->src().cast(); - PycRef srcString = src->object().try_cast(); + PycRef srcString = + src->object().try_cast(); PycRef dest = store->dest().cast(); if (dest->name()->isEqual("__qualname__")) { // __qualname__ = '' @@ -3521,13 +3809,16 @@ void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) } // Class and module docstrings may only appear at the beginning of their source - if (printClassDocstring && clean->nodes().front().type() == ASTNode::NODE_STORE) { + if (printClassDocstring && + clean->nodes().front().type() == ASTNode::NODE_STORE) { PycRef store = clean->nodes().front().cast(); if (store->dest().type() == ASTNode::NODE_NAME && - store->dest().cast()->name()->isEqual("__doc__") && - store->src().type() == ASTNode::NODE_OBJECT) { + store->dest().cast()->name()->isEqual("__doc__") && + store->src().type() == ASTNode::NODE_OBJECT) { if (print_docstring(store->src().cast()->object(), - cur_indent + (code->name()->isEqual("") ? 0 : 1), mod, pyc_output)) + cur_indent + + (code->name()->isEqual("") ? 0 : 1), + mod, pyc_output)) clean->removeFirst(); } } @@ -3535,9 +3826,10 @@ void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) PycRef ret = clean->nodes().back().cast(); PycRef retObj = ret->value().try_cast(); - if (ret->value() == NULL || ret->value().type() == ASTNode::NODE_LOCALS || - (retObj && retObj->object().type() == PycObject::TYPE_NONE)) { - clean->removeLast(); // Always an extraneous return statement + if (ret->value() == NULL || + ret->value().type() == ASTNode::NODE_LOCALS || + (retObj && retObj->object().type() == PycObject::TYPE_NONE)) { + clean->removeLast(); // Always an extraneous return statement } } } @@ -3577,5 +3869,5 @@ void decompyle(PycRef code, PycModule* mod, std::ostream& pyc_output) pyc_output << "# WARNING: Decompyle incomplete\n"; } - code_seen.erase((PycCode *)code); + code_seen.erase((PycCode*)code); } diff --git a/ASTree.h b/ASTree.h index 75ed7a17b..f42f0bdcc 100644 --- a/ASTree.h +++ b/ASTree.h @@ -1,5 +1,5 @@ -#ifndef _PYC_ASTREE_H -#define _PYC_ASTREE_H +#ifndef PYC_ASTREE_H +#define PYC_ASTREE_H #include "ASTNode.h" diff --git a/CMakeLists.txt b/CMakeLists.txt index 476c96438..50f00cc57 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ project(pycdc) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) -# Debug options. +# Debug options option(ENABLE_BLOCK_DEBUG "Enable block debugging" OFF) option(ENABLE_STACK_DEBUG "Enable stack debugging" OFF) @@ -16,16 +16,15 @@ if (ENABLE_STACK_DEBUG) add_definitions(-DSTACK_DEBUG) endif() -if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") - set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wno-error=shadow -Werror ${CMAKE_CXX_FLAGS}") +# Compiler warnings +if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang") + add_compile_options(-Wall -Wextra -Werror -Wno-error=shadow) elseif(MSVC) - set(CMAKE_CXX_FLAGS "/WX ${CMAKE_CXX_FLAGS}") + add_compile_options(/WX) add_definitions(-D_CRT_SECURE_NO_WARNINGS) endif() -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) - -add_library(pycxx STATIC +file(GLOB SRC_LIB_CPP CONFIGURE_DEPENDS bytecode.cpp data.cpp pyc_code.cpp @@ -34,47 +33,91 @@ add_library(pycxx STATIC pyc_object.cpp pyc_sequence.cpp pyc_string.cpp - bytes/python_1_0.cpp - bytes/python_1_1.cpp - bytes/python_1_3.cpp - bytes/python_1_4.cpp - bytes/python_1_5.cpp - bytes/python_1_6.cpp - bytes/python_2_0.cpp - bytes/python_2_1.cpp - bytes/python_2_2.cpp - bytes/python_2_3.cpp - bytes/python_2_4.cpp - bytes/python_2_5.cpp - bytes/python_2_6.cpp - bytes/python_2_7.cpp - bytes/python_3_0.cpp - bytes/python_3_1.cpp - bytes/python_3_2.cpp - bytes/python_3_3.cpp - bytes/python_3_4.cpp - bytes/python_3_5.cpp - bytes/python_3_6.cpp - bytes/python_3_7.cpp - bytes/python_3_8.cpp - bytes/python_3_9.cpp - bytes/python_3_10.cpp - bytes/python_3_11.cpp - bytes/python_3_12.cpp - bytes/python_3_13.cpp + bytes/*.cpp +) + +file(GLOB SRC_MAIN CONFIGURE_DEPENDS + *.h + bytes/*.h + pycdas.cpp + pycdc.cpp + ASTree.cpp + ASTNode.cpp + ${SRC_LIB_CPP}) + +file(GLOB SRC_ALL CONFIGURE_DEPENDS + bytecode_ops.inl # This file does not contain compilable code + ${SRC_MAIN} +) + +# Enable/disable targets/tools +option(ENABLE_CLANG_FORMAT "Provide `format` and `format-check` targets using clang-format" ON) +option(ENABLE_CLANG_TIDY "Provide `tidy-all` target using clang-tidy" ON) + +# Export compile commands for clang-tidy / language servers +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +if(ENABLE_CLANG_FORMAT) + find_program(CLANG_FORMAT_EXECUTABLE + NAMES clang-format + ) + if(CLANG_FORMAT_EXECUTABLE) + add_custom_target(format + COMMAND ${CLANG_FORMAT_EXECUTABLE} -style=file -i ${SRC_ALL} + COMMENT "Running clang-format on project sources" + VERBATIM + ) + + add_custom_target(format-check + COMMAND ${CLANG_FORMAT_EXECUTABLE} -style=file --dry-run -Werror ${SRC_ALL} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + COMMENT "Checking clang-format (non-zero exit if formatting required)" + VERBATIM + USES_TERMINAL # Enables propagating error code + ) + endif() +endif() + +if(ENABLE_CLANG_TIDY) + find_program(CLANG_TIDY_EXECUTABLE + NAMES clang-tidy + ) + if(CLANG_TIDY_EXECUTABLE) + # Minimal clang-tidy wrapper. Adjust checks in your .clang-tidy file. + # Semicolon-separated list is required by CMake for the wrapper. + set(CMAKE_CXX_CLANG_TIDY + "${CLANG_TIDY_EXECUTABLE};-p=${CMAKE_BINARY_DIR}" + ) + # If you prefer to apply clang-tidy to specific targets only, remove the + # global set above and use set_target_properties(... CXX_CLANG_TIDY ...) + # Create a custom target to run clang-tidy over main sources + add_custom_target(tidy-all + COMMAND ${CLANG_TIDY_EXECUTABLE} -p ${CMAKE_BINARY_DIR} ${SRC_MAIN} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + COMMENT "Running clang-tidy on project sources" + VERBATIM + ) + endif() +endif() + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +# Library +add_library(pycxx STATIC + ${SRC_LIB_CPP} ) +# Executable: pycdas add_executable(pycdas pycdas.cpp) -target_link_libraries(pycdas pycxx) +target_link_libraries(pycdas PRIVATE pycxx) -install(TARGETS pycdas - RUNTIME DESTINATION bin) +install(TARGETS pycdas RUNTIME DESTINATION bin) +# Executable: pycdc add_executable(pycdc pycdc.cpp ASTree.cpp ASTNode.cpp) -target_link_libraries(pycdc pycxx) +target_link_libraries(pycdc PRIVATE pycxx) -install(TARGETS pycdc - RUNTIME DESTINATION bin) +install(TARGETS pycdc RUNTIME DESTINATION bin) find_package(Python3 3.6 COMPONENTS Interpreter) if(Python3_FOUND) diff --git a/FastStack.h b/FastStack.h index b91ec71de..364a47e3f 100644 --- a/FastStack.h +++ b/FastStack.h @@ -1,5 +1,5 @@ -#ifndef _PYC_FASTSTACK_H -#define _PYC_FASTSTACK_H +#ifndef PYC_FASTSTACK_H +#define PYC_FASTSTACK_H #include "ASTNode.h" #include @@ -8,8 +8,9 @@ class FastStack { public: FastStack(int size) : m_ptr(-1) { m_stack.resize(size); } - FastStack(const FastStack& copy) - : m_stack(copy.m_stack), m_ptr(copy.m_ptr) { } + FastStack(const FastStack& copy) : m_stack(copy.m_stack), m_ptr(copy.m_ptr) + { + } FastStack& operator=(const FastStack& copy) { @@ -31,9 +32,9 @@ class FastStack { if (m_ptr > -1) m_stack[m_ptr--] = nullptr; else { - #ifdef BLOCK_DEBUG - fprintf(stderr, "pop from empty stack\n"); - #endif +#ifdef BLOCK_DEBUG + fprintf(stderr, "pop from empty stack\n"); +#endif } } @@ -44,9 +45,9 @@ class FastStack { if ((m_ptr > -1) && (idx >= 0)) return m_stack[idx]; else { - #ifdef BLOCK_DEBUG - fprintf(stderr, "insufficient values on stack\n"); - #endif +#ifdef BLOCK_DEBUG + fprintf(stderr, "insufficient values on stack\n"); +#endif return nullptr; } } @@ -56,10 +57,7 @@ class FastStack { } } - bool empty() const - { - return m_ptr == -1; - } + bool empty() const { return m_ptr == -1; } private: std::vector> m_stack; diff --git a/bytecode.cpp b/bytecode.cpp index 6bee27994..1d24b1454 100644 --- a/bytecode.cpp +++ b/bytecode.cpp @@ -1,15 +1,14 @@ -#include "pyc_numeric.h" #include "bytecode.h" -#include -#include +#include "pyc_numeric.h" #include +#include +#include #ifdef _MSC_VER -#define snprintf _snprintf + #define snprintf _snprintf #endif -#define DECLARE_PYTHON(maj, min) \ - extern int python_##maj##_##min##_map(int); +#define DECLARE_PYTHON(maj, min) extern int python_##maj##_##min##_map(int); DECLARE_PYTHON(1, 0) DECLARE_PYTHON(1, 1) @@ -43,18 +42,19 @@ DECLARE_PYTHON(3, 13) const char* Pyc::OpcodeName(int opcode) { static const char* opcode_names[] = { - #define OPCODE(x) #x, - #define OPCODE_A_FIRST(x) #x, - #define OPCODE_A(x) #x, - #include "bytecode_ops.inl" - #undef OPCODE_A - #undef OPCODE_A_FIRST - #undef OPCODE +#define OPCODE(x) #x, +#define OPCODE_A_FIRST(x) #x, +#define OPCODE_A(x) #x, +#include "bytecode_ops.inl" +#undef OPCODE_A +#undef OPCODE_A_FIRST +#undef OPCODE }; #if __cplusplus >= 201103L - static_assert(sizeof(opcode_names) / sizeof(opcode_names[0]) == PYC_LAST_OPCODE, - "Pyc::OpcodeName opcode_names not in sync with opcode enum"); + static_assert( + sizeof(opcode_names) / sizeof(opcode_names[0]) == PYC_LAST_OPCODE, + "Pyc::OpcodeName opcode_names not in sync with opcode enum"); #endif if (opcode < 0) @@ -73,50 +73,86 @@ int Pyc::ByteToOpcode(int maj, int min, int opcode) switch (maj) { case 1: switch (min) { - case 0: return python_1_0_map(opcode); - case 1: return python_1_1_map(opcode); - case 3: return python_1_3_map(opcode); - case 4: return python_1_4_map(opcode); - case 5: return python_1_5_map(opcode); - case 6: return python_1_6_map(opcode); + case 0: + return python_1_0_map(opcode); + case 1: + return python_1_1_map(opcode); + case 3: + return python_1_3_map(opcode); + case 4: + return python_1_4_map(opcode); + case 5: + return python_1_5_map(opcode); + case 6: + return python_1_6_map(opcode); + default: + break; } break; case 2: switch (min) { - case 0: return python_2_0_map(opcode); - case 1: return python_2_1_map(opcode); - case 2: return python_2_2_map(opcode); - case 3: return python_2_3_map(opcode); - case 4: return python_2_4_map(opcode); - case 5: return python_2_5_map(opcode); - case 6: return python_2_6_map(opcode); - case 7: return python_2_7_map(opcode); + case 0: + return python_2_0_map(opcode); + case 1: + return python_2_1_map(opcode); + case 2: + return python_2_2_map(opcode); + case 3: + return python_2_3_map(opcode); + case 4: + return python_2_4_map(opcode); + case 5: + return python_2_5_map(opcode); + case 6: + return python_2_6_map(opcode); + case 7: + return python_2_7_map(opcode); + default: + break; } break; case 3: switch (min) { - case 0: return python_3_0_map(opcode); - case 1: return python_3_1_map(opcode); - case 2: return python_3_2_map(opcode); - case 3: return python_3_3_map(opcode); - case 4: return python_3_4_map(opcode); - case 5: return python_3_5_map(opcode); - case 6: return python_3_6_map(opcode); - case 7: return python_3_7_map(opcode); - case 8: return python_3_8_map(opcode); - case 9: return python_3_9_map(opcode); - case 10: return python_3_10_map(opcode); - case 11: return python_3_11_map(opcode); - case 12: return python_3_12_map(opcode); - case 13: return python_3_13_map(opcode); + case 0: + return python_3_0_map(opcode); + case 1: + return python_3_1_map(opcode); + case 2: + return python_3_2_map(opcode); + case 3: + return python_3_3_map(opcode); + case 4: + return python_3_4_map(opcode); + case 5: + return python_3_5_map(opcode); + case 6: + return python_3_6_map(opcode); + case 7: + return python_3_7_map(opcode); + case 8: + return python_3_8_map(opcode); + case 9: + return python_3_9_map(opcode); + case 10: + return python_3_10_map(opcode); + case 11: + return python_3_11_map(opcode); + case 12: + return python_3_12_map(opcode); + case 13: + return python_3_13_map(opcode); + default: + break; } break; + default: + break; } return PYC_INVALID_OPCODE; } -void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod, - const char* parent_f_string_quote) +void print_const(std::ostream& pyc_output, PycRef obj, + PycModule* mod, const char* parent_f_string_quote) { if (obj == NULL) { pyc_output << ""; @@ -131,7 +167,8 @@ void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod case PycObject::TYPE_ASCII_INTERNED: case PycObject::TYPE_SHORT_ASCII: case PycObject::TYPE_SHORT_ASCII_INTERNED: - obj.cast()->print(pyc_output, mod, false, parent_f_string_quote); + obj.cast()->print( + pyc_output, mod, false, parent_f_string_quote); break; case PycObject::TYPE_TUPLE: case PycObject::TYPE_SMALL_TUPLE: @@ -232,14 +269,15 @@ void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod formatted_print(pyc_output, "%d", obj.cast()->value()); break; case PycObject::TYPE_LONG: - formatted_print(pyc_output, "%s", obj.cast()->repr(mod).c_str()); + formatted_print( + pyc_output, "%s", obj.cast()->repr(mod).c_str()); break; case PycObject::TYPE_FLOAT: formatted_print(pyc_output, "%s", obj.cast()->value()); break; case PycObject::TYPE_COMPLEX: formatted_print(pyc_output, "(%s+%sj)", obj.cast()->value(), - obj.cast()->imag()); + obj.cast()->imag()); break; case PycObject::TYPE_BINARY_FLOAT: { @@ -249,23 +287,27 @@ void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod if (std::isnan(value)) { if (is_negative) { pyc_output << "float('-nan')"; - } else { + } + else { pyc_output << "float('nan')"; } - } else if (std::isinf(value)) { + } + else if (std::isinf(value)) { if (is_negative) { pyc_output << "float('-inf')"; - } else { + } + else { pyc_output << "float('inf')"; } - } else { + } + else { formatted_print(pyc_output, "%g", value); } } break; case PycObject::TYPE_BINARY_COMPLEX: - formatted_print(pyc_output, "(%g+%gj)", obj.cast()->value(), - obj.cast()->imag()); + formatted_print(pyc_output, "(%g+%gj)", + obj.cast()->value(), obj.cast()->imag()); break; case PycObject::TYPE_CODE: case PycObject::TYPE_CODE2: @@ -276,23 +318,28 @@ void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod } } -void bc_next(PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& pos) +void bc_next( + PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& pos) { - opcode = Pyc::ByteToOpcode(mod->majorVer(), mod->minorVer(), source.getByte()); + opcode = + Pyc::ByteToOpcode(mod->majorVer(), mod->minorVer(), source.getByte()); if (mod->verCompare(3, 6) >= 0) { operand = source.getByte(); pos += 2; if (opcode == Pyc::EXTENDED_ARG_A) { - opcode = Pyc::ByteToOpcode(mod->majorVer(), mod->minorVer(), source.getByte()); + opcode = Pyc::ByteToOpcode( + mod->majorVer(), mod->minorVer(), source.getByte()); operand = (operand << 8) | source.getByte(); pos += 2; } - } else { + } + else { operand = 0; pos += 1; if (opcode == Pyc::EXTENDED_ARG_A) { operand = source.get16() << 16; - opcode = Pyc::ByteToOpcode(mod->majorVer(), mod->minorVer(), source.getByte()); + opcode = Pyc::ByteToOpcode( + mod->majorVer(), mod->minorVer(), source.getByte()); pos += 3; } if (opcode >= Pyc::PYC_HAVE_ARG) { @@ -303,40 +350,80 @@ void bc_next(PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& } void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, - int indent, unsigned flags) + int indent, unsigned flags) { - static const char *cmp_strings[] = { - "<", "<=", "==", "!=", ">", ">=", "in", "not in", "is", "is not", - "", "" - }; - static const size_t cmp_strings_len = sizeof(cmp_strings) / sizeof(cmp_strings[0]); + static const char* cmp_strings[] = { "<", "<=", "==", "!=", ">", ">=", "in", + "not in", "is", "is not", "", "" }; + static const size_t cmp_strings_len = + sizeof(cmp_strings) / sizeof(cmp_strings[0]); - static const char *binop_strings[] = { - "+", "&", "//", "<<", "@", "*", "%", "|", "**", ">>", "-", "/", "^", - "+=", "&=", "//=", "<<=", "@=", "*=", "%=", "|=", "**=", ">>=", "-=", "/=", "^=", + static const char* binop_strings[] = { + "+", + "&", + "//", + "<<", + "@", + "*", + "%", + "|", + "**", + ">>", + "-", + "/", + "^", + "+=", + "&=", + "//=", + "<<=", + "@=", + "*=", + "%=", + "|=", + "**=", + ">>=", + "-=", + "/=", + "^=", }; - static const size_t binop_strings_len = sizeof(binop_strings) / sizeof(binop_strings[0]); + static const size_t binop_strings_len = + sizeof(binop_strings) / sizeof(binop_strings[0]); - static const char *intrinsic1_names[] = { - "INTRINSIC_1_INVALID", "INTRINSIC_PRINT", "INTRINSIC_IMPORT_STAR", - "INTRINSIC_STOPITERATION_ERROR", "INTRINSIC_ASYNC_GEN_WRAP", - "INTRINSIC_UNARY_POSITIVE", "INTRINSIC_LIST_TO_TUPLE", "INTRINSIC_TYPEVAR", - "INTRINSIC_PARAMSPEC", "INTRINSIC_TYPEVARTUPLE", - "INTRINSIC_SUBSCRIPT_GENERIC", "INTRINSIC_TYPEALIAS", + static const char* intrinsic1_names[] = { + "INTRINSIC_1_INVALID", + "INTRINSIC_PRINT", + "INTRINSIC_IMPORT_STAR", + "INTRINSIC_STOPITERATION_ERROR", + "INTRINSIC_ASYNC_GEN_WRAP", + "INTRINSIC_UNARY_POSITIVE", + "INTRINSIC_LIST_TO_TUPLE", + "INTRINSIC_TYPEVAR", + "INTRINSIC_PARAMSPEC", + "INTRINSIC_TYPEVARTUPLE", + "INTRINSIC_SUBSCRIPT_GENERIC", + "INTRINSIC_TYPEALIAS", }; - static const size_t intrinsic1_names_len = sizeof(intrinsic1_names) / sizeof(intrinsic1_names[0]); + static const size_t intrinsic1_names_len = + sizeof(intrinsic1_names) / sizeof(intrinsic1_names[0]); - static const char *intrinsic2_names[] = { - "INTRINSIC_2_INVALID", "INTRINSIC_PREP_RERAISE_STAR", - "INTRINSIC_TYPEVAR_WITH_BOUND", "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS", - "INTRINSIC_SET_FUNCTION_TYPE_PARAMS", "INTRINSIC_SET_TYPEPARAM_DEFAULT", + static const char* intrinsic2_names[] = { + "INTRINSIC_2_INVALID", + "INTRINSIC_PREP_RERAISE_STAR", + "INTRINSIC_TYPEVAR_WITH_BOUND", + "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS", + "INTRINSIC_SET_FUNCTION_TYPE_PARAMS", + "INTRINSIC_SET_TYPEPARAM_DEFAULT", }; - static const size_t intrinsic2_names_len = sizeof(intrinsic2_names) / sizeof(intrinsic2_names[0]); + static const size_t intrinsic2_names_len = + sizeof(intrinsic2_names) / sizeof(intrinsic2_names[0]); - static const char *format_value_names[] = { - "FVC_NONE", "FVC_STR", "FVC_REPR", "FVC_ASCII", + static const char* format_value_names[] = { + "FVC_NONE", + "FVC_STR", + "FVC_REPR", + "FVC_ASCII", }; - static const size_t format_value_names_len = sizeof(format_value_names) / sizeof(format_value_names[0]); + static const size_t format_value_names_len = + sizeof(format_value_names) / sizeof(format_value_names[0]); PycBuffer source(code->code()->value(), code->code()->length()); @@ -348,9 +435,10 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, if (opcode == Pyc::CACHE && (flags & Pyc::DISASM_SHOW_CACHES) == 0) continue; - for (int i=0; i= Pyc::PYC_HAVE_ARG) { switch (opcode) { @@ -363,7 +451,7 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, auto constParam = code->getConst(operand); formatted_print(pyc_output, "%d: ", operand); print_const(pyc_output, constParam, mod); - } catch (const std::out_of_range &) { + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -372,13 +460,17 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, // Special case for Python 3.11+ if (mod->verCompare(3, 11) >= 0) { if (operand & 1) - formatted_print(pyc_output, "%d: NULL + %s", operand, code->getName(operand >> 1)->value()); + formatted_print(pyc_output, "%d: NULL + %s", + operand, code->getName(operand >> 1)->value()); else - formatted_print(pyc_output, "%d: %s", operand, code->getName(operand >> 1)->value()); - } else { - formatted_print(pyc_output, "%d: %s", operand, code->getName(operand)->value()); + formatted_print(pyc_output, "%d: %s", operand, + code->getName(operand >> 1)->value()); } - } catch (const std::out_of_range &) { + else { + formatted_print(pyc_output, "%d: %s", operand, + code->getName(operand)->value()); + } + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -398,18 +490,21 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::LOAD_FROM_DICT_OR_GLOBALS_A: try { auto arg = operand; - if (opcode == Pyc::LOAD_ATTR_A && mod->verCompare(3, 12) >= 0) + if (opcode == Pyc::LOAD_ATTR_A && + mod->verCompare(3, 12) >= 0) arg >>= 1; - formatted_print(pyc_output, "%d: %s", operand, code->getName(arg)->value()); - } catch (const std::out_of_range &) { + formatted_print(pyc_output, "%d: %s", operand, + code->getName(arg)->value()); + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; case Pyc::LOAD_SUPER_ATTR_A: case Pyc::INSTRUMENTED_LOAD_SUPER_ATTR_A: try { - formatted_print(pyc_output, "%d: %s", operand, code->getName(operand >> 2)->value()); - } catch (const std::out_of_range &) { + formatted_print(pyc_output, "%d: %s", operand, + code->getName(operand >> 2)->value()); + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -419,8 +514,9 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::LOAD_FAST_CHECK_A: case Pyc::LOAD_FAST_AND_CLEAR_A: try { - formatted_print(pyc_output, "%d: %s", operand, code->getLocal(operand)->value()); - } catch (const std::out_of_range &) { + formatted_print(pyc_output, "%d: %s", operand, + code->getLocal(operand)->value()); + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -429,9 +525,9 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::STORE_FAST_STORE_FAST_A: try { formatted_print(pyc_output, "%d: %s, %s", operand, - code->getLocal(operand >> 4)->value(), - code->getLocal(operand & 0xF)->value()); - } catch (const std::out_of_range &) { + code->getLocal(operand >> 4)->value(), + code->getLocal(operand & 0xF)->value()); + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -443,8 +539,9 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::CALL_FINALLY_A: case Pyc::LOAD_FROM_DICT_OR_DEREF_A: try { - formatted_print(pyc_output, "%d: %s", operand, code->getCellVar(mod, operand)->value()); - } catch (const std::out_of_range &) { + formatted_print(pyc_output, "%d: %s", operand, + code->getCellVar(mod, operand)->value()); + } catch (const std::out_of_range&) { formatted_print(pyc_output, "%d ", operand); } break; @@ -478,8 +575,9 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, See TODO @ END_FOR ASTree.cpp */ int offs = operand; if (mod->verCompare(3, 10) >= 0) - offs *= sizeof(uint16_t); // BPO-27129 - formatted_print(pyc_output, "%d (to %d)", operand, pos+offs); + offs *= sizeof(uint16_t); // BPO-27129 + formatted_print( + pyc_output, "%d (to %d)", operand, pos + offs); } break; case Pyc::JUMP_BACKWARD_NO_INTERRUPT_A: @@ -491,8 +589,10 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::INSTRUMENTED_JUMP_BACKWARD_A: { // BACKWARD jumps were only introduced in Python 3.11 - int offs = operand * sizeof(uint16_t); // BPO-27129 - formatted_print(pyc_output, "%d (to %d)", operand, pos-offs); + int offs = static_cast( + operand * sizeof(uint16_t)); // BPO-27129 + formatted_print( + pyc_output, "%d (to %d)", operand, pos - offs); } break; case Pyc::POP_JUMP_IF_FALSE_A: @@ -503,13 +603,16 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, case Pyc::JUMP_IF_NOT_EXC_MATCH_A: if (mod->verCompare(3, 12) >= 0) { // These are now relative as well - int offs = operand * sizeof(uint16_t); - formatted_print(pyc_output, "%d (to %d)", operand, pos+offs); - } else if (mod->verCompare(3, 10) >= 0) { + int offs = static_cast(operand * sizeof(uint16_t)); + formatted_print( + pyc_output, "%d (to %d)", operand, pos + offs); + } + else if (mod->verCompare(3, 10) >= 0) { // BPO-27129 formatted_print(pyc_output, "%d (to %d)", operand, - int(operand * sizeof(uint16_t))); - } else { + int(operand * sizeof(uint16_t))); + } + else { formatted_print(pyc_output, "%d", operand); } break; @@ -517,58 +620,67 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, { auto arg = operand; if (mod->verCompare(3, 12) == 0) - arg >>= 4; // changed under GH-100923 + arg >>= 4; // changed under GH-100923 else if (mod->verCompare(3, 13) >= 0) arg >>= 5; if (static_cast(arg) < cmp_strings_len) - formatted_print(pyc_output, "%d (%s)", operand, cmp_strings[arg]); + formatted_print( + pyc_output, "%d (%s)", operand, cmp_strings[arg]); else formatted_print(pyc_output, "%d (UNKNOWN)", operand); } break; case Pyc::BINARY_OP_A: if (static_cast(operand) < binop_strings_len) - formatted_print(pyc_output, "%d (%s)", operand, binop_strings[operand]); + formatted_print( + pyc_output, "%d (%s)", operand, binop_strings[operand]); else formatted_print(pyc_output, "%d (UNKNOWN)", operand); break; case Pyc::IS_OP_A: - formatted_print(pyc_output, "%d (%s)", operand, (operand == 0) ? "is" - : (operand == 1) ? "is not" - : "UNKNOWN"); + formatted_print(pyc_output, "%d (%s)", operand, + (operand == 0) ? "is" + : (operand == 1) ? "is not" + : "UNKNOWN"); break; case Pyc::CONTAINS_OP_A: - formatted_print(pyc_output, "%d (%s)", operand, (operand == 0) ? "in" - : (operand == 1) ? "not in" - : "UNKNOWN"); + formatted_print(pyc_output, "%d (%s)", operand, + (operand == 0) ? "in" + : (operand == 1) ? "not in" + : "UNKNOWN"); break; case Pyc::CALL_INTRINSIC_1_A: if (static_cast(operand) < intrinsic1_names_len) - formatted_print(pyc_output, "%d (%s)", operand, intrinsic1_names[operand]); + formatted_print(pyc_output, "%d (%s)", operand, + intrinsic1_names[operand]); else formatted_print(pyc_output, "%d (UNKNOWN)", operand); break; case Pyc::CALL_INTRINSIC_2_A: if (static_cast(operand) < intrinsic2_names_len) - formatted_print(pyc_output, "%d (%s)", operand, intrinsic2_names[operand]); + formatted_print(pyc_output, "%d (%s)", operand, + intrinsic2_names[operand]); else formatted_print(pyc_output, "%d (UNKNOWN)", operand); break; case Pyc::FORMAT_VALUE_A: { auto conv = static_cast(operand & 0x03); - const char *flag = (operand & 0x04) ? " | FVS_HAVE_SPEC" : ""; + const char* flag = + (operand & 0x04) ? " | FVS_HAVE_SPEC" : ""; if (conv < format_value_names_len) { formatted_print(pyc_output, "%d (%s%s)", operand, - format_value_names[conv], flag); - } else { + format_value_names[conv], flag); + } + else { formatted_print(pyc_output, "%d (UNKNOWN)", operand); } } break; case Pyc::CONVERT_VALUE_A: if (static_cast(operand) < format_value_names_len) - formatted_print(pyc_output, "%d (%s)", operand, format_value_names[operand]); + formatted_print(pyc_output, "%d (%s)", operand, + format_value_names[operand]); else formatted_print(pyc_output, "%d (UNKNOWN)", operand); break; @@ -576,16 +688,20 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, // This looks like a bitmask, but CPython treats it as an exclusive lookup... switch (operand) { case 0x01: - formatted_print(pyc_output, "%d (MAKE_FUNCTION_DEFAULTS)", operand); + formatted_print( + pyc_output, "%d (MAKE_FUNCTION_DEFAULTS)", operand); break; case 0x02: - formatted_print(pyc_output, "%d (MAKE_FUNCTION_KWDEFAULTS)", operand); + formatted_print( + pyc_output, "%d (MAKE_FUNCTION_KWDEFAULTS)", operand); break; case 0x04: - formatted_print(pyc_output, "%d (MAKE_FUNCTION_ANNOTATIONS)", operand); + formatted_print( + pyc_output, "%d (MAKE_FUNCTION_ANNOTATIONS)", operand); break; case 0x08: - formatted_print(pyc_output, "%d (MAKE_FUNCTION_CLOSURE)", operand); + formatted_print( + pyc_output, "%d (MAKE_FUNCTION_CLOSURE)", operand); break; default: formatted_print(pyc_output, "%d (UNKNOWN)", operand); @@ -601,17 +717,16 @@ void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, } } -void bc_exceptiontable(std::ostream& pyc_output, PycRef code, - int indent) +void bc_exceptiontable( + std::ostream& pyc_output, PycRef code, int indent) { for (const auto& entry : code->exceptionTableEntries()) { - for (int i=0; i " << entry.target << " [" << entry.stack_depth - << "] " << (entry.push_lasti ? "lasti": "") - << "\n"; + pyc_output << entry.start_offset << " to " << entry.end_offset << " -> " + << entry.target << " [" << entry.stack_depth << "] " + << (entry.push_lasti ? "lasti" : "") << "\n"; } } diff --git a/bytecode.h b/bytecode.h index 3c0d9d3c7..d79671a88 100644 --- a/bytecode.h +++ b/bytecode.h @@ -1,17 +1,17 @@ +#include "data.h" #include "pyc_code.h" #include "pyc_module.h" -#include "data.h" namespace Pyc { enum Opcode { - #define OPCODE(x) x, - #define OPCODE_A_FIRST(x) PYC_HAVE_ARG, x##_A = PYC_HAVE_ARG, - #define OPCODE_A(x) x##_A, - #include "bytecode_ops.inl" - #undef OPCODE_A - #undef OPCODE_A_FIRST - #undef OPCODE +#define OPCODE(x) x, +#define OPCODE_A_FIRST(x) PYC_HAVE_ARG, x##_A = PYC_HAVE_ARG, +#define OPCODE_A(x) x##_A, +#include "bytecode_ops.inl" +#undef OPCODE_A +#undef OPCODE_A_FIRST +#undef OPCODE PYC_LAST_OPCODE, PYC_INVALID_OPCODE = -1, @@ -25,12 +25,13 @@ enum DisassemblyFlags { const char* OpcodeName(int opcode); int ByteToOpcode(int maj, int min, int opcode); -} +} // namespace Pyc -void print_const(std::ostream& pyc_output, PycRef obj, PycModule* mod, - const char* parent_f_string_quote = nullptr); -void bc_next(PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& pos); +void print_const(std::ostream& pyc_output, PycRef obj, + PycModule* mod, const char* parent_f_string_quote = nullptr); +void bc_next( + PycBuffer& source, PycModule* mod, int& opcode, int& operand, int& pos); void bc_disasm(std::ostream& pyc_output, PycRef code, PycModule* mod, - int indent, unsigned flags); -void bc_exceptiontable(std::ostream& pyc_output, PycRef code, - int indent); + int indent, unsigned flags); +void bc_exceptiontable( + std::ostream& pyc_output, PycRef code, int indent); diff --git a/bytecode_ops.inl b/bytecode_ops.inl index 5cc49c230..480702cce 100644 --- a/bytecode_ops.inl +++ b/bytecode_ops.inl @@ -125,168 +125,195 @@ OPCODE(MAKE_FUNCTION) // Python 3.13 -> OPCODE(TO_BOOL) // Python 3.13 -> /* Has parameter word */ -OPCODE_A_FIRST(STORE_NAME) // Python 1.0 -> names[A] -OPCODE_A(DELETE_NAME) // Python 1.0 -> names[A] -OPCODE_A(UNPACK_TUPLE) // Python 1.0 - 1.6 A=count -OPCODE_A(UNPACK_LIST) // Python 1.0 - 1.6 A=count -OPCODE_A(UNPACK_ARG) // Python 1.0 - 1.4 A=count -OPCODE_A(STORE_ATTR) // Python 1.0 -> names[A] -OPCODE_A(DELETE_ATTR) // Python 1.0 -> names[A] -OPCODE_A(STORE_GLOBAL) // Python 1.0 -> names[A] -OPCODE_A(DELETE_GLOBAL) // Python 1.0 -> names[A] -OPCODE_A(ROT_N) // Python 3.10 A=count -OPCODE_A(UNPACK_VARARG) // Python 1.0 - 1.4 A=count -OPCODE_A(LOAD_CONST) // Python 1.0 -> consts[A] -OPCODE_A(LOAD_NAME) // Python 1.0 -> names[A] -OPCODE_A(BUILD_TUPLE) // Python 1.0 -> A=size -OPCODE_A(BUILD_LIST) // Python 1.0 -> A=size -OPCODE_A(BUILD_MAP) // Python 1.0 -> A=size -OPCODE_A(LOAD_ATTR) // Python 1.0 - 3.11 names[A] - // Python 3.12 -> A=(names[A<<1])+(flag) -OPCODE_A(COMPARE_OP) // Python 1.0 - 3.11 cmp_ops[A] - // Python 3.12 A=(cmp_ops[A<<4])+(flags) - // Python 3.13 -> A=(cmp_ops[A<<5])+(flags) -OPCODE_A(IMPORT_NAME) // Python 1.0 -> names[A] -OPCODE_A(IMPORT_FROM) // Python 1.0 -> names[A] -OPCODE_A(ACCESS_MODE) // Python 1.0 - 1.4 names[A] -OPCODE_A(JUMP_FORWARD) // Python 1.0 -> rel jmp +A -OPCODE_A(JUMP_IF_FALSE) // Python 1.0 - 2.6, 3.0 rel jmp +A -OPCODE_A(JUMP_IF_TRUE) // Python 1.0 - 2.6, 3.0 rel jmp +A -OPCODE_A(JUMP_ABSOLUTE) // Python 1.0 - 3.10 abs jmp A -OPCODE_A(FOR_LOOP) // Python 1.0 - 2.2 rel jmp +A -OPCODE_A(LOAD_LOCAL) // Python 1.0 - 1.4 names[A] -OPCODE_A(LOAD_GLOBAL) // Python 1.0 - 3.10 names[A] - // Python 3.11 -> A=(names[A<<1])+(flag) -OPCODE_A(SET_FUNC_ARGS) // Python 1.1 - 1.4 A=count -OPCODE_A(SETUP_LOOP) // Python 1.0 - 3.7 rel jmp +A -OPCODE_A(SETUP_EXCEPT) // Python 1.0 - 3.7 rel jmp +A -OPCODE_A(SETUP_FINALLY) // Python 1.0 - 3.10 rel jmp +A -OPCODE_A(RESERVE_FAST) // Python 1.0 - 1.2 A=count -OPCODE_A(LOAD_FAST) // Python 1.0 -> locals[A] -OPCODE_A(STORE_FAST) // Python 1.0 -> locals[A] -OPCODE_A(DELETE_FAST) // Python 1.0 -> locals[A] -OPCODE_A(GEN_START) // Python 3.10 ??? -OPCODE_A(SET_LINENO) // Python 1.0 - 2.2 A=line -OPCODE_A(STORE_ANNOTATION) // Python 3.6 names[A] -OPCODE_A(RAISE_VARARGS) // Python 1.3 -> A=count -OPCODE_A(CALL_FUNCTION) // Python 1.3 - 3.5 A=(#args)+(#kwargs<<8) - // Python 3.6 - 3.10 A=#args -OPCODE_A(MAKE_FUNCTION) // Python 1.3 - 2.7 A=#defaults - // Python 3.0 - 3.5 A=(#defaults)+(#kwdefaults<<8)+(#annotations<<16) - // Python 3.6 - 3.12 A=flags -OPCODE_A(BUILD_SLICE) // Python 1.4 -> A=count -OPCODE_A(CALL_FUNCTION_VAR) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) -OPCODE_A(CALL_FUNCTION_KW) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) - // Python 3.6 - 3.10 A=#args -OPCODE_A(CALL_FUNCTION_VAR_KW) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) -OPCODE_A(CALL_FUNCTION_EX) // Python 3.6 -> A=flags -OPCODE_A(UNPACK_SEQUENCE) // Python 2.0 -> A=count -OPCODE_A(FOR_ITER) // Python 2.0 -> rel jmp +A -OPCODE_A(DUP_TOPX) // Python 2.0 - 3.1 A=count -OPCODE_A(BUILD_SET) // Python 2.7 -> A=size -OPCODE_A(JUMP_IF_FALSE_OR_POP) // Python 2.7, 3.1 - 3.11 abs jmp A -OPCODE_A(JUMP_IF_TRUE_OR_POP) // Python 2.7, 3.1 - 3.11 abs jmp A -OPCODE_A(POP_JUMP_IF_FALSE) // Python 2.7, 3.1 - 3.10 abs jmp A - // Python 3.12 -> rel jmp +A -OPCODE_A(POP_JUMP_IF_TRUE) // Python 2.7, 3.1 - 3.10 abs jmp A - // Python 3.12 -> rel jmp +A -OPCODE_A(CONTINUE_LOOP) // Python 2.1 - 3.7 abs jmp A -OPCODE_A(MAKE_CLOSURE) // Python 2.1 - 2.7 A=#defaults - // Python 3.0 - 3.5 A=(#defaults)+(#kwdefaults<<8)+(#annotations<<16) -OPCODE_A(LOAD_CLOSURE) // Python 2.1 -> freevars[A] -OPCODE_A(LOAD_DEREF) // Python 2.1 -> freevars[A] -OPCODE_A(STORE_DEREF) // Python 2.1 -> freevars[A] -OPCODE_A(DELETE_DEREF) // Python 3.2 -> freevars[A] -OPCODE_A(EXTENDED_ARG) // Python 2.0 -> A=extended_arg -OPCODE_A(SETUP_WITH) // Python 2.7, 3.2 - 3.10 rel jmp +A -OPCODE_A(SET_ADD) // Python 2.7, 3.1 -> stack[A] -OPCODE_A(MAP_ADD) // Python 2.7, 3.1 -> stack[A] -OPCODE_A(UNPACK_EX) // Python 3.0 -> A=(before)+(after<<8) -OPCODE_A(LIST_APPEND) // Python 2.7, 3.1 -> stack[A] -OPCODE_A(LOAD_CLASSDEREF) // Python 3.4 - 3.10 (cellvars+freevars)[A] - // Python 3.11 localsplusnames[A] -OPCODE_A(MATCH_CLASS) // Python 3.10 -> A=#args -OPCODE_A(BUILD_LIST_UNPACK) // Python 3.5 - 3.8 A=count -OPCODE_A(BUILD_MAP_UNPACK) // Python 3.5 - 3.8 A=count -OPCODE_A(BUILD_MAP_UNPACK_WITH_CALL) // Python 3.5 A=(count)+(fnloc<<8) - // Python 3.6 - 3.8 A=count -OPCODE_A(BUILD_TUPLE_UNPACK) // Python 3.5 - 3.8 A=count -OPCODE_A(BUILD_SET_UNPACK) // Python 3.5 - 3.8 A=count -OPCODE_A(SETUP_ASYNC_WITH) // Python 3.5 - 3.10 rel jmp +A -OPCODE_A(FORMAT_VALUE) // Python 3.6 - 3.12 A=(conversion_type&0x3)+(flags) -OPCODE_A(BUILD_CONST_KEY_MAP) // Python 3.6 -> A=count -OPCODE_A(BUILD_STRING) // Python 3.6 -> A=count -OPCODE_A(BUILD_TUPLE_UNPACK_WITH_CALL) // Python 3.6 - 3.8 A=count -OPCODE_A(LOAD_METHOD) // Python 3.7 - 3.11 names[A] -OPCODE_A(CALL_METHOD) // Python 3.7 - 3.10 A=#args -OPCODE_A(CALL_FINALLY) // Python 3.8 rel jmp +A -OPCODE_A(POP_FINALLY) // Python 3.8 A=flags -OPCODE_A(IS_OP) // Python 3.9 -> A=inverted -OPCODE_A(CONTAINS_OP) // Python 3.9 -> A=inverted -OPCODE_A(RERAISE) // Python 3.10 -> A=count -OPCODE_A(JUMP_IF_NOT_EXC_MATCH) // Python 3.9 - 3.10 abs jmp A -OPCODE_A(LIST_EXTEND) // Python 3.9 -> stack[A] -OPCODE_A(SET_UPDATE) // Python 3.9 -> stack[A] -OPCODE_A(DICT_MERGE) // Python 3.9 -> stack[A] -OPCODE_A(DICT_UPDATE) // Python 3.9 -> stack[A] -OPCODE_A(SWAP) // Python 3.11 -> stack[A] -OPCODE_A(POP_JUMP_FORWARD_IF_FALSE) // Python 3.11 rel jmp +A -OPCODE_A(POP_JUMP_FORWARD_IF_TRUE) // Python 3.11 rel jmp +A -OPCODE_A(COPY) // Python 3.11 -> stack[A] -OPCODE_A(BINARY_OP) // Python 3.11 -> bin_ops[A] -OPCODE_A(SEND) // Python 3.11 -> rel jmp +A -OPCODE_A(POP_JUMP_FORWARD_IF_NOT_NONE) // Python 3.11 rel jmp +A -OPCODE_A(POP_JUMP_FORWARD_IF_NONE) // Python 3.11 rel jmp +A -OPCODE_A(GET_AWAITABLE) // Python 3.11 -> A=awaitable_type -OPCODE_A(JUMP_BACKWARD_NO_INTERRUPT) // Python 3.11 -> rel jmp -A -OPCODE_A(MAKE_CELL) // Python 3.11 -> locals[A] -OPCODE_A(JUMP_BACKWARD) // Python 3.11 -> rel jmp -A -OPCODE_A(COPY_FREE_VARS) // Python 3.11 -> A=count -OPCODE_A(RESUME) // Python 3.11 -> ??? -OPCODE_A(PRECALL) // Python 3.11 A=#args -OPCODE_A(CALL) // Python 3.11 -> A=#args -OPCODE_A(KW_NAMES) // Python 3.11 - 3.12 consts[A] -OPCODE_A(POP_JUMP_BACKWARD_IF_NOT_NONE) // Python 3.11 jmp rel -A -OPCODE_A(POP_JUMP_BACKWARD_IF_NONE) // Python 3.11 jmp rel -A -OPCODE_A(POP_JUMP_BACKWARD_IF_FALSE) // Python 3.11 jmp rel -A -OPCODE_A(POP_JUMP_BACKWARD_IF_TRUE) // Python 3.11 jmp rel -A -OPCODE_A(RETURN_CONST) // Python 3.12 -> consts[A] -OPCODE_A(LOAD_FAST_CHECK) // Python 3.12 -> locals[A] -OPCODE_A(POP_JUMP_IF_NOT_NONE) // Python 3.12 -> rel jmp +A -OPCODE_A(POP_JUMP_IF_NONE) // Python 3.12 -> rel jmp +A -OPCODE_A(LOAD_SUPER_ATTR) // Python 3.12 -> A=(flags&0x3)+names[A<<2] -OPCODE_A(LOAD_FAST_AND_CLEAR) // Python 3.12 -> locals[A] -OPCODE_A(YIELD_VALUE) // Python 3.12 A=stack_depth (ignored) - // Python 3.13 -> A=type -OPCODE_A(CALL_INTRINSIC_1) // Python 3.12 -> intrinsics_1[A] -OPCODE_A(CALL_INTRINSIC_2) // Python 3.12 -> intrinsics_2[A] -OPCODE_A(LOAD_FROM_DICT_OR_GLOBALS) // Python 3.12 -> names[A] -OPCODE_A(LOAD_FROM_DICT_OR_DEREF) // Python 3.12 -> localsplusnames[A] -OPCODE_A(CALL_KW) // Python 3.13 -> A=#args -OPCODE_A(CONVERT_VALUE) // Python 3.13 -> A=conversion_type -OPCODE_A(ENTER_EXECUTOR) // Python 3.13 -> executors[A&0xff] -OPCODE_A(LOAD_FAST_LOAD_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] -OPCODE_A(SET_FUNCTION_ATTRIBUTE) // Python 3.13 -> A=attribute_type -OPCODE_A(STORE_FAST_LOAD_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] -OPCODE_A(STORE_FAST_STORE_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] +OPCODE_A_FIRST(STORE_NAME) // Python 1.0 -> names[A] +OPCODE_A(DELETE_NAME) // Python 1.0 -> names[A] +OPCODE_A(UNPACK_TUPLE) // Python 1.0 - 1.6 A=count +OPCODE_A(UNPACK_LIST) // Python 1.0 - 1.6 A=count +OPCODE_A(UNPACK_ARG) // Python 1.0 - 1.4 A=count +OPCODE_A(STORE_ATTR) // Python 1.0 -> names[A] +OPCODE_A(DELETE_ATTR) // Python 1.0 -> names[A] +OPCODE_A(STORE_GLOBAL) // Python 1.0 -> names[A] +OPCODE_A(DELETE_GLOBAL) // Python 1.0 -> names[A] +OPCODE_A(ROT_N) // Python 3.10 A=count +OPCODE_A(UNPACK_VARARG) // Python 1.0 - 1.4 A=count +OPCODE_A(LOAD_CONST) // Python 1.0 -> consts[A] +OPCODE_A(LOAD_NAME) // Python 1.0 -> names[A] +OPCODE_A(BUILD_TUPLE) // Python 1.0 -> A=size +OPCODE_A(BUILD_LIST) // Python 1.0 -> A=size +OPCODE_A(BUILD_MAP) // Python 1.0 -> A=size +OPCODE_A(LOAD_ATTR) // Python 1.0 - 3.11 names[A] +// Python 3.12 -> A=(names[A<<1])+(flag) +OPCODE_A(COMPARE_OP) // Python 1.0 - 3.11 cmp_ops[A] +// Python 3.12 A=(cmp_ops[A<<4])+(flags) +// Python 3.13 -> A=(cmp_ops[A<<5])+(flags) +OPCODE_A(IMPORT_NAME) // Python 1.0 -> names[A] +OPCODE_A(IMPORT_FROM) // Python 1.0 -> names[A] +OPCODE_A(ACCESS_MODE) // Python 1.0 - 1.4 names[A] +OPCODE_A(JUMP_FORWARD) // Python 1.0 -> rel jmp +A +OPCODE_A(JUMP_IF_FALSE) // Python 1.0 - 2.6, 3.0 rel jmp +A +OPCODE_A(JUMP_IF_TRUE) // Python 1.0 - 2.6, 3.0 rel jmp +A +OPCODE_A(JUMP_ABSOLUTE) // Python 1.0 - 3.10 abs jmp A +OPCODE_A(FOR_LOOP) // Python 1.0 - 2.2 rel jmp +A +OPCODE_A(LOAD_LOCAL) // Python 1.0 - 1.4 names[A] +OPCODE_A(LOAD_GLOBAL) // Python 1.0 - 3.10 names[A] +// Python 3.11 -> A=(names[A<<1])+(flag) +OPCODE_A(SET_FUNC_ARGS) // Python 1.1 - 1.4 A=count +OPCODE_A(SETUP_LOOP) // Python 1.0 - 3.7 rel jmp +A +OPCODE_A(SETUP_EXCEPT) // Python 1.0 - 3.7 rel jmp +A +OPCODE_A(SETUP_FINALLY) // Python 1.0 - 3.10 rel jmp +A +OPCODE_A(RESERVE_FAST) // Python 1.0 - 1.2 A=count +OPCODE_A(LOAD_FAST) // Python 1.0 -> locals[A] +OPCODE_A(STORE_FAST) // Python 1.0 -> locals[A] +OPCODE_A(DELETE_FAST) // Python 1.0 -> locals[A] +OPCODE_A(GEN_START) // Python 3.10 ??? +OPCODE_A(SET_LINENO) // Python 1.0 - 2.2 A=line +OPCODE_A(STORE_ANNOTATION) // Python 3.6 names[A] +OPCODE_A(RAISE_VARARGS) // Python 1.3 -> A=count +OPCODE_A(CALL_FUNCTION) // Python 1.3 - 3.5 A=(#args)+(#kwargs<<8) +// Python 3.6 - 3.10 A=#args +OPCODE_A(MAKE_FUNCTION) // Python 1.3 - 2.7 A=#defaults +// Python 3.0 - 3.5 A=(#defaults)+(#kwdefaults<<8)+(#annotations<<16) +// Python 3.6 - 3.12 A=flags +OPCODE_A(BUILD_SLICE) // Python 1.4 -> A=count +OPCODE_A( + CALL_FUNCTION_VAR) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) +OPCODE_A( + CALL_FUNCTION_KW) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) +// Python 3.6 - 3.10 A=#args +OPCODE_A( + CALL_FUNCTION_VAR_KW) // Python 1.6 - 3.5 A=(#args)+(#kwargs<<8) +OPCODE_A(CALL_FUNCTION_EX) // Python 3.6 -> A=flags +OPCODE_A(UNPACK_SEQUENCE) // Python 2.0 -> A=count +OPCODE_A(FOR_ITER) // Python 2.0 -> rel jmp +A +OPCODE_A(DUP_TOPX) // Python 2.0 - 3.1 A=count +OPCODE_A(BUILD_SET) // Python 2.7 -> A=size +OPCODE_A(JUMP_IF_FALSE_OR_POP) // Python 2.7, 3.1 - 3.11 abs jmp A +OPCODE_A(JUMP_IF_TRUE_OR_POP) // Python 2.7, 3.1 - 3.11 abs jmp A +OPCODE_A(POP_JUMP_IF_FALSE) // Python 2.7, 3.1 - 3.10 abs jmp A +// Python 3.12 -> rel jmp +A +OPCODE_A(POP_JUMP_IF_TRUE) // Python 2.7, 3.1 - 3.10 abs jmp A +// Python 3.12 -> rel jmp +A +OPCODE_A(CONTINUE_LOOP) // Python 2.1 - 3.7 abs jmp A +OPCODE_A(MAKE_CLOSURE) // Python 2.1 - 2.7 A=#defaults +// Python 3.0 - 3.5 A=(#defaults)+(#kwdefaults<<8)+(#annotations<<16) +OPCODE_A(LOAD_CLOSURE) // Python 2.1 -> freevars[A] +OPCODE_A(LOAD_DEREF) // Python 2.1 -> freevars[A] +OPCODE_A(STORE_DEREF) // Python 2.1 -> freevars[A] +OPCODE_A(DELETE_DEREF) // Python 3.2 -> freevars[A] +OPCODE_A(EXTENDED_ARG) // Python 2.0 -> A=extended_arg +OPCODE_A(SETUP_WITH) // Python 2.7, 3.2 - 3.10 rel jmp +A +OPCODE_A(SET_ADD) // Python 2.7, 3.1 -> stack[A] +OPCODE_A(MAP_ADD) // Python 2.7, 3.1 -> stack[A] +OPCODE_A(UNPACK_EX) // Python 3.0 -> A=(before)+(after<<8) +OPCODE_A(LIST_APPEND) // Python 2.7, 3.1 -> stack[A] +OPCODE_A( + LOAD_CLASSDEREF) // Python 3.4 - 3.10 (cellvars+freevars)[A] +// Python 3.11 localsplusnames[A] +OPCODE_A(MATCH_CLASS) // Python 3.10 -> A=#args +OPCODE_A(BUILD_LIST_UNPACK) // Python 3.5 - 3.8 A=count +OPCODE_A(BUILD_MAP_UNPACK) // Python 3.5 - 3.8 A=count +OPCODE_A( + BUILD_MAP_UNPACK_WITH_CALL) // Python 3.5 A=(count)+(fnloc<<8) +// Python 3.6 - 3.8 A=count +OPCODE_A(BUILD_TUPLE_UNPACK) // Python 3.5 - 3.8 A=count +OPCODE_A(BUILD_SET_UNPACK) // Python 3.5 - 3.8 A=count +OPCODE_A(SETUP_ASYNC_WITH) // Python 3.5 - 3.10 rel jmp +A +OPCODE_A( + FORMAT_VALUE) // Python 3.6 - 3.12 A=(conversion_type&0x3)+(flags) +OPCODE_A(BUILD_CONST_KEY_MAP) // Python 3.6 -> A=count +OPCODE_A(BUILD_STRING) // Python 3.6 -> A=count +OPCODE_A(BUILD_TUPLE_UNPACK_WITH_CALL) // Python 3.6 - 3.8 A=count +OPCODE_A(LOAD_METHOD) // Python 3.7 - 3.11 names[A] +OPCODE_A(CALL_METHOD) // Python 3.7 - 3.10 A=#args +OPCODE_A(CALL_FINALLY) // Python 3.8 rel jmp +A +OPCODE_A(POP_FINALLY) // Python 3.8 A=flags +OPCODE_A(IS_OP) // Python 3.9 -> A=inverted +OPCODE_A(CONTAINS_OP) // Python 3.9 -> A=inverted +OPCODE_A(RERAISE) // Python 3.10 -> A=count +OPCODE_A(JUMP_IF_NOT_EXC_MATCH) // Python 3.9 - 3.10 abs jmp A +OPCODE_A(LIST_EXTEND) // Python 3.9 -> stack[A] +OPCODE_A(SET_UPDATE) // Python 3.9 -> stack[A] +OPCODE_A(DICT_MERGE) // Python 3.9 -> stack[A] +OPCODE_A(DICT_UPDATE) // Python 3.9 -> stack[A] +OPCODE_A(SWAP) // Python 3.11 -> stack[A] +OPCODE_A(POP_JUMP_FORWARD_IF_FALSE) // Python 3.11 rel jmp +A +OPCODE_A(POP_JUMP_FORWARD_IF_TRUE) // Python 3.11 rel jmp +A +OPCODE_A(COPY) // Python 3.11 -> stack[A] +OPCODE_A(BINARY_OP) // Python 3.11 -> bin_ops[A] +OPCODE_A(SEND) // Python 3.11 -> rel jmp +A +OPCODE_A( + POP_JUMP_FORWARD_IF_NOT_NONE) // Python 3.11 rel jmp +A +OPCODE_A(POP_JUMP_FORWARD_IF_NONE) // Python 3.11 rel jmp +A +OPCODE_A(GET_AWAITABLE) // Python 3.11 -> A=awaitable_type +OPCODE_A( + JUMP_BACKWARD_NO_INTERRUPT) // Python 3.11 -> rel jmp -A +OPCODE_A(MAKE_CELL) // Python 3.11 -> locals[A] +OPCODE_A(JUMP_BACKWARD) // Python 3.11 -> rel jmp -A +OPCODE_A(COPY_FREE_VARS) // Python 3.11 -> A=count +OPCODE_A(RESUME) // Python 3.11 -> ??? +OPCODE_A(PRECALL) // Python 3.11 A=#args +OPCODE_A(CALL) // Python 3.11 -> A=#args +OPCODE_A(KW_NAMES) // Python 3.11 - 3.12 consts[A] +OPCODE_A( + POP_JUMP_BACKWARD_IF_NOT_NONE) // Python 3.11 jmp rel -A +OPCODE_A(POP_JUMP_BACKWARD_IF_NONE) // Python 3.11 jmp rel -A +OPCODE_A( + POP_JUMP_BACKWARD_IF_FALSE) // Python 3.11 jmp rel -A +OPCODE_A(POP_JUMP_BACKWARD_IF_TRUE) // Python 3.11 jmp rel -A +OPCODE_A(RETURN_CONST) // Python 3.12 -> consts[A] +OPCODE_A(LOAD_FAST_CHECK) // Python 3.12 -> locals[A] +OPCODE_A(POP_JUMP_IF_NOT_NONE) // Python 3.12 -> rel jmp +A +OPCODE_A(POP_JUMP_IF_NONE) // Python 3.12 -> rel jmp +A +OPCODE_A( + LOAD_SUPER_ATTR) // Python 3.12 -> A=(flags&0x3)+names[A<<2] +OPCODE_A(LOAD_FAST_AND_CLEAR) // Python 3.12 -> locals[A] +OPCODE_A(YIELD_VALUE) // Python 3.12 A=stack_depth (ignored) +// Python 3.13 -> A=type +OPCODE_A(CALL_INTRINSIC_1) // Python 3.12 -> intrinsics_1[A] +OPCODE_A(CALL_INTRINSIC_2) // Python 3.12 -> intrinsics_2[A] +OPCODE_A(LOAD_FROM_DICT_OR_GLOBALS) // Python 3.12 -> names[A] +OPCODE_A( + LOAD_FROM_DICT_OR_DEREF) // Python 3.12 -> localsplusnames[A] +OPCODE_A(CALL_KW) // Python 3.13 -> A=#args +OPCODE_A(CONVERT_VALUE) // Python 3.13 -> A=conversion_type +OPCODE_A(ENTER_EXECUTOR) // Python 3.13 -> executors[A&0xff] +OPCODE_A( + LOAD_FAST_LOAD_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] +OPCODE_A( + SET_FUNCTION_ATTRIBUTE) // Python 3.13 -> A=attribute_type +OPCODE_A( + STORE_FAST_LOAD_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] +OPCODE_A( + STORE_FAST_STORE_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] /* Instrumented opcodes */ -OPCODE_A(INSTRUMENTED_LOAD_SUPER_ATTR) // Python 3.12 -> (see LOAD_SUPER_ATTR) -OPCODE_A(INSTRUMENTED_POP_JUMP_IF_NONE) // Python 3.12 -> (see POP_JUMP_IF_NONE) -OPCODE_A(INSTRUMENTED_POP_JUMP_IF_NOT_NONE) // Python 3.12 -> (see POP_JUMP_IF_NOT_NONE) -OPCODE_A(INSTRUMENTED_RESUME) // Python 3.12 -> (see RESUME) -OPCODE_A(INSTRUMENTED_CALL) // Python 3.12 -> (see CALL) -OPCODE_A(INSTRUMENTED_RETURN_VALUE) // Python 3.12 -> (see RETURN_VALUE) -OPCODE_A(INSTRUMENTED_YIELD_VALUE) // Python 3.12 -> (see YIELD_VALUE) -OPCODE_A(INSTRUMENTED_CALL_FUNCTION_EX) // Python 3.12 -> (see CALL_FUNCTION_EX) -OPCODE_A(INSTRUMENTED_JUMP_FORWARD) // Python 3.12 -> (see JUMP_FORWARD) -OPCODE_A(INSTRUMENTED_JUMP_BACKWARD) // Python 3.12 -> (see JUMP_BACKWARD) -OPCODE_A(INSTRUMENTED_RETURN_CONST) // Python 3.12 -> (see RETURN_CONST) -OPCODE_A(INSTRUMENTED_FOR_ITER) // Python 3.12 -> (see FOR_ITER) -OPCODE_A(INSTRUMENTED_POP_JUMP_IF_FALSE) // Python 3.12 -> (see POP_JUMP_IF_FALSE) -OPCODE_A(INSTRUMENTED_POP_JUMP_IF_TRUE) // Python 3.12 -> (see POP_JUMP_IF_TRUE) -OPCODE_A(INSTRUMENTED_END_FOR) // Python 3.12 -> (see END_FOR) -OPCODE_A(INSTRUMENTED_END_SEND) // Python 3.12 -> (see END_SEND) -OPCODE_A(INSTRUMENTED_INSTRUCTION) // Python 3.12 -> A=(unused) -OPCODE_A(INSTRUMENTED_LINE) // Python 3.12 -> ??? -OPCODE_A(INSTRUMENTED_CALL_KW) // Python 3.13 -> (see CALL_KW) +OPCODE_A( + INSTRUMENTED_LOAD_SUPER_ATTR) // Python 3.12 -> (see LOAD_SUPER_ATTR) +OPCODE_A( + INSTRUMENTED_POP_JUMP_IF_NONE) // Python 3.12 -> (see POP_JUMP_IF_NONE) +OPCODE_A( + INSTRUMENTED_POP_JUMP_IF_NOT_NONE) // Python 3.12 -> (see POP_JUMP_IF_NOT_NONE) +OPCODE_A(INSTRUMENTED_RESUME) // Python 3.12 -> (see RESUME) +OPCODE_A(INSTRUMENTED_CALL) // Python 3.12 -> (see CALL) +OPCODE_A( + INSTRUMENTED_RETURN_VALUE) // Python 3.12 -> (see RETURN_VALUE) +OPCODE_A( + INSTRUMENTED_YIELD_VALUE) // Python 3.12 -> (see YIELD_VALUE) +OPCODE_A( + INSTRUMENTED_CALL_FUNCTION_EX) // Python 3.12 -> (see CALL_FUNCTION_EX) +OPCODE_A( + INSTRUMENTED_JUMP_FORWARD) // Python 3.12 -> (see JUMP_FORWARD) +OPCODE_A( + INSTRUMENTED_JUMP_BACKWARD) // Python 3.12 -> (see JUMP_BACKWARD) +OPCODE_A( + INSTRUMENTED_RETURN_CONST) // Python 3.12 -> (see RETURN_CONST) +OPCODE_A(INSTRUMENTED_FOR_ITER) // Python 3.12 -> (see FOR_ITER) +OPCODE_A( + INSTRUMENTED_POP_JUMP_IF_FALSE) // Python 3.12 -> (see POP_JUMP_IF_FALSE) +OPCODE_A( + INSTRUMENTED_POP_JUMP_IF_TRUE) // Python 3.12 -> (see POP_JUMP_IF_TRUE) +OPCODE_A(INSTRUMENTED_END_FOR) // Python 3.12 -> (see END_FOR) +OPCODE_A(INSTRUMENTED_END_SEND) // Python 3.12 -> (see END_SEND) +OPCODE_A(INSTRUMENTED_INSTRUCTION) // Python 3.12 -> A=(unused) +OPCODE_A(INSTRUMENTED_LINE) // Python 3.12 -> ??? +OPCODE_A(INSTRUMENTED_CALL_KW) // Python 3.13 -> (see CALL_KW) diff --git a/bytes/bytecode_map.h b/bytes/bytecode_map.h index aeb47e87f..08bb90780 100644 --- a/bytes/bytecode_map.h +++ b/bytes/bytecode_map.h @@ -1,14 +1,14 @@ #include "bytecode.h" -#define BEGIN_MAP(maj, min) \ +// clang-format off +#define BEGIN_MAP(maj, min) \ int python_##maj##_##min##_map(int id) \ - { \ + { \ switch (id) { - -#define MAP_OP(op, name) \ - case op: return Pyc::name; - -#define END_MAP() \ - default: return Pyc::PYC_INVALID_OPCODE; \ - } \ +#define MAP_OP(op, name) \ + case op: return Pyc::name; +#define END_MAP() \ + default: return Pyc::PYC_INVALID_OPCODE; \ + } \ } +// clang-format on diff --git a/bytes/python_1_0.cpp b/bytes/python_1_0.cpp index b271c66b5..9fc959cf8 100644 --- a/bytes/python_1_0.cpp +++ b/bytes/python_1_0.cpp @@ -1,89 +1,89 @@ #include "bytecode_map.h" BEGIN_MAP(1, 0) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(14, UNARY_CALL) - MAP_OP(15, UNARY_INVERT) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_CALL) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, RAISE_EXCEPTION) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, LOAD_GLOBALS) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, BUILD_FUNCTION) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(94, UNPACK_ARG_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, UNPACK_VARARG_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(109, ACCESS_MODE_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(115, LOAD_LOCAL_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(123, RESERVE_FAST_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(14, UNARY_CALL) +MAP_OP(15, UNARY_INVERT) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_CALL) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, RAISE_EXCEPTION) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, LOAD_GLOBALS) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, BUILD_FUNCTION) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(94, UNPACK_ARG_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, UNPACK_VARARG_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(109, ACCESS_MODE_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(115, LOAD_LOCAL_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(123, RESERVE_FAST_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) END_MAP() diff --git a/bytes/python_1_1.cpp b/bytes/python_1_1.cpp index c3b61105e..7c0b1a771 100644 --- a/bytes/python_1_1.cpp +++ b/bytes/python_1_1.cpp @@ -1,90 +1,90 @@ #include "bytecode_map.h" BEGIN_MAP(1, 1) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(14, UNARY_CALL) - MAP_OP(15, UNARY_INVERT) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_CALL) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, RAISE_EXCEPTION) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, LOAD_GLOBALS) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, BUILD_FUNCTION) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(94, UNPACK_ARG_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, UNPACK_VARARG_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(109, ACCESS_MODE_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(115, LOAD_LOCAL_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, SET_FUNC_ARGS_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(123, RESERVE_FAST_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(14, UNARY_CALL) +MAP_OP(15, UNARY_INVERT) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_CALL) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, RAISE_EXCEPTION) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, LOAD_GLOBALS) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, BUILD_FUNCTION) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(94, UNPACK_ARG_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, UNPACK_VARARG_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(109, ACCESS_MODE_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(115, LOAD_LOCAL_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, SET_FUNC_ARGS_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(123, RESERVE_FAST_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) END_MAP() diff --git a/bytes/python_1_3.cpp b/bytes/python_1_3.cpp index cda608a6a..529da4c97 100644 --- a/bytes/python_1_3.cpp +++ b/bytes/python_1_3.cpp @@ -1,87 +1,87 @@ #include "bytecode_map.h" BEGIN_MAP(1, 3) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(94, UNPACK_ARG_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, UNPACK_VARARG_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(109, ACCESS_MODE_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(115, LOAD_LOCAL_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, SET_FUNC_ARGS_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(94, UNPACK_ARG_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, UNPACK_VARARG_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(109, ACCESS_MODE_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(115, LOAD_LOCAL_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, SET_FUNC_ARGS_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) END_MAP() diff --git a/bytes/python_1_4.cpp b/bytes/python_1_4.cpp index f632d8fe9..ee0a8d82b 100644 --- a/bytes/python_1_4.cpp +++ b/bytes/python_1_4.cpp @@ -1,89 +1,89 @@ #include "bytecode_map.h" BEGIN_MAP(1, 4) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(94, UNPACK_ARG_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, UNPACK_VARARG_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(109, ACCESS_MODE_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(115, LOAD_LOCAL_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, SET_FUNC_ARGS_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(94, UNPACK_ARG_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, UNPACK_VARARG_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(109, ACCESS_MODE_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(115, LOAD_LOCAL_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, SET_FUNC_ARGS_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) END_MAP() diff --git a/bytes/python_1_5.cpp b/bytes/python_1_5.cpp index 5ca45fa40..15590205e 100644 --- a/bytes/python_1_5.cpp +++ b/bytes/python_1_5.cpp @@ -1,84 +1,84 @@ #include "bytecode_map.h" BEGIN_MAP(1, 5) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) END_MAP() diff --git a/bytes/python_1_6.cpp b/bytes/python_1_6.cpp index 7bb41abc9..ef0564b7f 100644 --- a/bytes/python_1_6.cpp +++ b/bytes/python_1_6.cpp @@ -1,87 +1,87 @@ #include "bytecode_map.h" BEGIN_MAP(1, 6) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_TUPLE_A) - MAP_OP(93, UNPACK_LIST_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_TUPLE_A) +MAP_OP(93, UNPACK_LIST_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) END_MAP() diff --git a/bytes/python_2_0.cpp b/bytes/python_2_0.cpp index 250a76f38..bd474de7e 100644 --- a/bytes/python_2_0.cpp +++ b/bytes/python_2_0.cpp @@ -1,103 +1,103 @@ #include "bytecode_map.h" BEGIN_MAP(2, 0) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_1.cpp b/bytes/python_2_1.cpp index 94d45b861..29d1c273a 100644 --- a/bytes/python_2_1.cpp +++ b/bytes/python_2_1.cpp @@ -1,108 +1,108 @@ #include "bytecode_map.h" BEGIN_MAP(2, 1) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_2.cpp b/bytes/python_2_2.cpp index 28d26be55..67d4ab7c1 100644 --- a/bytes/python_2_2.cpp +++ b/bytes/python_2_2.cpp @@ -1,115 +1,115 @@ #include "bytecode_map.h" BEGIN_MAP(2, 2) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, FOR_LOOP_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, SET_LINENO_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, FOR_LOOP_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, SET_LINENO_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_3.cpp b/bytes/python_2_3.cpp index 6b5fc3149..079c95eee 100644 --- a/bytes/python_2_3.cpp +++ b/bytes/python_2_3.cpp @@ -1,113 +1,113 @@ #include "bytecode_map.h" BEGIN_MAP(2, 3) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_4.cpp b/bytes/python_2_4.cpp index ba4a5e156..ac691ea6d 100644 --- a/bytes/python_2_4.cpp +++ b/bytes/python_2_4.cpp @@ -1,115 +1,115 @@ #include "bytecode_map.h" BEGIN_MAP(2, 4) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(18, LIST_APPEND) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(18, LIST_APPEND) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_5.cpp b/bytes/python_2_5.cpp index 3bf70dcac..71b9f437f 100644 --- a/bytes/python_2_5.cpp +++ b/bytes/python_2_5.cpp @@ -1,116 +1,116 @@ #include "bytecode_map.h" BEGIN_MAP(2, 5) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(18, LIST_APPEND) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(18, LIST_APPEND) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_6.cpp b/bytes/python_2_6.cpp index 996f96f60..e9cfe906f 100644 --- a/bytes/python_2_6.cpp +++ b/bytes/python_2_6.cpp @@ -1,117 +1,117 @@ #include "bytecode_map.h" BEGIN_MAP(2, 6) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(18, LIST_APPEND) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_MAP_A) - MAP_OP(105, LOAD_ATTR_A) - MAP_OP(106, COMPARE_OP_A) - MAP_OP(107, IMPORT_NAME_A) - MAP_OP(108, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(18, LIST_APPEND) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_MAP_A) +MAP_OP(105, LOAD_ATTR_A) +MAP_OP(106, COMPARE_OP_A) +MAP_OP(107, IMPORT_NAME_A) +MAP_OP(108, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_2_7.cpp b/bytes/python_2_7.cpp index 9897c4b00..72a40d298 100644 --- a/bytes/python_2_7.cpp +++ b/bytes/python_2_7.cpp @@ -1,123 +1,123 @@ #include "bytecode_map.h" BEGIN_MAP(2, 7) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(13, UNARY_CONVERT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(21, BINARY_DIVIDE) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, SLICE_0) - MAP_OP(31, SLICE_1) - MAP_OP(32, SLICE_2) - MAP_OP(33, SLICE_3) - MAP_OP(40, STORE_SLICE_0) - MAP_OP(41, STORE_SLICE_1) - MAP_OP(42, STORE_SLICE_2) - MAP_OP(43, STORE_SLICE_3) - MAP_OP(50, DELETE_SLICE_0) - MAP_OP(51, DELETE_SLICE_1) - MAP_OP(52, DELETE_SLICE_2) - MAP_OP(53, DELETE_SLICE_3) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(58, INPLACE_DIVIDE) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, PRINT_ITEM) - MAP_OP(72, PRINT_NEWLINE) - MAP_OP(73, PRINT_ITEM_TO) - MAP_OP(74, PRINT_NEWLINE_TO) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(82, LOAD_LOCALS) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, EXEC_STMT) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, BUILD_CLASS) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, LIST_APPEND_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(145, EXTENDED_ARG_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(13, UNARY_CONVERT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(21, BINARY_DIVIDE) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, SLICE_0) +MAP_OP(31, SLICE_1) +MAP_OP(32, SLICE_2) +MAP_OP(33, SLICE_3) +MAP_OP(40, STORE_SLICE_0) +MAP_OP(41, STORE_SLICE_1) +MAP_OP(42, STORE_SLICE_2) +MAP_OP(43, STORE_SLICE_3) +MAP_OP(50, DELETE_SLICE_0) +MAP_OP(51, DELETE_SLICE_1) +MAP_OP(52, DELETE_SLICE_2) +MAP_OP(53, DELETE_SLICE_3) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(58, INPLACE_DIVIDE) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, PRINT_ITEM) +MAP_OP(72, PRINT_NEWLINE) +MAP_OP(73, PRINT_ITEM_TO) +MAP_OP(74, PRINT_NEWLINE_TO) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(82, LOAD_LOCALS) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, EXEC_STMT) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, BUILD_CLASS) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, LIST_APPEND_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(145, EXTENDED_ARG_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) END_MAP() diff --git a/bytes/python_3_0.cpp b/bytes/python_3_0.cpp index 05c77b9eb..068f1c55b 100644 --- a/bytes/python_3_0.cpp +++ b/bytes/python_3_0.cpp @@ -1,101 +1,101 @@ #include "bytecode_map.h" BEGIN_MAP(3, 0) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(17, SET_ADD) - MAP_OP(18, LIST_APPEND) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, STORE_LOCALS) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_A) - MAP_OP(112, JUMP_IF_TRUE_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(17, SET_ADD) +MAP_OP(18, LIST_APPEND) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, STORE_LOCALS) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_A) +MAP_OP(112, JUMP_IF_TRUE_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) END_MAP() diff --git a/bytes/python_3_1.cpp b/bytes/python_3_1.cpp index 8c907cea2..08e2024ec 100644 --- a/bytes/python_3_1.cpp +++ b/bytes/python_3_1.cpp @@ -1,104 +1,104 @@ #include "bytecode_map.h" BEGIN_MAP(3, 1) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, STORE_LOCALS) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, DUP_TOPX_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, STORE_LOCALS) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, DUP_TOPX_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) END_MAP() diff --git a/bytes/python_3_10.cpp b/bytes/python_3_10.cpp index c95945af9..c74feab98 100644 --- a/bytes/python_3_10.cpp +++ b/bytes/python_3_10.cpp @@ -1,131 +1,131 @@ #include "bytecode_map.h" BEGIN_MAP(3, 10) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(6, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(30, GET_LEN) - MAP_OP(31, MATCH_MAPPING) - MAP_OP(32, MATCH_SEQUENCE) - MAP_OP(33, MATCH_KEYS) - MAP_OP(34, COPY_DICT_WITHOUT_KEYS) - MAP_OP(49, WITH_EXCEPT_START) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(54, END_ASYNC_FOR) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(74, LOAD_ASSERTION_ERROR) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(82, LIST_TO_TUPLE) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, ROT_N_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, IS_OP_A) - MAP_OP(118, CONTAINS_OP_A) - MAP_OP(119, RERAISE_A) - MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(129, GEN_START_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(152, MATCH_CLASS_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(160, LOAD_METHOD_A) - MAP_OP(161, CALL_METHOD_A) - MAP_OP(162, LIST_EXTEND_A) - MAP_OP(163, SET_UPDATE_A) - MAP_OP(164, DICT_MERGE_A) - MAP_OP(165, DICT_UPDATE_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(6, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(30, GET_LEN) +MAP_OP(31, MATCH_MAPPING) +MAP_OP(32, MATCH_SEQUENCE) +MAP_OP(33, MATCH_KEYS) +MAP_OP(34, COPY_DICT_WITHOUT_KEYS) +MAP_OP(49, WITH_EXCEPT_START) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(54, END_ASYNC_FOR) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(74, LOAD_ASSERTION_ERROR) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(82, LIST_TO_TUPLE) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, ROT_N_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, IS_OP_A) +MAP_OP(118, CONTAINS_OP_A) +MAP_OP(119, RERAISE_A) +MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(129, GEN_START_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(152, MATCH_CLASS_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(160, LOAD_METHOD_A) +MAP_OP(161, CALL_METHOD_A) +MAP_OP(162, LIST_EXTEND_A) +MAP_OP(163, SET_UPDATE_A) +MAP_OP(164, DICT_MERGE_A) +MAP_OP(165, DICT_UPDATE_A) END_MAP() diff --git a/bytes/python_3_11.cpp b/bytes/python_3_11.cpp index 33b3ec09d..b07edd036 100644 --- a/bytes/python_3_11.cpp +++ b/bytes/python_3_11.cpp @@ -1,114 +1,114 @@ #include "bytecode_map.h" BEGIN_MAP(3, 11) - MAP_OP(0, CACHE) - MAP_OP(1, POP_TOP) - MAP_OP(2, PUSH_NULL) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(30, GET_LEN) - MAP_OP(31, MATCH_MAPPING) - MAP_OP(32, MATCH_SEQUENCE) - MAP_OP(33, MATCH_KEYS) - MAP_OP(35, PUSH_EXC_INFO) - MAP_OP(36, CHECK_EXC_MATCH) - MAP_OP(37, CHECK_EG_MATCH) - MAP_OP(49, WITH_EXCEPT_START) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(53, BEFORE_WITH) - MAP_OP(54, END_ASYNC_FOR) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(74, LOAD_ASSERTION_ERROR) - MAP_OP(75, RETURN_GENERATOR) - MAP_OP(82, LIST_TO_TUPLE) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, ASYNC_GEN_WRAP) - MAP_OP(88, PREP_RERAISE_STAR) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, SWAP_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(114, POP_JUMP_FORWARD_IF_FALSE_A) - MAP_OP(115, POP_JUMP_FORWARD_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, IS_OP_A) - MAP_OP(118, CONTAINS_OP_A) - MAP_OP(119, RERAISE_A) - MAP_OP(120, COPY_A) - MAP_OP(122, BINARY_OP_A) - MAP_OP(123, SEND_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(128, POP_JUMP_FORWARD_IF_NOT_NONE_A) - MAP_OP(129, POP_JUMP_FORWARD_IF_NONE_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, GET_AWAITABLE_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A) - MAP_OP(135, MAKE_CELL_A) - MAP_OP(136, LOAD_CLOSURE_A) - MAP_OP(137, LOAD_DEREF_A) - MAP_OP(138, STORE_DEREF_A) - MAP_OP(139, DELETE_DEREF_A) - MAP_OP(140, JUMP_BACKWARD_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(149, COPY_FREE_VARS_A) - MAP_OP(151, RESUME_A) - MAP_OP(152, MATCH_CLASS_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(160, LOAD_METHOD_A) - MAP_OP(162, LIST_EXTEND_A) - MAP_OP(163, SET_UPDATE_A) - MAP_OP(164, DICT_MERGE_A) - MAP_OP(165, DICT_UPDATE_A) - MAP_OP(166, PRECALL_A) - MAP_OP(171, CALL_A) - MAP_OP(172, KW_NAMES_A) - MAP_OP(173, POP_JUMP_BACKWARD_IF_NOT_NONE_A) - MAP_OP(174, POP_JUMP_BACKWARD_IF_NONE_A) - MAP_OP(175, POP_JUMP_BACKWARD_IF_FALSE_A) - MAP_OP(176, POP_JUMP_BACKWARD_IF_TRUE_A) +MAP_OP(0, CACHE) +MAP_OP(1, POP_TOP) +MAP_OP(2, PUSH_NULL) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(30, GET_LEN) +MAP_OP(31, MATCH_MAPPING) +MAP_OP(32, MATCH_SEQUENCE) +MAP_OP(33, MATCH_KEYS) +MAP_OP(35, PUSH_EXC_INFO) +MAP_OP(36, CHECK_EXC_MATCH) +MAP_OP(37, CHECK_EG_MATCH) +MAP_OP(49, WITH_EXCEPT_START) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(53, BEFORE_WITH) +MAP_OP(54, END_ASYNC_FOR) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(74, LOAD_ASSERTION_ERROR) +MAP_OP(75, RETURN_GENERATOR) +MAP_OP(82, LIST_TO_TUPLE) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, ASYNC_GEN_WRAP) +MAP_OP(88, PREP_RERAISE_STAR) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, SWAP_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(114, POP_JUMP_FORWARD_IF_FALSE_A) +MAP_OP(115, POP_JUMP_FORWARD_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, IS_OP_A) +MAP_OP(118, CONTAINS_OP_A) +MAP_OP(119, RERAISE_A) +MAP_OP(120, COPY_A) +MAP_OP(122, BINARY_OP_A) +MAP_OP(123, SEND_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(128, POP_JUMP_FORWARD_IF_NOT_NONE_A) +MAP_OP(129, POP_JUMP_FORWARD_IF_NONE_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, GET_AWAITABLE_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A) +MAP_OP(135, MAKE_CELL_A) +MAP_OP(136, LOAD_CLOSURE_A) +MAP_OP(137, LOAD_DEREF_A) +MAP_OP(138, STORE_DEREF_A) +MAP_OP(139, DELETE_DEREF_A) +MAP_OP(140, JUMP_BACKWARD_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(149, COPY_FREE_VARS_A) +MAP_OP(151, RESUME_A) +MAP_OP(152, MATCH_CLASS_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(160, LOAD_METHOD_A) +MAP_OP(162, LIST_EXTEND_A) +MAP_OP(163, SET_UPDATE_A) +MAP_OP(164, DICT_MERGE_A) +MAP_OP(165, DICT_UPDATE_A) +MAP_OP(166, PRECALL_A) +MAP_OP(171, CALL_A) +MAP_OP(172, KW_NAMES_A) +MAP_OP(173, POP_JUMP_BACKWARD_IF_NOT_NONE_A) +MAP_OP(174, POP_JUMP_BACKWARD_IF_NONE_A) +MAP_OP(175, POP_JUMP_BACKWARD_IF_FALSE_A) +MAP_OP(176, POP_JUMP_BACKWARD_IF_TRUE_A) END_MAP() diff --git a/bytes/python_3_12.cpp b/bytes/python_3_12.cpp index c990d3c71..6bea1455f 100644 --- a/bytes/python_3_12.cpp +++ b/bytes/python_3_12.cpp @@ -1,133 +1,133 @@ #include "bytecode_map.h" BEGIN_MAP(3, 12) - MAP_OP(0, CACHE) - MAP_OP(1, POP_TOP) - MAP_OP(2, PUSH_NULL) - MAP_OP(3, INTERPRETER_EXIT) - MAP_OP(4, END_FOR) - MAP_OP(5, END_SEND) - MAP_OP(9, NOP) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(17, RESERVED) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_SLICE) - MAP_OP(27, STORE_SLICE) - MAP_OP(30, GET_LEN) - MAP_OP(31, MATCH_MAPPING) - MAP_OP(32, MATCH_SEQUENCE) - MAP_OP(33, MATCH_KEYS) - MAP_OP(35, PUSH_EXC_INFO) - MAP_OP(36, CHECK_EXC_MATCH) - MAP_OP(37, CHECK_EG_MATCH) - MAP_OP(49, WITH_EXCEPT_START) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(53, BEFORE_WITH) - MAP_OP(54, END_ASYNC_FOR) - MAP_OP(55, CLEANUP_THROW) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(74, LOAD_ASSERTION_ERROR) - MAP_OP(75, RETURN_GENERATOR) - MAP_OP(83, RETURN_VALUE) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(87, LOAD_LOCALS) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(99, SWAP_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, IS_OP_A) - MAP_OP(118, CONTAINS_OP_A) - MAP_OP(119, RERAISE_A) - MAP_OP(120, COPY_A) - MAP_OP(121, RETURN_CONST_A) - MAP_OP(122, BINARY_OP_A) - MAP_OP(123, SEND_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, LOAD_FAST_CHECK_A) - MAP_OP(128, POP_JUMP_IF_NOT_NONE_A) - MAP_OP(129, POP_JUMP_IF_NONE_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, GET_AWAITABLE_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A) - MAP_OP(135, MAKE_CELL_A) - MAP_OP(136, LOAD_CLOSURE_A) - MAP_OP(137, LOAD_DEREF_A) - MAP_OP(138, STORE_DEREF_A) - MAP_OP(139, DELETE_DEREF_A) - MAP_OP(140, JUMP_BACKWARD_A) - MAP_OP(141, LOAD_SUPER_ATTR_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, LOAD_FAST_AND_CLEAR_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(149, COPY_FREE_VARS_A) - MAP_OP(150, YIELD_VALUE_A) - MAP_OP(151, RESUME_A) - MAP_OP(152, MATCH_CLASS_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(162, LIST_EXTEND_A) - MAP_OP(163, SET_UPDATE_A) - MAP_OP(164, DICT_MERGE_A) - MAP_OP(165, DICT_UPDATE_A) - MAP_OP(171, CALL_A) - MAP_OP(172, KW_NAMES_A) - MAP_OP(173, CALL_INTRINSIC_1_A) - MAP_OP(174, CALL_INTRINSIC_2_A) - MAP_OP(175, LOAD_FROM_DICT_OR_GLOBALS_A) - MAP_OP(176, LOAD_FROM_DICT_OR_DEREF_A) - MAP_OP(237, INSTRUMENTED_LOAD_SUPER_ATTR_A) - MAP_OP(238, INSTRUMENTED_POP_JUMP_IF_NONE_A) - MAP_OP(239, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A) - MAP_OP(240, INSTRUMENTED_RESUME_A) - MAP_OP(241, INSTRUMENTED_CALL_A) - MAP_OP(242, INSTRUMENTED_RETURN_VALUE_A) - MAP_OP(243, INSTRUMENTED_YIELD_VALUE_A) - MAP_OP(244, INSTRUMENTED_CALL_FUNCTION_EX_A) - MAP_OP(245, INSTRUMENTED_JUMP_FORWARD_A) - MAP_OP(246, INSTRUMENTED_JUMP_BACKWARD_A) - MAP_OP(247, INSTRUMENTED_RETURN_CONST_A) - MAP_OP(248, INSTRUMENTED_FOR_ITER_A) - MAP_OP(249, INSTRUMENTED_POP_JUMP_IF_FALSE_A) - MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A) - MAP_OP(251, INSTRUMENTED_END_FOR_A) - MAP_OP(252, INSTRUMENTED_END_SEND_A) - MAP_OP(253, INSTRUMENTED_INSTRUCTION_A) - MAP_OP(254, INSTRUMENTED_LINE_A) +MAP_OP(0, CACHE) +MAP_OP(1, POP_TOP) +MAP_OP(2, PUSH_NULL) +MAP_OP(3, INTERPRETER_EXIT) +MAP_OP(4, END_FOR) +MAP_OP(5, END_SEND) +MAP_OP(9, NOP) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(17, RESERVED) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_SLICE) +MAP_OP(27, STORE_SLICE) +MAP_OP(30, GET_LEN) +MAP_OP(31, MATCH_MAPPING) +MAP_OP(32, MATCH_SEQUENCE) +MAP_OP(33, MATCH_KEYS) +MAP_OP(35, PUSH_EXC_INFO) +MAP_OP(36, CHECK_EXC_MATCH) +MAP_OP(37, CHECK_EG_MATCH) +MAP_OP(49, WITH_EXCEPT_START) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(53, BEFORE_WITH) +MAP_OP(54, END_ASYNC_FOR) +MAP_OP(55, CLEANUP_THROW) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(74, LOAD_ASSERTION_ERROR) +MAP_OP(75, RETURN_GENERATOR) +MAP_OP(83, RETURN_VALUE) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(87, LOAD_LOCALS) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(99, SWAP_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, IS_OP_A) +MAP_OP(118, CONTAINS_OP_A) +MAP_OP(119, RERAISE_A) +MAP_OP(120, COPY_A) +MAP_OP(121, RETURN_CONST_A) +MAP_OP(122, BINARY_OP_A) +MAP_OP(123, SEND_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, LOAD_FAST_CHECK_A) +MAP_OP(128, POP_JUMP_IF_NOT_NONE_A) +MAP_OP(129, POP_JUMP_IF_NONE_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, GET_AWAITABLE_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A) +MAP_OP(135, MAKE_CELL_A) +MAP_OP(136, LOAD_CLOSURE_A) +MAP_OP(137, LOAD_DEREF_A) +MAP_OP(138, STORE_DEREF_A) +MAP_OP(139, DELETE_DEREF_A) +MAP_OP(140, JUMP_BACKWARD_A) +MAP_OP(141, LOAD_SUPER_ATTR_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, LOAD_FAST_AND_CLEAR_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(149, COPY_FREE_VARS_A) +MAP_OP(150, YIELD_VALUE_A) +MAP_OP(151, RESUME_A) +MAP_OP(152, MATCH_CLASS_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(162, LIST_EXTEND_A) +MAP_OP(163, SET_UPDATE_A) +MAP_OP(164, DICT_MERGE_A) +MAP_OP(165, DICT_UPDATE_A) +MAP_OP(171, CALL_A) +MAP_OP(172, KW_NAMES_A) +MAP_OP(173, CALL_INTRINSIC_1_A) +MAP_OP(174, CALL_INTRINSIC_2_A) +MAP_OP(175, LOAD_FROM_DICT_OR_GLOBALS_A) +MAP_OP(176, LOAD_FROM_DICT_OR_DEREF_A) +MAP_OP(237, INSTRUMENTED_LOAD_SUPER_ATTR_A) +MAP_OP(238, INSTRUMENTED_POP_JUMP_IF_NONE_A) +MAP_OP(239, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A) +MAP_OP(240, INSTRUMENTED_RESUME_A) +MAP_OP(241, INSTRUMENTED_CALL_A) +MAP_OP(242, INSTRUMENTED_RETURN_VALUE_A) +MAP_OP(243, INSTRUMENTED_YIELD_VALUE_A) +MAP_OP(244, INSTRUMENTED_CALL_FUNCTION_EX_A) +MAP_OP(245, INSTRUMENTED_JUMP_FORWARD_A) +MAP_OP(246, INSTRUMENTED_JUMP_BACKWARD_A) +MAP_OP(247, INSTRUMENTED_RETURN_CONST_A) +MAP_OP(248, INSTRUMENTED_FOR_ITER_A) +MAP_OP(249, INSTRUMENTED_POP_JUMP_IF_FALSE_A) +MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A) +MAP_OP(251, INSTRUMENTED_END_FOR_A) +MAP_OP(252, INSTRUMENTED_END_SEND_A) +MAP_OP(253, INSTRUMENTED_INSTRUCTION_A) +MAP_OP(254, INSTRUMENTED_LINE_A) END_MAP() diff --git a/bytes/python_3_13.cpp b/bytes/python_3_13.cpp index 3709a1059..c3d2dac39 100644 --- a/bytes/python_3_13.cpp +++ b/bytes/python_3_13.cpp @@ -1,142 +1,142 @@ #include "bytecode_map.h" BEGIN_MAP(3, 13) - MAP_OP(0, CACHE) - MAP_OP(1, BEFORE_ASYNC_WITH) - MAP_OP(2, BEFORE_WITH) - MAP_OP(4, BINARY_SLICE) - MAP_OP(5, BINARY_SUBSCR) - MAP_OP(6, CHECK_EG_MATCH) - MAP_OP(7, CHECK_EXC_MATCH) - MAP_OP(8, CLEANUP_THROW) - MAP_OP(9, DELETE_SUBSCR) - MAP_OP(10, END_ASYNC_FOR) - MAP_OP(11, END_FOR) - MAP_OP(12, END_SEND) - MAP_OP(13, EXIT_INIT_CHECK) - MAP_OP(14, FORMAT_SIMPLE) - MAP_OP(15, FORMAT_WITH_SPEC) - MAP_OP(16, GET_AITER) - MAP_OP(17, RESERVED) - MAP_OP(18, GET_ANEXT) - MAP_OP(19, GET_ITER) - MAP_OP(20, GET_LEN) - MAP_OP(21, GET_YIELD_FROM_ITER) - MAP_OP(22, INTERPRETER_EXIT) - MAP_OP(23, LOAD_ASSERTION_ERROR) - MAP_OP(24, LOAD_BUILD_CLASS) - MAP_OP(25, LOAD_LOCALS) - MAP_OP(26, MAKE_FUNCTION) - MAP_OP(27, MATCH_KEYS) - MAP_OP(28, MATCH_MAPPING) - MAP_OP(29, MATCH_SEQUENCE) - MAP_OP(30, NOP) - MAP_OP(31, POP_EXCEPT) - MAP_OP(32, POP_TOP) - MAP_OP(33, PUSH_EXC_INFO) - MAP_OP(34, PUSH_NULL) - MAP_OP(35, RETURN_GENERATOR) - MAP_OP(36, RETURN_VALUE) - MAP_OP(37, SETUP_ANNOTATIONS) - MAP_OP(38, STORE_SLICE) - MAP_OP(39, STORE_SUBSCR) - MAP_OP(40, TO_BOOL) - MAP_OP(41, UNARY_INVERT) - MAP_OP(42, UNARY_NEGATIVE) - MAP_OP(43, UNARY_NOT) - MAP_OP(44, WITH_EXCEPT_START) - MAP_OP(45, BINARY_OP_A) - MAP_OP(46, BUILD_CONST_KEY_MAP_A) - MAP_OP(47, BUILD_LIST_A) - MAP_OP(48, BUILD_MAP_A) - MAP_OP(49, BUILD_SET_A) - MAP_OP(50, BUILD_SLICE_A) - MAP_OP(51, BUILD_STRING_A) - MAP_OP(52, BUILD_TUPLE_A) - MAP_OP(53, CALL_A) - MAP_OP(54, CALL_FUNCTION_EX_A) - MAP_OP(55, CALL_INTRINSIC_1_A) - MAP_OP(56, CALL_INTRINSIC_2_A) - MAP_OP(57, CALL_KW_A) - MAP_OP(58, COMPARE_OP_A) - MAP_OP(59, CONTAINS_OP_A) - MAP_OP(60, CONVERT_VALUE_A) - MAP_OP(61, COPY_A) - MAP_OP(62, COPY_FREE_VARS_A) - MAP_OP(63, DELETE_ATTR_A) - MAP_OP(64, DELETE_DEREF_A) - MAP_OP(65, DELETE_FAST_A) - MAP_OP(66, DELETE_GLOBAL_A) - MAP_OP(67, DELETE_NAME_A) - MAP_OP(68, DICT_MERGE_A) - MAP_OP(69, DICT_UPDATE_A) - MAP_OP(70, ENTER_EXECUTOR_A) - MAP_OP(71, EXTENDED_ARG_A) - MAP_OP(72, FOR_ITER_A) - MAP_OP(73, GET_AWAITABLE_A) - MAP_OP(74, IMPORT_FROM_A) - MAP_OP(75, IMPORT_NAME_A) - MAP_OP(76, IS_OP_A) - MAP_OP(77, JUMP_BACKWARD_A) - MAP_OP(78, JUMP_BACKWARD_NO_INTERRUPT_A) - MAP_OP(79, JUMP_FORWARD_A) - MAP_OP(80, LIST_APPEND_A) - MAP_OP(81, LIST_EXTEND_A) - MAP_OP(82, LOAD_ATTR_A) - MAP_OP(83, LOAD_CONST_A) - MAP_OP(84, LOAD_DEREF_A) - MAP_OP(85, LOAD_FAST_A) - MAP_OP(86, LOAD_FAST_AND_CLEAR_A) - MAP_OP(87, LOAD_FAST_CHECK_A) - MAP_OP(88, LOAD_FAST_LOAD_FAST_A) - MAP_OP(89, LOAD_FROM_DICT_OR_DEREF_A) - MAP_OP(90, LOAD_FROM_DICT_OR_GLOBALS_A) - MAP_OP(91, LOAD_GLOBAL_A) - MAP_OP(92, LOAD_NAME_A) - MAP_OP(93, LOAD_SUPER_ATTR_A) - MAP_OP(94, MAKE_CELL_A) - MAP_OP(95, MAP_ADD_A) - MAP_OP(96, MATCH_CLASS_A) - MAP_OP(97, POP_JUMP_IF_FALSE_A) - MAP_OP(98, POP_JUMP_IF_NONE_A) - MAP_OP(99, POP_JUMP_IF_NOT_NONE_A) - MAP_OP(100, POP_JUMP_IF_TRUE_A) - MAP_OP(101, RAISE_VARARGS_A) - MAP_OP(102, RERAISE_A) - MAP_OP(103, RETURN_CONST_A) - MAP_OP(104, SEND_A) - MAP_OP(105, SET_ADD_A) - MAP_OP(106, SET_FUNCTION_ATTRIBUTE_A) - MAP_OP(107, SET_UPDATE_A) - MAP_OP(108, STORE_ATTR_A) - MAP_OP(109, STORE_DEREF_A) - MAP_OP(110, STORE_FAST_A) - MAP_OP(111, STORE_FAST_LOAD_FAST_A) - MAP_OP(112, STORE_FAST_STORE_FAST_A) - MAP_OP(113, STORE_GLOBAL_A) - MAP_OP(114, STORE_NAME_A) - MAP_OP(115, SWAP_A) - MAP_OP(116, UNPACK_EX_A) - MAP_OP(117, UNPACK_SEQUENCE_A) - MAP_OP(118, YIELD_VALUE_A) - MAP_OP(149, RESUME_A) - MAP_OP(236, INSTRUMENTED_RESUME_A) - MAP_OP(237, INSTRUMENTED_END_FOR_A) - MAP_OP(238, INSTRUMENTED_END_SEND_A) - MAP_OP(239, INSTRUMENTED_RETURN_VALUE_A) - MAP_OP(240, INSTRUMENTED_RETURN_CONST_A) - MAP_OP(241, INSTRUMENTED_YIELD_VALUE_A) - MAP_OP(242, INSTRUMENTED_LOAD_SUPER_ATTR_A) - MAP_OP(243, INSTRUMENTED_FOR_ITER_A) - MAP_OP(244, INSTRUMENTED_CALL_A) - MAP_OP(245, INSTRUMENTED_CALL_KW_A) - MAP_OP(246, INSTRUMENTED_CALL_FUNCTION_EX_A) - MAP_OP(247, INSTRUMENTED_INSTRUCTION_A) - MAP_OP(248, INSTRUMENTED_JUMP_FORWARD_A) - MAP_OP(249, INSTRUMENTED_JUMP_BACKWARD_A) - MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A) - MAP_OP(251, INSTRUMENTED_POP_JUMP_IF_FALSE_A) - MAP_OP(252, INSTRUMENTED_POP_JUMP_IF_NONE_A) - MAP_OP(253, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A) - MAP_OP(254, INSTRUMENTED_LINE_A) +MAP_OP(0, CACHE) +MAP_OP(1, BEFORE_ASYNC_WITH) +MAP_OP(2, BEFORE_WITH) +MAP_OP(4, BINARY_SLICE) +MAP_OP(5, BINARY_SUBSCR) +MAP_OP(6, CHECK_EG_MATCH) +MAP_OP(7, CHECK_EXC_MATCH) +MAP_OP(8, CLEANUP_THROW) +MAP_OP(9, DELETE_SUBSCR) +MAP_OP(10, END_ASYNC_FOR) +MAP_OP(11, END_FOR) +MAP_OP(12, END_SEND) +MAP_OP(13, EXIT_INIT_CHECK) +MAP_OP(14, FORMAT_SIMPLE) +MAP_OP(15, FORMAT_WITH_SPEC) +MAP_OP(16, GET_AITER) +MAP_OP(17, RESERVED) +MAP_OP(18, GET_ANEXT) +MAP_OP(19, GET_ITER) +MAP_OP(20, GET_LEN) +MAP_OP(21, GET_YIELD_FROM_ITER) +MAP_OP(22, INTERPRETER_EXIT) +MAP_OP(23, LOAD_ASSERTION_ERROR) +MAP_OP(24, LOAD_BUILD_CLASS) +MAP_OP(25, LOAD_LOCALS) +MAP_OP(26, MAKE_FUNCTION) +MAP_OP(27, MATCH_KEYS) +MAP_OP(28, MATCH_MAPPING) +MAP_OP(29, MATCH_SEQUENCE) +MAP_OP(30, NOP) +MAP_OP(31, POP_EXCEPT) +MAP_OP(32, POP_TOP) +MAP_OP(33, PUSH_EXC_INFO) +MAP_OP(34, PUSH_NULL) +MAP_OP(35, RETURN_GENERATOR) +MAP_OP(36, RETURN_VALUE) +MAP_OP(37, SETUP_ANNOTATIONS) +MAP_OP(38, STORE_SLICE) +MAP_OP(39, STORE_SUBSCR) +MAP_OP(40, TO_BOOL) +MAP_OP(41, UNARY_INVERT) +MAP_OP(42, UNARY_NEGATIVE) +MAP_OP(43, UNARY_NOT) +MAP_OP(44, WITH_EXCEPT_START) +MAP_OP(45, BINARY_OP_A) +MAP_OP(46, BUILD_CONST_KEY_MAP_A) +MAP_OP(47, BUILD_LIST_A) +MAP_OP(48, BUILD_MAP_A) +MAP_OP(49, BUILD_SET_A) +MAP_OP(50, BUILD_SLICE_A) +MAP_OP(51, BUILD_STRING_A) +MAP_OP(52, BUILD_TUPLE_A) +MAP_OP(53, CALL_A) +MAP_OP(54, CALL_FUNCTION_EX_A) +MAP_OP(55, CALL_INTRINSIC_1_A) +MAP_OP(56, CALL_INTRINSIC_2_A) +MAP_OP(57, CALL_KW_A) +MAP_OP(58, COMPARE_OP_A) +MAP_OP(59, CONTAINS_OP_A) +MAP_OP(60, CONVERT_VALUE_A) +MAP_OP(61, COPY_A) +MAP_OP(62, COPY_FREE_VARS_A) +MAP_OP(63, DELETE_ATTR_A) +MAP_OP(64, DELETE_DEREF_A) +MAP_OP(65, DELETE_FAST_A) +MAP_OP(66, DELETE_GLOBAL_A) +MAP_OP(67, DELETE_NAME_A) +MAP_OP(68, DICT_MERGE_A) +MAP_OP(69, DICT_UPDATE_A) +MAP_OP(70, ENTER_EXECUTOR_A) +MAP_OP(71, EXTENDED_ARG_A) +MAP_OP(72, FOR_ITER_A) +MAP_OP(73, GET_AWAITABLE_A) +MAP_OP(74, IMPORT_FROM_A) +MAP_OP(75, IMPORT_NAME_A) +MAP_OP(76, IS_OP_A) +MAP_OP(77, JUMP_BACKWARD_A) +MAP_OP(78, JUMP_BACKWARD_NO_INTERRUPT_A) +MAP_OP(79, JUMP_FORWARD_A) +MAP_OP(80, LIST_APPEND_A) +MAP_OP(81, LIST_EXTEND_A) +MAP_OP(82, LOAD_ATTR_A) +MAP_OP(83, LOAD_CONST_A) +MAP_OP(84, LOAD_DEREF_A) +MAP_OP(85, LOAD_FAST_A) +MAP_OP(86, LOAD_FAST_AND_CLEAR_A) +MAP_OP(87, LOAD_FAST_CHECK_A) +MAP_OP(88, LOAD_FAST_LOAD_FAST_A) +MAP_OP(89, LOAD_FROM_DICT_OR_DEREF_A) +MAP_OP(90, LOAD_FROM_DICT_OR_GLOBALS_A) +MAP_OP(91, LOAD_GLOBAL_A) +MAP_OP(92, LOAD_NAME_A) +MAP_OP(93, LOAD_SUPER_ATTR_A) +MAP_OP(94, MAKE_CELL_A) +MAP_OP(95, MAP_ADD_A) +MAP_OP(96, MATCH_CLASS_A) +MAP_OP(97, POP_JUMP_IF_FALSE_A) +MAP_OP(98, POP_JUMP_IF_NONE_A) +MAP_OP(99, POP_JUMP_IF_NOT_NONE_A) +MAP_OP(100, POP_JUMP_IF_TRUE_A) +MAP_OP(101, RAISE_VARARGS_A) +MAP_OP(102, RERAISE_A) +MAP_OP(103, RETURN_CONST_A) +MAP_OP(104, SEND_A) +MAP_OP(105, SET_ADD_A) +MAP_OP(106, SET_FUNCTION_ATTRIBUTE_A) +MAP_OP(107, SET_UPDATE_A) +MAP_OP(108, STORE_ATTR_A) +MAP_OP(109, STORE_DEREF_A) +MAP_OP(110, STORE_FAST_A) +MAP_OP(111, STORE_FAST_LOAD_FAST_A) +MAP_OP(112, STORE_FAST_STORE_FAST_A) +MAP_OP(113, STORE_GLOBAL_A) +MAP_OP(114, STORE_NAME_A) +MAP_OP(115, SWAP_A) +MAP_OP(116, UNPACK_EX_A) +MAP_OP(117, UNPACK_SEQUENCE_A) +MAP_OP(118, YIELD_VALUE_A) +MAP_OP(149, RESUME_A) +MAP_OP(236, INSTRUMENTED_RESUME_A) +MAP_OP(237, INSTRUMENTED_END_FOR_A) +MAP_OP(238, INSTRUMENTED_END_SEND_A) +MAP_OP(239, INSTRUMENTED_RETURN_VALUE_A) +MAP_OP(240, INSTRUMENTED_RETURN_CONST_A) +MAP_OP(241, INSTRUMENTED_YIELD_VALUE_A) +MAP_OP(242, INSTRUMENTED_LOAD_SUPER_ATTR_A) +MAP_OP(243, INSTRUMENTED_FOR_ITER_A) +MAP_OP(244, INSTRUMENTED_CALL_A) +MAP_OP(245, INSTRUMENTED_CALL_KW_A) +MAP_OP(246, INSTRUMENTED_CALL_FUNCTION_EX_A) +MAP_OP(247, INSTRUMENTED_INSTRUCTION_A) +MAP_OP(248, INSTRUMENTED_JUMP_FORWARD_A) +MAP_OP(249, INSTRUMENTED_JUMP_BACKWARD_A) +MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A) +MAP_OP(251, INSTRUMENTED_POP_JUMP_IF_FALSE_A) +MAP_OP(252, INSTRUMENTED_POP_JUMP_IF_NONE_A) +MAP_OP(253, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A) +MAP_OP(254, INSTRUMENTED_LINE_A) END_MAP() diff --git a/bytes/python_3_2.cpp b/bytes/python_3_2.cpp index 5c6a78b09..2d80edc96 100644 --- a/bytes/python_3_2.cpp +++ b/bytes/python_3_2.cpp @@ -1,105 +1,105 @@ #include "bytecode_map.h" BEGIN_MAP(3, 2) - MAP_OP(0, STOP_CODE) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, STORE_LOCALS) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) +MAP_OP(0, STOP_CODE) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, STORE_LOCALS) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) END_MAP() diff --git a/bytes/python_3_3.cpp b/bytes/python_3_3.cpp index b309a421f..fb2473269 100644 --- a/bytes/python_3_3.cpp +++ b/bytes/python_3_3.cpp @@ -1,105 +1,105 @@ #include "bytecode_map.h" BEGIN_MAP(3, 3) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, STORE_LOCALS) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, STORE_LOCALS) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) END_MAP() diff --git a/bytes/python_3_4.cpp b/bytes/python_3_4.cpp index 786ee20da..1dcb0d682 100644 --- a/bytes/python_3_4.cpp +++ b/bytes/python_3_4.cpp @@ -1,105 +1,105 @@ #include "bytecode_map.h" BEGIN_MAP(3, 4) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(54, STORE_MAP) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(54, STORE_MAP) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) END_MAP() diff --git a/bytes/python_3_5.cpp b/bytes/python_3_5.cpp index 2fc30986d..b5907c39f 100644 --- a/bytes/python_3_5.cpp +++ b/bytes/python_3_5.cpp @@ -1,118 +1,118 @@ #include "bytecode_map.h" BEGIN_MAP(3, 5) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP_START) - MAP_OP(82, WITH_CLEANUP_FINISH) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(134, MAKE_CLOSURE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(140, CALL_FUNCTION_VAR_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_VAR_KW_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(149, BUILD_LIST_UNPACK_A) - MAP_OP(150, BUILD_MAP_UNPACK_A) - MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) - MAP_OP(152, BUILD_TUPLE_UNPACK_A) - MAP_OP(153, BUILD_SET_UNPACK_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP_START) +MAP_OP(82, WITH_CLEANUP_FINISH) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(134, MAKE_CLOSURE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(140, CALL_FUNCTION_VAR_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_VAR_KW_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(149, BUILD_LIST_UNPACK_A) +MAP_OP(150, BUILD_MAP_UNPACK_A) +MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) +MAP_OP(152, BUILD_TUPLE_UNPACK_A) +MAP_OP(153, BUILD_SET_UNPACK_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) END_MAP() diff --git a/bytes/python_3_6.cpp b/bytes/python_3_6.cpp index fa9d430c7..0cba0a409 100644 --- a/bytes/python_3_6.cpp +++ b/bytes/python_3_6.cpp @@ -1,122 +1,122 @@ #include "bytecode_map.h" BEGIN_MAP(3, 6) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP_START) - MAP_OP(82, WITH_CLEANUP_FINISH) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(127, STORE_ANNOTATION_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(149, BUILD_LIST_UNPACK_A) - MAP_OP(150, BUILD_MAP_UNPACK_A) - MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) - MAP_OP(152, BUILD_TUPLE_UNPACK_A) - MAP_OP(153, BUILD_SET_UNPACK_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP_START) +MAP_OP(82, WITH_CLEANUP_FINISH) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(127, STORE_ANNOTATION_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(149, BUILD_LIST_UNPACK_A) +MAP_OP(150, BUILD_MAP_UNPACK_A) +MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) +MAP_OP(152, BUILD_TUPLE_UNPACK_A) +MAP_OP(153, BUILD_SET_UNPACK_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) END_MAP() diff --git a/bytes/python_3_7.cpp b/bytes/python_3_7.cpp index c52adac38..ae0e571f7 100644 --- a/bytes/python_3_7.cpp +++ b/bytes/python_3_7.cpp @@ -1,123 +1,123 @@ #include "bytecode_map.h" BEGIN_MAP(3, 7) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(80, BREAK_LOOP) - MAP_OP(81, WITH_CLEANUP_START) - MAP_OP(82, WITH_CLEANUP_FINISH) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(119, CONTINUE_LOOP_A) - MAP_OP(120, SETUP_LOOP_A) - MAP_OP(121, SETUP_EXCEPT_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(149, BUILD_LIST_UNPACK_A) - MAP_OP(150, BUILD_MAP_UNPACK_A) - MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) - MAP_OP(152, BUILD_TUPLE_UNPACK_A) - MAP_OP(153, BUILD_SET_UNPACK_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) - MAP_OP(160, LOAD_METHOD_A) - MAP_OP(161, CALL_METHOD_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(80, BREAK_LOOP) +MAP_OP(81, WITH_CLEANUP_START) +MAP_OP(82, WITH_CLEANUP_FINISH) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(119, CONTINUE_LOOP_A) +MAP_OP(120, SETUP_LOOP_A) +MAP_OP(121, SETUP_EXCEPT_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(149, BUILD_LIST_UNPACK_A) +MAP_OP(150, BUILD_MAP_UNPACK_A) +MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) +MAP_OP(152, BUILD_TUPLE_UNPACK_A) +MAP_OP(153, BUILD_SET_UNPACK_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) +MAP_OP(160, LOAD_METHOD_A) +MAP_OP(161, CALL_METHOD_A) END_MAP() diff --git a/bytes/python_3_8.cpp b/bytes/python_3_8.cpp index 76ed41229..6bf7e511a 100644 --- a/bytes/python_3_8.cpp +++ b/bytes/python_3_8.cpp @@ -1,124 +1,124 @@ #include "bytecode_map.h" BEGIN_MAP(3, 8) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(6, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(53, BEGIN_FINALLY) - MAP_OP(54, END_ASYNC_FOR) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(81, WITH_CLEANUP_START) - MAP_OP(82, WITH_CLEANUP_FINISH) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(88, END_FINALLY) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(149, BUILD_LIST_UNPACK_A) - MAP_OP(150, BUILD_MAP_UNPACK_A) - MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) - MAP_OP(152, BUILD_TUPLE_UNPACK_A) - MAP_OP(153, BUILD_SET_UNPACK_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) - MAP_OP(160, LOAD_METHOD_A) - MAP_OP(161, CALL_METHOD_A) - MAP_OP(162, CALL_FINALLY_A) - MAP_OP(163, POP_FINALLY_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(6, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(53, BEGIN_FINALLY) +MAP_OP(54, END_ASYNC_FOR) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(81, WITH_CLEANUP_START) +MAP_OP(82, WITH_CLEANUP_FINISH) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(88, END_FINALLY) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(149, BUILD_LIST_UNPACK_A) +MAP_OP(150, BUILD_MAP_UNPACK_A) +MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A) +MAP_OP(152, BUILD_TUPLE_UNPACK_A) +MAP_OP(153, BUILD_SET_UNPACK_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A) +MAP_OP(160, LOAD_METHOD_A) +MAP_OP(161, CALL_METHOD_A) +MAP_OP(162, CALL_FINALLY_A) +MAP_OP(163, POP_FINALLY_A) END_MAP() diff --git a/bytes/python_3_9.cpp b/bytes/python_3_9.cpp index f4ca606a7..18c561d33 100644 --- a/bytes/python_3_9.cpp +++ b/bytes/python_3_9.cpp @@ -1,123 +1,123 @@ #include "bytecode_map.h" BEGIN_MAP(3, 9) - MAP_OP(1, POP_TOP) - MAP_OP(2, ROT_TWO) - MAP_OP(3, ROT_THREE) - MAP_OP(4, DUP_TOP) - MAP_OP(5, DUP_TOP_TWO) - MAP_OP(6, ROT_FOUR) - MAP_OP(9, NOP) - MAP_OP(10, UNARY_POSITIVE) - MAP_OP(11, UNARY_NEGATIVE) - MAP_OP(12, UNARY_NOT) - MAP_OP(15, UNARY_INVERT) - MAP_OP(16, BINARY_MATRIX_MULTIPLY) - MAP_OP(17, INPLACE_MATRIX_MULTIPLY) - MAP_OP(19, BINARY_POWER) - MAP_OP(20, BINARY_MULTIPLY) - MAP_OP(22, BINARY_MODULO) - MAP_OP(23, BINARY_ADD) - MAP_OP(24, BINARY_SUBTRACT) - MAP_OP(25, BINARY_SUBSCR) - MAP_OP(26, BINARY_FLOOR_DIVIDE) - MAP_OP(27, BINARY_TRUE_DIVIDE) - MAP_OP(28, INPLACE_FLOOR_DIVIDE) - MAP_OP(29, INPLACE_TRUE_DIVIDE) - MAP_OP(48, RERAISE) - MAP_OP(49, WITH_EXCEPT_START) - MAP_OP(50, GET_AITER) - MAP_OP(51, GET_ANEXT) - MAP_OP(52, BEFORE_ASYNC_WITH) - MAP_OP(54, END_ASYNC_FOR) - MAP_OP(55, INPLACE_ADD) - MAP_OP(56, INPLACE_SUBTRACT) - MAP_OP(57, INPLACE_MULTIPLY) - MAP_OP(59, INPLACE_MODULO) - MAP_OP(60, STORE_SUBSCR) - MAP_OP(61, DELETE_SUBSCR) - MAP_OP(62, BINARY_LSHIFT) - MAP_OP(63, BINARY_RSHIFT) - MAP_OP(64, BINARY_AND) - MAP_OP(65, BINARY_XOR) - MAP_OP(66, BINARY_OR) - MAP_OP(67, INPLACE_POWER) - MAP_OP(68, GET_ITER) - MAP_OP(69, GET_YIELD_FROM_ITER) - MAP_OP(70, PRINT_EXPR) - MAP_OP(71, LOAD_BUILD_CLASS) - MAP_OP(72, YIELD_FROM) - MAP_OP(73, GET_AWAITABLE) - MAP_OP(74, LOAD_ASSERTION_ERROR) - MAP_OP(75, INPLACE_LSHIFT) - MAP_OP(76, INPLACE_RSHIFT) - MAP_OP(77, INPLACE_AND) - MAP_OP(78, INPLACE_XOR) - MAP_OP(79, INPLACE_OR) - MAP_OP(82, LIST_TO_TUPLE) - MAP_OP(83, RETURN_VALUE) - MAP_OP(84, IMPORT_STAR) - MAP_OP(85, SETUP_ANNOTATIONS) - MAP_OP(86, YIELD_VALUE) - MAP_OP(87, POP_BLOCK) - MAP_OP(89, POP_EXCEPT) - MAP_OP(90, STORE_NAME_A) - MAP_OP(91, DELETE_NAME_A) - MAP_OP(92, UNPACK_SEQUENCE_A) - MAP_OP(93, FOR_ITER_A) - MAP_OP(94, UNPACK_EX_A) - MAP_OP(95, STORE_ATTR_A) - MAP_OP(96, DELETE_ATTR_A) - MAP_OP(97, STORE_GLOBAL_A) - MAP_OP(98, DELETE_GLOBAL_A) - MAP_OP(100, LOAD_CONST_A) - MAP_OP(101, LOAD_NAME_A) - MAP_OP(102, BUILD_TUPLE_A) - MAP_OP(103, BUILD_LIST_A) - MAP_OP(104, BUILD_SET_A) - MAP_OP(105, BUILD_MAP_A) - MAP_OP(106, LOAD_ATTR_A) - MAP_OP(107, COMPARE_OP_A) - MAP_OP(108, IMPORT_NAME_A) - MAP_OP(109, IMPORT_FROM_A) - MAP_OP(110, JUMP_FORWARD_A) - MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) - MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) - MAP_OP(113, JUMP_ABSOLUTE_A) - MAP_OP(114, POP_JUMP_IF_FALSE_A) - MAP_OP(115, POP_JUMP_IF_TRUE_A) - MAP_OP(116, LOAD_GLOBAL_A) - MAP_OP(117, IS_OP_A) - MAP_OP(118, CONTAINS_OP_A) - MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A) - MAP_OP(122, SETUP_FINALLY_A) - MAP_OP(124, LOAD_FAST_A) - MAP_OP(125, STORE_FAST_A) - MAP_OP(126, DELETE_FAST_A) - MAP_OP(130, RAISE_VARARGS_A) - MAP_OP(131, CALL_FUNCTION_A) - MAP_OP(132, MAKE_FUNCTION_A) - MAP_OP(133, BUILD_SLICE_A) - MAP_OP(135, LOAD_CLOSURE_A) - MAP_OP(136, LOAD_DEREF_A) - MAP_OP(137, STORE_DEREF_A) - MAP_OP(138, DELETE_DEREF_A) - MAP_OP(141, CALL_FUNCTION_KW_A) - MAP_OP(142, CALL_FUNCTION_EX_A) - MAP_OP(143, SETUP_WITH_A) - MAP_OP(144, EXTENDED_ARG_A) - MAP_OP(145, LIST_APPEND_A) - MAP_OP(146, SET_ADD_A) - MAP_OP(147, MAP_ADD_A) - MAP_OP(148, LOAD_CLASSDEREF_A) - MAP_OP(154, SETUP_ASYNC_WITH_A) - MAP_OP(155, FORMAT_VALUE_A) - MAP_OP(156, BUILD_CONST_KEY_MAP_A) - MAP_OP(157, BUILD_STRING_A) - MAP_OP(160, LOAD_METHOD_A) - MAP_OP(161, CALL_METHOD_A) - MAP_OP(162, LIST_EXTEND_A) - MAP_OP(163, SET_UPDATE_A) - MAP_OP(164, DICT_MERGE_A) - MAP_OP(165, DICT_UPDATE_A) +MAP_OP(1, POP_TOP) +MAP_OP(2, ROT_TWO) +MAP_OP(3, ROT_THREE) +MAP_OP(4, DUP_TOP) +MAP_OP(5, DUP_TOP_TWO) +MAP_OP(6, ROT_FOUR) +MAP_OP(9, NOP) +MAP_OP(10, UNARY_POSITIVE) +MAP_OP(11, UNARY_NEGATIVE) +MAP_OP(12, UNARY_NOT) +MAP_OP(15, UNARY_INVERT) +MAP_OP(16, BINARY_MATRIX_MULTIPLY) +MAP_OP(17, INPLACE_MATRIX_MULTIPLY) +MAP_OP(19, BINARY_POWER) +MAP_OP(20, BINARY_MULTIPLY) +MAP_OP(22, BINARY_MODULO) +MAP_OP(23, BINARY_ADD) +MAP_OP(24, BINARY_SUBTRACT) +MAP_OP(25, BINARY_SUBSCR) +MAP_OP(26, BINARY_FLOOR_DIVIDE) +MAP_OP(27, BINARY_TRUE_DIVIDE) +MAP_OP(28, INPLACE_FLOOR_DIVIDE) +MAP_OP(29, INPLACE_TRUE_DIVIDE) +MAP_OP(48, RERAISE) +MAP_OP(49, WITH_EXCEPT_START) +MAP_OP(50, GET_AITER) +MAP_OP(51, GET_ANEXT) +MAP_OP(52, BEFORE_ASYNC_WITH) +MAP_OP(54, END_ASYNC_FOR) +MAP_OP(55, INPLACE_ADD) +MAP_OP(56, INPLACE_SUBTRACT) +MAP_OP(57, INPLACE_MULTIPLY) +MAP_OP(59, INPLACE_MODULO) +MAP_OP(60, STORE_SUBSCR) +MAP_OP(61, DELETE_SUBSCR) +MAP_OP(62, BINARY_LSHIFT) +MAP_OP(63, BINARY_RSHIFT) +MAP_OP(64, BINARY_AND) +MAP_OP(65, BINARY_XOR) +MAP_OP(66, BINARY_OR) +MAP_OP(67, INPLACE_POWER) +MAP_OP(68, GET_ITER) +MAP_OP(69, GET_YIELD_FROM_ITER) +MAP_OP(70, PRINT_EXPR) +MAP_OP(71, LOAD_BUILD_CLASS) +MAP_OP(72, YIELD_FROM) +MAP_OP(73, GET_AWAITABLE) +MAP_OP(74, LOAD_ASSERTION_ERROR) +MAP_OP(75, INPLACE_LSHIFT) +MAP_OP(76, INPLACE_RSHIFT) +MAP_OP(77, INPLACE_AND) +MAP_OP(78, INPLACE_XOR) +MAP_OP(79, INPLACE_OR) +MAP_OP(82, LIST_TO_TUPLE) +MAP_OP(83, RETURN_VALUE) +MAP_OP(84, IMPORT_STAR) +MAP_OP(85, SETUP_ANNOTATIONS) +MAP_OP(86, YIELD_VALUE) +MAP_OP(87, POP_BLOCK) +MAP_OP(89, POP_EXCEPT) +MAP_OP(90, STORE_NAME_A) +MAP_OP(91, DELETE_NAME_A) +MAP_OP(92, UNPACK_SEQUENCE_A) +MAP_OP(93, FOR_ITER_A) +MAP_OP(94, UNPACK_EX_A) +MAP_OP(95, STORE_ATTR_A) +MAP_OP(96, DELETE_ATTR_A) +MAP_OP(97, STORE_GLOBAL_A) +MAP_OP(98, DELETE_GLOBAL_A) +MAP_OP(100, LOAD_CONST_A) +MAP_OP(101, LOAD_NAME_A) +MAP_OP(102, BUILD_TUPLE_A) +MAP_OP(103, BUILD_LIST_A) +MAP_OP(104, BUILD_SET_A) +MAP_OP(105, BUILD_MAP_A) +MAP_OP(106, LOAD_ATTR_A) +MAP_OP(107, COMPARE_OP_A) +MAP_OP(108, IMPORT_NAME_A) +MAP_OP(109, IMPORT_FROM_A) +MAP_OP(110, JUMP_FORWARD_A) +MAP_OP(111, JUMP_IF_FALSE_OR_POP_A) +MAP_OP(112, JUMP_IF_TRUE_OR_POP_A) +MAP_OP(113, JUMP_ABSOLUTE_A) +MAP_OP(114, POP_JUMP_IF_FALSE_A) +MAP_OP(115, POP_JUMP_IF_TRUE_A) +MAP_OP(116, LOAD_GLOBAL_A) +MAP_OP(117, IS_OP_A) +MAP_OP(118, CONTAINS_OP_A) +MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A) +MAP_OP(122, SETUP_FINALLY_A) +MAP_OP(124, LOAD_FAST_A) +MAP_OP(125, STORE_FAST_A) +MAP_OP(126, DELETE_FAST_A) +MAP_OP(130, RAISE_VARARGS_A) +MAP_OP(131, CALL_FUNCTION_A) +MAP_OP(132, MAKE_FUNCTION_A) +MAP_OP(133, BUILD_SLICE_A) +MAP_OP(135, LOAD_CLOSURE_A) +MAP_OP(136, LOAD_DEREF_A) +MAP_OP(137, STORE_DEREF_A) +MAP_OP(138, DELETE_DEREF_A) +MAP_OP(141, CALL_FUNCTION_KW_A) +MAP_OP(142, CALL_FUNCTION_EX_A) +MAP_OP(143, SETUP_WITH_A) +MAP_OP(144, EXTENDED_ARG_A) +MAP_OP(145, LIST_APPEND_A) +MAP_OP(146, SET_ADD_A) +MAP_OP(147, MAP_ADD_A) +MAP_OP(148, LOAD_CLASSDEREF_A) +MAP_OP(154, SETUP_ASYNC_WITH_A) +MAP_OP(155, FORMAT_VALUE_A) +MAP_OP(156, BUILD_CONST_KEY_MAP_A) +MAP_OP(157, BUILD_STRING_A) +MAP_OP(160, LOAD_METHOD_A) +MAP_OP(161, CALL_METHOD_A) +MAP_OP(162, LIST_EXTEND_A) +MAP_OP(163, SET_UPDATE_A) +MAP_OP(164, DICT_MERGE_A) +MAP_OP(165, DICT_UPDATE_A) END_MAP() diff --git a/data.cpp b/data.cpp index 2b560a7cf..1ea9474fd 100644 --- a/data.cpp +++ b/data.cpp @@ -1,6 +1,6 @@ #include "data.h" -#include #include +#include #include /* PycData */ @@ -16,7 +16,7 @@ int PycData::get32() { /* Ensure endianness */ int result = getByte() & 0xFF; - result |= (getByte() & 0xFF) << 8; + result |= (getByte() & 0xFF) << 8; result |= (getByte() & 0xFF) << 16; result |= (getByte() & 0xFF) << 24; return result; @@ -26,7 +26,7 @@ Pyc_INT64 PycData::get64() { /* Ensure endianness */ Pyc_INT64 result = (Pyc_INT64)(getByte() & 0xFF); - result |= (Pyc_INT64)(getByte() & 0xFF) << 8; + result |= (Pyc_INT64)(getByte() & 0xFF) << 8; result |= (Pyc_INT64)(getByte() & 0xFF) << 16; result |= (Pyc_INT64)(getByte() & 0xFF) << 24; result |= (Pyc_INT64)(getByte() & 0xFF) << 32; @@ -36,7 +36,6 @@ Pyc_INT64 PycData::get64() return result; } - /* PycFile */ PycFile::PycFile(const char* filename) { @@ -68,7 +67,6 @@ void PycFile::getBuffer(int bytes, void* buffer) } } - /* PycBuffer */ int PycBuffer::getByte() { @@ -106,8 +104,11 @@ int formatted_printv(std::ostream& stream, const char* format, va_list args) va_list saved_args; va_copy(saved_args, args); int len = std::vsnprintf(nullptr, 0, format, args); - if (len < 0) + if (len < 0) { + va_end(saved_args); return len; + } + std::vector vec(static_cast(len) + 1); int written = std::vsnprintf(&vec[0], vec.size(), format, saved_args); va_end(saved_args); diff --git a/data.h b/data.h index 28cc85e55..c29b1ed9e 100644 --- a/data.h +++ b/data.h @@ -1,5 +1,5 @@ -#ifndef _PYC_FILE_H -#define _PYC_FILE_H +#ifndef PYC_FILE_H +#define PYC_FILE_H #include #include @@ -28,7 +28,11 @@ class PycData { class PycFile : public PycData { public: PycFile(const char* filename); - ~PycFile() { if (m_stream) fclose(m_stream); } + ~PycFile() override + { + if (m_stream) + fclose(m_stream); + } bool isOpen() const override { return (m_stream != 0); } bool atEof() const override; @@ -42,9 +46,11 @@ class PycFile : public PycData { class PycBuffer : public PycData { public: - PycBuffer(const void* buffer, int size) - : m_buffer((const unsigned char*)buffer), m_size(size), m_pos(0) { } - ~PycBuffer() { } + PycBuffer(const void* buffer, int size) : + m_buffer((const unsigned char*)buffer), m_size(size), m_pos(0) + { + } + ~PycBuffer() override { } bool isOpen() const override { return (m_buffer != 0); } bool atEof() const override { return (m_pos == m_size); } diff --git a/pyc_code.cpp b/pyc_code.cpp index b88f666e1..45c5c5ac9 100644 --- a/pyc_code.cpp +++ b/pyc_code.cpp @@ -1,6 +1,6 @@ #include "pyc_code.h" -#include "pyc_module.h" #include "data.h" +#include "pyc_module.h" /* == Marshal structure for Code object == 1.0 1.3 1.5 2.1 2.3 3.0 3.8 3.11 @@ -125,11 +125,12 @@ PycRef PycCode::getCellVar(PycModule* mod, int idx) const return getLocal(idx); return (idx >= m_cellVars->size()) - ? m_freeVars->get(idx - m_cellVars->size()).cast() - : m_cellVars->get(idx).cast(); + ? m_freeVars->get(idx - m_cellVars->size()).cast() + : m_cellVars->get(idx).cast(); } -int _parse_varint(PycBuffer& data, int& pos) { +int parse_varint(PycBuffer& data, int& pos) +{ int b = data.getByte(); pos += 1; @@ -154,18 +155,19 @@ std::vector PycCode::exceptionTableEntries() const int pos = 0; while (!data.atEof()) { - int start = _parse_varint(data, pos) * 2; - int length = _parse_varint(data, pos) * 2; + int start = parse_varint(data, pos) * 2; + int length = parse_varint(data, pos) * 2; int end = start + length; - - int target = _parse_varint(data, pos) * 2; - int dl = _parse_varint(data, pos); + + int target = parse_varint(data, pos) * 2; + int dl = parse_varint(data, pos); int depth = dl >> 1; bool lasti = bool(dl & 1); - - entries.push_back(PycExceptionTableEntry(start, end, target, depth, lasti)); + + entries.push_back( + PycExceptionTableEntry(start, end, target, depth, lasti)); } - + return entries; } diff --git a/pyc_code.h b/pyc_code.h index 6485729a7..51e625548 100644 --- a/pyc_code.h +++ b/pyc_code.h @@ -1,5 +1,5 @@ -#ifndef _PYC_CODE_H -#define _PYC_CODE_H +#ifndef PYC_CODE_H +#define PYC_CODE_H #include "pyc_sequence.h" #include "pyc_string.h" @@ -16,8 +16,11 @@ class PycExceptionTableEntry { int stack_depth; bool push_lasti; - PycExceptionTableEntry(int m_start_offset, int m_end_offset, int m_target, int m_stack_depth, bool m_push_lasti) : - start_offset(m_start_offset), end_offset(m_end_offset), target(m_target), stack_depth(m_stack_depth), push_lasti(m_push_lasti) {}; + PycExceptionTableEntry(int m_start_offset, int m_end_offset, int m_target, + int m_stack_depth, bool m_push_lasti) : + start_offset(m_start_offset), end_offset(m_end_offset), + target(m_target), stack_depth(m_stack_depth), + push_lasti(m_push_lasti) { }; }; class PycCode : public PycObject { @@ -38,20 +41,22 @@ class PycCode : public PycObject { // The FUTURE flags are shifted left 4 bits starting from Python 3.8 // Older versions are automatically mapped to the new values in load() - CO_FUTURE_DIVISION = 0x20000, // 2.3 - 2.7, 3.1 -> - CO_FUTURE_ABSOLUTE_IMPORT = 0x40000, // 2.5 - 2.7, 3.1 -> - CO_FUTURE_WITH_STATEMENT = 0x80000, // 2.5 - 2.7, 3.1 -> - CO_FUTURE_PRINT_FUNCTION = 0x100000, // 2.6 - 2.7, 3.1 -> - CO_FUTURE_UNICODE_LITERALS = 0x200000, // 2.6 - 2.7, 3.1 -> - CO_FUTURE_BARRY_AS_BDFL = 0x400000, // 3.1 -> - CO_FUTURE_GENERATOR_STOP = 0x800000, // 3.5 -> - CO_FUTURE_ANNOTATIONS = 0x1000000, // 3.7 -> - CO_NO_MONITORING_EVENTS = 0x2000000, // 3.13 -> + CO_FUTURE_DIVISION = 0x20000, // 2.3 - 2.7, 3.1 -> + CO_FUTURE_ABSOLUTE_IMPORT = 0x40000, // 2.5 - 2.7, 3.1 -> + CO_FUTURE_WITH_STATEMENT = 0x80000, // 2.5 - 2.7, 3.1 -> + CO_FUTURE_PRINT_FUNCTION = 0x100000, // 2.6 - 2.7, 3.1 -> + CO_FUTURE_UNICODE_LITERALS = 0x200000, // 2.6 - 2.7, 3.1 -> + CO_FUTURE_BARRY_AS_BDFL = 0x400000, // 3.1 -> + CO_FUTURE_GENERATOR_STOP = 0x800000, // 3.5 -> + CO_FUTURE_ANNOTATIONS = 0x1000000, // 3.7 -> + CO_NO_MONITORING_EVENTS = 0x2000000, // 3.13 -> }; - PycCode(int type = TYPE_CODE) - : PycObject(type), m_argCount(), m_posOnlyArgCount(), m_kwOnlyArgCount(), - m_numLocals(), m_stackSize(), m_flags(), m_firstLine() { } + PycCode(int type = TYPE_CODE) : + PycObject(type), m_argCount(), m_posOnlyArgCount(), m_kwOnlyArgCount(), + m_numLocals(), m_stackSize(), m_flags(), m_firstLine() + { + } void load(PycData* stream, PycModule* mod) override; @@ -75,10 +80,7 @@ class PycCode : public PycObject { PycRef lnTable() const { return m_lnTable; } PycRef exceptTable() const { return m_exceptTable; } - PycRef getConst(int idx) const - { - return m_consts->get(idx); - } + PycRef getConst(int idx) const { return m_consts->get(idx); } PycRef getName(int idx) const { diff --git a/pyc_module.cpp b/pyc_module.cpp index 98eecffe9..944f294aa 100644 --- a/pyc_module.cpp +++ b/pyc_module.cpp @@ -30,63 +30,63 @@ void PycModule::setVersion(unsigned int magic) break; /* Starting with 1.6, Python adds +1 for unicode mode (-U) */ - case MAGIC_1_6+1: + case MAGIC_1_6 + 1: m_unicode = true; /* Fall through */ case MAGIC_1_6: m_maj = 1; m_min = 6; break; - case MAGIC_2_0+1: + case MAGIC_2_0 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_0: m_maj = 2; m_min = 0; break; - case MAGIC_2_1+1: + case MAGIC_2_1 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_1: m_maj = 2; m_min = 1; break; - case MAGIC_2_2+1: + case MAGIC_2_2 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_2: m_maj = 2; m_min = 2; break; - case MAGIC_2_3+1: + case MAGIC_2_3 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_3: m_maj = 2; m_min = 3; break; - case MAGIC_2_4+1: + case MAGIC_2_4 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_4: m_maj = 2; m_min = 4; break; - case MAGIC_2_5+1: + case MAGIC_2_5 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_5: m_maj = 2; m_min = 5; break; - case MAGIC_2_6+1: + case MAGIC_2_6 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_6: m_maj = 2; m_min = 6; break; - case MAGIC_2_7+1: + case MAGIC_2_7 + 1: m_unicode = true; /* Fall through */ case MAGIC_2_7: @@ -95,12 +95,12 @@ void PycModule::setVersion(unsigned int magic) break; /* 3.0 and above are always unicode */ - case MAGIC_3_0+1: + case MAGIC_3_0 + 1: m_maj = 3; m_min = 0; m_unicode = true; break; - case MAGIC_3_1+1: + case MAGIC_3_1 + 1: m_maj = 3; m_min = 1; m_unicode = true; @@ -224,7 +224,8 @@ void PycModule::loadFromFile(const char* filename) // Optional checksum added in Python 3.7 in.get32(); in.get32(); - } else { + } + else { in.get32(); // Timestamp -- who cares? if (verCompare(3, 3) >= 0) @@ -234,9 +235,10 @@ void PycModule::loadFromFile(const char* filename) m_code = LoadObject(&in, this).cast(); } -void PycModule::loadFromMarshalledFile(const char* filename, int major, int minor) +void PycModule::loadFromMarshalledFile( + const char* filename, int major, int minor) { - PycFile in (filename); + PycFile in(filename); if (!in.isOpen()) { fprintf(stderr, "Error opening file %s\n", filename); return; diff --git a/pyc_module.h b/pyc_module.h index 695f4ba48..f888f1797 100644 --- a/pyc_module.h +++ b/pyc_module.h @@ -1,5 +1,5 @@ -#ifndef _PYC_MODULE_H -#define _PYC_MODULE_H +#ifndef PYC_MODULE_H +#define PYC_MODULE_H #include "pyc_code.h" #include @@ -45,7 +45,7 @@ class PycModule { PycModule() : m_maj(-1), m_min(-1), m_unicode(false) { } void loadFromFile(const char* filename); - void loadFromMarshalledFile(const char *filename, int major, int minor); + void loadFromMarshalledFile(const char* filename, int major, int minor); bool isValid() const { return (m_maj >= 0) && (m_min >= 0); } int majorVer() const { return m_maj; } @@ -62,20 +62,28 @@ class PycModule { bool strIsUnicode() const { - return (m_maj >= 3) || (m_code->flags() & PycCode::CO_FUTURE_UNICODE_LITERALS) != 0; + return (m_maj >= 3) || + (m_code->flags() & PycCode::CO_FUTURE_UNICODE_LITERALS) != 0; } bool internIsBytes() const { - return (m_maj < 3) && (m_code->flags() & PycCode::CO_FUTURE_UNICODE_LITERALS) != 0; + return (m_maj < 3) && + (m_code->flags() & PycCode::CO_FUTURE_UNICODE_LITERALS) != 0; } PycRef code() const { return m_code; } - void intern(PycRef str) { m_interns.emplace_back(std::move(str)); } + void intern(PycRef str) + { + m_interns.emplace_back(std::move(str)); + } PycRef getIntern(int ref) const; - void refObject(PycRef obj) { m_refs.emplace_back(std::move(obj)); } + void refObject(PycRef obj) + { + m_refs.emplace_back(std::move(obj)); + } PycRef getRef(int ref) const; static bool isSupportedVersion(int major, int minor); diff --git a/pyc_numeric.cpp b/pyc_numeric.cpp index d70ffaf4b..f81cb27c0 100644 --- a/pyc_numeric.cpp +++ b/pyc_numeric.cpp @@ -1,10 +1,10 @@ #include "pyc_numeric.h" -#include "pyc_module.h" #include "data.h" +#include "pyc_module.h" #include #ifdef _MSC_VER -#define snprintf sprintf_s + #define snprintf sprintf_s #endif /* PycInt */ @@ -13,7 +13,6 @@ void PycInt::load(PycData* stream, PycModule*) m_value = stream->get32(); } - /* PycLong */ void PycLong::load(PycData* stream, PycModule*) { @@ -21,16 +20,17 @@ void PycLong::load(PycData* stream, PycModule*) m_value.reserve(4); int lo = stream->get32(); int hi = stream->get32(); - m_value.push_back((lo ) & 0xFFFF); + m_value.push_back((lo) & 0xFFFF); m_value.push_back((lo >> 16) & 0xFFFF); - m_value.push_back((hi ) & 0xFFFF); + m_value.push_back((hi) & 0xFFFF); m_value.push_back((hi >> 16) & 0xFFFF); m_size = (hi & 0x80000000) != 0 ? -4 : 4; - } else { + } + else { m_size = stream->get32(); int actualSize = m_size >= 0 ? m_size : -m_size; m_value.reserve(actualSize); - for (int i=0; iget16()); } } @@ -66,12 +66,12 @@ std::string PycLong::repr(PycModule* mod) const bits.reserve((m_value.size() + 1) / 2); int shift = 0, temp = 0; for (auto bit : m_value) { - temp |= unsigned(bit & 0xFFFF) << shift; + temp |= static_cast(unsigned(bit & 0xFFFF) << shift); shift += 15; if (shift >= 32) { bits.push_back(temp); shift -= 32; - temp = unsigned(bit & 0xFFFF) >> (15 - shift); + temp = static_cast(unsigned(bit & 0xFFFF) >> (15 - shift)); } } if (temp) @@ -96,7 +96,6 @@ std::string PycLong::repr(PycModule* mod) const return accum; } - /* PycFloat */ void PycFloat::load(PycData* stream, PycModule*) { @@ -118,7 +117,6 @@ bool PycFloat::isEqual(PycRef obj) const return m_value == floatObj->m_value; } - /* PycComplex */ void PycComplex::load(PycData* stream, PycModule* mod) { @@ -142,7 +140,6 @@ bool PycComplex::isEqual(PycRef obj) const return m_imag == floatObj->m_imag; } - /* PycCFloat */ void PycCFloat::load(PycData* stream, PycModule*) { @@ -150,7 +147,6 @@ void PycCFloat::load(PycData* stream, PycModule*) memcpy(&m_value, &bits, sizeof(bits)); } - /* PycCComplex */ void PycCComplex::load(PycData* stream, PycModule* mod) { diff --git a/pyc_numeric.h b/pyc_numeric.h index 548afcd0e..483bf0870 100644 --- a/pyc_numeric.h +++ b/pyc_numeric.h @@ -1,15 +1,16 @@ -#ifndef _PYC_NUMERIC_H -#define _PYC_NUMERIC_H +#ifndef PYC_NUMERIC_H +#define PYC_NUMERIC_H -#include "pyc_object.h" #include "data.h" -#include +#include "pyc_object.h" #include +#include class PycInt : public PycObject { public: - PycInt(int value = 0, int type = TYPE_INT) - : PycObject(type), m_value(value) { } + PycInt(int value = 0, int type = TYPE_INT) : PycObject(type), m_value(value) + { + } bool isEqual(PycRef obj) const override { @@ -27,8 +28,7 @@ class PycInt : public PycObject { class PycLong : public PycObject { public: - PycLong(int type = TYPE_LONG) - : PycObject(type), m_size(0) { } + PycLong(int type = TYPE_LONG) : PycObject(type), m_size(0) { } bool isEqual(PycRef obj) const override; @@ -46,8 +46,7 @@ class PycLong : public PycObject { class PycFloat : public PycObject { public: - PycFloat(int type = TYPE_FLOAT) - : PycObject(type) { } + PycFloat(int type = TYPE_FLOAT) : PycObject(type) { } bool isEqual(PycRef obj) const override; @@ -61,8 +60,7 @@ class PycFloat : public PycObject { class PycComplex : public PycFloat { public: - PycComplex(int type = TYPE_COMPLEX) - : PycFloat(type) { } + PycComplex(int type = TYPE_COMPLEX) : PycFloat(type) { } bool isEqual(PycRef obj) const override; @@ -76,8 +74,7 @@ class PycComplex : public PycFloat { class PycCFloat : public PycObject { public: - PycCFloat(int type = TYPE_BINARY_FLOAT) - : PycObject(type), m_value(0.0) { } + PycCFloat(int type = TYPE_BINARY_FLOAT) : PycObject(type), m_value(0.0) { } bool isEqual(PycRef obj) const override { @@ -95,8 +92,9 @@ class PycCFloat : public PycObject { class PycCComplex : public PycCFloat { public: - PycCComplex(int type = TYPE_BINARY_COMPLEX) - : PycCFloat(type), m_imag(0.0) { } + PycCComplex(int type = TYPE_BINARY_COMPLEX) : PycCFloat(type), m_imag(0.0) + { + } bool isEqual(PycRef obj) const override { diff --git a/pyc_object.cpp b/pyc_object.cpp index 54a8b731e..3b6b7cc3b 100644 --- a/pyc_object.cpp +++ b/pyc_object.cpp @@ -1,8 +1,8 @@ #include "pyc_object.h" +#include "data.h" +#include "pyc_code.h" #include "pyc_module.h" #include "pyc_numeric.h" -#include "pyc_code.h" -#include "data.h" #include PycRef Pyc_None = new PycObject(PycObject::TYPE_NONE); @@ -76,7 +76,8 @@ PycRef LoadObject(PycData* stream, PycModule* mod) if (type == PycObject::TYPE_OBREF) { int index = stream->get32(); obj = mod->getRef(index); - } else { + } + else { obj = CreateObject(type & 0x7F); if (obj != NULL) { if (type & 0x80) diff --git a/pyc_object.h b/pyc_object.h index 085944496..988cc52f1 100644 --- a/pyc_object.h +++ b/pyc_object.h @@ -1,26 +1,25 @@ -#ifndef _PYC_OBJECT_H -#define _PYC_OBJECT_H +#ifndef PYC_OBJECT_H +#define PYC_OBJECT_H #include -template -class PycRef { +template class PycRef { public: PycRef() noexcept : m_obj() { } - PycRef(_Obj* obj) noexcept : m_obj(obj) + PycRef(Obj* obj) noexcept : m_obj(obj) { if (m_obj) m_obj->addRef(); } - PycRef(const PycRef<_Obj>& obj) noexcept : m_obj(obj.m_obj) + PycRef(const PycRef& obj) noexcept : m_obj(obj.m_obj) { if (m_obj) m_obj->addRef(); } - PycRef(PycRef<_Obj>&& obj) noexcept : m_obj(obj.m_obj) + PycRef(PycRef&& obj) noexcept : m_obj(obj.m_obj) { obj.m_obj = nullptr; } @@ -31,7 +30,7 @@ class PycRef { m_obj->delRef(); } - PycRef<_Obj>& operator=(_Obj* obj) + PycRef& operator=(Obj* obj) { if (obj) obj->addRef(); @@ -41,8 +40,12 @@ class PycRef { return *this; } - PycRef<_Obj>& operator=(const PycRef<_Obj>& obj) + PycRef& operator=(const PycRef& obj) { + if (this == &obj) { + return *this; + } + if (obj.m_obj) obj.m_obj->addRef(); if (m_obj) @@ -51,43 +54,47 @@ class PycRef { return *this; } - PycRef<_Obj>& operator=(PycRef<_Obj>&& obj) noexcept + PycRef& operator=(PycRef&& obj) noexcept { + if (this == &obj) { + return *this; + } + m_obj = obj.m_obj; obj.m_obj = nullptr; return *this; } - bool operator==(_Obj* obj) const { return m_obj == obj; } - bool operator==(const PycRef<_Obj>& obj) const { return m_obj == obj.m_obj; } - bool operator!=(_Obj* obj) const { return m_obj != obj; } - bool operator!=(const PycRef<_Obj>& obj) const { return m_obj != obj.m_obj; } + bool operator==(Obj* obj) const { return m_obj == obj; } + bool operator==(const PycRef& obj) const { return m_obj == obj.m_obj; } + bool operator!=(Obj* obj) const { return m_obj != obj; } + bool operator!=(const PycRef& obj) const { return m_obj != obj.m_obj; } - _Obj& operator*() const { return *m_obj; } - _Obj* operator->() const { return m_obj; } - operator _Obj*() const { return m_obj; } + Obj& operator*() const { return *m_obj; } + Obj* operator->() const { return m_obj; } + operator Obj*() const { return m_obj; } inline int type() const; - template - PycRef<_Cast> try_cast() const { return dynamic_cast<_Cast*>(m_obj); } + template PycRef try_cast() const + { + return dynamic_cast(m_obj); + } - template - PycRef<_Cast> cast() const + template PycRef cast() const { - _Cast* result = dynamic_cast<_Cast*>(m_obj); + Cast* result = dynamic_cast(m_obj); if (!result) throw std::bad_cast(); return result; } - bool isIdent(const _Obj* obj) const { return m_obj == obj; } + bool isIdent(const Obj* obj) const { return m_obj == obj; } private: - _Obj* m_obj; + Obj* m_obj; }; - class PycData; class PycModule; @@ -149,11 +156,14 @@ class PycObject { public: void addRef() { ++m_refs; } - void delRef() { if (--m_refs == 0) delete this; } + void delRef() + { + if (--m_refs == 0) + delete this; + } }; -template -int PycRef<_Obj>::type() const +template int PycRef::type() const { return m_obj ? m_obj->type() : PycObject::TYPE_NULL; } diff --git a/pyc_sequence.cpp b/pyc_sequence.cpp index 29406c712..e231867fc 100644 --- a/pyc_sequence.cpp +++ b/pyc_sequence.cpp @@ -1,6 +1,6 @@ #include "pyc_sequence.h" -#include "pyc_module.h" #include "data.h" +#include "pyc_module.h" #include /* PycSimpleSequence */ @@ -8,7 +8,7 @@ void PycSimpleSequence::load(PycData* stream, PycModule* mod) { m_size = stream->get32(); m_values.reserve(m_size); - for (int i=0; i obj) const return true; } - /* PycTuple */ void PycTuple::load(PycData* stream, PycModule* mod) { @@ -40,11 +39,10 @@ void PycTuple::load(PycData* stream, PycModule* mod) m_size = stream->get32(); m_values.resize(m_size); - for (int i=0; i diff --git a/pyc_string.cpp b/pyc_string.cpp index 5dd78065a..f98020b79 100644 --- a/pyc_string.cpp +++ b/pyc_string.cpp @@ -1,6 +1,6 @@ #include "pyc_string.h" -#include "pyc_module.h" #include "data.h" +#include "pyc_module.h" #include static bool check_ascii(const std::string& data) @@ -21,7 +21,8 @@ void PycString::load(PycData* stream, PycModule* mod) PycRef str = mod->getIntern(stream->get32()); m_type = str->m_type; m_value = str->m_value; - } else { + } + else { int length; if (type() == TYPE_SHORT_ASCII || type() == TYPE_SHORT_ASCII_INTERNED) length = stream->getByte(); @@ -35,14 +36,15 @@ void PycString::load(PycData* stream, PycModule* mod) if (length) { stream->getBuffer(length, &m_value.front()); if (type() == TYPE_ASCII || type() == TYPE_ASCII_INTERNED || - type() == TYPE_SHORT_ASCII || type() == TYPE_SHORT_ASCII_INTERNED) { + type() == TYPE_SHORT_ASCII || + type() == TYPE_SHORT_ASCII_INTERNED) { if (!check_ascii(m_value)) throw std::runtime_error("Invalid bytes in ASCII string"); } } if (type() == TYPE_INTERNED || type() == TYPE_ASCII_INTERNED || - type() == TYPE_SHORT_ASCII_INTERNED) + type() == TYPE_SHORT_ASCII_INTERNED) mod->intern(this); } } @@ -56,8 +58,8 @@ bool PycString::isEqual(PycRef obj) const return isEqual(strObj->m_value); } -void PycString::print(std::ostream &pyc_output, PycModule* mod, bool triple, - const char* parent_f_string_quote) +void PycString::print(std::ostream& pyc_output, PycModule* mod, bool triple, + const char* parent_f_string_quote) { char prefix = 0; switch (type()) { @@ -95,12 +97,14 @@ void PycString::print(std::ostream &pyc_output, PycModule* mod, bool triple, for (char ch : m_value) { if (ch == '\'') { useQuotes = true; - } else if (ch == '"') { + } + else if (ch == '"') { useQuotes = false; break; } } - } else { + } + else { useQuotes = parent_f_string_quote[0] == '"'; } @@ -115,24 +119,30 @@ void PycString::print(std::ostream &pyc_output, PycModule* mod, bool triple, if (static_cast(ch) < 0x20 || ch == 0x7F) { if (ch == '\r') { pyc_output << "\\r"; - } else if (ch == '\n') { + } + else if (ch == '\n') { if (triple) pyc_output << '\n'; else pyc_output << "\\n"; - } else if (ch == '\t') { + } + else if (ch == '\t') { pyc_output << "\\t"; - } else { + } + else { formatted_print(pyc_output, "\\x%02x", (ch & 0xFF)); } - } else if (static_cast(ch) >= 0x80) { + } + else if (static_cast(ch) >= 0x80) { if (type() == TYPE_UNICODE) { // Unicode stored as UTF-8... Let the stream interpret it pyc_output << ch; - } else { + } + else { formatted_print(pyc_output, "\\x%02x", (ch & 0xFF)); } - } else { + } + else { if (!useQuotes && ch == '\'') pyc_output << R"(\')"; else if (useQuotes && ch == '"') diff --git a/pyc_string.h b/pyc_string.h index 43ae2ed7b..bfde0d1b3 100644 --- a/pyc_string.h +++ b/pyc_string.h @@ -1,15 +1,14 @@ -#ifndef _PYC_STRING_H -#define _PYC_STRING_H +#ifndef PYC_STRING_H +#define PYC_STRING_H -#include "pyc_object.h" #include "data.h" +#include "pyc_object.h" #include #include class PycString : public PycObject { public: - PycString(int type = TYPE_STRING) - : PycObject(type) { } + PycString(int type = TYPE_STRING) : PycObject(type) { } bool isEqual(PycRef obj) const override; bool isEqual(const std::string& str) const { return m_value == str; } @@ -23,12 +22,12 @@ class PycString : public PycObject { int length() const { return (int)m_value.size(); } const char* value() const { return m_value.c_str(); } - const std::string &strValue() const { return m_value; } + const std::string& strValue() const { return m_value; } void setValue(std::string str) { m_value = std::move(str); } void print(std::ostream& stream, class PycModule* mod, bool triple = false, - const char* parent_f_string_quote = nullptr); + const char* parent_f_string_quote = nullptr); private: std::string m_value; diff --git a/pycdas.cpp b/pycdas.cpp index fde9a70c8..10eb05762 100644 --- a/pycdas.cpp +++ b/pycdas.cpp @@ -1,31 +1,30 @@ +#include "bytecode.h" +#include "pyc_module.h" +#include "pyc_numeric.h" +#include #include #include -#include -#include -#include #include +#include +#include #include -#include "pyc_module.h" -#include "pyc_numeric.h" -#include "bytecode.h" #ifdef WIN32 -# define PATHSEP '\\' + #define PATHSEP '\\' #else -# define PATHSEP '/' + #define PATHSEP '/' #endif -static const char* flag_names[] = { - "CO_OPTIMIZED", "CO_NEWLOCALS", "CO_VARARGS", "CO_VARKEYWORDS", - "CO_NESTED", "CO_GENERATOR", "CO_NOFREE", "CO_COROUTINE", - "CO_ITERABLE_COROUTINE", "CO_ASYNC_GENERATOR", "<0x400>", "<0x800>", - "CO_GENERATOR_ALLOWED", "<0x2000>", "<0x4000>", "<0x8000>", - "<0x10000>", "CO_FUTURE_DIVISION", "CO_FUTURE_ABSOLUTE_IMPORT", "CO_FUTURE_WITH_STATEMENT", - "CO_FUTURE_PRINT_FUNCTION", "CO_FUTURE_UNICODE_LITERALS", "CO_FUTURE_BARRY_AS_BDFL", - "CO_FUTURE_GENERATOR_STOP", - "CO_FUTURE_ANNOTATIONS", "CO_NO_MONITORING_EVENTS", "<0x4000000>", "<0x8000000>", - "<0x10000000>", "<0x20000000>", "<0x40000000>", "<0x80000000>" -}; +static const char* flag_names[] = { "CO_OPTIMIZED", "CO_NEWLOCALS", + "CO_VARARGS", "CO_VARKEYWORDS", "CO_NESTED", "CO_GENERATOR", "CO_NOFREE", + "CO_COROUTINE", "CO_ITERABLE_COROUTINE", "CO_ASYNC_GENERATOR", "<0x400>", + "<0x800>", "CO_GENERATOR_ALLOWED", "<0x2000>", "<0x4000>", "<0x8000>", + "<0x10000>", "CO_FUTURE_DIVISION", "CO_FUTURE_ABSOLUTE_IMPORT", + "CO_FUTURE_WITH_STATEMENT", "CO_FUTURE_PRINT_FUNCTION", + "CO_FUTURE_UNICODE_LITERALS", "CO_FUTURE_BARRY_AS_BDFL", + "CO_FUTURE_GENERATOR_STOP", "CO_FUTURE_ANNOTATIONS", + "CO_NO_MONITORING_EVENTS", "<0x4000000>", "<0x8000000>", "<0x10000000>", + "<0x20000000>", "<0x40000000>", "<0x80000000>" }; static void print_coflags(unsigned long flags, std::ostream& pyc_output) { @@ -53,15 +52,15 @@ static void print_coflags(unsigned long flags, std::ostream& pyc_output) static void iputs(std::ostream& pyc_output, int indent, const char* text) { - for (int i=0; i out_seen; +static std::unordered_set out_seen; void output_object(PycRef obj, PycModule* mod, int indent, - unsigned flags, std::ostream& pyc_output) + unsigned flags, std::ostream& pyc_output) { if (obj == NULL) { iputs(pyc_output, indent, ""); return; } - if (out_seen.find((PycObject *)obj) != out_seen.end()) { + if (out_seen.find((PycObject*)obj) != out_seen.end()) { fputs("WARNING: Circular reference detected\n", stderr); return; } - out_seen.insert((PycObject *)obj); + out_seen.insert((PycObject*)obj); switch (obj->type()) { case PycObject::TYPE_CODE: @@ -96,73 +95,92 @@ void output_object(PycRef obj, PycModule* mod, int indent, { PycRef codeObj = obj.cast(); iputs(pyc_output, indent, "[Code]\n"); - iprintf(pyc_output, indent + 1, "File Name: %s\n", codeObj->fileName()->value()); - iprintf(pyc_output, indent + 1, "Object Name: %s\n", codeObj->name()->value()); + iprintf(pyc_output, indent + 1, "File Name: %s\n", + codeObj->fileName()->value()); + iprintf(pyc_output, indent + 1, "Object Name: %s\n", + codeObj->name()->value()); if (mod->verCompare(3, 11) >= 0) - iprintf(pyc_output, indent + 1, "Qualified Name: %s\n", codeObj->qualName()->value()); - iprintf(pyc_output, indent + 1, "Arg Count: %d\n", codeObj->argCount()); + iprintf(pyc_output, indent + 1, "Qualified Name: %s\n", + codeObj->qualName()->value()); + iprintf( + pyc_output, indent + 1, "Arg Count: %d\n", codeObj->argCount()); if (mod->verCompare(3, 8) >= 0) - iprintf(pyc_output, indent + 1, "Pos Only Arg Count: %d\n", codeObj->posOnlyArgCount()); + iprintf(pyc_output, indent + 1, "Pos Only Arg Count: %d\n", + codeObj->posOnlyArgCount()); if (mod->majorVer() >= 3) - iprintf(pyc_output, indent + 1, "KW Only Arg Count: %d\n", codeObj->kwOnlyArgCount()); + iprintf(pyc_output, indent + 1, "KW Only Arg Count: %d\n", + codeObj->kwOnlyArgCount()); if (mod->verCompare(3, 11) < 0) - iprintf(pyc_output, indent + 1, "Locals: %d\n", codeObj->numLocals()); + iprintf(pyc_output, indent + 1, "Locals: %d\n", + codeObj->numLocals()); if (mod->verCompare(1, 5) >= 0) - iprintf(pyc_output, indent + 1, "Stack Size: %d\n", codeObj->stackSize()); + iprintf(pyc_output, indent + 1, "Stack Size: %d\n", + codeObj->stackSize()); if (mod->verCompare(1, 3) >= 0) { unsigned int orig_flags = codeObj->flags(); if (mod->verCompare(3, 8) < 0) { // Remap flags back to the value stored in the PyCode object - orig_flags = (orig_flags & 0xFFFF) | ((orig_flags & 0xFFF00000) >> 4); + orig_flags = (orig_flags & 0xFFFF) | + ((orig_flags & 0xFFF00000) >> 4); } iprintf(pyc_output, indent + 1, "Flags: 0x%08X", orig_flags); print_coflags(codeObj->flags(), pyc_output); } iputs(pyc_output, indent + 1, "[Names]\n"); - for (int i=0; inames()->size(); i++) - output_object(codeObj->names()->get(i), mod, indent + 2, flags, pyc_output); + for (int i = 0; i < codeObj->names()->size(); i++) + output_object(codeObj->names()->get(i), mod, indent + 2, flags, + pyc_output); if (mod->verCompare(1, 3) >= 0) { if (mod->verCompare(3, 11) >= 0) iputs(pyc_output, indent + 1, "[Locals+Names]\n"); else iputs(pyc_output, indent + 1, "[Var Names]\n"); - for (int i=0; ilocalNames()->size(); i++) - output_object(codeObj->localNames()->get(i), mod, indent + 2, flags, pyc_output); + for (int i = 0; i < codeObj->localNames()->size(); i++) + output_object(codeObj->localNames()->get(i), mod, + indent + 2, flags, pyc_output); } - if (mod->verCompare(3, 11) >= 0 && (flags & Pyc::DISASM_PYCODE_VERBOSE) != 0) { + if (mod->verCompare(3, 11) >= 0 && + (flags & Pyc::DISASM_PYCODE_VERBOSE) != 0) { iputs(pyc_output, indent + 1, "[Locals+Kinds]\n"); - output_object(codeObj->localKinds().cast(), mod, indent + 2, flags, pyc_output); + output_object(codeObj->localKinds().cast(), mod, + indent + 2, flags, pyc_output); } if (mod->verCompare(2, 1) >= 0 && mod->verCompare(3, 11) < 0) { iputs(pyc_output, indent + 1, "[Free Vars]\n"); - for (int i=0; ifreeVars()->size(); i++) - output_object(codeObj->freeVars()->get(i), mod, indent + 2, flags, pyc_output); + for (int i = 0; i < codeObj->freeVars()->size(); i++) + output_object(codeObj->freeVars()->get(i), mod, indent + 2, + flags, pyc_output); iputs(pyc_output, indent + 1, "[Cell Vars]\n"); - for (int i=0; icellVars()->size(); i++) - output_object(codeObj->cellVars()->get(i), mod, indent + 2, flags, pyc_output); + for (int i = 0; i < codeObj->cellVars()->size(); i++) + output_object(codeObj->cellVars()->get(i), mod, indent + 2, + flags, pyc_output); } iputs(pyc_output, indent + 1, "[Constants]\n"); - for (int i=0; iconsts()->size(); i++) - output_object(codeObj->consts()->get(i), mod, indent + 2, flags, pyc_output); + for (int i = 0; i < codeObj->consts()->size(); i++) + output_object(codeObj->consts()->get(i), mod, indent + 2, flags, + pyc_output); iputs(pyc_output, indent + 1, "[Disassembly]\n"); bc_disasm(pyc_output, codeObj, mod, indent + 2, flags); if (mod->verCompare(3, 11) >= 0) { iputs(pyc_output, indent + 1, "[Exception Table]\n"); - bc_exceptiontable(pyc_output, codeObj, indent+2); + bc_exceptiontable(pyc_output, codeObj, indent + 2); } - if (mod->verCompare(1, 5) >= 0 && (flags & Pyc::DISASM_PYCODE_VERBOSE) != 0) { - iprintf(pyc_output, indent + 1, "First Line: %d\n", codeObj->firstLine()); + if (mod->verCompare(1, 5) >= 0 && + (flags & Pyc::DISASM_PYCODE_VERBOSE) != 0) { + iprintf(pyc_output, indent + 1, "First Line: %d\n", + codeObj->firstLine()); iputs(pyc_output, indent + 1, "[Line Number Table]\n"); - output_object(codeObj->lnTable().cast(), mod, indent + 2, flags, pyc_output); + output_object(codeObj->lnTable().cast(), mod, + indent + 2, flags, pyc_output); } } break; @@ -198,8 +216,10 @@ void output_object(PycRef obj, PycModule* mod, int indent, { iputs(pyc_output, indent, "{\n"); for (const auto& val : obj.cast()->values()) { - output_object(std::get<0>(val), mod, indent + 1, flags, pyc_output); - output_object(std::get<1>(val), mod, indent + 2, flags, pyc_output); + output_object( + std::get<0>(val), mod, indent + 1, flags, pyc_output); + output_object( + std::get<1>(val), mod, indent + 2, flags, pyc_output); } iputs(pyc_output, indent, "}\n"); } @@ -236,27 +256,28 @@ void output_object(PycRef obj, PycModule* mod, int indent, iprintf(pyc_output, indent, "%d\n", obj.cast()->value()); break; case PycObject::TYPE_LONG: - iprintf(pyc_output, indent, "%s\n", obj.cast()->repr(mod).c_str()); + iprintf( + pyc_output, indent, "%s\n", obj.cast()->repr(mod).c_str()); break; case PycObject::TYPE_FLOAT: iprintf(pyc_output, indent, "%s\n", obj.cast()->value()); break; case PycObject::TYPE_COMPLEX: - iprintf(pyc_output, indent, "(%s+%sj)\n", obj.cast()->value(), - obj.cast()->imag()); + iprintf(pyc_output, indent, "(%s+%sj)\n", + obj.cast()->value(), obj.cast()->imag()); break; case PycObject::TYPE_BINARY_FLOAT: iprintf(pyc_output, indent, "%g\n", obj.cast()->value()); break; case PycObject::TYPE_BINARY_COMPLEX: - iprintf(pyc_output, indent, "(%g+%gj)\n", obj.cast()->value(), - obj.cast()->imag()); + iprintf(pyc_output, indent, "(%g+%gj)\n", + obj.cast()->value(), obj.cast()->imag()); break; default: iprintf(pyc_output, indent, "\n", obj->type()); } - out_seen.erase((PycObject *)obj); + out_seen.erase((PycObject*)obj); } int main(int argc, char* argv[]) @@ -275,41 +296,61 @@ int main(int argc, char* argv[]) out_file.open(filename, std::ios_base::out); if (out_file.fail()) { fprintf(stderr, "Error opening file '%s' for writing\n", - filename); + filename); return 1; } pyc_output = &out_file; - } else { + } + else { fputs("Option '-o' requires a filename\n", stderr); return 1; } - } else if (strcmp(argv[arg], "-c") == 0) { + } + else if (strcmp(argv[arg], "-c") == 0) { marshalled = true; - } else if (strcmp(argv[arg], "-v") == 0) { + } + else if (strcmp(argv[arg], "-v") == 0) { if (arg + 1 < argc) { version = argv[++arg]; - } else { + } + else { fputs("Option '-v' requires a version\n", stderr); return 1; } - } else if (strcmp(argv[arg], "--pycode-extra") == 0) { + } + else if (strcmp(argv[arg], "--pycode-extra") == 0) { disasm_flags |= Pyc::DISASM_PYCODE_VERBOSE; - } else if (strcmp(argv[arg], "--show-caches") == 0) { + } + else if (strcmp(argv[arg], "--show-caches") == 0) { disasm_flags |= Pyc::DISASM_SHOW_CACHES; - } else if (strcmp(argv[arg], "--help") == 0 || strcmp(argv[arg], "-h") == 0) { + } + else if (strcmp(argv[arg], "--help") == 0 || + strcmp(argv[arg], "-h") == 0) { fprintf(stderr, "Usage: %s [options] input.pyc\n\n", argv[0]); fputs("Options:\n", stderr); - fputs(" -o Write output to (default: stdout)\n", stderr); - fputs(" -c Specify loading a compiled code object. Requires the version to be set\n", stderr); - fputs(" -v Specify a Python version for loading a compiled code object\n", stderr); - fputs(" --pycode-extra Show extra fields in PyCode object dumps\n", stderr); - fputs(" --show-caches Don't suprress CACHE instructions in Python 3.11+ disassembly\n", stderr); - fputs(" --help Show this help text and then exit\n", stderr); + fputs( + " -o Write output to (default: stdout)\n", + stderr); + fputs( + " -c Specify loading a compiled code object. Requires the version to be set\n", + stderr); + fputs( + " -v Specify a Python version for loading a compiled code object\n", + stderr); + fputs(" --pycode-extra Show extra fields in PyCode object dumps\n", + stderr); + fputs( + " --show-caches Don't suprress CACHE instructions in Python 3.11+ disassembly\n", + stderr); + fputs( + " --help Show this help text and then exit\n", stderr); return 0; - } else if (argv[arg][0] == '-') { + } + else if (argv[arg][0] == '-') { fprintf(stderr, "Error: Unrecognized argument %s\n", argv[arg]); return 1; - } else { + } + else { infile = argv[arg]; } } @@ -323,33 +364,37 @@ int main(int argc, char* argv[]) if (!marshalled) { try { mod.loadFromFile(infile); - } catch (std::exception &ex) { + } catch (std::exception& ex) { fprintf(stderr, "Error disassembling %s: %s\n", infile, ex.what()); return 1; } - } else { + } + else { if (!version) { - fputs("Opening raw code objects requires a version to be specified\n", stderr); + fputs( + "Opening raw code objects requires a version to be specified\n", + stderr); return 1; } std::string s(version); auto dot = s.find('.'); - if (dot == std::string::npos || dot == s.size()-1) { - fputs("Unable to parse version string (use the format x.y)\n", stderr); + if (dot == std::string::npos || dot == s.size() - 1) { + fputs("Unable to parse version string (use the format x.y)\n", + stderr); return 1; } int major = std::stoi(s.substr(0, dot)); - int minor = std::stoi(s.substr(dot+1, s.size())); + int minor = std::stoi(s.substr(dot + 1, s.size())); mod.loadFromMarshalledFile(infile, major, minor); } const char* dispname = strrchr(infile, PATHSEP); dispname = (dispname == NULL) ? infile : dispname + 1; formatted_print(*pyc_output, "%s (Python %d.%d%s)\n", dispname, - mod.majorVer(), mod.minorVer(), - (mod.majorVer() < 3 && mod.isUnicode()) ? " -U" : ""); + mod.majorVer(), mod.minorVer(), + (mod.majorVer() < 3 && mod.isUnicode()) ? " -U" : ""); try { output_object(mod.code().try_cast(), &mod, 0, disasm_flags, - *pyc_output); + *pyc_output); } catch (std::exception& ex) { fprintf(stderr, "Error disassembling %s: %s\n", infile, ex.what()); return 1; diff --git a/pycdc.cpp b/pycdc.cpp index 7bb6bd267..f4aa8ed3b 100644 --- a/pycdc.cpp +++ b/pycdc.cpp @@ -1,12 +1,12 @@ +#include "ASTree.h" #include #include #include -#include "ASTree.h" #ifdef WIN32 -# define PATHSEP '\\' + #define PATHSEP '\\' #else -# define PATHSEP '/' + #define PATHSEP '/' #endif int main(int argc, char* argv[]) @@ -24,32 +24,46 @@ int main(int argc, char* argv[]) out_file.open(filename, std::ios_base::out); if (out_file.fail()) { fprintf(stderr, "Error opening file '%s' for writing\n", - filename); + filename); return 1; } pyc_output = &out_file; - } else { + } + else { fputs("Option '-o' requires a filename\n", stderr); return 1; } - } else if (strcmp(argv[arg], "-c") == 0) { + } + else if (strcmp(argv[arg], "-c") == 0) { marshalled = true; - } else if (strcmp(argv[arg], "-v") == 0) { + } + else if (strcmp(argv[arg], "-v") == 0) { if (arg + 1 < argc) { version = argv[++arg]; - } else { + } + else { fputs("Option '-v' requires a version\n", stderr); return 1; } - } else if (strcmp(argv[arg], "--help") == 0 || strcmp(argv[arg], "-h") == 0) { + } + else if (strcmp(argv[arg], "--help") == 0 || + strcmp(argv[arg], "-h") == 0) { fprintf(stderr, "Usage: %s [options] input.pyc\n\n", argv[0]); fputs("Options:\n", stderr); - fputs(" -o Write output to (default: stdout)\n", stderr); - fputs(" -c Specify loading a compiled code object. Requires the version to be set\n", stderr); - fputs(" -v Specify a Python version for loading a compiled code object\n", stderr); - fputs(" --help Show this help text and then exit\n", stderr); + fputs( + " -o Write output to (default: stdout)\n", + stderr); + fputs( + " -c Specify loading a compiled code object. Requires the version to be set\n", + stderr); + fputs( + " -v Specify a Python version for loading a compiled code object\n", + stderr); + fputs( + " --help Show this help text and then exit\n", stderr); return 0; - } else { + } + else { infile = argv[arg]; } } @@ -67,19 +81,23 @@ int main(int argc, char* argv[]) fprintf(stderr, "Error loading file %s: %s\n", infile, ex.what()); return 1; } - } else { + } + else { if (!version) { - fputs("Opening raw code objects requires a version to be specified\n", stderr); + fputs( + "Opening raw code objects requires a version to be specified\n", + stderr); return 1; } std::string s(version); auto dot = s.find('.'); - if (dot == std::string::npos || dot == s.size()-1) { - fputs("Unable to parse version string (use the format x.y)\n", stderr); + if (dot == std::string::npos || dot == s.size() - 1) { + fputs("Unable to parse version string (use the format x.y)\n", + stderr); return 1; } int major = std::stoi(s.substr(0, dot)); - int minor = std::stoi(s.substr(dot+1, s.size())); + int minor = std::stoi(s.substr(dot + 1, s.size())); mod.loadFromMarshalledFile(infile, major, minor); } @@ -91,8 +109,8 @@ int main(int argc, char* argv[]) dispname = (dispname == NULL) ? infile : dispname + 1; *pyc_output << "# Source Generated with Decompyle++\n"; formatted_print(*pyc_output, "# File: %s (Python %d.%d%s)\n\n", dispname, - mod.majorVer(), mod.minorVer(), - (mod.majorVer() < 3 && mod.isUnicode()) ? " Unicode" : ""); + mod.majorVer(), mod.minorVer(), + (mod.majorVer() < 3 && mod.isUnicode()) ? " Unicode" : ""); try { decompyle(mod.code(), &mod, *pyc_output); } catch (std::exception& ex) {