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

Copyright 1991-1995 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 or Corporation for National Research Initiatives or

CNRI not be used in advertising or publicity pertaining to

distribution of the software without specific, written prior

permission.

While CWI is the initial source for this software, a modified version

is made available by the Corporation for National Research Initiatives

(CNRI) at the Internet address ftp://ftp.python.org.

STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH

REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF

MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH

CENTRUM OR CNRI 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 add __doc__ attribute == co_doc to code object attributes?

XXX (it's currently the first item of the co_const tuple)

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

XXX Allow 'continue' inside try-finally

XXX get rid of SET_LINENO instructions, use JAR's table trick

XXX (need an option to put them back in, for debugger!)

XXX New 1-byte opcode for loading None

XXX New opcode for loading the initial index for a for loop

XXX other JAR tricks?

*/

#ifndef NO_PRIVATE_NAME_MANGLING

#define PRIVATE_NAME_MANGLING

#endif

#include "allobjects.h"

#include "node.h"

#include "token.h"

#include "graminit.h"

#include "compile.h"

#include "opcode.h"

#include "structmember.h"

#include <ctype.h>

#include <errno.h>

#define OP_DELETE 0

#define OP_ASSIGN 1

#define OP_APPLY 2

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

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

{"co_name", T_OBJECT, OFF(co_name), 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);

XDECREF(co->co_name);

XDECREF(co->co_varnames);

DEL(co);

}

static object *

code_repr(co)

codeobject *co;

{

char buf[500];

int lineno = -1;

char *p = GETSTRINGVALUE(co->co_code);

char *filename = "???";

char *name = "???";

if (*p == SET_LINENO)

lineno = (p[1] & 0xff) | ((p[2] & 0xff) << 8);

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

filename = getstringvalue(co->co_filename);

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

name = getstringvalue(co->co_name);

sprintf(buf, "<code object %.100s at %lx, file \"%.300s\", line %d>",

name, (long)co, filename, lineno);

return newstringobject(buf);

}

static int

code_compare(co, cp)

codeobject *co, *cp;

{

int cmp;

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

if (cmp) return cmp;

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

if (cmp) return cmp;

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

if (cmp) return cmp;

cmp = cmpobject((object *)co->co_code, (object *)cp->co_code);

if (cmp) return cmp;

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

if (cmp) return cmp;

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

if (cmp) return cmp;

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

return cmp;

}

static long

code_hash(co)

codeobject *co;

{

long h, h1, h2, h3, h4;

h1 = hashobject((object *)co->co_code);

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

h2 = hashobject(co->co_consts);

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

h3 = hashobject(co->co_names);

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

h4 = hashobject(co->co_varnames);

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

h = h1 ^ h2 ^ h3 ^ h4 ^

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

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

return h;

}

typeobject Codetype = {

OB_HEAD_INIT(&Typetype)

0,

"code",

sizeof(codeobject),

0,

(destructor)code_dealloc, /*tp_dealloc*/

0, /*tp_print*/

(getattrfunc)code_getattr, /*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*/

};

codeobject *

newcodeobject(argcount, nlocals, stacksize, flags,

code, consts, names, varnames, filename, name)

int argcount;

int nlocals;

int stacksize;

int flags;

object *code;

object *consts;

object *names;

object *varnames;

object *filename;

object *name;

{

codeobject *co;

int i;

/* Check argument types */

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

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

consts == NULL || !is_tupleobject(consts) ||

names == NULL || !is_tupleobject(names) ||

varnames == NULL || !is_tupleobject(varnames) ||

name == NULL || !is_stringobject(name) ||

filename == NULL || !is_stringobject(filename)) {

err_badcall();

return NULL;

}

/* Make sure names and varnames are all strings */

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

object *v = gettupleitem(names, i);

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

err_badcall();

return NULL;

}

}

for (i = gettuplesize(varnames); --i >= 0; ) {

object *v = gettupleitem(varnames, i);

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

err_badcall();

return NULL;

}

}

co = NEWOBJ(codeobject, &Codetype);

if (co != NULL) {

co->co_argcount = argcount;

co->co_nlocals = nlocals;

co->co_stacksize = stacksize;

co->co_flags = flags;

INCREF(code);

co->co_code = (stringobject *)code;

INCREF(consts);

co->co_consts = consts;

INCREF(names);

co->co_names = names;

INCREF(varnames);

co->co_varnames = varnames;

INCREF(filename);

co->co_filename = filename;

INCREF(name);

co->co_name = name;

}

return co;

}

/* Data structure used internally */

struct compiling {

object *c_code; /* string */

object *c_consts; /* list of objects */

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

object *c_globals; /* dictionary (value=None) */

object *c_locals; /* dictionary (value=localID) */

object *c_varnames; /* list (inverse of c_locals) */

int c_nlocals; /* index of next local */

int c_argcount; /* number of top-level arguments */

int c_flags; /* same as co_flags */

int c_nexti; /* index into c_code */

int c_errors; /* counts errors occurred */

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

int c_interactive; /* generating code for interactive command */

int c_loops; /* counts nested loops */

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

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

int c_nblocks; /* current block stack level */

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

char *c_name; /* name of object (e.g. function) */

int c_lineno; /* Current line number */

int c_stacklevel; /* Current stack level */

int c_maxstacklevel; /* Maximum stack level */

#ifdef PRIVATE_NAME_MANGLING

char *c_private; /* for private name mangling */

#endif

};

/* Error message including line number */

static void

com_error(c, exc, msg)

struct compiling *c;

object *exc;

char *msg;

{

int n = strlen(msg);

object *v;

char buffer[30];

char *s;

c->c_errors++;

if (c->c_lineno <= 1) {

/* Unknown line number or single interactive command */

err_setstr(exc, msg);

return;

}

sprintf(buffer, " (line %d)", c->c_lineno);

v = newsizedstringobject((char *)NULL, n + strlen(buffer));

if (v == NULL)

return; /* MemoryError, too bad */

s = GETSTRINGVALUE((stringobject *)v);

strcpy(s, msg);

strcat(s, buffer);

err_setval(exc, v);

DECREF(v);

}

/* Interface to the block stack */

static void

block_push(c, type)

struct compiling *c;

int type;

{

if (c->c_nblocks >= CO_MAXBLOCKS) {

com_error(c, SystemError, "too many statically nested blocks");

}

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

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

}

}

/* Prototype forward declarations */

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

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

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

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

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

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

static void com_factor 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_argdefs PROTO((struct compiling *, node *));

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

static codeobject *icompile PROTO((struct _node *, struct compiling *));

static codeobject *jcompile PROTO((struct _node *, char *, struct compiling *));

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;

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

goto fail_00;

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

goto fail_000;

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;

return 1;

fail_000:

DECREF(c->c_locals);

fail_00:

DECREF(c->c_globals);

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

XDECREF(c->c_locals);

XDECREF(c->c_varnames);

}

static void

com_push(c, n)

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

struct compiling *c;

int n;

{

if (c->c_stacklevel < n) {

fprintf(stderr,

"%s:%d: underflow! nexti=%d, level=%d, n=%d\n",

c->c_filename, c->c_lineno,

c->c_nexti, c->c_stacklevel, n);

c->c_stacklevel = 0;

}

else

c->c_stacklevel -= n;

}

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;

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

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

/*

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

fatal("com_addbyte: byte out of range");

*/

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

}

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;

{

if (op == SET_LINENO)

c->c_lineno = 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);

}

#ifdef PRIVATE_NAME_MANGLING

static int

com_mangle(c, name, buffer, maxlen)

struct compiling *c;

char *name;

char *buffer;

int maxlen;

{

/* Name mangling: __private becomes _classname__private.

This is independent from how the name is used. */

char *p;

int nlen, plen;

nlen = strlen(name);

if (nlen+2 >= maxlen)

return 0; /* Don't mangle __extremely_long_names */

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

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

p = c->c_private;

/* Strip leading underscores from class name */

while (*p == '_')

p++;

if (*p == '\0')

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

plen = strlen(p);

if (plen + nlen >= maxlen)

plen = maxlen-nlen-2; /* Truncate class name if too long */

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

buffer[0] = '_';

strncpy(buffer+1, p, plen);

strcpy(buffer+1+plen, name);

/* fprintf(stderr, "mangle %s -> %s\n", name, buffer); */

return 1;

}

#endif

static void

com_addopnamestr(c, op, name)

struct compiling *c;

int op;

char *name;

{

object *v;

int i;

#ifdef PRIVATE_NAME_MANGLING

char buffer[256];

if (name != NULL && name[0] == '_' && name[1] == '_' &&

c->c_private != NULL &&

com_mangle(c, name, buffer, (int)sizeof(buffer)))

name = buffer;

#endif

if (name == NULL || (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 void

com_addopname(c, op, n)

struct compiling *c;

int op;

node *n;

{

char *name;

char buffer[1000];

/* XXX it is possible to write this code without the 1000

chars on the total length of dotted names, I just can't be

bothered right now */

if (TYPE(n) == STAR)

name = "*";

else if (TYPE(n) == dotted_name) {

char *p = buffer;

int i;

name = buffer;

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

char *s = STR(CHILD(n, i));

if (p + strlen(s) > buffer + (sizeof buffer) - 2) {

com_error(c, MemoryError,

"dotted_name too long");

name = NULL;

break;

}

if (p != buffer)

*p++ = '.';

strcpy(p, s);

p = strchr(p, '\0');

}

}

else {

REQ(n, NAME);

name = STR(n);

}

com_addopnamestr(c, op, name);

}

static object *

parsenumber(co, s)

struct compiling *co;

char *s;

{

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

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

extern double atof PROTO((const char *));

char *end;

long x;

#ifndef WITHOUT_COMPLEX

Py_complex c;

int imflag;

#endif

errno = 0;

end = s + strlen(s) - 1;

#ifndef WITHOUT_COMPLEX

imflag = *end == 'j' || *end == 'J';

#endif

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

return long_scan(s, 0);

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

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

else

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

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

if (errno != 0) {

com_error(co, OverflowError,

"integer literal too large");

return NULL;

}

return newintobject(x);

}

/* XXX Huge floats may silently fail */

#ifndef WITHOUT_COMPLEX

if (imflag) {

c.real = 0.;

c.imag = atof(s);

return newcomplexobject(c);

}

else

#endif

return newfloatobject(atof(s));

}

static object *

parsestr(s)

char *s;

{

object *v;

int len;

char *buf;

char *p;

char *end;

int c;

int quote = *s;

if (quote != '\'' && quote != '\"') {

err_badcall();

return NULL;

}

s++;

len = strlen(s);

if (s[--len] != quote) {

err_badcall();

return NULL;

}

if (len >= 4 && s[0] == quote && s[1] == quote) {

s += 2;

len -= 2;

if (s[--len] != quote || s[--len] != quote) {

err_badcall();

return NULL;

}

}

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

return newsizedstringobject(s, len);

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

p = buf = getstringvalue(v);

end = s + len;

while (s < end) {

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

*p++ = *s++;

continue;

}

s++;

switch (*s++) {

/* XXX This assumes ASCII! */

case '\n': break;

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

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(Py_CHARMASK(*s))) {

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

*p++ = c;

do {

s++;

} while (isxdigit(Py_CHARMASK(*s)));

break;

}

/* FALLTHROUGH */

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

}

}

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

return v;

}

static object *

parsestrplus(n)

node *n;

{

object *v;

int i;

REQ(CHILD(n, 0), STRING);

if ((v = parsestr(STR(CHILD(n, 0)))) != NULL) {

/* String literal concatenation */

for (i = 1; i < NCH(n) && v != NULL; i++) {

joinstring_decref(&v, parsestr(STR(CHILD(n, i))));

}

}

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

com_pop(c, len-1);

}

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_push(c, 1);

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

com_pop(c, 3);

}

}

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

com_push(c, 1);

}

else

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

break;

case LSQB:

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

com_addoparg(c, BUILD_LIST, 0);

com_push(c, 1);

}

else

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

break;

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

com_addoparg(c, BUILD_MAP, 0);

com_push(c, 1);

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(c, STR(ch))) == NULL) {

i = 255;

}

else {

i = com_addconst(c, v);

DECREF(v);

}

com_addoparg(c, LOAD_CONST, i);

com_push(c, 1);

break;

case STRING:

v = parsestrplus(n);

if (v == NULL) {

c->c_errors++;

i = 255;

}

else {

i = com_addconst(c, v);

DECREF(v);

}

com_addoparg(c, LOAD_CONST, i);

com_push(c, 1);

break;

case NAME:

com_addopname(c, LOAD_NAME, ch);

com_push(c, 1);

break;

default:

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

com_error(c, SystemError, "com_atom: unexpected node type");

}

}

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

}

com_pop(c, 1);

}

else {

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

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

com_addbyte(c, op+3);

com_pop(c, 2);

}

}

static void

com_argument(c, n, pkeywords)

struct compiling *c;

node *n; /* argument */

object **pkeywords;

{

node *m;

REQ(n, argument); /* [test '='] test; really [keyword '='] test */

if (NCH(n) == 1) {

if (*pkeywords != NULL) {

com_error(c, SyntaxError,

"non-keyword arg after keyword arg");

}

else {

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

}

return;

}

m = n;

do {

m = CHILD(m, 0);

} while (NCH(m) == 1);

if (TYPE(m) != NAME) {

com_error(c, SyntaxError, "keyword can't be an expression");

}

else {

object *v = newstringobject(STR(m));

if (v != NULL && *pkeywords == NULL)

*pkeywords = newdictobject();

if (v == NULL || *pkeywords == NULL)

c->c_errors++;

else {

if (dict2lookup(*pkeywords, v) != NULL)

com_error(c, SyntaxError,

"duplicate keyword argument");

else

if (dict2insert(*pkeywords, v, v) != 0)

c->c_errors++;