#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "pyarena.h"

#include "ast.h"

#include "code.h"

#include "compile.h"

#include "symtable.h"

#include "opcode.h"

int Py_OptimizeFlag = 0;

#define DEFAULT_BLOCK_SIZE 16

#define DEFAULT_BLOCKS 8

#define DEFAULT_CODE_SIZE 128

#define DEFAULT_LNOTAB_SIZE 16

#define COMP_GENEXP 0

#define COMP_SETCOMP 1

#define COMP_DICTCOMP 2

struct instr {

};

typedef struct basicblock_ {

} basicblock;

enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END };

struct fblockinfo {

enum fblocktype fb_type;

basicblock *fb_block;

};

struct compiler_unit {

};

struct compiler {

};

static int compiler_enter_scope(struct compiler *, identifier, void *, int);

static void compiler_free(struct compiler *);

static basicblock *compiler_new_block(struct compiler *);

static int compiler_next_instr(struct compiler *, basicblock *);

static int compiler_addop(struct compiler *, int);

static int compiler_addop_o(struct compiler *, int, PyObject *, PyObject *);

static int compiler_addop_i(struct compiler *, int, int);

static int compiler_addop_j(struct compiler *, int, basicblock *, int);

static basicblock *compiler_use_new_block(struct compiler *);

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

static int compiler_nameop(struct compiler *, 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_visit_slice(struct compiler *, slice_ty,

expr_context_ty);

static int compiler_push_fblock(struct compiler *, enum fblocktype,

basicblock *);

static void compiler_pop_fblock(struct compiler *, enum fblocktype,

basicblock *);

static int compiler_in_loop(struct compiler *);

static int inplace_binop(struct compiler *, operator_ty);

static int expr_constant(expr_ty e);

static int compiler_with(struct compiler *, stmt_ty);

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

static PyObject *__doc__;

#define COMPILER_CAPSULE_NAME_COMPILER_UNIT "compile.c compiler unit"

PyObject *

_Py_Mangle(PyObject *privateobj, PyObject *ident)

{

/* Name mangling: __private becomes _classname__private.

const char *p, *name = PyString_AsString(ident);

char *buffer;

size_t nlen, plen;

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

name == NULL || name[0] != '_' || name[1] != '_') {

Py_INCREF(ident);

return ident;

}

p = PyString_AsString(privateobj);

nlen = strlen(name);

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

if ((name[nlen-1] == '_' && name[nlen-2] == '_')

|| strchr(name, '.')) {

Py_INCREF(ident);

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

}

/* Strip leading underscores from class name */

while (*p == '_')

p++;

if (*p == '\0') {

Py_INCREF(ident);

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

}

plen = strlen(p);

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

PyErr_SetString(PyExc_OverflowError,

"private identifier too large to be mangled");

return NULL;

}

ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);

if (!ident)

return 0;

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

buffer = PyString_AS_STRING(ident);

buffer[0] = '_';

strncpy(buffer+1, p, plen);

strcpy(buffer+1+plen, name);

return ident;

}

static int

compiler_init(struct compiler *c)

{

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

c->c_stack = PyList_New(0);

if (!c->c_stack)

return 0;

return 1;

}

PyCodeObject *

PyAST_Compile(mod_ty mod, const char *filename, PyCompilerFlags *flags,

PyArena *arena)

{

struct compiler c;

PyCodeObject *co = NULL;

PyCompilerFlags local_flags;

int merged;

if (!__doc__) {

__doc__ = PyString_InternFromString("__doc__");

if (!__doc__)

return NULL;

}

if (!compiler_init(&c))

return NULL;

c.c_filename = filename;

c.c_arena = arena;

c.c_future = PyFuture_FromAST(mod, filename);

if (c.c_future == NULL)

goto finally;

if (!flags) {

local_flags.cf_flags = 0;

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_nestlevel = 0;

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;

}

PyCodeObject *

PyNode_Compile(struct _node *n, const char *filename)

{

PyCodeObject *co = NULL;

mod_ty mod;

PyArena *arena = PyArena_New();

if (!arena)

return NULL;

mod = PyAST_FromNode(n, NULL, filename, arena);

if (mod)

co = PyAST_Compile(mod, filename, NULL, arena);

PyArena_Free(arena);

return co;

}

static void

compiler_free(struct compiler *c)

{

if (c->c_st)

PySymtable_Free(c->c_st);

if (c->c_future)

PyObject_Free(c->c_future);

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 = PyInt_FromLong(i);

if (!v) {

Py_DECREF(dict);

return NULL;

}

k = PyList_GET_ITEM(list, i);

k = PyTuple_Pack(2, k, k->ob_type);

if (k == NULL || PyDict_SetItem(dict, k, v) < 0) {

Py_XDECREF(k);

Py_DECREF(v);

Py_DECREF(dict);

return NULL;

}

Py_DECREF(k);

Py_DECREF(v);

}

return dict;

}

static PyObject *

dictbytype(PyObject *src, int scope_type, int flag, int 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++) {

k = PyList_GET_ITEM(sorted_keys, key_i);

v = PyDict_GetItem(src, k);

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

assert(PyInt_Check(v));

scope = (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;

if (scope == scope_type || PyInt_AS_LONG(v) & flag) {

PyObject *tuple, *item = PyInt_FromLong(i);

if (item == NULL) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

i++;

tuple = PyTuple_Pack(2, k, k->ob_type);

if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) {

Py_DECREF(sorted_keys);

Py_DECREF(item);

Py_DECREF(dest);

Py_XDECREF(tuple);

return NULL;

}

Py_DECREF(item);

Py_DECREF(tuple);

}

}

Py_DECREF(sorted_keys);

return dest;

}

static void

compiler_unit_check(struct compiler_unit *u)

{

basicblock *block;

for (block = u->u_blocks; block != NULL; block = block->b_list) {

assert((void *)block != (void *)0xcbcbcbcb);

assert((void *)block != (void *)0xfbfbfbfb);

assert((void *)block != (void *)0xdbdbdbdb);

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 void

compiler_unit_free(struct compiler_unit *u)

{

basicblock *b, *next;

compiler_unit_check(u);

b = u->u_blocks;

while (b != NULL) {

if (b->b_instr)

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

next = b->b_list;

PyObject_Free((void *)b);

b = next;

}

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_name);

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_enter_scope(struct compiler *c, identifier name, void *key,

int lineno)

{

struct compiler_unit *u;

u = (struct compiler_unit *)PyObject_Malloc(sizeof(

struct compiler_unit));

if (!u) {

PyErr_NoMemory();

return 0;

}

memset(u, 0, sizeof(struct compiler_unit));

u->u_argcount = 0;

u->u_ste = PySymtable_Lookup(c->c_st, key);

if (!u->u_ste) {

compiler_unit_free(u);

return 0;

}

Py_INCREF(name);

u->u_name = name;

u->u_varnames = list2dict(u->u_ste->ste_varnames);

u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);

if (!u->u_varnames || !u->u_cellvars) {

compiler_unit_free(u);

return 0;

}

u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,

PyDict_Size(u->u_cellvars));

if (!u->u_freevars) {

compiler_unit_free(u);

return 0;

}

u->u_blocks = NULL;

u->u_nfblocks = 0;

u->u_firstlineno = lineno;

u->u_lineno = 0;

u->u_lineno_set = false;

u->u_consts = PyDict_New();

if (!u->u_consts) {

compiler_unit_free(u);

return 0;

}

u->u_names = PyDict_New();

if (!u->u_names) {

compiler_unit_free(u);

return 0;

}

u->u_private = NULL;

/* Push the old compiler_unit on the stack. */

if (c->u) {

PyObject *capsule = PyCapsule_New(c->u, COMPILER_CAPSULE_NAME_COMPILER_UNIT, NULL);

if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {

Py_XDECREF(capsule);

compiler_unit_free(u);

return 0;

}

Py_DECREF(capsule);

u->u_private = c->u->u_private;

Py_XINCREF(u->u_private);

}

c->u = u;

c->c_nestlevel++;

if (compiler_use_new_block(c) == NULL)

return 0;

return 1;

}

static void

compiler_exit_scope(struct compiler *c)

{

int n;

PyObject *capsule;

c->c_nestlevel--;

compiler_unit_free(c->u);

/* Restore c->u to the parent unit. */

n = PyList_GET_SIZE(c->c_stack) - 1;

if (n >= 0) {

capsule = PyList_GET_ITEM(c->c_stack, n);

c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT);

assert(c->u);

/* we are deleting from a list so this really shouldn't fail */

if (PySequence_DelItem(c->c_stack, n) < 0)

Py_FatalError("compiler_exit_scope()");

compiler_unit_check(c->u);

}

else

c->u = NULL;

}

static basicblock *

compiler_new_block(struct compiler *c)

{

basicblock *b;

struct compiler_unit *u;

u = c->u;

b = (basicblock *)PyObject_Malloc(sizeof(basicblock));

if (b == NULL) {

PyErr_NoMemory();

return NULL;

}

memset((void *)b, 0, sizeof(basicblock));

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

b->b_list = u->u_blocks;

u->u_blocks = b;

return b;

}

static basicblock *

compiler_use_new_block(struct compiler *c)

{

basicblock *block = compiler_new_block(c);

if (block == NULL)

return NULL;

c->u->u_curblock = block;

return block;

}

static basicblock *

compiler_next_block(struct compiler *c)

{

basicblock *block = compiler_new_block(c);

if (block == NULL)

return NULL;

c->u->u_curblock->b_next = block;

c->u->u_curblock = block;

return block;

}

static basicblock *

compiler_use_next_block(struct compiler *c, basicblock *block)

{

assert(block != NULL);

c->u->u_curblock->b_next = block;

c->u->u_curblock = block;

return block;

}

static int

compiler_next_instr(struct compiler *c, basicblock *b)

{

assert(b != NULL);

if (b->b_instr == NULL) {

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

sizeof(struct instr) * DEFAULT_BLOCK_SIZE);

if (b->b_instr == NULL) {

PyErr_NoMemory();

return -1;

}

b->b_ialloc = DEFAULT_BLOCK_SIZE;

memset((char *)b->b_instr, 0,

sizeof(struct instr) * 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 > (PY_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);

}

return b->b_iused++;

}

static void

compiler_set_lineno(struct compiler *c, int off)

{

basicblock *b;

if (c->u->u_lineno_set)

return;

c->u->u_lineno_set = true;

b = c->u->u_curblock;

b->b_instr[off].i_lineno = c->u->u_lineno;

}

static int

opcode_stack_effect(int opcode, int oparg)

{

switch (opcode) {

case POP_TOP:

return -1;

case ROT_TWO:

case ROT_THREE:

return 0;

case DUP_TOP:

return 1;

case ROT_FOUR:

return 0;

case UNARY_POSITIVE:

case UNARY_NEGATIVE:

case UNARY_NOT:

case UNARY_CONVERT:

case UNARY_INVERT:

return 0;

case SET_ADD:

case LIST_APPEND:

return -1;

case MAP_ADD:

return -2;

case BINARY_POWER:

case BINARY_MULTIPLY:

case BINARY_DIVIDE:

case BINARY_MODULO:

case BINARY_ADD:

case BINARY_SUBTRACT:

case BINARY_SUBSCR:

case BINARY_FLOOR_DIVIDE:

case BINARY_TRUE_DIVIDE:

return -1;

case INPLACE_FLOOR_DIVIDE:

case INPLACE_TRUE_DIVIDE:

return -1;

case SLICE+0:

return 0;

case SLICE+1:

return -1;

case SLICE+2:

return -1;

case SLICE+3:

return -2;

case STORE_SLICE+0:

return -2;

case STORE_SLICE+1:

return -3;

case STORE_SLICE+2:

return -3;

case STORE_SLICE+3:

return -4;

case DELETE_SLICE+0:

return -1;

case DELETE_SLICE+1:

return -2;

case DELETE_SLICE+2:

return -2;

case DELETE_SLICE+3:

return -3;

case INPLACE_ADD:

case INPLACE_SUBTRACT:

case INPLACE_MULTIPLY:

case INPLACE_DIVIDE:

case INPLACE_MODULO:

return -1;

case STORE_SUBSCR:

return -3;

case STORE_MAP:

return -2;

case DELETE_SUBSCR:

return -2;

case BINARY_LSHIFT:

case BINARY_RSHIFT:

case BINARY_AND:

case BINARY_XOR:

case BINARY_OR:

return -1;

case INPLACE_POWER:

return -1;

case GET_ITER:

return 0;

case PRINT_EXPR:

return -1;

case PRINT_ITEM:

return -1;

case PRINT_NEWLINE:

return 0;

case PRINT_ITEM_TO:

return -2;

case PRINT_NEWLINE_TO:

return -1;

case INPLACE_LSHIFT:

case INPLACE_RSHIFT:

case INPLACE_AND:

case INPLACE_XOR:

case INPLACE_OR:

return -1;

case BREAK_LOOP:

return 0;

case SETUP_WITH:

return 4;

case WITH_CLEANUP:

return -1; /* XXX Sometimes more */

case LOAD_LOCALS:

return 1;

case RETURN_VALUE:

return -1;

case IMPORT_STAR:

return -1;

case EXEC_STMT:

return -3;

case YIELD_VALUE:

return 0;

case POP_BLOCK:

return 0;

case END_FINALLY:

return -3; /* or -1 or -2 if no exception occurred or

case BUILD_CLASS:

return -2;

case STORE_NAME:

return -1;

case DELETE_NAME:

return 0;

case UNPACK_SEQUENCE:

return oparg-1;

case FOR_ITER:

return 1; /* or -1, at end of iterator */

case STORE_ATTR:

return -2;

case DELETE_ATTR:

return -1;

case STORE_GLOBAL:

return -1;

case DELETE_GLOBAL:

return 0;

case DUP_TOPX:

return oparg;

case LOAD_CONST:

return 1;

case LOAD_NAME:

return 1;

case BUILD_TUPLE:

case BUILD_LIST:

case BUILD_SET:

return 1-oparg;

case BUILD_MAP:

return 1;

case LOAD_ATTR:

return 0;

case COMPARE_OP:

return -1;

case IMPORT_NAME:

return -1;

case IMPORT_FROM:

return 1;

case JUMP_FORWARD:

case JUMP_IF_TRUE_OR_POP: /* -1 if jump not taken */

case JUMP_IF_FALSE_OR_POP: /* "" */

case JUMP_ABSOLUTE:

return 0;

case POP_JUMP_IF_FALSE:

case POP_JUMP_IF_TRUE:

return -1;

case LOAD_GLOBAL:

return 1;

case CONTINUE_LOOP:

return 0;

case SETUP_LOOP:

case SETUP_EXCEPT:

case SETUP_FINALLY:

return 0;

case LOAD_FAST:

return 1;

case STORE_FAST:

return -1;

case DELETE_FAST:

return 0;

case RAISE_VARARGS:

return -oparg;

#define NARGS(o) (((o) % 256) + 2*((o) / 256))

case CALL_FUNCTION:

return -NARGS(oparg);

case CALL_FUNCTION_VAR:

case CALL_FUNCTION_KW:

return -NARGS(oparg)-1;

case CALL_FUNCTION_VAR_KW:

return -NARGS(oparg)-2;

#undef NARGS

case MAKE_FUNCTION:

return -oparg;

case BUILD_SLICE:

if (oparg == 3)

return -2;

else

return -1;

case MAKE_CLOSURE:

return -oparg-1;

case LOAD_CLOSURE:

return 1;

case LOAD_DEREF:

return 1;

case STORE_DEREF:

return -1;

default:

fprintf(stderr, "opcode = %d\n", opcode);

Py_FatalError("opcode_stack_effect()");

}

return 0; /* not reachable */

}

static int

compiler_addop(struct compiler *c, int opcode)

{

basicblock *b;

struct instr *i;

int off;

off = compiler_next_instr(c, c->u->u_curblock);

if (off < 0)

return 0;

b = c->u->u_curblock;

i = &b->b_instr[off];

i->i_opcode = opcode;

i->i_hasarg = 0;

if (opcode == RETURN_VALUE)

b->b_return = 1;

compiler_set_lineno(c, off);

return 1;

}

static int

compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)

{

PyObject *t, *v;

Py_ssize_t arg;

double d;

/* necessary to make sure types aren't coerced (e.g., int and long) */

/* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */

if (PyFloat_Check(o)) {

d = PyFloat_AS_DOUBLE(o);

/* all we need is to make the tuple different in either the 0.0

if (d == 0.0 && copysign(1.0, d) < 0.0)

t = PyTuple_Pack(3, o, o->ob_type, Py_None);

else

t = PyTuple_Pack(2, o, o->ob_type);

}

#ifndef WITHOUT_COMPLEX

else if (PyComplex_Check(o)) {

Py_complex z;

int real_negzero, imag_negzero;

/* For the complex case we must make complex(x, 0.)

z = PyComplex_AsCComplex(o);

real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;

imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;

if (real_negzero && imag_negzero) {

t = PyTuple_Pack(5, o, o->ob_type,

Py_None, Py_None, Py_None);

}

else if (imag_negzero) {

t = PyTuple_Pack(4, o, o->ob_type, Py_None, Py_None);

}

else if (real_negzero) {

t = PyTuple_Pack(3, o, o->ob_type, Py_None);

}

else {

t = PyTuple_Pack(2, o, o->ob_type);

}

}

#endif /* WITHOUT_COMPLEX */

else {

t = PyTuple_Pack(2, o, o->ob_type);

}

if (t == NULL)

return -1;

v = PyDict_GetItem(dict, t);

if (!v) {

arg = PyDict_Size(dict);

v = PyInt_FromLong(arg);

if (!v) {

Py_DECREF(t);

return -1;

}