blob: 69a07af31d77f47925694a5544747dedb9f039dd [file] [log] [blame]
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001/* Compile an expression node to intermediate code */
2
Guido van Rossum3f5da241990-12-20 15:06:42 +00003/* XXX TO DO:
Guido van Rossum8b993a91997-01-17 21:04:03 +00004 XXX add __doc__ attribute == co_doc to code object attributes?
5 XXX (it's currently the first item of the co_const tuple)
Guido van Rossum3f5da241990-12-20 15:06:42 +00006 XXX Generate simple jump for break/return outside 'try...finally'
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00007 XXX Allow 'continue' inside finally clause of try-finally
Guido van Rossum8b993a91997-01-17 21:04:03 +00008 XXX New opcode for loading the initial index for a for loop
Guido van Rossum681d79a1995-07-18 14:51:37 +00009 XXX other JAR tricks?
Guido van Rossum3f5da241990-12-20 15:06:42 +000010*/
Guido van Rossum10dc2e81990-11-18 17:27:39 +000011
Guido van Rossum79f25d91997-04-29 20:08:16 +000012#include "Python.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000013
Guido van Rossum10dc2e81990-11-18 17:27:39 +000014#include "node.h"
15#include "token.h"
16#include "graminit.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000017#include "compile.h"
Jeremy Hylton4b38da62001-02-02 18:19:15 +000018#include "symtable.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000019#include "opcode.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000020#include "structmember.h"
21
22#include <ctype.h>
Guido van Rossum282914b1991-04-04 10:42:56 +000023
Guido van Rossumb05a5c71997-05-07 17:46:13 +000024/* Three symbols from graminit.h are also defined in Python.h, with
25 Py_ prefixes to their names. Python.h can't include graminit.h
26 (which defines too many confusing symbols), but we can check here
27 that they haven't changed (which is very unlikely, but possible). */
28#if Py_single_input != single_input
Guido van Rossum2f75b291997-05-20 22:18:48 +000029 #error "single_input has changed -- update Py_single_input in Python.h"
Guido van Rossumb05a5c71997-05-07 17:46:13 +000030#endif
31#if Py_file_input != file_input
Guido van Rossum2f75b291997-05-20 22:18:48 +000032 #error "file_input has changed -- update Py_file_input in Python.h"
Guido van Rossumb05a5c71997-05-07 17:46:13 +000033#endif
34#if Py_eval_input != eval_input
Guido van Rossum2f75b291997-05-20 22:18:48 +000035 #error "eval_input has changed -- update Py_eval_input in Python.h"
Guido van Rossumb05a5c71997-05-07 17:46:13 +000036#endif
37
Guido van Rossum8e793d91997-03-03 19:13:14 +000038int Py_OptimizeFlag = 0;
39
Guido van Rossum8861b741996-07-30 16:49:37 +000040#define OP_DELETE 0
41#define OP_ASSIGN 1
42#define OP_APPLY 2
43
Jeremy Hyltone36f7782001-01-19 03:21:30 +000044#define VAR_LOAD 0
45#define VAR_STORE 1
46#define VAR_DELETE 2
47
Jeremy Hylton64949cb2001-01-25 20:06:59 +000048#define DEL_CLOSURE_ERROR \
Jeremy Hyltoneab156f2001-01-30 01:24:43 +000049"can not delete variable '%.400s' referenced in nested scope"
50
51#define DUPLICATE_ARGUMENT \
52"duplicate argument '%s' in function definition"
53
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +000054#define ILLEGAL_DYNAMIC_SCOPE \
55"%.100s: exec or 'import *' makes names ambiguous in nested scope"
Jeremy Hyltoneab156f2001-01-30 01:24:43 +000056
Jeremy Hylton29906ee2001-02-27 04:23:34 +000057#define GLOBAL_AFTER_ASSIGN \
58"name '%.400s' is assigned to before global declaration"
59
60#define GLOBAL_AFTER_USE \
61"name '%.400s' is used prior to global declaration"
62
63#define LOCAL_GLOBAL \
Neal Norwitz2a47c0f2002-01-29 00:53:41 +000064"name '%.400s' is a function parameter and declared global"
Jeremy Hylton29906ee2001-02-27 04:23:34 +000065
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +000066#define LATE_FUTURE \
67"from __future__ imports must occur at the beginning of the file"
68
Jeremy Hylton897b8212001-03-23 14:08:38 +000069#define ASSIGN_DEBUG \
70"can not assign to __debug__"
71
Jeremy Hyltone36f7782001-01-19 03:21:30 +000072#define MANGLE_LEN 256
73
Guido van Rossum79f25d91997-04-29 20:08:16 +000074#define OFF(x) offsetof(PyCodeObject, x)
Guido van Rossum3f5da241990-12-20 15:06:42 +000075
Guido van Rossum6f799372001-09-20 20:46:19 +000076static PyMemberDef code_memberlist[] = {
Guido van Rossum681d79a1995-07-18 14:51:37 +000077 {"co_argcount", T_INT, OFF(co_argcount), READONLY},
78 {"co_nlocals", T_INT, OFF(co_nlocals), READONLY},
Guido van Rossum8b993a91997-01-17 21:04:03 +000079 {"co_stacksize",T_INT, OFF(co_stacksize), READONLY},
Guido van Rossum681d79a1995-07-18 14:51:37 +000080 {"co_flags", T_INT, OFF(co_flags), READONLY},
Guido van Rossum39d942d1992-01-12 02:30:05 +000081 {"co_code", T_OBJECT, OFF(co_code), READONLY},
82 {"co_consts", T_OBJECT, OFF(co_consts), READONLY},
83 {"co_names", T_OBJECT, OFF(co_names), READONLY},
Guido van Rossum681d79a1995-07-18 14:51:37 +000084 {"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},
Jeremy Hylton64949cb2001-01-25 20:06:59 +000085 {"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},
86 {"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},
Guido van Rossum39d942d1992-01-12 02:30:05 +000087 {"co_filename", T_OBJECT, OFF(co_filename), READONLY},
Guido van Rossum9bfef441993-03-29 10:43:31 +000088 {"co_name", T_OBJECT, OFF(co_name), READONLY},
Guido van Rossumda4eb5c1997-01-24 03:43:35 +000089 {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},
90 {"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY},
Guido van Rossum3f5da241990-12-20 15:06:42 +000091 {NULL} /* Sentinel */
92};
93
Guido van Rossumbea18cc2002-06-14 20:41:17 +000094PyDoc_STRVAR(code_doc,
95"code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n\
96 varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\
97\n\
98Create a code object. Not for the faint of heart.");
99
100static PyObject *
101code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
102{
103 int argcount;
104 int nlocals;
105 int stacksize;
106 int flags;
107 PyObject *code;
108 PyObject *consts;
109 PyObject *names;
110 PyObject *varnames;
111 PyObject *freevars = NULL;
112 PyObject *cellvars = NULL;
113 PyObject *filename;
114 PyObject *name;
115 int firstlineno;
116 PyObject *lnotab;
117
118 if (!PyArg_ParseTuple(args, "iiiiSO!O!O!SSiS|O!O!:code",
119 &argcount, &nlocals, &stacksize, &flags,
120 &code,
121 &PyTuple_Type, &consts,
122 &PyTuple_Type, &names,
123 &PyTuple_Type, &varnames,
124 &filename, &name,
125 &firstlineno, &lnotab,
126 &PyTuple_Type, &freevars,
127 &PyTuple_Type, &cellvars))
128 return NULL;
129
130 if (freevars == NULL || cellvars == NULL) {
131 PyObject *empty = PyTuple_New(0);
132 if (empty == NULL)
133 return NULL;
134 if (freevars == NULL) {
135 freevars = empty;
136 Py_INCREF(freevars);
137 }
138 if (cellvars == NULL) {
139 cellvars = empty;
140 Py_INCREF(cellvars);
141 }
142 Py_DECREF(empty);
143 }
144
145 if (!PyObject_CheckReadBuffer(code)) {
146 PyErr_SetString(PyExc_TypeError,
147 "bytecode object must be a single-segment read-only buffer");
148 return NULL;
149 }
150
151 return (PyObject *)PyCode_New(argcount, nlocals, stacksize, flags,
152 code, consts, names, varnames,
153 freevars, cellvars, filename, name,
154 firstlineno, lnotab);
155}
156
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000157static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000158code_dealloc(PyCodeObject *co)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000159{
Guido van Rossum79f25d91997-04-29 20:08:16 +0000160 Py_XDECREF(co->co_code);
161 Py_XDECREF(co->co_consts);
162 Py_XDECREF(co->co_names);
Guido van Rossum275558c1997-07-25 20:13:49 +0000163 Py_XDECREF(co->co_varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000164 Py_XDECREF(co->co_freevars);
165 Py_XDECREF(co->co_cellvars);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000166 Py_XDECREF(co->co_filename);
167 Py_XDECREF(co->co_name);
Guido van Rossum275558c1997-07-25 20:13:49 +0000168 Py_XDECREF(co->co_lnotab);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000169 PyObject_DEL(co);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000170}
171
Guido van Rossum79f25d91997-04-29 20:08:16 +0000172static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000173code_repr(PyCodeObject *co)
Guido van Rossum2dff9911992-09-03 20:50:59 +0000174{
175 char buf[500];
176 int lineno = -1;
Guido van Rossum2dff9911992-09-03 20:50:59 +0000177 char *filename = "???";
Guido van Rossum9bfef441993-03-29 10:43:31 +0000178 char *name = "???";
Guido van Rossumd076c731998-10-07 19:42:25 +0000179
Guido van Rossuma396a882000-04-07 01:21:36 +0000180 if (co->co_firstlineno != 0)
181 lineno = co->co_firstlineno;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000182 if (co->co_filename && PyString_Check(co->co_filename))
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000183 filename = PyString_AS_STRING(co->co_filename);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000184 if (co->co_name && PyString_Check(co->co_name))
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000185 name = PyString_AS_STRING(co->co_name);
Barry Warsaw8f6d8682001-11-28 21:10:39 +0000186 PyOS_snprintf(buf, sizeof(buf),
187 "<code object %.100s at %p, file \"%.300s\", line %d>",
188 name, co, filename, lineno);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000189 return PyString_FromString(buf);
Guido van Rossum2dff9911992-09-03 20:50:59 +0000190}
191
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000192static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000193code_compare(PyCodeObject *co, PyCodeObject *cp)
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000194{
195 int cmp;
Guido van Rossum44679592000-04-10 16:20:31 +0000196 cmp = PyObject_Compare(co->co_name, cp->co_name);
197 if (cmp) return cmp;
Guido van Rossumbeef8aa1997-08-29 17:12:43 +0000198 cmp = co->co_argcount - cp->co_argcount;
Michael W. Hudson3ae33152002-10-03 09:50:47 +0000199 if (cmp) return (cmp<0)?-1:1;
Guido van Rossumbeef8aa1997-08-29 17:12:43 +0000200 cmp = co->co_nlocals - cp->co_nlocals;
Michael W. Hudson3ae33152002-10-03 09:50:47 +0000201 if (cmp) return (cmp<0)?-1:1;
Guido van Rossumbeef8aa1997-08-29 17:12:43 +0000202 cmp = co->co_flags - cp->co_flags;
Michael W. Hudson3ae33152002-10-03 09:50:47 +0000203 if (cmp) return (cmp<0)?-1:1;
Guido van Rossumd076c731998-10-07 19:42:25 +0000204 cmp = PyObject_Compare(co->co_code, cp->co_code);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000205 if (cmp) return cmp;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000206 cmp = PyObject_Compare(co->co_consts, cp->co_consts);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000207 if (cmp) return cmp;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000208 cmp = PyObject_Compare(co->co_names, cp->co_names);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000209 if (cmp) return cmp;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000210 cmp = PyObject_Compare(co->co_varnames, cp->co_varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000211 if (cmp) return cmp;
212 cmp = PyObject_Compare(co->co_freevars, cp->co_freevars);
213 if (cmp) return cmp;
214 cmp = PyObject_Compare(co->co_cellvars, cp->co_cellvars);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000215 return cmp;
216}
217
218static long
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000219code_hash(PyCodeObject *co)
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000220{
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000221 long h, h0, h1, h2, h3, h4, h5, h6;
Guido van Rossum44679592000-04-10 16:20:31 +0000222 h0 = PyObject_Hash(co->co_name);
223 if (h0 == -1) return -1;
Guido van Rossumd076c731998-10-07 19:42:25 +0000224 h1 = PyObject_Hash(co->co_code);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000225 if (h1 == -1) return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000226 h2 = PyObject_Hash(co->co_consts);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000227 if (h2 == -1) return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000228 h3 = PyObject_Hash(co->co_names);
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000229 if (h3 == -1) return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000230 h4 = PyObject_Hash(co->co_varnames);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000231 if (h4 == -1) return -1;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000232 h5 = PyObject_Hash(co->co_freevars);
233 if (h5 == -1) return -1;
234 h6 = PyObject_Hash(co->co_cellvars);
235 if (h6 == -1) return -1;
236 h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^
Guido van Rossum681d79a1995-07-18 14:51:37 +0000237 co->co_argcount ^ co->co_nlocals ^ co->co_flags;
Guido van Rossum2e8f8a31993-11-05 10:20:10 +0000238 if (h == -1) h = -2;
239 return h;
240}
241
Jeremy Hylton78891072001-03-01 06:09:34 +0000242/* XXX code objects need to participate in GC? */
243
Guido van Rossum79f25d91997-04-29 20:08:16 +0000244PyTypeObject PyCode_Type = {
245 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000246 0,
247 "code",
Guido van Rossum79f25d91997-04-29 20:08:16 +0000248 sizeof(PyCodeObject),
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000249 0,
Jeremy Hyltonc785f482001-09-14 20:08:07 +0000250 (destructor)code_dealloc, /* tp_dealloc */
251 0, /* tp_print */
252 0, /* tp_getattr */
253 0, /* tp_setattr */
254 (cmpfunc)code_compare, /* tp_compare */
255 (reprfunc)code_repr, /* tp_repr */
256 0, /* tp_as_number */
257 0, /* tp_as_sequence */
258 0, /* tp_as_mapping */
259 (hashfunc)code_hash, /* tp_hash */
260 0, /* tp_call */
261 0, /* tp_str */
262 PyObject_GenericGetAttr, /* tp_getattro */
263 0, /* tp_setattro */
264 0, /* tp_as_buffer */
265 Py_TPFLAGS_DEFAULT, /* tp_flags */
Guido van Rossumbea18cc2002-06-14 20:41:17 +0000266 code_doc, /* tp_doc */
Jeremy Hyltonc785f482001-09-14 20:08:07 +0000267 0, /* tp_traverse */
268 0, /* tp_clear */
269 0, /* tp_richcompare */
270 0, /* tp_weaklistoffset */
271 0, /* tp_iter */
272 0, /* tp_iternext */
273 0, /* tp_methods */
274 code_memberlist, /* tp_members */
275 0, /* tp_getset */
276 0, /* tp_base */
277 0, /* tp_dict */
278 0, /* tp_descr_get */
279 0, /* tp_descr_set */
280 0, /* tp_dictoffset */
281 0, /* tp_init */
282 0, /* tp_alloc */
Guido van Rossumbea18cc2002-06-14 20:41:17 +0000283 code_new, /* tp_new */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000284};
285
Guido van Rossum644a12b1997-04-09 19:24:53 +0000286#define NAME_CHARS \
287 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
288
Guido van Rossumfc5ce612001-01-19 00:24:06 +0000289/* all_name_chars(s): true iff all chars in s are valid NAME_CHARS */
290
291static int
292all_name_chars(unsigned char *s)
293{
Guido van Rossumcd90c202001-02-09 15:06:42 +0000294 static char ok_name_char[256];
295 static unsigned char *name_chars = (unsigned char *)NAME_CHARS;
Guido van Rossumfc5ce612001-01-19 00:24:06 +0000296
Guido van Rossumcd90c202001-02-09 15:06:42 +0000297 if (ok_name_char[*name_chars] == 0) {
298 unsigned char *p;
299 for (p = name_chars; *p; p++)
300 ok_name_char[*p] = 1;
301 }
302 while (*s) {
303 if (ok_name_char[*s++] == 0)
304 return 0;
305 }
306 return 1;
Guido van Rossumfc5ce612001-01-19 00:24:06 +0000307}
308
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000309static int
310intern_strings(PyObject *tuple)
311{
312 int i;
313
314 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
315 PyObject *v = PyTuple_GET_ITEM(tuple, i);
316 if (v == NULL || !PyString_Check(v)) {
317 Py_FatalError("non-string found in code slot");
318 PyErr_BadInternalCall();
319 return -1;
320 }
321 PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
322 }
323 return 0;
324}
325
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000326#define GETARG(arr, i) ((int)((arr[i+2]<<8) + arr[i+1]))
327#define UNCONDITIONAL_JUMP(op) (op==JUMP_ABSOLUTE || op==JUMP_FORWARD)
Raymond Hettinger5b75c382003-03-28 12:05:00 +0000328#define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE || op==CONTINUE_LOOP)
329#define GETJUMPTGT(arr, i) (GETARG(arr,i) + (ABSOLUTE_JUMP(arr[i]) ? 0 : i+3))
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000330#define SETARG(arr, i, val) arr[i+2] = val>>8; arr[i+1] = val & 255
331
332static PyObject *
333optimize_code(PyObject *code, PyObject* consts)
334{
335 int i, j, codelen;
336 int tgt, tgttgt, opcode;
337 unsigned char *codestr;
338
339 /* Make a modifiable copy of the code string */
340 if (!PyString_Check(code))
341 goto exitUnchanged;
342 codelen = PyString_Size(code);
343 codestr = PyMem_Malloc(codelen);
Raymond Hettingerf4cf76d2003-04-24 05:45:23 +0000344 if (codestr == NULL)
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000345 goto exitUnchanged;
346 codestr = memcpy(codestr, PyString_AS_STRING(code), codelen);
347 assert(PyTuple_Check(consts));
348
Raymond Hettingerf4cf76d2003-04-24 05:45:23 +0000349 for (i=0 ; i<codelen-7 ; i += HAS_ARG(codestr[i]) ? 3 : 1) {
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000350 opcode = codestr[i];
351 switch (opcode) {
352
353 /* Skip over LOAD_CONST trueconst JUMP_IF_FALSE xx POP_TOP.
354 Note, only the first opcode is changed, the others still
355 perform normally if they happen to be jump targets. */
356 case LOAD_CONST:
357 j = GETARG(codestr, i);
358 if (codestr[i+3] != JUMP_IF_FALSE ||
359 codestr[i+6] != POP_TOP ||
360 !PyObject_IsTrue(PyTuple_GET_ITEM(consts, j)))
361 continue;
362 codestr[i] = JUMP_FORWARD;
363 SETARG(codestr, i, 4);
364 break;
365
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000366 /* Replace jumps to unconditional jumps */
Raymond Hettinger255a3d02003-04-15 10:35:07 +0000367 case FOR_ITER:
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000368 case JUMP_FORWARD:
369 case JUMP_IF_FALSE:
370 case JUMP_IF_TRUE:
371 case JUMP_ABSOLUTE:
372 case CONTINUE_LOOP:
373 case SETUP_LOOP:
374 case SETUP_EXCEPT:
375 case SETUP_FINALLY:
376 tgt = GETJUMPTGT(codestr, i);
Raymond Hettingerf4cf76d2003-04-24 05:45:23 +0000377 if (!UNCONDITIONAL_JUMP(codestr[tgt]))
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000378 continue;
379 tgttgt = GETJUMPTGT(codestr, tgt);
380 if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */
381 opcode = JUMP_ABSOLUTE;
Raymond Hettinger5b75c382003-03-28 12:05:00 +0000382 if (!ABSOLUTE_JUMP(opcode))
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000383 tgttgt -= i + 3; /* Calc relative jump addr */
384 if (tgttgt < 0) /* No backward relative jumps */
385 continue;
386 codestr[i] = opcode;
387 SETARG(codestr, i, tgttgt);
388 break;
389
390 case EXTENDED_ARG:
391 PyMem_Free(codestr);
392 goto exitUnchanged;
393 }
394 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000395 code = PyString_FromStringAndSize((char *)codestr, codelen);
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000396 PyMem_Free(codestr);
397 return code;
398
399exitUnchanged:
400 Py_INCREF(code);
401 return code;
402}
403
Guido van Rossum79f25d91997-04-29 20:08:16 +0000404PyCodeObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000405PyCode_New(int argcount, int nlocals, int stacksize, int flags,
406 PyObject *code, PyObject *consts, PyObject *names,
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000407 PyObject *varnames, PyObject *freevars, PyObject *cellvars,
408 PyObject *filename, PyObject *name, int firstlineno,
409 PyObject *lnotab)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000410{
Guido van Rossum79f25d91997-04-29 20:08:16 +0000411 PyCodeObject *co;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000412 int i;
413 /* Check argument types */
Guido van Rossum681d79a1995-07-18 14:51:37 +0000414 if (argcount < 0 || nlocals < 0 ||
Guido van Rossumd076c731998-10-07 19:42:25 +0000415 code == NULL ||
Guido van Rossum79f25d91997-04-29 20:08:16 +0000416 consts == NULL || !PyTuple_Check(consts) ||
417 names == NULL || !PyTuple_Check(names) ||
418 varnames == NULL || !PyTuple_Check(varnames) ||
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000419 freevars == NULL || !PyTuple_Check(freevars) ||
420 cellvars == NULL || !PyTuple_Check(cellvars) ||
Guido van Rossum79f25d91997-04-29 20:08:16 +0000421 name == NULL || !PyString_Check(name) ||
422 filename == NULL || !PyString_Check(filename) ||
Jeremy Hylton9f64caa2001-11-09 22:02:48 +0000423 lnotab == NULL || !PyString_Check(lnotab) ||
424 !PyObject_CheckReadBuffer(code)) {
Guido van Rossumd076c731998-10-07 19:42:25 +0000425 PyErr_BadInternalCall();
426 return NULL;
427 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000428 intern_strings(names);
429 intern_strings(varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000430 intern_strings(freevars);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000431 intern_strings(cellvars);
Guido van Rossum7b89b6a1997-01-18 08:02:57 +0000432 /* Intern selected string constants */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000433 for (i = PyTuple_Size(consts); --i >= 0; ) {
434 PyObject *v = PyTuple_GetItem(consts, i);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000435 if (!PyString_Check(v))
Guido van Rossum7b89b6a1997-01-18 08:02:57 +0000436 continue;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000437 if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
Guido van Rossum7b89b6a1997-01-18 08:02:57 +0000438 continue;
439 PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000440 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000441 co = PyObject_NEW(PyCodeObject, &PyCode_Type);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000442 if (co != NULL) {
Guido van Rossum681d79a1995-07-18 14:51:37 +0000443 co->co_argcount = argcount;
444 co->co_nlocals = nlocals;
Guido van Rossum8b993a91997-01-17 21:04:03 +0000445 co->co_stacksize = stacksize;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000446 co->co_flags = flags;
Raymond Hettingerf6f575a2003-03-26 01:07:54 +0000447 co->co_code = optimize_code(code, consts);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000448 Py_INCREF(consts);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000449 co->co_consts = consts;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000450 Py_INCREF(names);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000451 co->co_names = names;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000452 Py_INCREF(varnames);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000453 co->co_varnames = varnames;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000454 Py_INCREF(freevars);
455 co->co_freevars = freevars;
456 Py_INCREF(cellvars);
457 co->co_cellvars = cellvars;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000458 Py_INCREF(filename);
Guido van Rossuma082ce41991-06-04 19:41:56 +0000459 co->co_filename = filename;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000460 Py_INCREF(name);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000461 co->co_name = name;
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000462 co->co_firstlineno = firstlineno;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000463 Py_INCREF(lnotab);
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000464 co->co_lnotab = lnotab;
Jeremy Hylton985eba52003-02-05 23:13:00 +0000465 if (PyTuple_GET_SIZE(freevars) == 0 &&
466 PyTuple_GET_SIZE(cellvars) == 0)
467 co->co_flags |= CO_NOFREE;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000468 }
469 return co;
470}
471
472
473/* Data structure used internally */
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000474
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000475/* The compiler uses two passes to generate bytecodes. The first pass
476 builds the symbol table. The second pass generates the bytecode.
477
478 The first pass uses a single symtable struct. The second pass uses
479 a compiling struct for each code block. The compiling structs
480 share a reference to the symtable.
481
482 The two passes communicate via symtable_load_symbols() and via
483 is_local() and is_global(). The former initializes several slots
484 in the compiling struct: c_varnames, c_locals, c_nlocals,
485 c_argcount, c_globals, and c_flags.
486*/
487
Tim Peters2a7f3842001-06-09 09:26:21 +0000488/* All about c_lnotab.
489
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000490c_lnotab is an array of unsigned bytes disguised as a Python string. Since
491version 2.3, SET_LINENO opcodes are never generated and bytecode offsets are
492mapped to source code line #s via c_lnotab instead.
493
Tim Peters2a7f3842001-06-09 09:26:21 +0000494The array is conceptually a list of
495 (bytecode offset increment, line number increment)
496pairs. The details are important and delicate, best illustrated by example:
497
498 byte code offset source code line number
499 0 1
500 6 2
501 50 7
502 350 307
503 361 308
504
505The first trick is that these numbers aren't stored, only the increments
506from one row to the next (this doesn't really work, but it's a start):
507
508 0, 1, 6, 1, 44, 5, 300, 300, 11, 1
509
510The second trick is that an unsigned byte can't hold negative values, or
511values larger than 255, so (a) there's a deep assumption that byte code
512offsets and their corresponding line #s both increase monotonically, and (b)
513if at least one column jumps by more than 255 from one row to the next, more
514than one pair is written to the table. In case #b, there's no way to know
515from looking at the table later how many were written. That's the delicate
516part. A user of c_lnotab desiring to find the source line number
517corresponding to a bytecode address A should do something like this
518
519 lineno = addr = 0
520 for addr_incr, line_incr in c_lnotab:
521 addr += addr_incr
522 if addr > A:
523 return lineno
524 lineno += line_incr
525
526In order for this to work, when the addr field increments by more than 255,
527the line # increment in each pair generated must be 0 until the remaining addr
528increment is < 256. So, in the example above, com_set_lineno should not (as
529was actually done until 2.2) expand 300, 300 to 255, 255, 45, 45, but to
530255, 0, 45, 255, 0, 45.
531*/
532
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000533struct compiling {
Fred Drakefd1f1be2000-09-08 16:31:24 +0000534 PyObject *c_code; /* string */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000535 PyObject *c_consts; /* list of objects */
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000536 PyObject *c_const_dict; /* inverse of c_consts */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000537 PyObject *c_names; /* list of strings (names) */
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000538 PyObject *c_name_dict; /* inverse of c_names */
Neal Norwitz06982222002-12-18 01:18:44 +0000539 PyObject *c_globals; /* dictionary (value=None or True) */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000540 PyObject *c_locals; /* dictionary (value=localID) */
541 PyObject *c_varnames; /* list (inverse of c_locals) */
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000542 PyObject *c_freevars; /* dictionary (value=None) */
543 PyObject *c_cellvars; /* list */
Guido van Rossum681d79a1995-07-18 14:51:37 +0000544 int c_nlocals; /* index of next local */
545 int c_argcount; /* number of top-level arguments */
546 int c_flags; /* same as co_flags */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000547 int c_nexti; /* index into c_code */
548 int c_errors; /* counts errors occurred */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000549 int c_infunction; /* set when compiling a function */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +0000550 int c_interactive; /* generating code for interactive command */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000551 int c_loops; /* counts nested loops */
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000552 int c_begin; /* begin of current loop, for 'continue' */
Guido van Rossum8b993a91997-01-17 21:04:03 +0000553 int c_block[CO_MAXBLOCKS]; /* stack of block types */
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000554 int c_nblocks; /* current block stack level */
Martin v. Löwis95292d62002-12-11 14:04:59 +0000555 const char *c_filename; /* filename of current node */
Guido van Rossum9bfef441993-03-29 10:43:31 +0000556 char *c_name; /* name of object (e.g. function) */
Guido van Rossum452a9831996-09-17 14:32:04 +0000557 int c_lineno; /* Current line number */
Guido van Rossum8b993a91997-01-17 21:04:03 +0000558 int c_stacklevel; /* Current stack level */
559 int c_maxstacklevel; /* Maximum stack level */
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000560 int c_firstlineno;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000561 PyObject *c_lnotab; /* Table mapping address to line number */
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000562 int c_last_addr, c_last_line, c_lnotab_next;
Guido van Rossum8ff077b1996-08-24 06:21:31 +0000563 char *c_private; /* for private name mangling */
Skip Montanaro803d6e52000-08-12 18:09:51 +0000564 int c_tmpname; /* temporary local name counter */
Guido van Rossumcd90c202001-02-09 15:06:42 +0000565 int c_nested; /* Is block nested funcdef or lamdef? */
566 int c_closure; /* Is nested w/freevars? */
567 struct symtable *c_symtable; /* pointer to module symbol table */
Jeremy Hylton4db62b12001-02-27 19:07:02 +0000568 PyFutureFeatures *c_future; /* pointer to module's __future__ */
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +0000569 char *c_encoding; /* source encoding (a borrowed reference) */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000570};
571
Guido van Rossumf68d8e52001-04-14 17:55:09 +0000572static int
573is_free(int v)
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000574{
575 if ((v & (USE | DEF_FREE))
576 && !(v & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)))
577 return 1;
578 if (v & DEF_FREE_CLASS)
579 return 1;
580 return 0;
581}
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000582
Jeremy Hylton5acc0c02001-02-02 20:01:10 +0000583static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000584com_error(struct compiling *c, PyObject *exc, char *msg)
Guido van Rossum452a9831996-09-17 14:32:04 +0000585{
Jeremy Hylton9f1b9932001-02-28 07:07:43 +0000586 PyObject *t = NULL, *v = NULL, *w = NULL, *line = NULL;
587
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000588 if (c == NULL) {
589 /* Error occurred via symtable call to
590 is_constant_false */
591 PyErr_SetString(exc, msg);
592 return;
593 }
Guido van Rossum635abd21997-01-06 22:56:52 +0000594 c->c_errors++;
Jeremy Hylton9f1b9932001-02-28 07:07:43 +0000595 if (c->c_lineno < 1 || c->c_interactive) {
596 /* Unknown line number or interactive input */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000597 PyErr_SetString(exc, msg);
Guido van Rossum452a9831996-09-17 14:32:04 +0000598 return;
599 }
Fred Drakedcf08e02000-08-15 15:49:44 +0000600 v = PyString_FromString(msg);
Guido van Rossum452a9831996-09-17 14:32:04 +0000601 if (v == NULL)
602 return; /* MemoryError, too bad */
Fred Drakedcf08e02000-08-15 15:49:44 +0000603
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +0000604 line = PyErr_ProgramText(c->c_filename, c->c_lineno);
Jeremy Hylton9f1b9932001-02-28 07:07:43 +0000605 if (line == NULL) {
606 Py_INCREF(Py_None);
607 line = Py_None;
608 }
Martin v. Löwiscfeb3b62002-03-03 21:30:27 +0000609 if (exc == PyExc_SyntaxError) {
610 t = Py_BuildValue("(ziOO)", c->c_filename, c->c_lineno,
611 Py_None, line);
612 if (t == NULL)
613 goto exit;
614 w = Py_BuildValue("(OO)", v, t);
615 if (w == NULL)
616 goto exit;
617 PyErr_SetObject(exc, w);
618 } else {
619 /* Make sure additional exceptions are printed with
620 file and line, also. */
621 PyErr_SetObject(exc, v);
622 PyErr_SyntaxLocation(c->c_filename, c->c_lineno);
623 }
Jeremy Hylton9f1b9932001-02-28 07:07:43 +0000624 exit:
625 Py_XDECREF(t);
626 Py_XDECREF(v);
627 Py_XDECREF(w);
628 Py_XDECREF(line);
Guido van Rossum452a9831996-09-17 14:32:04 +0000629}
630
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000631/* Interface to the block stack */
632
633static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000634block_push(struct compiling *c, int type)
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000635{
Guido van Rossum8b993a91997-01-17 21:04:03 +0000636 if (c->c_nblocks >= CO_MAXBLOCKS) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000637 com_error(c, PyExc_SystemError,
638 "too many statically nested blocks");
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000639 }
640 else {
641 c->c_block[c->c_nblocks++] = type;
642 }
643}
644
645static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000646block_pop(struct compiling *c, int type)
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000647{
648 if (c->c_nblocks > 0)
649 c->c_nblocks--;
650 if (c->c_block[c->c_nblocks] != type && c->c_errors == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000651 com_error(c, PyExc_SystemError, "bad block pop");
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000652 }
653}
654
Guido van Rossum681d79a1995-07-18 14:51:37 +0000655/* Prototype forward declarations */
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000656
Martin v. Löwis95292d62002-12-11 14:04:59 +0000657static int issue_warning(const char *, const char *, int);
658static int com_init(struct compiling *, const char *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000659static void com_free(struct compiling *);
660static void com_push(struct compiling *, int);
661static void com_pop(struct compiling *, int);
662static void com_done(struct compiling *);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000663static void com_node(struct compiling *, node *);
664static void com_factor(struct compiling *, node *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000665static void com_addbyte(struct compiling *, int);
666static void com_addint(struct compiling *, int);
667static void com_addoparg(struct compiling *, int, int);
668static void com_addfwref(struct compiling *, int, int *);
669static void com_backpatch(struct compiling *, int);
670static int com_add(struct compiling *, PyObject *, PyObject *, PyObject *);
671static int com_addconst(struct compiling *, PyObject *);
672static int com_addname(struct compiling *, PyObject *);
673static void com_addopname(struct compiling *, int, node *);
674static void com_list(struct compiling *, node *, int);
Skip Montanaro803d6e52000-08-12 18:09:51 +0000675static void com_list_iter(struct compiling *, node *, node *, char *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000676static int com_argdefs(struct compiling *, node *);
Thomas Wouters434d0822000-08-24 20:11:32 +0000677static void com_assign(struct compiling *, node *, int, node *);
678static void com_assign_name(struct compiling *, node *, int);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000679static PyCodeObject *icompile(node *, struct compiling *);
Martin v. Löwis95292d62002-12-11 14:04:59 +0000680static PyCodeObject *jcompile(node *, const char *, struct compiling *,
Jeremy Hylton9f324e92001-03-01 22:59:14 +0000681 PyCompilerFlags *);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000682static PyObject *parsestrplus(struct compiling*, node *);
683static PyObject *parsestr(struct compiling *, char *);
Thomas Wouters434d0822000-08-24 20:11:32 +0000684static node *get_rawdocstring(node *);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000685
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000686static int get_ref_type(struct compiling *, char *);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000687
688/* symtable operations */
Jeremy Hylton1955fcf2003-07-15 20:23:26 +0000689static struct symtable *symtable_build(node *, PyFutureFeatures *,
690 const char *filename);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000691static int symtable_load_symbols(struct compiling *);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +0000692static struct symtable *symtable_init(void);
Jeremy Hylton4b38da62001-02-02 18:19:15 +0000693static void symtable_enter_scope(struct symtable *, char *, int, int);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000694static int symtable_exit_scope(struct symtable *);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000695static int symtable_add_def(struct symtable *, char *, int);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000696static int symtable_add_def_o(struct symtable *, PyObject *, PyObject *, int);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000697
698static void symtable_node(struct symtable *, node *);
699static void symtable_funcdef(struct symtable *, node *);
700static void symtable_default_args(struct symtable *, node *);
701static void symtable_params(struct symtable *, node *);
702static void symtable_params_fplist(struct symtable *, node *n);
703static void symtable_global(struct symtable *, node *);
704static void symtable_import(struct symtable *, node *);
Jeremy Hyltoneab156f2001-01-30 01:24:43 +0000705static void symtable_assign(struct symtable *, node *, int);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000706static void symtable_list_comprehension(struct symtable *, node *);
Jeremy Hylton4d508ad2003-05-21 17:34:50 +0000707static void symtable_list_for(struct symtable *, node *);
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000708
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000709static int symtable_update_free_vars(struct symtable *);
710static int symtable_undo_free(struct symtable *, PyObject *, PyObject *);
711static int symtable_check_global(struct symtable *, PyObject *, PyObject *);
712
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000713/* helper */
714static void
715do_pad(int pad)
716{
717 int i;
718 for (i = 0; i < pad; ++i)
719 fprintf(stderr, " ");
720}
721
722static void
723dump(node *n, int pad, int depth)
724{
725 int i;
726 if (depth == 0)
727 return;
728 do_pad(pad);
729 fprintf(stderr, "%d: %s\n", TYPE(n), STR(n));
730 if (depth > 0)
731 depth--;
732 for (i = 0; i < NCH(n); ++i)
733 dump(CHILD(n, i), pad + 1, depth);
734}
735
736#define DUMP(N) dump(N, 0, -1)
737
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000738static int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000739com_init(struct compiling *c, const char *filename)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000740{
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000741 memset((void *)c, '\0', sizeof(struct compiling));
Guido van Rossum79f25d91997-04-29 20:08:16 +0000742 if ((c->c_code = PyString_FromStringAndSize((char *)NULL,
743 1000)) == NULL)
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000744 goto fail;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000745 if ((c->c_consts = PyList_New(0)) == NULL)
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000746 goto fail;
747 if ((c->c_const_dict = PyDict_New()) == NULL)
748 goto fail;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000749 if ((c->c_names = PyList_New(0)) == NULL)
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000750 goto fail;
751 if ((c->c_name_dict = PyDict_New()) == NULL)
752 goto fail;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000753 if ((c->c_locals = PyDict_New()) == NULL)
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000754 goto fail;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000755 if ((c->c_lnotab = PyString_FromStringAndSize((char *)NULL,
756 1000)) == NULL)
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000757 goto fail;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000758 c->c_globals = NULL;
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000759 c->c_varnames = NULL;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000760 c->c_freevars = NULL;
761 c->c_cellvars = NULL;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000762 c->c_nlocals = 0;
763 c->c_argcount = 0;
764 c->c_flags = 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000765 c->c_nexti = 0;
766 c->c_errors = 0;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000767 c->c_infunction = 0;
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +0000768 c->c_interactive = 0;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000769 c->c_loops = 0;
Guido van Rossum4bad92c1991-07-27 21:34:52 +0000770 c->c_begin = 0;
771 c->c_nblocks = 0;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000772 c->c_filename = filename;
Guido van Rossum9bfef441993-03-29 10:43:31 +0000773 c->c_name = "?";
Guido van Rossum452a9831996-09-17 14:32:04 +0000774 c->c_lineno = 0;
Guido van Rossum8b993a91997-01-17 21:04:03 +0000775 c->c_stacklevel = 0;
776 c->c_maxstacklevel = 0;
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000777 c->c_firstlineno = 0;
778 c->c_last_addr = 0;
779 c->c_last_line = 0;
Barry Warsaw174e8012001-01-22 04:35:57 +0000780 c->c_lnotab_next = 0;
Skip Montanaro803d6e52000-08-12 18:09:51 +0000781 c->c_tmpname = 0;
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000782 c->c_nested = 0;
783 c->c_closure = 0;
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000784 c->c_symtable = NULL;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000785 return 1;
786
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000787 fail:
788 com_free(c);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000789 return 0;
790}
791
792static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000793com_free(struct compiling *c)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000794{
Guido van Rossum79f25d91997-04-29 20:08:16 +0000795 Py_XDECREF(c->c_code);
796 Py_XDECREF(c->c_consts);
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000797 Py_XDECREF(c->c_const_dict);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000798 Py_XDECREF(c->c_names);
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000799 Py_XDECREF(c->c_name_dict);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000800 Py_XDECREF(c->c_globals);
801 Py_XDECREF(c->c_locals);
802 Py_XDECREF(c->c_varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000803 Py_XDECREF(c->c_freevars);
804 Py_XDECREF(c->c_cellvars);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000805 Py_XDECREF(c->c_lnotab);
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +0000806 if (c->c_future)
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +0000807 PyObject_FREE((void *)c->c_future);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000808}
809
810static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000811com_push(struct compiling *c, int n)
Guido van Rossum8b993a91997-01-17 21:04:03 +0000812{
813 c->c_stacklevel += n;
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000814 if (c->c_stacklevel > c->c_maxstacklevel) {
Guido van Rossum8b993a91997-01-17 21:04:03 +0000815 c->c_maxstacklevel = c->c_stacklevel;
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000816 /*
817 fprintf(stderr, "%s:%s:%d max stack nexti=%d level=%d n=%d\n",
818 c->c_filename, c->c_name, c->c_lineno,
819 c->c_nexti, c->c_stacklevel, n);
820 */
821 }
Guido van Rossum8b993a91997-01-17 21:04:03 +0000822}
823
824static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000825com_pop(struct compiling *c, int n)
Guido van Rossum8b993a91997-01-17 21:04:03 +0000826{
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000827 if (c->c_stacklevel < n)
Guido van Rossum8b993a91997-01-17 21:04:03 +0000828 c->c_stacklevel = 0;
Guido van Rossum8b993a91997-01-17 21:04:03 +0000829 else
830 c->c_stacklevel -= n;
831}
832
833static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000834com_done(struct compiling *c)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000835{
836 if (c->c_code != NULL)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000837 _PyString_Resize(&c->c_code, c->c_nexti);
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000838 if (c->c_lnotab != NULL)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000839 _PyString_Resize(&c->c_lnotab, c->c_lnotab_next);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000840}
841
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000842static int
843com_check_size(PyObject **s, int offset)
844{
845 int len = PyString_GET_SIZE(*s);
846 if (offset >= len)
847 return _PyString_Resize(s, len * 2);
848 return 0;
849}
850
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000851static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000852com_addbyte(struct compiling *c, int byte)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000853{
Guido van Rossum681d79a1995-07-18 14:51:37 +0000854 /*fprintf(stderr, "%3d: %3d\n", c->c_nexti, byte);*/
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000855 assert(byte >= 0 && byte <= 255);
Martin v. Löwis7198a522002-01-01 19:59:11 +0000856 assert(c->c_code != 0);
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000857 if (com_check_size(&c->c_code, c->c_nexti)) {
858 c->c_errors++;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000859 return;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000860 }
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000861 PyString_AS_STRING(c->c_code)[c->c_nexti++] = byte;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000862}
863
864static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000865com_addint(struct compiling *c, int x)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000866{
Guido van Rossumd6f3bc21990-11-18 17:35:03 +0000867 com_addbyte(c, x & 0xff);
868 com_addbyte(c, x >> 8); /* XXX x should be positive */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000869}
870
871static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000872com_add_lnotab(struct compiling *c, int addr, int line)
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000873{
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000874 char *p;
875 if (c->c_lnotab == NULL)
876 return;
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000877 if (com_check_size(&c->c_lnotab, c->c_lnotab_next + 2)) {
878 c->c_errors++;
879 return;
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000880 }
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000881 p = PyString_AS_STRING(c->c_lnotab) + c->c_lnotab_next;
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000882 *p++ = addr;
883 *p++ = line;
884 c->c_lnotab_next += 2;
885}
886
887static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000888com_set_lineno(struct compiling *c, int lineno)
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000889{
890 c->c_lineno = lineno;
891 if (c->c_firstlineno == 0) {
892 c->c_firstlineno = c->c_last_line = lineno;
893 }
894 else {
895 int incr_addr = c->c_nexti - c->c_last_addr;
896 int incr_line = lineno - c->c_last_line;
Tim Peters2a7f3842001-06-09 09:26:21 +0000897 while (incr_addr > 255) {
898 com_add_lnotab(c, 255, 0);
899 incr_addr -= 255;
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000900 }
Tim Peters2a7f3842001-06-09 09:26:21 +0000901 while (incr_line > 255) {
902 com_add_lnotab(c, incr_addr, 255);
903 incr_line -=255;
904 incr_addr = 0;
905 }
906 if (incr_addr > 0 || incr_line > 0)
907 com_add_lnotab(c, incr_addr, incr_line);
Guido van Rossumda4eb5c1997-01-24 03:43:35 +0000908 c->c_last_addr = c->c_nexti;
909 c->c_last_line = lineno;
910 }
911}
912
913static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000914com_addoparg(struct compiling *c, int op, int arg)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000915{
Fred Drakeef8ace32000-08-24 00:32:09 +0000916 int extended_arg = arg >> 16;
Fred Drakeef8ace32000-08-24 00:32:09 +0000917 if (extended_arg){
918 com_addbyte(c, EXTENDED_ARG);
919 com_addint(c, extended_arg);
920 arg &= 0xffff;
921 }
Guido van Rossum8e793d91997-03-03 19:13:14 +0000922 com_addbyte(c, op);
923 com_addint(c, arg);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000924}
925
926static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000927com_addfwref(struct compiling *c, int op, int *p_anchor)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000928{
929 /* Compile a forward reference for backpatching */
930 int here;
931 int anchor;
932 com_addbyte(c, op);
933 here = c->c_nexti;
934 anchor = *p_anchor;
935 *p_anchor = here;
936 com_addint(c, anchor == 0 ? 0 : here - anchor);
937}
938
939static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000940com_backpatch(struct compiling *c, int anchor)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000941{
Jeremy Hylton93a569d2001-10-17 13:22:22 +0000942 unsigned char *code = (unsigned char *) PyString_AS_STRING(c->c_code);
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000943 int target = c->c_nexti;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000944 int dist;
945 int prev;
946 for (;;) {
947 /* Make the JUMP instruction at anchor point to target */
Guido van Rossumd6f3bc21990-11-18 17:35:03 +0000948 prev = code[anchor] + (code[anchor+1] << 8);
949 dist = target - (anchor+2);
950 code[anchor] = dist & 0xff;
Fred Drakeef8ace32000-08-24 00:32:09 +0000951 dist >>= 8;
952 code[anchor+1] = dist;
953 dist >>= 8;
954 if (dist) {
955 com_error(c, PyExc_SystemError,
956 "com_backpatch: offset too large");
957 break;
958 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000959 if (!prev)
960 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000961 anchor -= prev;
962 }
963}
964
Guido van Rossuma9df32a1991-12-31 13:13:35 +0000965/* Handle literals and names uniformly */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000966
967static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000968com_add(struct compiling *c, PyObject *list, PyObject *dict, PyObject *v)
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000969{
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000970 PyObject *w, *t, *np=NULL;
971 long n;
Jeremy Hyltone36f7782001-01-19 03:21:30 +0000972
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000973 t = Py_BuildValue("(OO)", v, v->ob_type);
974 if (t == NULL)
975 goto fail;
976 w = PyDict_GetItem(dict, t);
977 if (w != NULL) {
978 n = PyInt_AsLong(w);
979 } else {
980 n = PyList_Size(list);
981 np = PyInt_FromLong(n);
982 if (np == NULL)
983 goto fail;
984 if (PyList_Append(list, v) != 0)
985 goto fail;
986 if (PyDict_SetItem(dict, t, np) != 0)
987 goto fail;
988 Py_DECREF(np);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +0000989 }
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000990 Py_DECREF(t);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +0000991 return n;
Guido van Rossuma2ace6a2000-04-28 16:42:25 +0000992 fail:
993 Py_XDECREF(np);
994 Py_XDECREF(t);
995 c->c_errors++;
996 return 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000997}
998
999static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001000com_addconst(struct compiling *c, PyObject *v)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001001{
Guido van Rossuma2ace6a2000-04-28 16:42:25 +00001002 return com_add(c, c->c_consts, c->c_const_dict, v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001003}
1004
1005static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001006com_addname(struct compiling *c, PyObject *v)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001007{
Guido van Rossuma2ace6a2000-04-28 16:42:25 +00001008 return com_add(c, c->c_names, c->c_name_dict, v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001009}
1010
Raymond Hettinger0ae0c072002-06-20 22:23:15 +00001011int
1012_Py_Mangle(char *p, char *name, char *buffer, size_t maxlen)
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001013{
Guido van Rossumd8a6d1c1996-08-24 07:54:27 +00001014 /* Name mangling: __private becomes _classname__private.
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001015 This is independent from how the name is used. */
Guido van Rossum582acec2000-06-28 22:07:35 +00001016 size_t nlen, plen;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001017 if (p == NULL || name == NULL || name[0] != '_' || name[1] != '_')
1018 return 0;
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001019 nlen = strlen(name);
Guido van Rossumd8a6d1c1996-08-24 07:54:27 +00001020 if (nlen+2 >= maxlen)
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001021 return 0; /* Don't mangle __extremely_long_names */
1022 if (name[nlen-1] == '_' && name[nlen-2] == '_')
1023 return 0; /* Don't mangle __whatever__ */
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001024 /* Strip leading underscores from class name */
1025 while (*p == '_')
1026 p++;
1027 if (*p == '\0')
1028 return 0; /* Don't mangle if class is just underscores */
1029 plen = strlen(p);
1030 if (plen + nlen >= maxlen)
Guido van Rossumd8a6d1c1996-08-24 07:54:27 +00001031 plen = maxlen-nlen-2; /* Truncate class name if too long */
1032 /* buffer = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001033 buffer[0] = '_';
1034 strncpy(buffer+1, p, plen);
Guido van Rossumd8a6d1c1996-08-24 07:54:27 +00001035 strcpy(buffer+1+plen, name);
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001036 return 1;
1037}
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001038
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001039static void
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001040com_addop_name(struct compiling *c, int op, char *name)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001041{
Guido van Rossum79f25d91997-04-29 20:08:16 +00001042 PyObject *v;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001043 int i;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001044 char buffer[MANGLE_LEN];
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00001045
Raymond Hettinger0ae0c072002-06-20 22:23:15 +00001046 if (_Py_Mangle(c->c_private, name, buffer, sizeof(buffer)))
Guido van Rossum8ff077b1996-08-24 06:21:31 +00001047 name = buffer;
Guido van Rossum7b89b6a1997-01-18 08:02:57 +00001048 if (name == NULL || (v = PyString_InternFromString(name)) == NULL) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001049 c->c_errors++;
1050 i = 255;
1051 }
1052 else {
1053 i = com_addname(c, v);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001054 Py_DECREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001055 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001056 com_addoparg(c, op, i);
1057}
1058
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001059#define NAME_LOCAL 0
1060#define NAME_GLOBAL 1
1061#define NAME_DEFAULT 2
1062#define NAME_CLOSURE 3
1063
1064static int
1065com_lookup_arg(PyObject *dict, PyObject *name)
1066{
1067 PyObject *v = PyDict_GetItem(dict, name);
1068 if (v == NULL)
1069 return -1;
1070 else
1071 return PyInt_AS_LONG(v);
1072}
1073
Guido van Rossum3ac99d42002-08-16 02:13:49 +00001074static int
1075none_assignment_check(struct compiling *c, char *name, int assigning)
1076{
1077 if (name[0] == 'N' && strcmp(name, "None") == 0) {
1078 char *msg;
1079 if (assigning)
Michael W. Hudson976249b2003-01-16 15:39:07 +00001080 msg = "assignment to None";
Guido van Rossum3ac99d42002-08-16 02:13:49 +00001081 else
1082 msg = "deleting None";
1083 if (issue_warning(msg, c->c_filename, c->c_lineno) < 0) {
1084 c->c_errors++;
1085 return -1;
1086 }
1087 }
1088 return 0;
1089}
1090
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001091static void
1092com_addop_varname(struct compiling *c, int kind, char *name)
1093{
1094 PyObject *v;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001095 int i, reftype;
1096 int scope = NAME_DEFAULT;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001097 int op = STOP_CODE;
1098 char buffer[MANGLE_LEN];
1099
Guido van Rossum3ac99d42002-08-16 02:13:49 +00001100 if (kind != VAR_LOAD &&
1101 none_assignment_check(c, name, kind == VAR_STORE))
1102 {
1103 c->c_errors++;
1104 i = 255;
1105 goto done;
1106 }
Raymond Hettinger0ae0c072002-06-20 22:23:15 +00001107 if (_Py_Mangle(c->c_private, name, buffer, sizeof(buffer)))
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001108 name = buffer;
1109 if (name == NULL || (v = PyString_InternFromString(name)) == NULL) {
1110 c->c_errors++;
1111 i = 255;
1112 goto done;
Guido van Rossumc5e96291991-12-10 13:53:51 +00001113 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001114
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001115 reftype = get_ref_type(c, name);
1116 switch (reftype) {
1117 case LOCAL:
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00001118 if (c->c_symtable->st_cur->ste_type == TYPE_FUNCTION)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001119 scope = NAME_LOCAL;
1120 break;
1121 case GLOBAL_EXPLICIT:
1122 scope = NAME_GLOBAL;
1123 break;
1124 case GLOBAL_IMPLICIT:
1125 if (c->c_flags & CO_OPTIMIZED)
1126 scope = NAME_GLOBAL;
1127 break;
1128 case FREE:
1129 case CELL:
1130 scope = NAME_CLOSURE;
1131 break;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001132 }
1133
1134 i = com_addname(c, v);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001135 if (scope == NAME_LOCAL)
1136 i = com_lookup_arg(c->c_locals, v);
1137 else if (reftype == FREE)
1138 i = com_lookup_arg(c->c_freevars, v);
1139 else if (reftype == CELL)
1140 i = com_lookup_arg(c->c_cellvars, v);
1141 if (i == -1) {
1142 c->c_errors++; /* XXX no exception set */
1143 i = 255;
1144 goto done;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001145 }
1146 Py_DECREF(v);
1147
1148 switch (kind) {
1149 case VAR_LOAD:
1150 switch (scope) {
1151 case NAME_LOCAL:
1152 op = LOAD_FAST;
1153 break;
1154 case NAME_GLOBAL:
1155 op = LOAD_GLOBAL;
1156 break;
1157 case NAME_DEFAULT:
1158 op = LOAD_NAME;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001159 break;
1160 case NAME_CLOSURE:
1161 op = LOAD_DEREF;
1162 break;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001163 }
1164 break;
1165 case VAR_STORE:
1166 switch (scope) {
1167 case NAME_LOCAL:
1168 op = STORE_FAST;
1169 break;
1170 case NAME_GLOBAL:
1171 op = STORE_GLOBAL;
1172 break;
1173 case NAME_DEFAULT:
1174 op = STORE_NAME;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001175 break;
1176 case NAME_CLOSURE:
1177 op = STORE_DEREF;
1178 break;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001179 }
1180 break;
1181 case VAR_DELETE:
1182 switch (scope) {
1183 case NAME_LOCAL:
1184 op = DELETE_FAST;
1185 break;
1186 case NAME_GLOBAL:
1187 op = DELETE_GLOBAL;
1188 break;
1189 case NAME_DEFAULT:
1190 op = DELETE_NAME;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001191 break;
1192 case NAME_CLOSURE: {
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00001193 char buf[500];
Barry Warsaw8f6d8682001-11-28 21:10:39 +00001194 PyOS_snprintf(buf, sizeof(buf),
1195 DEL_CLOSURE_ERROR, name);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001196 com_error(c, PyExc_SyntaxError, buf);
1197 i = 255;
1198 break;
1199 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001200 }
1201 break;
1202 }
1203done:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001204 com_addoparg(c, op, i);
1205}
1206
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001207static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001208com_addopname(struct compiling *c, int op, node *n)
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001209{
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001210 char *name;
1211 char buffer[1000];
1212 /* XXX it is possible to write this code without the 1000
1213 chars on the total length of dotted names, I just can't be
1214 bothered right now */
1215 if (TYPE(n) == STAR)
1216 name = "*";
1217 else if (TYPE(n) == dotted_name) {
1218 char *p = buffer;
1219 int i;
1220 name = buffer;
1221 for (i = 0; i < NCH(n); i += 2) {
1222 char *s = STR(CHILD(n, i));
1223 if (p + strlen(s) > buffer + (sizeof buffer) - 2) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001224 com_error(c, PyExc_MemoryError,
Guido van Rossum452a9831996-09-17 14:32:04 +00001225 "dotted_name too long");
Guido van Rossumd9dfaf51995-02-17 15:04:57 +00001226 name = NULL;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001227 break;
1228 }
1229 if (p != buffer)
1230 *p++ = '.';
1231 strcpy(p, s);
1232 p = strchr(p, '\0');
1233 }
1234 }
1235 else {
1236 REQ(n, NAME);
1237 name = STR(n);
1238 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001239 com_addop_name(c, op, name);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001240}
1241
Guido van Rossum79f25d91997-04-29 20:08:16 +00001242static PyObject *
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001243parsenumber(struct compiling *c, char *s)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001244{
Guido van Rossumc5e96291991-12-10 13:53:51 +00001245 char *end;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001246 long x;
Guido van Rossum0ae748d1997-02-14 22:58:07 +00001247 double dx;
Guido van Rossum50564e81996-01-12 01:13:16 +00001248#ifndef WITHOUT_COMPLEX
Guido van Rossum50564e81996-01-12 01:13:16 +00001249 int imflag;
1250#endif
1251
Guido van Rossum282914b1991-04-04 10:42:56 +00001252 errno = 0;
Guido van Rossumc5e96291991-12-10 13:53:51 +00001253 end = s + strlen(s) - 1;
Guido van Rossum50564e81996-01-12 01:13:16 +00001254#ifndef WITHOUT_COMPLEX
Guido van Rossum15ad9a61996-01-26 20:53:56 +00001255 imflag = *end == 'j' || *end == 'J';
Guido van Rossum50564e81996-01-12 01:13:16 +00001256#endif
Guido van Rossumf1aeab71992-03-27 17:28:26 +00001257 if (*end == 'l' || *end == 'L')
Guido van Rossum79f25d91997-04-29 20:08:16 +00001258 return PyLong_FromString(s, (char **)0, 0);
Guido van Rossum078151d2002-08-11 04:24:12 +00001259 if (s[0] == '0') {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001260 x = (long) PyOS_strtoul(s, &end, 0);
Guido van Rossum078151d2002-08-11 04:24:12 +00001261 if (x < 0 && errno == 0) {
Guido van Rossum715eca92002-08-12 21:54:46 +00001262 if (PyErr_WarnExplicit(
Barry Warsaw9f007392002-08-14 15:51:29 +00001263 PyExc_FutureWarning,
Guido van Rossum715eca92002-08-12 21:54:46 +00001264 "hex/oct constants > sys.maxint "
1265 "will return positive values "
1266 "in Python 2.4 and up",
Martin v. Löwis95292d62002-12-11 14:04:59 +00001267 /* XXX: Give WarnExplicit
1268 a const char* argument. */
1269 (char*)c->c_filename,
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001270 c->c_lineno,
Guido van Rossum715eca92002-08-12 21:54:46 +00001271 NULL,
1272 NULL) < 0)
Guido van Rossum078151d2002-08-11 04:24:12 +00001273 return NULL;
Guido van Rossum3cb8e542002-08-11 14:06:15 +00001274 errno = 0; /* Might be changed by PyErr_Warn() */
Guido van Rossum078151d2002-08-11 04:24:12 +00001275 }
1276 }
Guido van Rossumacbefef1992-01-19 16:33:51 +00001277 else
Guido van Rossum79f25d91997-04-29 20:08:16 +00001278 x = PyOS_strtol(s, &end, 0);
Guido van Rossum282914b1991-04-04 10:42:56 +00001279 if (*end == '\0') {
Jeremy Hylton71b6af92001-08-27 19:45:25 +00001280 if (errno != 0)
1281 return PyLong_FromString(s, (char **)0, 0);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001282 return PyInt_FromLong(x);
Guido van Rossum282914b1991-04-04 10:42:56 +00001283 }
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00001284 /* XXX Huge floats may silently fail */
Guido van Rossum50564e81996-01-12 01:13:16 +00001285#ifndef WITHOUT_COMPLEX
1286 if (imflag) {
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001287 Py_complex z;
1288 z.real = 0.;
Guido van Rossum0ae748d1997-02-14 22:58:07 +00001289 PyFPE_START_PROTECT("atof", return 0)
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001290 z.imag = atof(s);
1291 PyFPE_END_PROTECT(z)
1292 return PyComplex_FromCComplex(z);
Guido van Rossum50564e81996-01-12 01:13:16 +00001293 }
Guido van Rossumac1fc951997-10-08 15:23:55 +00001294 else
Guido van Rossum50564e81996-01-12 01:13:16 +00001295#endif
Guido van Rossumac1fc951997-10-08 15:23:55 +00001296 {
Guido van Rossum0ae748d1997-02-14 22:58:07 +00001297 PyFPE_START_PROTECT("atof", return 0)
1298 dx = atof(s);
Guido van Rossum45b83911997-03-14 04:32:50 +00001299 PyFPE_END_PROTECT(dx)
Guido van Rossum79f25d91997-04-29 20:08:16 +00001300 return PyFloat_FromDouble(dx);
Guido van Rossum0ae748d1997-02-14 22:58:07 +00001301 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001302}
1303
Guido van Rossum79f25d91997-04-29 20:08:16 +00001304static PyObject *
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001305decode_utf8(char **sPtr, char *end, char* encoding)
1306{
Martin v. Löwis019934b2002-08-07 12:33:18 +00001307#ifndef Py_USING_UNICODE
Martin v. Löwis2863c102002-08-07 15:18:57 +00001308 Py_FatalError("decode_utf8 should not be called in this build.");
1309 return NULL;
Martin v. Löwis019934b2002-08-07 12:33:18 +00001310#else
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001311 PyObject *u, *v;
1312 char *s, *t;
1313 t = s = *sPtr;
1314 /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */
1315 while (s < end && (*s & 0x80)) s++;
1316 *sPtr = s;
1317 u = PyUnicode_DecodeUTF8(t, s - t, NULL);
1318 if (u == NULL)
1319 return NULL;
1320 v = PyUnicode_AsEncodedString(u, encoding, NULL);
1321 Py_DECREF(u);
1322 return v;
Martin v. Löwis019934b2002-08-07 12:33:18 +00001323#endif
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001324}
1325
Jeremy Hyltonaccb62b2002-12-31 18:17:44 +00001326/* compiler.transformer.Transformer.decode_literal depends on what
1327 might seem like minor details of this function -- changes here
1328 must be reflected there. */
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001329static PyObject *
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001330parsestr(struct compiling *c, char *s)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001331{
Guido van Rossum79f25d91997-04-29 20:08:16 +00001332 PyObject *v;
Guido van Rossum582acec2000-06-28 22:07:35 +00001333 size_t len;
Martin v. Löwis8a8da792002-08-14 07:46:28 +00001334 int quote = *s;
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001335 int rawmode = 0;
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001336 char* encoding = ((c == NULL) ? NULL : c->c_encoding);
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001337 int need_encoding;
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001338 int unicode = 0;
Guido van Rossum05459c52002-05-28 18:47:29 +00001339
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001340 if (isalpha(quote) || quote == '_') {
1341 if (quote == 'u' || quote == 'U') {
1342 quote = *++s;
1343 unicode = 1;
1344 }
1345 if (quote == 'r' || quote == 'R') {
1346 quote = *++s;
1347 rawmode = 1;
1348 }
1349 }
Guido van Rossum8054fad1993-10-26 15:19:44 +00001350 if (quote != '\'' && quote != '\"') {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001351 PyErr_BadInternalCall();
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001352 return NULL;
1353 }
1354 s++;
1355 len = strlen(s);
Guido van Rossum582acec2000-06-28 22:07:35 +00001356 if (len > INT_MAX) {
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001357 com_error(c, PyExc_OverflowError,
Martin v. Löwiscfeb3b62002-03-03 21:30:27 +00001358 "string to parse is too long");
Guido van Rossum582acec2000-06-28 22:07:35 +00001359 return NULL;
1360 }
Guido van Rossum8054fad1993-10-26 15:19:44 +00001361 if (s[--len] != quote) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001362 PyErr_BadInternalCall();
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001363 return NULL;
1364 }
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00001365 if (len >= 4 && s[0] == quote && s[1] == quote) {
1366 s += 2;
1367 len -= 2;
1368 if (s[--len] != quote || s[--len] != quote) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001369 PyErr_BadInternalCall();
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00001370 return NULL;
1371 }
1372 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001373#ifdef Py_USING_UNICODE
Guido van Rossumfdc8bdb2000-05-01 17:54:56 +00001374 if (unicode || Py_UnicodeFlag) {
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001375 PyObject *u, *w;
Walter Dörwald4c6c7652002-11-21 20:13:40 +00001376 char *buf;
1377 char *p;
1378 char *end;
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001379 if (encoding == NULL) {
1380 buf = s;
1381 u = NULL;
1382 } else if (strcmp(encoding, "iso-8859-1") == 0) {
1383 buf = s;
1384 u = NULL;
1385 } else {
1386 /* "\XX" may become "\u005c\uHHLL" (12 bytes) */
1387 u = PyString_FromStringAndSize((char *)NULL, len * 4);
1388 if (u == NULL)
1389 return NULL;
1390 p = buf = PyString_AsString(u);
1391 end = s + len;
1392 while (s < end) {
1393 if (*s == '\\') {
1394 *p++ = *s++;
1395 if (*s & 0x80) {
1396 strcpy(p, "u005c");
1397 p += 5;
1398 }
1399 }
1400 if (*s & 0x80) { /* XXX inefficient */
1401 char *r;
1402 int rn, i;
1403 w = decode_utf8(&s, end, "utf-16-be");
1404 if (w == NULL) {
1405 Py_DECREF(u);
1406 return NULL;
1407 }
1408 r = PyString_AsString(w);
1409 rn = PyString_Size(w);
1410 assert(rn % 2 == 0);
1411 for (i = 0; i < rn; i += 2) {
1412 sprintf(p, "\\u%02x%02x",
1413 r[i + 0] & 0xFF,
1414 r[i + 1] & 0xFF);
1415 p += 6;
1416 }
1417 Py_DECREF(w);
1418 } else {
1419 *p++ = *s++;
1420 }
1421 }
1422 len = p - buf;
1423 }
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001424 if (rawmode)
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001425 v = PyUnicode_DecodeRawUnicodeEscape(buf, len, NULL);
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001426 else
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001427 v = PyUnicode_DecodeUnicodeEscape(buf, len, NULL);
1428 Py_XDECREF(u);
Martin v. Löwiscfeb3b62002-03-03 21:30:27 +00001429 if (v == NULL)
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001430 PyErr_SyntaxLocation(c->c_filename, c->c_lineno);
Martin v. Löwiscfeb3b62002-03-03 21:30:27 +00001431 return v;
1432
Guido van Rossum5aa88f02000-03-10 23:01:36 +00001433 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001434#endif
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001435 need_encoding = (encoding != NULL &&
1436 strcmp(encoding, "utf-8") != 0 &&
1437 strcmp(encoding, "iso-8859-1") != 0);
1438 if (rawmode || strchr(s, '\\') == NULL) {
1439 if (need_encoding) {
Martin v. Löwis019934b2002-08-07 12:33:18 +00001440#ifndef Py_USING_UNICODE
1441 /* This should not happen - we never see any other
1442 encoding. */
Martin v. Löwis2863c102002-08-07 15:18:57 +00001443 Py_FatalError("cannot deal with encodings in this build.");
Martin v. Löwis019934b2002-08-07 12:33:18 +00001444#else
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001445 PyObject* u = PyUnicode_DecodeUTF8(s, len, NULL);
1446 if (u == NULL)
1447 return NULL;
1448 v = PyUnicode_AsEncodedString(u, encoding, NULL);
1449 Py_DECREF(u);
1450 return v;
Martin v. Löwis019934b2002-08-07 12:33:18 +00001451#endif
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00001452 } else {
1453 return PyString_FromStringAndSize(s, len);
1454 }
1455 }
Martin v. Löwis8a8da792002-08-14 07:46:28 +00001456
1457 v = PyString_DecodeEscape(s, len, NULL, unicode,
1458 need_encoding ? encoding : NULL);
Fredrik Lundh1fa0b892000-09-02 20:11:27 +00001459 if (v == NULL)
Guido van Rossumb081e0c2002-08-16 01:57:32 +00001460 PyErr_SyntaxLocation(c->c_filename, c->c_lineno);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001461 return v;
1462}
1463
Guido van Rossum79f25d91997-04-29 20:08:16 +00001464static PyObject *
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001465parsestrplus(struct compiling* c, node *n)
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001466{
Guido van Rossum79f25d91997-04-29 20:08:16 +00001467 PyObject *v;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001468 int i;
1469 REQ(CHILD(n, 0), STRING);
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001470 if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) {
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001471 /* String literal concatenation */
Fred Drake4e998bc2000-04-13 14:10:44 +00001472 for (i = 1; i < NCH(n); i++) {
1473 PyObject *s;
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001474 s = parsestr(c, STR(CHILD(n, i)));
Fred Drake4e998bc2000-04-13 14:10:44 +00001475 if (s == NULL)
1476 goto onError;
1477 if (PyString_Check(v) && PyString_Check(s)) {
1478 PyString_ConcatAndDel(&v, s);
1479 if (v == NULL)
1480 goto onError;
1481 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001482#ifdef Py_USING_UNICODE
Fred Drake4e998bc2000-04-13 14:10:44 +00001483 else {
1484 PyObject *temp;
1485 temp = PyUnicode_Concat(v, s);
1486 Py_DECREF(s);
1487 if (temp == NULL)
1488 goto onError;
1489 Py_DECREF(v);
1490 v = temp;
1491 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001492#endif
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001493 }
1494 }
1495 return v;
Fred Drake4e998bc2000-04-13 14:10:44 +00001496
1497 onError:
1498 Py_XDECREF(v);
1499 return NULL;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00001500}
1501
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001502static void
Skip Montanaro803d6e52000-08-12 18:09:51 +00001503com_list_for(struct compiling *c, node *n, node *e, char *t)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001504{
Skip Montanaro803d6e52000-08-12 18:09:51 +00001505 int anchor = 0;
1506 int save_begin = c->c_begin;
1507
1508 /* list_iter: for v in expr [list_iter] */
1509 com_node(c, CHILD(n, 3)); /* expr */
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001510 com_addbyte(c, GET_ITER);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001511 c->c_begin = c->c_nexti;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001512 com_addfwref(c, FOR_ITER, &anchor);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001513 com_push(c, 1);
Thomas Wouters434d0822000-08-24 20:11:32 +00001514 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001515 c->c_loops++;
1516 com_list_iter(c, n, e, t);
1517 c->c_loops--;
1518 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
1519 c->c_begin = save_begin;
1520 com_backpatch(c, anchor);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001521 com_pop(c, 1); /* FOR_ITER has popped this */
Skip Montanaro803d6e52000-08-12 18:09:51 +00001522}
1523
1524static void
1525com_list_if(struct compiling *c, node *n, node *e, char *t)
1526{
1527 int anchor = 0;
1528 int a = 0;
1529 /* list_iter: 'if' test [list_iter] */
Skip Montanaro803d6e52000-08-12 18:09:51 +00001530 com_node(c, CHILD(n, 1));
1531 com_addfwref(c, JUMP_IF_FALSE, &a);
1532 com_addbyte(c, POP_TOP);
1533 com_pop(c, 1);
1534 com_list_iter(c, n, e, t);
1535 com_addfwref(c, JUMP_FORWARD, &anchor);
1536 com_backpatch(c, a);
1537 /* We jump here with an extra entry which we now pop */
1538 com_addbyte(c, POP_TOP);
1539 com_backpatch(c, anchor);
1540}
1541
1542static void
1543com_list_iter(struct compiling *c,
1544 node *p, /* parent of list_iter node */
1545 node *e, /* element expression node */
1546 char *t /* name of result list temp local */)
1547{
1548 /* list_iter is the last child in a listmaker, list_for, or list_if */
1549 node *n = CHILD(p, NCH(p)-1);
1550 if (TYPE(n) == list_iter) {
1551 n = CHILD(n, 0);
1552 switch (TYPE(n)) {
1553 case list_for:
1554 com_list_for(c, n, e, t);
1555 break;
1556 case list_if:
1557 com_list_if(c, n, e, t);
1558 break;
1559 default:
1560 com_error(c, PyExc_SystemError,
1561 "invalid list_iter node type");
1562 }
1563 }
1564 else {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001565 com_addop_varname(c, VAR_LOAD, t);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001566 com_push(c, 1);
1567 com_node(c, e);
1568 com_addoparg(c, CALL_FUNCTION, 1);
1569 com_addbyte(c, POP_TOP);
1570 com_pop(c, 2);
1571 }
1572}
1573
1574static void
1575com_list_comprehension(struct compiling *c, node *n)
1576{
Skip Montanaro46dfa5f2000-08-22 02:43:07 +00001577 /* listmaker: test list_for */
Barry Warsaw8f6d8682001-11-28 21:10:39 +00001578 char tmpname[30];
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00001579
1580 REQ(n, listmaker);
Barry Warsaw8f6d8682001-11-28 21:10:39 +00001581 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", ++c->c_tmpname);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001582 com_addoparg(c, BUILD_LIST, 0);
1583 com_addbyte(c, DUP_TOP); /* leave the result on the stack */
1584 com_push(c, 2);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001585 com_addop_name(c, LOAD_ATTR, "append");
1586 com_addop_varname(c, VAR_STORE, tmpname);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001587 com_pop(c, 1);
Skip Montanaro46dfa5f2000-08-22 02:43:07 +00001588 com_list_for(c, CHILD(n, 1), CHILD(n, 0), tmpname);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001589 com_addop_varname(c, VAR_DELETE, tmpname);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001590 --c->c_tmpname;
1591}
1592
1593static void
1594com_listmaker(struct compiling *c, node *n)
1595{
Skip Montanaro46dfa5f2000-08-22 02:43:07 +00001596 /* listmaker: test ( list_for | (',' test)* [','] ) */
1597 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for)
Skip Montanaro803d6e52000-08-12 18:09:51 +00001598 com_list_comprehension(c, n);
1599 else {
1600 int len = 0;
1601 int i;
1602 for (i = 0; i < NCH(n); i += 2, len++)
1603 com_node(c, CHILD(n, i));
1604 com_addoparg(c, BUILD_LIST, len);
1605 com_pop(c, len-1);
1606 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001607}
1608
1609static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001610com_dictmaker(struct compiling *c, node *n)
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001611{
1612 int i;
1613 /* dictmaker: test ':' test (',' test ':' value)* [','] */
1614 for (i = 0; i+2 < NCH(n); i += 4) {
1615 /* We must arrange things just right for STORE_SUBSCR.
1616 It wants the stack to look like (value) (dict) (key) */
1617 com_addbyte(c, DUP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001618 com_push(c, 1);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001619 com_node(c, CHILD(n, i)); /* key */
Gustavo Niemeyer78429a62002-12-16 13:54:02 +00001620 com_node(c, CHILD(n, i+2)); /* value */
1621 com_addbyte(c, ROT_THREE);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001622 com_addbyte(c, STORE_SUBSCR);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001623 com_pop(c, 3);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001624 }
1625}
1626
1627static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001628com_atom(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001629{
1630 node *ch;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001631 PyObject *v;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001632 int i;
1633 REQ(n, atom);
1634 ch = CHILD(n, 0);
1635 switch (TYPE(ch)) {
1636 case LPAR:
Guido van Rossum8b993a91997-01-17 21:04:03 +00001637 if (TYPE(CHILD(n, 1)) == RPAR) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001638 com_addoparg(c, BUILD_TUPLE, 0);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001639 com_push(c, 1);
1640 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001641 else
1642 com_node(c, CHILD(n, 1));
1643 break;
Skip Montanaro803d6e52000-08-12 18:09:51 +00001644 case LSQB: /* '[' [listmaker] ']' */
Guido van Rossum8b993a91997-01-17 21:04:03 +00001645 if (TYPE(CHILD(n, 1)) == RSQB) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001646 com_addoparg(c, BUILD_LIST, 0);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001647 com_push(c, 1);
1648 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001649 else
Skip Montanaro803d6e52000-08-12 18:09:51 +00001650 com_listmaker(c, CHILD(n, 1));
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001651 break;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001652 case LBRACE: /* '{' [dictmaker] '}' */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001653 com_addoparg(c, BUILD_MAP, 0);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001654 com_push(c, 1);
Skip Montanaro803d6e52000-08-12 18:09:51 +00001655 if (TYPE(CHILD(n, 1)) == dictmaker)
Guido van Rossum4bad92c1991-07-27 21:34:52 +00001656 com_dictmaker(c, CHILD(n, 1));
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001657 break;
1658 case BACKQUOTE:
1659 com_node(c, CHILD(n, 1));
1660 com_addbyte(c, UNARY_CONVERT);
1661 break;
1662 case NUMBER:
Guido van Rossum452a9831996-09-17 14:32:04 +00001663 if ((v = parsenumber(c, STR(ch))) == NULL) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001664 i = 255;
1665 }
1666 else {
1667 i = com_addconst(c, v);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001668 Py_DECREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001669 }
1670 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001671 com_push(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001672 break;
1673 case STRING:
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001674 v = parsestrplus(c, n);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00001675 if (v == NULL) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001676 c->c_errors++;
1677 i = 255;
1678 }
1679 else {
1680 i = com_addconst(c, v);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001681 Py_DECREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001682 }
1683 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001684 com_push(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001685 break;
1686 case NAME:
Jeremy Hyltone36f7782001-01-19 03:21:30 +00001687 com_addop_varname(c, VAR_LOAD, STR(ch));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001688 com_push(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001689 break;
1690 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00001691 com_error(c, PyExc_SystemError,
1692 "com_atom: unexpected node type");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001693 }
1694}
1695
1696static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001697com_slice(struct compiling *c, node *n, int op)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001698{
1699 if (NCH(n) == 1) {
1700 com_addbyte(c, op);
1701 }
1702 else if (NCH(n) == 2) {
1703 if (TYPE(CHILD(n, 0)) != COLON) {
1704 com_node(c, CHILD(n, 0));
1705 com_addbyte(c, op+1);
1706 }
1707 else {
1708 com_node(c, CHILD(n, 1));
1709 com_addbyte(c, op+2);
1710 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00001711 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001712 }
1713 else {
1714 com_node(c, CHILD(n, 0));
1715 com_node(c, CHILD(n, 2));
1716 com_addbyte(c, op+3);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001717 com_pop(c, 2);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001718 }
1719}
1720
Guido van Rossum635abd21997-01-06 22:56:52 +00001721static void
Thomas Wouters434d0822000-08-24 20:11:32 +00001722com_augassign_slice(struct compiling *c, node *n, int opcode, node *augn)
1723{
1724 if (NCH(n) == 1) {
1725 com_addbyte(c, DUP_TOP);
1726 com_push(c, 1);
1727 com_addbyte(c, SLICE);
1728 com_node(c, augn);
1729 com_addbyte(c, opcode);
1730 com_pop(c, 1);
1731 com_addbyte(c, ROT_TWO);
1732 com_addbyte(c, STORE_SLICE);
1733 com_pop(c, 2);
1734 } else if (NCH(n) == 2 && TYPE(CHILD(n, 0)) != COLON) {
1735 com_node(c, CHILD(n, 0));
1736 com_addoparg(c, DUP_TOPX, 2);
1737 com_push(c, 2);
1738 com_addbyte(c, SLICE+1);
1739 com_pop(c, 1);
1740 com_node(c, augn);
1741 com_addbyte(c, opcode);
1742 com_pop(c, 1);
1743 com_addbyte(c, ROT_THREE);
1744 com_addbyte(c, STORE_SLICE+1);
1745 com_pop(c, 3);
1746 } else if (NCH(n) == 2) {
1747 com_node(c, CHILD(n, 1));
1748 com_addoparg(c, DUP_TOPX, 2);
1749 com_push(c, 2);
1750 com_addbyte(c, SLICE+2);
1751 com_pop(c, 1);
1752 com_node(c, augn);
1753 com_addbyte(c, opcode);
1754 com_pop(c, 1);
1755 com_addbyte(c, ROT_THREE);
1756 com_addbyte(c, STORE_SLICE+2);
1757 com_pop(c, 3);
1758 } else {
1759 com_node(c, CHILD(n, 0));
1760 com_node(c, CHILD(n, 2));
1761 com_addoparg(c, DUP_TOPX, 3);
1762 com_push(c, 3);
1763 com_addbyte(c, SLICE+3);
1764 com_pop(c, 2);
1765 com_node(c, augn);
1766 com_addbyte(c, opcode);
1767 com_pop(c, 1);
1768 com_addbyte(c, ROT_FOUR);
1769 com_addbyte(c, STORE_SLICE+3);
1770 com_pop(c, 4);
1771 }
1772}
1773
1774static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001775com_argument(struct compiling *c, node *n, PyObject **pkeywords)
Guido van Rossumf10570b1995-07-07 22:53:21 +00001776{
1777 node *m;
Guido van Rossum8b993a91997-01-17 21:04:03 +00001778 REQ(n, argument); /* [test '='] test; really [keyword '='] test */
Guido van Rossumf10570b1995-07-07 22:53:21 +00001779 if (NCH(n) == 1) {
Guido van Rossum635abd21997-01-06 22:56:52 +00001780 if (*pkeywords != NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001781 com_error(c, PyExc_SyntaxError,
Fred Drakedcf08e02000-08-15 15:49:44 +00001782 "non-keyword arg after keyword arg");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001783 }
1784 else {
1785 com_node(c, CHILD(n, 0));
1786 }
Guido van Rossum635abd21997-01-06 22:56:52 +00001787 return;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001788 }
1789 m = n;
1790 do {
1791 m = CHILD(m, 0);
1792 } while (NCH(m) == 1);
1793 if (TYPE(m) != NAME) {
Tim Peters4e303782001-02-18 04:45:10 +00001794 /* f(lambda x: x[0] = 3) ends up getting parsed with
1795 * LHS test = lambda x: x[0], and RHS test = 3.
1796 * SF bug 132313 points out that complaining about a keyword
1797 * then is very confusing.
1798 */
Guido van Rossum79f25d91997-04-29 20:08:16 +00001799 com_error(c, PyExc_SyntaxError,
Tim Peters4e303782001-02-18 04:45:10 +00001800 TYPE(m) == lambdef ?
1801 "lambda cannot contain assignment" :
1802 "keyword can't be an expression");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001803 }
1804 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001805 PyObject *v = PyString_InternFromString(STR(m));
Guido van Rossum63dd79a2002-08-16 02:24:56 +00001806 (void) none_assignment_check(c, STR(m), 1);
Guido van Rossum635abd21997-01-06 22:56:52 +00001807 if (v != NULL && *pkeywords == NULL)
Guido van Rossum79f25d91997-04-29 20:08:16 +00001808 *pkeywords = PyDict_New();
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00001809 if (v == NULL)
Guido van Rossumf10570b1995-07-07 22:53:21 +00001810 c->c_errors++;
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00001811 else if (*pkeywords == NULL) {
1812 c->c_errors++;
1813 Py_DECREF(v);
1814 } else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001815 if (PyDict_GetItem(*pkeywords, v) != NULL)
1816 com_error(c, PyExc_SyntaxError,
Guido van Rossum635abd21997-01-06 22:56:52 +00001817 "duplicate keyword argument");
1818 else
Guido van Rossum79f25d91997-04-29 20:08:16 +00001819 if (PyDict_SetItem(*pkeywords, v, v) != 0)
Guido van Rossum635abd21997-01-06 22:56:52 +00001820 c->c_errors++;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001821 com_addoparg(c, LOAD_CONST, com_addconst(c, v));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001822 com_push(c, 1);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001823 Py_DECREF(v);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001824 }
1825 }
1826 com_node(c, CHILD(n, 2));
Guido van Rossumf10570b1995-07-07 22:53:21 +00001827}
1828
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001829static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001830com_call_function(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001831{
1832 if (TYPE(n) == RPAR) {
Guido van Rossumf10570b1995-07-07 22:53:21 +00001833 com_addoparg(c, CALL_FUNCTION, 0);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001834 }
1835 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001836 PyObject *keywords = NULL;
Guido van Rossum635abd21997-01-06 22:56:52 +00001837 int i, na, nk;
Guido van Rossumca906051998-12-10 16:56:22 +00001838 int lineno = n->n_lineno;
Jeremy Hylton76901512000-03-28 23:49:17 +00001839 int star_flag = 0;
1840 int starstar_flag = 0;
1841 int opcode;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001842 REQ(n, arglist);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001843 na = 0;
1844 nk = 0;
1845 for (i = 0; i < NCH(n); i += 2) {
Guido van Rossumca906051998-12-10 16:56:22 +00001846 node *ch = CHILD(n, i);
Jeremy Hylton76901512000-03-28 23:49:17 +00001847 if (TYPE(ch) == STAR ||
1848 TYPE(ch) == DOUBLESTAR)
1849 break;
Guido van Rossumca906051998-12-10 16:56:22 +00001850 if (ch->n_lineno != lineno) {
1851 lineno = ch->n_lineno;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00001852 com_set_lineno(c, lineno);
Guido van Rossumca906051998-12-10 16:56:22 +00001853 }
1854 com_argument(c, ch, &keywords);
Guido van Rossum635abd21997-01-06 22:56:52 +00001855 if (keywords == NULL)
Guido van Rossumf10570b1995-07-07 22:53:21 +00001856 na++;
1857 else
1858 nk++;
1859 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00001860 Py_XDECREF(keywords);
Jeremy Hylton76901512000-03-28 23:49:17 +00001861 while (i < NCH(n)) {
1862 node *tok = CHILD(n, i);
1863 node *ch = CHILD(n, i+1);
1864 i += 3;
1865 switch (TYPE(tok)) {
1866 case STAR: star_flag = 1; break;
1867 case DOUBLESTAR: starstar_flag = 1; break;
1868 }
1869 com_node(c, ch);
1870 }
Guido van Rossumf10570b1995-07-07 22:53:21 +00001871 if (na > 255 || nk > 255) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001872 com_error(c, PyExc_SyntaxError,
1873 "more than 255 arguments");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001874 }
Jeremy Hylton76901512000-03-28 23:49:17 +00001875 if (star_flag || starstar_flag)
Jeremy Hyltone4fb9582000-03-29 00:10:44 +00001876 opcode = CALL_FUNCTION_VAR - 1 +
Jeremy Hylton76901512000-03-28 23:49:17 +00001877 star_flag + (starstar_flag << 1);
1878 else
1879 opcode = CALL_FUNCTION;
1880 com_addoparg(c, opcode, na | (nk << 8));
1881 com_pop(c, na + 2*nk + star_flag + starstar_flag);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001882 }
1883}
1884
1885static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001886com_select_member(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00001887{
1888 com_addopname(c, LOAD_ATTR, n);
1889}
1890
1891static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001892com_sliceobj(struct compiling *c, node *n)
Guido van Rossum8861b741996-07-30 16:49:37 +00001893{
1894 int i=0;
1895 int ns=2; /* number of slice arguments */
Guido van Rossum8861b741996-07-30 16:49:37 +00001896 node *ch;
1897
1898 /* first argument */
1899 if (TYPE(CHILD(n,i)) == COLON) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001900 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001901 com_push(c, 1);
Guido van Rossum8861b741996-07-30 16:49:37 +00001902 i++;
1903 }
1904 else {
1905 com_node(c, CHILD(n,i));
1906 i++;
1907 REQ(CHILD(n,i),COLON);
1908 i++;
1909 }
1910 /* second argument */
1911 if (i < NCH(n) && TYPE(CHILD(n,i)) == test) {
1912 com_node(c, CHILD(n,i));
1913 i++;
1914 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00001915 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001916 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001917 com_push(c, 1);
1918 }
Guido van Rossum8861b741996-07-30 16:49:37 +00001919 /* remaining arguments */
1920 for (; i < NCH(n); i++) {
1921 ns++;
1922 ch=CHILD(n,i);
1923 REQ(ch, sliceop);
1924 if (NCH(ch) == 1) {
1925 /* right argument of ':' missing */
Guido van Rossum79f25d91997-04-29 20:08:16 +00001926 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001927 com_push(c, 1);
Guido van Rossum8861b741996-07-30 16:49:37 +00001928 }
1929 else
1930 com_node(c, CHILD(ch,1));
1931 }
1932 com_addoparg(c, BUILD_SLICE, ns);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001933 com_pop(c, 1 + (ns == 3));
Guido van Rossum8861b741996-07-30 16:49:37 +00001934}
1935
1936static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001937com_subscript(struct compiling *c, node *n)
Guido van Rossum8861b741996-07-30 16:49:37 +00001938{
1939 node *ch;
1940 REQ(n, subscript);
1941 ch = CHILD(n,0);
1942 /* check for rubber index */
Guido van Rossum8b993a91997-01-17 21:04:03 +00001943 if (TYPE(ch) == DOT && TYPE(CHILD(n,1)) == DOT) {
Guido van Rossume449af71996-10-11 16:25:41 +00001944 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_Ellipsis));
Guido van Rossum8b993a91997-01-17 21:04:03 +00001945 com_push(c, 1);
1946 }
Guido van Rossum8861b741996-07-30 16:49:37 +00001947 else {
1948 /* check for slice */
1949 if ((TYPE(ch) == COLON || NCH(n) > 1))
1950 com_sliceobj(c, n);
1951 else {
1952 REQ(ch, test);
1953 com_node(c, ch);
1954 }
1955 }
1956}
1957
1958static void
Thomas Wouters434d0822000-08-24 20:11:32 +00001959com_subscriptlist(struct compiling *c, node *n, int assigning, node *augn)
Guido van Rossum8861b741996-07-30 16:49:37 +00001960{
1961 int i, op;
1962 REQ(n, subscriptlist);
1963 /* Check to make backward compatible slice behavior for '[i:j]' */
1964 if (NCH(n) == 1) {
1965 node *sub = CHILD(n, 0); /* subscript */
Thomas Wouterse8643c42000-08-05 21:37:50 +00001966 /* 'Basic' slice, should have exactly one colon. */
1967 if ((TYPE(CHILD(sub, 0)) == COLON
1968 || (NCH(sub) > 1 && TYPE(CHILD(sub, 1)) == COLON))
1969 && (TYPE(CHILD(sub,NCH(sub)-1)) != sliceop))
1970 {
Thomas Wouters434d0822000-08-24 20:11:32 +00001971 switch (assigning) {
1972 case OP_DELETE:
1973 op = DELETE_SLICE;
1974 break;
1975 case OP_ASSIGN:
1976 op = STORE_SLICE;
1977 break;
1978 case OP_APPLY:
Guido van Rossum8861b741996-07-30 16:49:37 +00001979 op = SLICE;
Thomas Wouters434d0822000-08-24 20:11:32 +00001980 break;
1981 default:
1982 com_augassign_slice(c, sub, assigning, augn);
1983 return;
1984 }
Guido van Rossum8861b741996-07-30 16:49:37 +00001985 com_slice(c, sub, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00001986 if (op == STORE_SLICE)
1987 com_pop(c, 2);
1988 else if (op == DELETE_SLICE)
1989 com_pop(c, 1);
Guido van Rossum8861b741996-07-30 16:49:37 +00001990 return;
1991 }
1992 }
1993 /* Else normal subscriptlist. Compile each subscript. */
1994 for (i = 0; i < NCH(n); i += 2)
1995 com_subscript(c, CHILD(n, i));
1996 /* Put multiple subscripts into a tuple */
Guido van Rossum8b993a91997-01-17 21:04:03 +00001997 if (NCH(n) > 1) {
1998 i = (NCH(n)+1) / 2;
1999 com_addoparg(c, BUILD_TUPLE, i);
2000 com_pop(c, i-1);
2001 }
Thomas Wouters434d0822000-08-24 20:11:32 +00002002 switch (assigning) {
2003 case OP_DELETE:
Guido van Rossum8b993a91997-01-17 21:04:03 +00002004 op = DELETE_SUBSCR;
2005 i = 2;
Thomas Wouters434d0822000-08-24 20:11:32 +00002006 break;
2007 default:
2008 case OP_ASSIGN:
2009 op = STORE_SUBSCR;
2010 i = 3;
2011 break;
2012 case OP_APPLY:
2013 op = BINARY_SUBSCR;
2014 i = 1;
2015 break;
2016 }
2017 if (assigning > OP_APPLY) {
2018 com_addoparg(c, DUP_TOPX, 2);
2019 com_push(c, 2);
2020 com_addbyte(c, BINARY_SUBSCR);
2021 com_pop(c, 1);
2022 com_node(c, augn);
2023 com_addbyte(c, assigning);
2024 com_pop(c, 1);
2025 com_addbyte(c, ROT_THREE);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002026 }
Guido van Rossum8861b741996-07-30 16:49:37 +00002027 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002028 com_pop(c, i);
Guido van Rossum8861b741996-07-30 16:49:37 +00002029}
2030
2031static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002032com_apply_trailer(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002033{
2034 REQ(n, trailer);
2035 switch (TYPE(CHILD(n, 0))) {
2036 case LPAR:
2037 com_call_function(c, CHILD(n, 1));
2038 break;
2039 case DOT:
2040 com_select_member(c, CHILD(n, 1));
2041 break;
2042 case LSQB:
Thomas Wouters434d0822000-08-24 20:11:32 +00002043 com_subscriptlist(c, CHILD(n, 1), OP_APPLY, NULL);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002044 break;
2045 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002046 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002047 "com_apply_trailer: unknown trailer type");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002048 }
2049}
2050
2051static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002052com_power(struct compiling *c, node *n)
Guido van Rossum50564e81996-01-12 01:13:16 +00002053{
2054 int i;
2055 REQ(n, power);
2056 com_atom(c, CHILD(n, 0));
2057 for (i = 1; i < NCH(n); i++) {
2058 if (TYPE(CHILD(n, i)) == DOUBLESTAR) {
2059 com_factor(c, CHILD(n, i+1));
2060 com_addbyte(c, BINARY_POWER);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002061 com_pop(c, 1);
Guido van Rossum50564e81996-01-12 01:13:16 +00002062 break;
2063 }
2064 else
2065 com_apply_trailer(c, CHILD(n, i));
2066 }
2067}
2068
2069static void
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002070com_invert_constant(struct compiling *c, node *n)
2071{
2072 /* Compute the inverse of int and longs and use them directly,
2073 but be prepared to generate code for all other
2074 possibilities (invalid numbers, floats, complex).
2075 */
2076 PyObject *num, *inv = NULL;
2077 int i;
2078
2079 REQ(n, NUMBER);
2080 num = parsenumber(c, STR(n));
2081 if (num == NULL)
2082 i = 255;
2083 else {
2084 inv = PyNumber_Invert(num);
2085 if (inv == NULL) {
2086 PyErr_Clear();
2087 i = com_addconst(c, num);
2088 } else {
2089 i = com_addconst(c, inv);
2090 Py_DECREF(inv);
2091 }
2092 Py_DECREF(num);
2093 }
2094 com_addoparg(c, LOAD_CONST, i);
2095 com_push(c, 1);
2096 if (num != NULL && inv == NULL)
2097 com_addbyte(c, UNARY_INVERT);
2098}
2099
Tim Peters51e26512001-09-07 08:45:55 +00002100static int
2101is_float_zero(const char *p)
2102{
2103 int found_radix_point = 0;
2104 int ch;
2105 while ((ch = Py_CHARMASK(*p++)) != '\0') {
2106 switch (ch) {
2107 case '0':
2108 /* no reason to believe it's not 0 -- continue */
2109 break;
2110
2111 case 'e': case 'E': case 'j': case 'J':
2112 /* If this was a hex constant, we already would have
2113 returned 0 due to the 'x' or 'X', so 'e' or 'E'
2114 must be an exponent marker, and we haven't yet
2115 seen a non-zero digit, and it doesn't matter what
2116 the exponent is then. For 'j' or 'J' similarly,
2117 except that this is an imaginary 0 then. */
2118 return 1;
2119
2120 case '.':
2121 found_radix_point = 1;
2122 break;
2123
2124 default:
2125 return 0;
2126 }
2127 }
2128 return found_radix_point;
2129}
2130
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002131static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002132com_factor(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002133{
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002134 int childtype = TYPE(CHILD(n, 0));
Tim Peters51e26512001-09-07 08:45:55 +00002135 node *pfactor, *ppower, *patom, *pnum;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002136 REQ(n, factor);
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002137 /* If the unary +, -, or ~ operator is applied to a constant,
Tim Peters51e26512001-09-07 08:45:55 +00002138 don't generate a UNARY_xxx opcode. Just store the
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002139 approriate value as a constant. If the value is negative,
2140 extend the string containing the constant and insert a
Tim Peters51e26512001-09-07 08:45:55 +00002141 negative in the 0th position -- unless we're doing unary minus
2142 of a floating zero! In that case the sign is significant, but
2143 the const dict can't distinguish +0.0 from -0.0.
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002144 */
2145 if ((childtype == PLUS || childtype == MINUS || childtype == TILDE)
Fred Drake14ef2442001-08-30 18:53:25 +00002146 && NCH(n) == 2
Tim Peters51e26512001-09-07 08:45:55 +00002147 && TYPE((pfactor = CHILD(n, 1))) == factor
2148 && NCH(pfactor) == 1
2149 && TYPE((ppower = CHILD(pfactor, 0))) == power
2150 && NCH(ppower) == 1
2151 && TYPE((patom = CHILD(ppower, 0))) == atom
2152 && TYPE((pnum = CHILD(patom, 0))) == NUMBER
Guido van Rossum66b12592003-02-12 16:57:47 +00002153 && !(childtype == MINUS &&
2154 (STR(pnum)[0] == '0' || is_float_zero(STR(pnum))))) {
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002155 if (childtype == TILDE) {
Tim Peters51e26512001-09-07 08:45:55 +00002156 com_invert_constant(c, pnum);
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002157 return;
2158 }
2159 if (childtype == MINUS) {
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +00002160 char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2);
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002161 if (s == NULL) {
2162 com_error(c, PyExc_MemoryError, "");
2163 com_addbyte(c, 255);
2164 return;
2165 }
2166 s[0] = '-';
Tim Peters51e26512001-09-07 08:45:55 +00002167 strcpy(s + 1, STR(pnum));
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +00002168 PyObject_FREE(STR(pnum));
Tim Peters51e26512001-09-07 08:45:55 +00002169 STR(pnum) = s;
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002170 }
Tim Peters51e26512001-09-07 08:45:55 +00002171 com_atom(c, patom);
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002172 }
2173 else if (childtype == PLUS) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002174 com_factor(c, CHILD(n, 1));
2175 com_addbyte(c, UNARY_POSITIVE);
2176 }
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002177 else if (childtype == MINUS) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002178 com_factor(c, CHILD(n, 1));
2179 com_addbyte(c, UNARY_NEGATIVE);
2180 }
Jeremy Hyltond5e5a2a2001-08-12 01:54:38 +00002181 else if (childtype == TILDE) {
Guido van Rossum7928cd71991-10-24 14:59:31 +00002182 com_factor(c, CHILD(n, 1));
2183 com_addbyte(c, UNARY_INVERT);
2184 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002185 else {
Guido van Rossum50564e81996-01-12 01:13:16 +00002186 com_power(c, CHILD(n, 0));
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002187 }
2188}
2189
2190static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002191com_term(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002192{
2193 int i;
2194 int op;
2195 REQ(n, term);
2196 com_factor(c, CHILD(n, 0));
2197 for (i = 2; i < NCH(n); i += 2) {
2198 com_factor(c, CHILD(n, i));
2199 switch (TYPE(CHILD(n, i-1))) {
2200 case STAR:
2201 op = BINARY_MULTIPLY;
2202 break;
2203 case SLASH:
Guido van Rossum4668b002001-08-08 05:00:18 +00002204 if (c->c_flags & CO_FUTURE_DIVISION)
2205 op = BINARY_TRUE_DIVIDE;
2206 else
2207 op = BINARY_DIVIDE;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002208 break;
2209 case PERCENT:
2210 op = BINARY_MODULO;
2211 break;
Guido van Rossum4668b002001-08-08 05:00:18 +00002212 case DOUBLESLASH:
2213 op = BINARY_FLOOR_DIVIDE;
2214 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002215 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002216 com_error(c, PyExc_SystemError,
Guido van Rossum4668b002001-08-08 05:00:18 +00002217 "com_term: operator not *, /, // or %");
Guido van Rossum7928cd71991-10-24 14:59:31 +00002218 op = 255;
2219 }
2220 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002221 com_pop(c, 1);
Guido van Rossum7928cd71991-10-24 14:59:31 +00002222 }
2223}
2224
2225static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002226com_arith_expr(struct compiling *c, node *n)
Guido van Rossum7928cd71991-10-24 14:59:31 +00002227{
2228 int i;
2229 int op;
2230 REQ(n, arith_expr);
2231 com_term(c, CHILD(n, 0));
2232 for (i = 2; i < NCH(n); i += 2) {
2233 com_term(c, CHILD(n, i));
2234 switch (TYPE(CHILD(n, i-1))) {
2235 case PLUS:
2236 op = BINARY_ADD;
2237 break;
2238 case MINUS:
2239 op = BINARY_SUBTRACT;
2240 break;
2241 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002242 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002243 "com_arith_expr: operator not + or -");
Guido van Rossum7928cd71991-10-24 14:59:31 +00002244 op = 255;
2245 }
2246 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002247 com_pop(c, 1);
Guido van Rossum7928cd71991-10-24 14:59:31 +00002248 }
2249}
2250
2251static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002252com_shift_expr(struct compiling *c, node *n)
Guido van Rossum7928cd71991-10-24 14:59:31 +00002253{
2254 int i;
2255 int op;
2256 REQ(n, shift_expr);
2257 com_arith_expr(c, CHILD(n, 0));
2258 for (i = 2; i < NCH(n); i += 2) {
2259 com_arith_expr(c, CHILD(n, i));
2260 switch (TYPE(CHILD(n, i-1))) {
2261 case LEFTSHIFT:
2262 op = BINARY_LSHIFT;
2263 break;
2264 case RIGHTSHIFT:
2265 op = BINARY_RSHIFT;
2266 break;
2267 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002268 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002269 "com_shift_expr: operator not << or >>");
Guido van Rossum7928cd71991-10-24 14:59:31 +00002270 op = 255;
2271 }
2272 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002273 com_pop(c, 1);
Guido van Rossum7928cd71991-10-24 14:59:31 +00002274 }
2275}
2276
2277static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002278com_and_expr(struct compiling *c, node *n)
Guido van Rossum7928cd71991-10-24 14:59:31 +00002279{
2280 int i;
2281 int op;
2282 REQ(n, and_expr);
2283 com_shift_expr(c, CHILD(n, 0));
2284 for (i = 2; i < NCH(n); i += 2) {
2285 com_shift_expr(c, CHILD(n, i));
2286 if (TYPE(CHILD(n, i-1)) == AMPER) {
2287 op = BINARY_AND;
2288 }
2289 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002290 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002291 "com_and_expr: operator not &");
Guido van Rossum7928cd71991-10-24 14:59:31 +00002292 op = 255;
2293 }
2294 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002295 com_pop(c, 1);
Guido van Rossum7928cd71991-10-24 14:59:31 +00002296 }
2297}
2298
2299static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002300com_xor_expr(struct compiling *c, node *n)
Guido van Rossum7928cd71991-10-24 14:59:31 +00002301{
2302 int i;
2303 int op;
2304 REQ(n, xor_expr);
2305 com_and_expr(c, CHILD(n, 0));
2306 for (i = 2; i < NCH(n); i += 2) {
2307 com_and_expr(c, CHILD(n, i));
2308 if (TYPE(CHILD(n, i-1)) == CIRCUMFLEX) {
2309 op = BINARY_XOR;
2310 }
2311 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002312 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002313 "com_xor_expr: operator not ^");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002314 op = 255;
2315 }
2316 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002317 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002318 }
2319}
2320
2321static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002322com_expr(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002323{
2324 int i;
2325 int op;
2326 REQ(n, expr);
Guido van Rossum7928cd71991-10-24 14:59:31 +00002327 com_xor_expr(c, CHILD(n, 0));
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002328 for (i = 2; i < NCH(n); i += 2) {
Guido van Rossum7928cd71991-10-24 14:59:31 +00002329 com_xor_expr(c, CHILD(n, i));
2330 if (TYPE(CHILD(n, i-1)) == VBAR) {
2331 op = BINARY_OR;
2332 }
2333 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002334 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002335 "com_expr: expr operator not |");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002336 op = 255;
2337 }
2338 com_addbyte(c, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002339 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002340 }
2341}
2342
2343static enum cmp_op
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002344cmp_type(node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002345{
2346 REQ(n, comp_op);
Tim Peters12d55a72003-05-12 19:16:52 +00002347 /* comp_op: '<' | '>' | '>=' | '<=' | '<>' | '!=' | '=='
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002348 | 'in' | 'not' 'in' | 'is' | 'is' not' */
2349 if (NCH(n) == 1) {
2350 n = CHILD(n, 0);
2351 switch (TYPE(n)) {
Martin v. Löwis7198a522002-01-01 19:59:11 +00002352 case LESS: return PyCmp_LT;
2353 case GREATER: return PyCmp_GT;
Tim Peters12d55a72003-05-12 19:16:52 +00002354 case EQEQUAL: return PyCmp_EQ;
Martin v. Löwis7198a522002-01-01 19:59:11 +00002355 case LESSEQUAL: return PyCmp_LE;
2356 case GREATEREQUAL: return PyCmp_GE;
2357 case NOTEQUAL: return PyCmp_NE; /* <> or != */
2358 case NAME: if (strcmp(STR(n), "in") == 0) return PyCmp_IN;
2359 if (strcmp(STR(n), "is") == 0) return PyCmp_IS;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002360 }
2361 }
2362 else if (NCH(n) == 2) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002363 switch (TYPE(CHILD(n, 0))) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002364 case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0)
Martin v. Löwis7198a522002-01-01 19:59:11 +00002365 return PyCmp_NOT_IN;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002366 if (strcmp(STR(CHILD(n, 0)), "is") == 0)
Martin v. Löwis7198a522002-01-01 19:59:11 +00002367 return PyCmp_IS_NOT;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002368 }
2369 }
Martin v. Löwis7198a522002-01-01 19:59:11 +00002370 return PyCmp_BAD;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002371}
2372
2373static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002374com_comparison(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002375{
2376 int i;
2377 enum cmp_op op;
2378 int anchor;
2379 REQ(n, comparison); /* comparison: expr (comp_op expr)* */
2380 com_expr(c, CHILD(n, 0));
2381 if (NCH(n) == 1)
2382 return;
2383
2384 /****************************************************************
2385 The following code is generated for all but the last
2386 comparison in a chain:
2387
2388 label: on stack: opcode: jump to:
2389
2390 a <code to load b>
2391 a, b DUP_TOP
2392 a, b, b ROT_THREE
2393 b, a, b COMPARE_OP
2394 b, 0-or-1 JUMP_IF_FALSE L1
2395 b, 1 POP_TOP
2396 b
2397
2398 We are now ready to repeat this sequence for the next
2399 comparison in the chain.
2400
2401 For the last we generate:
2402
2403 b <code to load c>
2404 b, c COMPARE_OP
2405 0-or-1
2406
2407 If there were any jumps to L1 (i.e., there was more than one
2408 comparison), we generate:
2409
2410 0-or-1 JUMP_FORWARD L2
2411 L1: b, 0 ROT_TWO
2412 0, b POP_TOP
2413 0
Guido van Rossum8b993a91997-01-17 21:04:03 +00002414 L2: 0-or-1
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002415 ****************************************************************/
2416
2417 anchor = 0;
2418
2419 for (i = 2; i < NCH(n); i += 2) {
2420 com_expr(c, CHILD(n, i));
2421 if (i+2 < NCH(n)) {
2422 com_addbyte(c, DUP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002423 com_push(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002424 com_addbyte(c, ROT_THREE);
2425 }
2426 op = cmp_type(CHILD(n, i-1));
Martin v. Löwis7198a522002-01-01 19:59:11 +00002427 if (op == PyCmp_BAD) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002428 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002429 "com_comparison: unknown comparison op");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002430 }
2431 com_addoparg(c, COMPARE_OP, op);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002432 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002433 if (i+2 < NCH(n)) {
2434 com_addfwref(c, JUMP_IF_FALSE, &anchor);
2435 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002436 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002437 }
2438 }
2439
2440 if (anchor) {
2441 int anchor2 = 0;
2442 com_addfwref(c, JUMP_FORWARD, &anchor2);
2443 com_backpatch(c, anchor);
2444 com_addbyte(c, ROT_TWO);
2445 com_addbyte(c, POP_TOP);
2446 com_backpatch(c, anchor2);
2447 }
2448}
2449
2450static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002451com_not_test(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002452{
2453 REQ(n, not_test); /* 'not' not_test | comparison */
2454 if (NCH(n) == 1) {
2455 com_comparison(c, CHILD(n, 0));
2456 }
2457 else {
2458 com_not_test(c, CHILD(n, 1));
2459 com_addbyte(c, UNARY_NOT);
2460 }
2461}
2462
2463static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002464com_and_test(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002465{
2466 int i;
2467 int anchor;
2468 REQ(n, and_test); /* not_test ('and' not_test)* */
2469 anchor = 0;
2470 i = 0;
2471 for (;;) {
2472 com_not_test(c, CHILD(n, i));
2473 if ((i += 2) >= NCH(n))
2474 break;
2475 com_addfwref(c, JUMP_IF_FALSE, &anchor);
2476 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002477 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002478 }
2479 if (anchor)
2480 com_backpatch(c, anchor);
2481}
2482
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002483static int
2484com_make_closure(struct compiling *c, PyCodeObject *co)
2485{
Jeremy Hylton733c8932001-12-13 19:51:56 +00002486 int i, free = PyCode_GetNumFree(co);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002487 if (free == 0)
2488 return 0;
2489 for (i = 0; i < free; ++i) {
2490 /* Bypass com_addop_varname because it will generate
2491 LOAD_DEREF but LOAD_CLOSURE is needed.
2492 */
2493 PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i);
2494 int arg, reftype;
2495
2496 /* Special case: If a class contains a method with a
2497 free variable that has the same name as a method,
2498 the name will be considered free *and* local in the
2499 class. It should be handled by the closure, as
2500 well as by the normal name loookup logic.
2501 */
2502 reftype = get_ref_type(c, PyString_AS_STRING(name));
2503 if (reftype == CELL)
2504 arg = com_lookup_arg(c->c_cellvars, name);
2505 else /* (reftype == FREE) */
2506 arg = com_lookup_arg(c->c_freevars, name);
2507 if (arg == -1) {
Jeremy Hylton78891072001-03-01 06:09:34 +00002508 fprintf(stderr, "lookup %s in %s %d %d\n"
2509 "freevars of %s: %s\n",
2510 PyObject_REPR(name),
2511 c->c_name,
2512 reftype, arg,
2513 PyString_AS_STRING(co->co_name),
2514 PyObject_REPR(co->co_freevars));
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002515 Py_FatalError("com_make_closure()");
2516 }
2517 com_addoparg(c, LOAD_CLOSURE, arg);
2518
2519 }
2520 com_push(c, free);
2521 return 1;
2522}
2523
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002524static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002525com_test(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002526{
Guido van Rossum8b993a91997-01-17 21:04:03 +00002527 REQ(n, test); /* and_test ('or' and_test)* | lambdef */
Guido van Rossum57531fe1993-11-30 14:57:42 +00002528 if (NCH(n) == 1 && TYPE(CHILD(n, 0)) == lambdef) {
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002529 PyCodeObject *co;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002530 int i, closure;
Guido van Rossum681d79a1995-07-18 14:51:37 +00002531 int ndefs = com_argdefs(c, CHILD(n, 0));
Jeremy Hylton4b38da62001-02-02 18:19:15 +00002532 symtable_enter_scope(c->c_symtable, "lambda", lambdef,
2533 n->n_lineno);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002534 co = icompile(CHILD(n, 0), c);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00002535 if (co == NULL) {
2536 c->c_errors++;
2537 return;
2538 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00002539 symtable_exit_scope(c->c_symtable);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002540 i = com_addconst(c, (PyObject *)co);
2541 closure = com_make_closure(c, co);
Guido van Rossum57531fe1993-11-30 14:57:42 +00002542 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002543 com_push(c, 1);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002544 if (closure) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002545 com_addoparg(c, MAKE_CLOSURE, ndefs);
Jeremy Hylton733c8932001-12-13 19:51:56 +00002546 com_pop(c, PyCode_GetNumFree(co));
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002547 } else
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002548 com_addoparg(c, MAKE_FUNCTION, ndefs);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00002549 Py_DECREF(co);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002550 com_pop(c, ndefs);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002551 }
Guido van Rossum57531fe1993-11-30 14:57:42 +00002552 else {
2553 int anchor = 0;
2554 int i = 0;
2555 for (;;) {
2556 com_and_test(c, CHILD(n, i));
2557 if ((i += 2) >= NCH(n))
2558 break;
2559 com_addfwref(c, JUMP_IF_TRUE, &anchor);
2560 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002561 com_pop(c, 1);
Guido van Rossum57531fe1993-11-30 14:57:42 +00002562 }
2563 if (anchor)
2564 com_backpatch(c, anchor);
2565 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002566}
2567
2568static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002569com_list(struct compiling *c, node *n, int toplevel)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002570{
2571 /* exprlist: expr (',' expr)* [',']; likewise for testlist */
Guido van Rossum288a60f1991-12-16 13:05:10 +00002572 if (NCH(n) == 1 && !toplevel) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002573 com_node(c, CHILD(n, 0));
2574 }
2575 else {
2576 int i;
2577 int len;
2578 len = (NCH(n) + 1) / 2;
2579 for (i = 0; i < NCH(n); i += 2)
2580 com_node(c, CHILD(n, i));
2581 com_addoparg(c, BUILD_TUPLE, len);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002582 com_pop(c, len-1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002583 }
2584}
2585
2586
2587/* Begin of assignment compilation */
2588
Thomas Wouters434d0822000-08-24 20:11:32 +00002589
2590static void
2591com_augassign_attr(struct compiling *c, node *n, int opcode, node *augn)
2592{
2593 com_addbyte(c, DUP_TOP);
2594 com_push(c, 1);
2595 com_addopname(c, LOAD_ATTR, n);
Thomas Wouters434d0822000-08-24 20:11:32 +00002596 com_node(c, augn);
2597 com_addbyte(c, opcode);
2598 com_pop(c, 1);
2599 com_addbyte(c, ROT_TWO);
2600 com_addopname(c, STORE_ATTR, n);
2601 com_pop(c, 2);
2602}
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002603
2604static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002605com_assign_attr(struct compiling *c, node *n, int assigning)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002606{
Guido van Rossum3ac99d42002-08-16 02:13:49 +00002607 if (none_assignment_check(c, STR(n), assigning))
2608 return;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002609 com_addopname(c, assigning ? STORE_ATTR : DELETE_ATTR, n);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002610 com_pop(c, assigning ? 2 : 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002611}
2612
2613static void
Thomas Wouters434d0822000-08-24 20:11:32 +00002614com_assign_trailer(struct compiling *c, node *n, int assigning, node *augn)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002615{
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002616 REQ(n, trailer);
2617 switch (TYPE(CHILD(n, 0))) {
2618 case LPAR: /* '(' [exprlist] ')' */
Jeremy Hylton05ab2e62002-05-31 14:08:29 +00002619 if (assigning == OP_DELETE)
2620 com_error(c, PyExc_SyntaxError,
2621 "can't delete function call");
2622 else
2623 com_error(c, PyExc_SyntaxError,
2624 "can't assign to function call");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002625 break;
2626 case DOT: /* '.' NAME */
Thomas Wouters434d0822000-08-24 20:11:32 +00002627 if (assigning > OP_APPLY)
2628 com_augassign_attr(c, CHILD(n, 1), assigning, augn);
2629 else
2630 com_assign_attr(c, CHILD(n, 1), assigning);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002631 break;
Guido van Rossum8861b741996-07-30 16:49:37 +00002632 case LSQB: /* '[' subscriptlist ']' */
Thomas Wouters434d0822000-08-24 20:11:32 +00002633 com_subscriptlist(c, CHILD(n, 1), assigning, augn);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002634 break;
2635 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002636 com_error(c, PyExc_SystemError, "unknown trailer type");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002637 }
2638}
2639
2640static void
Thomas Wouters0be5aab2000-08-11 22:15:52 +00002641com_assign_sequence(struct compiling *c, node *n, int assigning)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002642{
2643 int i;
Thomas Woutersb59290f2000-08-25 05:41:11 +00002644 if (TYPE(n) != testlist && TYPE(n) != listmaker)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002645 REQ(n, exprlist);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002646 if (assigning) {
2647 i = (NCH(n)+1)/2;
Thomas Wouters0be5aab2000-08-11 22:15:52 +00002648 com_addoparg(c, UNPACK_SEQUENCE, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002649 com_push(c, i-1);
2650 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002651 for (i = 0; i < NCH(n); i += 2)
Thomas Wouters434d0822000-08-24 20:11:32 +00002652 com_assign(c, CHILD(n, i), assigning, NULL);
2653}
2654
2655static void
2656com_augassign_name(struct compiling *c, node *n, int opcode, node *augn)
2657{
2658 REQ(n, NAME);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00002659 com_addop_varname(c, VAR_LOAD, STR(n));
Thomas Wouters434d0822000-08-24 20:11:32 +00002660 com_push(c, 1);
2661 com_node(c, augn);
2662 com_addbyte(c, opcode);
2663 com_pop(c, 1);
2664 com_assign_name(c, n, OP_ASSIGN);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002665}
2666
2667static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002668com_assign_name(struct compiling *c, node *n, int assigning)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002669{
2670 REQ(n, NAME);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00002671 com_addop_varname(c, assigning ? VAR_STORE : VAR_DELETE, STR(n));
Guido van Rossum8b993a91997-01-17 21:04:03 +00002672 if (assigning)
2673 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002674}
2675
2676static void
Thomas Wouters434d0822000-08-24 20:11:32 +00002677com_assign(struct compiling *c, node *n, int assigning, node *augn)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002678{
2679 /* Loop to avoid trivial recursion */
2680 for (;;) {
2681 switch (TYPE(n)) {
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002682
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002683 case exprlist:
2684 case testlist:
Guido van Rossum2d3b9862002-05-24 15:47:06 +00002685 case testlist1:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002686 if (NCH(n) > 1) {
Thomas Wouters434d0822000-08-24 20:11:32 +00002687 if (assigning > OP_APPLY) {
2688 com_error(c, PyExc_SyntaxError,
Jeremy Hylton29906ee2001-02-27 04:23:34 +00002689 "augmented assign to tuple not possible");
Thomas Wouters434d0822000-08-24 20:11:32 +00002690 return;
2691 }
Thomas Wouters0be5aab2000-08-11 22:15:52 +00002692 com_assign_sequence(c, n, assigning);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002693 return;
2694 }
2695 n = CHILD(n, 0);
2696 break;
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002697
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002698 case test:
2699 case and_test:
2700 case not_test:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002701 case comparison:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002702 case expr:
Guido van Rossum7928cd71991-10-24 14:59:31 +00002703 case xor_expr:
2704 case and_expr:
2705 case shift_expr:
2706 case arith_expr:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002707 case term:
Guido van Rossum50564e81996-01-12 01:13:16 +00002708 case factor:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002709 if (NCH(n) > 1) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002710 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002711 "can't assign to operator");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002712 return;
2713 }
2714 n = CHILD(n, 0);
2715 break;
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002716
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00002717 case power: /* atom trailer* ('**' power)*
2718 ('+'|'-'|'~') factor | atom trailer* */
Guido van Rossum50564e81996-01-12 01:13:16 +00002719 if (TYPE(CHILD(n, 0)) != atom) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002720 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002721 "can't assign to operator");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002722 return;
2723 }
Guido van Rossum50564e81996-01-12 01:13:16 +00002724 if (NCH(n) > 1) { /* trailer or exponent present */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002725 int i;
2726 com_node(c, CHILD(n, 0));
2727 for (i = 1; i+1 < NCH(n); i++) {
Guido van Rossum50564e81996-01-12 01:13:16 +00002728 if (TYPE(CHILD(n, i)) == DOUBLESTAR) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002729 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002730 "can't assign to operator");
Guido van Rossum50564e81996-01-12 01:13:16 +00002731 return;
2732 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002733 com_apply_trailer(c, CHILD(n, i));
2734 } /* NB i is still alive */
2735 com_assign_trailer(c,
Thomas Wouters434d0822000-08-24 20:11:32 +00002736 CHILD(n, i), assigning, augn);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002737 return;
2738 }
2739 n = CHILD(n, 0);
2740 break;
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002741
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002742 case atom:
2743 switch (TYPE(CHILD(n, 0))) {
2744 case LPAR:
2745 n = CHILD(n, 1);
2746 if (TYPE(n) == RPAR) {
2747 /* XXX Should allow () = () ??? */
Guido van Rossum79f25d91997-04-29 20:08:16 +00002748 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002749 "can't assign to ()");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002750 return;
2751 }
Thomas Wouters434d0822000-08-24 20:11:32 +00002752 if (assigning > OP_APPLY) {
2753 com_error(c, PyExc_SyntaxError,
Neal Norwitza1d654e2003-05-22 22:00:04 +00002754 "augmented assign to tuple literal not possible");
Thomas Wouters434d0822000-08-24 20:11:32 +00002755 return;
2756 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002757 break;
2758 case LSQB:
2759 n = CHILD(n, 1);
2760 if (TYPE(n) == RSQB) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002761 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002762 "can't assign to []");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002763 return;
2764 }
Thomas Wouters434d0822000-08-24 20:11:32 +00002765 if (assigning > OP_APPLY) {
2766 com_error(c, PyExc_SyntaxError,
Neal Norwitza1d654e2003-05-22 22:00:04 +00002767 "augmented assign to list literal not possible");
Jeremy Hyltone36f7782001-01-19 03:21:30 +00002768 return;
2769 }
2770 if (NCH(n) > 1
2771 && TYPE(CHILD(n, 1)) == list_for) {
2772 com_error(c, PyExc_SyntaxError,
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002773 "can't assign to list comprehension");
Thomas Wouters434d0822000-08-24 20:11:32 +00002774 return;
2775 }
Thomas Wouters0be5aab2000-08-11 22:15:52 +00002776 com_assign_sequence(c, n, assigning);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002777 return;
2778 case NAME:
Thomas Wouters434d0822000-08-24 20:11:32 +00002779 if (assigning > OP_APPLY)
2780 com_augassign_name(c, CHILD(n, 0),
2781 assigning, augn);
2782 else
2783 com_assign_name(c, CHILD(n, 0),
2784 assigning);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002785 return;
2786 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002787 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00002788 "can't assign to literal");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002789 return;
2790 }
2791 break;
Guido van Rossum15cc9a01996-08-08 18:51:04 +00002792
2793 case lambdef:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002794 com_error(c, PyExc_SyntaxError,
2795 "can't assign to lambda");
Guido van Rossum15cc9a01996-08-08 18:51:04 +00002796 return;
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002797
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002798 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00002799 com_error(c, PyExc_SystemError,
2800 "com_assign: bad node");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002801 return;
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00002802
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002803 }
2804 }
2805}
Guido van Rossum7c531111997-03-11 18:42:21 +00002806
Thomas Wouters434d0822000-08-24 20:11:32 +00002807static void
2808com_augassign(struct compiling *c, node *n)
2809{
2810 int opcode;
2811
2812 switch (STR(CHILD(CHILD(n, 1), 0))[0]) {
2813 case '+': opcode = INPLACE_ADD; break;
2814 case '-': opcode = INPLACE_SUBTRACT; break;
Guido van Rossum4668b002001-08-08 05:00:18 +00002815 case '/':
2816 if (STR(CHILD(CHILD(n, 1), 0))[1] == '/')
2817 opcode = INPLACE_FLOOR_DIVIDE;
2818 else if (c->c_flags & CO_FUTURE_DIVISION)
2819 opcode = INPLACE_TRUE_DIVIDE;
2820 else
2821 opcode = INPLACE_DIVIDE;
2822 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00002823 case '%': opcode = INPLACE_MODULO; break;
2824 case '<': opcode = INPLACE_LSHIFT; break;
2825 case '>': opcode = INPLACE_RSHIFT; break;
2826 case '&': opcode = INPLACE_AND; break;
2827 case '^': opcode = INPLACE_XOR; break;
2828 case '|': opcode = INPLACE_OR; break;
2829 case '*':
2830 if (STR(CHILD(CHILD(n, 1), 0))[1] == '*')
2831 opcode = INPLACE_POWER;
2832 else
2833 opcode = INPLACE_MULTIPLY;
2834 break;
2835 default:
2836 com_error(c, PyExc_SystemError, "com_augassign: bad operator");
2837 return;
2838 }
2839 com_assign(c, CHILD(n, 0), opcode, CHILD(n, 2));
2840}
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002841
2842static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002843com_expr_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002844{
Thomas Wouters434d0822000-08-24 20:11:32 +00002845 REQ(n, expr_stmt);
2846 /* testlist (('=' testlist)* | augassign testlist) */
Guido van Rossum8b993a91997-01-17 21:04:03 +00002847 /* Forget it if we have just a doc string here */
Guido van Rossum5f5e8171997-04-06 03:41:40 +00002848 if (!c->c_interactive && NCH(n) == 1 && get_rawdocstring(n) != NULL)
Guido van Rossum8b993a91997-01-17 21:04:03 +00002849 return;
Thomas Wouters434d0822000-08-24 20:11:32 +00002850 if (NCH(n) == 1) {
2851 com_node(c, CHILD(n, NCH(n)-1));
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00002852 if (c->c_interactive)
2853 com_addbyte(c, PRINT_EXPR);
2854 else
2855 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002856 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002857 }
Thomas Wouters434d0822000-08-24 20:11:32 +00002858 else if (TYPE(CHILD(n,1)) == augassign)
2859 com_augassign(c, n);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002860 else {
2861 int i;
Thomas Wouters434d0822000-08-24 20:11:32 +00002862 com_node(c, CHILD(n, NCH(n)-1));
Guido van Rossum4bad92c1991-07-27 21:34:52 +00002863 for (i = 0; i < NCH(n)-2; i+=2) {
Guido van Rossum8b993a91997-01-17 21:04:03 +00002864 if (i+2 < NCH(n)-2) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002865 com_addbyte(c, DUP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00002866 com_push(c, 1);
2867 }
Thomas Wouters434d0822000-08-24 20:11:32 +00002868 com_assign(c, CHILD(n, i), OP_ASSIGN, NULL);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002869 }
2870 }
2871}
2872
2873static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002874com_assert_stmt(struct compiling *c, node *n)
Guido van Rossum228d7f31997-04-02 05:24:36 +00002875{
Neil Schemenauer89e3ee02002-04-26 01:58:53 +00002876 int a = 0;
Guido van Rossum228d7f31997-04-02 05:24:36 +00002877 int i;
2878 REQ(n, assert_stmt); /* 'assert' test [',' test] */
Neil Schemenauer89e3ee02002-04-26 01:58:53 +00002879 if (Py_OptimizeFlag)
2880 return;
2881 /* Generate code like
Guido van Rossum228d7f31997-04-02 05:24:36 +00002882
Neil Schemenauer89e3ee02002-04-26 01:58:53 +00002883 if not <test>:
Guido van Rossum228d7f31997-04-02 05:24:36 +00002884 raise AssertionError [, <message>]
2885
2886 where <message> is the second test, if present.
2887 */
Guido van Rossum228d7f31997-04-02 05:24:36 +00002888 com_node(c, CHILD(n, 1));
Neil Schemenauer89e3ee02002-04-26 01:58:53 +00002889 com_addfwref(c, JUMP_IF_TRUE, &a);
Guido van Rossum228d7f31997-04-02 05:24:36 +00002890 com_addbyte(c, POP_TOP);
2891 com_pop(c, 1);
2892 /* Raise that exception! */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00002893 com_addop_name(c, LOAD_GLOBAL, "AssertionError");
Guido van Rossum228d7f31997-04-02 05:24:36 +00002894 com_push(c, 1);
2895 i = NCH(n)/2; /* Either 2 or 4 */
2896 if (i > 1)
2897 com_node(c, CHILD(n, 3));
2898 com_addoparg(c, RAISE_VARARGS, i);
2899 com_pop(c, i);
2900 /* The interpreter does not fall through */
Neil Schemenauer89e3ee02002-04-26 01:58:53 +00002901 /* Jump ends up here */
Guido van Rossum228d7f31997-04-02 05:24:36 +00002902 com_backpatch(c, a);
Guido van Rossum228d7f31997-04-02 05:24:36 +00002903 com_addbyte(c, POP_TOP);
2904}
2905
2906static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002907com_print_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002908{
Barry Warsaw29c574e2000-08-21 15:38:56 +00002909 int i = 1;
2910 node* stream = NULL;
2911
Guido van Rossum4bad92c1991-07-27 21:34:52 +00002912 REQ(n, print_stmt); /* 'print' (test ',')* [test] */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002913
2914 /* are we using the extended print form? */
2915 if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) {
2916 stream = CHILD(n, 2);
Barry Warsaw24703a02000-08-21 17:07:20 +00002917 com_node(c, stream);
2918 /* stack: [...] => [... stream] */
2919 com_push(c, 1);
Barry Warsaw29c574e2000-08-21 15:38:56 +00002920 if (NCH(n) > 3 && TYPE(CHILD(n, 3)) == COMMA)
2921 i = 4;
2922 else
2923 i = 3;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002924 }
Barry Warsaw29c574e2000-08-21 15:38:56 +00002925 for (; i < NCH(n); i += 2) {
2926 if (stream != NULL) {
Barry Warsaw24703a02000-08-21 17:07:20 +00002927 com_addbyte(c, DUP_TOP);
2928 /* stack: [stream] => [stream stream] */
2929 com_push(c, 1);
Barry Warsaw29c574e2000-08-21 15:38:56 +00002930 com_node(c, CHILD(n, i));
Barry Warsaw24703a02000-08-21 17:07:20 +00002931 /* stack: [stream stream] => [stream stream obj] */
2932 com_addbyte(c, ROT_TWO);
2933 /* stack: [stream stream obj] => [stream obj stream] */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002934 com_addbyte(c, PRINT_ITEM_TO);
Barry Warsaw24703a02000-08-21 17:07:20 +00002935 /* stack: [stream obj stream] => [stream] */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002936 com_pop(c, 2);
2937 }
2938 else {
Barry Warsaw29c574e2000-08-21 15:38:56 +00002939 com_node(c, CHILD(n, i));
Barry Warsaw24703a02000-08-21 17:07:20 +00002940 /* stack: [...] => [... obj] */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002941 com_addbyte(c, PRINT_ITEM);
2942 com_pop(c, 1);
2943 }
2944 }
2945 /* XXX Alternatively, LOAD_CONST '\n' and then PRINT_ITEM */
Barry Warsaw24703a02000-08-21 17:07:20 +00002946 if (TYPE(CHILD(n, NCH(n)-1)) == COMMA) {
Barry Warsaw29c574e2000-08-21 15:38:56 +00002947 if (stream != NULL) {
Barry Warsaw24703a02000-08-21 17:07:20 +00002948 /* must pop the extra stream object off the stack */
2949 com_addbyte(c, POP_TOP);
2950 /* stack: [... stream] => [...] */
2951 com_pop(c, 1);
2952 }
2953 }
2954 else {
2955 if (stream != NULL) {
2956 /* this consumes the last stream object on stack */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002957 com_addbyte(c, PRINT_NEWLINE_TO);
Barry Warsaw24703a02000-08-21 17:07:20 +00002958 /* stack: [... stream] => [...] */
Barry Warsaw29c574e2000-08-21 15:38:56 +00002959 com_pop(c, 1);
2960 }
2961 else
2962 com_addbyte(c, PRINT_NEWLINE);
2963 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002964}
2965
2966static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002967com_return_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002968{
Guido van Rossum4bad92c1991-07-27 21:34:52 +00002969 REQ(n, return_stmt); /* 'return' [testlist] */
Guido van Rossum3f5da241990-12-20 15:06:42 +00002970 if (!c->c_infunction) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002971 com_error(c, PyExc_SyntaxError, "'return' outside function");
Guido van Rossum3f5da241990-12-20 15:06:42 +00002972 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002973 if (c->c_flags & CO_GENERATOR) {
2974 if (NCH(n) > 1) {
2975 com_error(c, PyExc_SyntaxError,
2976 "'return' with argument inside generator");
2977 }
Tim Petersad1a18b2001-06-23 06:19:16 +00002978 }
2979 if (NCH(n) < 2) {
2980 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00002981 com_push(c, 1);
2982 }
Tim Petersad1a18b2001-06-23 06:19:16 +00002983 else
2984 com_node(c, CHILD(n, 1));
2985 com_addbyte(c, RETURN_VALUE);
Tim Peters5ca576e2001-06-18 22:08:13 +00002986 com_pop(c, 1);
2987}
2988
2989static void
2990com_yield_stmt(struct compiling *c, node *n)
2991{
Tim Peters95c80f82001-06-23 02:07:08 +00002992 int i;
Tim Peters5ca576e2001-06-18 22:08:13 +00002993 REQ(n, yield_stmt); /* 'yield' testlist */
2994 if (!c->c_infunction) {
2995 com_error(c, PyExc_SyntaxError, "'yield' outside function");
2996 }
Tim Peters95c80f82001-06-23 02:07:08 +00002997
2998 for (i = 0; i < c->c_nblocks; ++i) {
2999 if (c->c_block[i] == SETUP_FINALLY) {
3000 com_error(c, PyExc_SyntaxError,
3001 "'yield' not allowed in a 'try' block "
3002 "with a 'finally' clause");
3003 return;
3004 }
3005 }
Tim Peters5ca576e2001-06-18 22:08:13 +00003006 com_node(c, CHILD(n, 1));
3007 com_addbyte(c, YIELD_VALUE);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003008 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003009}
3010
3011static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003012com_raise_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003013{
Guido van Rossum8b993a91997-01-17 21:04:03 +00003014 int i;
Guido van Rossumd295f121998-04-09 21:39:57 +00003015 REQ(n, raise_stmt); /* 'raise' [test [',' test [',' test]]] */
3016 if (NCH(n) > 1) {
3017 com_node(c, CHILD(n, 1));
3018 if (NCH(n) > 3) {
3019 com_node(c, CHILD(n, 3));
3020 if (NCH(n) > 5)
3021 com_node(c, CHILD(n, 5));
3022 }
Guido van Rossumf10570b1995-07-07 22:53:21 +00003023 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00003024 i = NCH(n)/2;
3025 com_addoparg(c, RAISE_VARARGS, i);
3026 com_pop(c, i);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003027}
3028
3029static void
Thomas Wouters52152252000-08-17 22:55:00 +00003030com_from_import(struct compiling *c, node *n)
3031{
3032 com_addopname(c, IMPORT_FROM, CHILD(n, 0));
3033 com_push(c, 1);
3034 if (NCH(n) > 1) {
3035 if (strcmp(STR(CHILD(n, 1)), "as") != 0) {
3036 com_error(c, PyExc_SyntaxError, "invalid syntax");
3037 return;
3038 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003039 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 2)));
Thomas Wouters52152252000-08-17 22:55:00 +00003040 } else
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003041 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 0)));
Thomas Wouters52152252000-08-17 22:55:00 +00003042 com_pop(c, 1);
3043}
3044
3045static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003046com_import_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003047{
3048 int i;
3049 REQ(n, import_stmt);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003050 /* 'import' dotted_name (',' dotted_name)* |
3051 'from' dotted_name 'import' ('*' | NAME (',' NAME)*) */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003052 if (STR(CHILD(n, 0))[0] == 'f') {
Guido van Rossum83fb0732000-11-27 22:22:36 +00003053 PyObject *tup;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003054 /* 'from' dotted_name 'import' ... */
3055 REQ(CHILD(n, 1), dotted_name);
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00003056
3057 if (TYPE(CHILD(n, 3)) == STAR) {
3058 tup = Py_BuildValue("(s)", "*");
3059 } else {
3060 tup = PyTuple_New((NCH(n) - 2)/2);
3061 for (i = 3; i < NCH(n); i += 2) {
3062 PyTuple_SET_ITEM(tup, (i-3)/2,
Guido van Rossum633d90c2002-12-23 16:51:42 +00003063 PyString_FromString(STR(
3064 CHILD(CHILD(n, i), 0))));
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00003065 }
3066 }
3067 com_addoparg(c, LOAD_CONST, com_addconst(c, tup));
Guido van Rossum83fb0732000-11-27 22:22:36 +00003068 Py_DECREF(tup);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003069 com_push(c, 1);
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00003070 com_addopname(c, IMPORT_NAME, CHILD(n, 1));
Thomas Wouters52152252000-08-17 22:55:00 +00003071 if (TYPE(CHILD(n, 3)) == STAR)
3072 com_addbyte(c, IMPORT_STAR);
3073 else {
3074 for (i = 3; i < NCH(n); i += 2)
3075 com_from_import(c, CHILD(n, i));
3076 com_addbyte(c, POP_TOP);
3077 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00003078 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003079 }
3080 else {
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003081 /* 'import' ... */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003082 for (i = 1; i < NCH(n); i += 2) {
Thomas Wouters52152252000-08-17 22:55:00 +00003083 node *subn = CHILD(n, i);
3084 REQ(subn, dotted_as_name);
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00003085 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003086 com_push(c, 1);
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00003087 com_addopname(c, IMPORT_NAME, CHILD(subn, 0));
Thomas Wouters52152252000-08-17 22:55:00 +00003088 if (NCH(subn) > 1) {
Thomas Wouterse753ef82000-08-27 20:16:32 +00003089 int j;
3090 if (strcmp(STR(CHILD(subn, 1)), "as") != 0) {
Thomas Wouters52152252000-08-17 22:55:00 +00003091 com_error(c, PyExc_SyntaxError,
3092 "invalid syntax");
3093 return;
3094 }
Thomas Wouterse753ef82000-08-27 20:16:32 +00003095 for (j=2 ; j < NCH(CHILD(subn, 0)); j += 2)
3096 com_addopname(c, LOAD_ATTR,
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003097 CHILD(CHILD(subn, 0),
3098 j));
3099 com_addop_varname(c, VAR_STORE,
3100 STR(CHILD(subn, 2)));
Thomas Wouters52152252000-08-17 22:55:00 +00003101 } else
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003102 com_addop_varname(c, VAR_STORE,
3103 STR(CHILD(CHILD(subn, 0),
3104 0)));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003105 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003106 }
3107 }
3108}
3109
3110static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003111com_exec_stmt(struct compiling *c, node *n)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003112{
3113 REQ(n, exec_stmt);
3114 /* exec_stmt: 'exec' expr ['in' expr [',' expr]] */
3115 com_node(c, CHILD(n, 1));
3116 if (NCH(n) >= 4)
3117 com_node(c, CHILD(n, 3));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003118 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00003119 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003120 com_push(c, 1);
3121 }
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003122 if (NCH(n) >= 6)
3123 com_node(c, CHILD(n, 5));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003124 else {
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003125 com_addbyte(c, DUP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003126 com_push(c, 1);
3127 }
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003128 com_addbyte(c, EXEC_STMT);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003129 com_pop(c, 3);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003130}
3131
Guido van Rossum7c531111997-03-11 18:42:21 +00003132static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003133is_constant_false(struct compiling *c, node *n)
Guido van Rossum7c531111997-03-11 18:42:21 +00003134{
Guido van Rossum79f25d91997-04-29 20:08:16 +00003135 PyObject *v;
Guido van Rossum7c531111997-03-11 18:42:21 +00003136 int i;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003137 /* argument c will be NULL when called from symtable_node() */
Guido van Rossum7c531111997-03-11 18:42:21 +00003138
3139 /* Label to avoid tail recursion */
3140 next:
3141 switch (TYPE(n)) {
3142
3143 case suite:
3144 if (NCH(n) == 1) {
3145 n = CHILD(n, 0);
3146 goto next;
3147 }
3148 /* Fall through */
3149 case file_input:
3150 for (i = 0; i < NCH(n); i++) {
3151 node *ch = CHILD(n, i);
3152 if (TYPE(ch) == stmt) {
3153 n = ch;
3154 goto next;
3155 }
3156 }
3157 break;
3158
3159 case stmt:
3160 case simple_stmt:
3161 case small_stmt:
3162 n = CHILD(n, 0);
3163 goto next;
3164
3165 case expr_stmt:
3166 case testlist:
Guido van Rossum2d3b9862002-05-24 15:47:06 +00003167 case testlist1:
Guido van Rossum7c531111997-03-11 18:42:21 +00003168 case test:
3169 case and_test:
3170 case not_test:
3171 case comparison:
3172 case expr:
3173 case xor_expr:
3174 case and_expr:
3175 case shift_expr:
3176 case arith_expr:
3177 case term:
3178 case factor:
3179 case power:
3180 case atom:
3181 if (NCH(n) == 1) {
3182 n = CHILD(n, 0);
3183 goto next;
3184 }
3185 break;
3186
3187 case NAME:
3188 if (Py_OptimizeFlag && strcmp(STR(n), "__debug__") == 0)
3189 return 1;
3190 break;
3191
3192 case NUMBER:
3193 v = parsenumber(c, STR(n));
3194 if (v == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00003195 PyErr_Clear();
Guido van Rossum7c531111997-03-11 18:42:21 +00003196 break;
3197 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00003198 i = PyObject_IsTrue(v);
3199 Py_DECREF(v);
Guido van Rossum7c531111997-03-11 18:42:21 +00003200 return i == 0;
3201
3202 case STRING:
Martin v. Löwis339d0f72001-08-17 18:39:25 +00003203 v = parsestr(c, STR(n));
Guido van Rossum7c531111997-03-11 18:42:21 +00003204 if (v == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00003205 PyErr_Clear();
Guido van Rossum7c531111997-03-11 18:42:21 +00003206 break;
3207 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00003208 i = PyObject_IsTrue(v);
3209 Py_DECREF(v);
Guido van Rossum7c531111997-03-11 18:42:21 +00003210 return i == 0;
3211
3212 }
3213 return 0;
3214}
3215
Tim Peters08a898f2001-06-28 01:52:22 +00003216
3217/* Look under n for a return stmt with an expression.
3218 * This hack is used to find illegal returns under "if 0:" blocks in
3219 * functions already known to be generators (as determined by the symtable
3220 * pass).
3221 * Return the offending return node if found, else NULL.
3222 */
3223static node *
3224look_for_offending_return(node *n)
3225{
3226 int i;
3227
3228 for (i = 0; i < NCH(n); ++i) {
3229 node *kid = CHILD(n, i);
3230
3231 switch (TYPE(kid)) {
3232 case classdef:
3233 case funcdef:
3234 case lambdef:
3235 /* Stuff in nested functions & classes doesn't
3236 affect the code block we started in. */
3237 return NULL;
3238
3239 case return_stmt:
3240 if (NCH(kid) > 1)
3241 return kid;
3242 break;
3243
3244 default: {
3245 node *bad = look_for_offending_return(kid);
3246 if (bad != NULL)
3247 return bad;
3248 }
3249 }
3250 }
3251
3252 return NULL;
3253}
3254
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003255static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003256com_if_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003257{
3258 int i;
3259 int anchor = 0;
3260 REQ(n, if_stmt);
3261 /*'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */
3262 for (i = 0; i+3 < NCH(n); i+=4) {
3263 int a = 0;
Guido van Rossum3f5da241990-12-20 15:06:42 +00003264 node *ch = CHILD(n, i+1);
Tim Peters08a898f2001-06-28 01:52:22 +00003265 if (is_constant_false(c, ch)) {
3266 /* We're going to skip this block. However, if this
3267 is a generator, we have to check the dead code
3268 anyway to make sure there aren't any return stmts
3269 with expressions, in the same scope. */
3270 if (c->c_flags & CO_GENERATOR) {
3271 node *p = look_for_offending_return(n);
3272 if (p != NULL) {
3273 int savelineno = c->c_lineno;
3274 c->c_lineno = p->n_lineno;
3275 com_error(c, PyExc_SyntaxError,
3276 "'return' with argument "
3277 "inside generator");
3278 c->c_lineno = savelineno;
3279 }
3280 }
Guido van Rossum7c531111997-03-11 18:42:21 +00003281 continue;
Tim Peters08a898f2001-06-28 01:52:22 +00003282 }
Guido van Rossum3f5da241990-12-20 15:06:42 +00003283 if (i > 0)
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003284 com_set_lineno(c, ch->n_lineno);
Guido van Rossum7c531111997-03-11 18:42:21 +00003285 com_node(c, ch);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003286 com_addfwref(c, JUMP_IF_FALSE, &a);
3287 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003288 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003289 com_node(c, CHILD(n, i+3));
3290 com_addfwref(c, JUMP_FORWARD, &anchor);
3291 com_backpatch(c, a);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003292 /* We jump here with an extra entry which we now pop */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003293 com_addbyte(c, POP_TOP);
3294 }
3295 if (i+2 < NCH(n))
3296 com_node(c, CHILD(n, i+2));
Guido van Rossum7c531111997-03-11 18:42:21 +00003297 if (anchor)
3298 com_backpatch(c, anchor);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003299}
3300
3301static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003302com_while_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003303{
3304 int break_anchor = 0;
3305 int anchor = 0;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003306 int save_begin = c->c_begin;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003307 REQ(n, while_stmt); /* 'while' test ':' suite ['else' ':' suite] */
3308 com_addfwref(c, SETUP_LOOP, &break_anchor);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003309 block_push(c, SETUP_LOOP);
3310 c->c_begin = c->c_nexti;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003311 com_set_lineno(c, n->n_lineno);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003312 com_node(c, CHILD(n, 1));
3313 com_addfwref(c, JUMP_IF_FALSE, &anchor);
3314 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003315 com_pop(c, 1);
Guido van Rossum3f5da241990-12-20 15:06:42 +00003316 c->c_loops++;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003317 com_node(c, CHILD(n, 3));
Guido van Rossum3f5da241990-12-20 15:06:42 +00003318 c->c_loops--;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003319 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
3320 c->c_begin = save_begin;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003321 com_backpatch(c, anchor);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003322 /* We jump here with one entry more on the stack */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003323 com_addbyte(c, POP_TOP);
3324 com_addbyte(c, POP_BLOCK);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003325 block_pop(c, SETUP_LOOP);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003326 if (NCH(n) > 4)
3327 com_node(c, CHILD(n, 6));
3328 com_backpatch(c, break_anchor);
3329}
3330
3331static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003332com_for_stmt(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003333{
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003334 int break_anchor = 0;
3335 int anchor = 0;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003336 int save_begin = c->c_begin;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003337 REQ(n, for_stmt);
3338 /* 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] */
3339 com_addfwref(c, SETUP_LOOP, &break_anchor);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003340 block_push(c, SETUP_LOOP);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003341 com_node(c, CHILD(n, 3));
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00003342 com_addbyte(c, GET_ITER);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003343 c->c_begin = c->c_nexti;
Michael W. Hudson26848a32003-04-29 17:07:36 +00003344 com_set_lineno(c, c->c_last_line);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00003345 com_addfwref(c, FOR_ITER, &anchor);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003346 com_push(c, 1);
Thomas Wouters434d0822000-08-24 20:11:32 +00003347 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL);
Guido van Rossum3f5da241990-12-20 15:06:42 +00003348 c->c_loops++;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003349 com_node(c, CHILD(n, 5));
Guido van Rossum3f5da241990-12-20 15:06:42 +00003350 c->c_loops--;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003351 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
3352 c->c_begin = save_begin;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003353 com_backpatch(c, anchor);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00003354 com_pop(c, 1); /* FOR_ITER has popped this */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003355 com_addbyte(c, POP_BLOCK);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003356 block_pop(c, SETUP_LOOP);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003357 if (NCH(n) > 8)
3358 com_node(c, CHILD(n, 8));
3359 com_backpatch(c, break_anchor);
3360}
3361
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003362/* Code generated for "try: S finally: Sf" is as follows:
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003363
3364 SETUP_FINALLY L
3365 <code for S>
3366 POP_BLOCK
3367 LOAD_CONST <nil>
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003368 L: <code for Sf>
3369 END_FINALLY
3370
3371 The special instructions use the block stack. Each block
3372 stack entry contains the instruction that created it (here
3373 SETUP_FINALLY), the level of the value stack at the time the
3374 block stack entry was created, and a label (here L).
3375
3376 SETUP_FINALLY:
3377 Pushes the current value stack level and the label
3378 onto the block stack.
3379 POP_BLOCK:
3380 Pops en entry from the block stack, and pops the value
3381 stack until its level is the same as indicated on the
3382 block stack. (The label is ignored.)
3383 END_FINALLY:
Guido van Rossum3f5da241990-12-20 15:06:42 +00003384 Pops a variable number of entries from the *value* stack
3385 and re-raises the exception they specify. The number of
3386 entries popped depends on the (pseudo) exception type.
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003387
3388 The block stack is unwound when an exception is raised:
3389 when a SETUP_FINALLY entry is found, the exception is pushed
3390 onto the value stack (and the exception condition is cleared),
3391 and the interpreter jumps to the label gotten from the block
3392 stack.
3393
3394 Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...":
Guido van Rossum3f5da241990-12-20 15:06:42 +00003395 (The contents of the value stack is shown in [], with the top
3396 at the right; 'tb' is trace-back info, 'val' the exception's
3397 associated value, and 'exc' the exception.)
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003398
3399 Value stack Label Instruction Argument
3400 [] SETUP_EXCEPT L1
3401 [] <code for S>
3402 [] POP_BLOCK
3403 [] JUMP_FORWARD L0
3404
Guido van Rossum3f5da241990-12-20 15:06:42 +00003405 [tb, val, exc] L1: DUP )
3406 [tb, val, exc, exc] <evaluate E1> )
3407 [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1
3408 [tb, val, exc, 1-or-0] JUMP_IF_FALSE L2 )
3409 [tb, val, exc, 1] POP )
3410 [tb, val, exc] POP
3411 [tb, val] <assign to V1> (or POP if no V1)
3412 [tb] POP
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003413 [] <code for S1>
3414 JUMP_FORWARD L0
3415
Guido van Rossum3f5da241990-12-20 15:06:42 +00003416 [tb, val, exc, 0] L2: POP
3417 [tb, val, exc] DUP
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003418 .............................etc.......................
3419
Guido van Rossum3f5da241990-12-20 15:06:42 +00003420 [tb, val, exc, 0] Ln+1: POP
3421 [tb, val, exc] END_FINALLY # re-raise exception
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003422
3423 [] L0: <next statement>
3424
3425 Of course, parts are not generated if Vi or Ei is not present.
3426*/
3427
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003428static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003429com_try_except(struct compiling *c, node *n)
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003430{
3431 int except_anchor = 0;
3432 int end_anchor = 0;
3433 int else_anchor = 0;
3434 int i;
3435 node *ch;
3436
3437 com_addfwref(c, SETUP_EXCEPT, &except_anchor);
3438 block_push(c, SETUP_EXCEPT);
3439 com_node(c, CHILD(n, 2));
3440 com_addbyte(c, POP_BLOCK);
3441 block_pop(c, SETUP_EXCEPT);
3442 com_addfwref(c, JUMP_FORWARD, &else_anchor);
3443 com_backpatch(c, except_anchor);
3444 for (i = 3;
3445 i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause;
3446 i += 3) {
Guido van Rossum8b993a91997-01-17 21:04:03 +00003447 /* except_clause: 'except' [expr [',' var]] */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003448 if (except_anchor == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00003449 com_error(c, PyExc_SyntaxError,
Guido van Rossum452a9831996-09-17 14:32:04 +00003450 "default 'except:' must be last");
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003451 break;
3452 }
3453 except_anchor = 0;
Guido van Rossum8b993a91997-01-17 21:04:03 +00003454 com_push(c, 3); /* tb, val, exc pushed by exception */
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003455 com_set_lineno(c, ch->n_lineno);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003456 if (NCH(ch) > 1) {
3457 com_addbyte(c, DUP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003458 com_push(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003459 com_node(c, CHILD(ch, 1));
Martin v. Löwis7198a522002-01-01 19:59:11 +00003460 com_addoparg(c, COMPARE_OP, PyCmp_EXC_MATCH);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003461 com_pop(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003462 com_addfwref(c, JUMP_IF_FALSE, &except_anchor);
3463 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003464 com_pop(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003465 }
3466 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003467 com_pop(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003468 if (NCH(ch) > 3)
Thomas Wouters434d0822000-08-24 20:11:32 +00003469 com_assign(c, CHILD(ch, 3), OP_ASSIGN, NULL);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003470 else {
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003471 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003472 com_pop(c, 1);
3473 }
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003474 com_addbyte(c, POP_TOP);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003475 com_pop(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003476 com_node(c, CHILD(n, i+2));
3477 com_addfwref(c, JUMP_FORWARD, &end_anchor);
3478 if (except_anchor) {
3479 com_backpatch(c, except_anchor);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003480 /* We come in with [tb, val, exc, 0] on the
3481 stack; one pop and it's the same as
3482 expected at the start of the loop */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003483 com_addbyte(c, POP_TOP);
3484 }
3485 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00003486 /* We actually come in here with [tb, val, exc] but the
3487 END_FINALLY will zap those and jump around.
3488 The c_stacklevel does not reflect them so we need not pop
3489 anything. */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003490 com_addbyte(c, END_FINALLY);
3491 com_backpatch(c, else_anchor);
3492 if (i < NCH(n))
3493 com_node(c, CHILD(n, i+2));
3494 com_backpatch(c, end_anchor);
3495}
3496
3497static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003498com_try_finally(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003499{
3500 int finally_anchor = 0;
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003501 node *ch;
Guido van Rossum94fb82e1992-04-05 14:24:50 +00003502
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003503 com_addfwref(c, SETUP_FINALLY, &finally_anchor);
3504 block_push(c, SETUP_FINALLY);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003505 com_node(c, CHILD(n, 2));
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003506 com_addbyte(c, POP_BLOCK);
3507 block_pop(c, SETUP_FINALLY);
3508 block_push(c, END_FINALLY);
Guido van Rossum79f25d91997-04-29 20:08:16 +00003509 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003510 /* While the generated code pushes only one item,
3511 the try-finally handling can enter here with
3512 up to three items. OK, here are the details:
3513 3 for an exception, 2 for RETURN, 1 for BREAK. */
3514 com_push(c, 3);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003515 com_backpatch(c, finally_anchor);
3516 ch = CHILD(n, NCH(n)-1);
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003517 com_set_lineno(c, ch->n_lineno);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003518 com_node(c, ch);
3519 com_addbyte(c, END_FINALLY);
3520 block_pop(c, END_FINALLY);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003521 com_pop(c, 3); /* Matches the com_push above */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003522}
3523
3524static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003525com_try_stmt(struct compiling *c, node *n)
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003526{
3527 REQ(n, try_stmt);
3528 /* 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
3529 | 'try' ':' suite 'finally' ':' suite */
3530 if (TYPE(CHILD(n, 3)) != except_clause)
3531 com_try_finally(c, n);
3532 else
3533 com_try_except(c, n);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003534}
3535
Guido van Rossum8b993a91997-01-17 21:04:03 +00003536static node *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003537get_rawdocstring(node *n)
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003538{
Guido van Rossum164d4ff1995-01-26 00:40:09 +00003539 int i;
3540
Guido van Rossum8b993a91997-01-17 21:04:03 +00003541 /* Label to avoid tail recursion */
3542 next:
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003543 switch (TYPE(n)) {
3544
3545 case suite:
Guido van Rossum8b993a91997-01-17 21:04:03 +00003546 if (NCH(n) == 1) {
3547 n = CHILD(n, 0);
3548 goto next;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003549 }
Guido van Rossum8b993a91997-01-17 21:04:03 +00003550 /* Fall through */
Guido van Rossum164d4ff1995-01-26 00:40:09 +00003551 case file_input:
3552 for (i = 0; i < NCH(n); i++) {
3553 node *ch = CHILD(n, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003554 if (TYPE(ch) == stmt) {
3555 n = ch;
3556 goto next;
3557 }
Guido van Rossum164d4ff1995-01-26 00:40:09 +00003558 }
3559 break;
3560
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003561 case stmt:
3562 case simple_stmt:
3563 case small_stmt:
Guido van Rossum8b993a91997-01-17 21:04:03 +00003564 n = CHILD(n, 0);
3565 goto next;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003566
3567 case expr_stmt:
3568 case testlist:
Guido van Rossum2d3b9862002-05-24 15:47:06 +00003569 case testlist1:
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003570 case test:
3571 case and_test:
3572 case not_test:
3573 case comparison:
3574 case expr:
3575 case xor_expr:
3576 case and_expr:
3577 case shift_expr:
3578 case arith_expr:
3579 case term:
3580 case factor:
Guido van Rossum50564e81996-01-12 01:13:16 +00003581 case power:
Guido van Rossum8b993a91997-01-17 21:04:03 +00003582 if (NCH(n) == 1) {
3583 n = CHILD(n, 0);
3584 goto next;
3585 }
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003586 break;
3587
3588 case atom:
3589 if (TYPE(CHILD(n, 0)) == STRING)
Guido van Rossum8b993a91997-01-17 21:04:03 +00003590 return n;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00003591 break;
3592
3593 }
3594 return NULL;
3595}
3596
Guido van Rossum79f25d91997-04-29 20:08:16 +00003597static PyObject *
Martin v. Löwis339d0f72001-08-17 18:39:25 +00003598get_docstring(struct compiling *c, node *n)
Guido van Rossum8b993a91997-01-17 21:04:03 +00003599{
Guido van Rossum541563e1999-01-28 15:08:09 +00003600 /* Don't generate doc-strings if run with -OO */
3601 if (Py_OptimizeFlag > 1)
3602 return NULL;
Guido van Rossum8b993a91997-01-17 21:04:03 +00003603 n = get_rawdocstring(n);
3604 if (n == NULL)
3605 return NULL;
Martin v. Löwis339d0f72001-08-17 18:39:25 +00003606 return parsestrplus(c, n);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003607}
3608
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003609static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003610com_suite(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003611{
3612 REQ(n, suite);
3613 /* simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT */
3614 if (NCH(n) == 1) {
3615 com_node(c, CHILD(n, 0));
3616 }
3617 else {
3618 int i;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00003619 for (i = 0; i < NCH(n) && c->c_errors == 0; i++) {
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003620 node *ch = CHILD(n, i);
3621 if (TYPE(ch) == stmt)
3622 com_node(c, ch);
3623 }
3624 }
3625}
3626
Guido van Rossumf1aeab71992-03-27 17:28:26 +00003627/* ARGSUSED */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003628static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003629com_continue_stmt(struct compiling *c, node *n)
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003630{
3631 int i = c->c_nblocks;
3632 if (i-- > 0 && c->c_block[i] == SETUP_LOOP) {
3633 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
3634 }
Fred Drakefd1f1be2000-09-08 16:31:24 +00003635 else if (i <= 0) {
3636 /* at the outer level */
3637 com_error(c, PyExc_SyntaxError,
3638 "'continue' not properly in loop");
3639 }
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003640 else {
Fred Drakefd1f1be2000-09-08 16:31:24 +00003641 int j;
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003642 for (j = i-1; j >= 0; --j) {
Fred Drakefd1f1be2000-09-08 16:31:24 +00003643 if (c->c_block[j] == SETUP_LOOP)
3644 break;
3645 }
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003646 if (j >= 0) {
Fred Drakefd1f1be2000-09-08 16:31:24 +00003647 /* there is a loop, but something interferes */
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003648 for (; i > j; --i) {
3649 if (c->c_block[i] == SETUP_EXCEPT ||
3650 c->c_block[i] == SETUP_FINALLY) {
3651 com_addoparg(c, CONTINUE_LOOP,
3652 c->c_begin);
Fred Drakefd1f1be2000-09-08 16:31:24 +00003653 return;
3654 }
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003655 if (c->c_block[i] == END_FINALLY) {
3656 com_error(c, PyExc_SyntaxError,
3657 "'continue' not supported inside 'finally' clause");
3658 return;
3659 }
Fred Drakefd1f1be2000-09-08 16:31:24 +00003660 }
3661 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00003662 com_error(c, PyExc_SyntaxError,
3663 "'continue' not properly in loop");
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003664 }
3665 /* XXX Could allow it inside a 'finally' clause
3666 XXX if we could pop the exception still on the stack */
3667}
3668
Jeremy Hylton376e63d2003-08-28 14:42:14 +00003669/* Return the number of default values in the argument list.
3670
3671 If a non-default argument follows a default argument, set an
3672 exception and return -1.
3673*/
3674
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003675static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003676com_argdefs(struct compiling *c, node *n)
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003677{
Jeremy Hylton376e63d2003-08-28 14:42:14 +00003678 int i, nch, ndefs;
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003679 if (TYPE(n) == lambdef) {
3680 /* lambdef: 'lambda' [varargslist] ':' test */
3681 n = CHILD(n, 1);
3682 }
3683 else {
3684 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ... */
3685 n = CHILD(n, 2);
3686 REQ(n, parameters); /* parameters: '(' [varargslist] ')' */
3687 n = CHILD(n, 1);
3688 }
3689 if (TYPE(n) != varargslist)
Guido van Rossum681d79a1995-07-18 14:51:37 +00003690 return 0;
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003691 /* varargslist:
Guido van Rossum681d79a1995-07-18 14:51:37 +00003692 (fpdef ['=' test] ',')* '*' ....... |
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003693 fpdef ['=' test] (',' fpdef ['=' test])* [','] */
3694 nch = NCH(n);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003695 ndefs = 0;
3696 for (i = 0; i < nch; i++) {
3697 int t;
Guido van Rossum79f25d91997-04-29 20:08:16 +00003698 if (TYPE(CHILD(n, i)) == STAR ||
3699 TYPE(CHILD(n, i)) == DOUBLESTAR)
Guido van Rossumf10570b1995-07-07 22:53:21 +00003700 break;
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003701 i++;
3702 if (i >= nch)
Guido van Rossuma1e7e621995-09-18 21:44:04 +00003703 t = RPAR; /* Anything except EQUAL or COMMA */
3704 else
3705 t = TYPE(CHILD(n, i));
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003706 if (t == EQUAL) {
3707 i++;
3708 ndefs++;
3709 com_node(c, CHILD(n, i));
3710 i++;
3711 if (i >= nch)
3712 break;
3713 t = TYPE(CHILD(n, i));
3714 }
3715 else {
Guido van Rossum29d38cd1998-10-02 13:41:54 +00003716 /* Treat "(a=1, b)" as an error */
Jeremy Hylton376e63d2003-08-28 14:42:14 +00003717 if (ndefs) {
Guido van Rossum29d38cd1998-10-02 13:41:54 +00003718 com_error(c, PyExc_SyntaxError,
Guido van Rossumdfede311998-10-02 14:06:56 +00003719 "non-default argument follows default argument");
Jeremy Hylton376e63d2003-08-28 14:42:14 +00003720 return -1;
3721 }
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003722 }
3723 if (t != COMMA)
3724 break;
3725 }
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00003726 return ndefs;
3727}
3728
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003729static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003730com_funcdef(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003731{
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003732 PyObject *co;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003733 int ndefs;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003734 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003735 ndefs = com_argdefs(c, n);
Jeremy Hylton376e63d2003-08-28 14:42:14 +00003736 if (ndefs < 0)
3737 return;
Jeremy Hylton4b38da62001-02-02 18:19:15 +00003738 symtable_enter_scope(c->c_symtable, STR(CHILD(n, 1)), TYPE(n),
3739 n->n_lineno);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003740 co = (PyObject *)icompile(n, c);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003741 symtable_exit_scope(c->c_symtable);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003742 if (co == NULL)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003743 c->c_errors++;
3744 else {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003745 int closure = com_make_closure(c, (PyCodeObject *)co);
3746 int i = com_addconst(c, co);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003747 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003748 com_push(c, 1);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003749 if (closure)
3750 com_addoparg(c, MAKE_CLOSURE, ndefs);
3751 else
3752 com_addoparg(c, MAKE_FUNCTION, ndefs);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003753 com_pop(c, ndefs);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003754 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1)));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003755 com_pop(c, 1);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003756 Py_DECREF(co);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003757 }
3758}
3759
3760static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003761com_bases(struct compiling *c, node *n)
Guido van Rossumc5e96291991-12-10 13:53:51 +00003762{
Guido van Rossumf1aeab71992-03-27 17:28:26 +00003763 int i;
Guido van Rossumc5e96291991-12-10 13:53:51 +00003764 REQ(n, testlist);
3765 /* testlist: test (',' test)* [','] */
3766 for (i = 0; i < NCH(n); i += 2)
3767 com_node(c, CHILD(n, i));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003768 i = (NCH(n)+1) / 2;
3769 com_addoparg(c, BUILD_TUPLE, i);
3770 com_pop(c, i-1);
Guido van Rossumc5e96291991-12-10 13:53:51 +00003771}
3772
3773static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003774com_classdef(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003775{
Guido van Rossum25831651993-05-19 14:50:45 +00003776 int i;
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003777 PyObject *v;
3778 PyCodeObject *co;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003779 char *name;
3780
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003781 REQ(n, classdef);
Guido van Rossum25831651993-05-19 14:50:45 +00003782 /* classdef: class NAME ['(' testlist ')'] ':' suite */
Guido van Rossum7b89b6a1997-01-18 08:02:57 +00003783 if ((v = PyString_InternFromString(STR(CHILD(n, 1)))) == NULL) {
Guido van Rossum25831651993-05-19 14:50:45 +00003784 c->c_errors++;
3785 return;
3786 }
3787 /* Push the class name on the stack */
3788 i = com_addconst(c, v);
3789 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003790 com_push(c, 1);
Guido van Rossum79f25d91997-04-29 20:08:16 +00003791 Py_DECREF(v);
Guido van Rossum25831651993-05-19 14:50:45 +00003792 /* Push the tuple of base classes on the stack */
Guido van Rossum8b993a91997-01-17 21:04:03 +00003793 if (TYPE(CHILD(n, 2)) != LPAR) {
Guido van Rossumc5e96291991-12-10 13:53:51 +00003794 com_addoparg(c, BUILD_TUPLE, 0);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003795 com_push(c, 1);
3796 }
Guido van Rossum25831651993-05-19 14:50:45 +00003797 else
3798 com_bases(c, CHILD(n, 3));
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003799 name = STR(CHILD(n, 1));
Jeremy Hylton4b38da62001-02-02 18:19:15 +00003800 symtable_enter_scope(c->c_symtable, name, TYPE(n), n->n_lineno);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003801 co = icompile(n, c);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003802 symtable_exit_scope(c->c_symtable);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003803 if (co == NULL)
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003804 c->c_errors++;
3805 else {
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003806 int closure = com_make_closure(c, co);
3807 i = com_addconst(c, (PyObject *)co);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003808 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003809 com_push(c, 1);
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003810 if (closure) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003811 com_addoparg(c, MAKE_CLOSURE, 0);
Jeremy Hylton733c8932001-12-13 19:51:56 +00003812 com_pop(c, PyCode_GetNumFree(co));
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003813 } else
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003814 com_addoparg(c, MAKE_FUNCTION, 0);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003815 com_addoparg(c, CALL_FUNCTION, 0);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003816 com_addbyte(c, BUILD_CLASS);
Guido van Rossum8b993a91997-01-17 21:04:03 +00003817 com_pop(c, 2);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003818 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1)));
Jeremy Hylton93a569d2001-10-17 13:22:22 +00003819 com_pop(c, 1);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00003820 Py_DECREF(co);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00003821 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003822}
3823
3824static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003825com_node(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003826{
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003827 loop:
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00003828 if (c->c_errors)
3829 return;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003830 switch (TYPE(n)) {
3831
3832 /* Definition nodes */
3833
3834 case funcdef:
3835 com_funcdef(c, n);
3836 break;
3837 case classdef:
3838 com_classdef(c, n);
3839 break;
3840
3841 /* Trivial parse tree nodes */
3842
3843 case stmt:
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003844 case small_stmt:
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003845 case flow_stmt:
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003846 n = CHILD(n, 0);
3847 goto loop;
Guido van Rossum3f5da241990-12-20 15:06:42 +00003848
3849 case simple_stmt:
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003850 /* small_stmt (';' small_stmt)* [';'] NEWLINE */
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003851 com_set_lineno(c, n->n_lineno);
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003852 {
3853 int i;
3854 for (i = 0; i < NCH(n)-1; i += 2)
3855 com_node(c, CHILD(n, i));
3856 }
3857 break;
3858
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003859 case compound_stmt:
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003860 com_set_lineno(c, n->n_lineno);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003861 n = CHILD(n, 0);
3862 goto loop;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003863
3864 /* Statement nodes */
3865
3866 case expr_stmt:
3867 com_expr_stmt(c, n);
3868 break;
3869 case print_stmt:
3870 com_print_stmt(c, n);
3871 break;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003872 case del_stmt: /* 'del' exprlist */
Thomas Wouters434d0822000-08-24 20:11:32 +00003873 com_assign(c, CHILD(n, 1), OP_DELETE, NULL);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003874 break;
3875 case pass_stmt:
3876 break;
3877 case break_stmt:
Guido van Rossum3f5da241990-12-20 15:06:42 +00003878 if (c->c_loops == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00003879 com_error(c, PyExc_SyntaxError,
3880 "'break' outside loop");
Guido van Rossum3f5da241990-12-20 15:06:42 +00003881 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003882 com_addbyte(c, BREAK_LOOP);
3883 break;
Guido van Rossum4bad92c1991-07-27 21:34:52 +00003884 case continue_stmt:
3885 com_continue_stmt(c, n);
3886 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003887 case return_stmt:
3888 com_return_stmt(c, n);
3889 break;
Tim Peters5ca576e2001-06-18 22:08:13 +00003890 case yield_stmt:
3891 com_yield_stmt(c, n);
3892 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003893 case raise_stmt:
3894 com_raise_stmt(c, n);
3895 break;
3896 case import_stmt:
3897 com_import_stmt(c, n);
3898 break;
Guido van Rossumc5e96291991-12-10 13:53:51 +00003899 case global_stmt:
Guido van Rossumc5e96291991-12-10 13:53:51 +00003900 break;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003901 case exec_stmt:
3902 com_exec_stmt(c, n);
3903 break;
Guido van Rossum228d7f31997-04-02 05:24:36 +00003904 case assert_stmt:
3905 com_assert_stmt(c, n);
3906 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003907 case if_stmt:
3908 com_if_stmt(c, n);
3909 break;
3910 case while_stmt:
3911 com_while_stmt(c, n);
3912 break;
3913 case for_stmt:
3914 com_for_stmt(c, n);
3915 break;
3916 case try_stmt:
3917 com_try_stmt(c, n);
3918 break;
3919 case suite:
3920 com_suite(c, n);
3921 break;
3922
3923 /* Expression nodes */
3924
3925 case testlist:
Guido van Rossum2d3b9862002-05-24 15:47:06 +00003926 case testlist1:
Guido van Rossum1c917072001-10-15 15:44:05 +00003927 case testlist_safe:
Guido van Rossum288a60f1991-12-16 13:05:10 +00003928 com_list(c, n, 0);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003929 break;
3930 case test:
3931 com_test(c, n);
3932 break;
3933 case and_test:
3934 com_and_test(c, n);
3935 break;
3936 case not_test:
3937 com_not_test(c, n);
3938 break;
3939 case comparison:
3940 com_comparison(c, n);
3941 break;
3942 case exprlist:
Guido van Rossum288a60f1991-12-16 13:05:10 +00003943 com_list(c, n, 0);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003944 break;
3945 case expr:
3946 com_expr(c, n);
3947 break;
Guido van Rossum7928cd71991-10-24 14:59:31 +00003948 case xor_expr:
3949 com_xor_expr(c, n);
3950 break;
3951 case and_expr:
3952 com_and_expr(c, n);
3953 break;
3954 case shift_expr:
3955 com_shift_expr(c, n);
3956 break;
3957 case arith_expr:
3958 com_arith_expr(c, n);
3959 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003960 case term:
3961 com_term(c, n);
3962 break;
3963 case factor:
3964 com_factor(c, n);
3965 break;
Guido van Rossum50564e81996-01-12 01:13:16 +00003966 case power:
3967 com_power(c, n);
3968 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003969 case atom:
3970 com_atom(c, n);
3971 break;
3972
3973 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00003974 com_error(c, PyExc_SystemError,
3975 "com_node: unexpected node type");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003976 }
3977}
3978
Tim Petersdbd9ba62000-07-09 03:09:57 +00003979static void com_fplist(struct compiling *, node *);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003980
3981static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003982com_fpdef(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003983{
3984 REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */
3985 if (TYPE(CHILD(n, 0)) == LPAR)
3986 com_fplist(c, CHILD(n, 1));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003987 else {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00003988 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 0)));
Guido van Rossum8b993a91997-01-17 21:04:03 +00003989 com_pop(c, 1);
3990 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003991}
3992
3993static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003994com_fplist(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003995{
Guido van Rossuma9df32a1991-12-31 13:13:35 +00003996 REQ(n, fplist); /* fplist: fpdef (',' fpdef)* [','] */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003997 if (NCH(n) == 1) {
3998 com_fpdef(c, CHILD(n, 0));
3999 }
4000 else {
Guido van Rossum8b993a91997-01-17 21:04:03 +00004001 int i = (NCH(n)+1)/2;
Thomas Wouters0be5aab2000-08-11 22:15:52 +00004002 com_addoparg(c, UNPACK_SEQUENCE, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004003 com_push(c, i-1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004004 for (i = 0; i < NCH(n); i += 2)
4005 com_fpdef(c, CHILD(n, i));
4006 }
4007}
4008
4009static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004010com_arglist(struct compiling *c, node *n)
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004011{
Guido van Rossum633d90c2002-12-23 16:51:42 +00004012 int nch, i, narg;
Guido van Rossum681d79a1995-07-18 14:51:37 +00004013 int complex = 0;
Guido van Rossum633d90c2002-12-23 16:51:42 +00004014 char nbuf[30];
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004015 REQ(n, varargslist);
Guido van Rossumacbefef1992-01-19 16:33:51 +00004016 /* varargslist:
Guido van Rossum681d79a1995-07-18 14:51:37 +00004017 (fpdef ['=' test] ',')* (fpdef ['=' test] | '*' .....) */
Guido van Rossum633d90c2002-12-23 16:51:42 +00004018 nch = NCH(n);
4019 /* Enter all arguments in table of locals */
4020 for (i = 0, narg = 0; i < nch; i++) {
4021 node *ch = CHILD(n, i);
4022 node *fp;
4023 if (TYPE(ch) == STAR || TYPE(ch) == DOUBLESTAR)
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004024 break;
Guido van Rossum633d90c2002-12-23 16:51:42 +00004025 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */
4026 fp = CHILD(ch, 0);
4027 if (TYPE(fp) != NAME) {
4028 PyOS_snprintf(nbuf, sizeof(nbuf), ".%d", i);
4029 complex = 1;
Guido van Rossum9c8a0862002-12-23 16:35:23 +00004030 }
Guido van Rossum633d90c2002-12-23 16:51:42 +00004031 narg++;
4032 /* all name updates handled by symtable */
4033 if (++i >= nch)
4034 break;
4035 ch = CHILD(n, i);
4036 if (TYPE(ch) == EQUAL)
4037 i += 2;
4038 else
4039 REQ(ch, COMMA);
4040 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00004041 if (complex) {
4042 /* Generate code for complex arguments only after
4043 having counted the simple arguments */
4044 int ilocal = 0;
Guido van Rossum633d90c2002-12-23 16:51:42 +00004045 for (i = 0; i < nch; i++) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00004046 node *ch = CHILD(n, i);
4047 node *fp;
Guido van Rossum50564e81996-01-12 01:13:16 +00004048 if (TYPE(ch) == STAR || TYPE(ch) == DOUBLESTAR)
Guido van Rossum681d79a1995-07-18 14:51:37 +00004049 break;
4050 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */
4051 fp = CHILD(ch, 0);
4052 if (TYPE(fp) != NAME) {
4053 com_addoparg(c, LOAD_FAST, ilocal);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004054 com_push(c, 1);
Guido van Rossum681d79a1995-07-18 14:51:37 +00004055 com_fpdef(c, ch);
4056 }
4057 ilocal++;
Guido van Rossum633d90c2002-12-23 16:51:42 +00004058 if (++i >= nch)
Guido van Rossum681d79a1995-07-18 14:51:37 +00004059 break;
4060 ch = CHILD(n, i);
4061 if (TYPE(ch) == EQUAL)
4062 i += 2;
4063 else
4064 REQ(ch, COMMA);
4065 }
4066 }
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004067}
4068
4069static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004070com_file_input(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004071{
4072 int i;
Guido van Rossum79f25d91997-04-29 20:08:16 +00004073 PyObject *doc;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004074 REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */
Martin v. Löwis339d0f72001-08-17 18:39:25 +00004075 doc = get_docstring(c, n);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004076 if (doc != NULL) {
4077 int i = com_addconst(c, doc);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004078 Py_DECREF(doc);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004079 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004080 com_push(c, 1);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004081 com_addop_name(c, STORE_NAME, "__doc__");
Guido van Rossum8b993a91997-01-17 21:04:03 +00004082 com_pop(c, 1);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004083 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004084 for (i = 0; i < NCH(n); i++) {
4085 node *ch = CHILD(n, i);
4086 if (TYPE(ch) != ENDMARKER && TYPE(ch) != NEWLINE)
4087 com_node(c, ch);
4088 }
4089}
4090
4091/* Top-level compile-node interface */
4092
4093static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004094compile_funcdef(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004095{
Guido van Rossum79f25d91997-04-29 20:08:16 +00004096 PyObject *doc;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004097 node *ch;
4098 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
Guido van Rossum9bfef441993-03-29 10:43:31 +00004099 c->c_name = STR(CHILD(n, 1));
Martin v. Löwis339d0f72001-08-17 18:39:25 +00004100 doc = get_docstring(c, CHILD(n, 4));
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004101 if (doc != NULL) {
4102 (void) com_addconst(c, doc);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004103 Py_DECREF(doc);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004104 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00004105 else
Guido van Rossum79f25d91997-04-29 20:08:16 +00004106 (void) com_addconst(c, Py_None); /* No docstring */
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004107 ch = CHILD(n, 2); /* parameters: '(' [varargslist] ')' */
4108 ch = CHILD(ch, 1); /* ')' | varargslist */
Guido van Rossum681d79a1995-07-18 14:51:37 +00004109 if (TYPE(ch) == varargslist)
Guido van Rossum49d6dc41992-01-14 18:30:26 +00004110 com_arglist(c, ch);
Guido van Rossum3f5da241990-12-20 15:06:42 +00004111 c->c_infunction = 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004112 com_node(c, CHILD(n, 4));
Guido van Rossum3f5da241990-12-20 15:06:42 +00004113 c->c_infunction = 0;
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00004114 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
4115 com_push(c, 1);
4116 com_addbyte(c, RETURN_VALUE);
4117 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004118}
4119
4120static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004121compile_lambdef(struct compiling *c, node *n)
Guido van Rossum12d12c51993-10-26 17:58:25 +00004122{
Guido van Rossum590baa41993-11-30 13:40:46 +00004123 node *ch;
Guido van Rossum681d79a1995-07-18 14:51:37 +00004124 REQ(n, lambdef); /* lambdef: 'lambda' [varargslist] ':' test */
Guido van Rossum363ac7d1994-11-10 22:40:34 +00004125 c->c_name = "<lambda>";
Guido van Rossum590baa41993-11-30 13:40:46 +00004126
4127 ch = CHILD(n, 1);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004128 (void) com_addconst(c, Py_None); /* No docstring */
Guido van Rossum681d79a1995-07-18 14:51:37 +00004129 if (TYPE(ch) == varargslist) {
Guido van Rossum590baa41993-11-30 13:40:46 +00004130 com_arglist(c, ch);
Guido van Rossum681d79a1995-07-18 14:51:37 +00004131 ch = CHILD(n, 3);
Guido van Rossum590baa41993-11-30 13:40:46 +00004132 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00004133 else
4134 ch = CHILD(n, 2);
4135 com_node(c, ch);
Guido van Rossum12d12c51993-10-26 17:58:25 +00004136 com_addbyte(c, RETURN_VALUE);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004137 com_pop(c, 1);
Guido van Rossum12d12c51993-10-26 17:58:25 +00004138}
4139
4140static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004141compile_classdef(struct compiling *c, node *n)
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004142{
4143 node *ch;
Guido van Rossum79f25d91997-04-29 20:08:16 +00004144 PyObject *doc;
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004145 REQ(n, classdef);
4146 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */
4147 c->c_name = STR(CHILD(n, 1));
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004148 c->c_private = c->c_name;
Guido van Rossum340cbe72002-01-15 21:06:07 +00004149 /* Initialize local __module__ from global __name__ */
4150 com_addop_name(c, LOAD_GLOBAL, "__name__");
4151 com_addop_name(c, STORE_NAME, "__module__");
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004152 ch = CHILD(n, NCH(n)-1); /* The suite */
Martin v. Löwis339d0f72001-08-17 18:39:25 +00004153 doc = get_docstring(c, ch);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004154 if (doc != NULL) {
4155 int i = com_addconst(c, doc);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004156 Py_DECREF(doc);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004157 com_addoparg(c, LOAD_CONST, i);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004158 com_push(c, 1);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004159 com_addop_name(c, STORE_NAME, "__doc__");
Guido van Rossum8b993a91997-01-17 21:04:03 +00004160 com_pop(c, 1);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004161 }
4162 else
Guido van Rossum79f25d91997-04-29 20:08:16 +00004163 (void) com_addconst(c, Py_None);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004164 com_node(c, ch);
4165 com_addbyte(c, LOAD_LOCALS);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004166 com_push(c, 1);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004167 com_addbyte(c, RETURN_VALUE);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004168 com_pop(c, 1);
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004169}
4170
4171static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004172compile_node(struct compiling *c, node *n)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004173{
Michael W. Hudsondd32a912002-08-15 14:59:02 +00004174 com_set_lineno(c, n->n_lineno);
Guido van Rossum3f5da241990-12-20 15:06:42 +00004175
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004176 switch (TYPE(n)) {
4177
Guido van Rossum4c417781991-01-21 16:09:22 +00004178 case single_input: /* One interactive command */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004179 /* NEWLINE | simple_stmt | compound_stmt NEWLINE */
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00004180 c->c_interactive++;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004181 n = CHILD(n, 0);
4182 if (TYPE(n) != NEWLINE)
4183 com_node(c, n);
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00004184 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
4185 com_push(c, 1);
4186 com_addbyte(c, RETURN_VALUE);
4187 com_pop(c, 1);
Guido van Rossum4ca6c9d1994-08-29 12:16:12 +00004188 c->c_interactive--;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004189 break;
4190
Guido van Rossum4c417781991-01-21 16:09:22 +00004191 case file_input: /* A whole file, or built-in function exec() */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004192 com_file_input(c, n);
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00004193 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
4194 com_push(c, 1);
4195 com_addbyte(c, RETURN_VALUE);
4196 com_pop(c, 1);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004197 break;
4198
Guido van Rossum590baa41993-11-30 13:40:46 +00004199 case eval_input: /* Built-in function input() */
Guido van Rossum4c417781991-01-21 16:09:22 +00004200 com_node(c, CHILD(n, 0));
4201 com_addbyte(c, RETURN_VALUE);
Guido van Rossum8b993a91997-01-17 21:04:03 +00004202 com_pop(c, 1);
Guido van Rossum4c417781991-01-21 16:09:22 +00004203 break;
4204
Guido van Rossum590baa41993-11-30 13:40:46 +00004205 case lambdef: /* anonymous function definition */
4206 compile_lambdef(c, n);
4207 break;
4208
Guido van Rossum4c417781991-01-21 16:09:22 +00004209 case funcdef: /* A function definition */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004210 compile_funcdef(c, n);
4211 break;
4212
Guido van Rossum4c417781991-01-21 16:09:22 +00004213 case classdef: /* A class definition */
Guido van Rossum1f4fa501995-01-07 12:41:23 +00004214 compile_classdef(c, n);
Guido van Rossumd6f3bc21990-11-18 17:35:03 +00004215 break;
4216
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004217 default:
Guido van Rossum79f25d91997-04-29 20:08:16 +00004218 com_error(c, PyExc_SystemError,
Guido van Rossum452a9831996-09-17 14:32:04 +00004219 "compile_node: unexpected node type");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004220 }
4221}
4222
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004223static PyObject *
4224dict_keys_inorder(PyObject *dict, int offset)
4225{
4226 PyObject *tuple, *k, *v;
4227 int i, pos = 0, size = PyDict_Size(dict);
4228
4229 tuple = PyTuple_New(size);
4230 if (tuple == NULL)
4231 return NULL;
4232 while (PyDict_Next(dict, &pos, &k, &v)) {
4233 i = PyInt_AS_LONG(v);
4234 Py_INCREF(k);
Jeremy Hyltonce7ef592001-03-20 00:25:43 +00004235 assert((i - offset) < size);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004236 PyTuple_SET_ITEM(tuple, i - offset, k);
4237 }
4238 return tuple;
4239}
4240
Guido van Rossum79f25d91997-04-29 20:08:16 +00004241PyCodeObject *
Martin v. Löwis95292d62002-12-11 14:04:59 +00004242PyNode_Compile(node *n, const char *filename)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004243{
Jeremy Hylton9f324e92001-03-01 22:59:14 +00004244 return PyNode_CompileFlags(n, filename, NULL);
4245}
4246
4247PyCodeObject *
Martin v. Löwis95292d62002-12-11 14:04:59 +00004248PyNode_CompileFlags(node *n, const char *filename, PyCompilerFlags *flags)
Jeremy Hylton9f324e92001-03-01 22:59:14 +00004249{
4250 return jcompile(n, filename, NULL, flags);
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004251}
4252
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004253struct symtable *
Martin v. Löwis95292d62002-12-11 14:04:59 +00004254PyNode_CompileSymtable(node *n, const char *filename)
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004255{
4256 struct symtable *st;
Jeremy Hyltonded4bd72001-03-21 19:01:33 +00004257 PyFutureFeatures *ff;
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004258
Jeremy Hyltonded4bd72001-03-21 19:01:33 +00004259 ff = PyNode_Future(n, filename);
4260 if (ff == NULL)
4261 return NULL;
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004262 st = symtable_build(n, ff, filename);
Tim Peters8c5e4152001-11-04 19:26:58 +00004263 if (st == NULL) {
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +00004264 PyObject_FREE((void *)ff);
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004265 return NULL;
Tim Peters8c5e4152001-11-04 19:26:58 +00004266 }
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004267 return st;
4268}
4269
Guido van Rossum79f25d91997-04-29 20:08:16 +00004270static PyCodeObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004271icompile(node *n, struct compiling *base)
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004272{
Jeremy Hylton9f324e92001-03-01 22:59:14 +00004273 return jcompile(n, base->c_filename, base, NULL);
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004274}
4275
Guido van Rossum79f25d91997-04-29 20:08:16 +00004276static PyCodeObject *
Martin v. Löwis95292d62002-12-11 14:04:59 +00004277jcompile(node *n, const char *filename, struct compiling *base,
Jeremy Hylton9f324e92001-03-01 22:59:14 +00004278 PyCompilerFlags *flags)
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004279{
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004280 struct compiling sc;
Guido van Rossum79f25d91997-04-29 20:08:16 +00004281 PyCodeObject *co;
Guido van Rossum590baa41993-11-30 13:40:46 +00004282 if (!com_init(&sc, filename))
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004283 return NULL;
Just van Rossum3aaf42c2003-02-10 08:21:10 +00004284 if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) {
4285 sc.c_encoding = "utf-8";
4286 } else if (TYPE(n) == encoding_decl) {
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00004287 sc.c_encoding = STR(n);
4288 n = CHILD(n, 0);
4289 } else {
4290 sc.c_encoding = NULL;
4291 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004292 if (base) {
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004293 sc.c_private = base->c_private;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004294 sc.c_symtable = base->c_symtable;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004295 /* c_symtable still points to parent's symbols */
4296 if (base->c_nested
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004297 || (sc.c_symtable->st_cur->ste_type == TYPE_FUNCTION))
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004298 sc.c_nested = 1;
Jeremy Hylton93a569d2001-10-17 13:22:22 +00004299 sc.c_flags |= base->c_flags & PyCF_MASK;
Martin v. Löwis00f1e3f2002-08-04 17:29:52 +00004300 if (base->c_encoding != NULL) {
4301 assert(sc.c_encoding == NULL);
4302 sc.c_encoding = base->c_encoding;
4303 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004304 } else {
Guido van Rossum8ff077b1996-08-24 06:21:31 +00004305 sc.c_private = NULL;
Jeremy Hylton4db62b12001-02-27 19:07:02 +00004306 sc.c_future = PyNode_Future(n, filename);
Jeremy Hylton9f324e92001-03-01 22:59:14 +00004307 if (sc.c_future == NULL) {
4308 com_free(&sc);
4309 return NULL;
4310 }
Jeremy Hylton481081e2001-08-14 20:01:59 +00004311 if (flags) {
4312 int merged = sc.c_future->ff_features |
4313 flags->cf_flags;
4314 sc.c_future->ff_features = merged;
4315 flags->cf_flags = merged;
4316 }
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004317 sc.c_symtable = symtable_build(n, sc.c_future, sc.c_filename);
4318 if (sc.c_symtable == NULL) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004319 com_free(&sc);
4320 return NULL;
4321 }
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004322 /* reset symbol table for second pass */
4323 sc.c_symtable->st_nscopes = 1;
4324 sc.c_symtable->st_pass = 2;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004325 }
4326 co = NULL;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004327 if (symtable_load_symbols(&sc) < 0) {
4328 sc.c_errors++;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004329 goto exit;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004330 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004331 compile_node(&sc, n);
4332 com_done(&sc);
Guido van Rossum9bfef441993-03-29 10:43:31 +00004333 if (sc.c_errors == 0) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004334 PyObject *consts, *names, *varnames, *filename, *name,
4335 *freevars, *cellvars;
Guido van Rossum79f25d91997-04-29 20:08:16 +00004336 consts = PyList_AsTuple(sc.c_consts);
4337 names = PyList_AsTuple(sc.c_names);
4338 varnames = PyList_AsTuple(sc.c_varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004339 cellvars = dict_keys_inorder(sc.c_cellvars, 0);
4340 freevars = dict_keys_inorder(sc.c_freevars,
4341 PyTuple_GET_SIZE(cellvars));
Guido van Rossum7b89b6a1997-01-18 08:02:57 +00004342 filename = PyString_InternFromString(sc.c_filename);
4343 name = PyString_InternFromString(sc.c_name);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004344 if (!PyErr_Occurred())
4345 co = PyCode_New(sc.c_argcount,
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004346 sc.c_nlocals,
4347 sc.c_maxstacklevel,
4348 sc.c_flags,
4349 sc.c_code,
4350 consts,
4351 names,
4352 varnames,
4353 freevars,
4354 cellvars,
4355 filename,
4356 name,
4357 sc.c_firstlineno,
4358 sc.c_lnotab);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004359 Py_XDECREF(consts);
4360 Py_XDECREF(names);
4361 Py_XDECREF(varnames);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004362 Py_XDECREF(freevars);
4363 Py_XDECREF(cellvars);
Guido van Rossum79f25d91997-04-29 20:08:16 +00004364 Py_XDECREF(filename);
4365 Py_XDECREF(name);
Guido van Rossuma082ce41991-06-04 19:41:56 +00004366 }
Guido van Rossum6c2f0c72000-08-07 19:22:43 +00004367 else if (!PyErr_Occurred()) {
4368 /* This could happen if someone called PyErr_Clear() after an
4369 error was reported above. That's not supposed to happen,
4370 but I just plugged one case and I'm not sure there can't be
4371 others. In that case, raise SystemError so that at least
4372 it gets reported instead dumping core. */
4373 PyErr_SetString(PyExc_SystemError, "lost syntax error");
4374 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004375 exit:
Jeremy Hylton74b3bc42001-02-23 17:55:27 +00004376 if (base == NULL) {
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004377 PySymtable_Free(sc.c_symtable);
Jeremy Hylton74b3bc42001-02-23 17:55:27 +00004378 sc.c_symtable = NULL;
4379 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004380 com_free(&sc);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004381 return co;
4382}
Guido van Rossumda4eb5c1997-01-24 03:43:35 +00004383
4384int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004385PyCode_Addr2Line(PyCodeObject *co, int addrq)
Guido van Rossumda4eb5c1997-01-24 03:43:35 +00004386{
4387 int size = PyString_Size(co->co_lnotab) / 2;
Guido van Rossum2174dcb1999-09-15 22:48:09 +00004388 unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
Guido van Rossumda4eb5c1997-01-24 03:43:35 +00004389 int line = co->co_firstlineno;
4390 int addr = 0;
4391 while (--size >= 0) {
4392 addr += *p++;
4393 if (addr > addrq)
4394 break;
4395 line += *p++;
4396 }
4397 return line;
4398}
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004399
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004400/* The test for LOCAL must come before the test for FREE in order to
4401 handle classes where name is both local and free. The local var is
4402 a method and the free var is a free var referenced within a method.
4403*/
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004404
4405static int
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004406get_ref_type(struct compiling *c, char *name)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004407{
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004408 char buf[350];
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004409 PyObject *v;
Jeremy Hylton51257732001-03-01 00:42:55 +00004410
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004411 if (PyDict_GetItemString(c->c_cellvars, name) != NULL)
4412 return CELL;
4413 if (PyDict_GetItemString(c->c_locals, name) != NULL)
4414 return LOCAL;
4415 if (PyDict_GetItemString(c->c_freevars, name) != NULL)
4416 return FREE;
4417 v = PyDict_GetItemString(c->c_globals, name);
4418 if (v) {
4419 if (v == Py_None)
4420 return GLOBAL_EXPLICIT;
4421 else {
4422 return GLOBAL_IMPLICIT;
4423 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004424 }
Marc-André Lemburgd4c0a9c2001-11-28 11:47:00 +00004425 PyOS_snprintf(buf, sizeof(buf),
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004426 "unknown scope for %.100s in %.100s(%s) "
4427 "in %s\nsymbols: %s\nlocals: %s\nglobals: %s\n",
4428 name, c->c_name,
4429 PyObject_REPR(c->c_symtable->st_cur->ste_id),
4430 c->c_filename,
4431 PyObject_REPR(c->c_symtable->st_cur->ste_symbols),
4432 PyObject_REPR(c->c_locals),
4433 PyObject_REPR(c->c_globals)
4434 );
4435
4436 Py_FatalError(buf);
4437 return -1;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004438}
4439
Guido van Rossum207fda62001-03-02 03:30:41 +00004440/* Helper functions to issue warnings */
4441
4442static int
Martin v. Löwis95292d62002-12-11 14:04:59 +00004443issue_warning(const char *msg, const char *filename, int lineno)
Guido van Rossum207fda62001-03-02 03:30:41 +00004444{
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004445 if (PyErr_Occurred()) {
4446 /* This can happen because symtable_node continues
4447 processing even after raising a SyntaxError.
4448 Calling PyErr_WarnExplicit now would clobber the
4449 pending exception; instead we fail and let that
4450 exception propagate.
4451 */
4452 return -1;
4453 }
Guido van Rossum207fda62001-03-02 03:30:41 +00004454 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, filename,
4455 lineno, NULL, NULL) < 0) {
4456 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
4457 PyErr_SetString(PyExc_SyntaxError, msg);
4458 PyErr_SyntaxLocation(filename, lineno);
4459 }
4460 return -1;
4461 }
4462 return 0;
4463}
Guido van Rossumee34ac12001-02-28 22:08:12 +00004464
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004465static int
Guido van Rossumee34ac12001-02-28 22:08:12 +00004466symtable_warn(struct symtable *st, char *msg)
4467{
Guido van Rossum207fda62001-03-02 03:30:41 +00004468 if (issue_warning(msg, st->st_filename, st->st_cur->ste_lineno) < 0) {
Guido van Rossumee34ac12001-02-28 22:08:12 +00004469 st->st_errors++;
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004470 return -1;
Guido van Rossumee34ac12001-02-28 22:08:12 +00004471 }
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004472 return 0;
Guido van Rossumee34ac12001-02-28 22:08:12 +00004473}
4474
Jeremy Hylton9f1b9932001-02-28 07:07:43 +00004475/* Helper function for setting lineno and filename */
4476
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004477static struct symtable *
4478symtable_build(node *n, PyFutureFeatures *ff, const char *filename)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004479{
Jeremy Hylton1955fcf2003-07-15 20:23:26 +00004480 struct symtable *st;
4481
4482 st = symtable_init();
4483 if (st == NULL)
4484 return NULL;
4485 st->st_future = ff;
4486 st->st_filename = filename;
4487 symtable_enter_scope(st, TOP, TYPE(n), n->n_lineno);
4488 if (st->st_errors > 0)
4489 goto fail;
4490 symtable_node(st, n);
4491 if (st->st_errors > 0)
4492 goto fail;
4493 return st;
4494 fail:
4495 if (!PyErr_Occurred()) {
4496 /* This could happen because after a syntax error is
4497 detected, the symbol-table-building continues for
4498 a while, and PyErr_Clear() might erroneously be
4499 called during that process. One such case has been
4500 fixed, but there might be more (now or later).
4501 */
4502 PyErr_SetString(PyExc_SystemError, "lost exception");
4503 }
4504 st->st_future = NULL;
4505 st->st_filename = NULL;
4506 PySymtable_Free(st);
4507 return NULL;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004508}
4509
4510static int
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004511symtable_init_compiling_symbols(struct compiling *c)
4512{
4513 PyObject *varnames;
4514
4515 varnames = c->c_symtable->st_cur->ste_varnames;
4516 if (varnames == NULL) {
4517 varnames = PyList_New(0);
4518 if (varnames == NULL)
4519 return -1;
4520 c->c_symtable->st_cur->ste_varnames = varnames;
4521 Py_INCREF(varnames);
4522 } else
4523 Py_INCREF(varnames);
4524 c->c_varnames = varnames;
4525
4526 c->c_globals = PyDict_New();
4527 if (c->c_globals == NULL)
4528 return -1;
4529 c->c_freevars = PyDict_New();
4530 if (c->c_freevars == NULL)
4531 return -1;
4532 c->c_cellvars = PyDict_New();
4533 if (c->c_cellvars == NULL)
4534 return -1;
4535 return 0;
4536}
4537
4538struct symbol_info {
4539 int si_nlocals;
4540 int si_ncells;
4541 int si_nfrees;
4542 int si_nimplicit;
4543};
4544
4545static void
4546symtable_init_info(struct symbol_info *si)
4547{
4548 si->si_nlocals = 0;
4549 si->si_ncells = 0;
4550 si->si_nfrees = 0;
4551 si->si_nimplicit = 0;
4552}
4553
4554static int
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004555symtable_resolve_free(struct compiling *c, PyObject *name, int flags,
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004556 struct symbol_info *si)
4557{
4558 PyObject *dict, *v;
4559
4560 /* Seperate logic for DEF_FREE. If it occurs in a function,
4561 it indicates a local that we must allocate storage for (a
4562 cell var). If it occurs in a class, then the class has a
4563 method and a free variable with the same name.
4564 */
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004565 if (c->c_symtable->st_cur->ste_type == TYPE_FUNCTION) {
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004566 /* If it isn't declared locally, it can't be a cell. */
4567 if (!(flags & (DEF_LOCAL | DEF_PARAM)))
4568 return 0;
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004569 v = PyInt_FromLong(si->si_ncells++);
4570 dict = c->c_cellvars;
4571 } else {
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004572 /* If it is free anyway, then there is no need to do
4573 anything here.
4574 */
4575 if (is_free(flags ^ DEF_FREE_CLASS)
Jeremy Hylton9c901052001-05-08 04:12:34 +00004576 || (flags == DEF_FREE_CLASS))
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004577 return 0;
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004578 v = PyInt_FromLong(si->si_nfrees++);
4579 dict = c->c_freevars;
4580 }
4581 if (v == NULL)
4582 return -1;
4583 if (PyDict_SetItem(dict, name, v) < 0) {
4584 Py_DECREF(v);
4585 return -1;
4586 }
4587 Py_DECREF(v);
4588 return 0;
4589}
4590
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004591/* If a variable is a cell and an argument, make sure that appears in
4592 co_cellvars before any variable to its right in varnames.
4593*/
4594
4595
4596static int
4597symtable_cellvar_offsets(PyObject **cellvars, int argcount,
4598 PyObject *varnames, int flags)
4599{
Tim Petersb39903b2003-03-24 17:22:24 +00004600 PyObject *v = NULL;
4601 PyObject *w, *d, *list = NULL;
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004602 int i, pos;
4603
4604 if (flags & CO_VARARGS)
4605 argcount++;
4606 if (flags & CO_VARKEYWORDS)
4607 argcount++;
4608 for (i = argcount; --i >= 0; ) {
4609 v = PyList_GET_ITEM(varnames, i);
4610 if (PyDict_GetItem(*cellvars, v)) {
4611 if (list == NULL) {
4612 list = PyList_New(1);
4613 if (list == NULL)
4614 return -1;
4615 PyList_SET_ITEM(list, 0, v);
4616 Py_INCREF(v);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004617 } else {
4618 if (PyList_Insert(list, 0, v) < 0) {
4619 Py_DECREF(list);
4620 return -1;
4621 }
4622 }
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004623 }
4624 }
Jeremy Hylton521482d2003-05-22 15:47:02 +00004625 if (list == NULL)
4626 return 0;
4627
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004628 /* There are cellvars that are also arguments. Create a dict
4629 to replace cellvars and put the args at the front.
4630 */
4631 d = PyDict_New();
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004632 if (d == NULL)
4633 return -1;
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004634 for (i = PyList_GET_SIZE(list); --i >= 0; ) {
4635 v = PyInt_FromLong(i);
4636 if (v == NULL)
4637 goto fail;
4638 if (PyDict_SetItem(d, PyList_GET_ITEM(list, i), v) < 0)
4639 goto fail;
4640 if (PyDict_DelItem(*cellvars, PyList_GET_ITEM(list, i)) < 0)
4641 goto fail;
Tim Petersb39903b2003-03-24 17:22:24 +00004642 Py_DECREF(v);
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004643 }
4644 pos = 0;
4645 i = PyList_GET_SIZE(list);
4646 Py_DECREF(list);
4647 while (PyDict_Next(*cellvars, &pos, &v, &w)) {
4648 w = PyInt_FromLong(i++); /* don't care about the old key */
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004649 if (w == NULL)
4650 goto fail;
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004651 if (PyDict_SetItem(d, v, w) < 0) {
4652 Py_DECREF(w);
Tim Petersb39903b2003-03-24 17:22:24 +00004653 v = NULL;
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004654 goto fail;
4655 }
4656 Py_DECREF(w);
4657 }
4658 Py_DECREF(*cellvars);
4659 *cellvars = d;
4660 return 1;
4661 fail:
4662 Py_DECREF(d);
Tim Petersb39903b2003-03-24 17:22:24 +00004663 Py_XDECREF(v);
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004664 return -1;
4665}
4666
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004667static int
4668symtable_freevar_offsets(PyObject *freevars, int offset)
4669{
4670 PyObject *name, *v;
4671 int pos;
4672
4673 /* The cell vars are the first elements of the closure,
4674 followed by the free vars. Update the offsets in
4675 c_freevars to account for number of cellvars. */
4676 pos = 0;
4677 while (PyDict_Next(freevars, &pos, &name, &v)) {
4678 int i = PyInt_AS_LONG(v) + offset;
4679 PyObject *o = PyInt_FromLong(i);
4680 if (o == NULL)
4681 return -1;
4682 if (PyDict_SetItem(freevars, name, o) < 0) {
4683 Py_DECREF(o);
4684 return -1;
4685 }
4686 Py_DECREF(o);
4687 }
4688 return 0;
4689}
4690
4691static int
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004692symtable_check_unoptimized(struct compiling *c,
4693 PySymtableEntryObject *ste,
4694 struct symbol_info *si)
4695{
4696 char buf[300];
4697
4698 if (!(si->si_ncells || si->si_nfrees || ste->ste_child_free
4699 || (ste->ste_nested && si->si_nimplicit)))
4700 return 0;
4701
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004702#define ILLEGAL_CONTAINS "contains a nested function with free variables"
4703
4704#define ILLEGAL_IS "is a nested function"
4705
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004706#define ILLEGAL_IMPORT_STAR \
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004707"import * is not allowed in function '%.100s' because it %s"
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004708
4709#define ILLEGAL_BARE_EXEC \
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004710"unqualified exec is not allowed in function '%.100s' it %s"
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004711
4712#define ILLEGAL_EXEC_AND_IMPORT_STAR \
Neal Norwitz150d09d2002-01-29 00:56:37 +00004713"function '%.100s' uses import * and bare exec, which are illegal " \
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004714"because it %s"
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004715
4716 /* XXX perhaps the linenos for these opt-breaking statements
4717 should be stored so the exception can point to them. */
4718
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004719 if (ste->ste_child_free) {
4720 if (ste->ste_optimized == OPT_IMPORT_STAR)
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004721 PyOS_snprintf(buf, sizeof(buf),
4722 ILLEGAL_IMPORT_STAR,
4723 PyString_AS_STRING(ste->ste_name),
4724 ILLEGAL_CONTAINS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004725 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC))
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004726 PyOS_snprintf(buf, sizeof(buf),
4727 ILLEGAL_BARE_EXEC,
4728 PyString_AS_STRING(ste->ste_name),
4729 ILLEGAL_CONTAINS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004730 else {
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004731 PyOS_snprintf(buf, sizeof(buf),
4732 ILLEGAL_EXEC_AND_IMPORT_STAR,
4733 PyString_AS_STRING(ste->ste_name),
4734 ILLEGAL_CONTAINS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004735 }
4736 } else {
4737 if (ste->ste_optimized == OPT_IMPORT_STAR)
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004738 PyOS_snprintf(buf, sizeof(buf),
4739 ILLEGAL_IMPORT_STAR,
4740 PyString_AS_STRING(ste->ste_name),
4741 ILLEGAL_IS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004742 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC))
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004743 PyOS_snprintf(buf, sizeof(buf),
4744 ILLEGAL_BARE_EXEC,
4745 PyString_AS_STRING(ste->ste_name),
4746 ILLEGAL_IS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004747 else {
Barry Warsaw8f6d8682001-11-28 21:10:39 +00004748 PyOS_snprintf(buf, sizeof(buf),
4749 ILLEGAL_EXEC_AND_IMPORT_STAR,
4750 PyString_AS_STRING(ste->ste_name),
4751 ILLEGAL_IS);
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004752 }
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004753 }
Jeremy Hylton280e6bd2001-03-22 03:51:05 +00004754
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004755 PyErr_SetString(PyExc_SyntaxError, buf);
4756 PyErr_SyntaxLocation(c->c_symtable->st_filename,
4757 ste->ste_opt_lineno);
4758 return -1;
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004759}
4760
4761static int
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004762symtable_update_flags(struct compiling *c, PySymtableEntryObject *ste,
4763 struct symbol_info *si)
4764{
Jeremy Hyltonb857ba22001-08-10 21:41:33 +00004765 if (c->c_future)
4766 c->c_flags |= c->c_future->ff_features;
Tim Peters5ca576e2001-06-18 22:08:13 +00004767 if (ste->ste_generator)
4768 c->c_flags |= CO_GENERATOR;
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004769 if (ste->ste_type != TYPE_MODULE)
4770 c->c_flags |= CO_NEWLOCALS;
4771 if (ste->ste_type == TYPE_FUNCTION) {
4772 c->c_nlocals = si->si_nlocals;
4773 if (ste->ste_optimized == 0)
4774 c->c_flags |= CO_OPTIMIZED;
Jeremy Hylton4419ac12001-02-28 22:54:51 +00004775 else if (ste->ste_optimized != OPT_EXEC)
4776 return symtable_check_unoptimized(c, ste, si);
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004777 }
4778 return 0;
4779}
4780
4781static int
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004782symtable_load_symbols(struct compiling *c)
4783{
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004784 struct symtable *st = c->c_symtable;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004785 PySymtableEntryObject *ste = st->st_cur;
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004786 PyObject *name, *varnames, *v;
4787 int i, flags, pos;
4788 struct symbol_info si;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004789
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004790 v = NULL;
4791
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004792 if (symtable_init_compiling_symbols(c) < 0)
4793 goto fail;
4794 symtable_init_info(&si);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004795 varnames = st->st_cur->ste_varnames;
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004796 si.si_nlocals = PyList_GET_SIZE(varnames);
4797 c->c_argcount = si.si_nlocals;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004798
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004799 for (i = 0; i < si.si_nlocals; ++i) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004800 v = PyInt_FromLong(i);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004801 if (v == NULL)
4802 goto fail;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004803 if (PyDict_SetItem(c->c_locals,
4804 PyList_GET_ITEM(varnames, i), v) < 0)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004805 goto fail;
4806 Py_DECREF(v);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004807 }
4808
4809 /* XXX The cases below define the rules for whether a name is
4810 local or global. The logic could probably be clearer. */
4811 pos = 0;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004812 while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
4813 flags = PyInt_AS_LONG(v);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004814
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004815 if (flags & DEF_FREE_GLOBAL)
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004816 /* undo the original DEF_FREE */
4817 flags &= ~(DEF_FREE | DEF_FREE_CLASS);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004818
Jeremy Hyltonce7ef592001-03-20 00:25:43 +00004819 /* Deal with names that need two actions:
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004820 1. Cell variables that are also locals.
Jeremy Hyltonce7ef592001-03-20 00:25:43 +00004821 2. Free variables in methods that are also class
4822 variables or declared global.
4823 */
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004824 if (flags & (DEF_FREE | DEF_FREE_CLASS))
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004825 symtable_resolve_free(c, name, flags, &si);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004826
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004827 if (flags & DEF_STAR) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004828 c->c_argcount--;
4829 c->c_flags |= CO_VARARGS;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004830 } else if (flags & DEF_DOUBLESTAR) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004831 c->c_argcount--;
4832 c->c_flags |= CO_VARKEYWORDS;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004833 } else if (flags & DEF_INTUPLE)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004834 c->c_argcount--;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004835 else if (flags & DEF_GLOBAL) {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004836 if (flags & DEF_PARAM) {
4837 PyErr_Format(PyExc_SyntaxError, LOCAL_GLOBAL,
Jeremy Hylton5acc0c02001-02-02 20:01:10 +00004838 PyString_AS_STRING(name));
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +00004839 PyErr_SyntaxLocation(st->st_filename,
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004840 ste->ste_lineno);
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004841 st->st_errors++;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004842 goto fail;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004843 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004844 if (PyDict_SetItem(c->c_globals, name, Py_None) < 0)
4845 goto fail;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004846 } else if (flags & DEF_FREE_GLOBAL) {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004847 si.si_nimplicit++;
Neal Norwitz06982222002-12-18 01:18:44 +00004848 if (PyDict_SetItem(c->c_globals, name, Py_True) < 0)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004849 goto fail;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004850 } else if ((flags & DEF_LOCAL) && !(flags & DEF_PARAM)) {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004851 v = PyInt_FromLong(si.si_nlocals++);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004852 if (v == NULL)
4853 goto fail;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004854 if (PyDict_SetItem(c->c_locals, name, v) < 0)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004855 goto fail;
4856 Py_DECREF(v);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004857 if (ste->ste_type != TYPE_CLASS)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004858 if (PyList_Append(c->c_varnames, name) < 0)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004859 goto fail;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004860 } else if (is_free(flags)) {
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004861 if (ste->ste_nested) {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004862 v = PyInt_FromLong(si.si_nfrees++);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004863 if (v == NULL)
4864 goto fail;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004865 if (PyDict_SetItem(c->c_freevars, name, v) < 0)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004866 goto fail;
4867 Py_DECREF(v);
4868 } else {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004869 si.si_nimplicit++;
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004870 if (PyDict_SetItem(c->c_globals, name,
Neal Norwitz06982222002-12-18 01:18:44 +00004871 Py_True) < 0)
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004872 goto fail;
4873 if (st->st_nscopes != 1) {
4874 v = PyInt_FromLong(flags);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004875 if (v == NULL)
4876 goto fail;
Jeremy Hylton1abf6102001-08-11 21:51:24 +00004877 if (PyDict_SetItem(st->st_global,
4878 name, v))
4879 goto fail;
4880 Py_DECREF(v);
4881 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004882 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004883 }
4884 }
4885
Jeremy Hyltonddc4fd02001-04-27 02:29:40 +00004886 assert(PyDict_Size(c->c_freevars) == si.si_nfrees);
4887
Jeremy Hylton220ae7c2001-03-21 16:43:47 +00004888 if (si.si_ncells > 1) { /* one cell is always in order */
4889 if (symtable_cellvar_offsets(&c->c_cellvars, c->c_argcount,
4890 c->c_varnames, c->c_flags) < 0)
4891 return -1;
4892 }
Jeremy Hylton29906ee2001-02-27 04:23:34 +00004893 if (symtable_freevar_offsets(c->c_freevars, si.si_ncells) < 0)
4894 return -1;
4895 return symtable_update_flags(c, ste, &si);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004896 fail:
4897 /* is this always the right thing to do? */
4898 Py_XDECREF(v);
4899 return -1;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004900}
4901
4902static struct symtable *
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004903symtable_init()
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004904{
4905 struct symtable *st;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004906
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +00004907 st = (struct symtable *)PyObject_MALLOC(sizeof(struct symtable));
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004908 if (st == NULL)
4909 return NULL;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004910 st->st_pass = 1;
Tim Petersff1f8522001-08-11 01:06:35 +00004911
Jeremy Hylton5acc0c02001-02-02 20:01:10 +00004912 st->st_filename = NULL;
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004913 st->st_symbols = NULL;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004914 if ((st->st_stack = PyList_New(0)) == NULL)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004915 goto fail;
4916 if ((st->st_symbols = PyDict_New()) == NULL)
4917 goto fail;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004918 st->st_cur = NULL;
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004919 st->st_nscopes = 0;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004920 st->st_errors = 0;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004921 st->st_private = NULL;
4922 return st;
4923 fail:
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004924 PySymtable_Free(st);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004925 return NULL;
4926}
4927
Jeremy Hylton4b38da62001-02-02 18:19:15 +00004928void
4929PySymtable_Free(struct symtable *st)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004930{
4931 Py_XDECREF(st->st_symbols);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004932 Py_XDECREF(st->st_stack);
Jeremy Hylton74b3bc42001-02-23 17:55:27 +00004933 Py_XDECREF(st->st_cur);
Andrew MacIntyre80d4e2a2002-08-04 06:28:21 +00004934 PyObject_FREE((void *)st);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00004935}
4936
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004937/* When the compiler exits a scope, it must should update the scope's
4938 free variable information with the list of free variables in its
4939 children.
4940
4941 Variables that are free in children and defined in the current
4942 scope are cellvars.
4943
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004944 If the scope being exited is defined at the top-level (ste_nested is
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004945 false), free variables in children that are not defined here are
4946 implicit globals.
4947
4948*/
4949
4950static int
4951symtable_update_free_vars(struct symtable *st)
4952{
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00004953 int i, j, def;
4954 PyObject *o, *name, *list = NULL;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004955 PySymtableEntryObject *child, *ste = st->st_cur;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004956
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004957 if (ste->ste_type == TYPE_CLASS)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004958 def = DEF_FREE_CLASS;
4959 else
4960 def = DEF_FREE;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004961 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004962 int pos = 0;
4963
Jeremy Hyltonf9415e62003-05-22 16:22:33 +00004964 if (list && PyList_SetSlice(list, 0,
4965 PyList_GET_SIZE(list), 0) < 0)
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00004966 return -1;
Barry Warsaw0372af72001-02-23 18:22:59 +00004967 child = (PySymtableEntryObject *)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004968 PyList_GET_ITEM(ste->ste_children, i);
4969 while (PyDict_Next(child->ste_symbols, &pos, &name, &o)) {
Jeremy Hylton78891072001-03-01 06:09:34 +00004970 int flags = PyInt_AS_LONG(o);
4971 if (!(is_free(flags)))
Jeremy Hylton64949cb2001-01-25 20:06:59 +00004972 continue; /* avoids indentation */
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00004973 if (list == NULL) {
4974 list = PyList_New(0);
4975 if (list == NULL)
4976 return -1;
4977 }
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00004978 ste->ste_child_free = 1;
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00004979 if (PyList_Append(list, name) < 0) {
4980 Py_DECREF(list);
4981 return -1;
4982 }
4983 }
4984 for (j = 0; list && j < PyList_GET_SIZE(list); j++) {
Jeremy Hylton78891072001-03-01 06:09:34 +00004985 PyObject *v;
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00004986 name = PyList_GET_ITEM(list, j);
Jeremy Hylton78891072001-03-01 06:09:34 +00004987 v = PyDict_GetItem(ste->ste_symbols, name);
4988 /* If a name N is declared global in scope A and
4989 referenced in scope B contained (perhaps
4990 indirectly) in A and there are no scopes
4991 with bindings for N between B and A, then N
Jeremy Hylton9c901052001-05-08 04:12:34 +00004992 is global in B. Unless A is a class scope,
4993 because class scopes are not considered for
4994 nested scopes.
Jeremy Hylton78891072001-03-01 06:09:34 +00004995 */
Jeremy Hyltonce7ef592001-03-20 00:25:43 +00004996 if (v && (ste->ste_type != TYPE_CLASS)) {
Jeremy Hylton78891072001-03-01 06:09:34 +00004997 int flags = PyInt_AS_LONG(v);
4998 if (flags & DEF_GLOBAL) {
4999 symtable_undo_free(st, child->ste_id,
5000 name);
5001 continue;
5002 }
5003 }
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005004 if (ste->ste_nested) {
5005 if (symtable_add_def_o(st, ste->ste_symbols,
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00005006 name, def) < 0) {
5007 Py_DECREF(list);
5008 return -1;
5009 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005010 } else {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005011 if (symtable_check_global(st, child->ste_id,
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00005012 name) < 0) {
5013 Py_DECREF(list);
5014 return -1;
5015 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005016 }
5017 }
5018 }
Jeremy Hyltond7f393e2001-02-12 16:01:03 +00005019
5020 Py_XDECREF(list);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005021 return 0;
5022}
5023
5024/* If the current scope is a non-nested class or if name is not
5025 defined in the current, non-nested scope, then it is an implicit
5026 global in all nested scopes.
5027*/
5028
5029static int
5030symtable_check_global(struct symtable *st, PyObject *child, PyObject *name)
5031{
5032 PyObject *o;
5033 int v;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005034 PySymtableEntryObject *ste = st->st_cur;
Jeremy Hylton78891072001-03-01 06:09:34 +00005035
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005036 if (ste->ste_type == TYPE_CLASS)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005037 return symtable_undo_free(st, child, name);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005038 o = PyDict_GetItem(ste->ste_symbols, name);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005039 if (o == NULL)
5040 return symtable_undo_free(st, child, name);
5041 v = PyInt_AS_LONG(o);
Jeremy Hylton78891072001-03-01 06:09:34 +00005042
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005043 if (is_free(v) || (v & DEF_GLOBAL))
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005044 return symtable_undo_free(st, child, name);
5045 else
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005046 return symtable_add_def_o(st, ste->ste_symbols,
5047 name, DEF_FREE);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005048}
5049
5050static int
5051symtable_undo_free(struct symtable *st, PyObject *id,
5052 PyObject *name)
5053{
5054 int i, v, x;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005055 PyObject *info;
5056 PySymtableEntryObject *ste;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005057
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005058 ste = (PySymtableEntryObject *)PyDict_GetItem(st->st_symbols, id);
5059 if (ste == NULL)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005060 return -1;
Jeremy Hylton78891072001-03-01 06:09:34 +00005061
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005062 info = PyDict_GetItem(ste->ste_symbols, name);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005063 if (info == NULL)
5064 return 0;
5065 v = PyInt_AS_LONG(info);
5066 if (is_free(v)) {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005067 if (symtable_add_def_o(st, ste->ste_symbols, name,
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005068 DEF_FREE_GLOBAL) < 0)
5069 return -1;
5070 } else
5071 /* If the name is defined here or declared global,
5072 then the recursion stops. */
5073 return 0;
5074
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005075 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
5076 PySymtableEntryObject *child;
Barry Warsaw0372af72001-02-23 18:22:59 +00005077 child = (PySymtableEntryObject *)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005078 PyList_GET_ITEM(ste->ste_children, i);
5079 x = symtable_undo_free(st, child->ste_id, name);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005080 if (x < 0)
5081 return x;
5082 }
5083 return 0;
5084}
5085
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005086/* symtable_enter_scope() gets a reference via PySymtableEntry_New().
5087 This reference is released when the scope is exited, via the DECREF
5088 in symtable_exit_scope().
5089*/
5090
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005091static int
5092symtable_exit_scope(struct symtable *st)
5093{
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005094 int end;
5095
Jeremy Hylton4419ac12001-02-28 22:54:51 +00005096 if (st->st_pass == 1)
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005097 symtable_update_free_vars(st);
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005098 Py_DECREF(st->st_cur);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005099 end = PyList_GET_SIZE(st->st_stack) - 1;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005100 st->st_cur = (PySymtableEntryObject *)PyList_GET_ITEM(st->st_stack,
5101 end);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005102 if (PySequence_DelItem(st->st_stack, end) < 0)
5103 return -1;
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005104 return 0;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005105}
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005106
Jeremy Hylton4b38da62001-02-02 18:19:15 +00005107static void
5108symtable_enter_scope(struct symtable *st, char *name, int type,
5109 int lineno)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005110{
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005111 PySymtableEntryObject *prev = NULL;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005112
5113 if (st->st_cur) {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005114 prev = st->st_cur;
5115 if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {
Jeremy Hylton4b38da62001-02-02 18:19:15 +00005116 st->st_errors++;
5117 return;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005118 }
5119 }
Barry Warsaw0372af72001-02-23 18:22:59 +00005120 st->st_cur = (PySymtableEntryObject *)
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005121 PySymtableEntry_New(st, name, type, lineno);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00005122 if (st->st_cur == NULL) {
5123 st->st_errors++;
5124 return;
5125 }
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005126 if (strcmp(name, TOP) == 0)
5127 st->st_global = st->st_cur->ste_symbols;
Jeremy Hylton74b3bc42001-02-23 17:55:27 +00005128 if (prev && st->st_pass == 1) {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005129 if (PyList_Append(prev->ste_children,
5130 (PyObject *)st->st_cur) < 0)
5131 st->st_errors++;
Jeremy Hylton74b3bc42001-02-23 17:55:27 +00005132 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005133}
5134
5135static int
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005136symtable_lookup(struct symtable *st, char *name)
5137{
5138 char buffer[MANGLE_LEN];
5139 PyObject *v;
5140 int flags;
5141
Raymond Hettinger0ae0c072002-06-20 22:23:15 +00005142 if (_Py_Mangle(st->st_private, name, buffer, sizeof(buffer)))
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005143 name = buffer;
5144 v = PyDict_GetItemString(st->st_cur->ste_symbols, name);
5145 if (v == NULL) {
5146 if (PyErr_Occurred())
5147 return -1;
5148 else
5149 return 0;
5150 }
5151
5152 flags = PyInt_AS_LONG(v);
5153 return flags;
5154}
5155
5156static int
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005157symtable_add_def(struct symtable *st, char *name, int flag)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005158{
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005159 PyObject *s;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005160 char buffer[MANGLE_LEN];
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005161 int ret;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005162
Guido van Rossumb7164622002-08-16 02:48:11 +00005163 /* Warn about None, except inside a tuple (where the assignment
5164 code already issues a warning). */
5165 if ((flag & DEF_PARAM) && !(flag & DEF_INTUPLE) &&
5166 *name == 'N' && strcmp(name, "None") == 0)
5167 {
5168 if (symtable_warn(st, "argument named None"))
5169 return -1;
5170 }
Raymond Hettinger0ae0c072002-06-20 22:23:15 +00005171 if (_Py_Mangle(st->st_private, name, buffer, sizeof(buffer)))
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005172 name = buffer;
5173 if ((s = PyString_InternFromString(name)) == NULL)
5174 return -1;
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005175 ret = symtable_add_def_o(st, st->st_cur->ste_symbols, s, flag);
5176 Py_DECREF(s);
5177 return ret;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005178}
5179
5180/* Must only be called with mangled names */
5181
5182static int
5183symtable_add_def_o(struct symtable *st, PyObject *dict,
5184 PyObject *name, int flag)
5185{
5186 PyObject *o;
5187 int val;
5188
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005189 if ((o = PyDict_GetItem(dict, name))) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005190 val = PyInt_AS_LONG(o);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005191 if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005192 PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
Jeremy Hylton483638c2001-02-01 20:20:45 +00005193 PyString_AsString(name));
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +00005194 PyErr_SyntaxLocation(st->st_filename,
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005195 st->st_cur->ste_lineno);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005196 return -1;
5197 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005198 val |= flag;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005199 } else
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005200 val = flag;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005201 o = PyInt_FromLong(val);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00005202 if (o == NULL)
5203 return -1;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005204 if (PyDict_SetItem(dict, name, o) < 0) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005205 Py_DECREF(o);
5206 return -1;
5207 }
5208 Py_DECREF(o);
5209
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005210 if (flag & DEF_PARAM) {
Jeremy Hyltoncb17ae82001-02-09 22:22:18 +00005211 if (PyList_Append(st->st_cur->ste_varnames, name) < 0)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005212 return -1;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005213 } else if (flag & DEF_GLOBAL) {
5214 /* XXX need to update DEF_GLOBAL for other flags too;
5215 perhaps only DEF_FREE_GLOBAL */
5216 if ((o = PyDict_GetItem(st->st_global, name))) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005217 val = PyInt_AS_LONG(o);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005218 val |= flag;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005219 } else
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005220 val = flag;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005221 o = PyInt_FromLong(val);
Martin v. Löwiscd12bfc2003-05-03 10:53:08 +00005222 if (o == NULL)
5223 return -1;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005224 if (PyDict_SetItem(st->st_global, name, o) < 0) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005225 Py_DECREF(o);
5226 return -1;
5227 }
5228 Py_DECREF(o);
5229 }
5230 return 0;
5231}
5232
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005233#define symtable_add_use(ST, NAME) symtable_add_def((ST), (NAME), USE)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005234
Tim Peters08a898f2001-06-28 01:52:22 +00005235/* Look for a yield stmt under n. Return 1 if found, else 0.
5236 This hack is used to look inside "if 0:" blocks (which are normally
5237 ignored) in case those are the only places a yield occurs (so that this
5238 function is a generator). */
Tim Petersb6c3cea2001-06-26 03:36:28 +00005239static int
5240look_for_yield(node *n)
5241{
5242 int i;
5243
5244 for (i = 0; i < NCH(n); ++i) {
5245 node *kid = CHILD(n, i);
5246
5247 switch (TYPE(kid)) {
5248
5249 case classdef:
5250 case funcdef:
Tim Peters08a898f2001-06-28 01:52:22 +00005251 case lambdef:
Tim Petersb6c3cea2001-06-26 03:36:28 +00005252 /* Stuff in nested functions and classes can't make
5253 the parent a generator. */
5254 return 0;
5255
5256 case yield_stmt:
5257 return 1;
5258
5259 default:
5260 if (look_for_yield(kid))
5261 return 1;
5262 }
5263 }
5264 return 0;
5265}
5266
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005267static void
5268symtable_node(struct symtable *st, node *n)
5269{
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005270 int i;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005271
5272 loop:
5273 switch (TYPE(n)) {
5274 case funcdef: {
5275 char *func_name = STR(CHILD(n, 1));
5276 symtable_add_def(st, func_name, DEF_LOCAL);
5277 symtable_default_args(st, CHILD(n, 2));
Jeremy Hylton4b38da62001-02-02 18:19:15 +00005278 symtable_enter_scope(st, func_name, TYPE(n), n->n_lineno);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005279 symtable_funcdef(st, n);
5280 symtable_exit_scope(st);
5281 break;
5282 }
5283 case lambdef:
5284 if (NCH(n) == 4)
5285 symtable_default_args(st, CHILD(n, 1));
Jeremy Hylton4b38da62001-02-02 18:19:15 +00005286 symtable_enter_scope(st, "lambda", TYPE(n), n->n_lineno);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005287 symtable_funcdef(st, n);
5288 symtable_exit_scope(st);
5289 break;
5290 case classdef: {
5291 char *tmp, *class_name = STR(CHILD(n, 1));
5292 symtable_add_def(st, class_name, DEF_LOCAL);
5293 if (TYPE(CHILD(n, 2)) == LPAR) {
5294 node *bases = CHILD(n, 3);
5295 int i;
5296 for (i = 0; i < NCH(bases); i += 2) {
5297 symtable_node(st, CHILD(bases, i));
5298 }
5299 }
Jeremy Hylton4b38da62001-02-02 18:19:15 +00005300 symtable_enter_scope(st, class_name, TYPE(n), n->n_lineno);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005301 tmp = st->st_private;
5302 st->st_private = class_name;
5303 symtable_node(st, CHILD(n, NCH(n) - 1));
5304 st->st_private = tmp;
5305 symtable_exit_scope(st);
5306 break;
5307 }
5308 case if_stmt:
5309 for (i = 0; i + 3 < NCH(n); i += 4) {
Tim Petersb6c3cea2001-06-26 03:36:28 +00005310 if (is_constant_false(NULL, (CHILD(n, i + 1)))) {
5311 if (st->st_cur->ste_generator == 0)
5312 st->st_cur->ste_generator =
5313 look_for_yield(CHILD(n, i+3));
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005314 continue;
Tim Petersb6c3cea2001-06-26 03:36:28 +00005315 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005316 symtable_node(st, CHILD(n, i + 1));
5317 symtable_node(st, CHILD(n, i + 3));
5318 }
5319 if (i + 2 < NCH(n))
5320 symtable_node(st, CHILD(n, i + 2));
5321 break;
5322 case global_stmt:
5323 symtable_global(st, n);
5324 break;
5325 case import_stmt:
5326 symtable_import(st, n);
5327 break;
Jeremy Hylton483638c2001-02-01 20:20:45 +00005328 case exec_stmt: {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005329 st->st_cur->ste_optimized |= OPT_EXEC;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005330 symtable_node(st, CHILD(n, 1));
5331 if (NCH(n) > 2)
5332 symtable_node(st, CHILD(n, 3));
Jeremy Hylton2e2cded2001-03-22 03:57:58 +00005333 else {
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005334 st->st_cur->ste_optimized |= OPT_BARE_EXEC;
Jeremy Hylton2e2cded2001-03-22 03:57:58 +00005335 st->st_cur->ste_opt_lineno = n->n_lineno;
5336 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005337 if (NCH(n) > 4)
5338 symtable_node(st, CHILD(n, 5));
5339 break;
Jeremy Hylton483638c2001-02-01 20:20:45 +00005340
5341 }
Jeremy Hylton384639f2001-02-19 15:50:51 +00005342 case assert_stmt:
5343 if (Py_OptimizeFlag)
5344 return;
5345 if (NCH(n) == 2) {
5346 n = CHILD(n, 1);
5347 goto loop;
5348 } else {
5349 symtable_node(st, CHILD(n, 1));
5350 n = CHILD(n, 3);
5351 goto loop;
5352 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005353 case except_clause:
5354 if (NCH(n) == 4)
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005355 symtable_assign(st, CHILD(n, 3), 0);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005356 if (NCH(n) > 1) {
5357 n = CHILD(n, 1);
5358 goto loop;
5359 }
5360 break;
5361 case del_stmt:
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005362 symtable_assign(st, CHILD(n, 1), 0);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005363 break;
Tim Peters5ca576e2001-06-18 22:08:13 +00005364 case yield_stmt:
5365 st->st_cur->ste_generator = 1;
5366 n = CHILD(n, 1);
5367 goto loop;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005368 case expr_stmt:
5369 if (NCH(n) == 1)
5370 n = CHILD(n, 0);
5371 else {
5372 if (TYPE(CHILD(n, 1)) == augassign) {
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005373 symtable_assign(st, CHILD(n, 0), 0);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005374 symtable_node(st, CHILD(n, 2));
5375 break;
5376 } else {
5377 int i;
5378 for (i = 0; i < NCH(n) - 2; i += 2)
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005379 symtable_assign(st, CHILD(n, i), 0);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005380 n = CHILD(n, NCH(n) - 1);
5381 }
5382 }
5383 goto loop;
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005384 case list_iter:
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005385 /* only occurs when there are multiple for loops
5386 in a list comprehension */
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005387 n = CHILD(n, 0);
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005388 if (TYPE(n) == list_for)
5389 symtable_list_for(st, n);
5390 else {
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005391 REQ(n, list_if);
5392 symtable_node(st, CHILD(n, 1));
5393 if (NCH(n) == 3) {
5394 n = CHILD(n, 2);
5395 goto loop;
5396 }
5397 }
5398 break;
5399 case for_stmt:
5400 symtable_assign(st, CHILD(n, 1), 0);
5401 for (i = 3; i < NCH(n); ++i)
5402 if (TYPE(CHILD(n, i)) >= single_input)
5403 symtable_node(st, CHILD(n, i));
5404 break;
5405 /* The remaining cases fall through to default except in
5406 special circumstances. This requires the individual cases
5407 to be coded with great care, even though they look like
5408 rather innocuous. Each case must double-check TYPE(n).
5409 */
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005410 case argument:
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005411 if (TYPE(n) == argument && NCH(n) == 3) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005412 n = CHILD(n, 2);
5413 goto loop;
5414 }
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005415 /* fall through */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005416 case listmaker:
5417 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) {
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005418 symtable_list_comprehension(st, n);
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005419 break;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005420 }
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005421 /* fall through */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005422 case atom:
5423 if (TYPE(n) == atom && TYPE(CHILD(n, 0)) == NAME) {
5424 symtable_add_use(st, STR(CHILD(n, 0)));
5425 break;
5426 }
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005427 /* fall through */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005428 default:
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005429 /* Walk over every non-token child with a special case
5430 for one child.
5431 */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005432 if (NCH(n) == 1) {
5433 n = CHILD(n, 0);
5434 goto loop;
5435 }
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005436 for (i = 0; i < NCH(n); ++i)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005437 if (TYPE(CHILD(n, i)) >= single_input)
5438 symtable_node(st, CHILD(n, i));
5439 }
5440}
5441
5442static void
5443symtable_funcdef(struct symtable *st, node *n)
5444{
5445 node *body;
5446
5447 if (TYPE(n) == lambdef) {
5448 if (NCH(n) == 4)
5449 symtable_params(st, CHILD(n, 1));
5450 } else
5451 symtable_params(st, CHILD(n, 2));
5452 body = CHILD(n, NCH(n) - 1);
5453 symtable_node(st, body);
5454}
5455
5456/* The next two functions parse the argument tuple.
Guido van Rossumb7164622002-08-16 02:48:11 +00005457 symtable_default_args() checks for names in the default arguments,
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005458 which are references in the defining scope. symtable_params()
5459 parses the parameter names, which are defined in the function's
5460 body.
5461
5462 varargslist:
5463 (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME)
5464 | fpdef ['=' test] (',' fpdef ['=' test])* [',']
5465*/
5466
5467static void
5468symtable_default_args(struct symtable *st, node *n)
5469{
5470 node *c;
5471 int i;
5472
5473 if (TYPE(n) == parameters) {
5474 n = CHILD(n, 1);
5475 if (TYPE(n) == RPAR)
5476 return;
5477 }
5478 REQ(n, varargslist);
5479 for (i = 0; i < NCH(n); i += 2) {
5480 c = CHILD(n, i);
5481 if (TYPE(c) == STAR || TYPE(c) == DOUBLESTAR) {
5482 break;
5483 }
5484 if (i > 0 && (TYPE(CHILD(n, i - 1)) == EQUAL))
5485 symtable_node(st, CHILD(n, i));
5486 }
5487}
5488
5489static void
5490symtable_params(struct symtable *st, node *n)
5491{
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005492 int i, complex = -1, ext = 0;
Guido van Rossum633d90c2002-12-23 16:51:42 +00005493 node *c = NULL;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005494
5495 if (TYPE(n) == parameters) {
5496 n = CHILD(n, 1);
5497 if (TYPE(n) == RPAR)
5498 return;
5499 }
5500 REQ(n, varargslist);
5501 for (i = 0; i < NCH(n); i += 2) {
5502 c = CHILD(n, i);
5503 if (TYPE(c) == STAR || TYPE(c) == DOUBLESTAR) {
5504 ext = 1;
5505 break;
5506 }
5507 if (TYPE(c) == test) {
5508 continue;
5509 }
Guido van Rossum633d90c2002-12-23 16:51:42 +00005510 if (TYPE(CHILD(c, 0)) == NAME)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005511 symtable_add_def(st, STR(CHILD(c, 0)), DEF_PARAM);
Guido van Rossum633d90c2002-12-23 16:51:42 +00005512 else {
Barry Warsaw8f6d8682001-11-28 21:10:39 +00005513 char nbuf[30];
5514 PyOS_snprintf(nbuf, sizeof(nbuf), ".%d", i);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005515 symtable_add_def(st, nbuf, DEF_PARAM);
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005516 complex = i;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005517 }
5518 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005519 if (ext) {
5520 c = CHILD(n, i);
5521 if (TYPE(c) == STAR) {
5522 i++;
5523 symtable_add_def(st, STR(CHILD(n, i)),
5524 DEF_PARAM | DEF_STAR);
5525 i += 2;
Jeremy Hylton1113cfc2001-01-23 00:50:52 +00005526 if (i >= NCH(n))
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005527 c = NULL;
5528 else
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005529 c = CHILD(n, i);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005530 }
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005531 if (c && TYPE(c) == DOUBLESTAR) {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005532 i++;
5533 symtable_add_def(st, STR(CHILD(n, i)),
5534 DEF_PARAM | DEF_DOUBLESTAR);
5535 }
5536 }
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005537 if (complex >= 0) {
5538 int j;
5539 for (j = 0; j <= complex; j++) {
5540 c = CHILD(n, j);
5541 if (TYPE(c) == COMMA)
Jeremy Hylton2b3f0ca2001-02-19 23:52:49 +00005542 c = CHILD(n, ++j);
5543 else if (TYPE(c) == EQUAL)
5544 c = CHILD(n, j += 3);
Jeremy Hyltona6ebc482001-01-25 17:01:49 +00005545 if (TYPE(CHILD(c, 0)) == LPAR)
5546 symtable_params_fplist(st, CHILD(c, 1));
5547 }
5548 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005549}
5550
5551static void
5552symtable_params_fplist(struct symtable *st, node *n)
5553{
5554 int i;
5555 node *c;
5556
5557 REQ(n, fplist);
5558 for (i = 0; i < NCH(n); i += 2) {
5559 c = CHILD(n, i);
5560 REQ(c, fpdef);
5561 if (NCH(c) == 1)
5562 symtable_add_def(st, STR(CHILD(c, 0)),
5563 DEF_PARAM | DEF_INTUPLE);
5564 else
5565 symtable_params_fplist(st, CHILD(c, 1));
5566 }
5567
5568}
5569
5570static void
5571symtable_global(struct symtable *st, node *n)
5572{
5573 int i;
5574
Jeremy Hylton9f324e92001-03-01 22:59:14 +00005575 /* XXX It might be helpful to warn about module-level global
5576 statements, but it's hard to tell the difference between
5577 module-level and a string passed to exec.
5578 */
Jeremy Hyltonc1761322001-02-28 23:44:45 +00005579
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005580 for (i = 1; i < NCH(n); i += 2) {
5581 char *name = STR(CHILD(n, i));
Jeremy Hyltonbe77cf72001-02-27 05:15:57 +00005582 int flags;
5583
5584 flags = symtable_lookup(st, name);
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005585 if (flags < 0)
5586 continue;
Jeremy Hyltonbe77cf72001-02-27 05:15:57 +00005587 if (flags && flags != DEF_GLOBAL) {
5588 char buf[500];
5589 if (flags & DEF_PARAM) {
5590 PyErr_Format(PyExc_SyntaxError,
5591 "name '%.400s' is local and global",
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005592 name);
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +00005593 PyErr_SyntaxLocation(st->st_filename,
Jeremy Hyltonbe77cf72001-02-27 05:15:57 +00005594 st->st_cur->ste_lineno);
5595 st->st_errors++;
5596 return;
Guido van Rossum0bba7f82001-02-28 21:55:38 +00005597 }
5598 else {
5599 if (flags & DEF_LOCAL)
Barry Warsaw8f6d8682001-11-28 21:10:39 +00005600 PyOS_snprintf(buf, sizeof(buf),
5601 GLOBAL_AFTER_ASSIGN,
5602 name);
Guido van Rossum0bba7f82001-02-28 21:55:38 +00005603 else
Barry Warsaw8f6d8682001-11-28 21:10:39 +00005604 PyOS_snprintf(buf, sizeof(buf),
5605 GLOBAL_AFTER_USE, name);
Guido van Rossumee34ac12001-02-28 22:08:12 +00005606 symtable_warn(st, buf);
Jeremy Hyltonbe77cf72001-02-27 05:15:57 +00005607 }
5608 }
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005609 symtable_add_def(st, name, DEF_GLOBAL);
5610 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005611}
5612
5613static void
5614symtable_list_comprehension(struct symtable *st, node *n)
5615{
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005616 /* listmaker: test list_for */
Barry Warsaw8f6d8682001-11-28 21:10:39 +00005617 char tmpname[30];
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005618
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005619 REQ(n, listmaker);
5620 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
5621 ++st->st_cur->ste_tmpname);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005622 symtable_add_def(st, tmpname, DEF_LOCAL);
Jeremy Hylton4d508ad2003-05-21 17:34:50 +00005623 symtable_list_for(st, CHILD(n, 1));
5624 symtable_node(st, CHILD(n, 0));
5625 --st->st_cur->ste_tmpname;
5626}
5627
5628static void
5629symtable_list_for(struct symtable *st, node *n)
5630{
5631 REQ(n, list_for);
5632 /* list_for: for v in expr [list_iter] */
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005633 symtable_assign(st, CHILD(n, 1), 0);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005634 symtable_node(st, CHILD(n, 3));
5635 if (NCH(n) == 5)
5636 symtable_node(st, CHILD(n, 4));
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005637}
5638
5639static void
5640symtable_import(struct symtable *st, node *n)
5641{
5642 int i;
Jeremy Hylton483638c2001-02-01 20:20:45 +00005643 /* import_stmt: 'import' dotted_as_name (',' dotted_as_name)*
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005644 | 'from' dotted_name 'import'
5645 ('*' | import_as_name (',' import_as_name)*)
Jeremy Hylton483638c2001-02-01 20:20:45 +00005646 import_as_name: NAME [NAME NAME]
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005647 */
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005648 if (STR(CHILD(n, 0))[0] == 'f') { /* from */
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005649 node *dotname = CHILD(n, 1);
5650 if (strcmp(STR(CHILD(dotname, 0)), "__future__") == 0) {
5651 /* check for bogus imports */
5652 if (n->n_lineno >= st->st_future->ff_last_lineno) {
5653 PyErr_SetString(PyExc_SyntaxError,
5654 LATE_FUTURE);
Jeremy Hyltonad3d3f22001-02-28 17:47:12 +00005655 PyErr_SyntaxLocation(st->st_filename,
Jeremy Hylton39e2f3f2001-02-28 01:58:08 +00005656 n->n_lineno);
5657 st->st_errors++;
5658 return;
5659 }
5660 }
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005661 if (TYPE(CHILD(n, 3)) == STAR) {
Jeremy Hylton8a6f2952001-08-06 19:45:40 +00005662 if (st->st_cur->ste_type != TYPE_MODULE) {
Jeremy Hylton6a53bd82001-08-06 20:34:25 +00005663 if (symtable_warn(st,
5664 "import * only allowed at module level") < 0)
5665 return;
Jeremy Hylton8a6f2952001-08-06 19:45:40 +00005666 }
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005667 st->st_cur->ste_optimized |= OPT_IMPORT_STAR;
Jeremy Hylton2e2cded2001-03-22 03:57:58 +00005668 st->st_cur->ste_opt_lineno = n->n_lineno;
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005669 } else {
5670 for (i = 3; i < NCH(n); i += 2) {
5671 node *c = CHILD(n, i);
5672 if (NCH(c) > 1) /* import as */
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005673 symtable_assign(st, CHILD(c, 2),
5674 DEF_IMPORT);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005675 else
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005676 symtable_assign(st, CHILD(c, 0),
5677 DEF_IMPORT);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005678 }
5679 }
Jeremy Hylton29906ee2001-02-27 04:23:34 +00005680 } else {
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005681 for (i = 1; i < NCH(n); i += 2) {
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005682 symtable_assign(st, CHILD(n, i), DEF_IMPORT);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005683 }
5684 }
5685}
5686
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005687/* The third argument to symatble_assign() is a flag to be passed to
5688 symtable_add_def() if it is eventually called. The flag is useful
5689 to specify the particular type of assignment that should be
5690 recorded, e.g. an assignment caused by import.
5691 */
5692
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005693static void
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005694symtable_assign(struct symtable *st, node *n, int def_flag)
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005695{
5696 node *tmp;
5697 int i;
5698
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005699 loop:
5700 switch (TYPE(n)) {
5701 case lambdef:
Jeremy Hyltoneab156f2001-01-30 01:24:43 +00005702 /* invalid assignment, e.g. lambda x:x=2. The next
5703 pass will catch this error. */
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005704 return;
5705 case power:
5706 if (NCH(n) > 2) {
5707 for (i = 2; i < NCH(n); ++i)
5708 if (TYPE(CHILD(n, i)) != DOUBLESTAR)
5709 symtable_node(st, CHILD(n, i));
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005710 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005711 if (NCH(n) > 1) {
5712 symtable_node(st, CHILD(n, 0));
5713 symtable_node(st, CHILD(n, 1));
5714 } else {
5715 n = CHILD(n, 0);
5716 goto loop;
5717 }
5718 return;
5719 case listmaker:
Jeremy Hylton23b42272001-03-19 20:38:06 +00005720 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) {
5721 /* XXX This is an error, but the next pass
5722 will catch it. */
5723 return;
5724 } else {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005725 for (i = 0; i < NCH(n); i += 2)
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005726 symtable_assign(st, CHILD(n, i), def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005727 }
5728 return;
5729 case exprlist:
5730 case testlist:
Guido van Rossum2d3b9862002-05-24 15:47:06 +00005731 case testlist1:
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005732 if (NCH(n) == 1) {
5733 n = CHILD(n, 0);
5734 goto loop;
5735 }
5736 else {
5737 int i;
5738 for (i = 0; i < NCH(n); i += 2)
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005739 symtable_assign(st, CHILD(n, i), def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005740 return;
5741 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005742 case atom:
5743 tmp = CHILD(n, 0);
5744 if (TYPE(tmp) == LPAR || TYPE(tmp) == LSQB) {
5745 n = CHILD(n, 1);
5746 goto loop;
Jeremy Hylton897b8212001-03-23 14:08:38 +00005747 } else if (TYPE(tmp) == NAME) {
Jeremy Hylton778e2652001-11-09 19:50:08 +00005748 if (strcmp(STR(tmp), "__debug__") == 0) {
5749 PyErr_SetString(PyExc_SyntaxError,
5750 ASSIGN_DEBUG);
5751 PyErr_SyntaxLocation(st->st_filename,
Jeremy Hylton86424e32001-12-04 02:41:46 +00005752 n->n_lineno);
Jeremy Hylton778e2652001-11-09 19:50:08 +00005753 st->st_errors++;
5754 }
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005755 symtable_add_def(st, STR(tmp), DEF_LOCAL | def_flag);
Jeremy Hylton897b8212001-03-23 14:08:38 +00005756 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005757 return;
5758 case dotted_as_name:
5759 if (NCH(n) == 3)
5760 symtable_add_def(st, STR(CHILD(n, 2)),
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005761 DEF_LOCAL | def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005762 else
5763 symtable_add_def(st,
5764 STR(CHILD(CHILD(n,
5765 0), 0)),
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005766 DEF_LOCAL | def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005767 return;
5768 case dotted_name:
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005769 symtable_add_def(st, STR(CHILD(n, 0)), DEF_LOCAL | def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005770 return;
5771 case NAME:
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005772 symtable_add_def(st, STR(n), DEF_LOCAL | def_flag);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005773 return;
5774 default:
5775 if (NCH(n) == 0)
5776 return;
Jeremy Hylton17820c42001-02-19 15:33:10 +00005777 if (NCH(n) == 1) {
5778 n = CHILD(n, 0);
5779 goto loop;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00005780 }
Jeremy Hylton17820c42001-02-19 15:33:10 +00005781 /* Should only occur for errors like x + 1 = 1,
5782 which will be caught in the next pass. */
5783 for (i = 0; i < NCH(n); ++i)
5784 if (TYPE(CHILD(n, i)) >= single_input)
Jeremy Hylton961dfe02001-10-18 16:15:10 +00005785 symtable_assign(st, CHILD(n, i), def_flag);
Jeremy Hyltone36f7782001-01-19 03:21:30 +00005786 }
5787}