/* 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 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(PyCodeObject *co, char *name)

{

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

}

static void

code_dealloc(PyCodeObject *co)

{

Py_XDECREF(co->co_code);

Py_XDECREF(co->co_consts);

Py_XDECREF(co->co_names);

Py_XDECREF(co->co_varnames);

Py_XDECREF(co->co_filename);

Py_XDECREF(co->co_name);

Py_XDECREF(co->co_lnotab);

PyObject_DEL(co);

}

static PyObject *

code_repr(PyCodeObject *co)

{

char buf[500];

int lineno = -1;

char *filename = "???";

char *name = "???";

if (co->co_firstlineno != 0)

lineno = co->co_firstlineno;

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 %p, file \"%.300s\", line %d>",

name, co, filename, lineno);

return PyString_FromString(buf);

}

static int

code_compare(PyCodeObject *co, PyCodeObject *cp)

{

int cmp;

cmp = PyObject_Compare(co->co_name, cp->co_name);

if (cmp) return cmp;

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

if (cmp) return cmp;

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

if (cmp) return cmp;

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

if (cmp) return cmp;

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

{

long h, h0, h1, h2, h3, h4;

h0 = PyObject_Hash(co->co_name);

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

h1 = PyObject_Hash(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 = h0 ^ 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"

/* all_name_chars(s): true iff all chars in s are valid NAME_CHARS */

static int

all_name_chars(unsigned char *s)

{

static char ok_name_char[256];

static unsigned char *name_chars = NAME_CHARS;

if (ok_name_char[*name_chars] == 0) {

unsigned char *p;

for (p = name_chars; *p; p++)

ok_name_char[*p] = 1;

}

while (*s) {

if (ok_name_char[*s++] == 0)

return 0;

}

return 1;

}

PyCodeObject *

PyCode_New(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;

PyBufferProcs *pb;

/* Check argument types */

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

code == NULL ||

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;

}

pb = code->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getreadbuffer == NULL ||

pb->bf_getsegcount == NULL ||

(*pb->bf_getsegcount)(code, NULL) != 1)

{

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

if (!PyString_Check(v))

continue;

if (!all_name_chars((unsigned char *)PyString_AsString(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 = 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_const_dict; /* inverse of c_consts */

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

PyObject *c_name_dict; /* inverse of c_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

int c_tmpname; /* temporary local name counter */

};

/* Error message including line number */

static void

com_error(struct compiling *c, PyObject *exc, char *msg)

{

PyObject *v, *tb, *tmp;

c->c_errors++;

if (c->c_lineno <= 1) {

/* Unknown line number or single interactive command */

PyErr_SetString(exc, msg);

return;

}

v = PyString_FromString(msg);

if (v == NULL)

return; /* MemoryError, too bad */

PyErr_SetObject(exc, v);

Py_DECREF(v);

/* add attributes for the line number and filename for the error */

PyErr_Fetch(&exc, &v, &tb);

PyErr_NormalizeException(&exc, &v, &tb);

tmp = PyInt_FromLong(c->c_lineno);

if (tmp == NULL)

PyErr_Clear();

else {

if (PyObject_SetAttrString(v, "lineno", tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

if (c->c_filename != NULL) {

tmp = PyString_FromString(c->c_filename);

if (tmp == NULL)

PyErr_Clear();

else {

if (PyObject_SetAttrString(v, "filename", tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

}

PyErr_Restore(exc, v, tb);

}

/* Interface to the block stack */

static void

block_push(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(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(struct compiling *, char *);

static void com_free(struct compiling *);

static void com_push(struct compiling *, int);

static void com_pop(struct compiling *, int);

static void com_done(struct compiling *);

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

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

static void com_addbyte(struct compiling *, int);

static void com_addint(struct compiling *, int);

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

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

static void com_backpatch(struct compiling *, int);

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

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

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

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

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

static void com_list_iter(struct compiling *, node *, node *, char *);

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

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

static void com_assign(struct compiling *, node *, int, node *);

static void com_assign_name(struct compiling *, node *, int);

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

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

struct compiling *);

static PyObject *parsestrplus(node *);

static PyObject *parsestr(char *);

static node *get_rawdocstring(node *);

static int

com_init(struct compiling *c, char *filename)

{

memset((void *)c, '\0', sizeof(struct compiling));

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

1000)) == NULL)

goto fail;

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

goto fail;

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

goto fail;

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

goto fail;

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

goto fail;

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

goto fail;

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

goto fail;

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

goto fail;

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

1000)) == NULL)

goto fail;

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;

c->c_tmpname = 0;

return 1;

fail:

com_free(c);

return 0;

}

static void

com_free(struct compiling *c)

{

Py_XDECREF(c->c_code);

Py_XDECREF(c->c_consts);

Py_XDECREF(c->c_const_dict);

Py_XDECREF(c->c_names);

Py_XDECREF(c->c_name_dict);

Py_XDECREF(c->c_globals);

Py_XDECREF(c->c_locals);

Py_XDECREF(c->c_varnames);

Py_XDECREF(c->c_lnotab);

}

static void

com_push(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(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(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(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(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(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(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(struct compiling *c, int op, int arg)

{

int extended_arg = arg >> 16;

if (op == SET_LINENO) {

com_set_lineno(c, arg);

if (Py_OptimizeFlag)

return;

}

if (extended_arg){

com_addbyte(c, EXTENDED_ARG);

com_addint(c, extended_arg);

arg &= 0xffff;

}

com_addbyte(c, op);

com_addint(c, arg);

}

static void

com_addfwref(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(struct compiling *c, int anchor)

{

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;

dist >>= 8;

code[anchor+1] = dist;

dist >>= 8;

if (dist) {

com_error(c, PyExc_SystemError,

"com_backpatch: offset too large");

break;

}

if (!prev)

break;

anchor -= prev;

}

}

/* Handle literals and names uniformly */

static int

com_add(struct compiling *c, PyObject *list, PyObject *dict, PyObject *v)

{

PyObject *w, *t, *np=NULL;

long n;

t = Py_BuildValue("(OO)", v, v->ob_type);

if (t == NULL)

goto fail;

w = PyDict_GetItem(dict, t);

if (w != NULL) {

n = PyInt_AsLong(w);

} else {

n = PyList_Size(list);

np = PyInt_FromLong(n);

if (np == NULL)

goto fail;

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

goto fail;

if (PyDict_SetItem(dict, t, np) != 0)

goto fail;

Py_DECREF(np);

}

Py_DECREF(t);

return n;

fail:

Py_XDECREF(np);

Py_XDECREF(t);

c->c_errors++;

return 0;

}

static int

com_addconst(struct compiling *c, PyObject *v)

{

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

}

static int

com_addname(struct compiling *c, PyObject *v)

{

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

}

#ifdef PRIVATE_NAME_MANGLING

static int

com_mangle(struct compiling *c, char *name, char *buffer, size_t maxlen)

{

/* Name mangling: __private becomes _classname__private.

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

char *p;

size_t 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(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, 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(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(struct compiling *co, char *s)

{

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

{

PyObject *v;

size_t len;

char *buf;

char *p;

char *end;

int c;

int first = *s;

int quote = first;

int rawmode = 0;

int unicode = 0;

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

if (quote == 'u' || quote == 'U') {

quote = *++s;

unicode = 1;

}

if (quote == 'r' || quote == 'R') {

quote = *++s;

rawmode = 1;

}

}

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

PyErr_BadInternalCall();

return NULL;

}

s++;

len = strlen(s);

if (len > INT_MAX) {

PyErr_SetString(PyExc_OverflowError, "string to parse is too long");

return NULL;

}

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 (unicode || Py_UnicodeFlag) {

if (rawmode)

return PyUnicode_DecodeRawUnicodeEscape(

s, len, NULL);

else

return PyUnicode_DecodeUnicodeEscape(

s, len, NULL);

}

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

return PyString_FromStringAndSize(s, len);

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

if (v == NULL)

return NULL;

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[0])) && isxdigit(Py_CHARMASK(s[1]))) {

unsigned int x = 0;

c = Py_CHARMASK(*s);

s++;

if (isdigit(c))

x = c - '0';

else if (islower(c))

x = 10 + c - 'a';

else

x = 10 + c - 'A';

x = x << 4;

c = Py_CHARMASK(*s);

s++;

if (isdigit(c))

x += c - '0';

else if (islower(c))

x += 10 + c - 'a';

else

x += 10 + c - 'A';

*p++ = x;

break;

}

PyErr_SetString(PyExc_ValueError, "invalid \\x escape");

Py_DECREF(v);

return NULL;

default:

*p++ = '\\';

*p++ = s[-1];

break;

}

}

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

return v;

}

static PyObject *

parsestrplus(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); i++) {

PyObject *s;

s = parsestr(STR(CHILD(n, i)));

if (s == NULL)

goto onError;

if (PyString_Check(v) && PyString_Check(s)) {

PyString_ConcatAndDel(&v, s);

if (v == NULL)

goto onError;

}

else {

PyObject *temp;

temp = PyUnicode_Concat(v, s);

Py_DECREF(s);

if (temp == NULL)

goto onError;

Py_DECREF(v);

v = temp;

}

}

}

return v;

onError:

Py_XDECREF(v);

return NULL;

}

static void

com_list_for(struct compiling *c, node *n, node *e, char *t)

{

PyObject *v;

int anchor = 0;

int save_begin = c->c_begin;