/***********************************************************

Copyright 1991, 1992 by Stichting Mathematisch Centrum, Amsterdam, The

Netherlands.

All Rights Reserved

Permission to use, copy, modify, and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appear in all copies and that

both that copyright notice and this permission notice appear in

supporting documentation, and that the names of Stichting Mathematisch

Centrum or CWI not be used in advertising or publicity pertaining to

distribution of the software without specific, written prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO

THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE

FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT

OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

/* Compile an expression node to intermediate code */

/* XXX TO DO:

XXX Compute maximum needed stack sizes while compiling

XXX Generate simple jump for break/return outside 'try...finally'

XXX Include function name in code (and module names?)

*/

#include "allobjects.h"

#include "node.h"

#include "token.h"

#include "graminit.h"

#include "compile.h"

#include "opcode.h"

#include "structmember.h"

#include <ctype.h>

extern int errno;

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

static struct memberlist code_memberlist[] = {

{"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_filename", T_OBJECT, OFF(co_filename), READONLY},

{NULL} /* Sentinel */

};

static object *

code_getattr(co, name)

codeobject *co;

char *name;

{

return getmember((char *)co, code_memberlist, name);

}

static void

code_dealloc(co)

codeobject *co;

{

XDECREF(co->co_code);

XDECREF(co->co_consts);

XDECREF(co->co_names);

XDECREF(co->co_filename);

DEL(co);

}

typeobject Codetype = {

OB_HEAD_INIT(&Typetype)

0,

"code",

sizeof(codeobject),

0,

code_dealloc, /*tp_dealloc*/

0, /*tp_print*/

code_getattr, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare*/

0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

};

codeobject *

newcodeobject(code, consts, names, filename)

object *code;

object *consts;

object *names;

object *filename;

{

codeobject *co;

int i;

/* Check argument types */

if (code == NULL || !is_stringobject(code) ||

consts == NULL || !is_listobject(consts) ||

names == NULL || !is_listobject(names)) {

err_badcall();

return NULL;

}

/* Make sure the list of names contains only strings */

for (i = getlistsize(names); --i >= 0; ) {

object *v = getlistitem(names, i);

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

err_badcall();

return NULL;

}

}

co = NEWOBJ(codeobject, &Codetype);

if (co != NULL) {

INCREF(code);

co->co_code = (stringobject *)code;

INCREF(consts);

co->co_consts = consts;

INCREF(names);

co->co_names = names;

INCREF(filename);

co->co_filename = filename;

}

return co;

}

/* Data structure used internally */

#define MAXBLOCKS 20 /* Max static block nesting within a function */

struct compiling {

object *c_code; /* string */

object *c_consts; /* list of objects */

object *c_names; /* list of strings (names) */

object *c_globals; /* dictionary */

int c_nexti; /* index into c_code */

int c_errors; /* counts errors occurred */

int c_infunction; /* set when compiling a function */

int c_loops; /* counts nested loops */

int c_begin; /* begin of current loop, for 'continue' */

int c_block[MAXBLOCKS]; /* stack of block types */

int c_nblocks; /* current block stack level */

char *c_filename; /* filename of current node */

};

/* Interface to the block stack */

static void

block_push(c, type)

struct compiling *c;

int type;

{

if (c->c_nblocks >= MAXBLOCKS) {

err_setstr(SystemError, "too many statically nested blocks");

c->c_errors++;

}

else {

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

}

}

static void

block_pop(c, type)

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

err_setstr(SystemError, "bad block pop");

c->c_errors++;

}

}

/* Prototypes */

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

static void com_free PROTO((struct compiling *));

static void com_done PROTO((struct compiling *));

static void com_node PROTO((struct compiling *, struct _node *));

static void com_addbyte PROTO((struct compiling *, int));

static void com_addint PROTO((struct compiling *, int));

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

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

static void com_backpatch PROTO((struct compiling *, int));

static int com_add PROTO((struct compiling *, object *, object *));

static int com_addconst PROTO((struct compiling *, object *));

static int com_addname PROTO((struct compiling *, object *));

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

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

static int

com_init(c, filename)

struct compiling *c;

char *filename;

{

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

goto fail_3;

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

goto fail_2;

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

goto fail_1;

if ((c->c_globals = newdictobject()) == NULL)

goto fail_0;

c->c_nexti = 0;

c->c_errors = 0;

c->c_infunction = 0;

c->c_loops = 0;

c->c_begin = 0;

c->c_nblocks = 0;

c->c_filename = filename;

return 1;

fail_0:

DECREF(c->c_names);

fail_1:

DECREF(c->c_consts);

fail_2:

DECREF(c->c_code);

fail_3:

return 0;

}

static void

com_free(c)

struct compiling *c;

{

XDECREF(c->c_code);

XDECREF(c->c_consts);

XDECREF(c->c_names);

XDECREF(c->c_globals);

}

static void

com_done(c)

struct compiling *c;

{

if (c->c_code != NULL)

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

}

static void

com_addbyte(c, byte)

struct compiling *c;

int byte;

{

int len;

if (byte < 0 || byte > 255) {

/*

fprintf(stderr, "XXX compiling bad byte: %d\n", byte);

abort();

*/

err_setstr(SystemError, "com_addbyte: byte out of range");

c->c_errors++;

}

if (c->c_code == NULL)

return;

len = getstringsize(c->c_code);

if (c->c_nexti >= len) {

if (resizestring(&c->c_code, len+1000) != 0) {

c->c_errors++;

return;

}

}

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

}

static void

com_addint(c, x)

struct compiling *c;

int x;

{

com_addbyte(c, x & 0xff);

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

}

static void

com_addoparg(c, op, arg)

struct compiling *c;

int op;

int arg;

{

com_addbyte(c, op);

com_addint(c, arg);

}

static void

com_addfwref(c, op, p_anchor)

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(c, anchor)

struct compiling *c;

int anchor; /* Must be nonzero */

{

unsigned char *code = (unsigned char *) getstringvalue(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;

code[anchor+1] = dist >> 8;

if (!prev)

break;

anchor -= prev;

}

}

/* Handle literals and names uniformly */

static int

com_add(c, list, v)

struct compiling *c;

object *list;

object *v;

{

int n = getlistsize(list);

int i;

for (i = n; --i >= 0; ) {

object *w = getlistitem(list, i);

if (v->ob_type == w->ob_type && cmpobject(v, w) == 0)

return i;

}

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

c->c_errors++;

return n;

}

static int

com_addconst(c, v)

struct compiling *c;

object *v;

{

return com_add(c, c->c_consts, v);

}

static int

com_addname(c, v)

struct compiling *c;

object *v;

{

return com_add(c, c->c_names, v);

}

static void

com_addopname(c, op, n)

struct compiling *c;

int op;

node *n;

{

object *v;

int i;

char *name;

if (TYPE(n) == STAR)

name = "*";

else {

REQ(n, NAME);

name = STR(n);

}

if ((v = newstringobject(name)) == NULL) {

c->c_errors++;

i = 255;

}

else {

i = com_addname(c, v);

DECREF(v);

}

/* Hack to replace *_NAME opcodes by *_GLOBAL if necessary */

switch (op) {

case LOAD_NAME:

case STORE_NAME:

case DELETE_NAME:

if (dictlookup(c->c_globals, name) != NULL) {

switch (op) {

case LOAD_NAME: op = LOAD_GLOBAL; break;

case STORE_NAME: op = STORE_GLOBAL; break;

case DELETE_NAME: op = DELETE_GLOBAL; break;

}

}

}

com_addoparg(c, op, i);

}

static object *

parsenumber(s)

char *s;

{

extern long strtol PROTO((const char *, char **, int));

extern unsigned long strtoul PROTO((const char *, char **, int));

extern double strtod PROTO((const char *, char **));

char *end;

long x;

double xx;

errno = 0;

end = s + strlen(s) - 1;

if (*end == 'l' || *end == 'L')

return long_scan(s, 0);

if (s[0] == '0')

x = (long) strtoul(s, &end, 0);

else

x = strtol(s, &end, 0);

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

if (errno != 0) {

err_setstr(OverflowError,

"integer literal too large");

return NULL;

}

return newintobject(x);

}

errno = 0;

xx = strtod(s, &end);

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

#ifndef BROKEN_STRTOD

/* Some strtod() versions (e.g., in older SunOS systems)

set errno incorrectly; better to ignore overflows

than not to be able to use float literals at all! */

if (errno != 0) {

err_setstr(OverflowError, "float literal too large");

return NULL;

}

#endif

return newfloatobject(xx);

}

err_setstr(SystemError, "bad number syntax?!?!");

return NULL;

}

static object *

parsestr(s)

char *s;

{

object *v;

int len;

char *buf;

char *p;

int c;

if (*s != '\'') {

err_badcall();

return NULL;

}

s++;

len = strlen(s);

if (s[--len] != '\'') {

err_badcall();

return NULL;

}

if (strchr(s, '\\') == NULL)

return newsizedstringobject(s, len);

v = newsizedstringobject((char *)NULL, len);

p = buf = getstringvalue(v);

while (*s != '\0' && *s != '\'') {

if (*s != '\\') {

*p++ = *s++;

continue;

}

s++;

switch (*s++) {

/* XXX This assumes ASCII! */

case '\\': *p++ = '\\'; break;

case '\'': *p++ = '\''; break;

case 'b': *p++ = '\b'; break;

case 'f': *p++ = '\014'; break; /* FF */

case 't': *p++ = '\t'; break;

case 'n': *p++ = '\n'; break;

case 'r': *p++ = '\r'; break;

case 'v': *p++ = '\013'; break; /* VT */

case 'a': *p++ = '\007'; break; /* BEL, not classic C */

case '0': case '1': case '2': case '3':

case '4': case '5': case '6': case '7':

c = s[-1] - '0';

if ('0' <= *s && *s <= '7') {

c = (c<<3) + *s++ - '0';

if ('0' <= *s && *s <= '7')

c = (c<<3) + *s++ - '0';

}

*p++ = c;

break;

case 'x':

if (isxdigit(*s)) {

sscanf(s, "%x", &c);

*p++ = c;

do {

s++;

} while (isxdigit(*s));

break;

}

/* FALLTHROUGH */

default: *p++ = '\\'; *p++ = s[-1]; break;

}

}

resizestring(&v, (int)(p - buf));

return v;

}

static void

com_list_constructor(c, n)

struct compiling *c;

node *n;

{

int len;

int i;

if (TYPE(n) != testlist)

REQ(n, exprlist);

/* exprlist: expr (',' expr)* [',']; likewise for testlist */

len = (NCH(n) + 1) / 2;

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

com_node(c, CHILD(n, i));

com_addoparg(c, BUILD_LIST, len);

}

static void

com_dictmaker(c, n)

struct compiling *c;

node *n;

{

int i;

/* dictmaker: test ':' test (',' test ':' value)* [','] */

for (i = 0; i+2 < NCH(n); i += 4) {

/* We must arrange things just right for STORE_SUBSCR.

It wants the stack to look like (value) (dict) (key) */

com_addbyte(c, DUP_TOP);

com_node(c, CHILD(n, i+2)); /* value */

com_addbyte(c, ROT_TWO);

com_node(c, CHILD(n, i)); /* key */

com_addbyte(c, STORE_SUBSCR);

}

}

static void

com_atom(c, n)

struct compiling *c;

node *n;

{

node *ch;

object *v;

int i;

REQ(n, atom);

ch = CHILD(n, 0);

switch (TYPE(ch)) {

case LPAR:

if (TYPE(CHILD(n, 1)) == RPAR)

com_addoparg(c, BUILD_TUPLE, 0);

else

com_node(c, CHILD(n, 1));

break;

case LSQB:

if (TYPE(CHILD(n, 1)) == RSQB)

com_addoparg(c, BUILD_LIST, 0);

else

com_list_constructor(c, CHILD(n, 1));

break;

case LBRACE: /* '{' [dictmaker] '}' */

com_addoparg(c, BUILD_MAP, 0);

if (TYPE(CHILD(n, 1)) != RBRACE)

com_dictmaker(c, CHILD(n, 1));

break;

case BACKQUOTE:

com_node(c, CHILD(n, 1));

com_addbyte(c, UNARY_CONVERT);

break;

case NUMBER:

if ((v = parsenumber(STR(ch))) == NULL) {

c->c_errors++;

i = 255;

}

else {

i = com_addconst(c, v);

DECREF(v);

}

com_addoparg(c, LOAD_CONST, i);

break;

case STRING:

if ((v = parsestr(STR(ch))) == NULL) {

c->c_errors++;

i = 255;

}

else {

i = com_addconst(c, v);

DECREF(v);

}

com_addoparg(c, LOAD_CONST, i);

break;

case NAME:

com_addopname(c, LOAD_NAME, ch);

break;

default:

fprintf(stderr, "node type %d\n", TYPE(ch));

err_setstr(SystemError, "com_atom: unexpected node type");

c->c_errors++;

}

}

static void

com_slice(c, n, op)

struct compiling *c;

node *n;

int op;

{

if (NCH(n) == 1) {

com_addbyte(c, op);

}

else if (NCH(n) == 2) {

if (TYPE(CHILD(n, 0)) != COLON) {

com_node(c, CHILD(n, 0));

com_addbyte(c, op+1);

}

else {

com_node(c, CHILD(n, 1));

com_addbyte(c, op+2);

}

}

else {

com_node(c, CHILD(n, 0));

com_node(c, CHILD(n, 2));

com_addbyte(c, op+3);

}

}

static void

com_apply_subscript(c, n)

struct compiling *c;

node *n;

{

REQ(n, subscript);

if (NCH(n) == 1 && TYPE(CHILD(n, 0)) != COLON) {

/* It's a single subscript */

com_node(c, CHILD(n, 0));

com_addbyte(c, BINARY_SUBSCR);

}

else {

/* It's a slice: [expr] ':' [expr] */

com_slice(c, n, SLICE);

}

}

static void

com_call_function(c, n)

struct compiling *c;

node *n; /* EITHER testlist OR ')' */

{

if (TYPE(n) == RPAR) {

com_addoparg(c, BUILD_TUPLE, 0);

com_addbyte(c, BINARY_CALL);

}

else {

REQ(n, testlist);

com_list(c, n, 1);

com_addbyte(c, BINARY_CALL);

}

}

static void

com_select_member(c, n)

struct compiling *c;

node *n;

{

com_addopname(c, LOAD_ATTR, n);

}

static void

com_apply_trailer(c, n)

struct compiling *c;

node *n;

{

REQ(n, trailer);

switch (TYPE(CHILD(n, 0))) {

case LPAR:

com_call_function(c, CHILD(n, 1));

break;

case DOT:

com_select_member(c, CHILD(n, 1));

break;

case LSQB:

com_apply_subscript(c, CHILD(n, 1));

break;

default:

err_setstr(SystemError,

"com_apply_trailer: unknown trailer type");

c->c_errors++;

}

}

static void

com_factor(c, n)

struct compiling *c;

node *n;

{

int i;

REQ(n, factor);

if (TYPE(CHILD(n, 0)) == PLUS) {

com_factor(c, CHILD(n, 1));

com_addbyte(c, UNARY_POSITIVE);

}

else if (TYPE(CHILD(n, 0)) == MINUS) {

com_factor(c, CHILD(n, 1));

com_addbyte(c, UNARY_NEGATIVE);

}

else if (TYPE(CHILD(n, 0)) == TILDE) {

com_factor(c, CHILD(n, 1));

com_addbyte(c, UNARY_INVERT);

}

else {

com_atom(c, CHILD(n, 0));

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

com_apply_trailer(c, CHILD(n, i));

}

}

static void

com_term(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, term);

com_factor(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_factor(c, CHILD(n, i));

switch (TYPE(CHILD(n, i-1))) {

case STAR:

op = BINARY_MULTIPLY;

break;

case SLASH:

op = BINARY_DIVIDE;

break;

case PERCENT:

op = BINARY_MODULO;

break;

default:

err_setstr(SystemError,

"com_term: operator not *, / or %");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static void

com_arith_expr(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, arith_expr);

com_term(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_term(c, CHILD(n, i));

switch (TYPE(CHILD(n, i-1))) {

case PLUS:

op = BINARY_ADD;

break;

case MINUS:

op = BINARY_SUBTRACT;

break;

default:

err_setstr(SystemError,

"com_arith_expr: operator not + or -");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static void

com_shift_expr(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, shift_expr);

com_arith_expr(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_arith_expr(c, CHILD(n, i));

switch (TYPE(CHILD(n, i-1))) {

case LEFTSHIFT:

op = BINARY_LSHIFT;

break;

case RIGHTSHIFT:

op = BINARY_RSHIFT;

break;

default:

err_setstr(SystemError,

"com_shift_expr: operator not << or >>");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static void

com_and_expr(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, and_expr);

com_shift_expr(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_shift_expr(c, CHILD(n, i));

if (TYPE(CHILD(n, i-1)) == AMPER) {

op = BINARY_AND;

}

else {

err_setstr(SystemError,

"com_and_expr: operator not &");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static void

com_xor_expr(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, xor_expr);

com_and_expr(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_and_expr(c, CHILD(n, i));

if (TYPE(CHILD(n, i-1)) == CIRCUMFLEX) {

op = BINARY_XOR;

}

else {

err_setstr(SystemError,

"com_xor_expr: operator not ^");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static void

com_expr(c, n)

struct compiling *c;

node *n;

{

int i;

int op;

REQ(n, expr);

com_xor_expr(c, CHILD(n, 0));

for (i = 2; i < NCH(n); i += 2) {

com_xor_expr(c, CHILD(n, i));

if (TYPE(CHILD(n, i-1)) == VBAR) {

op = BINARY_OR;

}

else {

err_setstr(SystemError,

"com_expr: expr operator not |");

c->c_errors++;

op = 255;

}

com_addbyte(c, op);

}

}

static enum cmp_op

cmp_type(n)

node *n;

{

REQ(n, comp_op);

/* comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='

| 'in' | 'not' 'in' | 'is' | 'is' not' */

if (NCH(n) == 1) {

n = CHILD(n, 0);

switch (TYPE(n)) {

case LESS: return LT;

case GREATER: return GT;

case EQEQUAL: /* == */

case EQUAL: return EQ;

case LESSEQUAL: return LE;

case GREATEREQUAL: return GE;

case NOTEQUAL: return NE; /* <> or != */

case NAME: if (strcmp(STR(n), "in") == 0) return IN;

if (strcmp(STR(n), "is") == 0) return IS;

}

}

else if (NCH(n) == 2) {

switch (TYPE(CHILD(n, 0))) {

case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0)

return NOT_IN;

if (strcmp(STR(CHILD(n, 0)), "is") == 0)

return IS_NOT;

}

}

return BAD;

}

static void

com_comparison(c, n)

struct compiling *c;

node *n;

{

int i;

enum cmp_op op;

int anchor;

REQ(n, comparison); /* comparison: expr (comp_op expr)* */

com_expr(c, CHILD(n, 0));

if (NCH(n) == 1)

return;

/****************************************************************

The following code is generated for all but the last

comparison in a chain:

label: on stack: opcode: jump to:

a <code to load b>

a, b DUP_TOP

a, b, b ROT_THREE

b, a, b COMPARE_OP

b, 0-or-1 JUMP_IF_FALSE L1

b, 1 POP_TOP

b

We are now ready to repeat this sequence for the next

comparison in the chain.

For the last we generate:

b <code to load c>

b, c COMPARE_OP

0-or-1

If there were any jumps to L1 (i.e., there was more than one

comparison), we generate:

0-or-1 JUMP_FORWARD L2

L1: b, 0 ROT_TWO

0, b POP_TOP

0

L2:

****************************************************************/

anchor = 0;

for (i = 2; i < NCH(n); i += 2) {

com_expr(c, CHILD(n, i));

if (i+2 < NCH(n)) {

com_addbyte(c, DUP_TOP);

com_addbyte(c, ROT_THREE);

}

op = cmp_type(CHILD(n, i-1));

if (op == BAD) {

err_setstr(SystemError,

"com_comparison: unknown comparison op");

c->c_errors++;

}

com_addoparg(c, COMPARE_OP, op);

if (i+2 < NCH(n)) {

com_addfwref(c, JUMP_IF_FALSE, &anchor);

com_addbyte(c, POP_TOP);

}

}

if (anchor) {

int anchor2 = 0;

com_addfwref(c, JUMP_FORWARD, &anchor2);

com_backpatch(c, anchor);

com_addbyte(c, ROT_TWO);

com_addbyte(c, POP_TOP);

com_backpatch(c, anchor2);

}

}

static void

com_not_test(c, n)

struct compiling *c;