Mercurial > cpython-lru_cache-weakref
annotate Python/compile.c @ 18065:889db6d55506 legacy-trunk
SF bug 430991: wrong co_lnotab
Armin Rigo pointed out that the way the line-# table got built didn't work
for lines generating more than 255 bytes of bytecode. Fixed as he
suggested, plus corresponding changes to pyassem.py, plus added some
long overdue docs about this subtle table to compile.c.
Bugfix candidate (line numbers may be off in tracebacks under -O).
| author | Tim Peters <tim.peters@gmail.com> |
|---|---|
| date | Sat, 09 Jun 2001 09:26:21 +0000 |
| parents | 437482fe55e6 |
| children | 7bc473b2c654 |
| rev | line source |
|---|---|
| 69 | 1 /* Compile an expression node to intermediate code */ |
| 2 | |
| 86 | 3 /* XXX TO DO: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
4 XXX add __doc__ attribute == co_doc to code object attributes? |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
5 XXX (it's currently the first item of the co_const tuple) |
| 86 | 6 XXX Generate simple jump for break/return outside 'try...finally' |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
7 XXX Allow 'continue' inside finally clause of try-finally |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
8 XXX New opcode for loading the initial index for a for loop |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
9 XXX other JAR tricks? |
| 86 | 10 */ |
| 69 | 11 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
12 #include "Python.h" |
| 86 | 13 |
| 69 | 14 #include "node.h" |
| 15 #include "token.h" | |
| 16 #include "graminit.h" | |
| 17 #include "compile.h" | |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
18 #include "symtable.h" |
| 69 | 19 #include "opcode.h" |
| 86 | 20 #include "structmember.h" |
| 21 | |
| 22 #include <ctype.h> | |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
23 |
|
5438
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
24 /* Three symbols from graminit.h are also defined in Python.h, with |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
25 Py_ prefixes to their names. Python.h can't include graminit.h |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
26 (which defines too many confusing symbols), but we can check here |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
27 that they haven't changed (which is very unlikely, but possible). */ |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
28 #if Py_single_input != single_input |
|
5566
19d4a2874645
Indent the #error directives so a classic K&R cpp doesn't see them.
Guido van Rossum <guido@python.org>
parents:
5453
diff
changeset
|
29 #error "single_input has changed -- update Py_single_input in Python.h" |
|
5438
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
30 #endif |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
31 #if Py_file_input != file_input |
|
5566
19d4a2874645
Indent the #error directives so a classic K&R cpp doesn't see them.
Guido van Rossum <guido@python.org>
parents:
5453
diff
changeset
|
32 #error "file_input has changed -- update Py_file_input in Python.h" |
|
5438
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
33 #endif |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
34 #if Py_eval_input != eval_input |
|
5566
19d4a2874645
Indent the #error directives so a classic K&R cpp doesn't see them.
Guido van Rossum <guido@python.org>
parents:
5453
diff
changeset
|
35 #error "eval_input has changed -- update Py_eval_input in Python.h" |
|
5438
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
36 #endif |
|
e926c331ebbf
Instead of importing graminit.h whenever one of the three grammar 'root'
Guido van Rossum <guido@python.org>
parents:
5373
diff
changeset
|
37 |
|
5164
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
38 int Py_OptimizeFlag = 0; |
|
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
39 |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
40 #define OP_DELETE 0 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
41 #define OP_ASSIGN 1 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
42 #define OP_APPLY 2 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
43 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
44 #define VAR_LOAD 0 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
45 #define VAR_STORE 1 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
46 #define VAR_DELETE 2 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
47 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
48 #define DEL_CLOSURE_ERROR \ |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
49 "can not delete variable '%.400s' referenced in nested scope" |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
50 |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
51 #define DUPLICATE_ARGUMENT \ |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
52 "duplicate argument '%s' in function definition" |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
53 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
54 #define ILLEGAL_DYNAMIC_SCOPE \ |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
55 "%.100s: exec or 'import *' makes names ambiguous in nested scope" |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
56 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
57 #define GLOBAL_AFTER_ASSIGN \ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
58 "name '%.400s' is assigned to before global declaration" |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
59 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
60 #define GLOBAL_AFTER_USE \ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
61 "name '%.400s' is used prior to global declaration" |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
62 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
63 #define LOCAL_GLOBAL \ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
64 "name '%.400s' is a function paramter and declared global" |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
65 |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
66 #define LATE_FUTURE \ |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
67 "from __future__ imports must occur at the beginning of the file" |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
68 |
|
17185
f9a30015e8b0
Make it illegal to assign to __debug__ as per Guido's request.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17132
diff
changeset
|
69 #define ASSIGN_DEBUG \ |
|
f9a30015e8b0
Make it illegal to assign to __debug__ as per Guido's request.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17132
diff
changeset
|
70 "can not assign to __debug__" |
|
f9a30015e8b0
Make it illegal to assign to __debug__ as per Guido's request.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17132
diff
changeset
|
71 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
72 #define MANGLE_LEN 256 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
73 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
74 #define OFF(x) offsetof(PyCodeObject, x) |
| 86 | 75 |
| 76 static struct memberlist code_memberlist[] = { | |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
77 {"co_argcount", T_INT, OFF(co_argcount), READONLY}, |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
78 {"co_nlocals", T_INT, OFF(co_nlocals), READONLY}, |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
79 {"co_stacksize",T_INT, OFF(co_stacksize), READONLY}, |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
80 {"co_flags", T_INT, OFF(co_flags), READONLY}, |
|
568
92509d304e47
add READONLY to member list.
Guido van Rossum <guido@python.org>
parents:
544
diff
changeset
|
81 {"co_code", T_OBJECT, OFF(co_code), READONLY}, |
|
92509d304e47
add READONLY to member list.
Guido van Rossum <guido@python.org>
parents:
544
diff
changeset
|
82 {"co_consts", T_OBJECT, OFF(co_consts), READONLY}, |
|
92509d304e47
add READONLY to member list.
Guido van Rossum <guido@python.org>
parents:
544
diff
changeset
|
83 {"co_names", T_OBJECT, OFF(co_names), READONLY}, |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
84 {"co_varnames", T_OBJECT, OFF(co_varnames), READONLY}, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
85 {"co_freevars", T_OBJECT, OFF(co_freevars), READONLY}, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
86 {"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY}, |
|
568
92509d304e47
add READONLY to member list.
Guido van Rossum <guido@python.org>
parents:
544
diff
changeset
|
87 {"co_filename", T_OBJECT, OFF(co_filename), READONLY}, |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
88 {"co_name", T_OBJECT, OFF(co_name), READONLY}, |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
89 {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY}, |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
90 {"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY}, |
| 86 | 91 {NULL} /* Sentinel */ |
| 92 }; | |
| 93 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
94 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
95 code_getattr(PyCodeObject *co, char *name) |
| 86 | 96 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
97 return PyMember_Get((char *)co, code_memberlist, name); |
| 86 | 98 } |
| 69 | 99 |
| 100 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
101 code_dealloc(PyCodeObject *co) |
| 69 | 102 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
103 Py_XDECREF(co->co_code); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
104 Py_XDECREF(co->co_consts); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
105 Py_XDECREF(co->co_names); |
|
5901
ba49a6ef7214
Plug a leak in code_dealloc() (and reordered the deallocs to match the
Guido van Rossum <guido@python.org>
parents:
5754
diff
changeset
|
106 Py_XDECREF(co->co_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
107 Py_XDECREF(co->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
108 Py_XDECREF(co->co_cellvars); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
109 Py_XDECREF(co->co_filename); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
110 Py_XDECREF(co->co_name); |
|
5901
ba49a6ef7214
Plug a leak in code_dealloc() (and reordered the deallocs to match the
Guido van Rossum <guido@python.org>
parents:
5754
diff
changeset
|
111 Py_XDECREF(co->co_lnotab); |
|
12576
1c7c2dd1beb1
Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents:
12538
diff
changeset
|
112 PyObject_DEL(co); |
| 69 | 113 } |
| 114 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
115 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
116 code_repr(PyCodeObject *co) |
|
1029
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
117 { |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
118 char buf[500]; |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
119 int lineno = -1; |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
120 char *filename = "???"; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
121 char *name = "???"; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
122 |
|
12278
647bf71912f0
Vladimir Marangozov: This fixes the line number in the string
Guido van Rossum <guido@python.org>
parents:
12086
diff
changeset
|
123 if (co->co_firstlineno != 0) |
|
647bf71912f0
Vladimir Marangozov: This fixes the line number in the string
Guido van Rossum <guido@python.org>
parents:
12086
diff
changeset
|
124 lineno = co->co_firstlineno; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
125 if (co->co_filename && PyString_Check(co->co_filename)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
126 filename = PyString_AS_STRING(co->co_filename); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
127 if (co->co_name && PyString_Check(co->co_name)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
128 name = PyString_AS_STRING(co->co_name); |
|
13227
c2df5d28034d
Trent Mick <trentm@activestate.com>:
Fred Drake <fdrake@acm.org>
parents:
13096
diff
changeset
|
129 sprintf(buf, "<code object %.100s at %p, file \"%.300s\", line %d>", |
|
c2df5d28034d
Trent Mick <trentm@activestate.com>:
Fred Drake <fdrake@acm.org>
parents:
13096
diff
changeset
|
130 name, co, filename, lineno); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
131 return PyString_FromString(buf); |
|
1029
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
132 } |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
133 |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
134 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
135 code_compare(PyCodeObject *co, PyCodeObject *cp) |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
136 { |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
137 int cmp; |
|
12333
525b2358721e
Patch by Vladimir Marangozov to include the function name when
Guido van Rossum <guido@python.org>
parents:
12278
diff
changeset
|
138 cmp = PyObject_Compare(co->co_name, cp->co_name); |
|
525b2358721e
Patch by Vladimir Marangozov to include the function name when
Guido van Rossum <guido@python.org>
parents:
12278
diff
changeset
|
139 if (cmp) return cmp; |
|
6186
2e755d1ff661
Cprrect stuoid tyops -- was comparing variabes with themselves because
Guido van Rossum <guido@python.org>
parents:
5901
diff
changeset
|
140 cmp = co->co_argcount - cp->co_argcount; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
141 if (cmp) return cmp; |
|
6186
2e755d1ff661
Cprrect stuoid tyops -- was comparing variabes with themselves because
Guido van Rossum <guido@python.org>
parents:
5901
diff
changeset
|
142 cmp = co->co_nlocals - cp->co_nlocals; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
143 if (cmp) return cmp; |
|
6186
2e755d1ff661
Cprrect stuoid tyops -- was comparing variabes with themselves because
Guido van Rossum <guido@python.org>
parents:
5901
diff
changeset
|
144 cmp = co->co_flags - cp->co_flags; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
145 if (cmp) return cmp; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
146 cmp = PyObject_Compare(co->co_code, cp->co_code); |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
147 if (cmp) return cmp; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
148 cmp = PyObject_Compare(co->co_consts, cp->co_consts); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
149 if (cmp) return cmp; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
150 cmp = PyObject_Compare(co->co_names, cp->co_names); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
151 if (cmp) return cmp; |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
152 cmp = PyObject_Compare(co->co_varnames, cp->co_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
153 if (cmp) return cmp; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
154 cmp = PyObject_Compare(co->co_freevars, cp->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
155 if (cmp) return cmp; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
156 cmp = PyObject_Compare(co->co_cellvars, cp->co_cellvars); |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
157 return cmp; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
158 } |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
159 |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
160 static long |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
161 code_hash(PyCodeObject *co) |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
162 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
163 long h, h0, h1, h2, h3, h4, h5, h6; |
|
12333
525b2358721e
Patch by Vladimir Marangozov to include the function name when
Guido van Rossum <guido@python.org>
parents:
12278
diff
changeset
|
164 h0 = PyObject_Hash(co->co_name); |
|
525b2358721e
Patch by Vladimir Marangozov to include the function name when
Guido van Rossum <guido@python.org>
parents:
12278
diff
changeset
|
165 if (h0 == -1) return -1; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
166 h1 = PyObject_Hash(co->co_code); |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
167 if (h1 == -1) return -1; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
168 h2 = PyObject_Hash(co->co_consts); |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
169 if (h2 == -1) return -1; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
170 h3 = PyObject_Hash(co->co_names); |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
171 if (h3 == -1) return -1; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
172 h4 = PyObject_Hash(co->co_varnames); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
173 if (h4 == -1) return -1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
174 h5 = PyObject_Hash(co->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
175 if (h5 == -1) return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
176 h6 = PyObject_Hash(co->co_cellvars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
177 if (h6 == -1) return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
178 h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
179 co->co_argcount ^ co->co_nlocals ^ co->co_flags; |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
180 if (h == -1) h = -2; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
181 return h; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
182 } |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
183 |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
184 /* XXX code objects need to participate in GC? */ |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
185 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
186 PyTypeObject PyCode_Type = { |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
187 PyObject_HEAD_INIT(&PyType_Type) |
| 69 | 188 0, |
| 189 "code", | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
190 sizeof(PyCodeObject), |
| 69 | 191 0, |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
192 (destructor)code_dealloc, /*tp_dealloc*/ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
193 0, /*tp_print*/ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
194 (getattrfunc)code_getattr, /*tp_getattr*/ |
| 69 | 195 0, /*tp_setattr*/ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
196 (cmpfunc)code_compare, /*tp_compare*/ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
197 (reprfunc)code_repr, /*tp_repr*/ |
| 69 | 198 0, /*tp_as_number*/ |
| 199 0, /*tp_as_sequence*/ | |
| 200 0, /*tp_as_mapping*/ | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
201 (hashfunc)code_hash, /*tp_hash*/ |
| 69 | 202 }; |
| 203 | |
|
5287
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
204 #define NAME_CHARS \ |
|
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
205 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz" |
|
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
206 |
|
16006
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
207 /* all_name_chars(s): true iff all chars in s are valid NAME_CHARS */ |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
208 |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
209 static int |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
210 all_name_chars(unsigned char *s) |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
211 { |
|
16523
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
212 static char ok_name_char[256]; |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
213 static unsigned char *name_chars = (unsigned char *)NAME_CHARS; |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
214 |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
215 if (ok_name_char[*name_chars] == 0) { |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
216 unsigned char *p; |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
217 for (p = name_chars; *p; p++) |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
218 ok_name_char[*p] = 1; |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
219 } |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
220 while (*s) { |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
221 if (ok_name_char[*s++] == 0) |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
222 return 0; |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
223 } |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
224 return 1; |
|
16006
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
225 } |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
226 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
227 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
228 intern_strings(PyObject *tuple) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
229 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
230 int i; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
231 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
232 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
233 PyObject *v = PyTuple_GET_ITEM(tuple, i); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
234 if (v == NULL || !PyString_Check(v)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
235 Py_FatalError("non-string found in code slot"); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
236 PyErr_BadInternalCall(); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
237 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
238 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
239 PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
240 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
241 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
242 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
243 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
244 PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
245 PyCode_New(int argcount, int nlocals, int stacksize, int flags, |
|
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
246 PyObject *code, PyObject *consts, PyObject *names, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
247 PyObject *varnames, PyObject *freevars, PyObject *cellvars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
248 PyObject *filename, PyObject *name, int firstlineno, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
249 PyObject *lnotab) |
| 69 | 250 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
251 PyCodeObject *co; |
| 69 | 252 int i; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
253 PyBufferProcs *pb; |
| 69 | 254 /* Check argument types */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
255 if (argcount < 0 || nlocals < 0 || |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
256 code == NULL || |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
257 consts == NULL || !PyTuple_Check(consts) || |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
258 names == NULL || !PyTuple_Check(names) || |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
259 varnames == NULL || !PyTuple_Check(varnames) || |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
260 freevars == NULL || !PyTuple_Check(freevars) || |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
261 cellvars == NULL || !PyTuple_Check(cellvars) || |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
262 name == NULL || !PyString_Check(name) || |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
263 filename == NULL || !PyString_Check(filename) || |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
264 lnotab == NULL || !PyString_Check(lnotab)) { |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
265 PyErr_BadInternalCall(); |
| 69 | 266 return NULL; |
| 267 } | |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
268 pb = code->ob_type->tp_as_buffer; |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
269 if (pb == NULL || |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
270 pb->bf_getreadbuffer == NULL || |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
271 pb->bf_getsegcount == NULL || |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
272 (*pb->bf_getsegcount)(code, NULL) != 1) |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
273 { |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
274 PyErr_BadInternalCall(); |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
275 return NULL; |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
276 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
277 intern_strings(names); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
278 intern_strings(varnames); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
279 if (freevars == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
280 freevars = PyTuple_New(0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
281 intern_strings(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
282 if (cellvars == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
283 cellvars = PyTuple_New(0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
284 intern_strings(cellvars); |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
285 /* Intern selected string constants */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
286 for (i = PyTuple_Size(consts); --i >= 0; ) { |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
287 PyObject *v = PyTuple_GetItem(consts, i); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
288 if (!PyString_Check(v)) |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
289 continue; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
290 if (!all_name_chars((unsigned char *)PyString_AS_STRING(v))) |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
291 continue; |
|
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
292 PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i)); |
| 69 | 293 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
294 co = PyObject_NEW(PyCodeObject, &PyCode_Type); |
| 69 | 295 if (co != NULL) { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
296 co->co_argcount = argcount; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
297 co->co_nlocals = nlocals; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
298 co->co_stacksize = stacksize; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
299 co->co_flags = flags; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
300 Py_INCREF(code); |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
301 co->co_code = code; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
302 Py_INCREF(consts); |
| 69 | 303 co->co_consts = consts; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
304 Py_INCREF(names); |
| 69 | 305 co->co_names = names; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
306 Py_INCREF(varnames); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
307 co->co_varnames = varnames; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
308 Py_INCREF(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
309 co->co_freevars = freevars; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
310 Py_INCREF(cellvars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
311 co->co_cellvars = cellvars; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
312 Py_INCREF(filename); |
|
266
b5826bf29677
Changed and exported newcodeobject() interface, for ".pyc" files.
Guido van Rossum <guido@python.org>
parents:
238
diff
changeset
|
313 co->co_filename = filename; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
314 Py_INCREF(name); |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
315 co->co_name = name; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
316 co->co_firstlineno = firstlineno; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
317 Py_INCREF(lnotab); |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
318 co->co_lnotab = lnotab; |
| 69 | 319 } |
| 320 return co; | |
| 321 } | |
| 322 | |
| 323 | |
| 324 /* Data structure used internally */ | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
325 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
326 /* The compiler uses two passes to generate bytecodes. The first pass |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
327 builds the symbol table. The second pass generates the bytecode. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
328 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
329 The first pass uses a single symtable struct. The second pass uses |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
330 a compiling struct for each code block. The compiling structs |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
331 share a reference to the symtable. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
332 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
333 The two passes communicate via symtable_load_symbols() and via |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
334 is_local() and is_global(). The former initializes several slots |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
335 in the compiling struct: c_varnames, c_locals, c_nlocals, |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
336 c_argcount, c_globals, and c_flags. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
337 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
338 |
|
18065
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
339 /* All about c_lnotab. |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
340 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
341 c_lnotab is an array of unsigned bytes disguised as a Python string. In -O |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
342 mode, SET_LINENO opcodes aren't generated, and bytecode offsets are mapped |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
343 to source code line #s (when needed for tracebacks) via c_lnotab instead. |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
344 The array is conceptually a list of |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
345 (bytecode offset increment, line number increment) |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
346 pairs. The details are important and delicate, best illustrated by example: |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
347 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
348 byte code offset source code line number |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
349 0 1 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
350 6 2 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
351 50 7 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
352 350 307 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
353 361 308 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
354 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
355 The first trick is that these numbers aren't stored, only the increments |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
356 from one row to the next (this doesn't really work, but it's a start): |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
357 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
358 0, 1, 6, 1, 44, 5, 300, 300, 11, 1 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
359 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
360 The second trick is that an unsigned byte can't hold negative values, or |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
361 values larger than 255, so (a) there's a deep assumption that byte code |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
362 offsets and their corresponding line #s both increase monotonically, and (b) |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
363 if at least one column jumps by more than 255 from one row to the next, more |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
364 than one pair is written to the table. In case #b, there's no way to know |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
365 from looking at the table later how many were written. That's the delicate |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
366 part. A user of c_lnotab desiring to find the source line number |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
367 corresponding to a bytecode address A should do something like this |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
368 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
369 lineno = addr = 0 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
370 for addr_incr, line_incr in c_lnotab: |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
371 addr += addr_incr |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
372 if addr > A: |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
373 return lineno |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
374 lineno += line_incr |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
375 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
376 In order for this to work, when the addr field increments by more than 255, |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
377 the line # increment in each pair generated must be 0 until the remaining addr |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
378 increment is < 256. So, in the example above, com_set_lineno should not (as |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
379 was actually done until 2.2) expand 300, 300 to 255, 255, 45, 45, but to |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
380 255, 0, 45, 255, 0, 45. |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
381 */ |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
382 |
| 69 | 383 struct compiling { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
384 PyObject *c_code; /* string */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
385 PyObject *c_consts; /* list of objects */ |
| 12522 | 386 PyObject *c_const_dict; /* inverse of c_consts */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
387 PyObject *c_names; /* list of strings (names) */ |
| 12522 | 388 PyObject *c_name_dict; /* inverse of c_names */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
389 PyObject *c_globals; /* dictionary (value=None) */ |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
390 PyObject *c_locals; /* dictionary (value=localID) */ |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
391 PyObject *c_varnames; /* list (inverse of c_locals) */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
392 PyObject *c_freevars; /* dictionary (value=None) */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
393 PyObject *c_cellvars; /* list */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
394 int c_nlocals; /* index of next local */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
395 int c_argcount; /* number of top-level arguments */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
396 int c_flags; /* same as co_flags */ |
| 69 | 397 int c_nexti; /* index into c_code */ |
| 398 int c_errors; /* counts errors occurred */ | |
| 86 | 399 int c_infunction; /* set when compiling a function */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
400 int c_interactive; /* generating code for interactive command */ |
| 86 | 401 int c_loops; /* counts nested loops */ |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
402 int c_begin; /* begin of current loop, for 'continue' */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
403 int c_block[CO_MAXBLOCKS]; /* stack of block types */ |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
404 int c_nblocks; /* current block stack level */ |
| 86 | 405 char *c_filename; /* filename of current node */ |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
406 char *c_name; /* name of object (e.g. function) */ |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
407 int c_lineno; /* Current line number */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
408 int c_stacklevel; /* Current stack level */ |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
409 int c_maxstacklevel; /* Maximum stack level */ |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
410 int c_firstlineno; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
411 PyObject *c_lnotab; /* Table mapping address to line number */ |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
412 int c_last_addr, c_last_line, c_lnotab_next; |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
413 char *c_private; /* for private name mangling */ |
| 13936 | 414 int c_tmpname; /* temporary local name counter */ |
|
16523
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
415 int c_nested; /* Is block nested funcdef or lamdef? */ |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
416 int c_closure; /* Is nested w/freevars? */ |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
417 struct symtable *c_symtable; /* pointer to module symbol table */ |
|
16799
08d937107fe6
Improved __future__ parser; still more to do
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16783
diff
changeset
|
418 PyFutureFeatures *c_future; /* pointer to module's __future__ */ |
| 69 | 419 }; |
| 420 | |
|
17518
f939ce52a734
Make some private symbols static.
Guido van Rossum <guido@python.org>
parents:
17355
diff
changeset
|
421 static int |
|
f939ce52a734
Make some private symbols static.
Guido van Rossum <guido@python.org>
parents:
17355
diff
changeset
|
422 is_free(int v) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
423 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
424 if ((v & (USE | DEF_FREE)) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
425 && !(v & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL))) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
426 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
427 if (v & DEF_FREE_CLASS) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
428 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
429 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
430 } |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
431 |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
432 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
433 com_error(struct compiling *c, PyObject *exc, char *msg) |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
434 { |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
435 PyObject *t = NULL, *v = NULL, *w = NULL, *line = NULL; |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
436 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
437 if (c == NULL) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
438 /* Error occurred via symtable call to |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
439 is_constant_false */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
440 PyErr_SetString(exc, msg); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
441 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
442 } |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
443 c->c_errors++; |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
444 if (c->c_lineno < 1 || c->c_interactive) { |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
445 /* Unknown line number or interactive input */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
446 PyErr_SetString(exc, msg); |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
447 return; |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
448 } |
|
13993
716e1c4e3f78
When raising a SyntaxError, make a best-effort attempt to set the
Fred Drake <fdrake@acm.org>
parents:
13956
diff
changeset
|
449 v = PyString_FromString(msg); |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
450 if (v == NULL) |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
451 return; /* MemoryError, too bad */ |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
452 |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
453 line = PyErr_ProgramText(c->c_filename, c->c_lineno); |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
454 if (line == NULL) { |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
455 Py_INCREF(Py_None); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
456 line = Py_None; |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
457 } |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
458 t = Py_BuildValue("(ziOO)", c->c_filename, c->c_lineno, |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
459 Py_None, line); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
460 if (t == NULL) |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
461 goto exit; |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
462 w = Py_BuildValue("(OO)", v, t); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
463 if (w == NULL) |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
464 goto exit; |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
465 PyErr_SetObject(exc, w); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
466 exit: |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
467 Py_XDECREF(t); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
468 Py_XDECREF(v); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
469 Py_XDECREF(w); |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
470 Py_XDECREF(line); |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
471 } |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
472 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
473 /* Interface to the block stack */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
474 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
475 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
476 block_push(struct compiling *c, int type) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
477 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
478 if (c->c_nblocks >= CO_MAXBLOCKS) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
479 com_error(c, PyExc_SystemError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
480 "too many statically nested blocks"); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
481 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
482 else { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
483 c->c_block[c->c_nblocks++] = type; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
484 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
485 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
486 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
487 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
488 block_pop(struct compiling *c, int type) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
489 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
490 if (c->c_nblocks > 0) |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
491 c->c_nblocks--; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
492 if (c->c_block[c->c_nblocks] != type && c->c_errors == 0) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
493 com_error(c, PyExc_SystemError, "bad block pop"); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
494 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
495 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
496 |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
497 /* Prototype forward declarations */ |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
498 |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
499 static int com_init(struct compiling *, char *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
500 static void com_free(struct compiling *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
501 static void com_push(struct compiling *, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
502 static void com_pop(struct compiling *, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
503 static void com_done(struct compiling *); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
504 static void com_node(struct compiling *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
505 static void com_factor(struct compiling *, node *); |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
506 static void com_addbyte(struct compiling *, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
507 static void com_addint(struct compiling *, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
508 static void com_addoparg(struct compiling *, int, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
509 static void com_addfwref(struct compiling *, int, int *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
510 static void com_backpatch(struct compiling *, int); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
511 static int com_add(struct compiling *, PyObject *, PyObject *, PyObject *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
512 static int com_addconst(struct compiling *, PyObject *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
513 static int com_addname(struct compiling *, PyObject *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
514 static void com_addopname(struct compiling *, int, node *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
515 static void com_list(struct compiling *, node *, int); |
| 13936 | 516 static void com_list_iter(struct compiling *, node *, node *, char *); |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
517 static int com_argdefs(struct compiling *, node *); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
518 static void com_assign(struct compiling *, node *, int, node *); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
519 static void com_assign_name(struct compiling *, node *, int); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
520 static PyCodeObject *icompile(node *, struct compiling *); |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
521 static PyCodeObject *jcompile(node *, char *, struct compiling *, |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
522 PyCompilerFlags *); |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
523 static PyObject *parsestrplus(node *); |
|
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
524 static PyObject *parsestr(char *); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
525 static node *get_rawdocstring(node *); |
| 69 | 526 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
527 static int get_ref_type(struct compiling *, char *); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
528 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
529 /* symtable operations */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
530 static int symtable_build(struct compiling *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
531 static int symtable_load_symbols(struct compiling *); |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
532 static struct symtable *symtable_init(void); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
533 static void symtable_enter_scope(struct symtable *, char *, int, int); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
534 static int symtable_exit_scope(struct symtable *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
535 static int symtable_add_def(struct symtable *, char *, int); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
536 static int symtable_add_def_o(struct symtable *, PyObject *, PyObject *, int); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
537 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
538 static void symtable_node(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
539 static void symtable_funcdef(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
540 static void symtable_default_args(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
541 static void symtable_params(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
542 static void symtable_params_fplist(struct symtable *, node *n); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
543 static void symtable_global(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
544 static void symtable_import(struct symtable *, node *); |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
545 static void symtable_assign(struct symtable *, node *, int); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
546 static void symtable_list_comprehension(struct symtable *, node *); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
547 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
548 static int symtable_update_free_vars(struct symtable *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
549 static int symtable_undo_free(struct symtable *, PyObject *, PyObject *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
550 static int symtable_check_global(struct symtable *, PyObject *, PyObject *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
551 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
552 /* helper */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
553 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
554 do_pad(int pad) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
555 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
556 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
557 for (i = 0; i < pad; ++i) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
558 fprintf(stderr, " "); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
559 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
560 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
561 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
562 dump(node *n, int pad, int depth) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
563 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
564 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
565 if (depth == 0) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
566 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
567 do_pad(pad); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
568 fprintf(stderr, "%d: %s\n", TYPE(n), STR(n)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
569 if (depth > 0) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
570 depth--; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
571 for (i = 0; i < NCH(n); ++i) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
572 dump(CHILD(n, i), pad + 1, depth); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
573 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
574 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
575 #define DUMP(N) dump(N, 0, -1) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
576 |
| 69 | 577 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
578 com_init(struct compiling *c, char *filename) |
| 69 | 579 { |
| 12522 | 580 memset((void *)c, '\0', sizeof(struct compiling)); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
581 if ((c->c_code = PyString_FromStringAndSize((char *)NULL, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
582 1000)) == NULL) |
| 12522 | 583 goto fail; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
584 if ((c->c_consts = PyList_New(0)) == NULL) |
| 12522 | 585 goto fail; |
| 586 if ((c->c_const_dict = PyDict_New()) == NULL) | |
| 587 goto fail; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
588 if ((c->c_names = PyList_New(0)) == NULL) |
| 12522 | 589 goto fail; |
| 590 if ((c->c_name_dict = PyDict_New()) == NULL) | |
| 591 goto fail; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
592 if ((c->c_locals = PyDict_New()) == NULL) |
| 12522 | 593 goto fail; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
594 if ((c->c_lnotab = PyString_FromStringAndSize((char *)NULL, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
595 1000)) == NULL) |
| 12522 | 596 goto fail; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
597 c->c_globals = NULL; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
598 c->c_varnames = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
599 c->c_freevars = NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
600 c->c_cellvars = NULL; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
601 c->c_nlocals = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
602 c->c_argcount = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
603 c->c_flags = 0; |
| 69 | 604 c->c_nexti = 0; |
| 605 c->c_errors = 0; | |
| 86 | 606 c->c_infunction = 0; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
607 c->c_interactive = 0; |
| 86 | 608 c->c_loops = 0; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
609 c->c_begin = 0; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
610 c->c_nblocks = 0; |
| 86 | 611 c->c_filename = filename; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
612 c->c_name = "?"; |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
613 c->c_lineno = 0; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
614 c->c_stacklevel = 0; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
615 c->c_maxstacklevel = 0; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
616 c->c_firstlineno = 0; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
617 c->c_last_addr = 0; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
618 c->c_last_line = 0; |
|
16096
fb67122e5c1e
com_init(): My entry into the smallest patch possible category.
Barry Warsaw <barry@python.org>
parents:
16060
diff
changeset
|
619 c->c_lnotab_next = 0; |
| 13936 | 620 c->c_tmpname = 0; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
621 c->c_nested = 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
622 c->c_closure = 0; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
623 c->c_symtable = NULL; |
| 69 | 624 return 1; |
| 625 | |
| 12522 | 626 fail: |
| 627 com_free(c); | |
| 69 | 628 return 0; |
| 629 } | |
| 630 | |
| 631 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
632 com_free(struct compiling *c) |
| 69 | 633 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
634 Py_XDECREF(c->c_code); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
635 Py_XDECREF(c->c_consts); |
| 12522 | 636 Py_XDECREF(c->c_const_dict); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
637 Py_XDECREF(c->c_names); |
| 12522 | 638 Py_XDECREF(c->c_name_dict); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
639 Py_XDECREF(c->c_globals); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
640 Py_XDECREF(c->c_locals); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
641 Py_XDECREF(c->c_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
642 Py_XDECREF(c->c_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
643 Py_XDECREF(c->c_cellvars); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
644 Py_XDECREF(c->c_lnotab); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
645 if (c->c_future) |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
646 PyMem_Free((void *)c->c_future); |
| 69 | 647 } |
| 648 | |
| 649 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
650 com_push(struct compiling *c, int n) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
651 { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
652 c->c_stacklevel += n; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
653 if (c->c_stacklevel > c->c_maxstacklevel) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
654 c->c_maxstacklevel = c->c_stacklevel; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
655 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
656 |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
657 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
658 com_pop(struct compiling *c, int n) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
659 { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
660 if (c->c_stacklevel < n) { |
|
9049
cbf72b2210ae
Comment out the print statement about underflow. (This only seems to
Guido van Rossum <guido@python.org>
parents:
8328
diff
changeset
|
661 /* fprintf(stderr, |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
662 "%s:%d: underflow! nexti=%d, level=%d, n=%d\n", |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
663 c->c_filename, c->c_lineno, |
|
9049
cbf72b2210ae
Comment out the print statement about underflow. (This only seems to
Guido van Rossum <guido@python.org>
parents:
8328
diff
changeset
|
664 c->c_nexti, c->c_stacklevel, n); */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
665 c->c_stacklevel = 0; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
666 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
667 else |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
668 c->c_stacklevel -= n; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
669 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
670 |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
671 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
672 com_done(struct compiling *c) |
| 69 | 673 { |
| 674 if (c->c_code != NULL) | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
675 _PyString_Resize(&c->c_code, c->c_nexti); |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
676 if (c->c_lnotab != NULL) |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
677 _PyString_Resize(&c->c_lnotab, c->c_lnotab_next); |
| 69 | 678 } |
| 679 | |
| 680 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
681 com_addbyte(struct compiling *c, int byte) |
| 69 | 682 { |
| 683 int len; | |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
684 /*fprintf(stderr, "%3d: %3d\n", c->c_nexti, byte);*/ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
685 assert(byte >= 0 && byte <= 255); |
| 69 | 686 if (byte < 0 || byte > 255) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
687 com_error(c, PyExc_SystemError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
688 "com_addbyte: byte out of range"); |
| 69 | 689 } |
| 690 if (c->c_code == NULL) | |
| 691 return; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
692 len = PyString_Size(c->c_code); |
| 69 | 693 if (c->c_nexti >= len) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
694 if (_PyString_Resize(&c->c_code, len+1000) != 0) { |
| 69 | 695 c->c_errors++; |
| 696 return; | |
| 697 } | |
| 698 } | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
699 PyString_AsString(c->c_code)[c->c_nexti++] = byte; |
| 69 | 700 } |
| 701 | |
| 702 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
703 com_addint(struct compiling *c, int x) |
| 69 | 704 { |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
705 com_addbyte(c, x & 0xff); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
706 com_addbyte(c, x >> 8); /* XXX x should be positive */ |
| 69 | 707 } |
| 708 | |
| 709 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
710 com_add_lnotab(struct compiling *c, int addr, int line) |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
711 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
712 int size; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
713 char *p; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
714 if (c->c_lnotab == NULL) |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
715 return; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
716 size = PyString_Size(c->c_lnotab); |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
717 if (c->c_lnotab_next+2 > size) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
718 if (_PyString_Resize(&c->c_lnotab, size + 1000) < 0) { |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
719 c->c_errors++; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
720 return; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
721 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
722 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
723 p = PyString_AsString(c->c_lnotab) + c->c_lnotab_next; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
724 *p++ = addr; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
725 *p++ = line; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
726 c->c_lnotab_next += 2; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
727 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
728 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
729 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
730 com_set_lineno(struct compiling *c, int lineno) |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
731 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
732 c->c_lineno = lineno; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
733 if (c->c_firstlineno == 0) { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
734 c->c_firstlineno = c->c_last_line = lineno; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
735 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
736 else { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
737 int incr_addr = c->c_nexti - c->c_last_addr; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
738 int incr_line = lineno - c->c_last_line; |
|
18065
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
739 while (incr_addr > 255) { |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
740 com_add_lnotab(c, 255, 0); |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
741 incr_addr -= 255; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
742 } |
|
18065
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
743 while (incr_line > 255) { |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
744 com_add_lnotab(c, incr_addr, 255); |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
745 incr_line -=255; |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
746 incr_addr = 0; |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
747 } |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
748 if (incr_addr > 0 || incr_line > 0) |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
749 com_add_lnotab(c, incr_addr, incr_line); |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
750 c->c_last_addr = c->c_nexti; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
751 c->c_last_line = lineno; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
752 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
753 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
754 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
755 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
756 com_addoparg(struct compiling *c, int op, int arg) |
| 69 | 757 { |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
758 int extended_arg = arg >> 16; |
|
5164
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
759 if (op == SET_LINENO) { |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
760 com_set_lineno(c, arg); |
|
5164
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
761 if (Py_OptimizeFlag) |
|
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
762 return; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
763 } |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
764 if (extended_arg){ |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
765 com_addbyte(c, EXTENDED_ARG); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
766 com_addint(c, extended_arg); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
767 arg &= 0xffff; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
768 } |
|
5164
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
769 com_addbyte(c, op); |
|
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
770 com_addint(c, arg); |
| 69 | 771 } |
| 772 | |
| 773 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
774 com_addfwref(struct compiling *c, int op, int *p_anchor) |
| 69 | 775 { |
| 776 /* Compile a forward reference for backpatching */ | |
| 777 int here; | |
| 778 int anchor; | |
| 779 com_addbyte(c, op); | |
| 780 here = c->c_nexti; | |
| 781 anchor = *p_anchor; | |
| 782 *p_anchor = here; | |
| 783 com_addint(c, anchor == 0 ? 0 : here - anchor); | |
| 784 } | |
| 785 | |
| 786 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
787 com_backpatch(struct compiling *c, int anchor) |
| 69 | 788 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
789 unsigned char *code = (unsigned char *) PyString_AsString(c->c_code); |
| 69 | 790 int target = c->c_nexti; |
| 791 int dist; | |
| 792 int prev; | |
| 793 for (;;) { | |
| 794 /* Make the JUMP instruction at anchor point to target */ | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
795 prev = code[anchor] + (code[anchor+1] << 8); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
796 dist = target - (anchor+2); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
797 code[anchor] = dist & 0xff; |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
798 dist >>= 8; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
799 code[anchor+1] = dist; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
800 dist >>= 8; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
801 if (dist) { |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
802 com_error(c, PyExc_SystemError, |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
803 "com_backpatch: offset too large"); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
804 break; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
805 } |
| 69 | 806 if (!prev) |
| 807 break; | |
| 808 anchor -= prev; | |
| 809 } | |
| 810 } | |
| 811 | |
| 544 | 812 /* Handle literals and names uniformly */ |
| 69 | 813 |
| 814 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
815 com_add(struct compiling *c, PyObject *list, PyObject *dict, PyObject *v) |
| 69 | 816 { |
| 12522 | 817 PyObject *w, *t, *np=NULL; |
| 818 long n; | |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
819 |
| 12522 | 820 t = Py_BuildValue("(OO)", v, v->ob_type); |
| 821 if (t == NULL) | |
| 822 goto fail; | |
| 823 w = PyDict_GetItem(dict, t); | |
| 824 if (w != NULL) { | |
| 825 n = PyInt_AsLong(w); | |
| 826 } else { | |
| 827 n = PyList_Size(list); | |
| 828 np = PyInt_FromLong(n); | |
| 829 if (np == NULL) | |
| 830 goto fail; | |
| 831 if (PyList_Append(list, v) != 0) | |
| 832 goto fail; | |
| 833 if (PyDict_SetItem(dict, t, np) != 0) | |
| 834 goto fail; | |
| 835 Py_DECREF(np); | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
836 } |
| 12522 | 837 Py_DECREF(t); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
838 return n; |
| 12522 | 839 fail: |
| 840 Py_XDECREF(np); | |
| 841 Py_XDECREF(t); | |
| 842 c->c_errors++; | |
| 843 return 0; | |
| 69 | 844 } |
| 845 | |
| 846 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
847 com_addconst(struct compiling *c, PyObject *v) |
| 69 | 848 { |
| 12522 | 849 return com_add(c, c->c_consts, c->c_const_dict, v); |
| 69 | 850 } |
| 851 | |
| 852 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
853 com_addname(struct compiling *c, PyObject *v) |
| 69 | 854 { |
| 12522 | 855 return com_add(c, c->c_names, c->c_name_dict, v); |
| 69 | 856 } |
| 857 | |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
858 static int |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
859 mangle(char *p, char *name, char *buffer, size_t maxlen) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
860 { |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
861 /* Name mangling: __private becomes _classname__private. |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
862 This is independent from how the name is used. */ |
|
13096
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
863 size_t nlen, plen; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
864 if (p == NULL || name == NULL || name[0] != '_' || name[1] != '_') |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
865 return 0; |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
866 nlen = strlen(name); |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
867 if (nlen+2 >= maxlen) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
868 return 0; /* Don't mangle __extremely_long_names */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
869 if (name[nlen-1] == '_' && name[nlen-2] == '_') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
870 return 0; /* Don't mangle __whatever__ */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
871 /* Strip leading underscores from class name */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
872 while (*p == '_') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
873 p++; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
874 if (*p == '\0') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
875 return 0; /* Don't mangle if class is just underscores */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
876 plen = strlen(p); |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
877 if (plen + nlen >= maxlen) |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
878 plen = maxlen-nlen-2; /* Truncate class name if too long */ |
|
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
879 /* buffer = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */ |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
880 buffer[0] = '_'; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
881 strncpy(buffer+1, p, plen); |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
882 strcpy(buffer+1+plen, name); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
883 return 1; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
884 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
885 |
| 69 | 886 static void |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
887 com_addop_name(struct compiling *c, int op, char *name) |
| 69 | 888 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
889 PyObject *v; |
| 69 | 890 int i; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
891 char buffer[MANGLE_LEN]; |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
892 |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
893 if (mangle(c->c_private, name, buffer, sizeof(buffer))) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
894 name = buffer; |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
895 if (name == NULL || (v = PyString_InternFromString(name)) == NULL) { |
| 69 | 896 c->c_errors++; |
| 897 i = 255; | |
| 898 } | |
| 899 else { | |
| 900 i = com_addname(c, v); | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
901 Py_DECREF(v); |
| 69 | 902 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
903 com_addoparg(c, op, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
904 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
905 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
906 #define NAME_LOCAL 0 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
907 #define NAME_GLOBAL 1 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
908 #define NAME_DEFAULT 2 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
909 #define NAME_CLOSURE 3 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
910 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
911 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
912 com_lookup_arg(PyObject *dict, PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
913 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
914 PyObject *v = PyDict_GetItem(dict, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
915 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
916 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
917 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
918 return PyInt_AS_LONG(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
919 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
920 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
921 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
922 com_addop_varname(struct compiling *c, int kind, char *name) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
923 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
924 PyObject *v; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
925 int i, reftype; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
926 int scope = NAME_DEFAULT; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
927 int op = STOP_CODE; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
928 char buffer[MANGLE_LEN]; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
929 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
930 if (mangle(c->c_private, name, buffer, sizeof(buffer))) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
931 name = buffer; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
932 if (name == NULL || (v = PyString_InternFromString(name)) == NULL) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
933 c->c_errors++; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
934 i = 255; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
935 goto done; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
936 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
937 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
938 reftype = get_ref_type(c, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
939 switch (reftype) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
940 case LOCAL: |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
941 if (c->c_symtable->st_cur->ste_type == TYPE_FUNCTION) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
942 scope = NAME_LOCAL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
943 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
944 case GLOBAL_EXPLICIT: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
945 scope = NAME_GLOBAL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
946 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
947 case GLOBAL_IMPLICIT: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
948 if (c->c_flags & CO_OPTIMIZED) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
949 scope = NAME_GLOBAL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
950 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
951 case FREE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
952 case CELL: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
953 scope = NAME_CLOSURE; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
954 break; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
955 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
956 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
957 i = com_addname(c, v); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
958 if (scope == NAME_LOCAL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
959 i = com_lookup_arg(c->c_locals, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
960 else if (reftype == FREE) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
961 i = com_lookup_arg(c->c_freevars, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
962 else if (reftype == CELL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
963 i = com_lookup_arg(c->c_cellvars, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
964 if (i == -1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
965 c->c_errors++; /* XXX no exception set */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
966 i = 255; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
967 goto done; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
968 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
969 Py_DECREF(v); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
970 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
971 switch (kind) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
972 case VAR_LOAD: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
973 switch (scope) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
974 case NAME_LOCAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
975 op = LOAD_FAST; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
976 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
977 case NAME_GLOBAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
978 op = LOAD_GLOBAL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
979 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
980 case NAME_DEFAULT: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
981 op = LOAD_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
982 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
983 case NAME_CLOSURE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
984 op = LOAD_DEREF; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
985 break; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
986 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
987 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
988 case VAR_STORE: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
989 switch (scope) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
990 case NAME_LOCAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
991 op = STORE_FAST; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
992 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
993 case NAME_GLOBAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
994 op = STORE_GLOBAL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
995 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
996 case NAME_DEFAULT: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
997 op = STORE_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
998 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
999 case NAME_CLOSURE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1000 op = STORE_DEREF; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1001 break; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1002 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1003 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1004 case VAR_DELETE: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1005 switch (scope) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1006 case NAME_LOCAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1007 op = DELETE_FAST; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1008 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1009 case NAME_GLOBAL: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1010 op = DELETE_GLOBAL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1011 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1012 case NAME_DEFAULT: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1013 op = DELETE_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1014 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1015 case NAME_CLOSURE: { |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
1016 char buf[500]; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1017 sprintf(buf, DEL_CLOSURE_ERROR, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1018 com_error(c, PyExc_SyntaxError, buf); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1019 i = 255; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1020 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1021 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1022 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1023 break; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1024 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1025 done: |
| 69 | 1026 com_addoparg(c, op, i); |
| 1027 } | |
| 1028 | |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1029 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1030 com_addopname(struct compiling *c, int op, node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1031 { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1032 char *name; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1033 char buffer[1000]; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1034 /* XXX it is possible to write this code without the 1000 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1035 chars on the total length of dotted names, I just can't be |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1036 bothered right now */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1037 if (TYPE(n) == STAR) |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1038 name = "*"; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1039 else if (TYPE(n) == dotted_name) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1040 char *p = buffer; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1041 int i; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1042 name = buffer; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1043 for (i = 0; i < NCH(n); i += 2) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1044 char *s = STR(CHILD(n, i)); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1045 if (p + strlen(s) > buffer + (sizeof buffer) - 2) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1046 com_error(c, PyExc_MemoryError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1047 "dotted_name too long"); |
|
2367
915fabec64a3
fix typo (== for =) in assignment
Guido van Rossum <guido@python.org>
parents:
2310
diff
changeset
|
1048 name = NULL; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1049 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1050 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1051 if (p != buffer) |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1052 *p++ = '.'; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1053 strcpy(p, s); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1054 p = strchr(p, '\0'); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1055 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1056 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1057 else { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1058 REQ(n, NAME); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1059 name = STR(n); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1060 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1061 com_addop_name(c, op, name); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1062 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1063 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1064 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1065 parsenumber(struct compiling *co, char *s) |
| 69 | 1066 { |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1067 char *end; |
| 69 | 1068 long x; |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1069 double dx; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1070 #ifndef WITHOUT_COMPLEX |
|
3766
516490c8192c
Py_complex; and WITHOUT_COMPLEX added to getargs.c
Guido van Rossum <guido@python.org>
parents:
3366
diff
changeset
|
1071 Py_complex c; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1072 int imflag; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1073 #endif |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1074 |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1075 errno = 0; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1076 end = s + strlen(s) - 1; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1077 #ifndef WITHOUT_COMPLEX |
|
3366
c25865884649
only use 'j' for imaginary constants
Guido van Rossum <guido@python.org>
parents:
3349
diff
changeset
|
1078 imflag = *end == 'j' || *end == 'J'; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1079 #endif |
| 744 | 1080 if (*end == 'l' || *end == 'L') |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1081 return PyLong_FromString(s, (char **)0, 0); |
|
617
755bb8efcc2d
Use strtoul() for oct/hex constants.
Guido van Rossum <guido@python.org>
parents:
584
diff
changeset
|
1082 if (s[0] == '0') |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1083 x = (long) PyOS_strtoul(s, &end, 0); |
|
617
755bb8efcc2d
Use strtoul() for oct/hex constants.
Guido van Rossum <guido@python.org>
parents:
584
diff
changeset
|
1084 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1085 x = PyOS_strtol(s, &end, 0); |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1086 if (*end == '\0') { |
|
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1087 if (errno != 0) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1088 com_error(co, PyExc_OverflowError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1089 "integer literal too large"); |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1090 return NULL; |
|
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1091 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1092 return PyInt_FromLong(x); |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1093 } |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1094 /* XXX Huge floats may silently fail */ |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1095 #ifndef WITHOUT_COMPLEX |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1096 if (imflag) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1097 c.real = 0.; |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1098 PyFPE_START_PROTECT("atof", return 0) |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1099 c.imag = atof(s); |
|
5197
74c12704a0bd
New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents:
5183
diff
changeset
|
1100 PyFPE_END_PROTECT(c) |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1101 return PyComplex_FromCComplex(c); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1102 } |
|
6453
c9b139b9c5ff
Fixed for WITHOUT_COMPLEX compilation (Jack)
Guido van Rossum <guido@python.org>
parents:
6186
diff
changeset
|
1103 else |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1104 #endif |
|
6453
c9b139b9c5ff
Fixed for WITHOUT_COMPLEX compilation (Jack)
Guido van Rossum <guido@python.org>
parents:
6186
diff
changeset
|
1105 { |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1106 PyFPE_START_PROTECT("atof", return 0) |
|
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1107 dx = atof(s); |
|
5197
74c12704a0bd
New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents:
5183
diff
changeset
|
1108 PyFPE_END_PROTECT(dx) |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1109 return PyFloat_FromDouble(dx); |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1110 } |
| 69 | 1111 } |
| 1112 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1113 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1114 parsestr(char *s) |
| 69 | 1115 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1116 PyObject *v; |
|
13096
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
1117 size_t len; |
| 69 | 1118 char *buf; |
| 1119 char *p; | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1120 char *end; |
| 69 | 1121 int c; |
|
5264
38878f1cd4f1
Support for alternative string quotes (a"xx", b"xx", c"xx", ...).
Guido van Rossum <guido@python.org>
parents:
5233
diff
changeset
|
1122 int first = *s; |
|
38878f1cd4f1
Support for alternative string quotes (a"xx", b"xx", c"xx", ...).
Guido van Rossum <guido@python.org>
parents:
5233
diff
changeset
|
1123 int quote = first; |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1124 int rawmode = 0; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1125 int unicode = 0; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1126 if (isalpha(quote) || quote == '_') { |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1127 if (quote == 'u' || quote == 'U') { |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1128 quote = *++s; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1129 unicode = 1; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1130 } |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1131 if (quote == 'r' || quote == 'R') { |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1132 quote = *++s; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1133 rawmode = 1; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1134 } |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1135 } |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1136 if (quote != '\'' && quote != '\"') { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1137 PyErr_BadInternalCall(); |
| 69 | 1138 return NULL; |
| 1139 } | |
| 1140 s++; | |
| 1141 len = strlen(s); | |
|
13096
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
1142 if (len > INT_MAX) { |
|
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
1143 PyErr_SetString(PyExc_OverflowError, "string to parse is too long"); |
|
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
1144 return NULL; |
|
8c8de5b736dc
Trent Mick's Win64 changes: size_t vs. int or long; also some overflow
Guido van Rossum <guido@python.org>
parents:
12576
diff
changeset
|
1145 } |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1146 if (s[--len] != quote) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1147 PyErr_BadInternalCall(); |
| 69 | 1148 return NULL; |
| 1149 } | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1150 if (len >= 4 && s[0] == quote && s[1] == quote) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1151 s += 2; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1152 len -= 2; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1153 if (s[--len] != quote || s[--len] != quote) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1154 PyErr_BadInternalCall(); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1155 return NULL; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1156 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1157 } |
| 12538 | 1158 if (unicode || Py_UnicodeFlag) { |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1159 if (rawmode) |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1160 return PyUnicode_DecodeRawUnicodeEscape( |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1161 s, len, NULL); |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1162 else |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1163 return PyUnicode_DecodeUnicodeEscape( |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1164 s, len, NULL); |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1165 } |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1166 if (rawmode || strchr(s, '\\') == NULL) |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1167 return PyString_FromStringAndSize(s, len); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1168 v = PyString_FromStringAndSize((char *)NULL, len); |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1169 if (v == NULL) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1170 return NULL; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1171 p = buf = PyString_AsString(v); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1172 end = s + len; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1173 while (s < end) { |
| 69 | 1174 if (*s != '\\') { |
| 1175 *p++ = *s++; | |
| 1176 continue; | |
| 1177 } | |
| 1178 s++; | |
| 1179 switch (*s++) { | |
| 1180 /* XXX This assumes ASCII! */ | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1181 case '\n': break; |
| 69 | 1182 case '\\': *p++ = '\\'; break; |
| 1183 case '\'': *p++ = '\''; break; | |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1184 case '\"': *p++ = '\"'; break; |
| 69 | 1185 case 'b': *p++ = '\b'; break; |
| 1186 case 'f': *p++ = '\014'; break; /* FF */ | |
| 1187 case 't': *p++ = '\t'; break; | |
| 1188 case 'n': *p++ = '\n'; break; | |
| 1189 case 'r': *p++ = '\r'; break; | |
| 1190 case 'v': *p++ = '\013'; break; /* VT */ | |
| 1191 case 'a': *p++ = '\007'; break; /* BEL, not classic C */ | |
| 1192 case '0': case '1': case '2': case '3': | |
| 1193 case '4': case '5': case '6': case '7': | |
| 1194 c = s[-1] - '0'; | |
| 1195 if ('0' <= *s && *s <= '7') { | |
| 1196 c = (c<<3) + *s++ - '0'; | |
| 1197 if ('0' <= *s && *s <= '7') | |
| 1198 c = (c<<3) + *s++ - '0'; | |
| 1199 } | |
| 1200 *p++ = c; | |
| 1201 break; | |
| 1202 case 'x': | |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
1203 if (isxdigit(Py_CHARMASK(s[0])) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
1204 && isxdigit(Py_CHARMASK(s[1]))) { |
|
6501
9ef9cadd978c
Don't use sscanf(s, "%x", &c) to parse \xX... escapes; hardcode it.
Guido van Rossum <guido@python.org>
parents:
6453
diff
changeset
|
1205 unsigned int x = 0; |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1206 c = Py_CHARMASK(*s); |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1207 s++; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1208 if (isdigit(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1209 x = c - '0'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1210 else if (islower(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1211 x = 10 + c - 'a'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1212 else |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1213 x = 10 + c - 'A'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1214 x = x << 4; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1215 c = Py_CHARMASK(*s); |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1216 s++; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1217 if (isdigit(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1218 x += c - '0'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1219 else if (islower(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1220 x += 10 + c - 'a'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1221 else |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1222 x += 10 + c - 'A'; |
|
6501
9ef9cadd978c
Don't use sscanf(s, "%x", &c) to parse \xX... escapes; hardcode it.
Guido van Rossum <guido@python.org>
parents:
6453
diff
changeset
|
1223 *p++ = x; |
| 69 | 1224 break; |
| 1225 } | |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
1226 PyErr_SetString(PyExc_ValueError, |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
1227 "invalid \\x escape"); |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1228 Py_DECREF(v); |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1229 return NULL; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1230 default: |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1231 *p++ = '\\'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1232 *p++ = s[-1]; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1233 break; |
| 69 | 1234 } |
| 1235 } | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1236 _PyString_Resize(&v, (int)(p - buf)); |
| 69 | 1237 return v; |
| 1238 } | |
| 1239 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1240 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1241 parsestrplus(node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1242 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1243 PyObject *v; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1244 int i; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1245 REQ(CHILD(n, 0), STRING); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1246 if ((v = parsestr(STR(CHILD(n, 0)))) != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1247 /* String literal concatenation */ |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1248 for (i = 1; i < NCH(n); i++) { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1249 PyObject *s; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1250 s = parsestr(STR(CHILD(n, i))); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1251 if (s == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1252 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1253 if (PyString_Check(v) && PyString_Check(s)) { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1254 PyString_ConcatAndDel(&v, s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1255 if (v == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1256 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1257 } |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1258 else { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1259 PyObject *temp; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1260 temp = PyUnicode_Concat(v, s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1261 Py_DECREF(s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1262 if (temp == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1263 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1264 Py_DECREF(v); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1265 v = temp; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1266 } |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1267 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1268 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1269 return v; |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1270 |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1271 onError: |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1272 Py_XDECREF(v); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1273 return NULL; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1274 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1275 |
| 69 | 1276 static void |
| 13936 | 1277 com_list_for(struct compiling *c, node *n, node *e, char *t) |
| 1278 { | |
| 1279 int anchor = 0; | |
| 1280 int save_begin = c->c_begin; | |
| 1281 | |
| 1282 /* list_iter: for v in expr [list_iter] */ | |
| 1283 com_node(c, CHILD(n, 3)); /* expr */ | |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
1284 com_addbyte(c, GET_ITER); |
| 13936 | 1285 c->c_begin = c->c_nexti; |
| 1286 com_addoparg(c, SET_LINENO, n->n_lineno); | |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
1287 com_addfwref(c, FOR_ITER, &anchor); |
| 13936 | 1288 com_push(c, 1); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1289 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL); |
| 13936 | 1290 c->c_loops++; |
| 1291 com_list_iter(c, n, e, t); | |
| 1292 c->c_loops--; | |
| 1293 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); | |
| 1294 c->c_begin = save_begin; | |
| 1295 com_backpatch(c, anchor); | |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
1296 com_pop(c, 1); /* FOR_ITER has popped this */ |
| 13936 | 1297 } |
| 1298 | |
| 1299 static void | |
| 1300 com_list_if(struct compiling *c, node *n, node *e, char *t) | |
| 1301 { | |
| 1302 int anchor = 0; | |
| 1303 int a = 0; | |
| 1304 /* list_iter: 'if' test [list_iter] */ | |
| 1305 com_addoparg(c, SET_LINENO, n->n_lineno); | |
| 1306 com_node(c, CHILD(n, 1)); | |
| 1307 com_addfwref(c, JUMP_IF_FALSE, &a); | |
| 1308 com_addbyte(c, POP_TOP); | |
| 1309 com_pop(c, 1); | |
| 1310 com_list_iter(c, n, e, t); | |
| 1311 com_addfwref(c, JUMP_FORWARD, &anchor); | |
| 1312 com_backpatch(c, a); | |
| 1313 /* We jump here with an extra entry which we now pop */ | |
| 1314 com_addbyte(c, POP_TOP); | |
| 1315 com_backpatch(c, anchor); | |
| 1316 } | |
| 1317 | |
| 1318 static void | |
| 1319 com_list_iter(struct compiling *c, | |
| 1320 node *p, /* parent of list_iter node */ | |
| 1321 node *e, /* element expression node */ | |
| 1322 char *t /* name of result list temp local */) | |
| 69 | 1323 { |
| 13936 | 1324 /* list_iter is the last child in a listmaker, list_for, or list_if */ |
| 1325 node *n = CHILD(p, NCH(p)-1); | |
| 1326 if (TYPE(n) == list_iter) { | |
| 1327 n = CHILD(n, 0); | |
| 1328 switch (TYPE(n)) { | |
| 1329 case list_for: | |
| 1330 com_list_for(c, n, e, t); | |
| 1331 break; | |
| 1332 case list_if: | |
| 1333 com_list_if(c, n, e, t); | |
| 1334 break; | |
| 1335 default: | |
| 1336 com_error(c, PyExc_SystemError, | |
| 1337 "invalid list_iter node type"); | |
| 1338 } | |
| 1339 } | |
| 1340 else { | |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1341 com_addop_varname(c, VAR_LOAD, t); |
| 13936 | 1342 com_push(c, 1); |
| 1343 com_node(c, e); | |
| 1344 com_addoparg(c, CALL_FUNCTION, 1); | |
| 1345 com_addbyte(c, POP_TOP); | |
| 1346 com_pop(c, 2); | |
| 1347 } | |
| 1348 } | |
| 1349 | |
| 1350 static void | |
| 1351 com_list_comprehension(struct compiling *c, node *n) | |
| 1352 { | |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1353 /* listmaker: test list_for */ |
| 13936 | 1354 char tmpname[12]; |
|
16638
79568c0d3e77
Change temp names created by listcomps from [%d] to _[%d], so the one-liner
Tim Peters <tim.peters@gmail.com>
parents:
16571
diff
changeset
|
1355 sprintf(tmpname, "_[%d]", ++c->c_tmpname); |
| 13936 | 1356 com_addoparg(c, BUILD_LIST, 0); |
| 1357 com_addbyte(c, DUP_TOP); /* leave the result on the stack */ | |
| 1358 com_push(c, 2); | |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1359 com_addop_name(c, LOAD_ATTR, "append"); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1360 com_addop_varname(c, VAR_STORE, tmpname); |
| 13936 | 1361 com_pop(c, 1); |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1362 com_list_for(c, CHILD(n, 1), CHILD(n, 0), tmpname); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1363 com_addop_varname(c, VAR_DELETE, tmpname); |
| 13936 | 1364 --c->c_tmpname; |
| 1365 } | |
| 1366 | |
| 1367 static void | |
| 1368 com_listmaker(struct compiling *c, node *n) | |
| 1369 { | |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1370 /* listmaker: test ( list_for | (',' test)* [','] ) */ |
|
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1371 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) |
| 13936 | 1372 com_list_comprehension(c, n); |
| 1373 else { | |
| 1374 int len = 0; | |
| 1375 int i; | |
| 1376 for (i = 0; i < NCH(n); i += 2, len++) | |
| 1377 com_node(c, CHILD(n, i)); | |
| 1378 com_addoparg(c, BUILD_LIST, len); | |
| 1379 com_pop(c, len-1); | |
| 1380 } | |
| 69 | 1381 } |
| 1382 | |
| 1383 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1384 com_dictmaker(struct compiling *c, node *n) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1385 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1386 int i; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1387 /* dictmaker: test ':' test (',' test ':' value)* [','] */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1388 for (i = 0; i+2 < NCH(n); i += 4) { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1389 /* We must arrange things just right for STORE_SUBSCR. |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1390 It wants the stack to look like (value) (dict) (key) */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1391 com_addbyte(c, DUP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1392 com_push(c, 1); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1393 com_node(c, CHILD(n, i+2)); /* value */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1394 com_addbyte(c, ROT_TWO); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1395 com_node(c, CHILD(n, i)); /* key */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1396 com_addbyte(c, STORE_SUBSCR); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1397 com_pop(c, 3); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1398 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1399 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1400 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1401 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1402 com_atom(struct compiling *c, node *n) |
| 69 | 1403 { |
| 1404 node *ch; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1405 PyObject *v; |
| 69 | 1406 int i; |
| 1407 REQ(n, atom); | |
| 1408 ch = CHILD(n, 0); | |
| 1409 switch (TYPE(ch)) { | |
| 1410 case LPAR: | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1411 if (TYPE(CHILD(n, 1)) == RPAR) { |
| 69 | 1412 com_addoparg(c, BUILD_TUPLE, 0); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1413 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1414 } |
| 69 | 1415 else |
| 1416 com_node(c, CHILD(n, 1)); | |
| 1417 break; | |
| 13936 | 1418 case LSQB: /* '[' [listmaker] ']' */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1419 if (TYPE(CHILD(n, 1)) == RSQB) { |
| 69 | 1420 com_addoparg(c, BUILD_LIST, 0); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1421 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1422 } |
| 69 | 1423 else |
| 13936 | 1424 com_listmaker(c, CHILD(n, 1)); |
| 69 | 1425 break; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1426 case LBRACE: /* '{' [dictmaker] '}' */ |
| 69 | 1427 com_addoparg(c, BUILD_MAP, 0); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1428 com_push(c, 1); |
| 13936 | 1429 if (TYPE(CHILD(n, 1)) == dictmaker) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1430 com_dictmaker(c, CHILD(n, 1)); |
| 69 | 1431 break; |
| 1432 case BACKQUOTE: | |
| 1433 com_node(c, CHILD(n, 1)); | |
| 1434 com_addbyte(c, UNARY_CONVERT); | |
| 1435 break; | |
| 1436 case NUMBER: | |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1437 if ((v = parsenumber(c, STR(ch))) == NULL) { |
| 69 | 1438 i = 255; |
| 1439 } | |
| 1440 else { | |
| 1441 i = com_addconst(c, v); | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1442 Py_DECREF(v); |
| 69 | 1443 } |
| 1444 com_addoparg(c, LOAD_CONST, i); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1445 com_push(c, 1); |
| 69 | 1446 break; |
| 1447 case STRING: | |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1448 v = parsestrplus(n); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1449 if (v == NULL) { |
| 69 | 1450 c->c_errors++; |
| 1451 i = 255; | |
| 1452 } | |
| 1453 else { | |
| 1454 i = com_addconst(c, v); | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1455 Py_DECREF(v); |
| 69 | 1456 } |
| 1457 com_addoparg(c, LOAD_CONST, i); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1458 com_push(c, 1); |
| 69 | 1459 break; |
| 1460 case NAME: | |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1461 com_addop_varname(c, VAR_LOAD, STR(ch)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1462 com_push(c, 1); |
| 69 | 1463 break; |
| 1464 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1465 com_error(c, PyExc_SystemError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1466 "com_atom: unexpected node type"); |
| 69 | 1467 } |
| 1468 } | |
| 1469 | |
| 1470 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1471 com_slice(struct compiling *c, node *n, int op) |
| 69 | 1472 { |
| 1473 if (NCH(n) == 1) { | |
| 1474 com_addbyte(c, op); | |
| 1475 } | |
| 1476 else if (NCH(n) == 2) { | |
| 1477 if (TYPE(CHILD(n, 0)) != COLON) { | |
| 1478 com_node(c, CHILD(n, 0)); | |
| 1479 com_addbyte(c, op+1); | |
| 1480 } | |
| 1481 else { | |
| 1482 com_node(c, CHILD(n, 1)); | |
| 1483 com_addbyte(c, op+2); | |
| 1484 } | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1485 com_pop(c, 1); |
| 69 | 1486 } |
| 1487 else { | |
| 1488 com_node(c, CHILD(n, 0)); | |
| 1489 com_node(c, CHILD(n, 2)); | |
| 1490 com_addbyte(c, op+3); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1491 com_pop(c, 2); |
| 69 | 1492 } |
| 1493 } | |
| 1494 | |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1495 static void |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1496 com_augassign_slice(struct compiling *c, node *n, int opcode, node *augn) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1497 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1498 if (NCH(n) == 1) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1499 com_addbyte(c, DUP_TOP); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1500 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1501 com_addbyte(c, SLICE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1502 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1503 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1504 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1505 com_addbyte(c, ROT_TWO); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1506 com_addbyte(c, STORE_SLICE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1507 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1508 } else if (NCH(n) == 2 && TYPE(CHILD(n, 0)) != COLON) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1509 com_node(c, CHILD(n, 0)); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1510 com_addoparg(c, DUP_TOPX, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1511 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1512 com_addbyte(c, SLICE+1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1513 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1514 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1515 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1516 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1517 com_addbyte(c, ROT_THREE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1518 com_addbyte(c, STORE_SLICE+1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1519 com_pop(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1520 } else if (NCH(n) == 2) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1521 com_node(c, CHILD(n, 1)); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1522 com_addoparg(c, DUP_TOPX, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1523 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1524 com_addbyte(c, SLICE+2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1525 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1526 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1527 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1528 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1529 com_addbyte(c, ROT_THREE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1530 com_addbyte(c, STORE_SLICE+2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1531 com_pop(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1532 } else { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1533 com_node(c, CHILD(n, 0)); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1534 com_node(c, CHILD(n, 2)); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1535 com_addoparg(c, DUP_TOPX, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1536 com_push(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1537 com_addbyte(c, SLICE+3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1538 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1539 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1540 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1541 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1542 com_addbyte(c, ROT_FOUR); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1543 com_addbyte(c, STORE_SLICE+3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1544 com_pop(c, 4); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1545 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1546 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1547 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1548 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1549 com_argument(struct compiling *c, node *n, PyObject **pkeywords) |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1550 { |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1551 node *m; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1552 REQ(n, argument); /* [test '='] test; really [keyword '='] test */ |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1553 if (NCH(n) == 1) { |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1554 if (*pkeywords != NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1555 com_error(c, PyExc_SyntaxError, |
|
13993
716e1c4e3f78
When raising a SyntaxError, make a best-effort attempt to set the
Fred Drake <fdrake@acm.org>
parents:
13956
diff
changeset
|
1556 "non-keyword arg after keyword arg"); |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1557 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1558 else { |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1559 com_node(c, CHILD(n, 0)); |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1560 } |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1561 return; |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1562 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1563 m = n; |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1564 do { |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1565 m = CHILD(m, 0); |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1566 } while (NCH(m) == 1); |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1567 if (TYPE(m) != NAME) { |
|
16658
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1568 /* f(lambda x: x[0] = 3) ends up getting parsed with |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1569 * LHS test = lambda x: x[0], and RHS test = 3. |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1570 * SF bug 132313 points out that complaining about a keyword |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1571 * then is very confusing. |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1572 */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1573 com_error(c, PyExc_SyntaxError, |
|
16658
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1574 TYPE(m) == lambdef ? |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1575 "lambda cannot contain assignment" : |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1576 "keyword can't be an expression"); |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1577 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1578 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1579 PyObject *v = PyString_InternFromString(STR(m)); |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1580 if (v != NULL && *pkeywords == NULL) |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1581 *pkeywords = PyDict_New(); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1582 if (v == NULL) |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1583 c->c_errors++; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1584 else if (*pkeywords == NULL) { |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1585 c->c_errors++; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1586 Py_DECREF(v); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1587 } else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1588 if (PyDict_GetItem(*pkeywords, v) != NULL) |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1589 com_error(c, PyExc_SyntaxError, |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1590 "duplicate keyword argument"); |
|
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1591 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1592 if (PyDict_SetItem(*pkeywords, v, v) != 0) |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1593 c->c_errors++; |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1594 com_addoparg(c, LOAD_CONST, com_addconst(c, v)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1595 com_push(c, 1); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1596 Py_DECREF(v); |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1597 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1598 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1599 com_node(c, CHILD(n, 2)); |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1600 } |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1601 |
| 69 | 1602 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1603 com_call_function(struct compiling *c, node *n) |
| 69 | 1604 { |
| 1605 if (TYPE(n) == RPAR) { | |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1606 com_addoparg(c, CALL_FUNCTION, 0); |
| 69 | 1607 } |
| 1608 else { | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1609 PyObject *keywords = NULL; |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1610 int i, na, nk; |
|
9625
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1611 int lineno = n->n_lineno; |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1612 int star_flag = 0; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1613 int starstar_flag = 0; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1614 int opcode; |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1615 REQ(n, arglist); |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1616 na = 0; |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1617 nk = 0; |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1618 for (i = 0; i < NCH(n); i += 2) { |
|
9625
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1619 node *ch = CHILD(n, i); |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1620 if (TYPE(ch) == STAR || |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1621 TYPE(ch) == DOUBLESTAR) |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1622 break; |
|
9625
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1623 if (ch->n_lineno != lineno) { |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1624 lineno = ch->n_lineno; |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1625 com_addoparg(c, SET_LINENO, lineno); |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1626 } |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1627 com_argument(c, ch, &keywords); |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1628 if (keywords == NULL) |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1629 na++; |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1630 else |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1631 nk++; |
|
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1632 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1633 Py_XDECREF(keywords); |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1634 while (i < NCH(n)) { |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1635 node *tok = CHILD(n, i); |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1636 node *ch = CHILD(n, i+1); |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1637 i += 3; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1638 switch (TYPE(tok)) { |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1639 case STAR: star_flag = 1; break; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1640 case DOUBLESTAR: starstar_flag = 1; break; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1641 } |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1642 com_node(c, ch); |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1643 } |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1644 if (na > 255 || nk > 255) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1645 com_error(c, PyExc_SyntaxError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1646 "more than 255 arguments"); |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
1647 } |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1648 if (star_flag || starstar_flag) |
|
12086
96ea1a800b23
remove reference (vestigal) to CALL_FUNCTION_STAR
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12082
diff
changeset
|
1649 opcode = CALL_FUNCTION_VAR - 1 + |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1650 star_flag + (starstar_flag << 1); |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1651 else |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1652 opcode = CALL_FUNCTION; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1653 com_addoparg(c, opcode, na | (nk << 8)); |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1654 com_pop(c, na + 2*nk + star_flag + starstar_flag); |
| 69 | 1655 } |
| 1656 } | |
| 1657 | |
| 1658 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1659 com_select_member(struct compiling *c, node *n) |
| 69 | 1660 { |
| 1661 com_addopname(c, LOAD_ATTR, n); | |
| 1662 } | |
| 1663 | |
| 1664 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1665 com_sliceobj(struct compiling *c, node *n) |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1666 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1667 int i=0; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1668 int ns=2; /* number of slice arguments */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1669 node *ch; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1670 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1671 /* first argument */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1672 if (TYPE(CHILD(n,i)) == COLON) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1673 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1674 com_push(c, 1); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1675 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1676 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1677 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1678 com_node(c, CHILD(n,i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1679 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1680 REQ(CHILD(n,i),COLON); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1681 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1682 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1683 /* second argument */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1684 if (i < NCH(n) && TYPE(CHILD(n,i)) == test) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1685 com_node(c, CHILD(n,i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1686 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1687 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1688 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1689 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1690 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1691 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1692 /* remaining arguments */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1693 for (; i < NCH(n); i++) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1694 ns++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1695 ch=CHILD(n,i); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1696 REQ(ch, sliceop); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1697 if (NCH(ch) == 1) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1698 /* right argument of ':' missing */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1699 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1700 com_push(c, 1); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1701 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1702 else |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1703 com_node(c, CHILD(ch,1)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1704 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1705 com_addoparg(c, BUILD_SLICE, ns); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1706 com_pop(c, 1 + (ns == 3)); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1707 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1708 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1709 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1710 com_subscript(struct compiling *c, node *n) |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1711 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1712 node *ch; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1713 REQ(n, subscript); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1714 ch = CHILD(n,0); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1715 /* check for rubber index */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1716 if (TYPE(ch) == DOT && TYPE(CHILD(n,1)) == DOT) { |
|
4403
3b3f7c3f6da2
Ellipses -> Ellipsis rename (the dictionary really says that it should
Guido van Rossum <guido@python.org>
parents:
4315
diff
changeset
|
1717 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_Ellipsis)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1718 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1719 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1720 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1721 /* check for slice */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1722 if ((TYPE(ch) == COLON || NCH(n) > 1)) |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1723 com_sliceobj(c, n); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1724 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1725 REQ(ch, test); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1726 com_node(c, ch); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1727 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1728 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1729 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1730 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1731 static void |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1732 com_subscriptlist(struct compiling *c, node *n, int assigning, node *augn) |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1733 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1734 int i, op; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1735 REQ(n, subscriptlist); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1736 /* Check to make backward compatible slice behavior for '[i:j]' */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1737 if (NCH(n) == 1) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1738 node *sub = CHILD(n, 0); /* subscript */ |
|
13873
d014c8ab6a82
Fix some strange indentation and grammar that have been bugging me for
Thomas Wouters <thomas@python.org>
parents:
13658
diff
changeset
|
1739 /* 'Basic' slice, should have exactly one colon. */ |
|
d014c8ab6a82
Fix some strange indentation and grammar that have been bugging me for
Thomas Wouters <thomas@python.org>
parents:
13658
diff
changeset
|
1740 if ((TYPE(CHILD(sub, 0)) == COLON |
|
d014c8ab6a82
Fix some strange indentation and grammar that have been bugging me for
Thomas Wouters <thomas@python.org>
parents:
13658
diff
changeset
|
1741 || (NCH(sub) > 1 && TYPE(CHILD(sub, 1)) == COLON)) |
|
d014c8ab6a82
Fix some strange indentation and grammar that have been bugging me for
Thomas Wouters <thomas@python.org>
parents:
13658
diff
changeset
|
1742 && (TYPE(CHILD(sub,NCH(sub)-1)) != sliceop)) |
|
d014c8ab6a82
Fix some strange indentation and grammar that have been bugging me for
Thomas Wouters <thomas@python.org>
parents:
13658
diff
changeset
|
1743 { |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1744 switch (assigning) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1745 case OP_DELETE: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1746 op = DELETE_SLICE; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1747 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1748 case OP_ASSIGN: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1749 op = STORE_SLICE; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1750 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1751 case OP_APPLY: |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1752 op = SLICE; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1753 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1754 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1755 com_augassign_slice(c, sub, assigning, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1756 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1757 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1758 com_slice(c, sub, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1759 if (op == STORE_SLICE) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1760 com_pop(c, 2); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1761 else if (op == DELETE_SLICE) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1762 com_pop(c, 1); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1763 return; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1764 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1765 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1766 /* Else normal subscriptlist. Compile each subscript. */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1767 for (i = 0; i < NCH(n); i += 2) |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1768 com_subscript(c, CHILD(n, i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1769 /* Put multiple subscripts into a tuple */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1770 if (NCH(n) > 1) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1771 i = (NCH(n)+1) / 2; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1772 com_addoparg(c, BUILD_TUPLE, i); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1773 com_pop(c, i-1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1774 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1775 switch (assigning) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1776 case OP_DELETE: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1777 op = DELETE_SUBSCR; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1778 i = 2; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1779 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1780 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1781 case OP_ASSIGN: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1782 op = STORE_SUBSCR; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1783 i = 3; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1784 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1785 case OP_APPLY: |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1786 op = BINARY_SUBSCR; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1787 i = 1; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1788 break; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1789 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1790 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1791 com_addoparg(c, DUP_TOPX, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1792 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1793 com_addbyte(c, BINARY_SUBSCR); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1794 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1795 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1796 com_addbyte(c, assigning); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1797 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1798 com_addbyte(c, ROT_THREE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1799 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1800 com_addbyte(c, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1801 com_pop(c, i); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1802 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1803 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1804 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1805 com_apply_trailer(struct compiling *c, node *n) |
| 69 | 1806 { |
| 1807 REQ(n, trailer); | |
| 1808 switch (TYPE(CHILD(n, 0))) { | |
| 1809 case LPAR: | |
| 1810 com_call_function(c, CHILD(n, 1)); | |
| 1811 break; | |
| 1812 case DOT: | |
| 1813 com_select_member(c, CHILD(n, 1)); | |
| 1814 break; | |
| 1815 case LSQB: | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1816 com_subscriptlist(c, CHILD(n, 1), OP_APPLY, NULL); |
| 69 | 1817 break; |
| 1818 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1819 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1820 "com_apply_trailer: unknown trailer type"); |
| 69 | 1821 } |
| 1822 } | |
| 1823 | |
| 1824 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1825 com_power(struct compiling *c, node *n) |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1826 { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1827 int i; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1828 REQ(n, power); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1829 com_atom(c, CHILD(n, 0)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1830 for (i = 1; i < NCH(n); i++) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1831 if (TYPE(CHILD(n, i)) == DOUBLESTAR) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1832 com_factor(c, CHILD(n, i+1)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1833 com_addbyte(c, BINARY_POWER); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1834 com_pop(c, 1); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1835 break; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1836 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1837 else |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1838 com_apply_trailer(c, CHILD(n, i)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1839 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1840 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1841 |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1842 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1843 com_factor(struct compiling *c, node *n) |
| 69 | 1844 { |
| 1845 REQ(n, factor); | |
| 1846 if (TYPE(CHILD(n, 0)) == PLUS) { | |
| 1847 com_factor(c, CHILD(n, 1)); | |
| 1848 com_addbyte(c, UNARY_POSITIVE); | |
| 1849 } | |
| 1850 else if (TYPE(CHILD(n, 0)) == MINUS) { | |
| 1851 com_factor(c, CHILD(n, 1)); | |
| 1852 com_addbyte(c, UNARY_NEGATIVE); | |
| 1853 } | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1854 else if (TYPE(CHILD(n, 0)) == TILDE) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1855 com_factor(c, CHILD(n, 1)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1856 com_addbyte(c, UNARY_INVERT); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1857 } |
| 69 | 1858 else { |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1859 com_power(c, CHILD(n, 0)); |
| 69 | 1860 } |
| 1861 } | |
| 1862 | |
| 1863 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1864 com_term(struct compiling *c, node *n) |
| 69 | 1865 { |
| 1866 int i; | |
| 1867 int op; | |
| 1868 REQ(n, term); | |
| 1869 com_factor(c, CHILD(n, 0)); | |
| 1870 for (i = 2; i < NCH(n); i += 2) { | |
| 1871 com_factor(c, CHILD(n, i)); | |
| 1872 switch (TYPE(CHILD(n, i-1))) { | |
| 1873 case STAR: | |
| 1874 op = BINARY_MULTIPLY; | |
| 1875 break; | |
| 1876 case SLASH: | |
| 1877 op = BINARY_DIVIDE; | |
| 1878 break; | |
| 1879 case PERCENT: | |
| 1880 op = BINARY_MODULO; | |
| 1881 break; | |
| 1882 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1883 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1884 "com_term: operator not *, / or %"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1885 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1886 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1887 com_addbyte(c, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1888 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1889 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1890 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1891 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1892 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1893 com_arith_expr(struct compiling *c, node *n) |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1894 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1895 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1896 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1897 REQ(n, arith_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1898 com_term(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1899 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1900 com_term(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1901 switch (TYPE(CHILD(n, i-1))) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1902 case PLUS: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1903 op = BINARY_ADD; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1904 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1905 case MINUS: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1906 op = BINARY_SUBTRACT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1907 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1908 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1909 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1910 "com_arith_expr: operator not + or -"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1911 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1912 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1913 com_addbyte(c, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1914 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1915 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1916 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1917 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1918 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1919 com_shift_expr(struct compiling *c, node *n) |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1920 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1921 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1922 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1923 REQ(n, shift_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1924 com_arith_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1925 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1926 com_arith_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1927 switch (TYPE(CHILD(n, i-1))) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1928 case LEFTSHIFT: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1929 op = BINARY_LSHIFT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1930 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1931 case RIGHTSHIFT: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1932 op = BINARY_RSHIFT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1933 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1934 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1935 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1936 "com_shift_expr: operator not << or >>"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1937 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1938 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1939 com_addbyte(c, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1940 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1941 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1942 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1943 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1944 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1945 com_and_expr(struct compiling *c, node *n) |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1946 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1947 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1948 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1949 REQ(n, and_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1950 com_shift_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1951 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1952 com_shift_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1953 if (TYPE(CHILD(n, i-1)) == AMPER) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1954 op = BINARY_AND; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1955 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1956 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1957 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1958 "com_and_expr: operator not &"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1959 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1960 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1961 com_addbyte(c, op); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1962 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1963 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1964 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1965 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1966 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1967 com_xor_expr(struct compiling *c, node *n) |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1968 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1969 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1970 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1971 REQ(n, xor_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1972 com_and_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1973 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1974 com_and_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1975 if (TYPE(CHILD(n, i-1)) == CIRCUMFLEX) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1976 op = BINARY_XOR; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1977 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1978 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1979 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1980 "com_xor_expr: operator not ^"); |
| 69 | 1981 op = 255; |
| 1982 } | |
| 1983 com_addbyte(c, op); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1984 com_pop(c, 1); |
| 69 | 1985 } |
| 1986 } | |
| 1987 | |
| 1988 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1989 com_expr(struct compiling *c, node *n) |
| 69 | 1990 { |
| 1991 int i; | |
| 1992 int op; | |
| 1993 REQ(n, expr); | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1994 com_xor_expr(c, CHILD(n, 0)); |
| 69 | 1995 for (i = 2; i < NCH(n); i += 2) { |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1996 com_xor_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1997 if (TYPE(CHILD(n, i-1)) == VBAR) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1998 op = BINARY_OR; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1999 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2000 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2001 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2002 "com_expr: expr operator not |"); |
| 69 | 2003 op = 255; |
| 2004 } | |
| 2005 com_addbyte(c, op); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2006 com_pop(c, 1); |
| 69 | 2007 } |
| 2008 } | |
| 2009 | |
| 2010 static enum cmp_op | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2011 cmp_type(node *n) |
| 69 | 2012 { |
| 2013 REQ(n, comp_op); | |
|
388
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2014 /* comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '==' |
| 69 | 2015 | 'in' | 'not' 'in' | 'is' | 'is' not' */ |
| 2016 if (NCH(n) == 1) { | |
| 2017 n = CHILD(n, 0); | |
| 2018 switch (TYPE(n)) { | |
| 2019 case LESS: return LT; | |
| 2020 case GREATER: return GT; | |
|
388
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2021 case EQEQUAL: /* == */ |
| 69 | 2022 case EQUAL: return EQ; |
|
388
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2023 case LESSEQUAL: return LE; |
|
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2024 case GREATEREQUAL: return GE; |
|
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2025 case NOTEQUAL: return NE; /* <> or != */ |
| 69 | 2026 case NAME: if (strcmp(STR(n), "in") == 0) return IN; |
| 2027 if (strcmp(STR(n), "is") == 0) return IS; | |
| 2028 } | |
| 2029 } | |
| 2030 else if (NCH(n) == 2) { | |
| 2031 switch (TYPE(CHILD(n, 0))) { | |
| 2032 case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0) | |
| 2033 return NOT_IN; | |
| 2034 if (strcmp(STR(CHILD(n, 0)), "is") == 0) | |
| 2035 return IS_NOT; | |
| 2036 } | |
| 2037 } | |
| 2038 return BAD; | |
| 2039 } | |
| 2040 | |
| 2041 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2042 com_comparison(struct compiling *c, node *n) |
| 69 | 2043 { |
| 2044 int i; | |
| 2045 enum cmp_op op; | |
| 2046 int anchor; | |
| 2047 REQ(n, comparison); /* comparison: expr (comp_op expr)* */ | |
| 2048 com_expr(c, CHILD(n, 0)); | |
| 2049 if (NCH(n) == 1) | |
| 2050 return; | |
| 2051 | |
| 2052 /**************************************************************** | |
| 2053 The following code is generated for all but the last | |
| 2054 comparison in a chain: | |
| 2055 | |
| 2056 label: on stack: opcode: jump to: | |
| 2057 | |
| 2058 a <code to load b> | |
| 2059 a, b DUP_TOP | |
| 2060 a, b, b ROT_THREE | |
| 2061 b, a, b COMPARE_OP | |
| 2062 b, 0-or-1 JUMP_IF_FALSE L1 | |
| 2063 b, 1 POP_TOP | |
| 2064 b | |
| 2065 | |
| 2066 We are now ready to repeat this sequence for the next | |
| 2067 comparison in the chain. | |
| 2068 | |
| 2069 For the last we generate: | |
| 2070 | |
| 2071 b <code to load c> | |
| 2072 b, c COMPARE_OP | |
| 2073 0-or-1 | |
| 2074 | |
| 2075 If there were any jumps to L1 (i.e., there was more than one | |
| 2076 comparison), we generate: | |
| 2077 | |
| 2078 0-or-1 JUMP_FORWARD L2 | |
| 2079 L1: b, 0 ROT_TWO | |
| 2080 0, b POP_TOP | |
| 2081 0 | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2082 L2: 0-or-1 |
| 69 | 2083 ****************************************************************/ |
| 2084 | |
| 2085 anchor = 0; | |
| 2086 | |
| 2087 for (i = 2; i < NCH(n); i += 2) { | |
| 2088 com_expr(c, CHILD(n, i)); | |
| 2089 if (i+2 < NCH(n)) { | |
| 2090 com_addbyte(c, DUP_TOP); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2091 com_push(c, 1); |
| 69 | 2092 com_addbyte(c, ROT_THREE); |
| 2093 } | |
| 2094 op = cmp_type(CHILD(n, i-1)); | |
| 2095 if (op == BAD) { | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2096 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2097 "com_comparison: unknown comparison op"); |
| 69 | 2098 } |
| 2099 com_addoparg(c, COMPARE_OP, op); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2100 com_pop(c, 1); |
| 69 | 2101 if (i+2 < NCH(n)) { |
| 2102 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 2103 com_addbyte(c, POP_TOP); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2104 com_pop(c, 1); |
| 69 | 2105 } |
| 2106 } | |
| 2107 | |
| 2108 if (anchor) { | |
| 2109 int anchor2 = 0; | |
| 2110 com_addfwref(c, JUMP_FORWARD, &anchor2); | |
| 2111 com_backpatch(c, anchor); | |
| 2112 com_addbyte(c, ROT_TWO); | |
| 2113 com_addbyte(c, POP_TOP); | |
| 2114 com_backpatch(c, anchor2); | |
| 2115 } | |
| 2116 } | |
| 2117 | |
| 2118 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2119 com_not_test(struct compiling *c, node *n) |
| 69 | 2120 { |
| 2121 REQ(n, not_test); /* 'not' not_test | comparison */ | |
| 2122 if (NCH(n) == 1) { | |
| 2123 com_comparison(c, CHILD(n, 0)); | |
| 2124 } | |
| 2125 else { | |
| 2126 com_not_test(c, CHILD(n, 1)); | |
| 2127 com_addbyte(c, UNARY_NOT); | |
| 2128 } | |
| 2129 } | |
| 2130 | |
| 2131 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2132 com_and_test(struct compiling *c, node *n) |
| 69 | 2133 { |
| 2134 int i; | |
| 2135 int anchor; | |
| 2136 REQ(n, and_test); /* not_test ('and' not_test)* */ | |
| 2137 anchor = 0; | |
| 2138 i = 0; | |
| 2139 for (;;) { | |
| 2140 com_not_test(c, CHILD(n, i)); | |
| 2141 if ((i += 2) >= NCH(n)) | |
| 2142 break; | |
| 2143 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 2144 com_addbyte(c, POP_TOP); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2145 com_pop(c, 1); |
| 69 | 2146 } |
| 2147 if (anchor) | |
| 2148 com_backpatch(c, anchor); | |
| 2149 } | |
| 2150 | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2151 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2152 com_make_closure(struct compiling *c, PyCodeObject *co) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2153 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2154 int i, free = PyTuple_GET_SIZE(co->co_freevars); |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
2155 /* If the code is compiled with st->st_nested_scopes == 0, |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
2156 then no variable will ever be added to co_freevars. |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
2157 */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2158 if (free == 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2159 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2160 for (i = 0; i < free; ++i) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2161 /* Bypass com_addop_varname because it will generate |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2162 LOAD_DEREF but LOAD_CLOSURE is needed. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2163 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2164 PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2165 int arg, reftype; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2166 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2167 /* Special case: If a class contains a method with a |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2168 free variable that has the same name as a method, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2169 the name will be considered free *and* local in the |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2170 class. It should be handled by the closure, as |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2171 well as by the normal name loookup logic. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2172 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2173 reftype = get_ref_type(c, PyString_AS_STRING(name)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2174 if (reftype == CELL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2175 arg = com_lookup_arg(c->c_cellvars, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2176 else /* (reftype == FREE) */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2177 arg = com_lookup_arg(c->c_freevars, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2178 if (arg == -1) { |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2179 fprintf(stderr, "lookup %s in %s %d %d\n" |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2180 "freevars of %s: %s\n", |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2181 PyObject_REPR(name), |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2182 c->c_name, |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2183 reftype, arg, |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2184 PyString_AS_STRING(co->co_name), |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2185 PyObject_REPR(co->co_freevars)); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2186 Py_FatalError("com_make_closure()"); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2187 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2188 com_addoparg(c, LOAD_CLOSURE, arg); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2189 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2190 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2191 com_push(c, free); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2192 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2193 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2194 |
| 69 | 2195 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2196 com_test(struct compiling *c, node *n) |
| 69 | 2197 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2198 REQ(n, test); /* and_test ('or' and_test)* | lambdef */ |
|
1417
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2199 if (NCH(n) == 1 && TYPE(CHILD(n, 0)) == lambdef) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2200 PyObject *co; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2201 int i, closure; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
2202 int ndefs = com_argdefs(c, CHILD(n, 0)); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
2203 symtable_enter_scope(c->c_symtable, "lambda", lambdef, |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
2204 n->n_lineno); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2205 co = (PyObject *) icompile(CHILD(n, 0), c); |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2206 if (co == NULL) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2207 c->c_errors++; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2208 return; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2209 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2210 symtable_exit_scope(c->c_symtable); |
|
16763
2f585cbe71da
Shuffle premature decref; nuke unreachable code block.
Tim Peters <tim.peters@gmail.com>
parents:
16754
diff
changeset
|
2211 i = com_addconst(c, co); |
|
2f585cbe71da
Shuffle premature decref; nuke unreachable code block.
Tim Peters <tim.peters@gmail.com>
parents:
16754
diff
changeset
|
2212 closure = com_make_closure(c, (PyCodeObject *)co); |
|
2f585cbe71da
Shuffle premature decref; nuke unreachable code block.
Tim Peters <tim.peters@gmail.com>
parents:
16754
diff
changeset
|
2213 Py_DECREF(co); |
|
1417
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2214 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2215 com_push(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2216 if (closure) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2217 com_addoparg(c, MAKE_CLOSURE, ndefs); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2218 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2219 com_addoparg(c, MAKE_FUNCTION, ndefs); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2220 com_pop(c, ndefs); |
| 69 | 2221 } |
|
1417
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2222 else { |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2223 int anchor = 0; |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2224 int i = 0; |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2225 for (;;) { |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2226 com_and_test(c, CHILD(n, i)); |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2227 if ((i += 2) >= NCH(n)) |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2228 break; |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2229 com_addfwref(c, JUMP_IF_TRUE, &anchor); |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2230 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2231 com_pop(c, 1); |
|
1417
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2232 } |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2233 if (anchor) |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2234 com_backpatch(c, anchor); |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2235 } |
| 69 | 2236 } |
| 2237 | |
| 2238 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2239 com_list(struct compiling *c, node *n, int toplevel) |
| 69 | 2240 { |
| 2241 /* exprlist: expr (',' expr)* [',']; likewise for testlist */ | |
| 482 | 2242 if (NCH(n) == 1 && !toplevel) { |
| 69 | 2243 com_node(c, CHILD(n, 0)); |
| 2244 } | |
| 2245 else { | |
| 2246 int i; | |
| 2247 int len; | |
| 2248 len = (NCH(n) + 1) / 2; | |
| 2249 for (i = 0; i < NCH(n); i += 2) | |
| 2250 com_node(c, CHILD(n, i)); | |
| 2251 com_addoparg(c, BUILD_TUPLE, len); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2252 com_pop(c, len-1); |
| 69 | 2253 } |
| 2254 } | |
| 2255 | |
| 2256 | |
| 2257 /* Begin of assignment compilation */ | |
| 2258 | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2259 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2260 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2261 com_augassign_attr(struct compiling *c, node *n, int opcode, node *augn) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2262 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2263 com_addbyte(c, DUP_TOP); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2264 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2265 com_addopname(c, LOAD_ATTR, n); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2266 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2267 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2268 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2269 com_addbyte(c, ROT_TWO); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2270 com_addopname(c, STORE_ATTR, n); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2271 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2272 } |
| 69 | 2273 |
| 2274 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2275 com_assign_attr(struct compiling *c, node *n, int assigning) |
| 69 | 2276 { |
| 2277 com_addopname(c, assigning ? STORE_ATTR : DELETE_ATTR, n); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2278 com_pop(c, assigning ? 2 : 1); |
| 69 | 2279 } |
| 2280 | |
| 2281 static void | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2282 com_assign_trailer(struct compiling *c, node *n, int assigning, node *augn) |
| 69 | 2283 { |
| 2284 REQ(n, trailer); | |
| 2285 switch (TYPE(CHILD(n, 0))) { | |
| 2286 case LPAR: /* '(' [exprlist] ')' */ | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2287 com_error(c, PyExc_SyntaxError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2288 "can't assign to function call"); |
| 69 | 2289 break; |
| 2290 case DOT: /* '.' NAME */ | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2291 if (assigning > OP_APPLY) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2292 com_augassign_attr(c, CHILD(n, 1), assigning, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2293 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2294 com_assign_attr(c, CHILD(n, 1), assigning); |
| 69 | 2295 break; |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
2296 case LSQB: /* '[' subscriptlist ']' */ |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2297 com_subscriptlist(c, CHILD(n, 1), assigning, augn); |
| 69 | 2298 break; |
| 2299 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2300 com_error(c, PyExc_SystemError, "unknown trailer type"); |
| 69 | 2301 } |
| 2302 } | |
| 2303 | |
| 2304 static void | |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2305 com_assign_sequence(struct compiling *c, node *n, int assigning) |
| 69 | 2306 { |
| 2307 int i; | |
|
14178
dff22d4a48da
Fix allowable node-types for assignment, need to add 'listmaker'.
Thomas Wouters <thomas@python.org>
parents:
14163
diff
changeset
|
2308 if (TYPE(n) != testlist && TYPE(n) != listmaker) |
| 69 | 2309 REQ(n, exprlist); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2310 if (assigning) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2311 i = (NCH(n)+1)/2; |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2312 com_addoparg(c, UNPACK_SEQUENCE, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2313 com_push(c, i-1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2314 } |
| 69 | 2315 for (i = 0; i < NCH(n); i += 2) |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2316 com_assign(c, CHILD(n, i), assigning, NULL); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2317 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2318 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2319 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2320 com_augassign_name(struct compiling *c, node *n, int opcode, node *augn) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2321 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2322 REQ(n, NAME); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2323 com_addop_varname(c, VAR_LOAD, STR(n)); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2324 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2325 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2326 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2327 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2328 com_assign_name(c, n, OP_ASSIGN); |
| 69 | 2329 } |
| 2330 | |
| 2331 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2332 com_assign_name(struct compiling *c, node *n, int assigning) |
| 69 | 2333 { |
| 2334 REQ(n, NAME); | |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2335 com_addop_varname(c, assigning ? VAR_STORE : VAR_DELETE, STR(n)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2336 if (assigning) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2337 com_pop(c, 1); |
| 69 | 2338 } |
| 2339 | |
| 2340 static void | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2341 com_assign(struct compiling *c, node *n, int assigning, node *augn) |
| 69 | 2342 { |
| 2343 /* Loop to avoid trivial recursion */ | |
| 2344 for (;;) { | |
| 2345 switch (TYPE(n)) { | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2346 |
| 69 | 2347 case exprlist: |
| 2348 case testlist: | |
| 2349 if (NCH(n) > 1) { | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2350 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2351 com_error(c, PyExc_SyntaxError, |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
2352 "augmented assign to tuple not possible"); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2353 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2354 } |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2355 com_assign_sequence(c, n, assigning); |
| 69 | 2356 return; |
| 2357 } | |
| 2358 n = CHILD(n, 0); | |
| 2359 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2360 |
| 69 | 2361 case test: |
| 2362 case and_test: | |
| 2363 case not_test: | |
| 2364 case comparison: | |
| 2365 case expr: | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2366 case xor_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2367 case and_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2368 case shift_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2369 case arith_expr: |
| 69 | 2370 case term: |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2371 case factor: |
| 69 | 2372 if (NCH(n) > 1) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2373 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2374 "can't assign to operator"); |
| 69 | 2375 return; |
| 2376 } | |
| 2377 n = CHILD(n, 0); | |
| 2378 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2379 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2380 case power: /* atom trailer* ('**' power)* |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2381 ('+'|'-'|'~') factor | atom trailer* */ |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2382 if (TYPE(CHILD(n, 0)) != atom) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2383 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2384 "can't assign to operator"); |
| 69 | 2385 return; |
| 2386 } | |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2387 if (NCH(n) > 1) { /* trailer or exponent present */ |
| 69 | 2388 int i; |
| 2389 com_node(c, CHILD(n, 0)); | |
| 2390 for (i = 1; i+1 < NCH(n); i++) { | |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2391 if (TYPE(CHILD(n, i)) == DOUBLESTAR) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2392 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2393 "can't assign to operator"); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2394 return; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2395 } |
| 69 | 2396 com_apply_trailer(c, CHILD(n, i)); |
| 2397 } /* NB i is still alive */ | |
| 2398 com_assign_trailer(c, | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2399 CHILD(n, i), assigning, augn); |
| 69 | 2400 return; |
| 2401 } | |
| 2402 n = CHILD(n, 0); | |
| 2403 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2404 |
| 69 | 2405 case atom: |
| 2406 switch (TYPE(CHILD(n, 0))) { | |
| 2407 case LPAR: | |
| 2408 n = CHILD(n, 1); | |
| 2409 if (TYPE(n) == RPAR) { | |
| 2410 /* XXX Should allow () = () ??? */ | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2411 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2412 "can't assign to ()"); |
| 69 | 2413 return; |
| 2414 } | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2415 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2416 com_error(c, PyExc_SyntaxError, |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2417 "augmented assign to tuple not possible"); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2418 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2419 } |
| 69 | 2420 break; |
| 2421 case LSQB: | |
| 2422 n = CHILD(n, 1); | |
| 2423 if (TYPE(n) == RSQB) { | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2424 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2425 "can't assign to []"); |
| 69 | 2426 return; |
| 2427 } | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2428 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2429 com_error(c, PyExc_SyntaxError, |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2430 "augmented assign to list not possible"); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2431 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2432 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2433 if (NCH(n) > 1 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2434 && TYPE(CHILD(n, 1)) == list_for) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2435 com_error(c, PyExc_SyntaxError, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2436 "can't assign to list comprehension"); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2437 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2438 } |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2439 com_assign_sequence(c, n, assigning); |
| 69 | 2440 return; |
| 2441 case NAME: | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2442 if (assigning > OP_APPLY) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2443 com_augassign_name(c, CHILD(n, 0), |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2444 assigning, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2445 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2446 com_assign_name(c, CHILD(n, 0), |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2447 assigning); |
| 69 | 2448 return; |
| 2449 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2450 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
2451 "can't assign to literal"); |
| 69 | 2452 return; |
| 2453 } | |
| 2454 break; | |
|
3963
00722990b80c
Removed unused var; added error check for ``lambda: x=1''.
Guido van Rossum <guido@python.org>
parents:
3839
diff
changeset
|
2455 |
|
00722990b80c
Removed unused var; added error check for ``lambda: x=1''.
Guido van Rossum <guido@python.org>
parents:
3839
diff
changeset
|
2456 case lambdef: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2457 com_error(c, PyExc_SyntaxError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2458 "can't assign to lambda"); |
|
3963
00722990b80c
Removed unused var; added error check for ``lambda: x=1''.
Guido van Rossum <guido@python.org>
parents:
3839
diff
changeset
|
2459 return; |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2460 |
| 69 | 2461 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2462 com_error(c, PyExc_SystemError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2463 "com_assign: bad node"); |
| 69 | 2464 return; |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2465 |
| 69 | 2466 } |
| 2467 } | |
| 2468 } | |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2469 |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2470 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2471 com_augassign(struct compiling *c, node *n) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2472 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2473 int opcode; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2474 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2475 switch (STR(CHILD(CHILD(n, 1), 0))[0]) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2476 case '+': opcode = INPLACE_ADD; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2477 case '-': opcode = INPLACE_SUBTRACT; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2478 case '/': opcode = INPLACE_DIVIDE; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2479 case '%': opcode = INPLACE_MODULO; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2480 case '<': opcode = INPLACE_LSHIFT; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2481 case '>': opcode = INPLACE_RSHIFT; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2482 case '&': opcode = INPLACE_AND; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2483 case '^': opcode = INPLACE_XOR; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2484 case '|': opcode = INPLACE_OR; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2485 case '*': |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2486 if (STR(CHILD(CHILD(n, 1), 0))[1] == '*') |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2487 opcode = INPLACE_POWER; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2488 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2489 opcode = INPLACE_MULTIPLY; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2490 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2491 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2492 com_error(c, PyExc_SystemError, "com_augassign: bad operator"); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2493 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2494 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2495 com_assign(c, CHILD(n, 0), opcode, CHILD(n, 2)); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2496 } |
| 69 | 2497 |
| 2498 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2499 com_expr_stmt(struct compiling *c, node *n) |
| 69 | 2500 { |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2501 REQ(n, expr_stmt); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2502 /* testlist (('=' testlist)* | augassign testlist) */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2503 /* Forget it if we have just a doc string here */ |
|
5264
38878f1cd4f1
Support for alternative string quotes (a"xx", b"xx", c"xx", ...).
Guido van Rossum <guido@python.org>
parents:
5233
diff
changeset
|
2504 if (!c->c_interactive && NCH(n) == 1 && get_rawdocstring(n) != NULL) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2505 return; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2506 if (NCH(n) == 1) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2507 com_node(c, CHILD(n, NCH(n)-1)); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2508 if (c->c_interactive) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2509 com_addbyte(c, PRINT_EXPR); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2510 else |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2511 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2512 com_pop(c, 1); |
| 69 | 2513 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2514 else if (TYPE(CHILD(n,1)) == augassign) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2515 com_augassign(c, n); |
| 69 | 2516 else { |
| 2517 int i; | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2518 com_node(c, CHILD(n, NCH(n)-1)); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2519 for (i = 0; i < NCH(n)-2; i+=2) { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2520 if (i+2 < NCH(n)-2) { |
| 69 | 2521 com_addbyte(c, DUP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2522 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2523 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2524 com_assign(c, CHILD(n, i), OP_ASSIGN, NULL); |
| 69 | 2525 } |
| 2526 } | |
| 2527 } | |
| 2528 | |
| 2529 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2530 com_assert_stmt(struct compiling *c, node *n) |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2531 { |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2532 int a = 0, b = 0; |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2533 int i; |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2534 REQ(n, assert_stmt); /* 'assert' test [',' test] */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2535 /* Generate code like for |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2536 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2537 if __debug__: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2538 if not <test>: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2539 raise AssertionError [, <message>] |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2540 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2541 where <message> is the second test, if present. |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2542 */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2543 |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2544 if (Py_OptimizeFlag) |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2545 return; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2546 com_addop_name(c, LOAD_GLOBAL, "__debug__"); |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2547 com_push(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2548 com_addfwref(c, JUMP_IF_FALSE, &a); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2549 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2550 com_pop(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2551 com_node(c, CHILD(n, 1)); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2552 com_addfwref(c, JUMP_IF_TRUE, &b); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2553 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2554 com_pop(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2555 /* Raise that exception! */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2556 com_addop_name(c, LOAD_GLOBAL, "AssertionError"); |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2557 com_push(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2558 i = NCH(n)/2; /* Either 2 or 4 */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2559 if (i > 1) |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2560 com_node(c, CHILD(n, 3)); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2561 com_addoparg(c, RAISE_VARARGS, i); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2562 com_pop(c, i); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2563 /* The interpreter does not fall through */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2564 /* All jumps converge here */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2565 com_backpatch(c, a); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2566 com_backpatch(c, b); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2567 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2568 } |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2569 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2570 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2571 com_print_stmt(struct compiling *c, node *n) |
| 69 | 2572 { |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2573 int i = 1; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2574 node* stream = NULL; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2575 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2576 REQ(n, print_stmt); /* 'print' (test ',')* [test] */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2577 |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2578 /* are we using the extended print form? */ |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2579 if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) { |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2580 stream = CHILD(n, 2); |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2581 com_node(c, stream); |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2582 /* stack: [...] => [... stream] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2583 com_push(c, 1); |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2584 if (NCH(n) > 3 && TYPE(CHILD(n, 3)) == COMMA) |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2585 i = 4; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2586 else |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2587 i = 3; |
| 69 | 2588 } |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2589 for (; i < NCH(n); i += 2) { |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2590 if (stream != NULL) { |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2591 com_addbyte(c, DUP_TOP); |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2592 /* stack: [stream] => [stream stream] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2593 com_push(c, 1); |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2594 com_node(c, CHILD(n, i)); |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2595 /* stack: [stream stream] => [stream stream obj] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2596 com_addbyte(c, ROT_TWO); |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2597 /* stack: [stream stream obj] => [stream obj stream] */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2598 com_addbyte(c, PRINT_ITEM_TO); |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2599 /* stack: [stream obj stream] => [stream] */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2600 com_pop(c, 2); |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2601 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2602 else { |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2603 com_node(c, CHILD(n, i)); |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2604 /* stack: [...] => [... obj] */ |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2605 com_addbyte(c, PRINT_ITEM); |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2606 com_pop(c, 1); |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2607 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2608 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2609 /* XXX Alternatively, LOAD_CONST '\n' and then PRINT_ITEM */ |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2610 if (TYPE(CHILD(n, NCH(n)-1)) == COMMA) { |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2611 if (stream != NULL) { |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2612 /* must pop the extra stream object off the stack */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2613 com_addbyte(c, POP_TOP); |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2614 /* stack: [... stream] => [...] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2615 com_pop(c, 1); |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2616 } |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2617 } |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2618 else { |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2619 if (stream != NULL) { |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2620 /* this consumes the last stream object on stack */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2621 com_addbyte(c, PRINT_NEWLINE_TO); |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2622 /* stack: [... stream] => [...] */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2623 com_pop(c, 1); |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2624 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2625 else |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2626 com_addbyte(c, PRINT_NEWLINE); |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2627 } |
| 69 | 2628 } |
| 2629 | |
| 2630 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2631 com_return_stmt(struct compiling *c, node *n) |
| 69 | 2632 { |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2633 REQ(n, return_stmt); /* 'return' [testlist] */ |
| 86 | 2634 if (!c->c_infunction) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2635 com_error(c, PyExc_SyntaxError, "'return' outside function"); |
| 86 | 2636 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2637 if (NCH(n) < 2) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2638 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2639 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2640 } |
| 69 | 2641 else |
| 2642 com_node(c, CHILD(n, 1)); | |
| 2643 com_addbyte(c, RETURN_VALUE); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2644 com_pop(c, 1); |
| 69 | 2645 } |
| 2646 | |
| 2647 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2648 com_raise_stmt(struct compiling *c, node *n) |
| 69 | 2649 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2650 int i; |
|
7946
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2651 REQ(n, raise_stmt); /* 'raise' [test [',' test [',' test]]] */ |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2652 if (NCH(n) > 1) { |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2653 com_node(c, CHILD(n, 1)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2654 if (NCH(n) > 3) { |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2655 com_node(c, CHILD(n, 3)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2656 if (NCH(n) > 5) |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2657 com_node(c, CHILD(n, 5)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2658 } |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
2659 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2660 i = NCH(n)/2; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2661 com_addoparg(c, RAISE_VARARGS, i); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2662 com_pop(c, i); |
| 69 | 2663 } |
| 2664 | |
| 2665 static void | |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2666 com_from_import(struct compiling *c, node *n) |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2667 { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2668 com_addopname(c, IMPORT_FROM, CHILD(n, 0)); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2669 com_push(c, 1); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2670 if (NCH(n) > 1) { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2671 if (strcmp(STR(CHILD(n, 1)), "as") != 0) { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2672 com_error(c, PyExc_SyntaxError, "invalid syntax"); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2673 return; |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2674 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2675 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 2))); |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2676 } else |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2677 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 0))); |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2678 com_pop(c, 1); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2679 } |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2680 |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2681 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2682 com_import_stmt(struct compiling *c, node *n) |
| 69 | 2683 { |
| 2684 int i; | |
| 2685 REQ(n, import_stmt); | |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2686 /* 'import' dotted_name (',' dotted_name)* | |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2687 'from' dotted_name 'import' ('*' | NAME (',' NAME)*) */ |
| 69 | 2688 if (STR(CHILD(n, 0))[0] == 'f') { |
|
15438
433458651eb4
Plug a memory leak in com_import_stmt(): the tuple created to hold the
Guido van Rossum <guido@python.org>
parents:
15408
diff
changeset
|
2689 PyObject *tup; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2690 /* 'from' dotted_name 'import' ... */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2691 REQ(CHILD(n, 1), dotted_name); |
|
14232
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2692 |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2693 if (TYPE(CHILD(n, 3)) == STAR) { |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2694 tup = Py_BuildValue("(s)", "*"); |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2695 } else { |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2696 tup = PyTuple_New((NCH(n) - 2)/2); |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2697 for (i = 3; i < NCH(n); i += 2) { |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2698 PyTuple_SET_ITEM(tup, (i-3)/2, |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2699 PyString_FromString(STR( |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
2700 CHILD(CHILD(n, i), 0)))); |
|
14232
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2701 } |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2702 } |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2703 com_addoparg(c, LOAD_CONST, com_addconst(c, tup)); |
|
15438
433458651eb4
Plug a memory leak in com_import_stmt(): the tuple created to hold the
Guido van Rossum <guido@python.org>
parents:
15408
diff
changeset
|
2704 Py_DECREF(tup); |
|
14232
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2705 com_push(c, 1); |
| 69 | 2706 com_addopname(c, IMPORT_NAME, CHILD(n, 1)); |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2707 if (TYPE(CHILD(n, 3)) == STAR) |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2708 com_addbyte(c, IMPORT_STAR); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2709 else { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2710 for (i = 3; i < NCH(n); i += 2) |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2711 com_from_import(c, CHILD(n, i)); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2712 com_addbyte(c, POP_TOP); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2713 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2714 com_pop(c, 1); |
| 69 | 2715 } |
| 2716 else { | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2717 /* 'import' ... */ |
| 69 | 2718 for (i = 1; i < NCH(n); i += 2) { |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2719 node *subn = CHILD(n, i); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2720 REQ(subn, dotted_as_name); |
|
14232
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2721 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2722 com_push(c, 1); |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2723 com_addopname(c, IMPORT_NAME, CHILD(subn, 0)); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2724 if (NCH(subn) > 1) { |
|
14230
31925ab46b23
Re-allow 'import mod.submod as s', and change its meaning to what it should
Thomas Wouters <thomas@python.org>
parents:
14226
diff
changeset
|
2725 int j; |
|
31925ab46b23
Re-allow 'import mod.submod as s', and change its meaning to what it should
Thomas Wouters <thomas@python.org>
parents:
14226
diff
changeset
|
2726 if (strcmp(STR(CHILD(subn, 1)), "as") != 0) { |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2727 com_error(c, PyExc_SyntaxError, |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2728 "invalid syntax"); |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2729 return; |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2730 } |
|
14230
31925ab46b23
Re-allow 'import mod.submod as s', and change its meaning to what it should
Thomas Wouters <thomas@python.org>
parents:
14226
diff
changeset
|
2731 for (j=2 ; j < NCH(CHILD(subn, 0)); j += 2) |
|
31925ab46b23
Re-allow 'import mod.submod as s', and change its meaning to what it should
Thomas Wouters <thomas@python.org>
parents:
14226
diff
changeset
|
2732 com_addopname(c, LOAD_ATTR, |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2733 CHILD(CHILD(subn, 0), |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2734 j)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2735 com_addop_varname(c, VAR_STORE, |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2736 STR(CHILD(subn, 2))); |
|
14038
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2737 } else |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2738 com_addop_varname(c, VAR_STORE, |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2739 STR(CHILD(CHILD(subn, 0), |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2740 0))); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2741 com_pop(c, 1); |
| 69 | 2742 } |
| 2743 } | |
| 2744 } | |
| 2745 | |
| 2746 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2747 com_exec_stmt(struct compiling *c, node *n) |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2748 { |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2749 REQ(n, exec_stmt); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2750 /* exec_stmt: 'exec' expr ['in' expr [',' expr]] */ |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2751 com_node(c, CHILD(n, 1)); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2752 if (NCH(n) >= 4) |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2753 com_node(c, CHILD(n, 3)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2754 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2755 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2756 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2757 } |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2758 if (NCH(n) >= 6) |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2759 com_node(c, CHILD(n, 5)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2760 else { |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2761 com_addbyte(c, DUP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2762 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2763 } |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2764 com_addbyte(c, EXEC_STMT); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2765 com_pop(c, 3); |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2766 } |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2767 |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2768 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2769 is_constant_false(struct compiling *c, node *n) |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2770 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2771 PyObject *v; |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2772 int i; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2773 /* argument c will be NULL when called from symtable_node() */ |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2774 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2775 /* Label to avoid tail recursion */ |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2776 next: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2777 switch (TYPE(n)) { |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2778 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2779 case suite: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2780 if (NCH(n) == 1) { |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2781 n = CHILD(n, 0); |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2782 goto next; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2783 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2784 /* Fall through */ |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2785 case file_input: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2786 for (i = 0; i < NCH(n); i++) { |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2787 node *ch = CHILD(n, i); |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2788 if (TYPE(ch) == stmt) { |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2789 n = ch; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2790 goto next; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2791 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2792 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2793 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2794 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2795 case stmt: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2796 case simple_stmt: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2797 case small_stmt: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2798 n = CHILD(n, 0); |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2799 goto next; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2800 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2801 case expr_stmt: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2802 case testlist: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2803 case test: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2804 case and_test: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2805 case not_test: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2806 case comparison: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2807 case expr: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2808 case xor_expr: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2809 case and_expr: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2810 case shift_expr: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2811 case arith_expr: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2812 case term: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2813 case factor: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2814 case power: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2815 case atom: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2816 if (NCH(n) == 1) { |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2817 n = CHILD(n, 0); |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2818 goto next; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2819 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2820 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2821 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2822 case NAME: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2823 if (Py_OptimizeFlag && strcmp(STR(n), "__debug__") == 0) |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2824 return 1; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2825 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2826 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2827 case NUMBER: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2828 v = parsenumber(c, STR(n)); |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2829 if (v == NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2830 PyErr_Clear(); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2831 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2832 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2833 i = PyObject_IsTrue(v); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2834 Py_DECREF(v); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2835 return i == 0; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2836 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2837 case STRING: |
|
5183
636757e812a4
Fix dumb bug calling parsestrplus with wrong node as argument.
Guido van Rossum <guido@python.org>
parents:
5181
diff
changeset
|
2838 v = parsestr(STR(n)); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2839 if (v == NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2840 PyErr_Clear(); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2841 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2842 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2843 i = PyObject_IsTrue(v); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2844 Py_DECREF(v); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2845 return i == 0; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2846 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2847 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2848 return 0; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2849 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2850 |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2851 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2852 com_if_stmt(struct compiling *c, node *n) |
| 69 | 2853 { |
| 2854 int i; | |
| 2855 int anchor = 0; | |
| 2856 REQ(n, if_stmt); | |
| 2857 /*'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */ | |
| 2858 for (i = 0; i+3 < NCH(n); i+=4) { | |
| 2859 int a = 0; | |
| 86 | 2860 node *ch = CHILD(n, i+1); |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2861 if (is_constant_false(c, ch)) |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2862 continue; |
| 86 | 2863 if (i > 0) |
| 2864 com_addoparg(c, SET_LINENO, ch->n_lineno); | |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2865 com_node(c, ch); |
| 69 | 2866 com_addfwref(c, JUMP_IF_FALSE, &a); |
| 2867 com_addbyte(c, POP_TOP); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2868 com_pop(c, 1); |
| 69 | 2869 com_node(c, CHILD(n, i+3)); |
| 2870 com_addfwref(c, JUMP_FORWARD, &anchor); | |
| 2871 com_backpatch(c, a); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2872 /* We jump here with an extra entry which we now pop */ |
| 69 | 2873 com_addbyte(c, POP_TOP); |
| 2874 } | |
| 2875 if (i+2 < NCH(n)) | |
| 2876 com_node(c, CHILD(n, i+2)); | |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2877 if (anchor) |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2878 com_backpatch(c, anchor); |
| 69 | 2879 } |
| 2880 | |
| 2881 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2882 com_while_stmt(struct compiling *c, node *n) |
| 69 | 2883 { |
| 2884 int break_anchor = 0; | |
| 2885 int anchor = 0; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2886 int save_begin = c->c_begin; |
| 69 | 2887 REQ(n, while_stmt); /* 'while' test ':' suite ['else' ':' suite] */ |
| 2888 com_addfwref(c, SETUP_LOOP, &break_anchor); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2889 block_push(c, SETUP_LOOP); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2890 c->c_begin = c->c_nexti; |
| 86 | 2891 com_addoparg(c, SET_LINENO, n->n_lineno); |
| 69 | 2892 com_node(c, CHILD(n, 1)); |
| 2893 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 2894 com_addbyte(c, POP_TOP); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2895 com_pop(c, 1); |
| 86 | 2896 c->c_loops++; |
| 69 | 2897 com_node(c, CHILD(n, 3)); |
| 86 | 2898 c->c_loops--; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2899 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2900 c->c_begin = save_begin; |
| 69 | 2901 com_backpatch(c, anchor); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2902 /* We jump here with one entry more on the stack */ |
| 69 | 2903 com_addbyte(c, POP_TOP); |
| 2904 com_addbyte(c, POP_BLOCK); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2905 block_pop(c, SETUP_LOOP); |
| 69 | 2906 if (NCH(n) > 4) |
| 2907 com_node(c, CHILD(n, 6)); | |
| 2908 com_backpatch(c, break_anchor); | |
| 2909 } | |
| 2910 | |
| 2911 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2912 com_for_stmt(struct compiling *c, node *n) |
| 69 | 2913 { |
| 2914 int break_anchor = 0; | |
| 2915 int anchor = 0; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2916 int save_begin = c->c_begin; |
| 69 | 2917 REQ(n, for_stmt); |
| 2918 /* 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] */ | |
| 2919 com_addfwref(c, SETUP_LOOP, &break_anchor); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2920 block_push(c, SETUP_LOOP); |
| 69 | 2921 com_node(c, CHILD(n, 3)); |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
2922 com_addbyte(c, GET_ITER); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2923 c->c_begin = c->c_nexti; |
| 86 | 2924 com_addoparg(c, SET_LINENO, n->n_lineno); |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
2925 com_addfwref(c, FOR_ITER, &anchor); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2926 com_push(c, 1); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2927 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL); |
| 86 | 2928 c->c_loops++; |
| 69 | 2929 com_node(c, CHILD(n, 5)); |
| 86 | 2930 c->c_loops--; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2931 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2932 c->c_begin = save_begin; |
| 69 | 2933 com_backpatch(c, anchor); |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
2934 com_pop(c, 1); /* FOR_ITER has popped this */ |
| 69 | 2935 com_addbyte(c, POP_BLOCK); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2936 block_pop(c, SETUP_LOOP); |
| 69 | 2937 if (NCH(n) > 8) |
| 2938 com_node(c, CHILD(n, 8)); | |
| 2939 com_backpatch(c, break_anchor); | |
| 2940 } | |
| 2941 | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2942 /* Code generated for "try: S finally: Sf" is as follows: |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2943 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2944 SETUP_FINALLY L |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2945 <code for S> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2946 POP_BLOCK |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2947 LOAD_CONST <nil> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2948 L: <code for Sf> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2949 END_FINALLY |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2950 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2951 The special instructions use the block stack. Each block |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2952 stack entry contains the instruction that created it (here |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2953 SETUP_FINALLY), the level of the value stack at the time the |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2954 block stack entry was created, and a label (here L). |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2955 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2956 SETUP_FINALLY: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2957 Pushes the current value stack level and the label |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2958 onto the block stack. |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2959 POP_BLOCK: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2960 Pops en entry from the block stack, and pops the value |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2961 stack until its level is the same as indicated on the |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2962 block stack. (The label is ignored.) |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2963 END_FINALLY: |
| 86 | 2964 Pops a variable number of entries from the *value* stack |
| 2965 and re-raises the exception they specify. The number of | |
| 2966 entries popped depends on the (pseudo) exception type. | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2967 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2968 The block stack is unwound when an exception is raised: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2969 when a SETUP_FINALLY entry is found, the exception is pushed |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2970 onto the value stack (and the exception condition is cleared), |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2971 and the interpreter jumps to the label gotten from the block |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2972 stack. |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2973 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2974 Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...": |
| 86 | 2975 (The contents of the value stack is shown in [], with the top |
| 2976 at the right; 'tb' is trace-back info, 'val' the exception's | |
| 2977 associated value, and 'exc' the exception.) | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2978 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2979 Value stack Label Instruction Argument |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2980 [] SETUP_EXCEPT L1 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2981 [] <code for S> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2982 [] POP_BLOCK |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2983 [] JUMP_FORWARD L0 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2984 |
| 86 | 2985 [tb, val, exc] L1: DUP ) |
| 2986 [tb, val, exc, exc] <evaluate E1> ) | |
| 2987 [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1 | |
| 2988 [tb, val, exc, 1-or-0] JUMP_IF_FALSE L2 ) | |
| 2989 [tb, val, exc, 1] POP ) | |
| 2990 [tb, val, exc] POP | |
| 2991 [tb, val] <assign to V1> (or POP if no V1) | |
| 2992 [tb] POP | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2993 [] <code for S1> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2994 JUMP_FORWARD L0 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2995 |
| 86 | 2996 [tb, val, exc, 0] L2: POP |
| 2997 [tb, val, exc] DUP | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2998 .............................etc....................... |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2999 |
| 86 | 3000 [tb, val, exc, 0] Ln+1: POP |
| 3001 [tb, val, exc] END_FINALLY # re-raise exception | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3002 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3003 [] L0: <next statement> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3004 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3005 Of course, parts are not generated if Vi or Ei is not present. |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3006 */ |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3007 |
| 69 | 3008 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3009 com_try_except(struct compiling *c, node *n) |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3010 { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3011 int except_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3012 int end_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3013 int else_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3014 int i; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3015 node *ch; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3016 |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3017 com_addfwref(c, SETUP_EXCEPT, &except_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3018 block_push(c, SETUP_EXCEPT); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3019 com_node(c, CHILD(n, 2)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3020 com_addbyte(c, POP_BLOCK); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3021 block_pop(c, SETUP_EXCEPT); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3022 com_addfwref(c, JUMP_FORWARD, &else_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3023 com_backpatch(c, except_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3024 for (i = 3; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3025 i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3026 i += 3) { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3027 /* except_clause: 'except' [expr [',' var]] */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3028 if (except_anchor == 0) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3029 com_error(c, PyExc_SyntaxError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
3030 "default 'except:' must be last"); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3031 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3032 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3033 except_anchor = 0; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3034 com_push(c, 3); /* tb, val, exc pushed by exception */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3035 com_addoparg(c, SET_LINENO, ch->n_lineno); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3036 if (NCH(ch) > 1) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3037 com_addbyte(c, DUP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3038 com_push(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3039 com_node(c, CHILD(ch, 1)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3040 com_addoparg(c, COMPARE_OP, EXC_MATCH); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3041 com_pop(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3042 com_addfwref(c, JUMP_IF_FALSE, &except_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3043 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3044 com_pop(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3045 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3046 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3047 com_pop(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3048 if (NCH(ch) > 3) |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
3049 com_assign(c, CHILD(ch, 3), OP_ASSIGN, NULL); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3050 else { |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3051 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3052 com_pop(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3053 } |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3054 com_addbyte(c, POP_TOP); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3055 com_pop(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3056 com_node(c, CHILD(n, i+2)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3057 com_addfwref(c, JUMP_FORWARD, &end_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3058 if (except_anchor) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3059 com_backpatch(c, except_anchor); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3060 /* We come in with [tb, val, exc, 0] on the |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3061 stack; one pop and it's the same as |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3062 expected at the start of the loop */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3063 com_addbyte(c, POP_TOP); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3064 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3065 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3066 /* We actually come in here with [tb, val, exc] but the |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3067 END_FINALLY will zap those and jump around. |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3068 The c_stacklevel does not reflect them so we need not pop |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3069 anything. */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3070 com_addbyte(c, END_FINALLY); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3071 com_backpatch(c, else_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3072 if (i < NCH(n)) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3073 com_node(c, CHILD(n, i+2)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3074 com_backpatch(c, end_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3075 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3076 |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3077 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3078 com_try_finally(struct compiling *c, node *n) |
| 69 | 3079 { |
| 3080 int finally_anchor = 0; | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3081 node *ch; |
|
792
dc3b455f7632
Only * can be used for varargs argument lists
Guido van Rossum <guido@python.org>
parents:
744
diff
changeset
|
3082 |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3083 com_addfwref(c, SETUP_FINALLY, &finally_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3084 block_push(c, SETUP_FINALLY); |
| 69 | 3085 com_node(c, CHILD(n, 2)); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3086 com_addbyte(c, POP_BLOCK); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3087 block_pop(c, SETUP_FINALLY); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3088 block_push(c, END_FINALLY); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3089 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3090 /* While the generated code pushes only one item, |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3091 the try-finally handling can enter here with |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3092 up to three items. OK, here are the details: |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3093 3 for an exception, 2 for RETURN, 1 for BREAK. */ |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3094 com_push(c, 3); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3095 com_backpatch(c, finally_anchor); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3096 ch = CHILD(n, NCH(n)-1); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3097 com_addoparg(c, SET_LINENO, ch->n_lineno); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3098 com_node(c, ch); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3099 com_addbyte(c, END_FINALLY); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3100 block_pop(c, END_FINALLY); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3101 com_pop(c, 3); /* Matches the com_push above */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3102 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3103 |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3104 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3105 com_try_stmt(struct compiling *c, node *n) |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3106 { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3107 REQ(n, try_stmt); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3108 /* 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite] |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3109 | 'try' ':' suite 'finally' ':' suite */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3110 if (TYPE(CHILD(n, 3)) != except_clause) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3111 com_try_finally(c, n); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3112 else |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3113 com_try_except(c, n); |
| 69 | 3114 } |
| 3115 | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3116 static node * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3117 get_rawdocstring(node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3118 { |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3119 int i; |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3120 |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3121 /* Label to avoid tail recursion */ |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3122 next: |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3123 switch (TYPE(n)) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3124 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3125 case suite: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3126 if (NCH(n) == 1) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3127 n = CHILD(n, 0); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3128 goto next; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3129 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3130 /* Fall through */ |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3131 case file_input: |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3132 for (i = 0; i < NCH(n); i++) { |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3133 node *ch = CHILD(n, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3134 if (TYPE(ch) == stmt) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3135 n = ch; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3136 goto next; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3137 } |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3138 } |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3139 break; |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3140 |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3141 case stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3142 case simple_stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3143 case small_stmt: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3144 n = CHILD(n, 0); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3145 goto next; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3146 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3147 case expr_stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3148 case testlist: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3149 case test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3150 case and_test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3151 case not_test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3152 case comparison: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3153 case expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3154 case xor_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3155 case and_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3156 case shift_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3157 case arith_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3158 case term: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3159 case factor: |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3160 case power: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3161 if (NCH(n) == 1) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3162 n = CHILD(n, 0); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3163 goto next; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3164 } |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3165 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3166 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3167 case atom: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3168 if (TYPE(CHILD(n, 0)) == STRING) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3169 return n; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3170 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3171 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3172 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3173 return NULL; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3174 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3175 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3176 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3177 get_docstring(node *n) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3178 { |
|
9987
b7bcc2cda1b3
Implement -OO; "unsafe" optimization that removes docstrings.
Guido van Rossum <guido@python.org>
parents:
9626
diff
changeset
|
3179 /* Don't generate doc-strings if run with -OO */ |
|
b7bcc2cda1b3
Implement -OO; "unsafe" optimization that removes docstrings.
Guido van Rossum <guido@python.org>
parents:
9626
diff
changeset
|
3180 if (Py_OptimizeFlag > 1) |
|
b7bcc2cda1b3
Implement -OO; "unsafe" optimization that removes docstrings.
Guido van Rossum <guido@python.org>
parents:
9626
diff
changeset
|
3181 return NULL; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3182 n = get_rawdocstring(n); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3183 if (n == NULL) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3184 return NULL; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3185 return parsestrplus(n); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3186 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3187 |
| 69 | 3188 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3189 com_suite(struct compiling *c, node *n) |
| 69 | 3190 { |
| 3191 REQ(n, suite); | |
| 3192 /* simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT */ | |
| 3193 if (NCH(n) == 1) { | |
| 3194 com_node(c, CHILD(n, 0)); | |
| 3195 } | |
| 3196 else { | |
| 3197 int i; | |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3198 for (i = 0; i < NCH(n) && c->c_errors == 0; i++) { |
| 69 | 3199 node *ch = CHILD(n, i); |
| 3200 if (TYPE(ch) == stmt) | |
| 3201 com_node(c, ch); | |
| 3202 } | |
| 3203 } | |
| 3204 } | |
| 3205 | |
| 744 | 3206 /* ARGSUSED */ |
| 69 | 3207 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3208 com_continue_stmt(struct compiling *c, node *n) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3209 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3210 int i = c->c_nblocks; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3211 if (i-- > 0 && c->c_block[i] == SETUP_LOOP) { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3212 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3213 } |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3214 else if (i <= 0) { |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3215 /* at the outer level */ |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3216 com_error(c, PyExc_SyntaxError, |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3217 "'continue' not properly in loop"); |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3218 } |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3219 else { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3220 int j; |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3221 for (j = i-1; j >= 0; --j) { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3222 if (c->c_block[j] == SETUP_LOOP) |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3223 break; |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3224 } |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3225 if (j >= 0) { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3226 /* there is a loop, but something interferes */ |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3227 for (; i > j; --i) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3228 if (c->c_block[i] == SETUP_EXCEPT || |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3229 c->c_block[i] == SETUP_FINALLY) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3230 com_addoparg(c, CONTINUE_LOOP, |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3231 c->c_begin); |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3232 return; |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3233 } |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3234 if (c->c_block[i] == END_FINALLY) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3235 com_error(c, PyExc_SyntaxError, |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3236 "'continue' not supported inside 'finally' clause"); |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3237 return; |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3238 } |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3239 } |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3240 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3241 com_error(c, PyExc_SyntaxError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3242 "'continue' not properly in loop"); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3243 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3244 /* XXX Could allow it inside a 'finally' clause |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3245 XXX if we could pop the exception still on the stack */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3246 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3247 |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3248 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3249 com_argdefs(struct compiling *c, node *n) |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3250 { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3251 int i, nch, nargs, ndefs; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3252 if (TYPE(n) == lambdef) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3253 /* lambdef: 'lambda' [varargslist] ':' test */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3254 n = CHILD(n, 1); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3255 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3256 else { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3257 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ... */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3258 n = CHILD(n, 2); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3259 REQ(n, parameters); /* parameters: '(' [varargslist] ')' */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3260 n = CHILD(n, 1); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3261 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3262 if (TYPE(n) != varargslist) |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3263 return 0; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3264 /* varargslist: |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3265 (fpdef ['=' test] ',')* '*' ....... | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3266 fpdef ['=' test] (',' fpdef ['=' test])* [','] */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3267 nch = NCH(n); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3268 nargs = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3269 ndefs = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3270 for (i = 0; i < nch; i++) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3271 int t; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3272 if (TYPE(CHILD(n, i)) == STAR || |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3273 TYPE(CHILD(n, i)) == DOUBLESTAR) |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
3274 break; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3275 nargs++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3276 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3277 if (i >= nch) |
|
3103
e51e17b2d88b
fix bug with missing default for last arg (discovered by Tommy Burnette)
Guido van Rossum <guido@python.org>
parents:
2844
diff
changeset
|
3278 t = RPAR; /* Anything except EQUAL or COMMA */ |
|
e51e17b2d88b
fix bug with missing default for last arg (discovered by Tommy Burnette)
Guido van Rossum <guido@python.org>
parents:
2844
diff
changeset
|
3279 else |
|
e51e17b2d88b
fix bug with missing default for last arg (discovered by Tommy Burnette)
Guido van Rossum <guido@python.org>
parents:
2844
diff
changeset
|
3280 t = TYPE(CHILD(n, i)); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3281 if (t == EQUAL) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3282 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3283 ndefs++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3284 com_node(c, CHILD(n, i)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3285 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3286 if (i >= nch) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3287 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3288 t = TYPE(CHILD(n, i)); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3289 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3290 else { |
|
9214
c259c3c4d0cc
Treat def f(a, b=1, c): ... as an error (missing default for c)
Guido van Rossum <guido@python.org>
parents:
9049
diff
changeset
|
3291 /* Treat "(a=1, b)" as an error */ |
|
c259c3c4d0cc
Treat def f(a, b=1, c): ... as an error (missing default for c)
Guido van Rossum <guido@python.org>
parents:
9049
diff
changeset
|
3292 if (ndefs) |
|
c259c3c4d0cc
Treat def f(a, b=1, c): ... as an error (missing default for c)
Guido van Rossum <guido@python.org>
parents:
9049
diff
changeset
|
3293 com_error(c, PyExc_SyntaxError, |
|
9215
1995cdbe3384
Eh, better error message for the previous change. It now says
Guido van Rossum <guido@python.org>
parents:
9214
diff
changeset
|
3294 "non-default argument follows default argument"); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3295 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3296 if (t != COMMA) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3297 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3298 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3299 return ndefs; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3300 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3301 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3302 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3303 com_funcdef(struct compiling *c, node *n) |
| 69 | 3304 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3305 PyObject *co; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3306 int ndefs; |
| 69 | 3307 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3308 ndefs = com_argdefs(c, n); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3309 symtable_enter_scope(c->c_symtable, STR(CHILD(n, 1)), TYPE(n), |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3310 n->n_lineno); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3311 co = (PyObject *)icompile(n, c); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3312 symtable_exit_scope(c->c_symtable); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3313 if (co == NULL) |
| 69 | 3314 c->c_errors++; |
| 3315 else { | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3316 int closure = com_make_closure(c, (PyCodeObject *)co); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3317 int i = com_addconst(c, co); |
| 69 | 3318 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3319 com_push(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3320 if (closure) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3321 com_addoparg(c, MAKE_CLOSURE, ndefs); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3322 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3323 com_addoparg(c, MAKE_FUNCTION, ndefs); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3324 com_pop(c, ndefs); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3325 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1))); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3326 com_pop(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3327 Py_DECREF(co); |
| 69 | 3328 } |
| 3329 } | |
| 3330 | |
| 3331 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3332 com_bases(struct compiling *c, node *n) |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3333 { |
| 744 | 3334 int i; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3335 REQ(n, testlist); |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3336 /* testlist: test (',' test)* [','] */ |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3337 for (i = 0; i < NCH(n); i += 2) |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3338 com_node(c, CHILD(n, i)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3339 i = (NCH(n)+1) / 2; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3340 com_addoparg(c, BUILD_TUPLE, i); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3341 com_pop(c, i-1); |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3342 } |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3343 |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3344 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3345 com_classdef(struct compiling *c, node *n) |
| 69 | 3346 { |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3347 int i; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3348 PyObject *co, *v; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3349 char *name; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3350 |
| 69 | 3351 REQ(n, classdef); |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3352 /* classdef: class NAME ['(' testlist ')'] ':' suite */ |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
3353 if ((v = PyString_InternFromString(STR(CHILD(n, 1)))) == NULL) { |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3354 c->c_errors++; |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3355 return; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3356 } |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3357 /* Push the class name on the stack */ |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3358 i = com_addconst(c, v); |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3359 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3360 com_push(c, 1); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3361 Py_DECREF(v); |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3362 /* Push the tuple of base classes on the stack */ |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3363 if (TYPE(CHILD(n, 2)) != LPAR) { |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3364 com_addoparg(c, BUILD_TUPLE, 0); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3365 com_push(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3366 } |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3367 else |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3368 com_bases(c, CHILD(n, 3)); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3369 name = STR(CHILD(n, 1)); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3370 symtable_enter_scope(c->c_symtable, name, TYPE(n), n->n_lineno); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3371 co = (PyObject *)icompile(n, c); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3372 symtable_exit_scope(c->c_symtable); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3373 if (co == NULL) |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3374 c->c_errors++; |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3375 else { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3376 int closure = com_make_closure(c, (PyCodeObject *)co); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3377 i = com_addconst(c, co); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3378 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3379 com_push(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3380 if (closure) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3381 com_addoparg(c, MAKE_CLOSURE, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3382 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3383 com_addoparg(c, MAKE_FUNCTION, 0); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3384 com_addoparg(c, CALL_FUNCTION, 0); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3385 com_addbyte(c, BUILD_CLASS); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3386 com_pop(c, 2); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3387 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1))); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3388 Py_DECREF(co); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3389 } |
| 69 | 3390 } |
| 3391 | |
| 3392 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3393 com_node(struct compiling *c, node *n) |
| 69 | 3394 { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3395 loop: |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3396 if (c->c_errors) |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3397 return; |
| 69 | 3398 switch (TYPE(n)) { |
| 3399 | |
| 3400 /* Definition nodes */ | |
| 3401 | |
| 3402 case funcdef: | |
| 3403 com_funcdef(c, n); | |
| 3404 break; | |
| 3405 case classdef: | |
| 3406 com_classdef(c, n); | |
| 3407 break; | |
| 3408 | |
| 3409 /* Trivial parse tree nodes */ | |
| 3410 | |
| 3411 case stmt: | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3412 case small_stmt: |
| 86 | 3413 case flow_stmt: |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3414 n = CHILD(n, 0); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3415 goto loop; |
| 86 | 3416 |
| 69 | 3417 case simple_stmt: |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3418 /* small_stmt (';' small_stmt)* [';'] NEWLINE */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3419 com_addoparg(c, SET_LINENO, n->n_lineno); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3420 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3421 int i; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3422 for (i = 0; i < NCH(n)-1; i += 2) |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3423 com_node(c, CHILD(n, i)); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3424 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3425 break; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3426 |
| 69 | 3427 case compound_stmt: |
| 86 | 3428 com_addoparg(c, SET_LINENO, n->n_lineno); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3429 n = CHILD(n, 0); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3430 goto loop; |
| 69 | 3431 |
| 3432 /* Statement nodes */ | |
| 3433 | |
| 3434 case expr_stmt: | |
| 3435 com_expr_stmt(c, n); | |
| 3436 break; | |
| 3437 case print_stmt: | |
| 3438 com_print_stmt(c, n); | |
| 3439 break; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3440 case del_stmt: /* 'del' exprlist */ |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
3441 com_assign(c, CHILD(n, 1), OP_DELETE, NULL); |
| 69 | 3442 break; |
| 3443 case pass_stmt: | |
| 3444 break; | |
| 3445 case break_stmt: | |
| 86 | 3446 if (c->c_loops == 0) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3447 com_error(c, PyExc_SyntaxError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3448 "'break' outside loop"); |
| 86 | 3449 } |
| 69 | 3450 com_addbyte(c, BREAK_LOOP); |
| 3451 break; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3452 case continue_stmt: |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3453 com_continue_stmt(c, n); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3454 break; |
| 69 | 3455 case return_stmt: |
| 3456 com_return_stmt(c, n); | |
| 3457 break; | |
| 3458 case raise_stmt: | |
| 3459 com_raise_stmt(c, n); | |
| 3460 break; | |
| 3461 case import_stmt: | |
| 3462 com_import_stmt(c, n); | |
| 3463 break; | |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3464 case global_stmt: |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3465 break; |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3466 case exec_stmt: |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3467 com_exec_stmt(c, n); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3468 break; |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3469 case assert_stmt: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3470 com_assert_stmt(c, n); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3471 break; |
| 69 | 3472 case if_stmt: |
| 3473 com_if_stmt(c, n); | |
| 3474 break; | |
| 3475 case while_stmt: | |
| 3476 com_while_stmt(c, n); | |
| 3477 break; | |
| 3478 case for_stmt: | |
| 3479 com_for_stmt(c, n); | |
| 3480 break; | |
| 3481 case try_stmt: | |
| 3482 com_try_stmt(c, n); | |
| 3483 break; | |
| 3484 case suite: | |
| 3485 com_suite(c, n); | |
| 3486 break; | |
| 3487 | |
| 3488 /* Expression nodes */ | |
| 3489 | |
| 3490 case testlist: | |
| 482 | 3491 com_list(c, n, 0); |
| 69 | 3492 break; |
| 3493 case test: | |
| 3494 com_test(c, n); | |
| 3495 break; | |
| 3496 case and_test: | |
| 3497 com_and_test(c, n); | |
| 3498 break; | |
| 3499 case not_test: | |
| 3500 com_not_test(c, n); | |
| 3501 break; | |
| 3502 case comparison: | |
| 3503 com_comparison(c, n); | |
| 3504 break; | |
| 3505 case exprlist: | |
| 482 | 3506 com_list(c, n, 0); |
| 69 | 3507 break; |
| 3508 case expr: | |
| 3509 com_expr(c, n); | |
| 3510 break; | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3511 case xor_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3512 com_xor_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3513 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3514 case and_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3515 com_and_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3516 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3517 case shift_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3518 com_shift_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3519 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3520 case arith_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3521 com_arith_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3522 break; |
| 69 | 3523 case term: |
| 3524 com_term(c, n); | |
| 3525 break; | |
| 3526 case factor: | |
| 3527 com_factor(c, n); | |
| 3528 break; | |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3529 case power: |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3530 com_power(c, n); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3531 break; |
| 69 | 3532 case atom: |
| 3533 com_atom(c, n); | |
| 3534 break; | |
| 3535 | |
| 3536 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3537 com_error(c, PyExc_SystemError, |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3538 "com_node: unexpected node type"); |
| 69 | 3539 } |
| 3540 } | |
| 3541 | |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
3542 static void com_fplist(struct compiling *, node *); |
| 69 | 3543 |
| 3544 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3545 com_fpdef(struct compiling *c, node *n) |
| 69 | 3546 { |
| 3547 REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */ | |
| 3548 if (TYPE(CHILD(n, 0)) == LPAR) | |
| 3549 com_fplist(c, CHILD(n, 1)); | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3550 else { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3551 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 0))); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3552 com_pop(c, 1); |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3553 } |
| 69 | 3554 } |
| 3555 | |
| 3556 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3557 com_fplist(struct compiling *c, node *n) |
| 69 | 3558 { |
| 544 | 3559 REQ(n, fplist); /* fplist: fpdef (',' fpdef)* [','] */ |
| 69 | 3560 if (NCH(n) == 1) { |
| 3561 com_fpdef(c, CHILD(n, 0)); | |
| 3562 } | |
| 3563 else { | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3564 int i = (NCH(n)+1)/2; |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
3565 com_addoparg(c, UNPACK_SEQUENCE, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3566 com_push(c, i-1); |
| 69 | 3567 for (i = 0; i < NCH(n); i += 2) |
| 3568 com_fpdef(c, CHILD(n, i)); | |
| 3569 } | |
| 3570 } | |
| 3571 | |
| 3572 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3573 com_arglist(struct compiling *c, node *n) |
| 584 | 3574 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3575 int nch, i, narg; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3576 int complex = 0; |
|
5754
9ed26afeeaa5
Fix bug reported by Just: anonymous arguments used for tuples should
Guido van Rossum <guido@python.org>
parents:
5610
diff
changeset
|
3577 char nbuf[10]; |
| 584 | 3578 REQ(n, varargslist); |
|
617
755bb8efcc2d
Use strtoul() for oct/hex constants.
Guido van Rossum <guido@python.org>
parents:
584
diff
changeset
|
3579 /* varargslist: |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3580 (fpdef ['=' test] ',')* (fpdef ['=' test] | '*' .....) */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3581 nch = NCH(n); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3582 /* Enter all arguments in table of locals */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3583 for (i = 0, narg = 0; i < nch; i++) { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3584 node *ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3585 node *fp; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3586 if (TYPE(ch) == STAR || TYPE(ch) == DOUBLESTAR) |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
3587 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3588 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3589 fp = CHILD(ch, 0); |
|
17104
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
3590 if (TYPE(fp) != NAME) { |
|
5754
9ed26afeeaa5
Fix bug reported by Just: anonymous arguments used for tuples should
Guido van Rossum <guido@python.org>
parents:
5610
diff
changeset
|
3591 sprintf(nbuf, ".%d", i); |
|
3766
516490c8192c
Py_complex; and WITHOUT_COMPLEX added to getargs.c
Guido van Rossum <guido@python.org>
parents:
3366
diff
changeset
|
3592 complex = 1; |
|
2813
999b5bdc18ce
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
Guido van Rossum <guido@python.org>
parents:
2367
diff
changeset
|
3593 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3594 narg++; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3595 /* all name updates handled by symtable */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3596 if (++i >= nch) |
| 584 | 3597 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3598 ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3599 if (TYPE(ch) == EQUAL) |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3600 i += 2; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3601 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3602 REQ(ch, COMMA); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3603 } |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3604 if (complex) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3605 /* Generate code for complex arguments only after |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3606 having counted the simple arguments */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3607 int ilocal = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3608 for (i = 0; i < nch; i++) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3609 node *ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3610 node *fp; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3611 if (TYPE(ch) == STAR || TYPE(ch) == DOUBLESTAR) |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3612 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3613 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3614 fp = CHILD(ch, 0); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3615 if (TYPE(fp) != NAME) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3616 com_addoparg(c, LOAD_FAST, ilocal); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3617 com_push(c, 1); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3618 com_fpdef(c, ch); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3619 } |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3620 ilocal++; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3621 if (++i >= nch) |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3622 break; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3623 ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3624 if (TYPE(ch) == EQUAL) |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3625 i += 2; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3626 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3627 REQ(ch, COMMA); |
| 584 | 3628 } |
| 3629 } | |
| 3630 } | |
| 3631 | |
| 3632 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3633 com_file_input(struct compiling *c, node *n) |
| 69 | 3634 { |
| 3635 int i; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3636 PyObject *doc; |
| 69 | 3637 REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */ |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3638 doc = get_docstring(n); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3639 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3640 int i = com_addconst(c, doc); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3641 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3642 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3643 com_push(c, 1); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3644 com_addop_name(c, STORE_NAME, "__doc__"); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3645 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3646 } |
| 69 | 3647 for (i = 0; i < NCH(n); i++) { |
| 3648 node *ch = CHILD(n, i); | |
| 3649 if (TYPE(ch) != ENDMARKER && TYPE(ch) != NEWLINE) | |
| 3650 com_node(c, ch); | |
| 3651 } | |
| 3652 } | |
| 3653 | |
| 3654 /* Top-level compile-node interface */ | |
| 3655 | |
| 3656 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3657 compile_funcdef(struct compiling *c, node *n) |
| 69 | 3658 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3659 PyObject *doc; |
| 69 | 3660 node *ch; |
| 3661 REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */ | |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
3662 c->c_name = STR(CHILD(n, 1)); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3663 doc = get_docstring(CHILD(n, 4)); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3664 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3665 (void) com_addconst(c, doc); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3666 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3667 } |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3668 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3669 (void) com_addconst(c, Py_None); /* No docstring */ |
| 584 | 3670 ch = CHILD(n, 2); /* parameters: '(' [varargslist] ')' */ |
| 3671 ch = CHILD(ch, 1); /* ')' | varargslist */ | |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3672 if (TYPE(ch) == varargslist) |
| 584 | 3673 com_arglist(c, ch); |
| 86 | 3674 c->c_infunction = 1; |
| 69 | 3675 com_node(c, CHILD(n, 4)); |
| 86 | 3676 c->c_infunction = 0; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3677 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3678 com_push(c, 1); |
| 69 | 3679 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3680 com_pop(c, 1); |
| 69 | 3681 } |
| 3682 | |
| 3683 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3684 compile_lambdef(struct compiling *c, node *n) |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3685 { |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3686 node *ch; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3687 REQ(n, lambdef); /* lambdef: 'lambda' [varargslist] ':' test */ |
|
2005
ed5d0ad5ea2f
set name to <lambda> instead of None for lambdas
Guido van Rossum <guido@python.org>
parents:
1833
diff
changeset
|
3688 c->c_name = "<lambda>"; |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3689 |
|
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3690 ch = CHILD(n, 1); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3691 (void) com_addconst(c, Py_None); /* No docstring */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3692 if (TYPE(ch) == varargslist) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3693 com_arglist(c, ch); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3694 ch = CHILD(n, 3); |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3695 } |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3696 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3697 ch = CHILD(n, 2); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3698 com_node(c, ch); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3699 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3700 com_pop(c, 1); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3701 } |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3702 |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3703 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3704 compile_classdef(struct compiling *c, node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3705 { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3706 node *ch; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3707 PyObject *doc; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3708 REQ(n, classdef); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3709 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3710 c->c_name = STR(CHILD(n, 1)); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3711 c->c_private = c->c_name; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3712 ch = CHILD(n, NCH(n)-1); /* The suite */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3713 doc = get_docstring(ch); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3714 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3715 int i = com_addconst(c, doc); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3716 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3717 com_addoparg(c, LOAD_CONST, i); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3718 com_push(c, 1); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3719 com_addop_name(c, STORE_NAME, "__doc__"); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3720 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3721 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3722 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3723 (void) com_addconst(c, Py_None); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3724 com_node(c, ch); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3725 com_addbyte(c, LOAD_LOCALS); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3726 com_push(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3727 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3728 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3729 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3730 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3731 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3732 compile_node(struct compiling *c, node *n) |
| 69 | 3733 { |
| 86 | 3734 com_addoparg(c, SET_LINENO, n->n_lineno); |
| 3735 | |
| 69 | 3736 switch (TYPE(n)) { |
| 3737 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3738 case single_input: /* One interactive command */ |
| 69 | 3739 /* NEWLINE | simple_stmt | compound_stmt NEWLINE */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3740 c->c_interactive++; |
| 69 | 3741 n = CHILD(n, 0); |
| 3742 if (TYPE(n) != NEWLINE) | |
| 3743 com_node(c, n); | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3744 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3745 com_push(c, 1); |
| 86 | 3746 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3747 com_pop(c, 1); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3748 c->c_interactive--; |
| 69 | 3749 break; |
| 3750 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3751 case file_input: /* A whole file, or built-in function exec() */ |
| 69 | 3752 com_file_input(c, n); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3753 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3754 com_push(c, 1); |
| 86 | 3755 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3756 com_pop(c, 1); |
| 69 | 3757 break; |
| 3758 | |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3759 case eval_input: /* Built-in function input() */ |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3760 com_node(c, CHILD(n, 0)); |
|
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3761 com_addbyte(c, RETURN_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3762 com_pop(c, 1); |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3763 break; |
|
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3764 |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3765 case lambdef: /* anonymous function definition */ |
|
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3766 compile_lambdef(c, n); |
|
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3767 break; |
|
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3768 |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3769 case funcdef: /* A function definition */ |
| 69 | 3770 compile_funcdef(c, n); |
| 3771 break; | |
| 3772 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3773 case classdef: /* A class definition */ |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3774 compile_classdef(c, n); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3775 break; |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3776 |
| 69 | 3777 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3778 com_error(c, PyExc_SystemError, |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
3779 "compile_node: unexpected node type"); |
| 69 | 3780 } |
| 3781 } | |
| 3782 | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3783 static PyObject * |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3784 dict_keys_inorder(PyObject *dict, int offset) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3785 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3786 PyObject *tuple, *k, *v; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3787 int i, pos = 0, size = PyDict_Size(dict); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3788 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3789 tuple = PyTuple_New(size); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3790 if (tuple == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3791 return NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3792 while (PyDict_Next(dict, &pos, &k, &v)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3793 i = PyInt_AS_LONG(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3794 Py_INCREF(k); |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
3795 assert((i - offset) < size); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3796 PyTuple_SET_ITEM(tuple, i - offset, k); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3797 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3798 return tuple; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3799 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3800 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3801 PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3802 PyNode_Compile(node *n, char *filename) |
| 69 | 3803 { |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3804 return PyNode_CompileFlags(n, filename, NULL); |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3805 } |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3806 |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3807 PyCodeObject * |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3808 PyNode_CompileFlags(node *n, char *filename, PyCompilerFlags *flags) |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3809 { |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3810 return jcompile(n, filename, NULL, flags); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3811 } |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3812 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3813 struct symtable * |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3814 PyNode_CompileSymtable(node *n, char *filename) |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3815 { |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3816 struct symtable *st; |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3817 PyFutureFeatures *ff; |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3818 |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3819 ff = PyNode_Future(n, filename); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3820 if (ff == NULL) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3821 return NULL; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3822 st = symtable_init(); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3823 if (st == NULL) |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3824 return NULL; |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3825 st->st_future = ff; |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3826 symtable_enter_scope(st, TOP, TYPE(n), n->n_lineno); |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3827 if (st->st_errors > 0) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3828 goto fail; |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3829 symtable_node(st, n); |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3830 if (st->st_errors > 0) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3831 goto fail; |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3832 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3833 return st; |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3834 fail: |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3835 PyMem_Free((void *)ff); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3836 st->st_future = NULL; |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3837 PySymtable_Free(st); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
3838 return NULL; |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3839 } |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3840 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3841 static PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3842 icompile(node *n, struct compiling *base) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3843 { |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3844 return jcompile(n, base->c_filename, base, NULL); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3845 } |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3846 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3847 static PyCodeObject * |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3848 jcompile(node *n, char *filename, struct compiling *base, |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3849 PyCompilerFlags *flags) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3850 { |
| 69 | 3851 struct compiling sc; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3852 PyCodeObject *co; |
|
1415
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3853 if (!com_init(&sc, filename)) |
| 69 | 3854 return NULL; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3855 if (base) { |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3856 sc.c_private = base->c_private; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3857 sc.c_symtable = base->c_symtable; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3858 /* c_symtable still points to parent's symbols */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3859 if (base->c_nested |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3860 || (sc.c_symtable->st_cur->ste_type == TYPE_FUNCTION)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3861 sc.c_nested = 1; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3862 } else { |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3863 sc.c_private = NULL; |
|
16799
08d937107fe6
Improved __future__ parser; still more to do
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16783
diff
changeset
|
3864 sc.c_future = PyNode_Future(n, filename); |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3865 if (sc.c_future == NULL) { |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3866 com_free(&sc); |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3867 return NULL; |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3868 } |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3869 if (flags) { |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3870 if (flags->cf_nested_scopes) |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3871 sc.c_future->ff_nested_scopes = 1; |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3872 else if (sc.c_future->ff_nested_scopes) |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3873 flags->cf_nested_scopes = 1; |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3874 } |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
3875 if (symtable_build(&sc, n) < 0) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3876 com_free(&sc); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3877 return NULL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3878 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3879 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3880 co = NULL; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3881 if (symtable_load_symbols(&sc) < 0) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3882 sc.c_errors++; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3883 goto exit; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3884 } |
| 69 | 3885 compile_node(&sc, n); |
| 3886 com_done(&sc); | |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
3887 if (sc.c_errors == 0) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3888 PyObject *consts, *names, *varnames, *filename, *name, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3889 *freevars, *cellvars; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3890 consts = PyList_AsTuple(sc.c_consts); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3891 names = PyList_AsTuple(sc.c_names); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3892 varnames = PyList_AsTuple(sc.c_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3893 cellvars = dict_keys_inorder(sc.c_cellvars, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3894 freevars = dict_keys_inorder(sc.c_freevars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3895 PyTuple_GET_SIZE(cellvars)); |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
3896 filename = PyString_InternFromString(sc.c_filename); |
|
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
3897 name = PyString_InternFromString(sc.c_name); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3898 if (!PyErr_Occurred()) |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3899 co = PyCode_New(sc.c_argcount, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3900 sc.c_nlocals, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3901 sc.c_maxstacklevel, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3902 sc.c_flags, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3903 sc.c_code, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3904 consts, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3905 names, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3906 varnames, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3907 freevars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3908 cellvars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3909 filename, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3910 name, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3911 sc.c_firstlineno, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3912 sc.c_lnotab); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3913 Py_XDECREF(consts); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3914 Py_XDECREF(names); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3915 Py_XDECREF(varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3916 Py_XDECREF(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3917 Py_XDECREF(cellvars); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3918 Py_XDECREF(filename); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3919 Py_XDECREF(name); |
|
266
b5826bf29677
Changed and exported newcodeobject() interface, for ".pyc" files.
Guido van Rossum <guido@python.org>
parents:
238
diff
changeset
|
3920 } |
|
13884
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3921 else if (!PyErr_Occurred()) { |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3922 /* This could happen if someone called PyErr_Clear() after an |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3923 error was reported above. That's not supposed to happen, |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3924 but I just plugged one case and I'm not sure there can't be |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3925 others. In that case, raise SystemError so that at least |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3926 it gets reported instead dumping core. */ |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3927 PyErr_SetString(PyExc_SystemError, "lost syntax error"); |
|
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
3928 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3929 exit: |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
3930 if (base == NULL) { |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
3931 PySymtable_Free(sc.c_symtable); |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
3932 sc.c_symtable = NULL; |
|
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
3933 } |
| 69 | 3934 com_free(&sc); |
| 3935 return co; | |
| 3936 } | |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3937 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3938 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3939 PyCode_Addr2Line(PyCodeObject *co, int addrq) |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3940 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3941 int size = PyString_Size(co->co_lnotab) / 2; |
| 11290 | 3942 unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab); |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3943 int line = co->co_firstlineno; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3944 int addr = 0; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3945 while (--size >= 0) { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3946 addr += *p++; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3947 if (addr > addrq) |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3948 break; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3949 line += *p++; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3950 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3951 return line; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
3952 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3953 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3954 /* The test for LOCAL must come before the test for FREE in order to |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3955 handle classes where name is both local and free. The local var is |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3956 a method and the free var is a free var referenced within a method. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3957 */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3958 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3959 static int |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3960 get_ref_type(struct compiling *c, char *name) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3961 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3962 PyObject *v; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3963 if (c->c_symtable->st_nested_scopes) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3964 if (PyDict_GetItemString(c->c_cellvars, name) != NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3965 return CELL; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3966 if (PyDict_GetItemString(c->c_locals, name) != NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3967 return LOCAL; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3968 if (PyDict_GetItemString(c->c_freevars, name) != NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3969 return FREE; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3970 v = PyDict_GetItemString(c->c_globals, name); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3971 if (v) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3972 if (v == Py_None) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3973 return GLOBAL_EXPLICIT; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3974 else { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3975 return GLOBAL_IMPLICIT; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3976 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3977 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3978 } else { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3979 if (PyDict_GetItemString(c->c_locals, name) != NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3980 return LOCAL; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3981 v = PyDict_GetItemString(c->c_globals, name); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3982 if (v) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3983 if (v == Py_None) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3984 return GLOBAL_EXPLICIT; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3985 else { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3986 return GLOBAL_IMPLICIT; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
3987 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3988 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3989 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3990 { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3991 char buf[350]; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3992 sprintf(buf, |
|
16878
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
3993 "unknown scope for %.100s in %.100s(%s) " |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
3994 "in %s\nsymbols: %s\nlocals: %s\nglobals: %s\n", |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
3995 name, c->c_name, |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
3996 PyObject_REPR(c->c_symtable->st_cur->ste_id), |
|
16878
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
3997 c->c_filename, |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
3998 PyObject_REPR(c->c_symtable->st_cur->ste_symbols), |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
3999 PyObject_REPR(c->c_locals), |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4000 PyObject_REPR(c->c_globals) |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4001 ); |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4002 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4003 Py_FatalError(buf); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4004 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4005 return -1; /* can't get here */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4006 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4007 |
|
16933
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4008 /* Helper functions to issue warnings */ |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4009 |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4010 static int |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4011 issue_warning(char *msg, char *filename, int lineno) |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4012 { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4013 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, filename, |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4014 lineno, NULL, NULL) < 0) { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4015 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4016 PyErr_SetString(PyExc_SyntaxError, msg); |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4017 PyErr_SyntaxLocation(filename, lineno); |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4018 } |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4019 return -1; |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4020 } |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4021 return 0; |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4022 } |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4023 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4024 static int |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4025 symtable_warn(struct symtable *st, char *msg) |
|
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4026 { |
|
16933
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4027 if (issue_warning(msg, st->st_filename, st->st_cur->ste_lineno) < 0) { |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4028 st->st_errors++; |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4029 return -1; |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4030 } |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4031 return 0; |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4032 } |
|
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4033 |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
4034 /* Helper function for setting lineno and filename */ |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
4035 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4036 static int |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4037 symtable_build(struct compiling *c, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4038 { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4039 if ((c->c_symtable = symtable_init()) == NULL) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4040 return -1; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4041 c->c_symtable->st_future = c->c_future; |
|
16799
08d937107fe6
Improved __future__ parser; still more to do
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16783
diff
changeset
|
4042 if (c->c_future->ff_nested_scopes) |
|
08d937107fe6
Improved __future__ parser; still more to do
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16783
diff
changeset
|
4043 c->c_symtable->st_nested_scopes = 1; |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
4044 c->c_symtable->st_filename = c->c_filename; |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4045 symtable_enter_scope(c->c_symtable, TOP, TYPE(n), n->n_lineno); |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4046 if (c->c_symtable->st_errors > 0) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4047 return -1; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4048 symtable_node(c->c_symtable, n); |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4049 if (c->c_symtable->st_errors > 0) |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4050 return -1; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4051 /* reset for second pass */ |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4052 c->c_symtable->st_nscopes = 1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4053 c->c_symtable->st_pass = 2; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4054 return 0; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4055 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4056 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4057 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4058 symtable_init_compiling_symbols(struct compiling *c) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4059 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4060 PyObject *varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4061 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4062 varnames = c->c_symtable->st_cur->ste_varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4063 if (varnames == NULL) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4064 varnames = PyList_New(0); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4065 if (varnames == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4066 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4067 c->c_symtable->st_cur->ste_varnames = varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4068 Py_INCREF(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4069 } else |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4070 Py_INCREF(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4071 c->c_varnames = varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4072 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4073 c->c_globals = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4074 if (c->c_globals == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4075 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4076 c->c_freevars = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4077 if (c->c_freevars == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4078 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4079 c->c_cellvars = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4080 if (c->c_cellvars == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4081 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4082 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4083 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4084 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4085 struct symbol_info { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4086 int si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4087 int si_ncells; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4088 int si_nfrees; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4089 int si_nimplicit; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4090 }; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4091 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4092 static void |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4093 symtable_init_info(struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4094 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4095 si->si_nlocals = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4096 si->si_ncells = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4097 si->si_nfrees = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4098 si->si_nimplicit = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4099 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4100 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4101 static int |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4102 symtable_resolve_free(struct compiling *c, PyObject *name, int flags, |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4103 struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4104 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4105 PyObject *dict, *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4106 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4107 /* Seperate logic for DEF_FREE. If it occurs in a function, |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4108 it indicates a local that we must allocate storage for (a |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4109 cell var). If it occurs in a class, then the class has a |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4110 method and a free variable with the same name. |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4111 */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4112 if (c->c_symtable->st_cur->ste_type == TYPE_FUNCTION) { |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4113 /* If it isn't declared locally, it can't be a cell. */ |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4114 if (!(flags & (DEF_LOCAL | DEF_PARAM))) |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4115 return 0; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4116 v = PyInt_FromLong(si->si_ncells++); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4117 dict = c->c_cellvars; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4118 } else { |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4119 /* If it is free anyway, then there is no need to do |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4120 anything here. |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4121 */ |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4122 if (is_free(flags ^ DEF_FREE_CLASS) |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4123 || (flags == DEF_FREE_CLASS)) |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4124 return 0; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4125 v = PyInt_FromLong(si->si_nfrees++); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4126 dict = c->c_freevars; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4127 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4128 if (v == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4129 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4130 if (PyDict_SetItem(dict, name, v) < 0) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4131 Py_DECREF(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4132 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4133 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4134 Py_DECREF(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4135 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4136 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4137 |
|
17104
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4138 /* If a variable is a cell and an argument, make sure that appears in |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4139 co_cellvars before any variable to its right in varnames. |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4140 */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4141 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4142 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4143 static int |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4144 symtable_cellvar_offsets(PyObject **cellvars, int argcount, |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4145 PyObject *varnames, int flags) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4146 { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4147 PyObject *v, *w, *d, *list = NULL; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4148 int i, pos; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4149 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4150 if (flags & CO_VARARGS) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4151 argcount++; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4152 if (flags & CO_VARKEYWORDS) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4153 argcount++; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4154 for (i = argcount; --i >= 0; ) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4155 v = PyList_GET_ITEM(varnames, i); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4156 if (PyDict_GetItem(*cellvars, v)) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4157 if (list == NULL) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4158 list = PyList_New(1); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4159 if (list == NULL) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4160 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4161 PyList_SET_ITEM(list, 0, v); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4162 Py_INCREF(v); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4163 } else |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4164 PyList_Insert(list, 0, v); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4165 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4166 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4167 if (list == NULL || PyList_GET_SIZE(list) == 0) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4168 return 0; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4169 /* There are cellvars that are also arguments. Create a dict |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4170 to replace cellvars and put the args at the front. |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4171 */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4172 d = PyDict_New(); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4173 for (i = PyList_GET_SIZE(list); --i >= 0; ) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4174 v = PyInt_FromLong(i); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4175 if (v == NULL) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4176 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4177 if (PyDict_SetItem(d, PyList_GET_ITEM(list, i), v) < 0) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4178 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4179 if (PyDict_DelItem(*cellvars, PyList_GET_ITEM(list, i)) < 0) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4180 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4181 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4182 pos = 0; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4183 i = PyList_GET_SIZE(list); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4184 Py_DECREF(list); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4185 while (PyDict_Next(*cellvars, &pos, &v, &w)) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4186 w = PyInt_FromLong(i++); /* don't care about the old key */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4187 if (PyDict_SetItem(d, v, w) < 0) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4188 Py_DECREF(w); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4189 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4190 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4191 Py_DECREF(w); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4192 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4193 Py_DECREF(*cellvars); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4194 *cellvars = d; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4195 return 1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4196 fail: |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4197 Py_DECREF(d); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4198 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4199 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4200 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4201 static int |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4202 symtable_freevar_offsets(PyObject *freevars, int offset) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4203 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4204 PyObject *name, *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4205 int pos; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4206 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4207 /* The cell vars are the first elements of the closure, |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4208 followed by the free vars. Update the offsets in |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4209 c_freevars to account for number of cellvars. */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4210 pos = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4211 while (PyDict_Next(freevars, &pos, &name, &v)) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4212 int i = PyInt_AS_LONG(v) + offset; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4213 PyObject *o = PyInt_FromLong(i); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4214 if (o == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4215 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4216 if (PyDict_SetItem(freevars, name, o) < 0) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4217 Py_DECREF(o); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4218 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4219 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4220 Py_DECREF(o); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4221 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4222 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4223 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4224 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4225 static int |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4226 symtable_check_unoptimized(struct compiling *c, |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4227 PySymtableEntryObject *ste, |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4228 struct symbol_info *si) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4229 { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4230 char buf[300]; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4231 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4232 if (!(si->si_ncells || si->si_nfrees || ste->ste_child_free |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4233 || (ste->ste_nested && si->si_nimplicit))) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4234 return 0; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4235 |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4236 #define ILLEGAL_CONTAINS "contains a nested function with free variables" |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4237 |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4238 #define ILLEGAL_IS "is a nested function" |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4239 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4240 #define ILLEGAL_IMPORT_STAR \ |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4241 "import * is not allowed in function '%.100s' because it %s" |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4242 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4243 #define ILLEGAL_BARE_EXEC \ |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4244 "unqualified exec is not allowed in function '%.100s' it %s" |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4245 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4246 #define ILLEGAL_EXEC_AND_IMPORT_STAR \ |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4247 "function '%.100s' uses import * and bare exec, which are illegal" \ |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4248 "because it %s" |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4249 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4250 /* XXX perhaps the linenos for these opt-breaking statements |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4251 should be stored so the exception can point to them. */ |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4252 |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4253 if (ste->ste_child_free) { |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4254 if (ste->ste_optimized == OPT_IMPORT_STAR) |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4255 sprintf(buf, ILLEGAL_IMPORT_STAR, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4256 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4257 ILLEGAL_CONTAINS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4258 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC)) |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4259 sprintf(buf, ILLEGAL_BARE_EXEC, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4260 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4261 ILLEGAL_CONTAINS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4262 else { |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4263 sprintf(buf, ILLEGAL_EXEC_AND_IMPORT_STAR, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4264 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4265 ILLEGAL_CONTAINS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4266 } |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4267 } else { |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4268 if (ste->ste_optimized == OPT_IMPORT_STAR) |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4269 sprintf(buf, ILLEGAL_IMPORT_STAR, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4270 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4271 ILLEGAL_IS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4272 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC)) |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4273 sprintf(buf, ILLEGAL_BARE_EXEC, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4274 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4275 ILLEGAL_IS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4276 else { |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4277 sprintf(buf, ILLEGAL_EXEC_AND_IMPORT_STAR, |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4278 PyString_AS_STRING(ste->ste_name), |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4279 ILLEGAL_IS); |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4280 } |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4281 } |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4282 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4283 if (c->c_symtable->st_nested_scopes) { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4284 PyErr_SetString(PyExc_SyntaxError, buf); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4285 PyErr_SyntaxLocation(c->c_symtable->st_filename, |
|
17132
55218e0495bc
Set the line number correctly for a nested function with an exec or
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17131
diff
changeset
|
4286 ste->ste_opt_lineno); |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4287 return -1; |
|
16933
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4288 } |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4289 else { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4290 return issue_warning(buf, c->c_filename, ste->ste_lineno); |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4291 } |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4292 return 0; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4293 } |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4294 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4295 static int |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4296 symtable_check_shadow(struct symtable *st, PyObject *name, int flags) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4297 { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4298 char buf[500]; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4299 PyObject *children, *v; |
|
16871
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
4300 PySymtableEntryObject *child = NULL; |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4301 int i; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4302 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4303 if (!(flags & DEF_BOUND)) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4304 return 0; |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4305 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4306 /* The semantics of this code will change with nested scopes. |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4307 It is defined in the current scope and referenced in a |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4308 child scope. Under the old rules, the child will see a |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4309 global. Under the new rules, the child will see the |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4310 binding in the current scope. |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4311 */ |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4312 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4313 /* Find name of child function that has free variable */ |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4314 children = st->st_cur->ste_children; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4315 for (i = 0; i < PyList_GET_SIZE(children); i++) { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4316 int cflags; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4317 child = (PySymtableEntryObject *)PyList_GET_ITEM(children, i); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4318 v = PyDict_GetItem(child->ste_symbols, name); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4319 if (v == NULL) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4320 continue; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4321 cflags = PyInt_AS_LONG(v); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4322 if (!(cflags & DEF_BOUND)) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4323 break; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4324 } |
|
16871
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
4325 |
|
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
4326 assert(child != NULL); |
|
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
4327 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4328 sprintf(buf, "local name '%.100s' in '%.100s' shadows " |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4329 "use of '%.100s' as global in nested scope '%.100s'", |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4330 PyString_AS_STRING(name), |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4331 PyString_AS_STRING(st->st_cur->ste_name), |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4332 PyString_AS_STRING(name), |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4333 PyString_AS_STRING(child->ste_name) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4334 ); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4335 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4336 return symtable_warn(st, buf); |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4337 } |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4338 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4339 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4340 symtable_update_flags(struct compiling *c, PySymtableEntryObject *ste, |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4341 struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4342 { |
|
17124
a8301d4ed2b1
If a code object is compiled with nested scopes, define the CO_NESTED flag.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17112
diff
changeset
|
4343 if (c->c_future && c->c_future->ff_nested_scopes) |
|
a8301d4ed2b1
If a code object is compiled with nested scopes, define the CO_NESTED flag.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17112
diff
changeset
|
4344 c->c_flags |= CO_NESTED; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4345 if (ste->ste_type != TYPE_MODULE) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4346 c->c_flags |= CO_NEWLOCALS; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4347 if (ste->ste_type == TYPE_FUNCTION) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4348 c->c_nlocals = si->si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4349 if (ste->ste_optimized == 0) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4350 c->c_flags |= CO_OPTIMIZED; |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4351 else if (ste->ste_optimized != OPT_EXEC) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4352 return symtable_check_unoptimized(c, ste, si); |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4353 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4354 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4355 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4356 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4357 static int |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4358 symtable_load_symbols(struct compiling *c) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4359 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4360 static PyObject *implicit = NULL; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4361 struct symtable *st = c->c_symtable; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4362 PySymtableEntryObject *ste = st->st_cur; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4363 PyObject *name, *varnames, *v; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4364 int i, flags, pos; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4365 struct symbol_info si; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4366 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4367 if (implicit == NULL) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4368 implicit = PyInt_FromLong(1); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4369 if (implicit == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4370 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4371 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4372 v = NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4373 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4374 if (symtable_init_compiling_symbols(c) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4375 goto fail; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4376 symtable_init_info(&si); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4377 varnames = st->st_cur->ste_varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4378 si.si_nlocals = PyList_GET_SIZE(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4379 c->c_argcount = si.si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4380 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4381 for (i = 0; i < si.si_nlocals; ++i) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4382 v = PyInt_FromLong(i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4383 if (PyDict_SetItem(c->c_locals, |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4384 PyList_GET_ITEM(varnames, i), v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4385 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4386 Py_DECREF(v); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4387 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4388 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4389 /* XXX The cases below define the rules for whether a name is |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4390 local or global. The logic could probably be clearer. */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4391 pos = 0; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4392 while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4393 flags = PyInt_AS_LONG(v); |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4394 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4395 if (st->st_nested_scopes == 0 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4396 && (flags & (DEF_FREE | DEF_FREE_CLASS))) { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4397 if (symtable_check_shadow(st, name, flags) < 0) |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4398 goto fail; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4399 } |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4400 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4401 if (flags & DEF_FREE_GLOBAL) |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4402 /* undo the original DEF_FREE */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4403 flags &= ~(DEF_FREE | DEF_FREE_CLASS); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4404 |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4405 /* Deal with names that need two actions: |
|
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4406 1. Cell variables, which are also locals. |
|
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4407 2. Free variables in methods that are also class |
|
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4408 variables or declared global. |
|
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4409 */ |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4410 if (st->st_nested_scopes) { |
|
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4411 if (flags & (DEF_FREE | DEF_FREE_CLASS)) { |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4412 symtable_resolve_free(c, name, flags, &si); |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4413 } |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4414 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4415 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4416 if (flags & DEF_STAR) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4417 c->c_argcount--; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4418 c->c_flags |= CO_VARARGS; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4419 } else if (flags & DEF_DOUBLESTAR) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4420 c->c_argcount--; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4421 c->c_flags |= CO_VARKEYWORDS; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4422 } else if (flags & DEF_INTUPLE) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4423 c->c_argcount--; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4424 else if (flags & DEF_GLOBAL) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4425 if (flags & DEF_PARAM) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4426 PyErr_Format(PyExc_SyntaxError, LOCAL_GLOBAL, |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
4427 PyString_AS_STRING(name)); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
4428 PyErr_SyntaxLocation(st->st_filename, |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4429 ste->ste_lineno); |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4430 st->st_errors++; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4431 goto fail; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4432 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4433 if (PyDict_SetItem(c->c_globals, name, Py_None) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4434 goto fail; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4435 } else if (flags & DEF_FREE_GLOBAL) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4436 si.si_nimplicit++; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4437 if (PyDict_SetItem(c->c_globals, name, implicit) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4438 goto fail; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4439 } else if ((flags & DEF_LOCAL) && !(flags & DEF_PARAM)) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4440 v = PyInt_FromLong(si.si_nlocals++); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4441 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4442 goto fail; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4443 if (PyDict_SetItem(c->c_locals, name, v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4444 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4445 Py_DECREF(v); |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4446 if (ste->ste_type != TYPE_CLASS) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4447 if (PyList_Append(c->c_varnames, name) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4448 goto fail; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4449 } else if (is_free(flags)) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4450 if (ste->ste_nested && st->st_nested_scopes) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4451 v = PyInt_FromLong(si.si_nfrees++); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4452 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4453 goto fail; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4454 if (PyDict_SetItem(c->c_freevars, name, v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4455 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4456 Py_DECREF(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4457 } else { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4458 si.si_nimplicit++; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4459 if (PyDict_SetItem(c->c_globals, name, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4460 implicit) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4461 goto fail; |
|
16878
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4462 if (st->st_nscopes != 1) { |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4463 v = PyInt_FromLong(flags); |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4464 if (PyDict_SetItem(st->st_global, |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4465 name, v)) |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4466 goto fail; |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4467 Py_DECREF(v); |
|
1cf52536c381
Don't add global names to st->st_global if we're already iterating
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16873
diff
changeset
|
4468 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4469 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4470 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4471 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4472 |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4473 assert(PyDict_Size(c->c_freevars) == si.si_nfrees); |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4474 |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4475 if (st->st_nested_scopes == 0) |
|
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4476 assert(si.si_nfrees == 0); |
|
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4477 |
|
17104
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4478 if (si.si_ncells > 1) { /* one cell is always in order */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4479 if (symtable_cellvar_offsets(&c->c_cellvars, c->c_argcount, |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4480 c->c_varnames, c->c_flags) < 0) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4481 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4482 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4483 if (symtable_freevar_offsets(c->c_freevars, si.si_ncells) < 0) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4484 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4485 return symtable_update_flags(c, ste, &si); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4486 fail: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4487 /* is this always the right thing to do? */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4488 Py_XDECREF(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4489 return -1; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4490 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4491 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4492 static struct symtable * |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4493 symtable_init() |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4494 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4495 struct symtable *st; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4496 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4497 st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4498 if (st == NULL) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4499 return NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4500 st->st_pass = 1; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4501 st->st_nested_scopes = NESTED_SCOPES_DEFAULT; |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
4502 st->st_filename = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4503 if ((st->st_stack = PyList_New(0)) == NULL) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4504 goto fail; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4505 if ((st->st_symbols = PyDict_New()) == NULL) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4506 goto fail; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4507 st->st_cur = NULL; |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4508 st->st_nscopes = 0; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4509 st->st_errors = 0; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4510 st->st_tmpname = 0; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4511 st->st_private = NULL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4512 return st; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4513 fail: |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4514 PySymtable_Free(st); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4515 return NULL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4516 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4517 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4518 void |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4519 PySymtable_Free(struct symtable *st) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4520 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4521 Py_XDECREF(st->st_symbols); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4522 Py_XDECREF(st->st_stack); |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4523 Py_XDECREF(st->st_cur); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4524 PyMem_Free((void *)st); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4525 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4526 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4527 /* When the compiler exits a scope, it must should update the scope's |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4528 free variable information with the list of free variables in its |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4529 children. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4530 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4531 Variables that are free in children and defined in the current |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4532 scope are cellvars. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4533 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4534 If the scope being exited is defined at the top-level (ste_nested is |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4535 false), free variables in children that are not defined here are |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4536 implicit globals. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4537 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4538 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4539 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4540 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4541 symtable_update_free_vars(struct symtable *st) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4542 { |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4543 int i, j, def; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4544 PyObject *o, *name, *list = NULL; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4545 PySymtableEntryObject *child, *ste = st->st_cur; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4546 |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4547 if (ste->ste_type == TYPE_CLASS) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4548 def = DEF_FREE_CLASS; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4549 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4550 def = DEF_FREE; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4551 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4552 int pos = 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4553 |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4554 if (list) |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4555 PyList_SetSlice(list, 0, |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4556 ((PyVarObject*)list)->ob_size, 0); |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4557 child = (PySymtableEntryObject *) |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4558 PyList_GET_ITEM(ste->ste_children, i); |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4559 while (PyDict_Next(child->ste_symbols, &pos, &name, &o)) { |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4560 int flags = PyInt_AS_LONG(o); |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4561 if (!(is_free(flags))) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4562 continue; /* avoids indentation */ |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4563 if (list == NULL) { |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4564 list = PyList_New(0); |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4565 if (list == NULL) |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4566 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4567 } |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4568 ste->ste_child_free = 1; |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4569 if (PyList_Append(list, name) < 0) { |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4570 Py_DECREF(list); |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4571 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4572 } |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4573 } |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4574 for (j = 0; list && j < PyList_GET_SIZE(list); j++) { |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4575 PyObject *v; |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4576 name = PyList_GET_ITEM(list, j); |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4577 v = PyDict_GetItem(ste->ste_symbols, name); |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4578 /* If a name N is declared global in scope A and |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4579 referenced in scope B contained (perhaps |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4580 indirectly) in A and there are no scopes |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4581 with bindings for N between B and A, then N |
|
17702
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4582 is global in B. Unless A is a class scope, |
|
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4583 because class scopes are not considered for |
|
e3f0fd38c24b
Several small changes. Mostly reformatting, adding parens.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17637
diff
changeset
|
4584 nested scopes. |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4585 */ |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4586 if (v && (ste->ste_type != TYPE_CLASS)) { |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4587 int flags = PyInt_AS_LONG(v); |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4588 if (flags & DEF_GLOBAL) { |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4589 symtable_undo_free(st, child->ste_id, |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4590 name); |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4591 continue; |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4592 } |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4593 } |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4594 if (ste->ste_nested) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4595 if (symtable_add_def_o(st, ste->ste_symbols, |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4596 name, def) < 0) { |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4597 Py_DECREF(list); |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4598 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4599 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4600 } else { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4601 if (symtable_check_global(st, child->ste_id, |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4602 name) < 0) { |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4603 Py_DECREF(list); |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4604 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4605 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4606 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4607 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4608 } |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4609 |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4610 Py_XDECREF(list); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4611 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4612 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4613 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4614 /* If the current scope is a non-nested class or if name is not |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4615 defined in the current, non-nested scope, then it is an implicit |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4616 global in all nested scopes. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4617 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4618 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4619 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4620 symtable_check_global(struct symtable *st, PyObject *child, PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4621 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4622 PyObject *o; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4623 int v; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4624 PySymtableEntryObject *ste = st->st_cur; |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4625 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4626 if (ste->ste_type == TYPE_CLASS) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4627 return symtable_undo_free(st, child, name); |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4628 o = PyDict_GetItem(ste->ste_symbols, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4629 if (o == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4630 return symtable_undo_free(st, child, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4631 v = PyInt_AS_LONG(o); |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4632 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4633 if (is_free(v) || (v & DEF_GLOBAL)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4634 return symtable_undo_free(st, child, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4635 else |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4636 return symtable_add_def_o(st, ste->ste_symbols, |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4637 name, DEF_FREE); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4638 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4639 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4640 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4641 symtable_undo_free(struct symtable *st, PyObject *id, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4642 PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4643 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4644 int i, v, x; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4645 PyObject *info; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4646 PySymtableEntryObject *ste; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4647 |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4648 ste = (PySymtableEntryObject *)PyDict_GetItem(st->st_symbols, id); |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4649 if (ste == NULL) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4650 return -1; |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4651 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4652 info = PyDict_GetItem(ste->ste_symbols, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4653 if (info == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4654 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4655 v = PyInt_AS_LONG(info); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4656 if (is_free(v)) { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4657 if (symtable_add_def_o(st, ste->ste_symbols, name, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4658 DEF_FREE_GLOBAL) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4659 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4660 } else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4661 /* If the name is defined here or declared global, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4662 then the recursion stops. */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4663 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4664 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4665 for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4666 PySymtableEntryObject *child; |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4667 child = (PySymtableEntryObject *) |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4668 PyList_GET_ITEM(ste->ste_children, i); |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4669 x = symtable_undo_free(st, child->ste_id, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4670 if (x < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4671 return x; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4672 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4673 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4674 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4675 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4676 /* symtable_enter_scope() gets a reference via PySymtableEntry_New(). |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4677 This reference is released when the scope is exited, via the DECREF |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4678 in symtable_exit_scope(). |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4679 */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4680 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4681 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4682 symtable_exit_scope(struct symtable *st) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4683 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4684 int end; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4685 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4686 if (st->st_pass == 1) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4687 symtable_update_free_vars(st); |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4688 Py_DECREF(st->st_cur); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4689 end = PyList_GET_SIZE(st->st_stack) - 1; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4690 st->st_cur = (PySymtableEntryObject *)PyList_GET_ITEM(st->st_stack, |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4691 end); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4692 if (PySequence_DelItem(st->st_stack, end) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4693 return -1; |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4694 return 0; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4695 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4696 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4697 static void |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4698 symtable_enter_scope(struct symtable *st, char *name, int type, |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4699 int lineno) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4700 { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4701 PySymtableEntryObject *prev = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4702 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4703 if (st->st_cur) { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4704 prev = st->st_cur; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4705 if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) { |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4706 Py_DECREF(st->st_cur); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4707 st->st_errors++; |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4708 return; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4709 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4710 } |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4711 st->st_cur = (PySymtableEntryObject *) |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4712 PySymtableEntry_New(st, name, type, lineno); |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4713 if (strcmp(name, TOP) == 0) |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4714 st->st_global = st->st_cur->ste_symbols; |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4715 if (prev && st->st_pass == 1) { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4716 if (PyList_Append(prev->ste_children, |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4717 (PyObject *)st->st_cur) < 0) |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4718 st->st_errors++; |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4719 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4720 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4721 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4722 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4723 symtable_lookup(struct symtable *st, char *name) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4724 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4725 char buffer[MANGLE_LEN]; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4726 PyObject *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4727 int flags; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4728 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4729 if (mangle(st->st_private, name, buffer, sizeof(buffer))) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4730 name = buffer; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4731 v = PyDict_GetItemString(st->st_cur->ste_symbols, name); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4732 if (v == NULL) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4733 if (PyErr_Occurred()) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4734 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4735 else |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4736 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4737 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4738 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4739 flags = PyInt_AS_LONG(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4740 return flags; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4741 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4742 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4743 static int |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4744 symtable_add_def(struct symtable *st, char *name, int flag) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4745 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4746 PyObject *s; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4747 char buffer[MANGLE_LEN]; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4748 int ret; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4749 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4750 if (mangle(st->st_private, name, buffer, sizeof(buffer))) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4751 name = buffer; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4752 if ((s = PyString_InternFromString(name)) == NULL) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4753 return -1; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4754 ret = symtable_add_def_o(st, st->st_cur->ste_symbols, s, flag); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4755 Py_DECREF(s); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4756 return ret; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4757 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4758 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4759 /* Must only be called with mangled names */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4760 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4761 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4762 symtable_add_def_o(struct symtable *st, PyObject *dict, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4763 PyObject *name, int flag) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4764 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4765 PyObject *o; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4766 int val; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4767 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4768 if ((o = PyDict_GetItem(dict, name))) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4769 val = PyInt_AS_LONG(o); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4770 if ((flag & DEF_PARAM) && (val & DEF_PARAM)) { |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4771 PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT, |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
4772 PyString_AsString(name)); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
4773 PyErr_SyntaxLocation(st->st_filename, |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4774 st->st_cur->ste_lineno); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4775 return -1; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4776 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4777 val |= flag; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4778 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4779 val = flag; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4780 o = PyInt_FromLong(val); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4781 if (PyDict_SetItem(dict, name, o) < 0) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4782 Py_DECREF(o); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4783 return -1; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4784 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4785 Py_DECREF(o); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4786 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4787 if (flag & DEF_PARAM) { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4788 if (PyList_Append(st->st_cur->ste_varnames, name) < 0) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4789 return -1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4790 } else if (flag & DEF_GLOBAL) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4791 /* XXX need to update DEF_GLOBAL for other flags too; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4792 perhaps only DEF_FREE_GLOBAL */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4793 if ((o = PyDict_GetItem(st->st_global, name))) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4794 val = PyInt_AS_LONG(o); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4795 val |= flag; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4796 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4797 val = flag; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4798 o = PyInt_FromLong(val); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4799 if (PyDict_SetItem(st->st_global, name, o) < 0) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4800 Py_DECREF(o); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4801 return -1; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4802 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4803 Py_DECREF(o); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4804 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4805 return 0; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4806 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4807 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4808 #define symtable_add_use(ST, NAME) symtable_add_def((ST), (NAME), USE) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4809 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4810 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4811 symtable_node(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4812 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4813 int i, start = 0; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4814 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4815 loop: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4816 switch (TYPE(n)) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4817 case funcdef: { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4818 char *func_name = STR(CHILD(n, 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4819 symtable_add_def(st, func_name, DEF_LOCAL); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4820 symtable_default_args(st, CHILD(n, 2)); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4821 symtable_enter_scope(st, func_name, TYPE(n), n->n_lineno); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4822 symtable_funcdef(st, n); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4823 symtable_exit_scope(st); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4824 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4825 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4826 case lambdef: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4827 if (NCH(n) == 4) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4828 symtable_default_args(st, CHILD(n, 1)); |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4829 symtable_enter_scope(st, "lambda", TYPE(n), n->n_lineno); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4830 symtable_funcdef(st, n); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4831 symtable_exit_scope(st); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4832 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4833 case classdef: { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4834 char *tmp, *class_name = STR(CHILD(n, 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4835 symtable_add_def(st, class_name, DEF_LOCAL); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4836 if (TYPE(CHILD(n, 2)) == LPAR) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4837 node *bases = CHILD(n, 3); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4838 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4839 for (i = 0; i < NCH(bases); i += 2) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4840 symtable_node(st, CHILD(bases, i)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4841 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4842 } |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4843 symtable_enter_scope(st, class_name, TYPE(n), n->n_lineno); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4844 tmp = st->st_private; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4845 st->st_private = class_name; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4846 symtable_node(st, CHILD(n, NCH(n) - 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4847 st->st_private = tmp; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4848 symtable_exit_scope(st); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4849 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4850 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4851 case if_stmt: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4852 for (i = 0; i + 3 < NCH(n); i += 4) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4853 if (is_constant_false(NULL, (CHILD(n, i + 1)))) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4854 continue; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4855 symtable_node(st, CHILD(n, i + 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4856 symtable_node(st, CHILD(n, i + 3)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4857 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4858 if (i + 2 < NCH(n)) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4859 symtable_node(st, CHILD(n, i + 2)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4860 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4861 case global_stmt: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4862 symtable_global(st, n); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4863 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4864 case import_stmt: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4865 symtable_import(st, n); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4866 break; |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
4867 case exec_stmt: { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4868 st->st_cur->ste_optimized |= OPT_EXEC; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4869 symtable_node(st, CHILD(n, 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4870 if (NCH(n) > 2) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4871 symtable_node(st, CHILD(n, 3)); |
|
17132
55218e0495bc
Set the line number correctly for a nested function with an exec or
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17131
diff
changeset
|
4872 else { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4873 st->st_cur->ste_optimized |= OPT_BARE_EXEC; |
|
17132
55218e0495bc
Set the line number correctly for a nested function with an exec or
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17131
diff
changeset
|
4874 st->st_cur->ste_opt_lineno = n->n_lineno; |
|
55218e0495bc
Set the line number correctly for a nested function with an exec or
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17131
diff
changeset
|
4875 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4876 if (NCH(n) > 4) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4877 symtable_node(st, CHILD(n, 5)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4878 break; |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
4879 |
|
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
4880 } |
|
16680
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4881 case assert_stmt: |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4882 if (Py_OptimizeFlag) |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4883 return; |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4884 if (NCH(n) == 2) { |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4885 n = CHILD(n, 1); |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4886 goto loop; |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4887 } else { |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4888 symtable_node(st, CHILD(n, 1)); |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4889 n = CHILD(n, 3); |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4890 goto loop; |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
4891 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4892 case except_clause: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4893 if (NCH(n) == 4) |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4894 symtable_assign(st, CHILD(n, 3), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4895 if (NCH(n) > 1) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4896 n = CHILD(n, 1); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4897 goto loop; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4898 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4899 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4900 case del_stmt: |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4901 symtable_assign(st, CHILD(n, 1), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4902 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4903 case expr_stmt: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4904 if (NCH(n) == 1) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4905 n = CHILD(n, 0); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4906 else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4907 if (TYPE(CHILD(n, 1)) == augassign) { |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4908 symtable_assign(st, CHILD(n, 0), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4909 symtable_node(st, CHILD(n, 2)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4910 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4911 } else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4912 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4913 for (i = 0; i < NCH(n) - 2; i += 2) |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4914 symtable_assign(st, CHILD(n, i), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4915 n = CHILD(n, NCH(n) - 1); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4916 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4917 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4918 goto loop; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4919 /* watchout for fall-through logic below */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4920 case argument: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4921 if (NCH(n) == 3) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4922 n = CHILD(n, 2); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4923 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4924 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4925 case listmaker: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4926 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) { |
|
17076
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
4927 st->st_tmpname++; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4928 symtable_list_comprehension(st, CHILD(n, 1)); |
|
17076
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
4929 symtable_node(st, CHILD(n, 0)); |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
4930 st->st_tmpname--; |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
4931 return; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4932 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4933 case atom: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4934 if (TYPE(n) == atom && TYPE(CHILD(n, 0)) == NAME) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4935 symtable_add_use(st, STR(CHILD(n, 0))); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4936 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4937 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4938 case for_stmt: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4939 if (TYPE(n) == for_stmt) { |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4940 symtable_assign(st, CHILD(n, 1), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4941 start = 3; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4942 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4943 default: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4944 if (NCH(n) == 1) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4945 n = CHILD(n, 0); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4946 goto loop; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4947 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4948 for (i = start; i < NCH(n); ++i) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4949 if (TYPE(CHILD(n, i)) >= single_input) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4950 symtable_node(st, CHILD(n, i)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4951 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4952 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4953 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4954 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4955 symtable_funcdef(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4956 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4957 node *body; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4958 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4959 if (TYPE(n) == lambdef) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4960 if (NCH(n) == 4) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4961 symtable_params(st, CHILD(n, 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4962 } else |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4963 symtable_params(st, CHILD(n, 2)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4964 body = CHILD(n, NCH(n) - 1); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4965 symtable_node(st, body); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4966 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4967 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4968 /* The next two functions parse the argument tuple. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4969 symtable_default_arg() checks for names in the default arguments, |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4970 which are references in the defining scope. symtable_params() |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4971 parses the parameter names, which are defined in the function's |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4972 body. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4973 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4974 varargslist: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4975 (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4976 | fpdef ['=' test] (',' fpdef ['=' test])* [','] |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4977 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4978 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4979 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4980 symtable_default_args(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4981 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4982 node *c; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4983 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4984 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4985 if (TYPE(n) == parameters) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4986 n = CHILD(n, 1); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4987 if (TYPE(n) == RPAR) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4988 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4989 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4990 REQ(n, varargslist); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4991 for (i = 0; i < NCH(n); i += 2) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4992 c = CHILD(n, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4993 if (TYPE(c) == STAR || TYPE(c) == DOUBLESTAR) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4994 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4995 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4996 if (i > 0 && (TYPE(CHILD(n, i - 1)) == EQUAL)) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4997 symtable_node(st, CHILD(n, i)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4998 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4999 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5000 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5001 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5002 symtable_params(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5003 { |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5004 int i, complex = -1, ext = 0; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5005 node *c = NULL; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5006 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5007 if (TYPE(n) == parameters) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5008 n = CHILD(n, 1); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5009 if (TYPE(n) == RPAR) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5010 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5011 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5012 REQ(n, varargslist); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5013 for (i = 0; i < NCH(n); i += 2) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5014 c = CHILD(n, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5015 if (TYPE(c) == STAR || TYPE(c) == DOUBLESTAR) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5016 ext = 1; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5017 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5018 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5019 if (TYPE(c) == test) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5020 continue; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5021 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5022 if (TYPE(CHILD(c, 0)) == NAME) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5023 symtable_add_def(st, STR(CHILD(c, 0)), DEF_PARAM); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5024 else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5025 char nbuf[10]; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5026 sprintf(nbuf, ".%d", i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5027 symtable_add_def(st, nbuf, DEF_PARAM); |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5028 complex = i; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5029 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5030 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5031 if (ext) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5032 c = CHILD(n, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5033 if (TYPE(c) == STAR) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5034 i++; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5035 symtable_add_def(st, STR(CHILD(n, i)), |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5036 DEF_PARAM | DEF_STAR); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5037 i += 2; |
|
16137
883cb0e31bb2
prevent symtable_params() from dereferencing off the end of the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16096
diff
changeset
|
5038 if (i >= NCH(n)) |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5039 c = NULL; |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5040 else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5041 c = CHILD(n, i); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5042 } |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5043 if (c && TYPE(c) == DOUBLESTAR) { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5044 i++; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5045 symtable_add_def(st, STR(CHILD(n, i)), |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5046 DEF_PARAM | DEF_DOUBLESTAR); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5047 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5048 } |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5049 if (complex >= 0) { |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5050 int j; |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5051 for (j = 0; j <= complex; j++) { |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5052 c = CHILD(n, j); |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5053 if (TYPE(c) == COMMA) |
|
16699
7334b2cedda8
Fix for implicit tuple + default arguments, courtesy of Michael Hudson.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16680
diff
changeset
|
5054 c = CHILD(n, ++j); |
|
7334b2cedda8
Fix for implicit tuple + default arguments, courtesy of Michael Hudson.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16680
diff
changeset
|
5055 else if (TYPE(c) == EQUAL) |
|
7334b2cedda8
Fix for implicit tuple + default arguments, courtesy of Michael Hudson.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16680
diff
changeset
|
5056 c = CHILD(n, j += 3); |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5057 if (TYPE(CHILD(c, 0)) == LPAR) |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5058 symtable_params_fplist(st, CHILD(c, 1)); |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5059 } |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5060 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5061 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5062 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5063 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5064 symtable_params_fplist(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5065 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5066 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5067 node *c; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5068 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5069 REQ(n, fplist); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5070 for (i = 0; i < NCH(n); i += 2) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5071 c = CHILD(n, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5072 REQ(c, fpdef); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5073 if (NCH(c) == 1) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5074 symtable_add_def(st, STR(CHILD(c, 0)), |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5075 DEF_PARAM | DEF_INTUPLE); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5076 else |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5077 symtable_params_fplist(st, CHILD(c, 1)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5078 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5079 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5080 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5081 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5082 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5083 symtable_global(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5084 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5085 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5086 |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
5087 /* XXX It might be helpful to warn about module-level global |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
5088 statements, but it's hard to tell the difference between |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
5089 module-level and a string passed to exec. |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
5090 */ |
|
16871
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
5091 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5092 for (i = 1; i < NCH(n); i += 2) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5093 char *name = STR(CHILD(n, i)); |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5094 int flags; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5095 |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5096 flags = symtable_lookup(st, name); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5097 if (flags < 0) |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5098 continue; |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5099 if (flags && flags != DEF_GLOBAL) { |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5100 char buf[500]; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5101 if (flags & DEF_PARAM) { |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5102 PyErr_Format(PyExc_SyntaxError, |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5103 "name '%.400s' is local and global", |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5104 name); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
5105 PyErr_SyntaxLocation(st->st_filename, |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5106 st->st_cur->ste_lineno); |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5107 st->st_errors++; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5108 return; |
|
16853
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5109 } |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5110 else { |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5111 if (flags & DEF_LOCAL) |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5112 sprintf(buf, GLOBAL_AFTER_ASSIGN, |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5113 name); |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5114 else |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5115 sprintf(buf, GLOBAL_AFTER_USE, name); |
|
16855
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
5116 symtable_warn(st, buf); |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5117 } |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5118 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5119 symtable_add_def(st, name, DEF_GLOBAL); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5120 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5121 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5122 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5123 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5124 symtable_list_comprehension(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5125 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5126 char tmpname[12]; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5127 |
|
17076
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5128 sprintf(tmpname, "_[%d]", st->st_tmpname); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5129 symtable_add_def(st, tmpname, DEF_LOCAL); |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5130 symtable_assign(st, CHILD(n, 1), 0); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5131 symtable_node(st, CHILD(n, 3)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5132 if (NCH(n) == 5) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5133 symtable_node(st, CHILD(n, 4)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5134 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5135 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5136 static void |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5137 symtable_import(struct symtable *st, node *n) |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5138 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5139 int i; |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
5140 /* import_stmt: 'import' dotted_as_name (',' dotted_as_name)* |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5141 | 'from' dotted_name 'import' |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5142 ('*' | import_as_name (',' import_as_name)*) |
|
16394
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
5143 import_as_name: NAME [NAME NAME] |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5144 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5145 if (STR(CHILD(n, 0))[0] == 'f') { /* from */ |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5146 node *dotname = CHILD(n, 1); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5147 if (strcmp(STR(CHILD(dotname, 0)), "__future__") == 0) { |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5148 /* check for bogus imports */ |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5149 if (n->n_lineno >= st->st_future->ff_last_lineno) { |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5150 PyErr_SetString(PyExc_SyntaxError, |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5151 LATE_FUTURE); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
5152 PyErr_SyntaxLocation(st->st_filename, |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5153 n->n_lineno); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5154 st->st_errors++; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5155 return; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5156 } |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5157 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5158 if (TYPE(CHILD(n, 3)) == STAR) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5159 st->st_cur->ste_optimized |= OPT_IMPORT_STAR; |
|
17132
55218e0495bc
Set the line number correctly for a nested function with an exec or
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17131
diff
changeset
|
5160 st->st_cur->ste_opt_lineno = n->n_lineno; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5161 } else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5162 for (i = 3; i < NCH(n); i += 2) { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5163 node *c = CHILD(n, i); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5164 if (NCH(c) > 1) /* import as */ |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5165 symtable_assign(st, CHILD(c, 2), |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5166 DEF_IMPORT); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5167 else |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5168 symtable_assign(st, CHILD(c, 0), |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5169 DEF_IMPORT); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5170 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5171 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5172 } else { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5173 for (i = 1; i < NCH(n); i += 2) { |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5174 symtable_assign(st, CHILD(n, i), DEF_IMPORT); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5175 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5176 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5177 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5178 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5179 static void |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5180 symtable_assign(struct symtable *st, node *n, int flag) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5181 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5182 node *tmp; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5183 int i; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5184 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5185 loop: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5186 switch (TYPE(n)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5187 case lambdef: |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5188 /* invalid assignment, e.g. lambda x:x=2. The next |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5189 pass will catch this error. */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5190 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5191 case power: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5192 if (NCH(n) > 2) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5193 for (i = 2; i < NCH(n); ++i) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5194 if (TYPE(CHILD(n, i)) != DOUBLESTAR) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5195 symtable_node(st, CHILD(n, i)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5196 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5197 if (NCH(n) > 1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5198 symtable_node(st, CHILD(n, 0)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5199 symtable_node(st, CHILD(n, 1)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5200 } else { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5201 n = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5202 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5203 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5204 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5205 case listmaker: |
|
17076
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5206 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) { |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5207 /* XXX This is an error, but the next pass |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5208 will catch it. */ |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5209 return; |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5210 } else { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5211 for (i = 0; i < NCH(n); i += 2) |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5212 symtable_assign(st, CHILD(n, i), flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5213 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5214 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5215 case exprlist: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5216 case testlist: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5217 if (NCH(n) == 1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5218 n = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5219 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5220 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5221 else { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5222 int i; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5223 for (i = 0; i < NCH(n); i += 2) |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5224 symtable_assign(st, CHILD(n, i), flag); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5225 return; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5226 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5227 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5228 case atom: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5229 tmp = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5230 if (TYPE(tmp) == LPAR || TYPE(tmp) == LSQB) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5231 n = CHILD(n, 1); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5232 goto loop; |
|
17185
f9a30015e8b0
Make it illegal to assign to __debug__ as per Guido's request.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17132
diff
changeset
|
5233 } else if (TYPE(tmp) == NAME) { |
|
17355
4468a8da67ca
Warn when assigning to __debug__ instead of raising an error.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17185
diff
changeset
|
5234 if (strcmp(STR(tmp), "__debug__") == 0) |
|
4468a8da67ca
Warn when assigning to __debug__ instead of raising an error.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17185
diff
changeset
|
5235 symtable_warn(st, ASSIGN_DEBUG); |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5236 symtable_add_def(st, STR(tmp), DEF_LOCAL | flag); |
|
17185
f9a30015e8b0
Make it illegal to assign to __debug__ as per Guido's request.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17132
diff
changeset
|
5237 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5238 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5239 case dotted_as_name: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5240 if (NCH(n) == 3) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5241 symtable_add_def(st, STR(CHILD(n, 2)), |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5242 DEF_LOCAL | flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5243 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5244 symtable_add_def(st, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5245 STR(CHILD(CHILD(n, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5246 0), 0)), |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5247 DEF_LOCAL | flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5248 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5249 case dotted_name: |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5250 symtable_add_def(st, STR(CHILD(n, 0)), DEF_LOCAL | flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5251 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5252 case NAME: |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5253 symtable_add_def(st, STR(n), DEF_LOCAL | flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5254 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5255 default: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5256 if (NCH(n) == 0) |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5257 return; |
|
16677
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5258 if (NCH(n) == 1) { |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5259 n = CHILD(n, 0); |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5260 goto loop; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5261 } |
|
16677
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5262 /* Should only occur for errors like x + 1 = 1, |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5263 which will be caught in the next pass. */ |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5264 for (i = 0; i < NCH(n); ++i) |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5265 if (TYPE(CHILD(n, i)) >= single_input) |
|
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5266 symtable_assign(st, CHILD(n, i), flag); |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5267 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5268 } |