#include "Python.h"

#include "node.h"

#include "token.h"

#include "graminit.h"

#include "compile.h"

#include "symtable.h"

#include "opcode.h"

#include "structmember.h"

#include <ctype.h>

#if Py_single_input != single_input

#error "single_input has changed -- update Py_single_input in Python.h"

#if Py_file_input != file_input

#error "file_input has changed -- update Py_file_input in Python.h"

#if Py_eval_input != eval_input

#error "eval_input has changed -- update Py_eval_input in Python.h"

int Py_OptimizeFlag = 0;

#define OP_DELETE 0

#define OP_ASSIGN 1

#define OP_APPLY 2

#define VAR_LOAD 0

#define VAR_STORE 1

#define VAR_DELETE 2

#define DEL_CLOSURE_ERROR \

"can not delete variable '%.400s' referenced in nested scope"

#define DUPLICATE_ARGUMENT \

"duplicate argument '%s' in function definition"

#define ILLEGAL_DYNAMIC_SCOPE \

"%.100s: exec or 'import *' makes names ambiguous in nested scope"

#define GLOBAL_AFTER_ASSIGN \

"name '%.400s' is assigned to before global declaration"

#define GLOBAL_AFTER_USE \

"name '%.400s' is used prior to global declaration"

#define LOCAL_GLOBAL \

"name '%.400s' is a function parameter and declared global"

#define LATE_FUTURE \

"from __future__ imports must occur at the beginning of the file"

#define ASSIGN_DEBUG \

"can not assign to __debug__"

#define MANGLE_LEN 256

#define OFF(x) offsetof(PyCodeObject, x)

static PyMemberDef code_memberlist[] = {

{"co_argcount", T_INT, OFF(co_argcount), READONLY},

{"co_nlocals", T_INT, OFF(co_nlocals), READONLY},

{"co_stacksize",T_INT, OFF(co_stacksize), READONLY},

{"co_flags", T_INT, OFF(co_flags), READONLY},

{"co_code", T_OBJECT, OFF(co_code), READONLY},

{"co_consts", T_OBJECT, OFF(co_consts), READONLY},

{"co_names", T_OBJECT, OFF(co_names), READONLY},

{"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},

{"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},

{"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},

{"co_filename", T_OBJECT, OFF(co_filename), READONLY},

{"co_name", T_OBJECT, OFF(co_name), READONLY},

{"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},

{"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY},

{NULL} /* Sentinel */

};

PyDoc_STRVAR(code_doc,

Create a code object. Not for the faint of heart.");

static PyObject *

code_new(PyTypeObject *type, PyObject *args, PyObject *kw)

{

int argcount;

int nlocals;

int stacksize;

int flags;

PyObject *co;

PyObject *empty = NULL;

PyObject *code;

PyObject *consts;

PyObject *names;

PyObject *varnames;

PyObject *freevars = NULL;

PyObject *cellvars = NULL;

PyObject *filename;

PyObject *name;

int firstlineno;

PyObject *lnotab;

if (!PyArg_ParseTuple(args, "iiiiSO!O!O!SSiS|O!O!:code",

&argcount, &nlocals, &stacksize, &flags,

&code,

&PyTuple_Type, &consts,

&PyTuple_Type, &names,

&PyTuple_Type, &varnames,

&filename, &name,

&firstlineno, &lnotab,

&PyTuple_Type, &freevars,

&PyTuple_Type, &cellvars))

return NULL;

if (!PyObject_CheckReadBuffer(code)) {

PyErr_SetString(PyExc_TypeError,

"bytecode object must be a single-segment read-only buffer");

return NULL;

}

if (freevars == NULL || cellvars == NULL) {

empty = PyTuple_New(0);

if (empty == NULL)

return NULL;

if (freevars == NULL)

freevars = empty;

if (cellvars == NULL)

cellvars = empty;

}

co = (PyObject *) PyCode_New(argcount, nlocals, stacksize, flags,

code, consts, names, varnames,

freevars, cellvars, filename, name,

firstlineno, lnotab);

Py_XDECREF(empty);

return co;

}

static void

code_dealloc(PyCodeObject *co)

{

Py_XDECREF(co->co_code);

Py_XDECREF(co->co_consts);

Py_XDECREF(co->co_names);

Py_XDECREF(co->co_varnames);

Py_XDECREF(co->co_freevars);

Py_XDECREF(co->co_cellvars);

Py_XDECREF(co->co_filename);

Py_XDECREF(co->co_name);

Py_XDECREF(co->co_lnotab);

PyObject_DEL(co);

}

static PyObject *

code_repr(PyCodeObject *co)

{

char buf[500];

int lineno = -1;

char *filename = "???";

char *name = "???";

if (co->co_firstlineno != 0)

lineno = co->co_firstlineno;

if (co->co_filename && PyString_Check(co->co_filename))

filename = PyString_AS_STRING(co->co_filename);

if (co->co_name && PyString_Check(co->co_name))

name = PyString_AS_STRING(co->co_name);

PyOS_snprintf(buf, sizeof(buf),

"<code object %.100s at %p, file \"%.300s\", line %d>",

name, co, filename, lineno);

return PyString_FromString(buf);

}

static int

code_compare(PyCodeObject *co, PyCodeObject *cp)

{

int cmp;

cmp = PyObject_Compare(co->co_name, cp->co_name);

if (cmp) return cmp;

cmp = co->co_argcount - cp->co_argcount;

if (cmp) return (cmp<0)?-1:1;

cmp = co->co_nlocals - cp->co_nlocals;

if (cmp) return (cmp<0)?-1:1;

cmp = co->co_flags - cp->co_flags;

if (cmp) return (cmp<0)?-1:1;

cmp = PyObject_Compare(co->co_code, cp->co_code);

if (cmp) return cmp;

cmp = PyObject_Compare(co->co_consts, cp->co_consts);

if (cmp) return cmp;

cmp = PyObject_Compare(co->co_names, cp->co_names);

if (cmp) return cmp;

cmp = PyObject_Compare(co->co_varnames, cp->co_varnames);

if (cmp) return cmp;

cmp = PyObject_Compare(co->co_freevars, cp->co_freevars);

if (cmp) return cmp;

cmp = PyObject_Compare(co->co_cellvars, cp->co_cellvars);

return cmp;

}

static long

code_hash(PyCodeObject *co)

{

long h, h0, h1, h2, h3, h4, h5, h6;

h0 = PyObject_Hash(co->co_name);

if (h0 == -1) return -1;

h1 = PyObject_Hash(co->co_code);

if (h1 == -1) return -1;

h2 = PyObject_Hash(co->co_consts);

if (h2 == -1) return -1;

h3 = PyObject_Hash(co->co_names);

if (h3 == -1) return -1;

h4 = PyObject_Hash(co->co_varnames);

if (h4 == -1) return -1;

h5 = PyObject_Hash(co->co_freevars);

if (h5 == -1) return -1;

h6 = PyObject_Hash(co->co_cellvars);

if (h6 == -1) return -1;

h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^

co->co_argcount ^ co->co_nlocals ^ co->co_flags;

if (h == -1) h = -2;

return h;

}

PyTypeObject PyCode_Type = {

PyObject_HEAD_INIT(&PyType_Type)

0,

"code",

sizeof(PyCodeObject),

0,

(destructor)code_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

(cmpfunc)code_compare, /* tp_compare */

(reprfunc)code_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

(hashfunc)code_hash, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

code_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

code_memberlist, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

code_new, /* tp_new */

};

#define NAME_CHARS \

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

static int

all_name_chars(unsigned char *s)

{

static char ok_name_char[256];

static unsigned char *name_chars = (unsigned char *)NAME_CHARS;

if (ok_name_char[*name_chars] == 0) {

unsigned char *p;

for (p = name_chars; *p; p++)

ok_name_char[*p] = 1;

}

while (*s) {

if (ok_name_char[*s++] == 0)

return 0;

}

return 1;

}

static int

intern_strings(PyObject *tuple)

{

int i;

for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {

PyObject *v = PyTuple_GET_ITEM(tuple, i);

if (v == NULL || !PyString_Check(v)) {

Py_FatalError("non-string found in code slot");

PyErr_BadInternalCall();

return -1;

}

PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));

}

return 0;

}

#define GETARG(arr, i) ((int)((arr[i+2]<<8) + arr[i+1]))

#define UNCONDITIONAL_JUMP(op) (op==JUMP_ABSOLUTE || op==JUMP_FORWARD)

#define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE || op==CONTINUE_LOOP)

#define GETJUMPTGT(arr, i) (GETARG(arr,i) + (ABSOLUTE_JUMP(arr[i]) ? 0 : i+3))

#define SETARG(arr, i, val) arr[i+2] = val>>8; arr[i+1] = val & 255

static PyObject *

optimize_code(PyObject *code, PyObject* consts)

{

int i, j, codelen;

int tgt, tgttgt, opcode;

unsigned char *codestr;

/* Make a modifiable copy of the code string */

if (!PyString_Check(code))

goto exitUnchanged;

codelen = PyString_Size(code);

codestr = PyMem_Malloc(codelen);

if (codestr == NULL)

goto exitUnchanged;

codestr = memcpy(codestr, PyString_AS_STRING(code), codelen);

assert(PyTuple_Check(consts));

/* Avoid situations where jump retargeting could overflow */

if (codelen > 65000)

goto exitUnchanged;

for (i=0 ; i<codelen-7 ; i += HAS_ARG(codestr[i]) ? 3 : 1) {

opcode = codestr[i];

switch (opcode) {

/* Skip over LOAD_CONST trueconst JUMP_IF_FALSE xx POP_TOP.

case LOAD_CONST:

j = GETARG(codestr, i);

if (codestr[i+3] != JUMP_IF_FALSE ||

codestr[i+6] != POP_TOP ||

!PyObject_IsTrue(PyTuple_GET_ITEM(consts, j)))

continue;

codestr[i] = JUMP_FORWARD;

SETARG(codestr, i, 4);

break;

/* Replace jumps to unconditional jumps */

case FOR_ITER:

case JUMP_FORWARD:

case JUMP_IF_FALSE:

case JUMP_IF_TRUE:

case JUMP_ABSOLUTE:

case CONTINUE_LOOP:

case SETUP_LOOP:

case SETUP_EXCEPT:

case SETUP_FINALLY:

tgt = GETJUMPTGT(codestr, i);

if (!UNCONDITIONAL_JUMP(codestr[tgt]))

continue;

tgttgt = GETJUMPTGT(codestr, tgt);

if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */

opcode = JUMP_ABSOLUTE;

if (!ABSOLUTE_JUMP(opcode))

tgttgt -= i + 3; /* Calc relative jump addr */

if (tgttgt < 0) /* No backward relative jumps */

continue;

codestr[i] = opcode;

SETARG(codestr, i, tgttgt);

break;

case EXTENDED_ARG:

PyMem_Free(codestr);

goto exitUnchanged;

}

}

code = PyString_FromStringAndSize((char *)codestr, codelen);

PyMem_Free(codestr);

return code;

exitUnchanged:

Py_INCREF(code);

return code;

}

PyCodeObject *

PyCode_New(int argcount, int nlocals, int stacksize, int flags,

PyObject *lnotab)

{

PyCodeObject *co;

int i;

/* Check argument types */

if (argcount < 0 || nlocals < 0 ||

code == NULL ||

consts == NULL || !PyTuple_Check(consts) ||

names == NULL || !PyTuple_Check(names) ||

varnames == NULL || !PyTuple_Check(varnames) ||

freevars == NULL || !PyTuple_Check(freevars) ||

cellvars == NULL || !PyTuple_Check(cellvars) ||

name == NULL || !PyString_Check(name) ||

filename == NULL || !PyString_Check(filename) ||

lnotab == NULL || !PyString_Check(lnotab) ||

!PyObject_CheckReadBuffer(code)) {

PyErr_BadInternalCall();

return NULL;

}

intern_strings(names);

intern_strings(varnames);

intern_strings(freevars);

intern_strings(cellvars);

/* Intern selected string constants */

for (i = PyTuple_Size(consts); --i >= 0; ) {

PyObject *v = PyTuple_GetItem(consts, i);

if (!PyString_Check(v))

continue;

if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))

continue;

PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));

}

co = PyObject_NEW(PyCodeObject, &PyCode_Type);

if (co != NULL) {

co->co_argcount = argcount;

co->co_nlocals = nlocals;

co->co_stacksize = stacksize;

co->co_flags = flags;

co->co_code = optimize_code(code, consts);

Py_INCREF(consts);

co->co_consts = consts;

Py_INCREF(names);

co->co_names = names;

Py_INCREF(varnames);

co->co_varnames = varnames;

Py_INCREF(freevars);

co->co_freevars = freevars;

Py_INCREF(cellvars);

co->co_cellvars = cellvars;

Py_INCREF(filename);

co->co_filename = filename;

Py_INCREF(name);

co->co_name = name;

co->co_firstlineno = firstlineno;

Py_INCREF(lnotab);

co->co_lnotab = lnotab;

if (PyTuple_GET_SIZE(freevars) == 0 &&

PyTuple_GET_SIZE(cellvars) == 0)

co->co_flags |= CO_NOFREE;

}

return co;

}

struct compiling {

};

static int

is_free(int v)

{

if ((v & (USE | DEF_FREE))

&& !(v & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)))

return 1;

if (v & DEF_FREE_CLASS)

return 1;

return 0;

}

static void

com_error(struct compiling *c, PyObject *exc, char *msg)

{

PyObject *t = NULL, *v = NULL, *w = NULL, *line = NULL;

if (c == NULL) {

/* Error occurred via symtable call to

PyErr_SetString(exc, msg);

return;

}

c->c_errors++;

if (c->c_lineno < 1 || c->c_interactive) {

/* Unknown line number or interactive input */

PyErr_SetString(exc, msg);

return;

}

v = PyString_FromString(msg);

if (v == NULL)

return; /* MemoryError, too bad */

line = PyErr_ProgramText(c->c_filename, c->c_lineno);

if (line == NULL) {

Py_INCREF(Py_None);

line = Py_None;

}

if (exc == PyExc_SyntaxError) {

t = Py_BuildValue("(ziOO)", c->c_filename, c->c_lineno,

Py_None, line);

if (t == NULL)

goto exit;

w = Py_BuildValue("(OO)", v, t);

if (w == NULL)

goto exit;

PyErr_SetObject(exc, w);

} else {

/* Make sure additional exceptions are printed with

PyErr_SetObject(exc, v);

PyErr_SyntaxLocation(c->c_filename, c->c_lineno);

}

exit:

Py_XDECREF(t);

Py_XDECREF(v);

Py_XDECREF(w);

Py_XDECREF(line);

}

static void

block_push(struct compiling *c, int type)

{

if (c->c_nblocks >= CO_MAXBLOCKS) {

com_error(c, PyExc_SystemError,

"too many statically nested blocks");

}

else {

c->c_block[c->c_nblocks++] = type;

}

}

static void

block_pop(struct compiling *c, int type)

{

if (c->c_nblocks > 0)

c->c_nblocks--;

if (c->c_block[c->c_nblocks] != type && c->c_errors == 0) {

com_error(c, PyExc_SystemError, "bad block pop");

}

}

static int issue_warning(const char *, const char *, int);

static int com_init(struct compiling *, const char *);

static void com_free(struct compiling *);

static void com_push(struct compiling *, int);

static void com_pop(struct compiling *, int);

static void com_done(struct compiling *);

static void com_node(struct compiling *, node *);

static void com_factor(struct compiling *, node *);

static void com_addbyte(struct compiling *, int);

static void com_addint(struct compiling *, int);

static void com_addoparg(struct compiling *, int, int);

static void com_addfwref(struct compiling *, int, int *);

static void com_backpatch(struct compiling *, int);

static int com_add(struct compiling *, PyObject *, PyObject *, PyObject *);

static int com_addconst(struct compiling *, PyObject *);

static int com_addname(struct compiling *, PyObject *);

static void com_addopname(struct compiling *, int, node *);

static void com_list(struct compiling *, node *, int);

static void com_list_iter(struct compiling *, node *, node *, char *);

static int com_argdefs(struct compiling *, node *);

static void com_assign(struct compiling *, node *, int, node *);

static void com_assign_name(struct compiling *, node *, int);

static PyCodeObject *icompile(node *, struct compiling *);

static PyCodeObject *jcompile(node *, const char *, struct compiling *,

PyCompilerFlags *);

static PyObject *parsestrplus(struct compiling*, node *);

static PyObject *parsestr(struct compiling *, char *);

static node *get_rawdocstring(node *);

static int get_ref_type(struct compiling *, char *);

static struct symtable *symtable_build(node *, PyFutureFeatures *,

const char *filename);

static int symtable_load_symbols(struct compiling *);

static struct symtable *symtable_init(void);

static void symtable_enter_scope(struct symtable *, char *, int, int);

static int symtable_exit_scope(struct symtable *);

static int symtable_add_def(struct symtable *, char *, int);

static int symtable_add_def_o(struct symtable *, PyObject *, PyObject *, int);

static void symtable_node(struct symtable *, node *);

static void symtable_funcdef(struct symtable *, node *);

static void symtable_default_args(struct symtable *, node *);

static void symtable_params(struct symtable *, node *);

static void symtable_params_fplist(struct symtable *, node *n);

static void symtable_global(struct symtable *, node *);

static void symtable_import(struct symtable *, node *);

static void symtable_assign(struct symtable *, node *, int);

static void symtable_list_comprehension(struct symtable *, node *);

static void symtable_list_for(struct symtable *, node *);

static int symtable_update_free_vars(struct symtable *);

static int symtable_undo_free(struct symtable *, PyObject *, PyObject *);

static int symtable_check_global(struct symtable *, PyObject *, PyObject *);

static void

do_pad(int pad)

{

int i;

for (i = 0; i < pad; ++i)

fprintf(stderr, " ");

}

static void

dump(node *n, int pad, int depth)

{

int i;

if (depth == 0)

return;

do_pad(pad);

fprintf(stderr, "%d: %s\n", TYPE(n), STR(n));

if (depth > 0)

depth--;

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

dump(CHILD(n, i), pad + 1, depth);

}

#define DUMP(N) dump(N, 0, -1)

static int

com_init(struct compiling *c, const char *filename)

{

memset((void *)c, '\0', sizeof(struct compiling));

if ((c->c_code = PyString_FromStringAndSize((char *)NULL,

1000)) == NULL)

goto fail;

if ((c->c_consts = PyList_New(0)) == NULL)

goto fail;

if ((c->c_const_dict = PyDict_New()) == NULL)

goto fail;

if ((c->c_names = PyList_New(0)) == NULL)

goto fail;

if ((c->c_name_dict = PyDict_New()) == NULL)

goto fail;

if ((c->c_locals = PyDict_New()) == NULL)

goto fail;

if ((c->c_lnotab = PyString_FromStringAndSize((char *)NULL,

1000)) == NULL)

goto fail;

c->c_globals = NULL;

c->c_varnames = NULL;

c->c_freevars = NULL;

c->c_cellvars = NULL;

c->c_nlocals = 0;

c->c_argcount = 0;

c->c_flags = 0;

c->c_nexti = 0;

c->c_errors = 0;

c->c_infunction = 0;

c->c_interactive = 0;

c->c_loops = 0;

c->c_begin = 0;

c->c_nblocks = 0;

c->c_filename = filename;

c->c_name = "?";

c->c_lineno = 0;

c->c_stacklevel = 0;

c->c_maxstacklevel = 0;

c->c_firstlineno = 0;

c->c_last_addr = 0;

c->c_last_line = 0;

c->c_lnotab_next = 0;

c->c_tmpname = 0;

c->c_nested = 0;

c->c_closure = 0;

c->c_symtable = NULL;

return 1;

fail:

com_free(c);

return 0;

}

static void

com_free(struct compiling *c)

{

Py_XDECREF(c->c_code);

Py_XDECREF(c->c_consts);

Py_XDECREF(c->c_const_dict);

Py_XDECREF(c->c_names);

Py_XDECREF(c->c_name_dict);

Py_XDECREF(c->c_globals);

Py_XDECREF(c->c_locals);

Py_XDECREF(c->c_varnames);

Py_XDECREF(c->c_freevars);

Py_XDECREF(c->c_cellvars);

Py_XDECREF(c->c_lnotab);

if (c->c_future)

PyObject_FREE((void *)c->c_future);

}

static void

com_push(struct compiling *c, int n)

{

c->c_stacklevel += n;

if (c->c_stacklevel > c->c_maxstacklevel) {

c->c_maxstacklevel = c->c_stacklevel;

/*

}

}

static void

com_pop(struct compiling *c, int n)

{

if (c->c_stacklevel < n)

c->c_stacklevel = 0;

else

c->c_stacklevel -= n;

}

static void

com_done(struct compiling *c)

{

if (c->c_code != NULL)

_PyString_Resize(&c->c_code, c->c_nexti);

if (c->c_lnotab != NULL)

_PyString_Resize(&c->c_lnotab, c->c_lnotab_next);

}

static int

com_check_size(PyObject **s, int offset)

{

int len = PyString_GET_SIZE(*s);

if (offset >= len)

return _PyString_Resize(s, len * 2);

return 0;

}

static void

com_addbyte(struct compiling *c, int byte)

{

/*fprintf(stderr, "%3d: %3d\n", c->c_nexti, byte);*/

assert(byte >= 0 && byte <= 255);

assert(c->c_code != 0);

if (com_check_size(&c->c_code, c->c_nexti)) {

c->c_errors++;

return;

}

PyString_AS_STRING(c->c_code)[c->c_nexti++] = byte;

}

static void

com_addint(struct compiling *c, int x)

{

com_addbyte(c, x & 0xff);

com_addbyte(c, x >> 8); /* XXX x should be positive */

}

static void

com_add_lnotab(struct compiling *c, int addr, int line)

{

char *p;

if (c->c_lnotab == NULL)

return;

if (com_check_size(&c->c_lnotab, c->c_lnotab_next + 2)) {

c->c_errors++;

return;

}

p = PyString_AS_STRING(c->c_lnotab) + c->c_lnotab_next;

*p++ = addr;

*p++ = line;

c->c_lnotab_next += 2;

}

static void

com_set_lineno(struct compiling *c, int lineno)

{

c->c_lineno = lineno;

if (c->c_firstlineno == 0) {

c->c_firstlineno = c->c_last_line = lineno;

}

else {

int incr_addr = c->c_nexti - c->c_last_addr;

int incr_line = lineno - c->c_last_line;

while (incr_addr > 255) {

com_add_lnotab(c, 255, 0);

incr_addr -= 255;

}

while (incr_line > 255) {

com_add_lnotab(c, incr_addr, 255);

incr_line -=255;

incr_addr = 0;

}

if (incr_addr > 0 || incr_line > 0)

com_add_lnotab(c, incr_addr, incr_line);

c->c_last_addr = c->c_nexti;

c->c_last_line = lineno;

}

}

static void

com_addoparg(struct compiling *c, int op, int arg)

{

int extended_arg = arg >> 16;

if (extended_arg){

com_addbyte(c, EXTENDED_ARG);

com_addint(c, extended_arg);

arg &= 0xffff;

}

com_addbyte(c, op);

com_addint(c, arg);

}

static void

com_addfwref(struct compiling *c, int op, int *p_anchor)

{

/* Compile a forward reference for backpatching */

int here;

int anchor;

com_addbyte(c, op);

here = c->c_nexti;

anchor = *p_anchor;

*p_anchor = here;

com_addint(c, anchor == 0 ? 0 : here - anchor);

}

static void

com_backpatch(struct compiling *c, int anchor)

{

unsigned char *code = (unsigned char *) PyString_AS_STRING(c->c_code);

int target = c->c_nexti;

int dist;

int prev;

for (;;) {

/* Make the JUMP instruction at anchor point to target */

prev = code[anchor] + (code[anchor+1] << 8);

dist = target - (anchor+2);

code[anchor] = dist & 0xff;

dist >>= 8;

code[anchor+1] = dist;

dist >>= 8;

if (dist) {

com_error(c, PyExc_SystemError,

"com_backpatch: offset too large");

break;

}

if (!prev)

break;

anchor -= prev;

}

}

static int

com_add(struct compiling *c, PyObject *list, PyObject *dict, PyObject *v)

{

PyObject *w, *t, *np=NULL;

long n;

t = Py_BuildValue("(OO)", v, v->ob_type);

if (t == NULL)

goto fail;

w = PyDict_GetItem(dict, t);

if (w != NULL) {

n = PyInt_AsLong(w);

} else {

n = PyList_Size(list);

np = PyInt_FromLong(n);

if (np == NULL)

goto fail;

if (PyList_Append(list, v) != 0)

goto fail;

if (PyDict_SetItem(dict, t, np) != 0)

goto fail;

Py_DECREF(np);

}

Py_DECREF(t);

return n;

fail:

Py_XDECREF(np);

Py_XDECREF(t);

c->c_errors++;

return 0;

}