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

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 "Python.h"

#include "node.h"

#include "token.h"

#include "graminit.h"

#include "compile.h"

#include "opcode.h"

#include "structmember.h"

#include <ctype.h>

/* Three symbols from graminit.h are also defined in Python.h, with

Py_ prefixes to their names. Python.h can't include graminit.h

(which defines too many confusing symbols), but we can check here

that they haven't changed (which is very unlikely, but possible). */

#if Py_single_input != single_input

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

#endif

#if Py_file_input != file_input

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

#endif

#if Py_eval_input != eval_input

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

#endif

int Py_OptimizeFlag = 0;

#define OP_DELETE 0

#define OP_ASSIGN 1

#define OP_APPLY 2

#define OFF(x) offsetof(PyCodeObject, 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},

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

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

{NULL} /* Sentinel */

};

static PyObject *

code_getattr(co, name)

PyCodeObject *co;

char *name;

{

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

}

static void

code_dealloc(co)

PyCodeObject *co;

{

Py_XDECREF(co->co_code);

Py_XDECREF(co->co_consts);

Py_XDECREF(co->co_names);

Py_XDECREF(co->co_filename);

Py_XDECREF(co->co_name);

Py_XDECREF(co->co_varnames);

PyMem_DEL(co);

}

static PyObject *

code_repr(co)

PyCodeObject *co;

{

char buf[500];

int lineno = -1;

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

char *filename = "???";

char *name = "???";

if (*p == SET_LINENO)

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

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

filename = PyString_AsString(co->co_filename);

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

name = PyString_AsString(co->co_name);

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

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

return PyString_FromString(buf);

}

static int

code_compare(co, cp)

PyCodeObject *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 = PyObject_Compare((PyObject *)co->co_code,

(PyObject *)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);

return cmp;

}

static long

code_hash(co)

PyCodeObject *co;

{

long h, h1, h2, h3, h4;

h1 = PyObject_Hash((PyObject *)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;

h = h1 ^ h2 ^ h3 ^ h4 ^

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*/

(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*/

};

#define NAME_CHARS \

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

PyCodeObject *

PyCode_New(argcount, nlocals, stacksize, flags,

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

firstlineno, lnotab)

int argcount;

int nlocals;

int stacksize;

int flags;

PyObject *code;

PyObject *consts;

PyObject *names;

PyObject *varnames;

PyObject *filename;

PyObject *name;

int firstlineno;

PyObject *lnotab;

{

PyCodeObject *co;

int i;

/* Check argument types */

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

code == NULL || !PyString_Check(code) ||

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

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

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

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

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

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

PyErr_BadInternalCall();

return NULL;

}

/* Make sure names and varnames are all strings, & intern them */

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

PyObject *v = PyTuple_GetItem(names, i);

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

PyErr_BadInternalCall();

return NULL;

}

PyString_InternInPlace(&PyTuple_GET_ITEM(names, i));

}

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

PyObject *v = PyTuple_GetItem(varnames, i);

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

PyErr_BadInternalCall();

return NULL;

}

PyString_InternInPlace(&PyTuple_GET_ITEM(varnames, i));

}

/* Intern selected string constants */

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

PyObject *v = PyTuple_GetItem(consts, i);

char *p;

if (!PyString_Check(v))

continue;

p = PyString_AsString(v);

if ((int)strspn(p, NAME_CHARS)

!= PyString_Size(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;

Py_INCREF(code);

co->co_code = (PyStringObject *)code;

Py_INCREF(consts);

co->co_consts = consts;

Py_INCREF(names);

co->co_names = names;

Py_INCREF(varnames);

co->co_varnames = varnames;

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;

}

return co;

}

/* Data structure used internally */

struct compiling {

PyObject *c_code; /* string */

PyObject *c_consts; /* list of objects */

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

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

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

PyObject *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 */

int c_firstlineno;

PyObject *c_lnotab; /* Table mapping address to line number */

int c_last_addr, c_last_line, c_lnotab_next;

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

PyObject *exc;

char *msg;

{

int n = strlen(msg);

PyObject *v;

char buffer[30];

char *s;

c->c_errors++;

if (c->c_lineno <= 1) {

/* Unknown line number or single interactive command */

PyErr_SetString(exc, msg);

return;

}

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

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

if (v == NULL)

return; /* MemoryError, too bad */

s = PyString_AS_STRING((PyStringObject *)v);

strcpy(s, msg);

strcat(s, buffer);

PyErr_SetObject(exc, v);

Py_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, PyExc_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, PyExc_SystemError, "bad block pop");

}

}

/* Prototype forward declarations */

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

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

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

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

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

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

static void com_factor Py_PROTO((struct compiling *, struct _node *));

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

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

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

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

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

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

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

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

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

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

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

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

static PyCodeObject *icompile Py_PROTO((struct _node *, struct compiling *));

static PyCodeObject *jcompile Py_PROTO((struct _node *, char *,

struct compiling *));

static PyObject *parsestrplus Py_PROTO((node *));

static PyObject *parsestr Py_PROTO((char *));

static int

com_init(c, filename)

struct compiling *c;

char *filename;

{

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

1000)) == NULL)

goto fail_3;

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

goto fail_2;

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

goto fail_1;

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

goto fail_0;

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

goto fail_00;

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

goto fail_000;

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

1000)) == NULL)

goto fail_0000;

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;

return 1;

fail_0000:

Py_DECREF(c->c_lnotab);

fail_000:

Py_DECREF(c->c_locals);

fail_00:

Py_DECREF(c->c_globals);

fail_0:

Py_DECREF(c->c_names);

fail_1:

Py_DECREF(c->c_consts);

fail_2:

Py_DECREF(c->c_code);

fail_3:

return 0;

}

static void

com_free(c)

struct compiling *c;

{

Py_XDECREF(c->c_code);

Py_XDECREF(c->c_consts);

Py_XDECREF(c->c_names);

Py_XDECREF(c->c_globals);

Py_XDECREF(c->c_locals);

Py_XDECREF(c->c_varnames);

Py_XDECREF(c->c_lnotab);

}

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)

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

if (c->c_lnotab != NULL)

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

}

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, PyExc_SystemError,

"com_addbyte: byte out of range");

}

if (c->c_code == NULL)

return;

len = PyString_Size(c->c_code);

if (c->c_nexti >= len) {

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

c->c_errors++;

return;

}

}

PyString_AsString(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_add_lnotab(c, addr, line)

struct compiling *c;

int addr;

int line;

{

int size;

char *p;

if (c->c_lnotab == NULL)

return;

size = PyString_Size(c->c_lnotab);

if (c->c_lnotab_next+2 > size) {

if (_PyString_Resize(&c->c_lnotab, size + 1000) < 0) {

c->c_errors++;

return;

}

}

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

*p++ = addr;

*p++ = line;

c->c_lnotab_next += 2;

}

static void

com_set_lineno(c, 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 > 0 || incr_line > 0) {

int trunc_addr = incr_addr;

int trunc_line = incr_line;

if (trunc_addr > 255)

trunc_addr = 255;

if (trunc_line > 255)

trunc_line = 255;

com_add_lnotab(c, trunc_addr, trunc_line);

incr_addr -= trunc_addr;

incr_line -= trunc_line;

}

c->c_last_addr = c->c_nexti;

c->c_last_line = lineno;

}

}

static void

com_addoparg(c, op, arg)

struct compiling *c;

int op;

int arg;

{

if (op == SET_LINENO) {

com_set_lineno(c, arg);

if (Py_OptimizeFlag)

return;

}

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 *) PyString_AsString(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;

PyObject *list;

PyObject *v;

{

int n = PyList_Size(list);

int i;

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

PyObject *w = PyList_GetItem(list, i);

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

return i;

}

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

c->c_errors++;

return n;

}

static int

com_addconst(c, v)

struct compiling *c;

PyObject *v;

{

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

}

static int

com_addname(c, v)

struct compiling *c;

PyObject *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;

{

PyObject *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 = PyString_InternFromString(name)) == NULL) {

c->c_errors++;

i = 255;

}

else {

i = com_addname(c, v);

Py_DECREF(v);

}

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

switch (op) {

case LOAD_NAME:

case STORE_NAME:

case DELETE_NAME:

if (PyDict_GetItemString(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, PyExc_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 PyObject *

parsenumber(co, s)

struct compiling *co;

char *s;

{

extern long PyOS_strtol Py_PROTO((const char *, char **, int));

extern unsigned long PyOS_strtoul Py_PROTO((const char *,

char **, int));

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

char *end;

long x;

double dx;

#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 PyLong_FromString(s, (char **)0, 0);

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

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

else

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

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

if (errno != 0) {

com_error(co, PyExc_OverflowError,

"integer literal too large");

return NULL;

}

return PyInt_FromLong(x);

}

/* XXX Huge floats may silently fail */

#ifndef WITHOUT_COMPLEX

if (imflag) {

c.real = 0.;

PyFPE_START_PROTECT("atof", return 0)

c.imag = atof(s);

PyFPE_END_PROTECT(c)

return PyComplex_FromCComplex(c);

}

else {

#endif

PyFPE_START_PROTECT("atof", return 0)

dx = atof(s);

PyFPE_END_PROTECT(dx)

return PyFloat_FromDouble(dx);

}

}

static PyObject *

parsestr(s)

char *s;

{

PyObject *v;

int len;

char *buf;

char *p;

char *end;

int c;

int first = *s;

int quote = first;

if (isalpha(quote) || quote == '_')

quote = *++s;

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

PyErr_BadInternalCall();

return NULL;

}

s++;

len = strlen(s);

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

PyErr_BadInternalCall();

return NULL;

}

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

s += 2;

len -= 2;

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

PyErr_BadInternalCall();

return NULL;

}

}

if (first != quote || strchr(s, '\\') == NULL)

return PyString_FromStringAndSize(s, len);

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

p = buf = PyString_AsString(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;

}

}

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

return v;

}

static PyObject *

parsestrplus(n)

node *n;

{

PyObject *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++) {

PyString_ConcatAndDel(&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;

PyObject *v;

int i;

REQ(n, atom);