#include <stdbool.h>

#define NEED_OPCODE_TABLES

#include "Python.h"

#include "pycore_ast.h" // _PyAST_GetDocString()

#include "pycore_code.h" // _PyCode_New()

#include "pycore_compile.h" // _PyFuture_FromAST()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_opcode.h" // _PyOpcode_Caches

#include "pycore_pymem.h" // _PyMem_IsPtrFreed()

#include "pycore_symtable.h" // PySTEntryObject

#define DEFAULT_BLOCK_SIZE 16

#define DEFAULT_CODE_SIZE 128

#define DEFAULT_LNOTAB_SIZE 16

#define DEFAULT_CNOTAB_SIZE 32

#define COMP_GENEXP 0

#define COMP_LISTCOMP 1

#define COMP_SETCOMP 2

#define COMP_DICTCOMP 3

#define STACK_USE_GUIDELINE 30

#define MAX_ALLOWED_STACK_USE (STACK_USE_GUIDELINE * 100)

#define MAX_REAL_OPCODE 254

#define IS_WITHIN_OPCODE_RANGE(opcode) \

(((opcode) >= 0 && (opcode) <= MAX_REAL_OPCODE) || \

IS_PSEUDO_OPCODE(opcode))

#define IS_JUMP_OPCODE(opcode) \

is_bit_set_in_table(_PyOpcode_Jump, opcode)

#define IS_BLOCK_PUSH_OPCODE(opcode) \

((opcode) == SETUP_FINALLY || \

(opcode) == SETUP_WITH || \

(opcode) == SETUP_CLEANUP)

#define HAS_TARGET(opcode) \

(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode))

#define IS_TERMINATOR_OPCODE(opcode) \

(IS_JUMP_OPCODE(opcode) || IS_SCOPE_EXIT_OPCODE(opcode))

#define IS_ASSEMBLER_OPCODE(opcode) \

((opcode) == JUMP_FORWARD || \

(opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_BACKWARDS_JUMP_OPCODE(opcode) \

((opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_UNCONDITIONAL_JUMP_OPCODE(opcode) \

((opcode) == JUMP || \

(opcode) == JUMP_NO_INTERRUPT || \

(opcode) == JUMP_FORWARD || \

(opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_SCOPE_EXIT_OPCODE(opcode) \

((opcode) == RETURN_VALUE || \

(opcode) == RAISE_VARARGS || \

(opcode) == RERAISE)

#define IS_SUPERINSTRUCTION_OPCODE(opcode) \

((opcode) == LOAD_FAST__LOAD_FAST || \

(opcode) == LOAD_FAST__LOAD_CONST || \

(opcode) == LOAD_CONST__LOAD_FAST || \

(opcode) == STORE_FAST__LOAD_FAST || \

(opcode) == STORE_FAST__STORE_FAST)

#define IS_TOP_LEVEL_AWAIT(c) ( \

(c->c_flags->cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \

&& (c->u->u_ste->ste_type == ModuleBlock))

typedef _PyCompilerSrcLocation location;

#define LOCATION(LNO, END_LNO, COL, END_COL) \

((const location){(LNO), (END_LNO), (COL), (END_COL)})

static location NO_LOCATION = {-1, -1, -1, -1};

static inline bool

location_is_after(location loc1, location loc2) {

return (loc1.lineno > loc2.end_lineno) ||

((loc1.lineno == loc2.end_lineno) &&

(loc1.col_offset > loc2.end_col_offset));

}

#define LOC(x) SRC_LOCATION_FROM_AST(x)

typedef struct jump_target_label_ {

int id;

} jump_target_label;

static struct jump_target_label_ NO_LABEL = {-1};

#define SAME_LABEL(L1, L2) ((L1).id == (L2).id)

#define IS_LABEL(L) (!SAME_LABEL((L), (NO_LABEL)))

#define NEW_JUMP_TARGET_LABEL(C, NAME) \

jump_target_label NAME = cfg_new_label(CFG_BUILDER(C)); \

if (!IS_LABEL(NAME)) { \

return 0; \

}

#define USE_LABEL(C, LBL) \

if (cfg_builder_use_label(CFG_BUILDER(C), LBL) < 0) { \

return 0; \

}

struct instr {

};

typedef struct exceptstack {

struct basicblock_ *handlers[CO_MAXBLOCKS+1];

int depth;

} ExceptStack;

#define LOG_BITS_PER_INT 5

#define MASK_LOW_LOG_BITS 31

static inline int

is_bit_set_in_table(const uint32_t *table, int bitindex) {

/* Is the relevant bit set in the relevant word? */

/* 512 bits fit into 9 32-bits words.

if (bitindex >= 0 && bitindex < 512) {

uint32_t word = table[bitindex >> LOG_BITS_PER_INT];

return (word >> (bitindex & MASK_LOW_LOG_BITS)) & 1;

}

else {

return 0;

}

}

static inline int

is_relative_jump(struct instr *i)

{

return is_bit_set_in_table(_PyOpcode_RelativeJump, i->i_opcode);

}

static inline int

is_block_push(struct instr *i)

{

return IS_BLOCK_PUSH_OPCODE(i->i_opcode);

}

static inline int

is_jump(struct instr *i)

{

return IS_JUMP_OPCODE(i->i_opcode);

}

static int

instr_size(struct instr *instruction)

{

int opcode = instruction->i_opcode;

assert(!IS_PSEUDO_OPCODE(opcode));

int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;

int extended_args = (0xFFFFFF < oparg) + (0xFFFF < oparg) + (0xFF < oparg);

int caches = _PyOpcode_Caches[opcode];

return extended_args + 1 + caches;

}

static void

write_instr(_Py_CODEUNIT *codestr, struct instr *instruction, int ilen)

{

int opcode = instruction->i_opcode;

assert(!IS_PSEUDO_OPCODE(opcode));

int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;

int caches = _PyOpcode_Caches[opcode];

switch (ilen - caches) {

case 4:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 24) & 0xFF);

/* fall through */

case 3:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 16) & 0xFF);

/* fall through */

case 2:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 8) & 0xFF);

/* fall through */

case 1:

*codestr++ = _Py_MAKECODEUNIT(opcode, oparg & 0xFF);

break;

default:

Py_UNREACHABLE();

}

while (caches--) {

*codestr++ = _Py_MAKECODEUNIT(CACHE, 0);

}

}

typedef struct basicblock_ {

} basicblock;

static struct instr *

basicblock_last_instr(const basicblock *b) {

assert(b->b_iused >= 0);

if (b->b_iused > 0) {

assert(b->b_instr != NULL);

return &b->b_instr[b->b_iused - 1];

}

return NULL;

}

static inline int

basicblock_returns(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

return last && last->i_opcode == RETURN_VALUE;

}

static inline int

basicblock_exits_scope(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

return last && IS_SCOPE_EXIT_OPCODE(last->i_opcode);

}

static inline int

basicblock_nofallthrough(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

return (last &&

(IS_SCOPE_EXIT_OPCODE(last->i_opcode) ||

IS_UNCONDITIONAL_JUMP_OPCODE(last->i_opcode)));

}

#define BB_NO_FALLTHROUGH(B) (basicblock_nofallthrough(B))

#define BB_HAS_FALLTHROUGH(B) (!basicblock_nofallthrough(B))

enum fblocktype { WHILE_LOOP, FOR_LOOP, TRY_EXCEPT, FINALLY_TRY, FINALLY_END,

WITH, ASYNC_WITH, HANDLER_CLEANUP, POP_VALUE, EXCEPTION_HANDLER,

EXCEPTION_GROUP_HANDLER, ASYNC_COMPREHENSION_GENERATOR };

struct fblockinfo {

};

enum {

COMPILER_SCOPE_MODULE,

COMPILER_SCOPE_CLASS,

COMPILER_SCOPE_FUNCTION,

COMPILER_SCOPE_ASYNC_FUNCTION,

COMPILER_SCOPE_LAMBDA,

COMPILER_SCOPE_COMPREHENSION,

};

typedef struct cfg_builder_ {

} cfg_builder;

struct compiler_unit {

};

struct compiler {

};

#define CFG_BUILDER(c) (&((c)->u->u_cfg_builder))

typedef struct {

// A list of strings corresponding to name captures. It is used to track:

// - Repeated name assignments in the same pattern.

// - Different name assignments in alternatives.

// - The order of name assignments in alternatives.

PyObject *stores;

// If 0, any name captures against our subject will raise.

int allow_irrefutable;

// An array of blocks to jump to on failure. Jumping to fail_pop[i] will pop

// i items off of the stack. The end result looks like this (with each block

// falling through to the next):

// fail_pop[4]: POP_TOP

// fail_pop[3]: POP_TOP

// fail_pop[2]: POP_TOP

// fail_pop[1]: POP_TOP

// fail_pop[0]: NOP

jump_target_label *fail_pop;

// The current length of fail_pop.

Py_ssize_t fail_pop_size;

// The number of items on top of the stack that need to *stay* on top of the

// stack. Variable captures go beneath these. All of them will be popped on

// failure.

Py_ssize_t on_top;

} pattern_context;

static int basicblock_next_instr(basicblock *);

static basicblock *cfg_builder_new_block(cfg_builder *g);

static int cfg_builder_maybe_start_new_block(cfg_builder *g);

static int cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, location loc);

static void compiler_free(struct compiler *);

static int compiler_error(struct compiler *, location loc, const char *, ...);

static int compiler_warn(struct compiler *, location loc, const char *, ...);

static int compiler_nameop(struct compiler *, location, identifier, expr_context_ty);

static PyCodeObject *compiler_mod(struct compiler *, mod_ty);

static int compiler_visit_stmt(struct compiler *, stmt_ty);

static int compiler_visit_keyword(struct compiler *, keyword_ty);

static int compiler_visit_expr(struct compiler *, expr_ty);

static int compiler_augassign(struct compiler *, stmt_ty);

static int compiler_annassign(struct compiler *, stmt_ty);

static int compiler_subscript(struct compiler *, expr_ty);

static int compiler_slice(struct compiler *, expr_ty);

static int are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t);

static int compiler_with(struct compiler *, stmt_ty, int);

static int compiler_async_with(struct compiler *, stmt_ty, int);

static int compiler_async_for(struct compiler *, stmt_ty);

static int compiler_call_simple_kw_helper(struct compiler *c,

location loc,

asdl_keyword_seq *keywords,

Py_ssize_t nkwelts);

static int compiler_call_helper(struct compiler *c, location loc,

int n, asdl_expr_seq *args,

asdl_keyword_seq *keywords);

static int compiler_try_except(struct compiler *, stmt_ty);

static int compiler_try_star_except(struct compiler *, stmt_ty);

static int compiler_set_qualname(struct compiler *);

static int compiler_sync_comprehension_generator(

expr_ty elt, expr_ty val, int type);

static int compiler_async_comprehension_generator(

expr_ty elt, expr_ty val, int type);

static int compiler_pattern(struct compiler *, location *,

pattern_ty, pattern_context *);

static int compiler_match(struct compiler *, stmt_ty);

static int compiler_pattern_subpattern(struct compiler *, location *,

pattern_ty, pattern_context *);

static void remove_redundant_nops(basicblock *bb);

static PyCodeObject *assemble(struct compiler *, int addNone);

#define CAPSULE_NAME "compile.c compiler unit"

PyObject *

_Py_Mangle(PyObject *privateobj, PyObject *ident)

{

/* Name mangling: __private becomes _classname__private.

PyObject *result;

size_t nlen, plen, ipriv;

Py_UCS4 maxchar;

if (privateobj == NULL || !PyUnicode_Check(privateobj) ||

PyUnicode_READ_CHAR(ident, 0) != '_' ||

PyUnicode_READ_CHAR(ident, 1) != '_') {

Py_INCREF(ident);

return ident;

}

nlen = PyUnicode_GET_LENGTH(ident);

plen = PyUnicode_GET_LENGTH(privateobj);

/* Don't mangle __id__ or names with dots.

if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&

PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||

PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {

Py_INCREF(ident);

return ident; /* Don't mangle __whatever__ */

}

/* Strip leading underscores from class name */

ipriv = 0;

while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')

ipriv++;

if (ipriv == plen) {

Py_INCREF(ident);

return ident; /* Don't mangle if class is just underscores */

}

plen -= ipriv;

if (plen + nlen >= PY_SSIZE_T_MAX - 1) {

PyErr_SetString(PyExc_OverflowError,

"private identifier too large to be mangled");

return NULL;

}

maxchar = PyUnicode_MAX_CHAR_VALUE(ident);

if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar)

maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);

result = PyUnicode_New(1 + nlen + plen, maxchar);

if (!result)

return 0;

/* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */

PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');

if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {

Py_DECREF(result);

return NULL;

}

if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {

Py_DECREF(result);

return NULL;

}

assert(_PyUnicode_CheckConsistency(result, 1));

return result;

}

static int

compiler_init(struct compiler *c)

{

memset(c, 0, sizeof(struct compiler));

c->c_const_cache = PyDict_New();

if (!c->c_const_cache) {

return 0;

}

c->c_stack = PyList_New(0);

if (!c->c_stack) {

Py_CLEAR(c->c_const_cache);

return 0;

}

return 1;

}

PyCodeObject *

_PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *flags,

int optimize, PyArena *arena)

{

struct compiler c;

PyCodeObject *co = NULL;

PyCompilerFlags local_flags = _PyCompilerFlags_INIT;

int merged;

if (!compiler_init(&c))

return NULL;

Py_INCREF(filename);

c.c_filename = filename;

c.c_arena = arena;

if (!_PyFuture_FromAST(mod, filename, &c.c_future)) {

goto finally;

}

if (!flags) {

flags = &local_flags;

}

merged = c.c_future.ff_features | flags->cf_flags;

c.c_future.ff_features = merged;

flags->cf_flags = merged;

c.c_flags = flags;

c.c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;

c.c_nestlevel = 0;

_PyASTOptimizeState state;

state.optimize = c.c_optimize;

state.ff_features = merged;

if (!_PyAST_Optimize(mod, arena, &state)) {

goto finally;

}

c.c_st = _PySymtable_Build(mod, filename, &c.c_future);

if (c.c_st == NULL) {

if (!PyErr_Occurred())

PyErr_SetString(PyExc_SystemError, "no symtable");

goto finally;

}

co = compiler_mod(&c, mod);

finally:

compiler_free(&c);

assert(co || PyErr_Occurred());

return co;

}

static void

compiler_free(struct compiler *c)

{

if (c->c_st)

_PySymtable_Free(c->c_st);

Py_XDECREF(c->c_filename);

Py_DECREF(c->c_const_cache);

Py_DECREF(c->c_stack);

}

static PyObject *

list2dict(PyObject *list)

{

Py_ssize_t i, n;

PyObject *v, *k;

PyObject *dict = PyDict_New();

if (!dict) return NULL;

n = PyList_Size(list);

for (i = 0; i < n; i++) {

v = PyLong_FromSsize_t(i);

if (!v) {

Py_DECREF(dict);

return NULL;

}

k = PyList_GET_ITEM(list, i);

if (PyDict_SetItem(dict, k, v) < 0) {

Py_DECREF(v);

Py_DECREF(dict);

return NULL;

}

Py_DECREF(v);

}

return dict;

}

static PyObject *

dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)

{

Py_ssize_t i = offset, scope, num_keys, key_i;

PyObject *k, *v, *dest = PyDict_New();

PyObject *sorted_keys;

assert(offset >= 0);

if (dest == NULL)

return NULL;

/* Sort the keys so that we have a deterministic order on the indexes

sorted_keys = PyDict_Keys(src);

if (sorted_keys == NULL)

return NULL;

if (PyList_Sort(sorted_keys) != 0) {

Py_DECREF(sorted_keys);

return NULL;

}

num_keys = PyList_GET_SIZE(sorted_keys);

for (key_i = 0; key_i < num_keys; key_i++) {

/* XXX this should probably be a macro in symtable.h */

long vi;

k = PyList_GET_ITEM(sorted_keys, key_i);

v = PyDict_GetItemWithError(src, k);

assert(v && PyLong_Check(v));

vi = PyLong_AS_LONG(v);

scope = (vi >> SCOPE_OFFSET) & SCOPE_MASK;

if (scope == scope_type || vi & flag) {

PyObject *item = PyLong_FromSsize_t(i);

if (item == NULL) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

i++;

if (PyDict_SetItem(dest, k, item) < 0) {

Py_DECREF(sorted_keys);

Py_DECREF(item);

Py_DECREF(dest);

return NULL;

}

Py_DECREF(item);

}

}

Py_DECREF(sorted_keys);

return dest;

}

static void

cfg_builder_check(cfg_builder *g)

{

for (basicblock *block = g->g_block_list; block != NULL; block = block->b_list) {

assert(!_PyMem_IsPtrFreed(block));

if (block->b_instr != NULL) {

assert(block->b_ialloc > 0);

assert(block->b_iused >= 0);

assert(block->b_ialloc >= block->b_iused);

}

else {

assert (block->b_iused == 0);

assert (block->b_ialloc == 0);

}

}

}

static int

cfg_builder_init(cfg_builder *g)

{

g->g_block_list = NULL;

basicblock *block = cfg_builder_new_block(g);

if (block == NULL)

return 0;

g->g_curblock = g->g_entryblock = block;

g->g_current_label = NO_LABEL;

return 1;

}

static void

cfg_builder_fini(cfg_builder* g)

{

cfg_builder_check(g);

basicblock *b = g->g_block_list;

while (b != NULL) {

if (b->b_instr) {

PyObject_Free((void *)b->b_instr);

}

basicblock *next = b->b_list;

PyObject_Free((void *)b);

b = next;

}

}

static void

compiler_unit_free(struct compiler_unit *u)

{

cfg_builder_fini(&u->u_cfg_builder);

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_name);

Py_CLEAR(u->u_qualname);

Py_CLEAR(u->u_consts);

Py_CLEAR(u->u_names);

Py_CLEAR(u->u_varnames);

Py_CLEAR(u->u_freevars);

Py_CLEAR(u->u_cellvars);

Py_CLEAR(u->u_private);

PyObject_Free(u);

}

static int

compiler_set_qualname(struct compiler *c)

{

Py_ssize_t stack_size;

struct compiler_unit *u = c->u;

PyObject *name, *base;

base = NULL;

stack_size = PyList_GET_SIZE(c->c_stack);

assert(stack_size >= 1);

if (stack_size > 1) {

int scope, force_global = 0;

struct compiler_unit *parent;

PyObject *mangled, *capsule;

capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1);

parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(parent);

if (u->u_scope_type == COMPILER_SCOPE_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_CLASS) {

assert(u->u_name);

mangled = _Py_Mangle(parent->u_private, u->u_name);

if (!mangled)

return 0;

scope = _PyST_GetScope(parent->u_ste, mangled);

Py_DECREF(mangled);

assert(scope != GLOBAL_IMPLICIT);

if (scope == GLOBAL_EXPLICIT)

force_global = 1;

}

if (!force_global) {

if (parent->u_scope_type == COMPILER_SCOPE_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_LAMBDA)

{

_Py_DECLARE_STR(dot_locals, ".<locals>");

base = PyUnicode_Concat(parent->u_qualname,

&_Py_STR(dot_locals));

if (base == NULL)

return 0;

}

else {

Py_INCREF(parent->u_qualname);

base = parent->u_qualname;

}

}

}

if (base != NULL) {

_Py_DECLARE_STR(dot, ".");

name = PyUnicode_Concat(base, &_Py_STR(dot));

Py_DECREF(base);

if (name == NULL)

return 0;

PyUnicode_Append(&name, u->u_name);

if (name == NULL)

return 0;

}

else {

Py_INCREF(u->u_name);

name = u->u_name;

}

u->u_qualname = name;

return 1;

}

static jump_target_label

cfg_new_label(cfg_builder *g)

{

jump_target_label lbl = {g->g_next_free_label++};

return lbl;

}

static basicblock *

cfg_builder_new_block(cfg_builder *g)

{

basicblock *b = (basicblock *)PyObject_Calloc(1, sizeof(basicblock));

if (b == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Extend the singly linked list of blocks with new block. */

b->b_list = g->g_block_list;

g->g_block_list = b;

b->b_label = -1;

return b;

}

static basicblock *

cfg_builder_use_next_block(cfg_builder *g, basicblock *block)

{

assert(block != NULL);

g->g_curblock->b_next = block;

g->g_curblock = block;

return block;

}

static int

cfg_builder_use_label(cfg_builder *g, jump_target_label lbl)

{

g->g_current_label = lbl;

return cfg_builder_maybe_start_new_block(g);

}

static inline int

basicblock_append_instructions(basicblock *target, basicblock *source)

{

for (int i = 0; i < source->b_iused; i++) {

int n = basicblock_next_instr(target);

if (n < 0) {

return -1;

}

target->b_instr[n] = source->b_instr[i];

}

return 0;

}

static basicblock *

copy_basicblock(cfg_builder *g, basicblock *block)

{

/* Cannot copy a block if it has a fallthrough, since

assert(BB_NO_FALLTHROUGH(block));

basicblock *result = cfg_builder_new_block(g);

if (result == NULL) {

return NULL;

}

if (basicblock_append_instructions(result, block) < 0) {

return NULL;

}

return result;

}

static int

basicblock_next_instr(basicblock *b)

{

assert(b != NULL);

if (b->b_instr == NULL) {

b->b_instr = (struct instr *)PyObject_Calloc(

DEFAULT_BLOCK_SIZE, sizeof(struct instr));

if (b->b_instr == NULL) {

PyErr_NoMemory();

return -1;

}

b->b_ialloc = DEFAULT_BLOCK_SIZE;

}

else if (b->b_iused == b->b_ialloc) {

struct instr *tmp;

size_t oldsize, newsize;

oldsize = b->b_ialloc * sizeof(struct instr);

newsize = oldsize << 1;

if (oldsize > (SIZE_MAX >> 1)) {

PyErr_NoMemory();

return -1;

}

if (newsize == 0) {

PyErr_NoMemory();

return -1;

}

b->b_ialloc <<= 1;

tmp = (struct instr *)PyObject_Realloc(

(void *)b->b_instr, newsize);

if (tmp == NULL) {

PyErr_NoMemory();

return -1;

}

b->b_instr = tmp;

memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);

}