opcode.h File Reference

#include <rz_types.h>
#include <rz_list.h>
#include <rz_util.h>
#include <rz_analysis.h>

Go to the source code of this file.

Classes
struct	pyc_opcode_object
struct	pyc_opcodes
struct	pyc_arg_fmt
struct	version_opcode
struct	op_analysis_func
struct	op_parameter

Macros
#define	OBJECT_SIZE_ON_STACK   1
#define	def_op(...)   def_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })
#define	def_op0(...)   def_opN((struct op_parameter){ .pop = -2, .push = -2, .fallthrough = true, __VA_ARGS__ })
#define	def_op00(...)   def_opN((struct op_parameter){ __VA_ARGS__ })
#define	name_op0(...)   name_opN((struct op_parameter){ .pop = -2, .push = -2, __VA_ARGS__ })
#define	name_op(...)   name_opN((struct op_parameter){ __VA_ARGS__ })
#define	local_op0(...)   local_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })
#define	local_op(...)   local_opN((struct op_parameter){ __VA_ARGS__ })
#define	free_op0(...)   free_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })
#define	free_op(...)   free_opN((struct op_parameter){ __VA_ARGS__ })
#define	store_op00(...)   store_opN((struct op_parameter){ __VA_ARGS__ })
#define	store_op(...)   store_opN((struct op_parameter){ .func = DEF_OP, __VA_ARGS__ })
#define	store_op0(...)   store_opN((struct op_parameter){ .pop = 0, .push = 1, .func = DEF_OP, __VA_ARGS__ })
#define	varargs_op(...)   varargs_op((struct op_parameter){ __VA_ARGS__ })
#define	varargs_op0(...)   varargs_op((struct op_parameter){ .pop = -1, .push = 1, __VA_ARGS__ })
#define	const_op(...)   const_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })
#define	const_op00(...)   const_opN((struct op_parameter){ __VA_ARGS__ })
#define	compare_op0(...)   compare_op((struct op_parameter){ .pop = 2, .push = 1, __VA_ARGS__ })
#define	compare_op(...)   compare_op((struct op_parameter){ __VA_ARGS__ })
#define	jabs_op00(...)   jabs_opN((struct op_parameter){ __VA_ARGS__ })
#define	jabs_op0(...)   jabs_opN((struct op_parameter){ .pop = 0, .push = 0, .conditional = false, .fallthrough = true, __VA_ARGS__ })
#define	jabs_op(...)   jabs_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })
#define	jrel_op00(...)   jrel_opN((struct op_parameter){ __VA_ARGS__ })
#define	jrel_op0(...)   jrel_opN((struct op_parameter){ .pop = 0, .push = 0, .conditional = false, .fallthrough = true, __VA_ARGS__ })
#define	jrel_op(...)   jrel_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })
#define	nargs_op(...)   nargs_op((struct op_parameter){ __VA_ARGS__ })
#define	nargs_op0(...)   nargs_op((struct op_parameter){ .pop = -2, .push = -2, __VA_ARGS__ })
#define	rm_op(...)   rm_op((struct op_parameter){ __VA_ARGS__ })

Enumerations
enum	pyc_opcode_type {   HASCOMPARE = 0x1 , HASCONDITION = 0x2 , HASCONST = 0x4 , HASFREE = 0x8 ,   HASJABS = 0x10 , HASJREL = 0x20 , HASLOCAL = 0x40 , HASNAME = 0x80 ,   HASNARGS = 0x100 , HASSTORE = 0x200 , HASVARGS = 0x400 , NOFOLLOW = 0x800 }
enum	pyc_store_op_func { NAME_OP = 0x1 , LOCAL_OP = 0x2 , FREE_OP = 0x4 , DEF_OP = 0x8 }

Functions
void	analysis_pyc_op (RzAnalysisOp *op, pyc_opcode_object *op_obj, ut32 oparg)
pyc_opcodes *	opcode_2x (void)
pyc_opcodes *	opcode_3x (void)
pyc_opcodes *	opcode_10 (void)
pyc_opcodes *	opcode_11 (void)
pyc_opcodes *	opcode_12 (void)
pyc_opcodes *	opcode_13 (void)
pyc_opcodes *	opcode_14 (void)
pyc_opcodes *	opcode_15 (void)
pyc_opcodes *	opcode_16 (void)
pyc_opcodes *	opcode_20 (void)
pyc_opcodes *	opcode_21 (void)
pyc_opcodes *	opcode_22 (void)
pyc_opcodes *	opcode_23 (void)
pyc_opcodes *	opcode_24 (void)
pyc_opcodes *	opcode_25 (void)
pyc_opcodes *	opcode_26 (void)
pyc_opcodes *	opcode_27 (void)
pyc_opcodes *	opcode_30 (void)
pyc_opcodes *	opcode_31 (void)
pyc_opcodes *	opcode_32 (void)
pyc_opcodes *	opcode_33 (void)
pyc_opcodes *	opcode_34 (void)
pyc_opcodes *	opcode_35 (void)
pyc_opcodes *	opcode_36 (void)
pyc_opcodes *	opcode_37 (void)
pyc_opcodes *	opcode_38 (void)
pyc_opcodes *	opcode_39 (void)
pyc_opcodes *	get_opcode_by_version (char *version)
pyc_opcodes *	new_pyc_opcodes ()
void	free_opcode (pyc_opcodes *opcodes)
bool	pyc_opcodes_equal (pyc_opcodes *op, const char *version)
void	add_arg_fmt (pyc_opcodes *ret, char *op_name, const char *(*formatter)(ut32 oparg))
const char *	format_MAKE_FUNCTION_arg_3x (ut32 oparg)
const char *	format_extended_arg (ut32 oparg)
const char *	format_CALL_FUNCTION_pos_name_encoded (ut32 oparg)
const char *	format_CALL_FUNCTION_KW_36 (ut32 oparg)
const char *	format_CALL_FUNCTION_EX_36 (ut32 oparg)
const char *	format_MAKE_FUNCTION_arg_36 (ut32 oparg)
const char *	format_value_flags_36 (ut32 oparg)
const char *	format_extended_arg_36 (ut32 oparg)
void()	def_opN (struct op_parameter par)
void()	name_opN (struct op_parameter par)
void()	local_opN (struct op_parameter par)
void()	free_opN (struct op_parameter par)
void()	store_opN (struct op_parameter par)
void()	varargs_op (struct op_parameter par)
void()	const_opN (struct op_parameter par)
void()	compare_op (struct op_parameter par)
void()	jabs_opN (struct op_parameter par)
void()	jrel_opN (struct op_parameter par)
void()	nargs_op (struct op_parameter par)
void()	rm_op (struct op_parameter par)

Macro Definition Documentation

compare_op

#define compare_op

(

...

)

compare_op((struct op_parameter){ __VA_ARGS__ })

Definition at line 158 of file opcode.h.

compare_op0

#define compare_op0

(

...

)

compare_op((struct op_parameter){ .pop = 2, .push = 1, __VA_ARGS__ })

Definition at line 157 of file opcode.h.

const_op

#define const_op

(

...

)

const_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })

Definition at line 153 of file opcode.h.

const_op00

#define const_op00

(

...

)

const_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 154 of file opcode.h.

def_op

#define def_op

(

...

)

def_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })

Definition at line 127 of file opcode.h.

def_op0

#define def_op0

(

...

)

def_opN((struct op_parameter){ .pop = -2, .push = -2, .fallthrough = true, __VA_ARGS__ })

Definition at line 128 of file opcode.h.

def_op00

#define def_op00

(

...

)

def_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 129 of file opcode.h.

free_op

#define free_op

(

...

)

free_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 141 of file opcode.h.

free_op0

#define free_op0

(

...

)

free_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })

Definition at line 140 of file opcode.h.

jabs_op

#define jabs_op

(

...

)

jabs_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })

Definition at line 163 of file opcode.h.

jabs_op0

#define jabs_op0

(

...

)

jabs_opN((struct op_parameter){ .pop = 0, .push = 0, .conditional = false, .fallthrough = true, __VA_ARGS__ })

Definition at line 162 of file opcode.h.

jabs_op00

#define jabs_op00

(

...

)

jabs_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 161 of file opcode.h.

jrel_op

#define jrel_op

(

...

)

jrel_opN((struct op_parameter){ .fallthrough = true, __VA_ARGS__ })

Definition at line 168 of file opcode.h.

jrel_op0

#define jrel_op0

(

...

)

jrel_opN((struct op_parameter){ .pop = 0, .push = 0, .conditional = false, .fallthrough = true, __VA_ARGS__ })

Definition at line 167 of file opcode.h.

jrel_op00

#define jrel_op00

(

...

)

jrel_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 166 of file opcode.h.

local_op

#define local_op

(

...

)

local_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 137 of file opcode.h.

local_op0

#define local_op0

(

...

)

local_opN((struct op_parameter){ .pop = 0, .push = 1, __VA_ARGS__ })

Definition at line 136 of file opcode.h.

name_op

#define name_op

(

...

)

name_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 133 of file opcode.h.

name_op0

#define name_op0

(

...

)

name_opN((struct op_parameter){ .pop = -2, .push = -2, __VA_ARGS__ })

Definition at line 132 of file opcode.h.

nargs_op

#define nargs_op

(

...

)

nargs_op((struct op_parameter){ __VA_ARGS__ })

Definition at line 171 of file opcode.h.

nargs_op0

#define nargs_op0

(

...

)

nargs_op((struct op_parameter){ .pop = -2, .push = -2, __VA_ARGS__ })

Definition at line 172 of file opcode.h.

OBJECT_SIZE_ON_STACK

#define OBJECT_SIZE_ON_STACK   1

Definition at line 13 of file opcode.h.

rm_op

#define rm_op

(

...

)

rm_op((struct op_parameter){ __VA_ARGS__ })

Definition at line 175 of file opcode.h.

store_op

#define store_op

(

...

)

store_opN((struct op_parameter){ .func = DEF_OP, __VA_ARGS__ })

Definition at line 145 of file opcode.h.

store_op0

#define store_op0

(

...

)

store_opN((struct op_parameter){ .pop = 0, .push = 1, .func = DEF_OP, __VA_ARGS__ })

Definition at line 146 of file opcode.h.

store_op00

#define store_op00

(

...

)

store_opN((struct op_parameter){ __VA_ARGS__ })

Definition at line 144 of file opcode.h.

varargs_op

#define varargs_op

(

...

)

varargs_op((struct op_parameter){ __VA_ARGS__ })

Definition at line 149 of file opcode.h.

varargs_op0

#define varargs_op0

(

...

)

varargs_op((struct op_parameter){ .pop = -1, .push = 1, __VA_ARGS__ })

Definition at line 150 of file opcode.h.

Enumeration Type Documentation

pyc_opcode_type

enum pyc_opcode_type

Enumerator
HASCOMPARE
HASCONDITION
HASCONST
HASFREE
HASJABS
HASJREL
HASLOCAL
HASNAME
HASNARGS
HASSTORE
HASVARGS
NOFOLLOW

Definition at line 15 of file opcode.h.

             {
    HASCOMPARE = 0x1,
    HASCONDITION = 0x2, // conditional operator; has jump offset
    HASCONST = 0x4,
    HASFREE = 0x8,
    HASJABS = 0x10, // Will appear with HASCONDITION sometimes
    HASJREL = 0x20, // Will appear with HASCONDITION sometimes
    HASLOCAL = 0x40,
    HASNAME = 0x80,
    HASNARGS = 0x100, // For function-like calls
    HASSTORE = 0x200, // Some sort of store operation
    HASVARGS = 0x400, // Similar but for operators BUILD_xxx
    NOFOLLOW = 0x800, // Instruction doesn't fall to the next opcode
} pyc_opcode_type;

pyc_store_op_func

enum pyc_store_op_func

Enumerator
NAME_OP
LOCAL_OP
FREE_OP
DEF_OP

Definition at line 30 of file opcode.h.

             {
    NAME_OP = 0x1,
    LOCAL_OP = 0x2,
    FREE_OP = 0x4,
    DEF_OP = 0x8,
} pyc_store_op_func;

Function Documentation

add_arg_fmt()

void add_arg_fmt	(	pyc_opcodes *	ret,
		char *	op_name,
		const char *(*)(ut32 oparg)	formatter
	)

Definition at line 234 of file opcode.c.

                                                                                        {
    pyc_arg_fmt *fmt = RZ_NEW0(pyc_arg_fmt);
    if (!fmt) {
        return;
    }
    fmt->op_name = op_name;
    fmt->formatter = formatter;
    rz_list_append(ret->opcode_arg_fmt, fmt);
}

References pyc_arg_fmt::formatter, pyc_arg_fmt::op_name, pyc_opcodes::opcode_arg_fmt, rz_list_append(), and RZ_NEW0.

Referenced by opcode_10(), opcode_11(), opcode_12(), opcode_13(), opcode_14(), opcode_15(), opcode_16(), opcode_20(), opcode_21(), opcode_22(), opcode_23(), opcode_24(), opcode_25(), opcode_26(), opcode_27(), opcode_30(), opcode_31(), opcode_32(), opcode_33(), opcode_34(), opcode_35(), opcode_36(), opcode_37(), opcode_38(), opcode_39(), and opcode_3x().

analysis_pyc_op()

void analysis_pyc_op	(	RzAnalysisOp *	op,
		pyc_opcode_object *	op_obj,
		ut32	oparg
	)

Definition at line 902 of file opcode_analysis.c.

                                                                              {
    size_t i;
    for (i = 0; i < (sizeof(op_analysis) / sizeof(op_analysis_func)); i++) {
        if (!strcmp(op_analysis[i].op_name, op_obj->op_name)) {
            op_analysis[i].func(op, op_obj, oparg);
            break;
        }
    }
}

References op_analysis_func::func, i, op_analysis, and pyc_opcode_object::op_name.

Referenced by pyc_op().

compare_op()

void() compare_op

(

struct op_parameter

par

)

Definition at line 301 of file opcode.c.

                                          {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASCOMPARE;
}

References def_op, HASCOMPARE, pyc_opcode_object::op_name, and op_parameter::op_obj.

const_opN()

void() const_opN

(

struct op_parameter

par

)

Definition at line 296 of file opcode.c.

                                         {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASCONST;
}

References def_op, HASCONST, pyc_opcode_object::op_name, and op_parameter::op_obj.

def_opN()

void() def_opN

(

struct op_parameter

par

)

Definition at line 244 of file opcode.c.

                                       {
    free(par.op_obj[par.op_code].op_name);
    par.op_obj[par.op_code].op_name = strdup(par.op_name);
    par.op_obj[par.op_code].op_code = par.op_code;
    par.op_obj[par.op_code].op_pop = par.pop;
    par.op_obj[par.op_code].op_push = par.push;
    if (!par.fallthrough) {
        par.op_obj[par.op_code].type |= NOFOLLOW;
    }
}

References free(), NOFOLLOW, and strdup().

Referenced by opcode_15().

format_CALL_FUNCTION_EX_36()

const char* format_CALL_FUNCTION_EX_36

(

ut32

oparg

)

Definition at line 27 of file opcode_arg_fmt.c.

                                                   {
    return rz_str_new((oparg & 0x01) ? "keyword args" : "");
}

References rz_str_new().

Referenced by opcode_36(), opcode_37(), opcode_38(), and opcode_39().

format_CALL_FUNCTION_KW_36()

const char* format_CALL_FUNCTION_KW_36

(

ut32

oparg

)

Definition at line 23 of file opcode_arg_fmt.c.

                                                   {
    return rz_str_newf("%u total positional and keyword args", oparg);
}

References rz_str_newf().

Referenced by opcode_36(), opcode_37(), opcode_38(), and opcode_39().

format_CALL_FUNCTION_pos_name_encoded()

const char* format_CALL_FUNCTION_pos_name_encoded

(

ut32

oparg

)

Definition at line 10 of file opcode_arg_fmt.c.

                                                              {
    ut32 pos_args = oparg & 0xFF;
    ut32 name = (oparg >> 8) & 0xFF;
    return rz_str_newf("%u positional, %u named", pos_args, name);
}

References rz_str_newf().

Referenced by opcode_27().

format_extended_arg()

const char* format_extended_arg

(

ut32

oparg

)

Definition at line 6 of file opcode_arg_fmt.c.

                                            {
    return rz_str_newf("%u", oparg * (1 << 16));
}

References rz_str_newf().

Referenced by opcode_10(), opcode_11(), opcode_12(), opcode_13(), opcode_14(), opcode_15(), opcode_16(), opcode_20(), opcode_21(), opcode_22(), opcode_23(), opcode_24(), opcode_25(), opcode_26(), opcode_27(), opcode_30(), opcode_31(), opcode_32(), opcode_33(), opcode_34(), opcode_35(), and opcode_3x().

format_extended_arg_36()

const char* format_extended_arg_36

(

ut32

oparg

)

Definition at line 69 of file opcode_arg_fmt.c.

                                               {
    return rz_str_newf("%u", oparg * (1 << 8));
}

References rz_str_newf().

Referenced by opcode_36(), opcode_37(), opcode_38(), and opcode_39().

format_MAKE_FUNCTION_arg_36()

const char* format_MAKE_FUNCTION_arg_36

(

ut32

oparg

)

Definition at line 33 of file opcode_arg_fmt.c.

                                                    {
    size_t i;
    char *ret = rz_str_new(" ");
    for (i = 0; i < sizeof(MAKE_FUNCTION_FLAGS) / sizeof(char *); ++i) {
        if (oparg & 0x1) {
            rz_str_appendf(ret, ", %s", MAKE_FUNCTION_FLAGS[i]);
        } else {
            free(ret);
            ret = rz_str_new(MAKE_FUNCTION_FLAGS[i]);
        }
        oparg >>= 1;
    }
    return ret;
}

References free(), i, MAKE_FUNCTION_FLAGS, rz_str_appendf(), and rz_str_new().

Referenced by opcode_36(), opcode_37(), opcode_38(), and opcode_39().

format_MAKE_FUNCTION_arg_3x()

const char* format_MAKE_FUNCTION_arg_3x

(

ut32

oparg

)

Definition at line 16 of file opcode_arg_fmt.c.

                                                    {
    ut32 pos_args = oparg & 0xFF;
    ut32 name_default = (oparg >> 8) & 0xFF;
    ut32 annotate_args = (oparg >> 16) & 0x7FFF;
    return rz_str_newf("%u positional, %u name and default, %u annotations", pos_args, name_default, annotate_args);
}

References rz_str_newf().

Referenced by opcode_30(), opcode_31(), opcode_32(), opcode_33(), opcode_34(), and opcode_35().

format_value_flags_36()

const char* format_value_flags_36

(

ut32

oparg

)

Definition at line 48 of file opcode_arg_fmt.c.

                                              {
    const char *ret = "";
    switch (oparg & 0x3) {
    case 1:
        ret = "!s";
        break;
    case 2:
        ret = "!r";
        break;
    case 3:
        ret = "!a";
        break;
    }
    if ((oparg & 0x4) == 0x4) {
        // pop fmt_spec from the stack and use it, else use an
        // empty fmt_spec.
        ret = "";
    }
    return rz_str_new(ret);
}

References rz_str_new().

Referenced by opcode_36(), opcode_37(), opcode_38(), and opcode_39().

free_opcode()

void free_opcode

(

pyc_opcodes *

opcodes

)

Definition at line 217 of file opcode.c.

                                       {
    size_t i;
    if (opcodes == NULL || opcodes->opcodes == NULL) {
        return;
    }
    for (i = 0; i < 256; i++) {
        if (opcodes->opcodes[i].op_name) {
            free(opcodes->opcodes[i].op_name);
        }
    }
    free(opcodes->opcodes);
    if (opcodes->opcode_arg_fmt) {
        rz_list_free(opcodes->opcode_arg_fmt);
    }
    free(opcodes);
}

References free(), i, NULL, opcodes, and rz_list_free().

Referenced by finish(), and pyc_op().

free_opN()

void() free_opN

(

struct op_parameter

par

)

Definition at line 265 of file opcode.c.

                                        {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASFREE;
}

References def_op, HASFREE, pyc_opcode_object::op_name, and op_parameter::op_obj.

get_opcode_by_version()

pyc_opcodes* get_opcode_by_version

(

char *

version

)

Definition at line 169 of file opcode.c.

                                                  {
    if (version == NULL) {
        return NULL;
    }
    version_opcode *vop = version_op;
 
    while (vop->version) {
        if (!strcmp(vop->version, version)) {
            return vop->opcode_func();
        }
        vop++;
    }
 
    return NULL; // No match version
}

References NULL, version_opcode::opcode_func, version_opcode::version, and version_op.

Referenced by disassemble(), and pyc_op().

jabs_opN()

void() jabs_opN

(

struct op_parameter

par

)

Definition at line 306 of file opcode.c.

                                        {
    def_op00(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push, .fallthrough = par.fallthrough);
    par.op_obj[par.op_code].type |= HASJABS;
    if (par.conditional) {
        par.op_obj[par.op_code].type |= HASCONDITION;
    }
}

References def_op00, HASCONDITION, HASJABS, pyc_opcode_object::op_name, and op_parameter::op_obj.

jrel_opN()

void() jrel_opN

(

struct op_parameter

par

)

Definition at line 314 of file opcode.c.

                                        {
    def_op00(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push, .fallthrough = par.fallthrough);
    par.op_obj[par.op_code].type |= HASJREL;
    if (par.conditional) {
        par.op_obj[par.op_code].type |= HASCONDITION;
    }
}

References def_op00, HASCONDITION, HASJREL, pyc_opcode_object::op_name, and op_parameter::op_obj.

local_opN()

void() local_opN

(

struct op_parameter

par

)

Definition at line 260 of file opcode.c.

                                         {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASLOCAL;
}

References def_op, HASLOCAL, pyc_opcode_object::op_name, and op_parameter::op_obj.

name_opN()

void() name_opN

(

struct op_parameter

par

)

Definition at line 255 of file opcode.c.

                                        {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASNAME;
}

References def_op, HASNAME, pyc_opcode_object::op_name, and op_parameter::op_obj.

nargs_op()

void() nargs_op

(

struct op_parameter

par

)

Definition at line 322 of file opcode.c.

                                        {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASNARGS;
}

References def_op, HASNARGS, pyc_opcode_object::op_name, and op_parameter::op_obj.

new_pyc_opcodes()

pyc_opcodes* new_pyc_opcodes

(

)

Definition at line 185 of file opcode.c.

                               {
    size_t i, j;
    pyc_opcodes *ret = RZ_NEW0(pyc_opcodes);
    if (!ret) {
        return NULL;
    }
    ret->have_argument = 90;
    ret->opcodes = malloc(sizeof(pyc_opcode_object) * 256);
    if (!ret->opcodes) {
        free(ret);
        return NULL;
    }
    for (i = 0; i < 256; i++) {
        ret->opcodes[i].op_name = rz_str_newf("<%zu>", i);
        if (!ret->opcodes[i].op_name) {
            for (j = 0; j < i; j++) {
                free(ret->opcodes[j].op_name);
            }
            free(ret->opcodes);
            RZ_FREE(ret);
            return NULL;
        }
        ret->opcodes[i].type = 0;
        ret->opcodes[i].op_code = i;
        ret->opcodes[i].op_push = 0;
        ret->opcodes[i].op_pop = 0;
    }
 
    ret->opcode_arg_fmt = rz_list_newf((RzListFree)free);
    return ret;
}

References free(), pyc_opcodes::have_argument, i, malloc(), NULL, pyc_opcode_object::op_code, pyc_opcode_object::op_name, pyc_opcode_object::op_pop, pyc_opcode_object::op_push, pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, RZ_FREE, rz_list_newf(), RZ_NEW0, rz_str_newf(), and pyc_opcode_object::type.

Referenced by opcode_15(), opcode_2x(), and opcode_3x().

opcode_10()

pyc_opcodes* opcode_10

(

void

)

Definition at line 6 of file opcode_10.c.

                             {
    pyc_opcodes *ret = opcode_11();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_10;
 
    // 1.0 - 1.1 bytecodes differences
    rm_op(.op_obj = ret->opcodes, .op_name = "LOAD_GLOBALS", .op_code = 84);
    rm_op(.op_obj = ret->opcodes, .op_name = "EXEC_STMT", .op_code = 85);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_10(), opcode_11(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_10().

opcode_11()

pyc_opcodes* opcode_11

(

void

)

Definition at line 6 of file opcode_11.c.

                             {
    pyc_opcodes *ret = opcode_13();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_11;
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, opcode_11(), opcode_13(), pyc_opcodes::opcode_arg_fmt, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_10(), and opcode_11().

opcode_12()

pyc_opcodes* opcode_12

(

void

)

Definition at line 6 of file opcode_12.c.

                             {
    pyc_opcodes *ret = opcode_13();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_12;
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, opcode_12(), opcode_13(), pyc_opcodes::opcode_arg_fmt, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_12().

opcode_13()

pyc_opcodes* opcode_13

(

void

)

Definition at line 6 of file opcode_13.c.

                             {
    pyc_opcodes *ret = opcode_14();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_13;
 
    // 1.3 - 1.4 bytecodes differences
    rm_op(.op_obj = ret->opcodes, .op_name = "BINARY_POWER", .op_code = 19);
    def_op(.op_obj = ret->opcodes, .op_name = "LOAD_GLOBALS", .op_code = 84);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_13(), opcode_14(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_11(), opcode_12(), and opcode_13().

opcode_14()

pyc_opcodes* opcode_14

(

void

)

Definition at line 6 of file opcode_14.c.

                             {
    pyc_opcodes *ret = opcode_15();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_14;
 
    // 1.4 Bytecodes not in 1.5
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_CALL", .op_code = 14);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_CALL", .op_code = 26);
    def_op(.op_obj = ret->opcodes, .op_name = "RAISE_EXCEPTION", .op_code = 81);
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_FUNCTION", .op_code = 86);
    varargs_op(.op_obj = ret->opcodes, .op_name = "UNPACK_ARG", .op_code = 94); // Number of arguments expected
    varargs_op(.op_obj = ret->opcodes, .op_name = "UNPACK_VARARG", .op_code = 99); // Minimal number of arguments
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_LOCAL", .op_code = 115);
    varargs_op(.op_obj = ret->opcodes, .op_name = "SET_FUNC_ARGS", .op_code = 117); // Argcount
    varargs_op(.op_obj = ret->opcodes, .op_name = "RESERVE_FAST", .op_code = 123); // Number of local variables
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), name_op, NULL, pyc_opcode_object::op_name, opcode_14(), opcode_15(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_13(), and opcode_14().

opcode_15()

pyc_opcodes* opcode_15

(

void

)

Definition at line 6 of file opcode_15.c.

                             {
    pyc_opcodes *ret = new_pyc_opcodes();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_15;
 
    def_opN((struct op_parameter){ .op_obj = ret->opcodes, .op_name = "STOP_CODE", .op_code = 0, .pop = 0, .push = 0, .fallthrough = false });
    def_op(.op_obj = ret->opcodes, .op_name = "POP_TOP", .op_code = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_TWO", .op_code = 2);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_THREE", .op_code = 3);
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOP", .op_code = 4);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_POSITIVE", .op_code = 10, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NEGATIVE", .op_code = 11, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NOT", .op_code = 12, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_CONVERT", .op_code = 13, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_INVERT", .op_code = 15, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_POWER", .op_code = 19, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MULTIPLY", .op_code = 20, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_DIVIDE", .op_code = 21, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MODULO", .op_code = 22, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_ADD", .op_code = 23, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBTRACT", .op_code = 24, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBSCR", .op_code = 25, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_0", .op_code = 30, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_1", .op_code = 31, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_2", .op_code = 32, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_3", .op_code = 33, .pop = 3, .push = 1);
 
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_0", .op_code = 40, .pop = 2, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_1", .op_code = 41, .pop = 3, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_2", .op_code = 42, .pop = 3, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_3", .op_code = 43, .pop = 4, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_0", .op_code = 50, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_1", .op_code = 51, .pop = 2, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_2", .op_code = 52, .pop = 2, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_3", .op_code = 53, .pop = 3, .push = 0);
 
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SUBSCR", .op_code = 60, .pop = 3, .push = 0); // Implements TOS1[TOS] = TOS2.
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SUBSCR", .op_code = 61, .pop = 2, .push = 0); // Implements del TOS1[TOS].
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_LSHIFT", .op_code = 62, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_RSHIFT", .op_code = 63, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_AND", .op_code = 64, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_XOR", .op_code = 65, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_OR", .op_code = 66, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_EXPR", .op_code = 70, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_ITEM", .op_code = 71, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_NEWLINE", .op_code = 72, .pop = 1, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BREAK_LOOP", .op_code = 80, .pop = 0, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "LOAD_LOCALS", .op_code = 82, .pop = 0, .push = 1);
    def_op00(.op_obj = ret->opcodes, .op_name = "RETURN_VALUE", .op_code = 83, .pop = 1, .push = 0, .fallthrough = false);
 
    def_op(.op_obj = ret->opcodes, .op_name = "EXEC_STMT", .op_code = 85, .pop = 3, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "POP_BLOCK", .op_code = 87, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "END_FINALLY", .op_code = 88, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_CLASS", .op_code = 89, .pop = 3, .push = 0);
 
    ret->have_argument = 90; // Opcodes from here have an argument:
 
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_NAME", .op_code = 90, .pop = 1, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_NAME", .op_code = 91, .pop = 0, .push = 0); // ""
    varargs_op(.op_obj = ret->opcodes, .op_name = "UNPACK_TUPLE", .op_code = 92); // Number of tuple items
    def_op(.op_obj = ret->opcodes, .op_name = "UNPACK_LIST", .op_code = 93); // Number of list items
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_ATTR", .op_code = 95, .pop = 2, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_ATTR", .op_code = 96, .pop = 1, .push = 0); // ""
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_GLOBAL", .op_code = 97, .pop = 1, .push = 0, .func = NAME_OP); // ""
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_GLOBAL", .op_code = 98, .pop = 0, .push = 0); // ""
 
    const_op00(.op_obj = ret->opcodes, .op_name = "LOAD_CONST", .op_code = 100, .pop = 0, .push = 1); // Operand is in const list
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_NAME", .op_code = 101, .pop = 0, .push = 1); // Operand is in name list
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_TUPLE", .op_code = 102, .pop = -1, .push = 1); // Number of tuple items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_LIST", .op_code = 103, .pop = -1, .push = 1); // Number of list items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP", .op_code = 104, .pop = -1, .push = 1); // Always zero for now
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_ATTR", .op_code = 105, .pop = 1, .push = 1); // Operand is in name list
    compare_op(.op_obj = ret->opcodes, .op_name = "COMPARE_OP", .op_code = 106, .pop = 2, .push = 1); // Comparison operator
 
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_NAME", .op_code = 107, .pop = 2, .push = 1); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_FROM", .op_code = 108, .pop = 0, .push = 1); // Operand is in name list
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_FORWARD", .op_code = 110, .pop = 0, .push = 0); // Number of bytes to skip
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE", .op_code = 111, .pop = 1, .push = 1, .conditional = true); // ""
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE", .op_code = 112, .pop = 1, .push = 1, .conditional = true); // ""
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_ABSOLUTE", .op_code = 113, .pop = 0, .push = 0); // Target byte offset from beginning of code
    def_op(.op_obj = ret->opcodes, .op_name = "FOR_LOOP", .op_code = 114); // Number of bytes to skip
 
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_GLOBAL", .op_code = 116, .pop = 0, .push = 1); // Operand is in name list
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_LOOP", .op_code = 120, .pop = 0, .push = 0, .conditional = true); // Distance to target address
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_EXCEPT", .op_code = 121, .pop = 0, .push = 0, .conditional = true); // ""
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_FINALLY", .op_code = 122, .pop = 0, .push = 0, .conditional = true); // ""
 
    local_op(.op_obj = ret->opcodes, .op_name = "LOAD_FAST", .op_code = 124, .pop = 0, .push = 1); // Local variable number
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_FAST", .op_code = 125, .pop = 1, .push = 0, .func = LOCAL_OP); // Local variable number
    local_op0(.op_obj = ret->opcodes, .op_name = "DELETE_FAST", .op_code = 126); // Local variable number
 
    def_op(.op_obj = ret->opcodes, .op_name = "SET_LINENO", .op_code = 127); // Current line number
 
    def_op00(.op_obj = ret->opcodes, .op_name = "RAISE_VARARGS", .op_code = 130, .pop = -1, .push = 0, .fallthrough = false);
    // Number of raise arguments (1, 2, or 3)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION", .op_code = 131, .pop = -1, .push = 1); // //args + (//kwargs << 8)
 
    def_op(.op_obj = ret->opcodes, .op_name = "MAKE_FUNCTION", .op_code = 132, .pop = -1, .push = 1); // Number of args with default values
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_SLICE", .op_code = 133, .pop = -1, .push = 1); // Number of items
 
    def_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", .op_code = 143);
    ret->extended_arg = 143;
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), compare_op, const_op00, def_op, def_op00, def_opN(), pyc_opcodes::extended_arg, format_extended_arg(), pyc_opcodes::have_argument, jabs_op, jrel_op, LOCAL_OP, local_op, local_op0, NAME_OP, name_op, nargs_op, new_pyc_opcodes(), NULL, pyc_opcode_object::op_name, opcode_15(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), store_op, store_op00, varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_14(), opcode_15(), and opcode_16().

opcode_16()

pyc_opcodes* opcode_16

(

void

)

Definition at line 6 of file opcode_16.c.

                             {
    pyc_opcodes *ret = opcode_15();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_16;
 
    // 1.6 Bytecodes not in 1.5
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR", .op_code = 140, .pop = -1, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_KW", .op_code = 141, .pop = -1, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR_KW", .op_code = 142, .pop = -1, .push = 1); // #args + (#kwargs << 8)
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), nargs_op, NULL, pyc_opcode_object::op_name, opcode_15(), opcode_16(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_16().

opcode_20()

pyc_opcodes* opcode_20

(

void

)

Definition at line 6 of file opcode_20.c.

                             {
    pyc_opcodes *ret = opcode_21();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_20;
 
    // 2.1 Bytecodes not in 2.0
    rm_op(.op_obj = ret->opcodes, .op_name = "CONTINUE_LOOP", .op_code = 119);
    rm_op(.op_obj = ret->opcodes, .op_name = "MAKE_CLOSURE", .op_code = 134);
    rm_op(.op_obj = ret->opcodes, .op_name = "LOAD_CLOSURE", .op_code = 135);
    rm_op(.op_obj = ret->opcodes, .op_name = "LOAD_DEREF", .op_code = 136);
    rm_op(.op_obj = ret->opcodes, .op_name = "STORE_DEREF", .op_code = 137);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_20(), opcode_21(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_20().

opcode_21()

pyc_opcodes* opcode_21

(

void

)

Definition at line 6 of file opcode_21.c.

                             {
    pyc_opcodes *ret = opcode_22();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_21;
 
    // 2.1 bytecodes changes from 2.2
    rm_op(.op_obj = ret->opcodes, .op_name = "BINARY_FLOOR_DIVIDE", .op_code = 26);
    rm_op(.op_obj = ret->opcodes, .op_name = "BINARY_TRUE_DIVIDE", .op_code = 27);
    rm_op(.op_obj = ret->opcodes, .op_name = "INPLACE_FLOOR_DIVIDE", .op_code = 28);
    rm_op(.op_obj = ret->opcodes, .op_name = "INPLACE_TRUE_DIVIDE", .op_code = 29);
    rm_op(.op_obj = ret->opcodes, .op_name = "GET_ITER", .op_code = 68);
    rm_op(.op_obj = ret->opcodes, .op_name = "YIELD_VALUE", .op_code = 86);
    rm_op(.op_obj = ret->opcodes, .op_name = "FOR_ITER", .op_code = 93);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_21(), opcode_22(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_20(), and opcode_21().

opcode_22()

pyc_opcodes* opcode_22

(

void

)

Definition at line 6 of file opcode_22.c.

                             {
    pyc_opcodes *ret = opcode_2x();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_22;
 
    // 2.2 Bytecodes not in 2.3
    def_op(.op_obj = ret->opcodes, .op_name = "FOR_LOOP", .op_code = 114);
    def_op(.op_obj = ret->opcodes, .op_name = "SET_LINENO", .op_code = 127, .pop = 0, .push = 0);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_22(), opcode_2x(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_21(), and opcode_22().

opcode_23()

pyc_opcodes* opcode_23

(

void

)

Definition at line 6 of file opcode_23.c.

                             {
    pyc_opcodes *ret = opcode_2x();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_23;
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, opcode_23(), opcode_2x(), pyc_opcodes::opcode_arg_fmt, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_23().

opcode_24()

pyc_opcodes* opcode_24

(

void

)

Definition at line 6 of file opcode_24.c.

                             {
    pyc_opcodes *ret = opcode_2x();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_24;
 
    // Bytecodes added since 2.3
    def_op(.op_obj = ret->opcodes, .op_name = "NOP", .op_code = 9, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "LIST_APPEND", .op_code = 18, .pop = 2, .push = 1); // Calls list.append(TOS[-i], TOS).
    // Used to implement list comprehensions.
    def_op(.op_obj = ret->opcodes, .op_name = "YIELD_VALUE", .op_code = 86, .pop = 1, .push = 0);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_24(), opcode_2x(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_24(), and opcode_25().

opcode_25()

pyc_opcodes* opcode_25

(

void

)

Definition at line 6 of file opcode_25.c.

                             {
    pyc_opcodes *ret = opcode_24();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_25;
 
    // Bytecodes added in 2.5 from 2.4
    def_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP", .op_code = 81);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_24(), opcode_25(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_25(), and opcode_26().

opcode_26()

pyc_opcodes* opcode_26

(

void

)

Definition at line 6 of file opcode_26.c.

                             {
    pyc_opcodes *ret = opcode_25();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_26;
 
    // Below are opcode changes since Python 2.5
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_MAP", .op_code = 54, .pop = 3, .push = 1);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), NULL, pyc_opcode_object::op_name, opcode_25(), opcode_26(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), store_op, and pyc_opcodes::version_sig.

Referenced by opcode_26(), and opcode_27().

opcode_27()

pyc_opcodes* opcode_27

(

void

)

Definition at line 6 of file opcode_27.c.

                             {
    pyc_opcodes *ret = opcode_26();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_27;
 
    // Below are opcode changes since Python 2.6
    rm_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP", .op_code = 104);
    rm_op(.op_obj = ret->opcodes, .op_name = "LOAD_ATTR", .op_code = 105);
    rm_op(.op_obj = ret->opcodes, .op_name = "COMPARE_OP", .op_code = 106);
    rm_op(.op_obj = ret->opcodes, .op_name = "IMPORT_NAME", .op_code = 107);
    rm_op(.op_obj = ret->opcodes, .op_name = "IMPORT_FROM", .op_code = 108);
    rm_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE", .op_code = 111);
    rm_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", .op_code = 143);
    rm_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE", .op_code = 112);
 
    def_op(.op_obj = ret->opcodes, .op_name = "LIST_APPEND", .op_code = 94, .pop = 2, .push = 1); // Calls list.append(TOS[-i], TOS).
    // Used to implement list comprehensions.
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_SET", .op_code = 104); // Number of set items
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP", .op_code = 105);
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_ATTR", .op_code = 106);
    compare_op(.op_obj = ret->opcodes, .op_name = "COMPARE_OP", .op_code = 107);
 
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_NAME", .op_code = 108, .pop = 2, .push = 1); // Index in name list
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_FROM", .op_code = 109, .pop = 0, .push = 1);
 
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE_OR_POP", .op_code = 111, .conditional = true); // Target byte offset from beginning of code
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE_OR_POP", .op_code = 112, .conditional = true); // ""
    jabs_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_FALSE", .op_code = 114, .conditional = true); // ""
    jabs_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_TRUE", .op_code = 115, .conditional = true); // ""
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_WITH", .op_code = 143, .pop = 0, .push = 2);
 
    def_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", .op_code = 145);
    def_op(.op_obj = ret->opcodes, .op_name = "SET_ADD", .op_code = 146, .pop = 1, .push = 0); // Calls set.add(TOS1[-i], TOS).
    // Used to implement set comprehensions.
    def_op(.op_obj = ret->opcodes, .op_name = "MAP_ADD", .op_code = 147, .pop = 2, .push = 1); // Calls dict.setitem(TOS1[-i], TOS, TOS1)
    // Used to implement dict comprehensions.
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "CALL_FUNCTION", format_CALL_FUNCTION_pos_name_encoded);
 
    return ret;
}

References add_arg_fmt(), compare_op, def_op, format_CALL_FUNCTION_pos_name_encoded(), format_extended_arg(), jabs_op, jrel_op, name_op, NULL, pyc_opcode_object::op_name, opcode_26(), opcode_27(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_27().

opcode_2x()

pyc_opcodes* opcode_2x

(

void

)

Definition at line 6 of file opcode_2x.c.

                             {
    pyc_opcodes *ret = new_pyc_opcodes();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_2x;
 
    def_op00(.op_obj = ret->opcodes, .op_name = "STOP_CODE", .op_code = 0, .pop = 0, .push = 0, .fallthrough = false);
    def_op(.op_obj = ret->opcodes, .op_name = "POP_TOP", .op_code = 1, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_TWO", .op_code = 2, .pop = 2, .push = 2);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_THREE", .op_code = 3, .pop = 3, .push = 3);
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOP", .op_code = 4, .pop = 0, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_FOUR", .op_code = 5, .pop = 4, .push = 4);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_POSITIVE", .op_code = 10, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NEGATIVE", .op_code = 11, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NOT", .op_code = 12, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_CONVERT", .op_code = 13, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_INVERT", .op_code = 15, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_POWER", .op_code = 19, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MULTIPLY", .op_code = 20, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_DIVIDE", .op_code = 21, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MODULO", .op_code = 22, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_ADD", .op_code = 23, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBTRACT", .op_code = 24, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBSCR", .op_code = 25, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_FLOOR_DIVIDE", .op_code = 26, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_TRUE_DIVIDE", .op_code = 27, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_FLOOR_DIVIDE", .op_code = 28, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_TRUE_DIVIDE", .op_code = 29, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_0", .op_code = 30, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_1", .op_code = 31, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_2", .op_code = 32, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SLICE_3", .op_code = 33, .pop = 3, .push = 1);
 
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_0", .op_code = 40, .pop = 2, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_1", .op_code = 41, .pop = 3, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_2", .op_code = 42, .pop = 3, .push = 0);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SLICE_3", .op_code = 43, .pop = 4, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_0", .op_code = 50, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_1", .op_code = 51, .pop = 2, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_2", .op_code = 52, .pop = 2, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SLICE_3", .op_code = 53, .pop = 3, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_ADD", .op_code = 55, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_SUBTRACT", .op_code = 56, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_MULTIPLY", .op_code = 57, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_DIVIDE", .op_code = 58, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_MODULO", .op_code = 59, .pop = 2, .push = 1);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SUBSCR", .op_code = 60, .pop = 3, .push = 0); // Implements TOS1[TOS] = TOS2.
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SUBSCR", .op_code = 61, .pop = 2, .push = 0); // Implements del TOS1[TOS].
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_LSHIFT", .op_code = 62, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_RSHIFT", .op_code = 63, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_AND", .op_code = 64, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_XOR", .op_code = 65, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_OR", .op_code = 66, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_POWER", .op_code = 67, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_ITER", .op_code = 68, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_EXPR", .op_code = 70, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_ITEM", .op_code = 71, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_NEWLINE", .op_code = 72, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_ITEM_TO", .op_code = 73, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_NEWLINE_TO", .op_code = 74, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_LSHIFT", .op_code = 75, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_RSHIFT", .op_code = 76, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_AND", .op_code = 77, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_XOR", .op_code = 78, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_OR", .op_code = 79, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BREAK_LOOP", .op_code = 80, .pop = 0, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "LOAD_LOCALS", .op_code = 82, .pop = 0, .push = 1);
    def_op00(.op_obj = ret->opcodes, .op_name = "RETURN_VALUE", .op_code = 83, .pop = 1, .push = 0, .fallthrough = false);
    def_op(.op_obj = ret->opcodes, .op_name = "IMPORT_STAR", .op_code = 84, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "EXEC_STMT", .op_code = 85, .pop = 3, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "YIELD_VALUE", .op_code = 86, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "POP_BLOCK", .op_code = 87, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "END_FINALLY", .op_code = 88, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_CLASS", .op_code = 89, .pop = 3, .push = 0);
 
    ret->have_argument = 90; // Opcodes from here have an argument:
 
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_NAME", .op_code = 90, .pop = 1, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_NAME", .op_code = 91, .pop = 0, .push = 0); // ""
    varargs_op(.op_obj = ret->opcodes, .op_name = "UNPACK_SEQUENCE", .op_code = 92, .pop = 9, .push = 1); // TOS is number of tuple items
    jrel_op(.op_obj = ret->opcodes, .op_name = "FOR_ITER", .op_code = 93, .pop = 9, .push = 1); // TOS is read
 
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_ATTR", .op_code = 95, .pop = 2, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_ATTR", .op_code = 96, .pop = 1, .push = 0); // ""
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_GLOBAL", .op_code = 97, .pop = 1, .push = 0, .func = NAME_OP); // ""
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_GLOBAL", .op_code = 98, .pop = 0, .push = 0); // ""
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOPX", .op_code = 99, .pop = 1, .push = -1); // number of items to duplicate
    const_op00(.op_obj = ret->opcodes, .op_name = "LOAD_CONST", .op_code = 100, .pop = 0, .push = 1); // Operand is in const list
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_NAME", .op_code = 101, .pop = 0, .push = 1); // Operand is in name list
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_TUPLE", .op_code = 102, .pop = 9, .push = 1); // TOS is number of tuple items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_LIST", .op_code = 103, .pop = 9, .push = 1); // TOS is number of list items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP", .op_code = 104, .pop = 0, .push = 1); // TOS is number of kwark items. Always zero for now
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_ATTR", .op_code = 105, .pop = 1, .push = 1); // Operand is in name list
    compare_op(.op_obj = ret->opcodes, .op_name = "COMPARE_OP", .op_code = 106, .pop = 2, .push = 1); // Comparison operator
 
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_NAME", .op_code = 107, .pop = 2, .push = 1); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_FROM", .op_code = 108, .pop = 0, .push = 1); // Operand is in name list
 
    jrel_op00(.op_obj = ret->opcodes, .op_name = "JUMP_FORWARD", .op_code = 110, .pop = 0, .push = 0, .fallthrough = false); // Number of bytes to skip
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE", .op_code = 111, .pop = 1, .push = 1, .conditional = true); // ""
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE", .op_code = 112, .pop = 1, .push = 1, .conditional = true); // ""
    jabs_op00(.op_obj = ret->opcodes, .op_name = "JUMP_ABSOLUTE", .op_code = 113, .pop = 0, .push = 0, .fallthrough = false); // Target byte offset from beginning of code
 
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_GLOBAL", .op_code = 116, .pop = 0, .push = 1); // Operand is in name list
 
    jabs_op00(.op_obj = ret->opcodes, .op_name = "CONTINUE_LOOP", .op_code = 119, .pop = 0, .push = 0, .fallthrough = false); // Target address
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_LOOP", .op_code = 120, .pop = 0, .push = 0, .conditional = true); // Distance to target address
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_EXCEPT", .op_code = 121, .pop = 0, .push = 6, .conditional = true); // ""
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_FINALLY", .op_code = 122, .pop = 0, .push = 7, .conditional = true); // ""
 
    local_op(.op_obj = ret->opcodes, .op_name = "LOAD_FAST", .op_code = 124, .pop = 0, .push = 1); // Local variable number
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_FAST", .op_code = 125, .pop = 1, .push = 0, .func = LOCAL_OP); // Local variable number
    local_op(.op_obj = ret->opcodes, .op_name = "DELETE_FAST", .op_code = 126); // Local variable number
 
    def_op00(.op_obj = ret->opcodes, .op_name = "RAISE_VARARGS", .op_code = 130, .pop = 1, .push = 0, .fallthrough = false); // Number of raise arguments (1, 2, or 3)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION", .op_code = 131, .pop = 9, .push = 1); // TOS is //args + (//kwargs << 8)
 
    def_op(.op_obj = ret->opcodes, .op_name = "MAKE_FUNCTION", .op_code = 132, .pop = 9, .push = 1); // TOS is number of args with default values
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_SLICE", .op_code = 133, .pop = 9, .push = 1); // TOS is number of items
 
    def_op(.op_obj = ret->opcodes, .op_name = "MAKE_CLOSURE", .op_code = 134, .pop = 9, .push = 1);
    free_op(.op_obj = ret->opcodes, .op_name = "LOAD_CLOSURE", .op_code = 135, .pop = 0, .push = 1);
    free_op(.op_obj = ret->opcodes, .op_name = "LOAD_DEREF", .op_code = 136, .pop = 0, .push = 1);
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_DEREF", .op_code = 137, .pop = 1, .push = 0, .func = FREE_OP);
 
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR", .op_code = 140, .pop = -1, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_KW", .op_code = 141, .pop = -1, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR_KW", .op_code = 142, .pop = -1, .push = 1); // #args + (#kwargs << 8)
 
    def_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", 143);
    ret->extended_arg = 143;
 
    rz_list_purge(ret->opcode_arg_fmt);
 
    return ret;
}

References compare_op, const_op00, def_op, def_op00, pyc_opcodes::extended_arg, FREE_OP, free_op, pyc_opcodes::have_argument, jabs_op00, jrel_op, jrel_op00, LOCAL_OP, local_op, NAME_OP, name_op, nargs_op, new_pyc_opcodes(), NULL, pyc_opcode_object::op_name, opcode_2x(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), store_op, store_op00, varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_22(), opcode_23(), opcode_24(), and opcode_2x().

opcode_30()

pyc_opcodes* opcode_30

(

void

)

Definition at line 6 of file opcode_30.c.

                             {
    pyc_opcodes *ret = opcode_31();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_30;
 
    // These are in Python 3.x but not in Python 3.0
 
    rm_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE_OR_POP", .op_code = 111);
    rm_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE_OR_POP", .op_code = 112);
    rm_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_FALSE", .op_code = 114);
    rm_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_TRUE", .op_code = 115);
    rm_op(.op_obj = ret->opcodes, .op_name = "LIST_APPEND", .op_code = 145);
    rm_op(.op_obj = ret->opcodes, .op_name = "MAP_ADD", .op_code = 147);
 
    // These are are in 3.0 but are not in 3.1 or they have
    // different opcode numbers. Note: As a result of opcode value
    // changes, these have to be applied *after* removing ops (with
    // the same name).
 
    def_op(.op_obj = ret->opcodes, .op_name = "SET_ADD", .op_code = 17, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "LIST_APPEND", .op_code = 18, .pop = 2, .push = 1);
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE", .op_code = 111, .pop = 1, .push = 1, .conditional = true);
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE", .op_code = 112, .pop = 1, .push = 1, .conditional = true);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), jrel_op, NULL, pyc_opcode_object::op_name, opcode_30(), opcode_31(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_30().

opcode_31()

pyc_opcodes* opcode_31

(

void

)

Definition at line 6 of file opcode_31.c.

                             {
    pyc_opcodes *ret = opcode_32();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_31;
 
    // These are in Python 3.2 but not in Python 3.1
    rm_op(.op_obj = ret->opcodes, .op_name = "DUP_TOP_TWO", .op_code = 5);
    rm_op(.op_obj = ret->opcodes, .op_name = "DELETE_DEREF", .op_code = 138);
    rm_op(.op_obj = ret->opcodes, .op_name = "SETUP_WITH", .op_code = 143);
 
    // These are in Python 3.1 but not Python 3.2
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_FOUR", .op_code = 5);
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOPX", .op_code = 99);
 
    // This op is in 3.2 but its opcode is a 144 instead
    def_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", .op_code = 143);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), NULL, pyc_opcode_object::op_name, opcode_31(), opcode_32(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_30(), and opcode_31().

opcode_32()

pyc_opcodes* opcode_32

(

void

)

Definition at line 6 of file opcode_32.c.

                             {
    pyc_opcodes *ret = opcode_3x();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_32;
 
    // There are no opcodes to add or change.
    // If there were, they'd be listed below.
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), NULL, opcode_32(), opcode_3x(), pyc_opcodes::opcode_arg_fmt, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_31(), and opcode_32().

opcode_33()

pyc_opcodes* opcode_33

(

void

)

Definition at line 6 of file opcode_33.c.

                             {
    pyc_opcodes *ret = opcode_3x();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_33;
 
    // Below are opcode changes since Python 3.2
 
    rm_op(.op_obj = ret->opcodes, .op_name = "STOP_CODE", .op_code = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "YIELD_FROM", .op_code = 72, .pop = 1, .push = 0);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), NULL, pyc_opcode_object::op_name, opcode_33(), opcode_3x(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_33(), and opcode_34().

opcode_34()

pyc_opcodes* opcode_34

(

void

)

Definition at line 6 of file opcode_34.c.

                             {
    pyc_opcodes *ret = opcode_33();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_34;
 
    // These are removed since Python 3.3
    rm_op(.op_obj = ret->opcodes, .op_name = "STORE_LOCALS", .op_code = 69);
 
    // These are new since Python 3.3
    def_op(.op_obj = ret->opcodes, .op_name = "YIELD_FROM", .op_code = 72);
    free_op(.op_obj = ret->opcodes, .op_name = "LOAD_CLASSDEREF", .op_code = 148);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), free_op, NULL, pyc_opcode_object::op_name, opcode_33(), opcode_34(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_34(), and opcode_35().

opcode_35()

pyc_opcodes* opcode_35

(

void

)

Definition at line 6 of file opcode_35.c.

                             {
    pyc_opcodes *ret = opcode_34();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_35;
 
    // These are removed since Python 3.5.
    // Removals happen before adds since
    // some opcodes are reused
    rm_op(.op_obj = ret->opcodes, .op_name = "STORE_MAP", .op_code = 54);
    rm_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP", .op_code = 81);
 
    // These are new since Python 3.5
    //          OP NAME                   OPCODE POP PUSH
    //---------------------------------------------------
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MATRIX_MULTIPLY", .op_code = 16, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_MATRIX_MULTIPLY", .op_code = 17, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_AITER", .op_code = 50, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_ANEXT", .op_code = 51, .pop = 0, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BEFORE_ASYNC_WITH", .op_code = 52);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_YIELD_FROM_ITER", .op_code = 69, .pop = 0, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_AWAITABLE", .op_code = 73, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP_START", .op_code = 81, .pop = 0, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP_FINISH", .op_code = 82, .pop = -1, .push = 1);
 
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_LIST_UNPACK", .op_code = 149, .pop = -1, .push = 1);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP_UNPACK", .op_code = 150, .pop = -1, .push = 1);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP_UNPACK_WITH_CALL", .op_code = 151, .pop = -1, .push = 1);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_TUPLE_UNPACK", .op_code = 152, .pop = -1, .push = 1);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_SET_UNPACK", .op_code = 153, .pop = -1, .push = 1);
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_ASYNC_WITH", .op_code = 154, .pop = 0, .push = 6);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_3x);
 
    return ret;
}

References add_arg_fmt(), def_op, format_extended_arg(), format_MAKE_FUNCTION_arg_3x(), jrel_op, NULL, pyc_opcode_object::op_name, opcode_34(), opcode_35(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_35(), and opcode_36().

opcode_36()

pyc_opcodes* opcode_36

(

void

)

Definition at line 6 of file opcode_36.c.

                             {
    pyc_opcodes *ret = opcode_35();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_36;
 
    // These are removed since Python 3.6
    rm_op(.op_obj = ret->opcodes, .op_name = "MAKE_CLOSURE", .op_code = 134);
    rm_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR", .op_code = 140);
    rm_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR_KW", .op_code = 142);
 
    // These are new since Python 3.6
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_ANNOTATION", .op_code = 127, .func = NAME_OP); // Index in name list
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_ASYNC_WITH", .op_code = 154);
    def_op(.op_obj = ret->opcodes, .op_name = "FORMAT_VALUE", .op_code = 155);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_CONST_KEY_MAP", .op_code = 156, .pop = -1, .push = 1); // TOS is count of kwargs
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_EX", .op_code = 142, .pop = -1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "SETUP_ANNOTATIONS", .op_code = 85);
    def_op(.op_obj = ret->opcodes, .op_name = "BUILD_STRING", .op_code = 157);
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_TUPLE_UNPACK_WITH_CALL", .op_code = 158);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "CALL_FUNCTION_KW", format_CALL_FUNCTION_KW_36);
    add_arg_fmt(ret, "CALL_FUNCTION_EX", format_CALL_FUNCTION_EX_36);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_36);
    add_arg_fmt(ret, "FORMAT_VALUE", format_value_flags_36);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg_36);
 
    return ret;
}

References add_arg_fmt(), def_op, format_CALL_FUNCTION_EX_36(), format_CALL_FUNCTION_KW_36(), format_extended_arg_36(), format_MAKE_FUNCTION_arg_36(), format_value_flags_36(), jrel_op, NAME_OP, nargs_op, NULL, pyc_opcode_object::op_name, opcode_35(), opcode_36(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), store_op00, varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_36(), and opcode_37().

opcode_37()

pyc_opcodes* opcode_37

(

void

)

Definition at line 6 of file opcode_37.c.

                             {
    pyc_opcodes *ret = opcode_36();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_37;
 
    // These are removed since 3.6...
    // and STORE_ANNOTATION introduced in 3.6!
    rm_op(.op_obj = ret->opcodes, .op_name = "STORE_ANNOTATION", .op_code = 127);
 
    // These are new since Python 3.7
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_METHOD", .op_code = 160);
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_METHOD", .op_code = 161);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "CALL_FUNCTION_KW", format_CALL_FUNCTION_KW_36);
    add_arg_fmt(ret, "CALL_FUNCTION_EX", format_CALL_FUNCTION_EX_36);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_36);
    add_arg_fmt(ret, "FORMAT_VALUE", format_value_flags_36);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg_36);
 
    return ret;
}

References add_arg_fmt(), format_CALL_FUNCTION_EX_36(), format_CALL_FUNCTION_KW_36(), format_extended_arg_36(), format_MAKE_FUNCTION_arg_36(), format_value_flags_36(), name_op, nargs_op, NULL, pyc_opcode_object::op_name, opcode_36(), opcode_37(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_37(), and opcode_38().

opcode_38()

pyc_opcodes* opcode_38

(

void

)

Definition at line 6 of file opcode_38.c.

                             {
    pyc_opcodes *ret = opcode_37();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_38;
 
    // These are removed since 3.7...
    rm_op(.op_obj = ret->opcodes, .op_name = "BREAK_LOOP", .op_code = 80);
    rm_op(.op_obj = ret->opcodes, .op_name = "CONTINUE_LOOP", .op_code = 119);
    rm_op(.op_obj = ret->opcodes, .op_name = "SETUP_LOOP", .op_code = 120);
    rm_op(.op_obj = ret->opcodes, .op_name = "SETUP_EXCEPT", .op_code = 121);
 
    // These are new since Python 3.7
 
    //          OP NAME            OPCODE POP PUSH
    // --------------------------------------------
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_FOUR", .op_code = 6, .pop = 4, .push = 4);
    def_op(.op_obj = ret->opcodes, .op_name = "BEGIN_FINALLY", .op_code = 53, .pop = 0, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "END_ASYNC_FOR", .op_code = 54, .pop = 7, .push = 0); // POP is 0, when not 7
    def_op(.op_obj = ret->opcodes, .op_name = "END_FINALLY", .op_code = 88, .pop = 1, .push = 0); // POP is 6, when not 1
    jrel_op(.op_obj = ret->opcodes, .op_name = "CALL_FINALLY", .op_code = 162, .pop = 0, .push = 1);
    nargs_op(.op_obj = ret->opcodes, .op_name = "POP_FINALLY", .op_code = 163, .pop = 0, .push = 0); // PUSH/POP vary
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "CALL_FUNCTION_KW", format_CALL_FUNCTION_KW_36);
    add_arg_fmt(ret, "CALL_FUNCTION_EX", format_CALL_FUNCTION_EX_36);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_36);
    add_arg_fmt(ret, "FORMAT_VALUE", format_value_flags_36);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg_36);
 
    return ret;
}

References add_arg_fmt(), def_op, format_CALL_FUNCTION_EX_36(), format_CALL_FUNCTION_KW_36(), format_extended_arg_36(), format_MAKE_FUNCTION_arg_36(), format_value_flags_36(), jrel_op, nargs_op, NULL, pyc_opcode_object::op_name, opcode_37(), opcode_38(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_38(), and opcode_39().

opcode_39()

pyc_opcodes* opcode_39

(

void

)

Definition at line 6 of file opcode_39.c.

                             {
    pyc_opcodes *ret = opcode_38();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_39;
 
    // These are removed since 3.8...
    rm_op(.op_obj = ret->opcodes, .op_name = "BEGIN_FINALLY", .op_code = 53);
    rm_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP_START", .op_code = 81);
    rm_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP_FINISH", .op_code = 82);
    rm_op(.op_obj = ret->opcodes, .op_name = "END_FINALLY", .op_code = 88);
    rm_op(.op_obj = ret->opcodes, .op_name = "CALL_FINALLY", .op_code = 162);
    rm_op(.op_obj = ret->opcodes, .op_name = "POP_FINALLY", .op_code = 163);
 
    // These are new since Python 3.9
    //          OP NAME              OPCODE  POP PUSH
    def_op(.op_obj = ret->opcodes, .op_name = "RERAISE", .op_code = 48, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "WITH_EXCEPT_START", .op_code = 49, .pop = 3, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "LOAD_ASSERTION_ERROR", .op_code = 74, .pop = 0, .push = 1);
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "CALL_FUNCTION_KW", format_CALL_FUNCTION_KW_36);
    add_arg_fmt(ret, "CALL_FUNCTION_EX", format_CALL_FUNCTION_EX_36);
    add_arg_fmt(ret, "MAKE_FUNCTION", format_MAKE_FUNCTION_arg_36);
    add_arg_fmt(ret, "FORMAT_VALUE", format_value_flags_36);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg_36);
 
    return ret;
}

References add_arg_fmt(), def_op, format_CALL_FUNCTION_EX_36(), format_CALL_FUNCTION_KW_36(), format_extended_arg_36(), format_MAKE_FUNCTION_arg_36(), format_value_flags_36(), NULL, pyc_opcode_object::op_name, opcode_38(), opcode_39(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rm_op, rz_list_purge(), and pyc_opcodes::version_sig.

Referenced by opcode_39().

opcode_3x()

pyc_opcodes* opcode_3x

(

void

)

Definition at line 6 of file opcode_3x.c.

                             {
    pyc_opcodes *ret = new_pyc_opcodes();
    if (!ret) {
        return NULL;
    }
 
    ret->version_sig = (void *(*)())opcode_3x;
 
    def_op00(.op_obj = ret->opcodes, .op_name = "STOP_CODE", .op_code = 0, .pop = 0, .push = 0, .fallthrough = false);
    def_op(.op_obj = ret->opcodes, .op_name = "POP_TOP", .op_code = 1, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_TWO", .op_code = 2, .pop = 2, .push = 2);
    def_op(.op_obj = ret->opcodes, .op_name = "ROT_THREE", .op_code = 3, .pop = 3, .push = 3);
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOP", .op_code = 4, .pop = 0, .push = 1);
 
    // Python 3.2+
    def_op(.op_obj = ret->opcodes, .op_name = "DUP_TOP_TWO", .op_code = 5, .pop = 0, .push = 2);
 
    def_op(.op_obj = ret->opcodes, .op_name = "NOP", 9);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_POSITIVE", .op_code = 10, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NEGATIVE", .op_code = 11, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_NOT", .op_code = 12, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNARY_INVERT", .op_code = 15, .pop = 1, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_POWER", .op_code = 19, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MULTIPLY", .op_code = 20, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_MODULO", .op_code = 22, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_ADD", .op_code = 23, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBTRACT", .op_code = 24, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_SUBSCR", .op_code = 25, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_FLOOR_DIVIDE", .op_code = 26, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_TRUE_DIVIDE", .op_code = 27, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_FLOOR_DIVIDE", .op_code = 28, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_TRUE_DIVIDE", .op_code = 29, .pop = 2, .push = 1);
 
    // Gone from Python 3 are Python2's
    // SLICE+0 .. SLICE+3
    // STORE_SLICE+0 .. STORE_SLICE+3
    // DELETE_SLICE+0 .. DELETE_SLICE+3
 
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_MAP", .op_code = 54, .pop = 3, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_ADD", .op_code = 55, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_SUBTRACT", .op_code = 56, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_MULTIPLY", .op_code = 57, .pop = 2, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_MODULO", .op_code = 59, .pop = 2, .push = 1);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_SUBSCR", .op_code = 60, .pop = 3, .push = 0); // Implements TOS1[TOS] = TOS2.
    def_op(.op_obj = ret->opcodes, .op_name = "DELETE_SUBSCR", .op_code = 61, .pop = 2, .push = 0); // Implements del TOS1[TOS].
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_LSHIFT", .op_code = 62, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_RSHIFT", .op_code = 63, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_AND", .op_code = 64, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_XOR", .op_code = 65, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BINARY_OR", .op_code = 66, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_POWER", .op_code = 67, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "GET_ITER", .op_code = 68, .pop = 1, .push = 1);
    store_op(.op_obj = ret->opcodes, .op_name = "STORE_LOCALS", .op_code = 69, .pop = 1, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "PRINT_EXPR", .op_code = 70, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "LOAD_BUILD_CLASS", .op_code = 71, .pop = 0, .push = 1);
 
    // Python3 drops/changes:
    //  def_op(.op_obj = ret->opcodes, .op_name = "PRINT_ITEM", 71)
    //  def_op(.op_obj = ret->opcodes, .op_name = "PRINT_NEWLINE", 72)
    //  def_op(.op_obj = ret->opcodes, .op_name = "PRINT_ITEM_TO", 73)
    //  def_op(.op_obj = ret->opcodes, .op_name = "PRINT_NEWLINE_TO", 74)
 
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_LSHIFT", .op_code = 75, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_RSHIFT", .op_code = 76, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_AND", .op_code = 77, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_XOR", .op_code = 78, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "INPLACE_OR", .op_code = 79, .pop = 2, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "BREAK_LOOP", .op_code = 80, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "WITH_CLEANUP", .op_code = 81, .pop = 1, .push = 0); // Cleans up the stack when a with statement
                                                       // block exits.  Handle stack special
 
    def_op00(.op_obj = ret->opcodes, .op_name = "RETURN_VALUE", .op_code = 83, .pop = 1, .push = 0, .fallthrough = false);
    def_op(.op_obj = ret->opcodes, .op_name = "IMPORT_STAR", .op_code = 84, .pop = 1, .push = 0);
 
    def_op(.op_obj = ret->opcodes, .op_name = "YIELD_VALUE", .op_code = 86, .pop = 1, .push = 1);
    def_op(.op_obj = ret->opcodes, .op_name = "POP_BLOCK", .op_code = 87, .pop = 0, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "END_FINALLY", .op_code = 88, .pop = 1, .push = 0);
    def_op(.op_obj = ret->opcodes, .op_name = "POP_EXCEPT", .op_code = 89, .pop = 1, .push = -1);
 
    ret->have_argument = 90; // Opcodes from here have an argument:
 
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_NAME", .op_code = 90, .pop = 1, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_NAME", .op_code = 91, .pop = 0, .push = 0); // ""
    varargs_op(.op_obj = ret->opcodes, .op_name = "UNPACK_SEQUENCE", .op_code = 92, .pop = 9, .push = 1); // TOS is number of tuple items
    jrel_op(.op_obj = ret->opcodes, .op_name = "FOR_ITER", .op_code = 93, .pop = 9, .push = 1);
 
    def_op(.op_obj = ret->opcodes, .op_name = "UNPACK_EX", .op_code = 94, .pop = 9, .push = 1); // assignment with a starred target; TOS is #entries
                                                    // argument has a count
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_ATTR", .op_code = 95, .pop = 2, .push = 0, .func = NAME_OP); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_ATTR", .op_code = 96, .pop = 1, .push = 0); // ""
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_GLOBAL", .op_code = 97, .pop = 1, .push = 0, .func = NAME_OP); // ""
    name_op(.op_obj = ret->opcodes, .op_name = "DELETE_GLOBAL", .op_code = 98, .pop = 0, .push = 0); // ""
 
    // Python 2's DUP_TOPX is gone starting in Python 3.2
 
    const_op00(.op_obj = ret->opcodes, .op_name = "LOAD_CONST", .op_code = 100, .pop = 0, .push = 1); // Operand is in const list
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_NAME", .op_code = 101, .pop = 0, .push = 1); // Operand is in name list
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_TUPLE", .op_code = 102, .pop = 9, .push = 1); // TOS is count of tuple items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_LIST", .op_code = 103, .pop = 9, .push = 1); // TOS is count of list items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_SET", .op_code = 104, .pop = 9, .push = 1); // TOS is count of set items
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_MAP", .op_code = 105, .pop = 0, .push = 1); // TOS is count of kwarg items
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_ATTR", .op_code = 106, .pop = 1, .push = 1); // Operand is in name list
    compare_op(.op_obj = ret->opcodes, .op_name = "COMPARE_OP", .op_code = 107, .pop = 2, .push = 1); // Comparison operator
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_NAME", .op_code = 108, .pop = 1, .push = 1); // Operand is in name list
    name_op(.op_obj = ret->opcodes, .op_name = "IMPORT_FROM", .op_code = 109, .pop = 0, .push = 1); // Operand is in name list
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "JUMP_FORWARD", .op_code = 110, .pop = 0, .push = 0); // Number of bytes to skip
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_FALSE_OR_POP", .op_code = 111, .conditional = true); // Target byte offset from beginning of code
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_IF_TRUE_OR_POP", .op_code = 112, .conditional = true); // ""
    jabs_op(.op_obj = ret->opcodes, .op_name = "JUMP_ABSOLUTE", .op_code = 113, .pop = 0, .push = 0); // Target byte offset from beginning of code
    jabs_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_FALSE", .op_code = 114, .pop = 9, .push = 1, .conditional = true); // ""
    jabs_op(.op_obj = ret->opcodes, .op_name = "POP_JUMP_IF_TRUE", .op_code = 115, .pop = 9, .push = 1, .conditional = true); // ""
 
    name_op(.op_obj = ret->opcodes, .op_name = "LOAD_GLOBAL", .op_code = 116, .pop = 0, .push = 1); // Operand is in name list
 
    jabs_op(.op_obj = ret->opcodes, .op_name = "CONTINUE_LOOP", .op_code = 119, .pop = 0, .push = 0); // Target address
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_LOOP", .op_code = 120, .pop = 0, .push = 0, .conditional = true); // Distance to target address
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_EXCEPT", .op_code = 121, .pop = 0, .push = 6, .conditional = true); // ""
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_FINALLY", .op_code = 122, .pop = 0, .push = 6, .conditional = true); // ""
 
    local_op(.op_obj = ret->opcodes, .op_name = "LOAD_FAST", .op_code = 124, .pop = 0, .push = 1); // Local variable number
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_FAST", .op_code = 125, .pop = 1, .push = 0, .func = LOCAL_OP); // Local variable number
    local_op(.op_obj = ret->opcodes, .op_name = "DELETE_FAST", .op_code = 126, .pop = 0, .push = 0); // Local variable number
 
    def_op00(.op_obj = ret->opcodes, .op_name = "RAISE_VARARGS", .op_code = 130, .pop = 9, .push = 1, .fallthrough = false);
    // Number of raise arguments (1, 2, or 3)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION", .op_code = 131, .pop = 9, .push = 1); // #args + (#kwargs << 8)
 
    def_op(.op_obj = ret->opcodes, .op_name = "MAKE_FUNCTION", .op_code = 132, .pop = 9, .push = 1); // TOS is number of args if < 3.6
    varargs_op(.op_obj = ret->opcodes, .op_name = "BUILD_SLICE", .op_code = 133, .pop = 9, .push = 1); // TOS is number of items to pop
 
    def_op(.op_obj = ret->opcodes, .op_name = "MAKE_CLOSURE", .op_code = 134, .pop = 9, .push = 1); // TOS is number of items to pop
    free_op(.op_obj = ret->opcodes, .op_name = "LOAD_CLOSURE", .op_code = 135, .pop = 0, .push = 1);
    free_op(.op_obj = ret->opcodes, .op_name = "LOAD_DEREF", .op_code = 136, .pop = 0, .push = 1);
    store_op00(.op_obj = ret->opcodes, .op_name = "STORE_DEREF", .op_code = 137, .pop = 1, .push = 0, .func = FREE_OP);
    free_op(.op_obj = ret->opcodes, .op_name = "DELETE_DEREF", .op_code = 138, .pop = 0, .push = 0);
 
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR", .op_code = 140, .pop = 9, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_KW", .op_code = 141, .pop = 9, .push = 1); // #args + (#kwargs << 8)
    nargs_op(.op_obj = ret->opcodes, .op_name = "CALL_FUNCTION_VAR_KW", .op_code = 142, .pop = 9, .push = 1); // #args + (#kwargs << 8)
 
    jrel_op(.op_obj = ret->opcodes, .op_name = "SETUP_WITH", .op_code = 143, .pop = 0, .push = 7);
 
    def_op(.op_obj = ret->opcodes, .op_name = "LIST_APPEND", .op_code = 145, .pop = 2, .push = 1); // Calls list.append(TOS[-i], TOS).
                                                       // Used to implement list comprehensions.
    def_op(.op_obj = ret->opcodes, .op_name = "SET_ADD", .op_code = 146, .pop = 1, .push = 0); // Calls set.add(TOS1[-i], TOS).
                                                   // Used to implement set comprehensions.
    def_op(.op_obj = ret->opcodes, .op_name = "MAP_ADD", .op_code = 147, .pop = 2, .push = 1); // Calls dict.setitem(TOS1[-i], TOS, TOS1)
                                                   // Used to implement dict comprehensions.
 
    def_op(.op_obj = ret->opcodes, .op_name = "EXTENDED_ARG", .op_code = 144);
    ret->extended_arg = 144;
 
    rz_list_purge(ret->opcode_arg_fmt);
    add_arg_fmt(ret, "EXTENDED_ARG", format_extended_arg);
 
    return ret;
}

References add_arg_fmt(), compare_op, const_op00, def_op, def_op00, pyc_opcodes::extended_arg, format_extended_arg(), FREE_OP, free_op, pyc_opcodes::have_argument, jabs_op, jrel_op, LOCAL_OP, local_op, NAME_OP, name_op, nargs_op, new_pyc_opcodes(), NULL, pyc_opcode_object::op_name, opcode_3x(), pyc_opcodes::opcode_arg_fmt, pyc_opcodes::opcodes, rz_list_purge(), store_op, store_op00, varargs_op, and pyc_opcodes::version_sig.

Referenced by opcode_32(), opcode_33(), and opcode_3x().

pyc_opcodes_equal()

bool pyc_opcodes_equal	(	pyc_opcodes *	op,
		const char *	version
	)

Definition at line 151 of file opcode.c.

                                                             {
    if (version == NULL || op == NULL) {
        return false;
    }
    version_opcode *vop = version_op;
 
    while (vop->version) {
        if (!strcmp(vop->version, version)) {
            if (vop->opcode_func == (pyc_opcodes * (*)())(op->version_sig)) {
                return true;
            }
        }
        vop++;
    }
 
    return false;
}

References NULL, version_opcode::opcode_func, version_opcode::version, and version_op.

Referenced by disassemble(), and pyc_op().

rm_op()

void() rm_op

(

struct op_parameter

par

)

Definition at line 327 of file opcode.c.

                                     {
    pyc_opcode_object *op_obj = &par.op_obj[par.op_code];
    if (op_obj->op_code == par.op_code && !strcmp(op_obj->op_name, par.op_name)) {
        free(op_obj->op_name);
        op_obj->op_name = rz_str_newf("<%u>", par.op_code);
        op_obj->type = op_obj->op_pop = op_obj->op_push = 0;
    } else {
        RZ_LOG_ERROR("Error in rm_op() while constructing opcodes for .pyc file: \n .op_code = %u, .op_name = %s", par.op_code, par.op_name);
    }
}

References free(), pyc_opcode_object::op_code, pyc_opcode_object::op_name, op_parameter::op_obj, pyc_opcode_object::op_pop, pyc_opcode_object::op_push, RZ_LOG_ERROR, rz_str_newf(), and pyc_opcode_object::type.

store_opN()

void() store_opN

(

struct op_parameter

par

)

Definition at line 270 of file opcode.c.

                                         {
    switch (par.func) {
    case NAME_OP:
        name_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
        break;
    case LOCAL_OP:
        local_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
        break;
    case FREE_OP:
        free_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
        break;
    case DEF_OP:
        def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
        break;
    default:
        RZ_LOG_ERROR("Error in store_op in pyc/opcode.c, call function %u.\n", par.func);
        return;
    }
    par.op_obj[par.op_code].type |= HASSTORE;
}

References DEF_OP, def_op, FREE_OP, free_op, HASSTORE, LOCAL_OP, local_op, NAME_OP, name_op, pyc_opcode_object::op_name, op_parameter::op_obj, and RZ_LOG_ERROR.

varargs_op()

void() varargs_op

(

struct op_parameter

par

)

Definition at line 291 of file opcode.c.

                                          {
    def_op(.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
    par.op_obj[par.op_code].type |= HASVARGS;
}

References def_op, HASVARGS, pyc_opcode_object::op_name, and op_parameter::op_obj.