#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "ast.h"

#include "code.h"

#include "symtable.h"

#include "opcode.h"

#include "wordcode_helpers.h"

#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_LISTCOMP 1

#define COMP_SETCOMP 2

#define COMP_DICTCOMP 3

struct instr {

};

typedef struct basicblock_ {

} basicblock;

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

WITH, ASYNC_WITH, HANDLER_CLEANUP };

struct fblockinfo {

};

enum {

COMPILER_SCOPE_MODULE,

COMPILER_SCOPE_CLASS,

COMPILER_SCOPE_FUNCTION,

COMPILER_SCOPE_ASYNC_FUNCTION,

COMPILER_SCOPE_LAMBDA,

COMPILER_SCOPE_COMPREHENSION,

};

struct compiler_unit {

};

struct compiler {

};

static int compiler_enter_scope(struct compiler *, identifier, int, 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_i(struct compiler *, int, Py_ssize_t);

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

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_annassign(struct compiler *, stmt_ty);

static int compiler_visit_slice(struct compiler *, slice_ty,

expr_context_ty);

static int inplace_binop(struct compiler *, operator_ty);

static int expr_constant(expr_ty);

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_helper(struct compiler *c, int n,

asdl_seq *args,

asdl_seq *keywords);

static int compiler_try_except(struct compiler *, stmt_ty);

static int compiler_set_qualname(struct compiler *);

static int compiler_sync_comprehension_generator(

struct compiler *c,

asdl_seq *generators, int gen_index,

expr_ty elt, expr_ty val, int type);

static int compiler_async_comprehension_generator(

struct compiler *c,

asdl_seq *generators, int gen_index,

expr_ty elt, expr_ty val, int type);

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

static PyObject *__doc__, *__annotations__;

#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_stack = PyList_New(0);

if (!c->c_stack)

return 0;

return 1;

}

PyCodeObject *

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

int optimize, PyArena *arena)

{

struct compiler c;

PyCodeObject *co = NULL;

PyCompilerFlags local_flags;

int merged;

if (!__doc__) {

__doc__ = PyUnicode_InternFromString("__doc__");

if (!__doc__)

return NULL;

}

if (!__annotations__) {

__annotations__ = PyUnicode_InternFromString("__annotations__");

if (!__annotations__)

return NULL;

}

if (!compiler_init(&c))

return NULL;

Py_INCREF(filename);

c.c_filename = filename;

c.c_arena = arena;

c.c_future = PyFuture_FromASTObject(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_optimize = (optimize == -1) ? Py_OptimizeFlag : optimize;

c.c_nestlevel = 0;

if (!_PyAST_Optimize(mod, arena, c.c_optimize)) {

goto finally;

}

c.c_st = PySymtable_BuildObject(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 *

PyAST_CompileEx(mod_ty mod, const char *filename_str, PyCompilerFlags *flags,

int optimize, PyArena *arena)

{

PyObject *filename;

PyCodeObject *co;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL)

return NULL;

co = PyAST_CompileObject(mod, filename, flags, optimize, arena);

Py_DECREF(filename);

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_XDECREF(c->c_filename);

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_GetItem(src, k);

assert(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

compiler_unit_check(struct compiler_unit *u)

{

basicblock *block;

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

assert((uintptr_t)block != 0xcbcbcbcbU);

assert((uintptr_t)block != 0xfbfbfbfbU);

assert((uintptr_t)block != 0xdbdbdbdbU);

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

int scope_type, void *key, int lineno)

{

struct compiler_unit *u;

basicblock *block;

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_scope_type = scope_type;

u->u_argcount = 0;

u->u_kwonlyargcount = 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;

}

if (u->u_ste->ste_needs_class_closure) {

/* Cook up an implicit __class__ cell. */

_Py_IDENTIFIER(__class__);

PyObject *name;

int res;

assert(u->u_scope_type == COMPILER_SCOPE_CLASS);

assert(PyDict_GET_SIZE(u->u_cellvars) == 0);

name = _PyUnicode_FromId(&PyId___class__);

if (!name) {

compiler_unit_free(u);

return 0;

}

res = PyDict_SetItem(u->u_cellvars, name, _PyLong_Zero);

if (res < 0) {

compiler_unit_free(u);

return 0;

}

}

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

PyDict_GET_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_col_offset = 0;

u->u_lineno_set = 0;

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, CAPSULE_NAME, 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++;

block = compiler_new_block(c);

if (block == NULL)

return 0;

c->u->u_curblock = block;

if (u->u_scope_type != COMPILER_SCOPE_MODULE) {

if (!compiler_set_qualname(c))

return 0;

}

return 1;

}

static void

compiler_exit_scope(struct compiler *c)

{

Py_ssize_t 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, CAPSULE_NAME);

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 int

compiler_set_qualname(struct compiler *c)

{

_Py_static_string(dot, ".");

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

Py_ssize_t stack_size;

struct compiler_unit *u = c->u;

PyObject *name, *base, *dot_str, *dot_locals_str;

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) {

dot_locals_str = _PyUnicode_FromId(&dot_locals);

if (dot_locals_str == NULL)

return 0;

base = PyUnicode_Concat(parent->u_qualname, dot_locals_str);

if (base == NULL)

return 0;

}

else {

Py_INCREF(parent->u_qualname);

base = parent->u_qualname;

}

}

}

if (base != NULL) {

dot_str = _PyUnicode_FromId(&dot);

if (dot_str == NULL) {

Py_DECREF(base);

return 0;

}

name = PyUnicode_Concat(base, dot_str);

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 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_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 > (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 = 1;

b = c->u->u_curblock;

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

}

static int

stack_effect(int opcode, int oparg, int jump)

{

switch (opcode) {

case NOP:

case EXTENDED_ARG:

return 0;

/* Stack manipulation */

case POP_TOP:

return -1;

case ROT_TWO:

case ROT_THREE:

case ROT_FOUR:

return 0;

case DUP_TOP:

return 1;

case DUP_TOP_TWO:

return 2;

/* Unary operators */

case UNARY_POSITIVE:

case UNARY_NEGATIVE:

case UNARY_NOT:

case UNARY_INVERT:

return 0;

case SET_ADD:

case LIST_APPEND:

return -1;

case MAP_ADD:

return -2;

/* Binary operators */

case BINARY_POWER:

case BINARY_MULTIPLY:

case BINARY_MATRIX_MULTIPLY:

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 INPLACE_ADD:

case INPLACE_SUBTRACT:

case INPLACE_MULTIPLY:

case INPLACE_MATRIX_MULTIPLY:

case INPLACE_MODULO:

return -1;

case STORE_SUBSCR:

return -3;

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 LOAD_BUILD_CLASS:

return 1;

case INPLACE_LSHIFT:

case INPLACE_RSHIFT:

case INPLACE_AND:

case INPLACE_XOR:

case INPLACE_OR:

return -1;

case SETUP_WITH:

/* 1 in the normal flow.

return jump ? 6 : 1;

case WITH_CLEANUP_START:

return 2; /* or 1, depending on TOS */

case WITH_CLEANUP_FINISH:

/* Pop a variable number of values pushed by WITH_CLEANUP_START

return -3;

case RETURN_VALUE:

return -1;

case IMPORT_STAR:

return -1;

case SETUP_ANNOTATIONS:

return 0;

case YIELD_VALUE:

return 0;

case YIELD_FROM:

return -1;

case POP_BLOCK:

return 0;

case POP_EXCEPT:

return -3;

case END_FINALLY:

case POP_FINALLY:

/* Pop 6 values when an exception was raised. */

return -6;

case STORE_NAME:

return -1;

case DELETE_NAME:

return 0;

case UNPACK_SEQUENCE:

return oparg-1;

case UNPACK_EX:

return (oparg&0xFF) + (oparg>>8);

case FOR_ITER:

/* -1 at end of iterator, 1 if continue iterating. */

return jump > 0 ? -1 : 1;

case STORE_ATTR:

return -2;

case DELETE_ATTR:

return -1;

case STORE_GLOBAL:

return -1;

case DELETE_GLOBAL:

return 0;

case LOAD_CONST:

return 1;

case LOAD_NAME:

return 1;

case BUILD_TUPLE:

case BUILD_LIST:

case BUILD_SET:

case BUILD_STRING:

return 1-oparg;

case BUILD_LIST_UNPACK:

case BUILD_TUPLE_UNPACK:

case BUILD_TUPLE_UNPACK_WITH_CALL: