Mercurial > cpython-lru_cache-weakref
annotate Python/compile.c @ 22621:830c829a7eb2 legacy-trunk
Fix an issue that was reported in but unrelated to the main problem of
SF bug 535905 (Evil Trashcan and GC interaction).
The SETLOCAL() macro should not DECREF the local variable in-place and
then store the new value; it should copy the old value to a temporary
value, then store the new value, and then DECREF the temporary value.
This is because it is possible that during the DECREF the frame is
accessed by other code (e.g. a __del__ method or gc.collect()) and the
variable would be pointing to already-freed memory.
BUGFIX CANDIDATE!
| author | Guido van Rossum <guido@python.org> |
|---|---|
| date | Thu, 28 Mar 2002 20:17:52 +0000 |
| parents | b2a2cc0c2a63 |
| children | 3e892582a850 |
| 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 \ |
|
21833
070d392042e3
Fix spelling mistakes. Bugfix candidates.
Neal Norwitz <nnorwitz@gmail.com>
parents:
21725
diff
changeset
|
64 "name '%.400s' is a function parameter and declared global" |
|
16781
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 |
|
20012
3faabf54b8b8
Add optional docstrings to member descriptors. For backwards
Guido van Rossum <guido@python.org>
parents:
19915
diff
changeset
|
76 static PyMemberDef 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 | |
| 69 | 94 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
95 code_dealloc(PyCodeObject *co) |
| 69 | 96 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
97 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
|
98 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
|
99 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
|
100 Py_XDECREF(co->co_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
101 Py_XDECREF(co->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
102 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
|
103 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
|
104 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
|
105 Py_XDECREF(co->co_lnotab); |
|
12576
1c7c2dd1beb1
Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents:
12538
diff
changeset
|
106 PyObject_DEL(co); |
| 69 | 107 } |
| 108 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
109 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
110 code_repr(PyCodeObject *co) |
|
1029
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
111 { |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
112 char buf[500]; |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
113 int lineno = -1; |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
114 char *filename = "???"; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
115 char *name = "???"; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
116 |
|
12278
647bf71912f0
Vladimir Marangozov: This fixes the line number in the string
Guido van Rossum <guido@python.org>
parents:
12086
diff
changeset
|
117 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
|
118 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
|
119 if (co->co_filename && PyString_Check(co->co_filename)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
120 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
|
121 if (co->co_name && PyString_Check(co->co_name)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
122 name = PyString_AS_STRING(co->co_name); |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
123 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
124 "<code object %.100s at %p, file \"%.300s\", line %d>", |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
125 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
|
126 return PyString_FromString(buf); |
|
1029
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
127 } |
|
2f9805c963e8
Give code objects a more useful representation.
Guido van Rossum <guido@python.org>
parents:
792
diff
changeset
|
128 |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
129 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
130 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
|
131 { |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
132 int cmp; |
|
12333
525b2358721e
Patch by Vladimir Marangozov to include the function name when
Guido van Rossum <guido@python.org>
parents:
12278
diff
changeset
|
133 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
|
134 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
|
135 cmp = co->co_argcount - cp->co_argcount; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
136 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
|
137 cmp = co->co_nlocals - cp->co_nlocals; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
138 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
|
139 cmp = co->co_flags - cp->co_flags; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
140 if (cmp) return cmp; |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
141 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
|
142 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
|
143 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
|
144 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
|
145 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
|
146 if (cmp) return cmp; |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
147 cmp = PyObject_Compare(co->co_varnames, cp->co_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
148 if (cmp) return cmp; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
149 cmp = PyObject_Compare(co->co_freevars, cp->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
150 if (cmp) return cmp; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
151 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
|
152 return cmp; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
153 } |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
154 |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
155 static long |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
156 code_hash(PyCodeObject *co) |
|
1399
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
157 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
158 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
|
159 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
|
160 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
|
161 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
|
162 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
|
163 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
|
164 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
|
165 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
|
166 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
|
167 h4 = PyObject_Hash(co->co_varnames); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
168 if (h4 == -1) return -1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
169 h5 = PyObject_Hash(co->co_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
170 if (h5 == -1) return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
171 h6 = PyObject_Hash(co->co_cellvars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
172 if (h6 == -1) return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
173 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
|
174 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
|
175 if (h == -1) h = -2; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
176 return h; |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
177 } |
|
cc172ce05561
Added compare operations for functions and code objects.
Guido van Rossum <guido@python.org>
parents:
1369
diff
changeset
|
178 |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
179 /* 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
|
180 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
181 PyTypeObject PyCode_Type = { |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
182 PyObject_HEAD_INIT(&PyType_Type) |
| 69 | 183 0, |
| 184 "code", | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
185 sizeof(PyCodeObject), |
| 69 | 186 0, |
|
19915
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
187 (destructor)code_dealloc, /* tp_dealloc */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
188 0, /* tp_print */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
189 0, /* tp_getattr */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
190 0, /* tp_setattr */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
191 (cmpfunc)code_compare, /* tp_compare */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
192 (reprfunc)code_repr, /* tp_repr */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
193 0, /* tp_as_number */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
194 0, /* tp_as_sequence */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
195 0, /* tp_as_mapping */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
196 (hashfunc)code_hash, /* tp_hash */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
197 0, /* tp_call */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
198 0, /* tp_str */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
199 PyObject_GenericGetAttr, /* tp_getattro */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
200 0, /* tp_setattro */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
201 0, /* tp_as_buffer */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
202 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
203 0, /* tp_doc */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
204 0, /* tp_traverse */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
205 0, /* tp_clear */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
206 0, /* tp_richcompare */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
207 0, /* tp_weaklistoffset */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
208 0, /* tp_iter */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
209 0, /* tp_iternext */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
210 0, /* tp_methods */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
211 code_memberlist, /* tp_members */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
212 0, /* tp_getset */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
213 0, /* tp_base */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
214 0, /* tp_dict */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
215 0, /* tp_descr_get */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
216 0, /* tp_descr_set */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
217 0, /* tp_dictoffset */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
218 0, /* tp_init */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
219 0, /* tp_alloc */ |
|
2263cb43eaab
Supply code objects a new-style tp_members slot and tp_getattr impl.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19793
diff
changeset
|
220 0, /* tp_new */ |
| 69 | 221 }; |
| 222 | |
|
5287
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
223 #define NAME_CHARS \ |
|
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
224 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz" |
|
5af766a1b531
Tweaks to keep the Microsoft compiler quier.
Guido van Rossum <guido@python.org>
parents:
5264
diff
changeset
|
225 |
|
16006
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
226 /* 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
|
227 |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
228 static int |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
229 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
|
230 { |
|
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
|
231 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
|
232 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
|
233 |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
234 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
|
235 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
|
236 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
|
237 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
|
238 } |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
239 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
|
240 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
|
241 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
|
242 } |
|
9d625303f914
Reindent a function that was somehow indented by 7 spaces. Also did a
Guido van Rossum <guido@python.org>
parents:
16428
diff
changeset
|
243 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
|
244 } |
|
51811d78a9da
SF Patch #103250, by pj99: Optimize a strspn() out of startup.
Guido van Rossum <guido@python.org>
parents:
15438
diff
changeset
|
245 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
246 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
247 intern_strings(PyObject *tuple) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
248 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
249 int i; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
250 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
251 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
252 PyObject *v = PyTuple_GET_ITEM(tuple, i); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
253 if (v == NULL || !PyString_Check(v)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
254 Py_FatalError("non-string found in code slot"); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
255 PyErr_BadInternalCall(); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
256 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
257 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
258 PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
259 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
260 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
261 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
262 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
263 PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
264 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
|
265 PyObject *code, PyObject *consts, PyObject *names, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
266 PyObject *varnames, PyObject *freevars, PyObject *cellvars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
267 PyObject *filename, PyObject *name, int firstlineno, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
268 PyObject *lnotab) |
| 69 | 269 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
270 PyCodeObject *co; |
| 69 | 271 int i; |
| 272 /* Check argument types */ | |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
273 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
|
274 code == NULL || |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
275 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
|
276 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
|
277 varnames == NULL || !PyTuple_Check(varnames) || |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
278 freevars == NULL || !PyTuple_Check(freevars) || |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
279 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
|
280 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
|
281 filename == NULL || !PyString_Check(filename) || |
|
20947
c555f1e7c4be
Use PyObject_CheckReadBuffer().
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20939
diff
changeset
|
282 lnotab == NULL || !PyString_Check(lnotab) || |
|
c555f1e7c4be
Use PyObject_CheckReadBuffer().
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20939
diff
changeset
|
283 !PyObject_CheckReadBuffer(code)) { |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
284 PyErr_BadInternalCall(); |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
285 return NULL; |
|
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
286 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
287 intern_strings(names); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
288 intern_strings(varnames); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
289 if (freevars == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
290 freevars = PyTuple_New(0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
291 intern_strings(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
292 if (cellvars == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
293 cellvars = PyTuple_New(0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
294 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
|
295 /* 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
|
296 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
|
297 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
|
298 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
|
299 continue; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
300 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
|
301 continue; |
|
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
302 PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i)); |
| 69 | 303 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
304 co = PyObject_NEW(PyCodeObject, &PyCode_Type); |
| 69 | 305 if (co != NULL) { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
306 co->co_argcount = argcount; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
307 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
|
308 co->co_stacksize = stacksize; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
309 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
|
310 Py_INCREF(code); |
|
9293
0a67db47e1d0
Changes to support other object types besides strings
Guido van Rossum <guido@python.org>
parents:
9215
diff
changeset
|
311 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
|
312 Py_INCREF(consts); |
| 69 | 313 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
|
314 Py_INCREF(names); |
| 69 | 315 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
|
316 Py_INCREF(varnames); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
317 co->co_varnames = varnames; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
318 Py_INCREF(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
319 co->co_freevars = freevars; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
320 Py_INCREF(cellvars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
321 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
|
322 Py_INCREF(filename); |
|
266
b5826bf29677
Changed and exported newcodeobject() interface, for ".pyc" files.
Guido van Rossum <guido@python.org>
parents:
238
diff
changeset
|
323 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
|
324 Py_INCREF(name); |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
325 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
|
326 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
|
327 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
|
328 co->co_lnotab = lnotab; |
| 69 | 329 } |
| 330 return co; | |
| 331 } | |
| 332 | |
| 333 | |
| 334 /* Data structure used internally */ | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
335 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
336 /* 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
|
337 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
|
338 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
339 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
|
340 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
|
341 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
|
342 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
343 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
|
344 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
|
345 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
|
346 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
|
347 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
348 |
|
18065
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
349 /* All about c_lnotab. |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
350 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
351 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
|
352 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
|
353 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
|
354 The array is conceptually a list of |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
355 (bytecode offset increment, line number increment) |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
356 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
|
357 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
358 byte code offset source code line number |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
359 0 1 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
360 6 2 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
361 50 7 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
362 350 307 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
363 361 308 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
364 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
365 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
|
366 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
|
367 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
368 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
|
369 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
370 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
|
371 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
|
372 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
|
373 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
|
374 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
|
375 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
|
376 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
|
377 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
|
378 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
379 lineno = addr = 0 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
380 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
|
381 addr += addr_incr |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
382 if addr > A: |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
383 return lineno |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
384 lineno += line_incr |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
385 |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
386 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
|
387 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
|
388 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
|
389 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
|
390 255, 0, 45, 255, 0, 45. |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
391 */ |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
392 |
| 69 | 393 struct compiling { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
394 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
|
395 PyObject *c_consts; /* list of objects */ |
| 12522 | 396 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
|
397 PyObject *c_names; /* list of strings (names) */ |
| 12522 | 398 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
|
399 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
|
400 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
|
401 PyObject *c_varnames; /* list (inverse of c_locals) */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
402 PyObject *c_freevars; /* dictionary (value=None) */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
403 PyObject *c_cellvars; /* list */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
404 int c_nlocals; /* index of next local */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
405 int c_argcount; /* number of top-level arguments */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
406 int c_flags; /* same as co_flags */ |
| 69 | 407 int c_nexti; /* index into c_code */ |
| 408 int c_errors; /* counts errors occurred */ | |
| 86 | 409 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
|
410 int c_interactive; /* generating code for interactive command */ |
| 86 | 411 int c_loops; /* counts nested loops */ |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
412 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
|
413 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
|
414 int c_nblocks; /* current block stack level */ |
| 86 | 415 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
|
416 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
|
417 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
|
418 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
|
419 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
|
420 int c_firstlineno; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
421 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
|
422 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
|
423 char *c_private; /* for private name mangling */ |
| 13936 | 424 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
|
425 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
|
426 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
|
427 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
|
428 PyFutureFeatures *c_future; /* pointer to module's __future__ */ |
| 69 | 429 }; |
| 430 | |
|
17518
f939ce52a734
Make some private symbols static.
Guido van Rossum <guido@python.org>
parents:
17355
diff
changeset
|
431 static int |
|
f939ce52a734
Make some private symbols static.
Guido van Rossum <guido@python.org>
parents:
17355
diff
changeset
|
432 is_free(int v) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
433 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
434 if ((v & (USE | DEF_FREE)) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
435 && !(v & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL))) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
436 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
437 if (v & DEF_FREE_CLASS) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
438 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
439 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
440 } |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
441 |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
442 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
443 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
|
444 { |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
445 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
|
446 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
447 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
|
448 /* 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
|
449 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
|
450 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
|
451 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
452 } |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
453 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
|
454 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
|
455 /* 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
|
456 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
|
457 return; |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
458 } |
|
13993
716e1c4e3f78
When raising a SyntaxError, make a best-effort attempt to set the
Fred Drake <fdrake@acm.org>
parents:
13956
diff
changeset
|
459 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
|
460 if (v == NULL) |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
461 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
|
462 |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
463 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
|
464 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
|
465 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
|
466 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
|
467 } |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
468 if (exc == PyExc_SyntaxError) { |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
469 t = Py_BuildValue("(ziOO)", c->c_filename, c->c_lineno, |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
470 Py_None, line); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
471 if (t == NULL) |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
472 goto exit; |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
473 w = Py_BuildValue("(OO)", v, t); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
474 if (w == NULL) |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
475 goto exit; |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
476 PyErr_SetObject(exc, w); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
477 } else { |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
478 /* Make sure additional exceptions are printed with |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
479 file and line, also. */ |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
480 PyErr_SetObject(exc, v); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
481 PyErr_SyntaxLocation(c->c_filename, c->c_lineno); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
482 } |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
483 exit: |
|
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
484 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
|
485 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
|
486 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
|
487 Py_XDECREF(line); |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
488 } |
|
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
489 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
490 /* Interface to the block stack */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
491 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
492 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
493 block_push(struct compiling *c, int type) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
494 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
495 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
|
496 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
|
497 "too many statically nested blocks"); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
498 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
499 else { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
500 c->c_block[c->c_nblocks++] = type; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
501 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
502 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
503 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
504 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
505 block_pop(struct compiling *c, int type) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
506 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
507 if (c->c_nblocks > 0) |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
508 c->c_nblocks--; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
509 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
|
510 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
|
511 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
512 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
513 |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
514 /* Prototype forward declarations */ |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
515 |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
516 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
|
517 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
|
518 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
|
519 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
|
520 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
|
521 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
|
522 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
|
523 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
|
524 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
|
525 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
|
526 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
|
527 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
|
528 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
|
529 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
|
530 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
|
531 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
|
532 static void com_list(struct compiling *, node *, int); |
| 13936 | 533 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
|
534 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
|
535 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
|
536 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
|
537 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
|
538 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
|
539 PyCompilerFlags *); |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
540 static PyObject *parsestrplus(struct compiling*, node *); |
|
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
541 static PyObject *parsestr(struct compiling *, char *); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
542 static node *get_rawdocstring(node *); |
| 69 | 543 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
544 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
|
545 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
546 /* 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
|
547 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
|
548 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
|
549 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
|
550 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
|
551 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
|
552 static int symtable_add_def(struct symtable *, char *, int); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
553 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
|
554 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
555 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
|
556 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
|
557 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
|
558 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
|
559 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
|
560 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
|
561 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
|
562 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
|
563 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
|
564 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
565 static int symtable_update_free_vars(struct symtable *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
566 static int symtable_undo_free(struct symtable *, PyObject *, PyObject *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
567 static int symtable_check_global(struct symtable *, PyObject *, PyObject *); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
568 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
569 /* helper */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
570 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
|
571 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
|
572 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
573 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
|
574 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
|
575 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
|
576 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
577 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
578 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
|
579 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
|
580 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
581 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
|
582 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
|
583 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
584 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
|
585 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
|
586 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
|
587 depth--; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
588 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
|
589 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
|
590 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
591 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
592 #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
|
593 |
| 69 | 594 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
595 com_init(struct compiling *c, char *filename) |
| 69 | 596 { |
| 12522 | 597 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
|
598 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
|
599 1000)) == NULL) |
| 12522 | 600 goto fail; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
601 if ((c->c_consts = PyList_New(0)) == NULL) |
| 12522 | 602 goto fail; |
| 603 if ((c->c_const_dict = PyDict_New()) == NULL) | |
| 604 goto fail; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
605 if ((c->c_names = PyList_New(0)) == NULL) |
| 12522 | 606 goto fail; |
| 607 if ((c->c_name_dict = PyDict_New()) == NULL) | |
| 608 goto fail; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
609 if ((c->c_locals = PyDict_New()) == NULL) |
| 12522 | 610 goto fail; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
611 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
|
612 1000)) == NULL) |
| 12522 | 613 goto fail; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
614 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
|
615 c->c_varnames = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
616 c->c_freevars = NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
617 c->c_cellvars = NULL; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
618 c->c_nlocals = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
619 c->c_argcount = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
620 c->c_flags = 0; |
| 69 | 621 c->c_nexti = 0; |
| 622 c->c_errors = 0; | |
| 86 | 623 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
|
624 c->c_interactive = 0; |
| 86 | 625 c->c_loops = 0; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
626 c->c_begin = 0; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
627 c->c_nblocks = 0; |
| 86 | 628 c->c_filename = filename; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
629 c->c_name = "?"; |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
630 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
|
631 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
|
632 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
|
633 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
|
634 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
|
635 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
|
636 c->c_lnotab_next = 0; |
| 13936 | 637 c->c_tmpname = 0; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
638 c->c_nested = 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
639 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
|
640 c->c_symtable = NULL; |
| 69 | 641 return 1; |
| 642 | |
| 12522 | 643 fail: |
| 644 com_free(c); | |
| 69 | 645 return 0; |
| 646 } | |
| 647 | |
| 648 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
649 com_free(struct compiling *c) |
| 69 | 650 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
651 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
|
652 Py_XDECREF(c->c_consts); |
| 12522 | 653 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
|
654 Py_XDECREF(c->c_names); |
| 12522 | 655 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
|
656 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
|
657 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
|
658 Py_XDECREF(c->c_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
659 Py_XDECREF(c->c_freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
660 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
|
661 Py_XDECREF(c->c_lnotab); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
662 if (c->c_future) |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
663 PyMem_Free((void *)c->c_future); |
| 69 | 664 } |
| 665 | |
| 666 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
667 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
|
668 { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
669 c->c_stacklevel += n; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
670 if (c->c_stacklevel > c->c_maxstacklevel) { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
671 c->c_maxstacklevel = c->c_stacklevel; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
672 /* |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
673 fprintf(stderr, "%s:%s:%d max stack nexti=%d level=%d n=%d\n", |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
674 c->c_filename, c->c_name, c->c_lineno, |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
675 c->c_nexti, c->c_stacklevel, n); |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
676 */ |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
677 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
678 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
679 |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
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_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
|
682 { |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
683 if (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
|
684 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
|
685 else |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
686 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
|
687 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
688 |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
689 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
690 com_done(struct compiling *c) |
| 69 | 691 { |
| 692 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
|
693 _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
|
694 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
|
695 _PyString_Resize(&c->c_lnotab, c->c_lnotab_next); |
| 69 | 696 } |
| 697 | |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
698 static int |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
699 com_check_size(PyObject **s, int offset) |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
700 { |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
701 int len = PyString_GET_SIZE(*s); |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
702 if (offset >= len) |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
703 return _PyString_Resize(s, len * 2); |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
704 return 0; |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
705 } |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
706 |
| 69 | 707 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
708 com_addbyte(struct compiling *c, int byte) |
| 69 | 709 { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
710 /*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
|
711 assert(byte >= 0 && byte <= 255); |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
712 assert(c->c_code != 0); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
713 if (com_check_size(&c->c_code, c->c_nexti)) { |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
714 c->c_errors++; |
| 69 | 715 return; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
716 } |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
717 PyString_AS_STRING(c->c_code)[c->c_nexti++] = byte; |
| 69 | 718 } |
| 719 | |
| 720 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
721 com_addint(struct compiling *c, int x) |
| 69 | 722 { |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
723 com_addbyte(c, x & 0xff); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
724 com_addbyte(c, x >> 8); /* XXX x should be positive */ |
| 69 | 725 } |
| 726 | |
| 727 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
728 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
|
729 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
730 char *p; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
731 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
|
732 return; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
733 if (com_check_size(&c->c_lnotab, c->c_lnotab_next + 2)) { |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
734 c->c_errors++; |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
735 return; |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
736 } |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
737 p = PyString_AS_STRING(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
|
738 *p++ = addr; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
739 *p++ = line; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
740 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
|
741 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
742 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
743 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
744 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
|
745 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
746 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
|
747 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
|
748 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
|
749 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
750 else { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
751 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
|
752 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
|
753 while (incr_addr > 255) { |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
754 com_add_lnotab(c, 255, 0); |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
755 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
|
756 } |
|
18065
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
757 while (incr_line > 255) { |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
758 com_add_lnotab(c, incr_addr, 255); |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
759 incr_line -=255; |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
760 incr_addr = 0; |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
761 } |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
762 if (incr_addr > 0 || incr_line > 0) |
|
889db6d55506
SF bug 430991: wrong co_lnotab
Tim Peters <tim.peters@gmail.com>
parents:
17736
diff
changeset
|
763 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
|
764 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
|
765 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
|
766 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
767 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
768 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
769 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
770 com_addoparg(struct compiling *c, int op, int arg) |
| 69 | 771 { |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
772 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
|
773 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
|
774 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
|
775 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
|
776 return; |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
777 } |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
778 if (extended_arg){ |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
779 com_addbyte(c, EXTENDED_ARG); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
780 com_addint(c, extended_arg); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
781 arg &= 0xffff; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
782 } |
|
5164
8c277f29b535
Add global Py_OptimizeFlag. SET_LINENO is omitted again unless this is
Guido van Rossum <guido@python.org>
parents:
5119
diff
changeset
|
783 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
|
784 com_addint(c, arg); |
| 69 | 785 } |
| 786 | |
| 787 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
788 com_addfwref(struct compiling *c, int op, int *p_anchor) |
| 69 | 789 { |
| 790 /* Compile a forward reference for backpatching */ | |
| 791 int here; | |
| 792 int anchor; | |
| 793 com_addbyte(c, op); | |
| 794 here = c->c_nexti; | |
| 795 anchor = *p_anchor; | |
| 796 *p_anchor = here; | |
| 797 com_addint(c, anchor == 0 ? 0 : here - anchor); | |
| 798 } | |
| 799 | |
| 800 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
801 com_backpatch(struct compiling *c, int anchor) |
| 69 | 802 { |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
803 unsigned char *code = (unsigned char *) PyString_AS_STRING(c->c_code); |
| 69 | 804 int target = c->c_nexti; |
| 805 int dist; | |
| 806 int prev; | |
| 807 for (;;) { | |
| 808 /* Make the JUMP instruction at anchor point to target */ | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
809 prev = code[anchor] + (code[anchor+1] << 8); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
810 dist = target - (anchor+2); |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
811 code[anchor] = dist & 0xff; |
|
14147
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
812 dist >>= 8; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
813 code[anchor+1] = dist; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
814 dist >>= 8; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
815 if (dist) { |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
816 com_error(c, PyExc_SystemError, |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
817 "com_backpatch: offset too large"); |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
818 break; |
|
21ec69a56228
Charles G. Waldman <cgw@fnal.gov>:
Fred Drake <fdrake@acm.org>
parents:
14117
diff
changeset
|
819 } |
| 69 | 820 if (!prev) |
| 821 break; | |
| 822 anchor -= prev; | |
| 823 } | |
| 824 } | |
| 825 | |
| 544 | 826 /* Handle literals and names uniformly */ |
| 69 | 827 |
| 828 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
829 com_add(struct compiling *c, PyObject *list, PyObject *dict, PyObject *v) |
| 69 | 830 { |
| 12522 | 831 PyObject *w, *t, *np=NULL; |
| 832 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
|
833 |
| 12522 | 834 t = Py_BuildValue("(OO)", v, v->ob_type); |
| 835 if (t == NULL) | |
| 836 goto fail; | |
| 837 w = PyDict_GetItem(dict, t); | |
| 838 if (w != NULL) { | |
| 839 n = PyInt_AsLong(w); | |
| 840 } else { | |
| 841 n = PyList_Size(list); | |
| 842 np = PyInt_FromLong(n); | |
| 843 if (np == NULL) | |
| 844 goto fail; | |
| 845 if (PyList_Append(list, v) != 0) | |
| 846 goto fail; | |
| 847 if (PyDict_SetItem(dict, t, np) != 0) | |
| 848 goto fail; | |
| 849 Py_DECREF(np); | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
850 } |
| 12522 | 851 Py_DECREF(t); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
852 return n; |
| 12522 | 853 fail: |
| 854 Py_XDECREF(np); | |
| 855 Py_XDECREF(t); | |
| 856 c->c_errors++; | |
| 857 return 0; | |
| 69 | 858 } |
| 859 | |
| 860 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
861 com_addconst(struct compiling *c, PyObject *v) |
| 69 | 862 { |
| 12522 | 863 return com_add(c, c->c_consts, c->c_const_dict, v); |
| 69 | 864 } |
| 865 | |
| 866 static int | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
867 com_addname(struct compiling *c, PyObject *v) |
| 69 | 868 { |
| 12522 | 869 return com_add(c, c->c_names, c->c_name_dict, v); |
| 69 | 870 } |
| 871 | |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
872 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
|
873 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
|
874 { |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
875 /* Name mangling: __private becomes _classname__private. |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
876 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
|
877 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
|
878 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
|
879 return 0; |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
880 nlen = strlen(name); |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
881 if (nlen+2 >= maxlen) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
882 return 0; /* Don't mangle __extremely_long_names */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
883 if (name[nlen-1] == '_' && name[nlen-2] == '_') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
884 return 0; /* Don't mangle __whatever__ */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
885 /* Strip leading underscores from class name */ |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
886 while (*p == '_') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
887 p++; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
888 if (*p == '\0') |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
889 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
|
890 plen = strlen(p); |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
891 if (plen + nlen >= maxlen) |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
892 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
|
893 /* 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
|
894 buffer[0] = '_'; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
895 strncpy(buffer+1, p, plen); |
|
4131
6b589334e0e9
Afterthough: leave both leading underscores in,
Guido van Rossum <guido@python.org>
parents:
4130
diff
changeset
|
896 strcpy(buffer+1+plen, name); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
897 return 1; |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
898 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
899 |
| 69 | 900 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
|
901 com_addop_name(struct compiling *c, int op, char *name) |
| 69 | 902 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
903 PyObject *v; |
| 69 | 904 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
|
905 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
|
906 |
|
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
907 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
|
908 name = buffer; |
|
5009
402e36c83d20
Intern all names and varnames in newcodeobject(), plus those string
Guido van Rossum <guido@python.org>
parents:
4991
diff
changeset
|
909 if (name == NULL || (v = PyString_InternFromString(name)) == NULL) { |
| 69 | 910 c->c_errors++; |
| 911 i = 255; | |
| 912 } | |
| 913 else { | |
| 914 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
|
915 Py_DECREF(v); |
| 69 | 916 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
917 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
|
918 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
919 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
920 #define NAME_LOCAL 0 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
921 #define NAME_GLOBAL 1 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
922 #define NAME_DEFAULT 2 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
923 #define NAME_CLOSURE 3 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
924 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
925 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
926 com_lookup_arg(PyObject *dict, PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
927 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
928 PyObject *v = PyDict_GetItem(dict, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
929 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
930 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
931 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
932 return PyInt_AS_LONG(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
933 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
934 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
935 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
|
936 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
|
937 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
938 PyObject *v; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
939 int i, reftype; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
940 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
|
941 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
|
942 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
|
943 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
944 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
|
945 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
|
946 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
|
947 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
|
948 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
|
949 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
|
950 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
951 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
952 reftype = get_ref_type(c, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
953 switch (reftype) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
954 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
|
955 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
|
956 scope = NAME_LOCAL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
957 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
958 case GLOBAL_EXPLICIT: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
959 scope = NAME_GLOBAL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
960 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
961 case GLOBAL_IMPLICIT: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
962 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
|
963 scope = NAME_GLOBAL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
964 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
965 case FREE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
966 case CELL: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
967 scope = NAME_CLOSURE; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
968 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
|
969 } |
|
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 i = com_addname(c, v); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
972 if (scope == NAME_LOCAL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
973 i = com_lookup_arg(c->c_locals, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
974 else if (reftype == FREE) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
975 i = com_lookup_arg(c->c_freevars, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
976 else if (reftype == CELL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
977 i = com_lookup_arg(c->c_cellvars, v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
978 if (i == -1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
979 c->c_errors++; /* XXX no exception set */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
980 i = 255; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
981 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
|
982 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
983 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
|
984 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
985 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
|
986 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
|
987 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
|
988 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
|
989 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
|
990 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
991 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
|
992 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
|
993 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
994 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
|
995 op = LOAD_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
996 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
997 case NAME_CLOSURE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
998 op = LOAD_DEREF; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
999 break; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1000 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1001 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1002 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
|
1003 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
|
1004 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
|
1005 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
|
1006 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1007 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
|
1008 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
|
1009 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1010 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
|
1011 op = STORE_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1012 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1013 case NAME_CLOSURE: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1014 op = STORE_DEREF; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1015 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
|
1016 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1017 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1018 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
|
1019 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
|
1020 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
|
1021 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
|
1022 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1023 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
|
1024 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
|
1025 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1026 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
|
1027 op = DELETE_NAME; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1028 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1029 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
|
1030 char buf[500]; |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
1031 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
1032 DEL_CLOSURE_ERROR, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1033 com_error(c, PyExc_SyntaxError, buf); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1034 i = 255; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1035 break; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
1036 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1037 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1038 break; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1039 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1040 done: |
| 69 | 1041 com_addoparg(c, op, i); |
| 1042 } | |
| 1043 | |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1044 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1045 com_addopname(struct compiling *c, int op, node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1046 { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1047 char *name; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1048 char buffer[1000]; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1049 /* 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
|
1050 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
|
1051 bothered right now */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1052 if (TYPE(n) == STAR) |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1053 name = "*"; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1054 else if (TYPE(n) == dotted_name) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1055 char *p = buffer; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1056 int i; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1057 name = buffer; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1058 for (i = 0; i < NCH(n); i += 2) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1059 char *s = STR(CHILD(n, i)); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1060 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
|
1061 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
|
1062 "dotted_name too long"); |
|
2367
915fabec64a3
fix typo (== for =) in assignment
Guido van Rossum <guido@python.org>
parents:
2310
diff
changeset
|
1063 name = NULL; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1064 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1065 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1066 if (p != buffer) |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1067 *p++ = '.'; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1068 strcpy(p, s); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1069 p = strchr(p, '\0'); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1070 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1071 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1072 else { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1073 REQ(n, NAME); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1074 name = STR(n); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1075 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
1076 com_addop_name(c, op, name); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1077 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1078 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1079 static PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1080 parsenumber(struct compiling *co, char *s) |
| 69 | 1081 { |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1082 char *end; |
| 69 | 1083 long x; |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1084 double dx; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1085 #ifndef WITHOUT_COMPLEX |
|
3766
516490c8192c
Py_complex; and WITHOUT_COMPLEX added to getargs.c
Guido van Rossum <guido@python.org>
parents:
3366
diff
changeset
|
1086 Py_complex c; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1087 int imflag; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1088 #endif |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1089 |
|
176
229168a2fe28
Added error checking for numeric constants; added local/global variable
Guido van Rossum <guido@python.org>
parents:
160
diff
changeset
|
1090 errno = 0; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
1091 end = s + strlen(s) - 1; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1092 #ifndef WITHOUT_COMPLEX |
|
3366
c25865884649
only use 'j' for imaginary constants
Guido van Rossum <guido@python.org>
parents:
3349
diff
changeset
|
1093 imflag = *end == 'j' || *end == 'J'; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1094 #endif |
| 744 | 1095 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
|
1096 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
|
1097 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
|
1098 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
|
1099 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1100 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
|
1101 if (*end == '\0') { |
|
19502
62bf9401a1ac
If an integer constant can't be generated from an integer literal
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19343
diff
changeset
|
1102 if (errno != 0) |
|
62bf9401a1ac
If an integer constant can't be generated from an integer literal
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19343
diff
changeset
|
1103 return PyLong_FromString(s, (char **)0, 0); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1104 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
|
1105 } |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1106 /* XXX Huge floats may silently fail */ |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1107 #ifndef WITHOUT_COMPLEX |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1108 if (imflag) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1109 c.real = 0.; |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1110 PyFPE_START_PROTECT("atof", return 0) |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1111 c.imag = atof(s); |
|
5197
74c12704a0bd
New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents:
5183
diff
changeset
|
1112 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
|
1113 return PyComplex_FromCComplex(c); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1114 } |
|
6453
c9b139b9c5ff
Fixed for WITHOUT_COMPLEX compilation (Jack)
Guido van Rossum <guido@python.org>
parents:
6186
diff
changeset
|
1115 else |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1116 #endif |
|
6453
c9b139b9c5ff
Fixed for WITHOUT_COMPLEX compilation (Jack)
Guido van Rossum <guido@python.org>
parents:
6186
diff
changeset
|
1117 { |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1118 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
|
1119 dx = atof(s); |
|
5197
74c12704a0bd
New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents:
5183
diff
changeset
|
1120 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
|
1121 return PyFloat_FromDouble(dx); |
|
5119
bda01a374762
Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents:
5041
diff
changeset
|
1122 } |
| 69 | 1123 } |
| 1124 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1125 static PyObject * |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1126 parsestr(struct compiling *com, char *s) |
| 69 | 1127 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1128 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
|
1129 size_t len; |
| 69 | 1130 char *buf; |
| 1131 char *p; | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1132 char *end; |
| 69 | 1133 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
|
1134 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
|
1135 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
|
1136 int rawmode = 0; |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1137 #ifdef Py_USING_UNICODE |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1138 int unicode = 0; |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1139 #endif |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1140 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
|
1141 if (quote == 'u' || quote == 'U') { |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1142 #ifdef Py_USING_UNICODE |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1143 quote = *++s; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1144 unicode = 1; |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1145 #else |
|
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1146 com_error(com, PyExc_SyntaxError, |
|
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1147 "Unicode literals not supported in this Python"); |
|
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1148 return NULL; |
|
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1149 #endif |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1150 } |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1151 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
|
1152 quote = *++s; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1153 rawmode = 1; |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1154 } |
|
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1155 } |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1156 if (quote != '\'' && quote != '\"') { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1157 PyErr_BadInternalCall(); |
| 69 | 1158 return NULL; |
| 1159 } | |
| 1160 s++; | |
| 1161 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
|
1162 if (len > INT_MAX) { |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1163 com_error(com, PyExc_OverflowError, |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1164 "string to parse is too long"); |
|
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
|
1165 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
|
1166 } |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1167 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
|
1168 PyErr_BadInternalCall(); |
| 69 | 1169 return NULL; |
| 1170 } | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1171 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
|
1172 s += 2; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1173 len -= 2; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1174 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
|
1175 PyErr_BadInternalCall(); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1176 return NULL; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1177 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1178 } |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1179 #ifdef Py_USING_UNICODE |
| 12538 | 1180 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
|
1181 if (rawmode) |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1182 v = PyUnicode_DecodeRawUnicodeEscape( |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1183 s, len, NULL); |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1184 else |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1185 v = PyUnicode_DecodeUnicodeEscape( |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1186 s, len, NULL); |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1187 if (v == NULL) |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1188 PyErr_SyntaxLocation(com->c_filename, com->c_lineno); |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1189 return v; |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1190 |
|
11974
28003afa1a2f
Marc-Andre Lemburg: support for Unicode string literals (u"...", ur"...").
Guido van Rossum <guido@python.org>
parents:
11598
diff
changeset
|
1191 } |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1192 #endif |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1193 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
|
1194 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
|
1195 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
|
1196 if (v == NULL) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1197 return NULL; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1198 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
|
1199 end = s + len; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1200 while (s < end) { |
| 69 | 1201 if (*s != '\\') { |
| 1202 *p++ = *s++; | |
| 1203 continue; | |
| 1204 } | |
| 1205 s++; | |
| 1206 switch (*s++) { | |
| 1207 /* 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
|
1208 case '\n': break; |
| 69 | 1209 case '\\': *p++ = '\\'; break; |
| 1210 case '\'': *p++ = '\''; break; | |
|
1364
132602d854d8
Changes to accept double-quoted strings on input.
Guido van Rossum <guido@python.org>
parents:
1354
diff
changeset
|
1211 case '\"': *p++ = '\"'; break; |
| 69 | 1212 case 'b': *p++ = '\b'; break; |
| 1213 case 'f': *p++ = '\014'; break; /* FF */ | |
| 1214 case 't': *p++ = '\t'; break; | |
| 1215 case 'n': *p++ = '\n'; break; | |
| 1216 case 'r': *p++ = '\r'; break; | |
| 1217 case 'v': *p++ = '\013'; break; /* VT */ | |
| 1218 case 'a': *p++ = '\007'; break; /* BEL, not classic C */ | |
| 1219 case '0': case '1': case '2': case '3': | |
| 1220 case '4': case '5': case '6': case '7': | |
| 1221 c = s[-1] - '0'; | |
| 1222 if ('0' <= *s && *s <= '7') { | |
| 1223 c = (c<<3) + *s++ - '0'; | |
| 1224 if ('0' <= *s && *s <= '7') | |
| 1225 c = (c<<3) + *s++ - '0'; | |
| 1226 } | |
| 1227 *p++ = c; | |
| 1228 break; | |
| 1229 case 'x': | |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
1230 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
|
1231 && 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
|
1232 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
|
1233 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
|
1234 s++; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1235 if (isdigit(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1236 x = c - '0'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1237 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
|
1238 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
|
1239 else |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1240 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
|
1241 x = x << 4; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1242 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
|
1243 s++; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1244 if (isdigit(c)) |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1245 x += c - '0'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1246 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
|
1247 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
|
1248 else |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1249 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
|
1250 *p++ = x; |
| 69 | 1251 break; |
| 1252 } | |
|
14382
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1253 Py_DECREF(v); |
|
22120
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1254 com_error(com, PyExc_ValueError, |
|
b2a2cc0c2a63
Patch #50002: Display line information for bad \x escapes:
Martin v. Löwis <martin@v.loewis.de>
parents:
21834
diff
changeset
|
1255 "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
|
1256 return NULL; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1257 default: |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1258 *p++ = '\\'; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1259 *p++ = s[-1]; |
|
2d6cf68aa64a
changed \x to consume exactly two hex digits. implements PEP-223
Fredrik Lundh <fredrik@pythonware.com>
parents:
14375
diff
changeset
|
1260 break; |
| 69 | 1261 } |
| 1262 } | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1263 _PyString_Resize(&v, (int)(p - buf)); |
| 69 | 1264 return v; |
| 1265 } | |
| 1266 | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1267 static PyObject * |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1268 parsestrplus(struct compiling* c, node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1269 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1270 PyObject *v; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1271 int i; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1272 REQ(CHILD(n, 0), STRING); |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1273 if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) { |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1274 /* String literal concatenation */ |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1275 for (i = 1; i < NCH(n); i++) { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1276 PyObject *s; |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1277 s = parsestr(c, STR(CHILD(n, i))); |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1278 if (s == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1279 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1280 if (PyString_Check(v) && PyString_Check(s)) { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1281 PyString_ConcatAndDel(&v, s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1282 if (v == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1283 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1284 } |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1285 #ifdef Py_USING_UNICODE |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1286 else { |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1287 PyObject *temp; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1288 temp = PyUnicode_Concat(v, s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1289 Py_DECREF(s); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1290 if (temp == NULL) |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1291 goto onError; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1292 Py_DECREF(v); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1293 v = temp; |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1294 } |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1295 #endif |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1296 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1297 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1298 return v; |
|
12388
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1299 |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1300 onError: |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1301 Py_XDECREF(v); |
|
c48172af13dc
M.-A. Lemburg <mal@lemburg.com>:
Fred Drake <fdrake@acm.org>
parents:
12333
diff
changeset
|
1302 return NULL; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1303 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
1304 |
| 69 | 1305 static void |
| 13936 | 1306 com_list_for(struct compiling *c, node *n, node *e, char *t) |
| 1307 { | |
| 1308 int anchor = 0; | |
| 1309 int save_begin = c->c_begin; | |
| 1310 | |
| 1311 /* list_iter: for v in expr [list_iter] */ | |
| 1312 com_node(c, CHILD(n, 3)); /* expr */ | |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
1313 com_addbyte(c, GET_ITER); |
| 13936 | 1314 c->c_begin = c->c_nexti; |
| 1315 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
|
1316 com_addfwref(c, FOR_ITER, &anchor); |
| 13936 | 1317 com_push(c, 1); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1318 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL); |
| 13936 | 1319 c->c_loops++; |
| 1320 com_list_iter(c, n, e, t); | |
| 1321 c->c_loops--; | |
| 1322 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); | |
| 1323 c->c_begin = save_begin; | |
| 1324 com_backpatch(c, anchor); | |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
1325 com_pop(c, 1); /* FOR_ITER has popped this */ |
| 13936 | 1326 } |
| 1327 | |
| 1328 static void | |
| 1329 com_list_if(struct compiling *c, node *n, node *e, char *t) | |
| 1330 { | |
| 1331 int anchor = 0; | |
| 1332 int a = 0; | |
| 1333 /* list_iter: 'if' test [list_iter] */ | |
| 1334 com_addoparg(c, SET_LINENO, n->n_lineno); | |
| 1335 com_node(c, CHILD(n, 1)); | |
| 1336 com_addfwref(c, JUMP_IF_FALSE, &a); | |
| 1337 com_addbyte(c, POP_TOP); | |
| 1338 com_pop(c, 1); | |
| 1339 com_list_iter(c, n, e, t); | |
| 1340 com_addfwref(c, JUMP_FORWARD, &anchor); | |
| 1341 com_backpatch(c, a); | |
| 1342 /* We jump here with an extra entry which we now pop */ | |
| 1343 com_addbyte(c, POP_TOP); | |
| 1344 com_backpatch(c, anchor); | |
| 1345 } | |
| 1346 | |
| 1347 static void | |
| 1348 com_list_iter(struct compiling *c, | |
| 1349 node *p, /* parent of list_iter node */ | |
| 1350 node *e, /* element expression node */ | |
| 1351 char *t /* name of result list temp local */) | |
| 69 | 1352 { |
| 13936 | 1353 /* list_iter is the last child in a listmaker, list_for, or list_if */ |
| 1354 node *n = CHILD(p, NCH(p)-1); | |
| 1355 if (TYPE(n) == list_iter) { | |
| 1356 n = CHILD(n, 0); | |
| 1357 switch (TYPE(n)) { | |
| 1358 case list_for: | |
| 1359 com_list_for(c, n, e, t); | |
| 1360 break; | |
| 1361 case list_if: | |
| 1362 com_list_if(c, n, e, t); | |
| 1363 break; | |
| 1364 default: | |
| 1365 com_error(c, PyExc_SystemError, | |
| 1366 "invalid list_iter node type"); | |
| 1367 } | |
| 1368 } | |
| 1369 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
|
1370 com_addop_varname(c, VAR_LOAD, t); |
| 13936 | 1371 com_push(c, 1); |
| 1372 com_node(c, e); | |
| 1373 com_addoparg(c, CALL_FUNCTION, 1); | |
| 1374 com_addbyte(c, POP_TOP); | |
| 1375 com_pop(c, 2); | |
| 1376 } | |
| 1377 } | |
| 1378 | |
| 1379 static void | |
| 1380 com_list_comprehension(struct compiling *c, node *n) | |
| 1381 { | |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1382 /* listmaker: test list_for */ |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
1383 char tmpname[30]; |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
1384 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", ++c->c_tmpname); |
| 13936 | 1385 com_addoparg(c, BUILD_LIST, 0); |
| 1386 com_addbyte(c, DUP_TOP); /* leave the result on the stack */ | |
| 1387 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
|
1388 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
|
1389 com_addop_varname(c, VAR_STORE, tmpname); |
| 13936 | 1390 com_pop(c, 1); |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1391 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
|
1392 com_addop_varname(c, VAR_DELETE, tmpname); |
| 13936 | 1393 --c->c_tmpname; |
| 1394 } | |
| 1395 | |
| 1396 static void | |
| 1397 com_listmaker(struct compiling *c, node *n) | |
| 1398 { | |
|
14117
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1399 /* listmaker: test ( list_for | (',' test)* [','] ) */ |
|
ac8809959d01
require list comprehensions to start with a for clause
Skip Montanaro <skip@pobox.com>
parents:
14105
diff
changeset
|
1400 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == list_for) |
| 13936 | 1401 com_list_comprehension(c, n); |
| 1402 else { | |
| 1403 int len = 0; | |
| 1404 int i; | |
| 1405 for (i = 0; i < NCH(n); i += 2, len++) | |
| 1406 com_node(c, CHILD(n, i)); | |
| 1407 com_addoparg(c, BUILD_LIST, len); | |
| 1408 com_pop(c, len-1); | |
| 1409 } | |
| 69 | 1410 } |
| 1411 | |
| 1412 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1413 com_dictmaker(struct compiling *c, node *n) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1414 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1415 int i; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1416 /* dictmaker: test ':' test (',' test ':' value)* [','] */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1417 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
|
1418 /* 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
|
1419 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
|
1420 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
|
1421 com_push(c, 1); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1422 com_node(c, CHILD(n, i+2)); /* value */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1423 com_addbyte(c, ROT_TWO); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1424 com_node(c, CHILD(n, i)); /* key */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1425 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
|
1426 com_pop(c, 3); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1427 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1428 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1429 |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1430 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1431 com_atom(struct compiling *c, node *n) |
| 69 | 1432 { |
| 1433 node *ch; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1434 PyObject *v; |
| 69 | 1435 int i; |
| 1436 REQ(n, atom); | |
| 1437 ch = CHILD(n, 0); | |
| 1438 switch (TYPE(ch)) { | |
| 1439 case LPAR: | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1440 if (TYPE(CHILD(n, 1)) == RPAR) { |
| 69 | 1441 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
|
1442 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
|
1443 } |
| 69 | 1444 else |
| 1445 com_node(c, CHILD(n, 1)); | |
| 1446 break; | |
| 13936 | 1447 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
|
1448 if (TYPE(CHILD(n, 1)) == RSQB) { |
| 69 | 1449 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
|
1450 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
|
1451 } |
| 69 | 1452 else |
| 13936 | 1453 com_listmaker(c, CHILD(n, 1)); |
| 69 | 1454 break; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1455 case LBRACE: /* '{' [dictmaker] '}' */ |
| 69 | 1456 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
|
1457 com_push(c, 1); |
| 13936 | 1458 if (TYPE(CHILD(n, 1)) == dictmaker) |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
1459 com_dictmaker(c, CHILD(n, 1)); |
| 69 | 1460 break; |
| 1461 case BACKQUOTE: | |
| 1462 com_node(c, CHILD(n, 1)); | |
| 1463 com_addbyte(c, UNARY_CONVERT); | |
| 1464 break; | |
| 1465 case NUMBER: | |
|
4315
46d736fb9da3
Added line number to most compile-time error messages.
Guido van Rossum <guido@python.org>
parents:
4131
diff
changeset
|
1466 if ((v = parsenumber(c, STR(ch))) == NULL) { |
| 69 | 1467 i = 255; |
| 1468 } | |
| 1469 else { | |
| 1470 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
|
1471 Py_DECREF(v); |
| 69 | 1472 } |
| 1473 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
|
1474 com_push(c, 1); |
| 69 | 1475 break; |
| 1476 case STRING: | |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
1477 v = parsestrplus(c, n); |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
1478 if (v == NULL) { |
| 69 | 1479 c->c_errors++; |
| 1480 i = 255; | |
| 1481 } | |
| 1482 else { | |
| 1483 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
|
1484 Py_DECREF(v); |
| 69 | 1485 } |
| 1486 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
|
1487 com_push(c, 1); |
| 69 | 1488 break; |
| 1489 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
|
1490 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
|
1491 com_push(c, 1); |
| 69 | 1492 break; |
| 1493 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1494 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
|
1495 "com_atom: unexpected node type"); |
| 69 | 1496 } |
| 1497 } | |
| 1498 | |
| 1499 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1500 com_slice(struct compiling *c, node *n, int op) |
| 69 | 1501 { |
| 1502 if (NCH(n) == 1) { | |
| 1503 com_addbyte(c, op); | |
| 1504 } | |
| 1505 else if (NCH(n) == 2) { | |
| 1506 if (TYPE(CHILD(n, 0)) != COLON) { | |
| 1507 com_node(c, CHILD(n, 0)); | |
| 1508 com_addbyte(c, op+1); | |
| 1509 } | |
| 1510 else { | |
| 1511 com_node(c, CHILD(n, 1)); | |
| 1512 com_addbyte(c, op+2); | |
| 1513 } | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1514 com_pop(c, 1); |
| 69 | 1515 } |
| 1516 else { | |
| 1517 com_node(c, CHILD(n, 0)); | |
| 1518 com_node(c, CHILD(n, 2)); | |
| 1519 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
|
1520 com_pop(c, 2); |
| 69 | 1521 } |
| 1522 } | |
| 1523 | |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1524 static void |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1525 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
|
1526 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1527 if (NCH(n) == 1) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1528 com_addbyte(c, DUP_TOP); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1529 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1530 com_addbyte(c, SLICE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1531 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1532 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1533 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1534 com_addbyte(c, ROT_TWO); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1535 com_addbyte(c, STORE_SLICE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1536 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1537 } 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
|
1538 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
|
1539 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
|
1540 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1541 com_addbyte(c, SLICE+1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1542 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1543 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1544 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1545 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1546 com_addbyte(c, ROT_THREE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1547 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
|
1548 com_pop(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1549 } else if (NCH(n) == 2) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1550 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
|
1551 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
|
1552 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1553 com_addbyte(c, SLICE+2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1554 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1555 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1556 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1557 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1558 com_addbyte(c, ROT_THREE); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1559 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
|
1560 com_pop(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1561 } else { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1562 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
|
1563 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
|
1564 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
|
1565 com_push(c, 3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1566 com_addbyte(c, SLICE+3); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1567 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1568 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1569 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1570 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1571 com_addbyte(c, ROT_FOUR); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1572 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
|
1573 com_pop(c, 4); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1574 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1575 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1576 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1577 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1578 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
|
1579 { |
|
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
|
1580 node *m; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1581 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
|
1582 if (NCH(n) == 1) { |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1583 if (*pkeywords != NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1584 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
|
1585 "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
|
1586 } |
|
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
|
1587 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
|
1588 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
|
1589 } |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1590 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
|
1591 } |
|
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
|
1592 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
|
1593 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
|
1594 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
|
1595 } 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
|
1596 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
|
1597 /* 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
|
1598 * 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
|
1599 * 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
|
1600 * then is very confusing. |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1601 */ |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1602 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
|
1603 TYPE(m) == lambdef ? |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1604 "lambda cannot contain assignment" : |
|
1a5a441772ff
Bug #132313 error message confusing for assignment in lambda.
Tim Peters <tim.peters@gmail.com>
parents:
16638
diff
changeset
|
1605 "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
|
1606 } |
|
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
|
1607 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1608 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
|
1609 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
|
1610 *pkeywords = PyDict_New(); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1611 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
|
1612 c->c_errors++; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1613 else if (*pkeywords == NULL) { |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1614 c->c_errors++; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1615 Py_DECREF(v); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
1616 } else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1617 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
|
1618 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
|
1619 "duplicate keyword argument"); |
|
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1620 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1621 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
|
1622 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
|
1623 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
|
1624 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
|
1625 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
|
1626 } |
|
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
|
1627 } |
|
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
|
1628 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
|
1629 } |
|
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 |
| 69 | 1631 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1632 com_call_function(struct compiling *c, node *n) |
| 69 | 1633 { |
| 1634 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
|
1635 com_addoparg(c, CALL_FUNCTION, 0); |
| 69 | 1636 } |
| 1637 else { | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1638 PyObject *keywords = NULL; |
|
4905
32220c5728f5
Check for duplicate keyword arguments at compile time.
Guido van Rossum <guido@python.org>
parents:
4596
diff
changeset
|
1639 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
|
1640 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
|
1641 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
|
1642 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
|
1643 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
|
1644 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
|
1645 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
|
1646 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
|
1647 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
|
1648 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
|
1649 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
|
1650 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
|
1651 break; |
|
9625
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1652 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
|
1653 lineno = ch->n_lineno; |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1654 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
|
1655 } |
|
1fe48009d8ea
Add more SET_LINENO instructions in long argument lists
Guido van Rossum <guido@python.org>
parents:
9293
diff
changeset
|
1656 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
|
1657 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
|
1658 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
|
1659 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
|
1660 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
|
1661 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1662 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
|
1663 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
|
1664 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
|
1665 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
|
1666 i += 3; |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1667 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
|
1668 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
|
1669 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
|
1670 } |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1671 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
|
1672 } |
|
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
|
1673 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
|
1674 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
|
1675 "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
|
1676 } |
|
12082
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1677 if (star_flag || starstar_flag) |
|
12086
96ea1a800b23
remove reference (vestigal) to CALL_FUNCTION_STAR
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12082
diff
changeset
|
1678 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
|
1679 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
|
1680 else |
|
603db0d0aed1
slightly modified version of Greg Ewing's extended call syntax patch
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
11974
diff
changeset
|
1681 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
|
1682 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
|
1683 com_pop(c, na + 2*nk + star_flag + starstar_flag); |
| 69 | 1684 } |
| 1685 } | |
| 1686 | |
| 1687 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1688 com_select_member(struct compiling *c, node *n) |
| 69 | 1689 { |
| 1690 com_addopname(c, LOAD_ATTR, n); | |
| 1691 } | |
| 1692 | |
| 1693 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1694 com_sliceobj(struct compiling *c, node *n) |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1695 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1696 int i=0; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1697 int ns=2; /* number of slice arguments */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1698 node *ch; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1699 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1700 /* first argument */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1701 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
|
1702 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
|
1703 com_push(c, 1); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1704 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1705 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1706 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1707 com_node(c, CHILD(n,i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1708 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1709 REQ(CHILD(n,i),COLON); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1710 i++; |
|
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 /* second argument */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1713 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
|
1714 com_node(c, CHILD(n,i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1715 i++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1716 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1717 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1718 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
|
1719 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
|
1720 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1721 /* remaining arguments */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1722 for (; i < NCH(n); i++) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1723 ns++; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1724 ch=CHILD(n,i); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1725 REQ(ch, sliceop); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1726 if (NCH(ch) == 1) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1727 /* 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
|
1728 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
|
1729 com_push(c, 1); |
|
3839
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 else |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1732 com_node(c, CHILD(ch,1)); |
|
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 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
|
1735 com_pop(c, 1 + (ns == 3)); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1736 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1737 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1738 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1739 com_subscript(struct compiling *c, node *n) |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1740 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1741 node *ch; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1742 REQ(n, subscript); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1743 ch = CHILD(n,0); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1744 /* 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
|
1745 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
|
1746 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
|
1747 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
|
1748 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1749 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1750 /* check for slice */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1751 if ((TYPE(ch) == COLON || NCH(n) > 1)) |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1752 com_sliceobj(c, n); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1753 else { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1754 REQ(ch, test); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1755 com_node(c, ch); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1756 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1757 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1758 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1759 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1760 static void |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1761 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
|
1762 { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1763 int i, op; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1764 REQ(n, subscriptlist); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1765 /* 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
|
1766 if (NCH(n) == 1) { |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1767 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
|
1768 /* '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
|
1769 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
|
1770 || (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
|
1771 && (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
|
1772 { |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1773 switch (assigning) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1774 case OP_DELETE: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1775 op = DELETE_SLICE; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1776 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1777 case OP_ASSIGN: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1778 op = STORE_SLICE; |
|
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 case OP_APPLY: |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1781 op = SLICE; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1782 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1783 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1784 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
|
1785 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1786 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1787 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
|
1788 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
|
1789 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
|
1790 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
|
1791 com_pop(c, 1); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1792 return; |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1793 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1794 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1795 /* Else normal subscriptlist. Compile each subscript. */ |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1796 for (i = 0; i < NCH(n); i += 2) |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1797 com_subscript(c, CHILD(n, i)); |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1798 /* 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
|
1799 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
|
1800 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
|
1801 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
|
1802 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
|
1803 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1804 switch (assigning) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1805 case OP_DELETE: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1806 op = DELETE_SUBSCR; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1807 i = 2; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1808 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1809 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1810 case OP_ASSIGN: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1811 op = STORE_SUBSCR; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1812 i = 3; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1813 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1814 case OP_APPLY: |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1815 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
|
1816 i = 1; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1817 break; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
1818 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1819 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1820 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
|
1821 com_push(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1822 com_addbyte(c, BINARY_SUBSCR); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1823 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1824 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1825 com_addbyte(c, assigning); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1826 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1827 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
|
1828 } |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1829 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
|
1830 com_pop(c, i); |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1831 } |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1832 |
|
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
1833 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1834 com_apply_trailer(struct compiling *c, node *n) |
| 69 | 1835 { |
| 1836 REQ(n, trailer); | |
| 1837 switch (TYPE(CHILD(n, 0))) { | |
| 1838 case LPAR: | |
| 1839 com_call_function(c, CHILD(n, 1)); | |
| 1840 break; | |
| 1841 case DOT: | |
| 1842 com_select_member(c, CHILD(n, 1)); | |
| 1843 break; | |
| 1844 case LSQB: | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
1845 com_subscriptlist(c, CHILD(n, 1), OP_APPLY, NULL); |
| 69 | 1846 break; |
| 1847 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
1848 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
|
1849 "com_apply_trailer: unknown trailer type"); |
| 69 | 1850 } |
| 1851 } | |
| 1852 | |
| 1853 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1854 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
|
1855 { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1856 int i; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1857 REQ(n, power); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1858 com_atom(c, CHILD(n, 0)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1859 for (i = 1; i < NCH(n); i++) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1860 if (TYPE(CHILD(n, i)) == DOUBLESTAR) { |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1861 com_factor(c, CHILD(n, i+1)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1862 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
|
1863 com_pop(c, 1); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1864 break; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1865 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1866 else |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1867 com_apply_trailer(c, CHILD(n, i)); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1868 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1869 } |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1870 |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1871 static void |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1872 com_invert_constant(struct compiling *c, node *n) |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1873 { |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1874 /* Compute the inverse of int and longs and use them directly, |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1875 but be prepared to generate code for all other |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1876 possibilities (invalid numbers, floats, complex). |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1877 */ |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1878 PyObject *num, *inv = NULL; |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1879 int i; |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1880 |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1881 REQ(n, NUMBER); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1882 num = parsenumber(c, STR(n)); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1883 if (num == NULL) |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1884 i = 255; |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1885 else { |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1886 inv = PyNumber_Invert(num); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1887 if (inv == NULL) { |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1888 PyErr_Clear(); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1889 i = com_addconst(c, num); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1890 } else { |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1891 i = com_addconst(c, inv); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1892 Py_DECREF(inv); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1893 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1894 Py_DECREF(num); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1895 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1896 com_addoparg(c, LOAD_CONST, i); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1897 com_push(c, 1); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1898 if (num != NULL && inv == NULL) |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1899 com_addbyte(c, UNARY_INVERT); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1900 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1901 |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1902 static int |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1903 is_float_zero(const char *p) |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1904 { |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1905 int found_radix_point = 0; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1906 int ch; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1907 while ((ch = Py_CHARMASK(*p++)) != '\0') { |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1908 switch (ch) { |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1909 case '0': |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1910 /* no reason to believe it's not 0 -- continue */ |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1911 break; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1912 |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1913 case 'e': case 'E': case 'j': case 'J': |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1914 /* If this was a hex constant, we already would have |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1915 returned 0 due to the 'x' or 'X', so 'e' or 'E' |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1916 must be an exponent marker, and we haven't yet |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1917 seen a non-zero digit, and it doesn't matter what |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1918 the exponent is then. For 'j' or 'J' similarly, |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1919 except that this is an imaginary 0 then. */ |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1920 return 1; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1921 |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1922 case '.': |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1923 found_radix_point = 1; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1924 break; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1925 |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1926 default: |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1927 return 0; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1928 } |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1929 } |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1930 return found_radix_point; |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1931 } |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1932 |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1933 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1934 com_factor(struct compiling *c, node *n) |
| 69 | 1935 { |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1936 int childtype = TYPE(CHILD(n, 0)); |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1937 node *pfactor, *ppower, *patom, *pnum; |
| 69 | 1938 REQ(n, factor); |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1939 /* If the unary +, -, or ~ operator is applied to a constant, |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1940 don't generate a UNARY_xxx opcode. Just store the |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1941 approriate value as a constant. If the value is negative, |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1942 extend the string containing the constant and insert a |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1943 negative in the 0th position -- unless we're doing unary minus |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1944 of a floating zero! In that case the sign is significant, but |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1945 the const dict can't distinguish +0.0 from -0.0. |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1946 */ |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1947 if ((childtype == PLUS || childtype == MINUS || childtype == TILDE) |
|
19613
f7cf8961c667
When re-writing a factor containing a unary negation of a literal, only
Fred Drake <fdrake@acm.org>
parents:
19601
diff
changeset
|
1948 && NCH(n) == 2 |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1949 && TYPE((pfactor = CHILD(n, 1))) == factor |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1950 && NCH(pfactor) == 1 |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1951 && TYPE((ppower = CHILD(pfactor, 0))) == power |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1952 && NCH(ppower) == 1 |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1953 && TYPE((patom = CHILD(ppower, 0))) == atom |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1954 && TYPE((pnum = CHILD(patom, 0))) == NUMBER |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1955 && !(childtype == MINUS && is_float_zero(STR(pnum)))) { |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1956 if (childtype == TILDE) { |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1957 com_invert_constant(c, pnum); |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1958 return; |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1959 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1960 if (childtype == MINUS) { |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1961 char *s = malloc(strlen(STR(pnum)) + 2); |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1962 if (s == NULL) { |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1963 com_error(c, PyExc_MemoryError, ""); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1964 com_addbyte(c, 255); |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1965 return; |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1966 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1967 s[0] = '-'; |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1968 strcpy(s + 1, STR(pnum)); |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1969 free(STR(pnum)); |
|
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1970 STR(pnum) = s; |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1971 } |
|
19793
e2e9f1722c4f
SF bug [#458941] Looks like a unary minus bug.
Tim Peters <tim.peters@gmail.com>
parents:
19613
diff
changeset
|
1972 com_atom(c, patom); |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1973 } |
|
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1974 else if (childtype == PLUS) { |
| 69 | 1975 com_factor(c, CHILD(n, 1)); |
| 1976 com_addbyte(c, UNARY_POSITIVE); | |
| 1977 } | |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1978 else if (childtype == MINUS) { |
| 69 | 1979 com_factor(c, CHILD(n, 1)); |
| 1980 com_addbyte(c, UNARY_NEGATIVE); | |
| 1981 } | |
|
19187
30f8b654c2e5
SF Patch [ 429024 ] deal with some unary ops at compile time
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19177
diff
changeset
|
1982 else if (childtype == TILDE) { |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1983 com_factor(c, CHILD(n, 1)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1984 com_addbyte(c, UNARY_INVERT); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
1985 } |
| 69 | 1986 else { |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
1987 com_power(c, CHILD(n, 0)); |
| 69 | 1988 } |
| 1989 } | |
| 1990 | |
| 1991 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
1992 com_term(struct compiling *c, node *n) |
| 69 | 1993 { |
| 1994 int i; | |
| 1995 int op; | |
| 1996 REQ(n, term); | |
| 1997 com_factor(c, CHILD(n, 0)); | |
| 1998 for (i = 2; i < NCH(n); i += 2) { | |
| 1999 com_factor(c, CHILD(n, i)); | |
| 2000 switch (TYPE(CHILD(n, i-1))) { | |
| 2001 case STAR: | |
| 2002 op = BINARY_MULTIPLY; | |
| 2003 break; | |
| 2004 case SLASH: | |
|
19051
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2005 if (c->c_flags & CO_FUTURE_DIVISION) |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2006 op = BINARY_TRUE_DIVIDE; |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2007 else |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2008 op = BINARY_DIVIDE; |
| 69 | 2009 break; |
| 2010 case PERCENT: | |
| 2011 op = BINARY_MODULO; | |
| 2012 break; | |
|
19051
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2013 case DOUBLESLASH: |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2014 op = BINARY_FLOOR_DIVIDE; |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2015 break; |
| 69 | 2016 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2017 com_error(c, PyExc_SystemError, |
|
19051
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2018 "com_term: operator not *, /, // or %"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2019 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2020 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2021 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
|
2022 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2023 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2024 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2025 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2026 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2027 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
|
2028 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2029 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2030 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2031 REQ(n, arith_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2032 com_term(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2033 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2034 com_term(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2035 switch (TYPE(CHILD(n, i-1))) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2036 case PLUS: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2037 op = BINARY_ADD; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2038 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2039 case MINUS: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2040 op = BINARY_SUBTRACT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2041 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2042 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2043 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
|
2044 "com_arith_expr: operator not + or -"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2045 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2046 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2047 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
|
2048 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2049 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2050 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2051 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2052 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2053 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
|
2054 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2055 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2056 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2057 REQ(n, shift_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2058 com_arith_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2059 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2060 com_arith_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2061 switch (TYPE(CHILD(n, i-1))) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2062 case LEFTSHIFT: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2063 op = BINARY_LSHIFT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2064 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2065 case RIGHTSHIFT: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2066 op = BINARY_RSHIFT; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2067 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2068 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2069 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
|
2070 "com_shift_expr: operator not << or >>"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2071 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2072 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2073 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
|
2074 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2075 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2076 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2077 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2078 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2079 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
|
2080 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2081 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2082 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2083 REQ(n, and_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2084 com_shift_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2085 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2086 com_shift_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2087 if (TYPE(CHILD(n, i-1)) == AMPER) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2088 op = BINARY_AND; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2089 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2090 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2091 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
|
2092 "com_and_expr: operator not &"); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2093 op = 255; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2094 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2095 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
|
2096 com_pop(c, 1); |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2097 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2098 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2099 |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2100 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2101 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
|
2102 { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2103 int i; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2104 int op; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2105 REQ(n, xor_expr); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2106 com_and_expr(c, CHILD(n, 0)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2107 for (i = 2; i < NCH(n); i += 2) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2108 com_and_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2109 if (TYPE(CHILD(n, i-1)) == CIRCUMFLEX) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2110 op = BINARY_XOR; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2111 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2112 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2113 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
|
2114 "com_xor_expr: operator not ^"); |
| 69 | 2115 op = 255; |
| 2116 } | |
| 2117 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
|
2118 com_pop(c, 1); |
| 69 | 2119 } |
| 2120 } | |
| 2121 | |
| 2122 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2123 com_expr(struct compiling *c, node *n) |
| 69 | 2124 { |
| 2125 int i; | |
| 2126 int op; | |
| 2127 REQ(n, expr); | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2128 com_xor_expr(c, CHILD(n, 0)); |
| 69 | 2129 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
|
2130 com_xor_expr(c, CHILD(n, i)); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2131 if (TYPE(CHILD(n, i-1)) == VBAR) { |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2132 op = BINARY_OR; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2133 } |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2134 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2135 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
|
2136 "com_expr: expr operator not |"); |
| 69 | 2137 op = 255; |
| 2138 } | |
| 2139 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
|
2140 com_pop(c, 1); |
| 69 | 2141 } |
| 2142 } | |
| 2143 | |
| 2144 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
|
2145 cmp_type(node *n) |
| 69 | 2146 { |
| 2147 REQ(n, comp_op); | |
|
388
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2148 /* comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '==' |
| 69 | 2149 | 'in' | 'not' 'in' | 'is' | 'is' not' */ |
| 2150 if (NCH(n) == 1) { | |
| 2151 n = CHILD(n, 0); | |
| 2152 switch (TYPE(n)) { | |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2153 case LESS: return PyCmp_LT; |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2154 case GREATER: return PyCmp_GT; |
|
388
31d509e94271
Comment out 'abort()' call.
Guido van Rossum <guido@python.org>
parents:
336
diff
changeset
|
2155 case EQEQUAL: /* == */ |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2156 case EQUAL: return PyCmp_EQ; |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2157 case LESSEQUAL: return PyCmp_LE; |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2158 case GREATEREQUAL: return PyCmp_GE; |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2159 case NOTEQUAL: return PyCmp_NE; /* <> or != */ |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2160 case NAME: if (strcmp(STR(n), "in") == 0) return PyCmp_IN; |
|
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2161 if (strcmp(STR(n), "is") == 0) return PyCmp_IS; |
| 69 | 2162 } |
| 2163 } | |
| 2164 else if (NCH(n) == 2) { | |
| 2165 switch (TYPE(CHILD(n, 0))) { | |
| 2166 case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0) | |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2167 return PyCmp_NOT_IN; |
| 69 | 2168 if (strcmp(STR(CHILD(n, 0)), "is") == 0) |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2169 return PyCmp_IS_NOT; |
| 69 | 2170 } |
| 2171 } | |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2172 return PyCmp_BAD; |
| 69 | 2173 } |
| 2174 | |
| 2175 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2176 com_comparison(struct compiling *c, node *n) |
| 69 | 2177 { |
| 2178 int i; | |
| 2179 enum cmp_op op; | |
| 2180 int anchor; | |
| 2181 REQ(n, comparison); /* comparison: expr (comp_op expr)* */ | |
| 2182 com_expr(c, CHILD(n, 0)); | |
| 2183 if (NCH(n) == 1) | |
| 2184 return; | |
| 2185 | |
| 2186 /**************************************************************** | |
| 2187 The following code is generated for all but the last | |
| 2188 comparison in a chain: | |
| 2189 | |
| 2190 label: on stack: opcode: jump to: | |
| 2191 | |
| 2192 a <code to load b> | |
| 2193 a, b DUP_TOP | |
| 2194 a, b, b ROT_THREE | |
| 2195 b, a, b COMPARE_OP | |
| 2196 b, 0-or-1 JUMP_IF_FALSE L1 | |
| 2197 b, 1 POP_TOP | |
| 2198 b | |
| 2199 | |
| 2200 We are now ready to repeat this sequence for the next | |
| 2201 comparison in the chain. | |
| 2202 | |
| 2203 For the last we generate: | |
| 2204 | |
| 2205 b <code to load c> | |
| 2206 b, c COMPARE_OP | |
| 2207 0-or-1 | |
| 2208 | |
| 2209 If there were any jumps to L1 (i.e., there was more than one | |
| 2210 comparison), we generate: | |
| 2211 | |
| 2212 0-or-1 JUMP_FORWARD L2 | |
| 2213 L1: b, 0 ROT_TWO | |
| 2214 0, b POP_TOP | |
| 2215 0 | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2216 L2: 0-or-1 |
| 69 | 2217 ****************************************************************/ |
| 2218 | |
| 2219 anchor = 0; | |
| 2220 | |
| 2221 for (i = 2; i < NCH(n); i += 2) { | |
| 2222 com_expr(c, CHILD(n, i)); | |
| 2223 if (i+2 < NCH(n)) { | |
| 2224 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
|
2225 com_push(c, 1); |
| 69 | 2226 com_addbyte(c, ROT_THREE); |
| 2227 } | |
| 2228 op = cmp_type(CHILD(n, i-1)); | |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
2229 if (op == PyCmp_BAD) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2230 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
|
2231 "com_comparison: unknown comparison op"); |
| 69 | 2232 } |
| 2233 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
|
2234 com_pop(c, 1); |
| 69 | 2235 if (i+2 < NCH(n)) { |
| 2236 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 2237 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
|
2238 com_pop(c, 1); |
| 69 | 2239 } |
| 2240 } | |
| 2241 | |
| 2242 if (anchor) { | |
| 2243 int anchor2 = 0; | |
| 2244 com_addfwref(c, JUMP_FORWARD, &anchor2); | |
| 2245 com_backpatch(c, anchor); | |
| 2246 com_addbyte(c, ROT_TWO); | |
| 2247 com_addbyte(c, POP_TOP); | |
| 2248 com_backpatch(c, anchor2); | |
| 2249 } | |
| 2250 } | |
| 2251 | |
| 2252 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2253 com_not_test(struct compiling *c, node *n) |
| 69 | 2254 { |
| 2255 REQ(n, not_test); /* 'not' not_test | comparison */ | |
| 2256 if (NCH(n) == 1) { | |
| 2257 com_comparison(c, CHILD(n, 0)); | |
| 2258 } | |
| 2259 else { | |
| 2260 com_not_test(c, CHILD(n, 1)); | |
| 2261 com_addbyte(c, UNARY_NOT); | |
| 2262 } | |
| 2263 } | |
| 2264 | |
| 2265 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2266 com_and_test(struct compiling *c, node *n) |
| 69 | 2267 { |
| 2268 int i; | |
| 2269 int anchor; | |
| 2270 REQ(n, and_test); /* not_test ('and' not_test)* */ | |
| 2271 anchor = 0; | |
| 2272 i = 0; | |
| 2273 for (;;) { | |
| 2274 com_not_test(c, CHILD(n, i)); | |
| 2275 if ((i += 2) >= NCH(n)) | |
| 2276 break; | |
| 2277 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 2278 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
|
2279 com_pop(c, 1); |
| 69 | 2280 } |
| 2281 if (anchor) | |
| 2282 com_backpatch(c, anchor); | |
| 2283 } | |
| 2284 | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2285 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2286 com_make_closure(struct compiling *c, PyCodeObject *co) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2287 { |
|
21398
de125792bfaa
Fix for SF bug [ #492403 ] exec() segfaults on closure's func_code
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
21179
diff
changeset
|
2288 int i, free = PyCode_GetNumFree(co); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2289 if (free == 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2290 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2291 for (i = 0; i < free; ++i) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2292 /* Bypass com_addop_varname because it will generate |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2293 LOAD_DEREF but LOAD_CLOSURE is needed. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2294 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2295 PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2296 int arg, reftype; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2297 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2298 /* Special case: If a class contains a method with a |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2299 free variable that has the same name as a method, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2300 the name will be considered free *and* local in the |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2301 class. It should be handled by the closure, as |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2302 well as by the normal name loookup logic. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2303 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2304 reftype = get_ref_type(c, PyString_AS_STRING(name)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2305 if (reftype == CELL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2306 arg = com_lookup_arg(c->c_cellvars, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2307 else /* (reftype == FREE) */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2308 arg = com_lookup_arg(c->c_freevars, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2309 if (arg == -1) { |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2310 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
|
2311 "freevars of %s: %s\n", |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2312 PyObject_REPR(name), |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2313 c->c_name, |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2314 reftype, arg, |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
2315 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
|
2316 PyObject_REPR(co->co_freevars)); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2317 Py_FatalError("com_make_closure()"); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2318 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2319 com_addoparg(c, LOAD_CLOSURE, arg); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2320 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2321 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2322 com_push(c, free); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2323 return 1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2324 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2325 |
| 69 | 2326 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2327 com_test(struct compiling *c, node *n) |
| 69 | 2328 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2329 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
|
2330 if (NCH(n) == 1 && TYPE(CHILD(n, 0)) == lambdef) { |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2331 PyCodeObject *co; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2332 int i, closure; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
2333 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
|
2334 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
|
2335 n->n_lineno); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2336 co = 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
|
2337 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
|
2338 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
|
2339 return; |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2340 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2341 symtable_exit_scope(c->c_symtable); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2342 i = com_addconst(c, (PyObject *)co); |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2343 closure = com_make_closure(c, 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
|
2344 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
|
2345 com_push(c, 1); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2346 if (closure) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2347 com_addoparg(c, MAKE_CLOSURE, ndefs); |
|
21398
de125792bfaa
Fix for SF bug [ #492403 ] exec() segfaults on closure's func_code
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
21179
diff
changeset
|
2348 com_pop(c, PyCode_GetNumFree(co)); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2349 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2350 com_addoparg(c, MAKE_FUNCTION, ndefs); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
2351 Py_DECREF(co); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2352 com_pop(c, ndefs); |
| 69 | 2353 } |
|
1417
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2354 else { |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2355 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
|
2356 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
|
2357 for (;;) { |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2358 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
|
2359 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
|
2360 break; |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2361 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
|
2362 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
|
2363 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
|
2364 } |
|
f7edfa6d0dcb
change syntactical position of lambdef (was an atom, now is a test)
Guido van Rossum <guido@python.org>
parents:
1415
diff
changeset
|
2365 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
|
2366 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
|
2367 } |
| 69 | 2368 } |
| 2369 | |
| 2370 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2371 com_list(struct compiling *c, node *n, int toplevel) |
| 69 | 2372 { |
| 2373 /* exprlist: expr (',' expr)* [',']; likewise for testlist */ | |
| 482 | 2374 if (NCH(n) == 1 && !toplevel) { |
| 69 | 2375 com_node(c, CHILD(n, 0)); |
| 2376 } | |
| 2377 else { | |
| 2378 int i; | |
| 2379 int len; | |
| 2380 len = (NCH(n) + 1) / 2; | |
| 2381 for (i = 0; i < NCH(n); i += 2) | |
| 2382 com_node(c, CHILD(n, i)); | |
| 2383 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
|
2384 com_pop(c, len-1); |
| 69 | 2385 } |
| 2386 } | |
| 2387 | |
| 2388 | |
| 2389 /* Begin of assignment compilation */ | |
| 2390 | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2391 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2392 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2393 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
|
2394 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2395 com_addbyte(c, DUP_TOP); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2396 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2397 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
|
2398 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2399 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2400 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2401 com_addbyte(c, ROT_TWO); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2402 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
|
2403 com_pop(c, 2); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2404 } |
| 69 | 2405 |
| 2406 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2407 com_assign_attr(struct compiling *c, node *n, int assigning) |
| 69 | 2408 { |
| 2409 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
|
2410 com_pop(c, assigning ? 2 : 1); |
| 69 | 2411 } |
| 2412 | |
| 2413 static void | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2414 com_assign_trailer(struct compiling *c, node *n, int assigning, node *augn) |
| 69 | 2415 { |
| 2416 REQ(n, trailer); | |
| 2417 switch (TYPE(CHILD(n, 0))) { | |
| 2418 case LPAR: /* '(' [exprlist] ')' */ | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2419 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
|
2420 "can't assign to function call"); |
| 69 | 2421 break; |
| 2422 case DOT: /* '.' NAME */ | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2423 if (assigning > OP_APPLY) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2424 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
|
2425 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2426 com_assign_attr(c, CHILD(n, 1), assigning); |
| 69 | 2427 break; |
|
3839
22e29b1747e1
Changes for slice and ellipses
Guido van Rossum <guido@python.org>
parents:
3766
diff
changeset
|
2428 case LSQB: /* '[' subscriptlist ']' */ |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2429 com_subscriptlist(c, CHILD(n, 1), assigning, augn); |
| 69 | 2430 break; |
| 2431 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2432 com_error(c, PyExc_SystemError, "unknown trailer type"); |
| 69 | 2433 } |
| 2434 } | |
| 2435 | |
| 2436 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
|
2437 com_assign_sequence(struct compiling *c, node *n, int assigning) |
| 69 | 2438 { |
| 2439 int i; | |
|
14178
dff22d4a48da
Fix allowable node-types for assignment, need to add 'listmaker'.
Thomas Wouters <thomas@python.org>
parents:
14163
diff
changeset
|
2440 if (TYPE(n) != testlist && TYPE(n) != listmaker) |
| 69 | 2441 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
|
2442 if (assigning) { |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2443 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
|
2444 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
|
2445 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
|
2446 } |
| 69 | 2447 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
|
2448 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
|
2449 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2450 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2451 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2452 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
|
2453 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2454 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
|
2455 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
|
2456 com_push(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2457 com_node(c, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2458 com_addbyte(c, opcode); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2459 com_pop(c, 1); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2460 com_assign_name(c, n, OP_ASSIGN); |
| 69 | 2461 } |
| 2462 | |
| 2463 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2464 com_assign_name(struct compiling *c, node *n, int assigning) |
| 69 | 2465 { |
| 2466 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
|
2467 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
|
2468 if (assigning) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2469 com_pop(c, 1); |
| 69 | 2470 } |
| 2471 | |
| 2472 static void | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2473 com_assign(struct compiling *c, node *n, int assigning, node *augn) |
| 69 | 2474 { |
| 2475 /* Loop to avoid trivial recursion */ | |
| 2476 for (;;) { | |
| 2477 switch (TYPE(n)) { | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2478 |
| 69 | 2479 case exprlist: |
| 2480 case testlist: | |
| 2481 if (NCH(n) > 1) { | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2482 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2483 com_error(c, PyExc_SyntaxError, |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
2484 "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
|
2485 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2486 } |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2487 com_assign_sequence(c, n, assigning); |
| 69 | 2488 return; |
| 2489 } | |
| 2490 n = CHILD(n, 0); | |
| 2491 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2492 |
| 69 | 2493 case test: |
| 2494 case and_test: | |
| 2495 case not_test: | |
| 2496 case comparison: | |
| 2497 case expr: | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2498 case xor_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2499 case and_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2500 case shift_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
2501 case arith_expr: |
| 69 | 2502 case term: |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2503 case factor: |
| 69 | 2504 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
|
2505 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
|
2506 "can't assign to operator"); |
| 69 | 2507 return; |
| 2508 } | |
| 2509 n = CHILD(n, 0); | |
| 2510 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2511 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
2512 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
|
2513 ('+'|'-'|'~') factor | atom trailer* */ |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2514 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
|
2515 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
|
2516 "can't assign to operator"); |
| 69 | 2517 return; |
| 2518 } | |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2519 if (NCH(n) > 1) { /* trailer or exponent present */ |
| 69 | 2520 int i; |
| 2521 com_node(c, CHILD(n, 0)); | |
| 2522 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
|
2523 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
|
2524 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
|
2525 "can't assign to operator"); |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2526 return; |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
2527 } |
| 69 | 2528 com_apply_trailer(c, CHILD(n, i)); |
| 2529 } /* NB i is still alive */ | |
| 2530 com_assign_trailer(c, | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2531 CHILD(n, i), assigning, augn); |
| 69 | 2532 return; |
| 2533 } | |
| 2534 n = CHILD(n, 0); | |
| 2535 break; | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2536 |
| 69 | 2537 case atom: |
| 2538 switch (TYPE(CHILD(n, 0))) { | |
| 2539 case LPAR: | |
| 2540 n = CHILD(n, 1); | |
| 2541 if (TYPE(n) == RPAR) { | |
| 2542 /* XXX Should allow () = () ??? */ | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2543 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
|
2544 "can't assign to ()"); |
| 69 | 2545 return; |
| 2546 } | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2547 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2548 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
|
2549 "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
|
2550 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2551 } |
| 69 | 2552 break; |
| 2553 case LSQB: | |
| 2554 n = CHILD(n, 1); | |
| 2555 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
|
2556 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
|
2557 "can't assign to []"); |
| 69 | 2558 return; |
| 2559 } | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2560 if (assigning > OP_APPLY) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2561 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
|
2562 "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
|
2563 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2564 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2565 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
|
2566 && 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
|
2567 com_error(c, PyExc_SyntaxError, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
2568 "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
|
2569 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2570 } |
|
13930
4eaa463c031a
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they
Thomas Wouters <thomas@python.org>
parents:
13884
diff
changeset
|
2571 com_assign_sequence(c, n, assigning); |
| 69 | 2572 return; |
| 2573 case NAME: | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2574 if (assigning > OP_APPLY) |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2575 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
|
2576 assigning, augn); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2577 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2578 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
|
2579 assigning); |
| 69 | 2580 return; |
| 2581 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2582 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
|
2583 "can't assign to literal"); |
| 69 | 2584 return; |
| 2585 } | |
| 2586 break; | |
|
3963
00722990b80c
Removed unused var; added error check for ``lambda: x=1''.
Guido van Rossum <guido@python.org>
parents:
3839
diff
changeset
|
2587 |
|
00722990b80c
Removed unused var; added error check for ``lambda: x=1''.
Guido van Rossum <guido@python.org>
parents:
3839
diff
changeset
|
2588 case lambdef: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2589 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
|
2590 "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
|
2591 return; |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2592 |
| 69 | 2593 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2594 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
|
2595 "com_assign: bad node"); |
| 69 | 2596 return; |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2597 |
| 69 | 2598 } |
| 2599 } | |
| 2600 } | |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2601 |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2602 static void |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2603 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
|
2604 { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2605 int opcode; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2606 |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2607 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
|
2608 case '+': opcode = INPLACE_ADD; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2609 case '-': opcode = INPLACE_SUBTRACT; break; |
|
19051
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2610 case '/': |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2611 if (STR(CHILD(CHILD(n, 1), 0))[1] == '/') |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2612 opcode = INPLACE_FLOOR_DIVIDE; |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2613 else if (c->c_flags & CO_FUTURE_DIVISION) |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2614 opcode = INPLACE_TRUE_DIVIDE; |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2615 else |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2616 opcode = INPLACE_DIVIDE; |
|
f20727cc3d0f
Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents:
19021
diff
changeset
|
2617 break; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2618 case '%': opcode = INPLACE_MODULO; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2619 case '<': opcode = INPLACE_LSHIFT; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2620 case '>': opcode = INPLACE_RSHIFT; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2621 case '&': opcode = INPLACE_AND; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2622 case '^': opcode = INPLACE_XOR; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2623 case '|': opcode = INPLACE_OR; break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2624 case '*': |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2625 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
|
2626 opcode = INPLACE_POWER; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2627 else |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2628 opcode = INPLACE_MULTIPLY; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2629 break; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2630 default: |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2631 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
|
2632 return; |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2633 } |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2634 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
|
2635 } |
| 69 | 2636 |
| 2637 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2638 com_expr_stmt(struct compiling *c, node *n) |
| 69 | 2639 { |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2640 REQ(n, expr_stmt); |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2641 /* 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
|
2642 /* 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
|
2643 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
|
2644 return; |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2645 if (NCH(n) == 1) { |
|
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2646 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
|
2647 if (c->c_interactive) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2648 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
|
2649 else |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
2650 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
|
2651 com_pop(c, 1); |
| 69 | 2652 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2653 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
|
2654 com_augassign(c, n); |
| 69 | 2655 else { |
| 2656 int i; | |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2657 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
|
2658 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
|
2659 if (i+2 < NCH(n)-2) { |
| 69 | 2660 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
|
2661 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
|
2662 } |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
2663 com_assign(c, CHILD(n, i), OP_ASSIGN, NULL); |
| 69 | 2664 } |
| 2665 } | |
| 2666 } | |
| 2667 | |
| 2668 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2669 com_assert_stmt(struct compiling *c, node *n) |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2670 { |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2671 int a = 0, b = 0; |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2672 int i; |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2673 REQ(n, assert_stmt); /* 'assert' test [',' test] */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2674 /* Generate code like for |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2675 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2676 if __debug__: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2677 if not <test>: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2678 raise AssertionError [, <message>] |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2679 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2680 where <message> is the second test, if present. |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2681 */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2682 |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2683 if (Py_OptimizeFlag) |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2684 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
|
2685 com_addop_name(c, LOAD_GLOBAL, "__debug__"); |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2686 com_push(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2687 com_addfwref(c, JUMP_IF_FALSE, &a); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2688 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2689 com_pop(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2690 com_node(c, CHILD(n, 1)); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2691 com_addfwref(c, JUMP_IF_TRUE, &b); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2692 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2693 com_pop(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2694 /* 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
|
2695 com_addop_name(c, LOAD_GLOBAL, "AssertionError"); |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2696 com_push(c, 1); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2697 i = NCH(n)/2; /* Either 2 or 4 */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2698 if (i > 1) |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2699 com_node(c, CHILD(n, 3)); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2700 com_addoparg(c, RAISE_VARARGS, i); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2701 com_pop(c, i); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2702 /* The interpreter does not fall through */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2703 /* All jumps converge here */ |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2704 com_backpatch(c, a); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2705 com_backpatch(c, b); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2706 com_addbyte(c, POP_TOP); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2707 } |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2708 |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
2709 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2710 com_print_stmt(struct compiling *c, node *n) |
| 69 | 2711 { |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2712 int i = 1; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2713 node* stream = NULL; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2714 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2715 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
|
2716 |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2717 /* 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
|
2718 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
|
2719 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
|
2720 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
|
2721 /* stack: [...] => [... stream] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2722 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
|
2723 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
|
2724 i = 4; |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2725 else |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2726 i = 3; |
| 69 | 2727 } |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2728 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
|
2729 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
|
2730 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
|
2731 /* 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
|
2732 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
|
2733 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
|
2734 /* 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
|
2735 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
|
2736 /* 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
|
2737 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
|
2738 /* 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
|
2739 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
|
2740 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2741 else { |
|
14105
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2742 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
|
2743 /* stack: [...] => [... obj] */ |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2744 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
|
2745 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
|
2746 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2747 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2748 /* 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
|
2749 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
|
2750 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
|
2751 /* 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
|
2752 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
|
2753 /* stack: [... stream] => [...] */ |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2754 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
|
2755 } |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2756 } |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2757 else { |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2758 if (stream != NULL) { |
|
d809b9b75b99
com_print_stmt(): Guido rightly points out that the stream expression
Barry Warsaw <barry@python.org>
parents:
14099
diff
changeset
|
2759 /* 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
|
2760 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
|
2761 /* stack: [... stream] => [...] */ |
|
14099
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2762 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
|
2763 } |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2764 else |
|
468481135c49
PEP 214, Extended print Statement, has been accepted by the BDFL.
Barry Warsaw <barry@python.org>
parents:
14077
diff
changeset
|
2765 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
|
2766 } |
| 69 | 2767 } |
| 2768 | |
| 2769 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2770 com_return_stmt(struct compiling *c, node *n) |
| 69 | 2771 { |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
2772 REQ(n, return_stmt); /* 'return' [testlist] */ |
| 86 | 2773 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
|
2774 com_error(c, PyExc_SyntaxError, "'return' outside function"); |
| 86 | 2775 } |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2776 if (c->c_flags & CO_GENERATOR) { |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2777 if (NCH(n) > 1) { |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2778 com_error(c, PyExc_SyntaxError, |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2779 "'return' with argument inside generator"); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2780 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2781 } |
|
18243
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2782 if (NCH(n) < 2) { |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2783 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2784 com_push(c, 1); |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2785 } |
|
18243
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2786 else |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2787 com_node(c, CHILD(n, 1)); |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
2788 com_addbyte(c, RETURN_VALUE); |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2789 com_pop(c, 1); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2790 } |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2791 |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2792 static void |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2793 com_yield_stmt(struct compiling *c, node *n) |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2794 { |
|
18228
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2795 int i; |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2796 REQ(n, yield_stmt); /* 'yield' testlist */ |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2797 if (!c->c_infunction) { |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2798 com_error(c, PyExc_SyntaxError, "'yield' outside function"); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2799 } |
|
18228
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2800 |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2801 for (i = 0; i < c->c_nblocks; ++i) { |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2802 if (c->c_block[i] == SETUP_FINALLY) { |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2803 com_error(c, PyExc_SyntaxError, |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2804 "'yield' not allowed in a 'try' block " |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2805 "with a 'finally' clause"); |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2806 return; |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2807 } |
|
4ebd292c975f
Disallow 'yield' in a 'try' block when there's a 'finally' clause.
Tim Peters <tim.peters@gmail.com>
parents:
18148
diff
changeset
|
2808 } |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2809 com_node(c, CHILD(n, 1)); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
2810 com_addbyte(c, YIELD_VALUE); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2811 com_pop(c, 1); |
| 69 | 2812 } |
| 2813 | |
| 2814 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2815 com_raise_stmt(struct compiling *c, node *n) |
| 69 | 2816 { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2817 int i; |
|
7946
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2818 REQ(n, raise_stmt); /* 'raise' [test [',' test [',' test]]] */ |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2819 if (NCH(n) > 1) { |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2820 com_node(c, CHILD(n, 1)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2821 if (NCH(n) > 3) { |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2822 com_node(c, CHILD(n, 3)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2823 if (NCH(n) > 5) |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2824 com_node(c, CHILD(n, 5)); |
|
ad114620f8c2
Make first raise argument optional
Guido van Rossum <guido@python.org>
parents:
6501
diff
changeset
|
2825 } |
|
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
|
2826 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2827 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
|
2828 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
|
2829 com_pop(c, i); |
| 69 | 2830 } |
| 2831 | |
| 2832 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
|
2833 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
|
2834 { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2835 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
|
2836 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
|
2837 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
|
2838 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
|
2839 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
|
2840 return; |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2841 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2842 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
|
2843 } 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
|
2844 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
|
2845 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
|
2846 } |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2847 |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2848 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2849 com_import_stmt(struct compiling *c, node *n) |
| 69 | 2850 { |
| 2851 int i; | |
| 2852 REQ(n, import_stmt); | |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2853 /* 'import' dotted_name (',' dotted_name)* | |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2854 'from' dotted_name 'import' ('*' | NAME (',' NAME)*) */ |
| 69 | 2855 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
|
2856 PyObject *tup; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2857 /* 'from' dotted_name 'import' ... */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
2858 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
|
2859 |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2860 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
|
2861 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
|
2862 } else { |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2863 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
|
2864 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
|
2865 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
|
2866 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
|
2867 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
|
2868 } |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2869 } |
|
1f1a156ed5af
Replace the run-time 'future-bytecode-stream-inspection' hack to find out
Thomas Wouters <thomas@python.org>
parents:
14230
diff
changeset
|
2870 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
|
2871 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
|
2872 com_push(c, 1); |
| 69 | 2873 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
|
2874 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
|
2875 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
|
2876 else { |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2877 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
|
2878 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
|
2879 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
|
2880 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2881 com_pop(c, 1); |
| 69 | 2882 } |
| 2883 else { | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
2884 /* 'import' ... */ |
| 69 | 2885 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
|
2886 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
|
2887 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
|
2888 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
|
2889 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
|
2890 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
|
2891 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
|
2892 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
|
2893 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
|
2894 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
|
2895 "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
|
2896 return; |
|
18385172fac0
Apply SF patch #101135, adding 'import module as m' and 'from module import
Thomas Wouters <thomas@python.org>
parents:
13997
diff
changeset
|
2897 } |
|
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
|
2898 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
|
2899 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
|
2900 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
|
2901 j)); |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
2902 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
|
2903 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
|
2904 } 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
|
2905 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
|
2906 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
|
2907 0))); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
2908 com_pop(c, 1); |
| 69 | 2909 } |
| 2910 } | |
| 2911 } | |
| 2912 | |
| 2913 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2914 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
|
2915 { |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2916 REQ(n, exec_stmt); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2917 /* 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
|
2918 com_node(c, CHILD(n, 1)); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2919 if (NCH(n) >= 4) |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2920 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
|
2921 else { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2922 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
|
2923 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
|
2924 } |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2925 if (NCH(n) >= 6) |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2926 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
|
2927 else { |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2928 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
|
2929 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
|
2930 } |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2931 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
|
2932 com_pop(c, 3); |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2933 } |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
2934 |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2935 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
2936 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
|
2937 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2938 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
|
2939 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
|
2940 /* 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
|
2941 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2942 /* 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
|
2943 next: |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2944 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
|
2945 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2946 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
|
2947 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
|
2948 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
|
2949 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
|
2950 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2951 /* 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
|
2952 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
|
2953 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
|
2954 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
|
2955 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
|
2956 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
|
2957 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
|
2958 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2959 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2960 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2961 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2962 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
|
2963 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
|
2964 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
|
2965 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
|
2966 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
|
2967 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2968 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
|
2969 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
|
2970 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
|
2971 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
|
2972 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
|
2973 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
|
2974 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
|
2975 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
|
2976 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
|
2977 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
|
2978 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
|
2979 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
|
2980 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
|
2981 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
|
2982 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
|
2983 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
|
2984 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
|
2985 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
|
2986 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2987 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2988 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2989 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
|
2990 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
|
2991 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
|
2992 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2993 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2994 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
|
2995 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
|
2996 if (v == NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
2997 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
|
2998 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
2999 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3000 i = PyObject_IsTrue(v); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3001 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
|
3002 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
|
3003 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3004 case STRING: |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3005 v = parsestr(c, 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
|
3006 if (v == NULL) { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3007 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
|
3008 break; |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3009 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3010 i = PyObject_IsTrue(v); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3011 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
|
3012 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
|
3013 |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3014 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3015 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
|
3016 } |
|
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3017 |
|
18333
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3018 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3019 /* Look under n for a return stmt with an expression. |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3020 * This hack is used to find illegal returns under "if 0:" blocks in |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3021 * functions already known to be generators (as determined by the symtable |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3022 * pass). |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3023 * Return the offending return node if found, else NULL. |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3024 */ |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3025 static node * |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3026 look_for_offending_return(node *n) |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3027 { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3028 int i; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3029 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3030 for (i = 0; i < NCH(n); ++i) { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3031 node *kid = CHILD(n, i); |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3032 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3033 switch (TYPE(kid)) { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3034 case classdef: |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3035 case funcdef: |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3036 case lambdef: |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3037 /* Stuff in nested functions & classes doesn't |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3038 affect the code block we started in. */ |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3039 return NULL; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3040 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3041 case return_stmt: |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3042 if (NCH(kid) > 1) |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3043 return kid; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3044 break; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3045 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3046 default: { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3047 node *bad = look_for_offending_return(kid); |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3048 if (bad != NULL) |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3049 return bad; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3050 } |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3051 } |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3052 } |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3053 |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3054 return NULL; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3055 } |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3056 |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3057 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3058 com_if_stmt(struct compiling *c, node *n) |
| 69 | 3059 { |
| 3060 int i; | |
| 3061 int anchor = 0; | |
| 3062 REQ(n, if_stmt); | |
| 3063 /*'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */ | |
| 3064 for (i = 0; i+3 < NCH(n); i+=4) { | |
| 3065 int a = 0; | |
| 86 | 3066 node *ch = CHILD(n, i+1); |
|
18333
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3067 if (is_constant_false(c, ch)) { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3068 /* We're going to skip this block. However, if this |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3069 is a generator, we have to check the dead code |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3070 anyway to make sure there aren't any return stmts |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3071 with expressions, in the same scope. */ |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3072 if (c->c_flags & CO_GENERATOR) { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3073 node *p = look_for_offending_return(n); |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3074 if (p != NULL) { |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3075 int savelineno = c->c_lineno; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3076 c->c_lineno = p->n_lineno; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3077 com_error(c, PyExc_SyntaxError, |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3078 "'return' with argument " |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3079 "inside generator"); |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3080 c->c_lineno = savelineno; |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3081 } |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3082 } |
|
5181
8a0b80dc6e71
Added support for ``if __debug__:'' -- if -O is given, this form is
Guido van Rossum <guido@python.org>
parents:
5164
diff
changeset
|
3083 continue; |
|
18333
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
3084 } |
| 86 | 3085 if (i > 0) |
| 3086 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
|
3087 com_node(c, ch); |
| 69 | 3088 com_addfwref(c, JUMP_IF_FALSE, &a); |
| 3089 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
|
3090 com_pop(c, 1); |
| 69 | 3091 com_node(c, CHILD(n, i+3)); |
| 3092 com_addfwref(c, JUMP_FORWARD, &anchor); | |
| 3093 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
|
3094 /* We jump here with an extra entry which we now pop */ |
| 69 | 3095 com_addbyte(c, POP_TOP); |
| 3096 } | |
| 3097 if (i+2 < NCH(n)) | |
| 3098 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
|
3099 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
|
3100 com_backpatch(c, anchor); |
| 69 | 3101 } |
| 3102 | |
| 3103 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3104 com_while_stmt(struct compiling *c, node *n) |
| 69 | 3105 { |
| 3106 int break_anchor = 0; | |
| 3107 int anchor = 0; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3108 int save_begin = c->c_begin; |
| 69 | 3109 REQ(n, while_stmt); /* 'while' test ':' suite ['else' ':' suite] */ |
| 3110 com_addfwref(c, SETUP_LOOP, &break_anchor); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3111 block_push(c, SETUP_LOOP); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3112 c->c_begin = c->c_nexti; |
| 86 | 3113 com_addoparg(c, SET_LINENO, n->n_lineno); |
| 69 | 3114 com_node(c, CHILD(n, 1)); |
| 3115 com_addfwref(c, JUMP_IF_FALSE, &anchor); | |
| 3116 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
|
3117 com_pop(c, 1); |
| 86 | 3118 c->c_loops++; |
| 69 | 3119 com_node(c, CHILD(n, 3)); |
| 86 | 3120 c->c_loops--; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3121 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3122 c->c_begin = save_begin; |
| 69 | 3123 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
|
3124 /* We jump here with one entry more on the stack */ |
| 69 | 3125 com_addbyte(c, POP_TOP); |
| 3126 com_addbyte(c, POP_BLOCK); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3127 block_pop(c, SETUP_LOOP); |
| 69 | 3128 if (NCH(n) > 4) |
| 3129 com_node(c, CHILD(n, 6)); | |
| 3130 com_backpatch(c, break_anchor); | |
| 3131 } | |
| 3132 | |
| 3133 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3134 com_for_stmt(struct compiling *c, node *n) |
| 69 | 3135 { |
| 3136 int break_anchor = 0; | |
| 3137 int anchor = 0; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3138 int save_begin = c->c_begin; |
| 69 | 3139 REQ(n, for_stmt); |
| 3140 /* 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] */ | |
| 3141 com_addfwref(c, SETUP_LOOP, &break_anchor); | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3142 block_push(c, SETUP_LOOP); |
| 69 | 3143 com_node(c, CHILD(n, 3)); |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
3144 com_addbyte(c, GET_ITER); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3145 c->c_begin = c->c_nexti; |
| 86 | 3146 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
|
3147 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
|
3148 com_push(c, 1); |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
3149 com_assign(c, CHILD(n, 1), OP_ASSIGN, NULL); |
| 86 | 3150 c->c_loops++; |
| 69 | 3151 com_node(c, CHILD(n, 5)); |
| 86 | 3152 c->c_loops--; |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3153 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3154 c->c_begin = save_begin; |
| 69 | 3155 com_backpatch(c, anchor); |
|
17597
32e7d0898eab
Iterators phase 1. This comprises:
Guido van Rossum <guido@python.org>
parents:
17518
diff
changeset
|
3156 com_pop(c, 1); /* FOR_ITER has popped this */ |
| 69 | 3157 com_addbyte(c, POP_BLOCK); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3158 block_pop(c, SETUP_LOOP); |
| 69 | 3159 if (NCH(n) > 8) |
| 3160 com_node(c, CHILD(n, 8)); | |
| 3161 com_backpatch(c, break_anchor); | |
| 3162 } | |
| 3163 | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3164 /* 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
|
3165 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3166 SETUP_FINALLY L |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3167 <code for S> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3168 POP_BLOCK |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3169 LOAD_CONST <nil> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3170 L: <code for Sf> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3171 END_FINALLY |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3172 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3173 The special instructions use the block stack. Each block |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3174 stack entry contains the instruction that created it (here |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3175 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
|
3176 block stack entry was created, and a label (here L). |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3177 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3178 SETUP_FINALLY: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3179 Pushes the current value stack level and the label |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3180 onto the block stack. |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3181 POP_BLOCK: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3182 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
|
3183 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
|
3184 block stack. (The label is ignored.) |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3185 END_FINALLY: |
| 86 | 3186 Pops a variable number of entries from the *value* stack |
| 3187 and re-raises the exception they specify. The number of | |
| 3188 entries popped depends on the (pseudo) exception type. | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3189 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3190 The block stack is unwound when an exception is raised: |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3191 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
|
3192 onto the value stack (and the exception condition is cleared), |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3193 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
|
3194 stack. |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3195 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3196 Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...": |
| 86 | 3197 (The contents of the value stack is shown in [], with the top |
| 3198 at the right; 'tb' is trace-back info, 'val' the exception's | |
| 3199 associated value, and 'exc' the exception.) | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3200 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3201 Value stack Label Instruction Argument |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3202 [] SETUP_EXCEPT L1 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3203 [] <code for S> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3204 [] POP_BLOCK |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3205 [] JUMP_FORWARD L0 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3206 |
| 86 | 3207 [tb, val, exc] L1: DUP ) |
| 3208 [tb, val, exc, exc] <evaluate E1> ) | |
| 3209 [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1 | |
| 3210 [tb, val, exc, 1-or-0] JUMP_IF_FALSE L2 ) | |
| 3211 [tb, val, exc, 1] POP ) | |
| 3212 [tb, val, exc] POP | |
| 3213 [tb, val] <assign to V1> (or POP if no V1) | |
| 3214 [tb] POP | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3215 [] <code for S1> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3216 JUMP_FORWARD L0 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3217 |
| 86 | 3218 [tb, val, exc, 0] L2: POP |
| 3219 [tb, val, exc] DUP | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3220 .............................etc....................... |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3221 |
| 86 | 3222 [tb, val, exc, 0] Ln+1: POP |
| 3223 [tb, val, exc] END_FINALLY # re-raise exception | |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3224 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3225 [] L0: <next statement> |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3226 |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3227 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
|
3228 */ |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3229 |
| 69 | 3230 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3231 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
|
3232 { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3233 int except_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3234 int end_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3235 int else_anchor = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3236 int i; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3237 node *ch; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3238 |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3239 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
|
3240 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
|
3241 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
|
3242 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
|
3243 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
|
3244 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
|
3245 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
|
3246 for (i = 3; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3247 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
|
3248 i += 3) { |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3249 /* 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
|
3250 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
|
3251 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
|
3252 "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
|
3253 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3254 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3255 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
|
3256 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
|
3257 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
|
3258 if (NCH(ch) > 1) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3259 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
|
3260 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
|
3261 com_node(c, CHILD(ch, 1)); |
|
21609
3ba0f1b20320
Patch #494783: Rename cmp_op enumerators.
Martin v. Löwis <martin@v.loewis.de>
parents:
21398
diff
changeset
|
3262 com_addoparg(c, COMPARE_OP, PyCmp_EXC_MATCH); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3263 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
|
3264 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
|
3265 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
|
3266 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
|
3267 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3268 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
|
3269 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
|
3270 if (NCH(ch) > 3) |
|
14163
1b9fd0cbd914
Support for three-token characters (**=, >>=, <<=) which was written by
Thomas Wouters <thomas@python.org>
parents:
14147
diff
changeset
|
3271 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
|
3272 else { |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3273 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
|
3274 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
|
3275 } |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3276 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
|
3277 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
|
3278 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
|
3279 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
|
3280 if (except_anchor) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3281 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
|
3282 /* 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
|
3283 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
|
3284 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
|
3285 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
|
3286 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3287 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3288 /* 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
|
3289 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
|
3290 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
|
3291 anything. */ |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3292 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
|
3293 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
|
3294 if (i < NCH(n)) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3295 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
|
3296 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
|
3297 } |
|
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 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3300 com_try_finally(struct compiling *c, node *n) |
| 69 | 3301 { |
| 3302 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
|
3303 node *ch; |
|
792
dc3b455f7632
Only * can be used for varargs argument lists
Guido van Rossum <guido@python.org>
parents:
744
diff
changeset
|
3304 |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3305 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
|
3306 block_push(c, SETUP_FINALLY); |
| 69 | 3307 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
|
3308 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
|
3309 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
|
3310 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
|
3311 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
|
3312 /* 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
|
3313 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
|
3314 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
|
3315 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
|
3316 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
|
3317 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
|
3318 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
|
3319 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
|
3320 com_node(c, ch); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3321 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
|
3322 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
|
3323 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
|
3324 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3325 |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3326 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3327 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
|
3328 { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3329 REQ(n, try_stmt); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3330 /* '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
|
3331 | 'try' ':' suite 'finally' ':' suite */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3332 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
|
3333 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
|
3334 else |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3335 com_try_except(c, n); |
| 69 | 3336 } |
| 3337 | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3338 static node * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3339 get_rawdocstring(node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3340 { |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3341 int i; |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3342 |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3343 /* 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
|
3344 next: |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3345 switch (TYPE(n)) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3346 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3347 case suite: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3348 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
|
3349 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
|
3350 goto next; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3351 } |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3352 /* Fall through */ |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3353 case file_input: |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3354 for (i = 0; i < NCH(n); i++) { |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3355 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
|
3356 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
|
3357 n = ch; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3358 goto next; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3359 } |
|
2241
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3360 } |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3361 break; |
|
fefae37c053c
added missing case to get_docstring
Guido van Rossum <guido@python.org>
parents:
2203
diff
changeset
|
3362 |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3363 case stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3364 case simple_stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3365 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
|
3366 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
|
3367 goto next; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3368 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3369 case expr_stmt: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3370 case testlist: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3371 case test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3372 case and_test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3373 case not_test: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3374 case comparison: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3375 case expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3376 case xor_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3377 case and_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3378 case shift_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3379 case arith_expr: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3380 case term: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3381 case factor: |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3382 case power: |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3383 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
|
3384 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
|
3385 goto next; |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3386 } |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3387 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3388 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3389 case atom: |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3390 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
|
3391 return n; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3392 break; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3393 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3394 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3395 return NULL; |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3396 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3397 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3398 static PyObject * |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3399 get_docstring(struct compiling *c, node *n) |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3400 { |
|
9987
b7bcc2cda1b3
Implement -OO; "unsafe" optimization that removes docstrings.
Guido van Rossum <guido@python.org>
parents:
9626
diff
changeset
|
3401 /* 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
|
3402 if (Py_OptimizeFlag > 1) |
|
b7bcc2cda1b3
Implement -OO; "unsafe" optimization that removes docstrings.
Guido van Rossum <guido@python.org>
parents:
9626
diff
changeset
|
3403 return NULL; |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3404 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
|
3405 if (n == NULL) |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3406 return NULL; |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3407 return parsestrplus(c, n); |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3408 } |
|
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3409 |
| 69 | 3410 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3411 com_suite(struct compiling *c, node *n) |
| 69 | 3412 { |
| 3413 REQ(n, suite); | |
| 3414 /* simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT */ | |
| 3415 if (NCH(n) == 1) { | |
| 3416 com_node(c, CHILD(n, 0)); | |
| 3417 } | |
| 3418 else { | |
| 3419 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
|
3420 for (i = 0; i < NCH(n) && c->c_errors == 0; i++) { |
| 69 | 3421 node *ch = CHILD(n, i); |
| 3422 if (TYPE(ch) == stmt) | |
| 3423 com_node(c, ch); | |
| 3424 } | |
| 3425 } | |
| 3426 } | |
| 3427 | |
| 744 | 3428 /* ARGSUSED */ |
| 69 | 3429 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3430 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
|
3431 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3432 int i = c->c_nblocks; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3433 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
|
3434 com_addoparg(c, JUMP_ABSOLUTE, c->c_begin); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3435 } |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3436 else if (i <= 0) { |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3437 /* at the outer level */ |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3438 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
|
3439 "'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
|
3440 } |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3441 else { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3442 int j; |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3443 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
|
3444 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
|
3445 break; |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3446 } |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3447 if (j >= 0) { |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3448 /* there is a loop, but something interferes */ |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3449 for (; i > j; --i) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3450 if (c->c_block[i] == SETUP_EXCEPT || |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3451 c->c_block[i] == SETUP_FINALLY) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3452 com_addoparg(c, CONTINUE_LOOP, |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3453 c->c_begin); |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3454 return; |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3455 } |
|
16398
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3456 if (c->c_block[i] == END_FINALLY) { |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3457 com_error(c, PyExc_SyntaxError, |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3458 "'continue' not supported inside 'finally' clause"); |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3459 return; |
|
80c0b280a4f9
Allow 'continue' inside 'try' clause
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16394
diff
changeset
|
3460 } |
|
14471
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3461 } |
|
c3c49859e80b
com_continue_stmt(): Improve error message when continue is found
Fred Drake <fdrake@acm.org>
parents:
14382
diff
changeset
|
3462 } |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3463 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
|
3464 "'continue' not properly in loop"); |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3465 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3466 /* XXX Could allow it inside a 'finally' clause |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3467 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
|
3468 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3469 |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3470 static int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3471 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
|
3472 { |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3473 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
|
3474 if (TYPE(n) == lambdef) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3475 /* lambdef: 'lambda' [varargslist] ':' test */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3476 n = CHILD(n, 1); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3477 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3478 else { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3479 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
|
3480 n = CHILD(n, 2); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3481 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
|
3482 n = CHILD(n, 1); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3483 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3484 if (TYPE(n) != varargslist) |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3485 return 0; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3486 /* varargslist: |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3487 (fpdef ['=' test] ',')* '*' ....... | |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3488 fpdef ['=' test] (',' fpdef ['=' test])* [','] */ |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3489 nch = NCH(n); |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3490 nargs = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3491 ndefs = 0; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3492 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
|
3493 int t; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3494 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
|
3495 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
|
3496 break; |
|
1833
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3497 nargs++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3498 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3499 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
|
3500 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
|
3501 else |
|
e51e17b2d88b
fix bug with missing default for last arg (discovered by Tommy Burnette)
Guido van Rossum <guido@python.org>
parents:
2844
diff
changeset
|
3502 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
|
3503 if (t == EQUAL) { |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3504 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3505 ndefs++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3506 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
|
3507 i++; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3508 if (i >= nch) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3509 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3510 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
|
3511 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3512 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
|
3513 /* 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
|
3514 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
|
3515 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
|
3516 "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
|
3517 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3518 if (t != COMMA) |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3519 break; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3520 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3521 return ndefs; |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3522 } |
|
39a4c15acb32
* Python/compile.c (com_argdefs, com_arglist): avoid referencing
Guido van Rossum <guido@python.org>
parents:
1417
diff
changeset
|
3523 |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3524 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3525 com_funcdef(struct compiling *c, node *n) |
| 69 | 3526 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3527 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
|
3528 int ndefs; |
| 69 | 3529 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
|
3530 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
|
3531 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
|
3532 n->n_lineno); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3533 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
|
3534 symtable_exit_scope(c->c_symtable); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3535 if (co == NULL) |
| 69 | 3536 c->c_errors++; |
| 3537 else { | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3538 int closure = com_make_closure(c, (PyCodeObject *)co); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3539 int i = com_addconst(c, co); |
| 69 | 3540 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
|
3541 com_push(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3542 if (closure) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3543 com_addoparg(c, MAKE_CLOSURE, ndefs); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3544 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3545 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
|
3546 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
|
3547 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
|
3548 com_pop(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3549 Py_DECREF(co); |
| 69 | 3550 } |
| 3551 } | |
| 3552 | |
| 3553 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3554 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
|
3555 { |
| 744 | 3556 int i; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3557 REQ(n, testlist); |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3558 /* testlist: test (',' test)* [','] */ |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3559 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
|
3560 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
|
3561 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
|
3562 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
|
3563 com_pop(c, i-1); |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3564 } |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3565 |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3566 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3567 com_classdef(struct compiling *c, node *n) |
| 69 | 3568 { |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3569 int i; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3570 PyObject *v; |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3571 PyCodeObject *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
|
3572 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
|
3573 |
| 69 | 3574 REQ(n, classdef); |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3575 /* 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
|
3576 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
|
3577 c->c_errors++; |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3578 return; |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3579 } |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3580 /* Push the class name on the stack */ |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3581 i = com_addconst(c, v); |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3582 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
|
3583 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
|
3584 Py_DECREF(v); |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3585 /* 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
|
3586 if (TYPE(CHILD(n, 2)) != LPAR) { |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3587 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
|
3588 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
|
3589 } |
|
1288
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3590 else |
|
9fed5726a36d
Several changes in one:
Guido van Rossum <guido@python.org>
parents:
1262
diff
changeset
|
3591 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
|
3592 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
|
3593 symtable_enter_scope(c->c_symtable, name, TYPE(n), n->n_lineno); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3594 co = 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
|
3595 symtable_exit_scope(c->c_symtable); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3596 if (co == NULL) |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3597 c->c_errors++; |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3598 else { |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3599 int closure = com_make_closure(c, co); |
|
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3600 i = com_addconst(c, (PyObject *)co); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3601 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
|
3602 com_push(c, 1); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3603 if (closure) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3604 com_addoparg(c, MAKE_CLOSURE, 0); |
|
21398
de125792bfaa
Fix for SF bug [ #492403 ] exec() segfaults on closure's func_code
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
21179
diff
changeset
|
3605 com_pop(c, PyCode_GetNumFree(co)); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3606 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3607 com_addoparg(c, MAKE_FUNCTION, 0); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3608 com_addoparg(c, CALL_FUNCTION, 0); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3609 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
|
3610 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
|
3611 com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1))); |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
3612 com_pop(c, 1); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3613 Py_DECREF(co); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
3614 } |
| 69 | 3615 } |
| 3616 | |
| 3617 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3618 com_node(struct compiling *c, node *n) |
| 69 | 3619 { |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
3620 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
|
3621 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
|
3622 return; |
| 69 | 3623 switch (TYPE(n)) { |
| 3624 | |
| 3625 /* Definition nodes */ | |
| 3626 | |
| 3627 case funcdef: | |
| 3628 com_funcdef(c, n); | |
| 3629 break; | |
| 3630 case classdef: | |
| 3631 com_classdef(c, n); | |
| 3632 break; | |
| 3633 | |
| 3634 /* Trivial parse tree nodes */ | |
| 3635 | |
| 3636 case stmt: | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3637 case small_stmt: |
| 86 | 3638 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
|
3639 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
|
3640 goto loop; |
| 86 | 3641 |
| 69 | 3642 case simple_stmt: |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3643 /* small_stmt (';' small_stmt)* [';'] NEWLINE */ |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3644 com_addoparg(c, SET_LINENO, n->n_lineno); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3645 { |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3646 int i; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3647 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
|
3648 com_node(c, CHILD(n, i)); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3649 } |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3650 break; |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3651 |
| 69 | 3652 case compound_stmt: |
| 86 | 3653 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
|
3654 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
|
3655 goto loop; |
| 69 | 3656 |
| 3657 /* Statement nodes */ | |
| 3658 | |
| 3659 case expr_stmt: | |
| 3660 com_expr_stmt(c, n); | |
| 3661 break; | |
| 3662 case print_stmt: | |
| 3663 com_print_stmt(c, n); | |
| 3664 break; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3665 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
|
3666 com_assign(c, CHILD(n, 1), OP_DELETE, NULL); |
| 69 | 3667 break; |
| 3668 case pass_stmt: | |
| 3669 break; | |
| 3670 case break_stmt: | |
| 86 | 3671 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
|
3672 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
|
3673 "'break' outside loop"); |
| 86 | 3674 } |
| 69 | 3675 com_addbyte(c, BREAK_LOOP); |
| 3676 break; | |
|
317
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3677 case continue_stmt: |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3678 com_continue_stmt(c, n); |
|
325b40d77235
New syntax: semicolons, continue statement.
Guido van Rossum <guido@python.org>
parents:
303
diff
changeset
|
3679 break; |
| 69 | 3680 case return_stmt: |
| 3681 com_return_stmt(c, n); | |
| 3682 break; | |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
3683 case yield_stmt: |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
3684 com_yield_stmt(c, n); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
3685 break; |
| 69 | 3686 case raise_stmt: |
| 3687 com_raise_stmt(c, n); | |
| 3688 break; | |
| 3689 case import_stmt: | |
| 3690 com_import_stmt(c, n); | |
| 3691 break; | |
|
466
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3692 case global_stmt: |
|
90cbcb0b97dc
Implement 'global' and new class syntax.
Guido van Rossum <guido@python.org>
parents:
409
diff
changeset
|
3693 break; |
|
1354
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3694 case exec_stmt: |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3695 com_exec_stmt(c, n); |
|
fccd415e2eb8
* bltinmodule.c: removed exec() built-in function.
Guido van Rossum <guido@python.org>
parents:
1319
diff
changeset
|
3696 break; |
|
5233
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3697 case assert_stmt: |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3698 com_assert_stmt(c, n); |
|
b749d2dd7582
Added assert statement.
Guido van Rossum <guido@python.org>
parents:
5197
diff
changeset
|
3699 break; |
| 69 | 3700 case if_stmt: |
| 3701 com_if_stmt(c, n); | |
| 3702 break; | |
| 3703 case while_stmt: | |
| 3704 com_while_stmt(c, n); | |
| 3705 break; | |
| 3706 case for_stmt: | |
| 3707 com_for_stmt(c, n); | |
| 3708 break; | |
| 3709 case try_stmt: | |
| 3710 com_try_stmt(c, n); | |
| 3711 break; | |
| 3712 case suite: | |
| 3713 com_suite(c, n); | |
| 3714 break; | |
| 3715 | |
| 3716 /* Expression nodes */ | |
| 3717 | |
| 3718 case testlist: | |
|
20432
56141b86a7f2
Very subtle syntax change: in a list comprehension, the testlist in
Guido van Rossum <guido@python.org>
parents:
20012
diff
changeset
|
3719 case testlist_safe: |
| 482 | 3720 com_list(c, n, 0); |
| 69 | 3721 break; |
| 3722 case test: | |
| 3723 com_test(c, n); | |
| 3724 break; | |
| 3725 case and_test: | |
| 3726 com_and_test(c, n); | |
| 3727 break; | |
| 3728 case not_test: | |
| 3729 com_not_test(c, n); | |
| 3730 break; | |
| 3731 case comparison: | |
| 3732 com_comparison(c, n); | |
| 3733 break; | |
| 3734 case exprlist: | |
| 482 | 3735 com_list(c, n, 0); |
| 69 | 3736 break; |
| 3737 case expr: | |
| 3738 com_expr(c, n); | |
| 3739 break; | |
|
409
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3740 case xor_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3741 com_xor_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3742 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3743 case and_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3744 com_and_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3745 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3746 case shift_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3747 com_shift_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3748 break; |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3749 case arith_expr: |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3750 com_arith_expr(c, n); |
|
b5fe6482072f
Added shift and mask ops.
Guido van Rossum <guido@python.org>
parents:
388
diff
changeset
|
3751 break; |
| 69 | 3752 case term: |
| 3753 com_term(c, n); | |
| 3754 break; | |
| 3755 case factor: | |
| 3756 com_factor(c, n); | |
| 3757 break; | |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3758 case power: |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3759 com_power(c, n); |
|
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3760 break; |
| 69 | 3761 case atom: |
| 3762 com_atom(c, n); | |
| 3763 break; | |
| 3764 | |
| 3765 default: | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3766 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
|
3767 "com_node: unexpected node type"); |
| 69 | 3768 } |
| 3769 } | |
| 3770 | |
|
13447
a89f7f268de4
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
Tim Peters <tim.peters@gmail.com>
parents:
13330
diff
changeset
|
3771 static void com_fplist(struct compiling *, node *); |
| 69 | 3772 |
| 3773 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3774 com_fpdef(struct compiling *c, node *n) |
| 69 | 3775 { |
| 3776 REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */ | |
| 3777 if (TYPE(CHILD(n, 0)) == LPAR) | |
| 3778 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
|
3779 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
|
3780 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
|
3781 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
|
3782 } |
| 69 | 3783 } |
| 3784 | |
| 3785 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3786 com_fplist(struct compiling *c, node *n) |
| 69 | 3787 { |
| 544 | 3788 REQ(n, fplist); /* fplist: fpdef (',' fpdef)* [','] */ |
| 69 | 3789 if (NCH(n) == 1) { |
| 3790 com_fpdef(c, CHILD(n, 0)); | |
| 3791 } | |
| 3792 else { | |
|
4991
8276916e1ea8
Add co_stacksize field to codeobject structure, and stacksize argument
Guido van Rossum <guido@python.org>
parents:
4905
diff
changeset
|
3793 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
|
3794 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
|
3795 com_push(c, i-1); |
| 69 | 3796 for (i = 0; i < NCH(n); i += 2) |
| 3797 com_fpdef(c, CHILD(n, i)); | |
| 3798 } | |
| 3799 } | |
| 3800 | |
| 3801 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3802 com_arglist(struct compiling *c, node *n) |
| 584 | 3803 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3804 int nch, i, narg; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3805 int complex = 0; |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
3806 char nbuf[30]; |
| 584 | 3807 REQ(n, varargslist); |
|
617
755bb8efcc2d
Use strtoul() for oct/hex constants.
Guido van Rossum <guido@python.org>
parents:
584
diff
changeset
|
3808 /* varargslist: |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3809 (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
|
3810 nch = NCH(n); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3811 /* Enter all arguments in table of locals */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3812 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
|
3813 node *ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3814 node *fp; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3815 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
|
3816 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3817 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3818 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
|
3819 if (TYPE(fp) != NAME) { |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
3820 PyOS_snprintf(nbuf, sizeof(nbuf), ".%d", i); |
|
3766
516490c8192c
Py_complex; and WITHOUT_COMPLEX added to getargs.c
Guido van Rossum <guido@python.org>
parents:
3366
diff
changeset
|
3821 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
|
3822 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
3823 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
|
3824 /* all name updates handled by symtable */ |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3825 if (++i >= nch) |
| 584 | 3826 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3827 ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3828 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
|
3829 i += 2; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3830 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3831 REQ(ch, COMMA); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3832 } |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3833 if (complex) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3834 /* Generate code for complex arguments only after |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3835 having counted the simple arguments */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3836 int ilocal = 0; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3837 for (i = 0; i < nch; i++) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3838 node *ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3839 node *fp; |
|
3324
36920bbd81a8
changes for complex and power (**) operator
Guido van Rossum <guido@python.org>
parents:
3166
diff
changeset
|
3840 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
|
3841 break; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3842 REQ(ch, fpdef); /* fpdef: NAME | '(' fplist ')' */ |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3843 fp = CHILD(ch, 0); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3844 if (TYPE(fp) != NAME) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3845 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
|
3846 com_push(c, 1); |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3847 com_fpdef(c, ch); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3848 } |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3849 ilocal++; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3850 if (++i >= nch) |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3851 break; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3852 ch = CHILD(n, i); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3853 if (TYPE(ch) == EQUAL) |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3854 i += 2; |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3855 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3856 REQ(ch, COMMA); |
| 584 | 3857 } |
| 3858 } | |
| 3859 } | |
| 3860 | |
| 3861 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3862 com_file_input(struct compiling *c, node *n) |
| 69 | 3863 { |
| 3864 int i; | |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3865 PyObject *doc; |
| 69 | 3866 REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */ |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3867 doc = get_docstring(c, n); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3868 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3869 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
|
3870 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3871 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
|
3872 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
|
3873 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
|
3874 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3875 } |
| 69 | 3876 for (i = 0; i < NCH(n); i++) { |
| 3877 node *ch = CHILD(n, i); | |
| 3878 if (TYPE(ch) != ENDMARKER && TYPE(ch) != NEWLINE) | |
| 3879 com_node(c, ch); | |
| 3880 } | |
| 3881 } | |
| 3882 | |
| 3883 /* Top-level compile-node interface */ | |
| 3884 | |
| 3885 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3886 compile_funcdef(struct compiling *c, node *n) |
| 69 | 3887 { |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3888 PyObject *doc; |
| 69 | 3889 node *ch; |
| 3890 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
|
3891 c->c_name = STR(CHILD(n, 1)); |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3892 doc = get_docstring(c, CHILD(n, 4)); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3893 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3894 (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
|
3895 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3896 } |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3897 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3898 (void) com_addconst(c, Py_None); /* No docstring */ |
| 584 | 3899 ch = CHILD(n, 2); /* parameters: '(' [varargslist] ')' */ |
| 3900 ch = CHILD(ch, 1); /* ')' | varargslist */ | |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3901 if (TYPE(ch) == varargslist) |
| 584 | 3902 com_arglist(c, ch); |
| 86 | 3903 c->c_infunction = 1; |
| 69 | 3904 com_node(c, CHILD(n, 4)); |
| 86 | 3905 c->c_infunction = 0; |
|
18243
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
3906 com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None)); |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
3907 com_push(c, 1); |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
3908 com_addbyte(c, RETURN_VALUE); |
|
47717e5667eb
Change the semantics of "return" in generators, as discussed on the
Tim Peters <tim.peters@gmail.com>
parents:
18228
diff
changeset
|
3909 com_pop(c, 1); |
| 69 | 3910 } |
| 3911 | |
| 3912 static void | |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3913 compile_lambdef(struct compiling *c, node *n) |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3914 { |
|
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
|
3915 node *ch; |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3916 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
|
3917 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
|
3918 |
|
06570429f062
* import.c (get_module): pass .py filename to parse_file, not .pyc filename!
Guido van Rossum <guido@python.org>
parents:
1405
diff
changeset
|
3919 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
|
3920 (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
|
3921 if (TYPE(ch) == varargslist) { |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3922 com_arglist(c, ch); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3923 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
|
3924 } |
|
2844
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3925 else |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3926 ch = CHILD(n, 2); |
|
0261bf5b3819
keyword arguments and faster calls
Guido van Rossum <guido@python.org>
parents:
2813
diff
changeset
|
3927 com_node(c, ch); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3928 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
|
3929 com_pop(c, 1); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3930 } |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3931 |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1364
diff
changeset
|
3932 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3933 compile_classdef(struct compiling *c, node *n) |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3934 { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3935 node *ch; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3936 PyObject *doc; |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3937 REQ(n, classdef); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3938 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */ |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3939 c->c_name = STR(CHILD(n, 1)); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
3940 c->c_private = c->c_name; |
|
21725
5d2bfbd47f1b
A tentative fix for SF bug #503837 (Roeland Rengelink):
Guido van Rossum <guido@python.org>
parents:
21609
diff
changeset
|
3941 /* Initialize local __module__ from global __name__ */ |
|
5d2bfbd47f1b
A tentative fix for SF bug #503837 (Roeland Rengelink):
Guido van Rossum <guido@python.org>
parents:
21609
diff
changeset
|
3942 com_addop_name(c, LOAD_GLOBAL, "__name__"); |
|
5d2bfbd47f1b
A tentative fix for SF bug #503837 (Roeland Rengelink):
Guido van Rossum <guido@python.org>
parents:
21609
diff
changeset
|
3943 com_addop_name(c, STORE_NAME, "__module__"); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3944 ch = CHILD(n, NCH(n)-1); /* The suite */ |
|
19343
7257e87e0720
Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents:
19252
diff
changeset
|
3945 doc = get_docstring(c, ch); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3946 if (doc != NULL) { |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3947 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
|
3948 Py_DECREF(doc); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3949 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
|
3950 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
|
3951 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
|
3952 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3953 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3954 else |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
3955 (void) com_addconst(c, Py_None); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3956 com_node(c, ch); |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3957 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
|
3958 com_push(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3959 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
|
3960 com_pop(c, 1); |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3961 } |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3962 |
|
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
3963 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
3964 compile_node(struct compiling *c, node *n) |
| 69 | 3965 { |
| 86 | 3966 com_addoparg(c, SET_LINENO, n->n_lineno); |
| 3967 | |
| 69 | 3968 switch (TYPE(n)) { |
| 3969 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3970 case single_input: /* One interactive command */ |
| 69 | 3971 /* 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
|
3972 c->c_interactive++; |
| 69 | 3973 n = CHILD(n, 0); |
| 3974 if (TYPE(n) != NEWLINE) | |
| 3975 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
|
3976 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
|
3977 com_push(c, 1); |
| 86 | 3978 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
|
3979 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
|
3980 c->c_interactive--; |
| 69 | 3981 break; |
| 3982 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3983 case file_input: /* A whole file, or built-in function exec() */ |
| 69 | 3984 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
|
3985 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
|
3986 com_push(c, 1); |
| 86 | 3987 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
|
3988 com_pop(c, 1); |
| 69 | 3989 break; |
| 3990 | |
|
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
|
3991 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
|
3992 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
|
3993 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
|
3994 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
|
3995 break; |
|
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
3996 |
|
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
|
3997 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
|
3998 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
|
3999 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
|
4000 |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
4001 case funcdef: /* A function definition */ |
| 69 | 4002 compile_funcdef(c, n); |
| 4003 break; | |
| 4004 | |
|
120
c9a5fe1660f5
Fix bug in input(); add comments to cases in compile().
Guido van Rossum <guido@python.org>
parents:
86
diff
changeset
|
4005 case classdef: /* A class definition */ |
|
2089
53aa51433f7f
Two independent chages:
Guido van Rossum <guido@python.org>
parents:
2062
diff
changeset
|
4006 compile_classdef(c, n); |
|
73
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
4007 break; |
|
3028acaa56b0
Compile class definitions.
Guido van Rossum <guido@python.org>
parents:
69
diff
changeset
|
4008 |
| 69 | 4009 default: |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4010 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
|
4011 "compile_node: unexpected node type"); |
| 69 | 4012 } |
| 4013 } | |
| 4014 | |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4015 static PyObject * |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4016 dict_keys_inorder(PyObject *dict, int offset) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4017 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4018 PyObject *tuple, *k, *v; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4019 int i, pos = 0, size = PyDict_Size(dict); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4020 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4021 tuple = PyTuple_New(size); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4022 if (tuple == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4023 return NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4024 while (PyDict_Next(dict, &pos, &k, &v)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4025 i = PyInt_AS_LONG(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4026 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
|
4027 assert((i - offset) < size); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4028 PyTuple_SET_ITEM(tuple, i - offset, k); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4029 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4030 return tuple; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4031 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4032 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4033 PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
4034 PyNode_Compile(node *n, char *filename) |
| 69 | 4035 { |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4036 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
|
4037 } |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4038 |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4039 PyCodeObject * |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4040 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
|
4041 { |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4042 return jcompile(n, filename, NULL, flags); |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4043 } |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4044 |
|
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 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
|
4046 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
|
4047 { |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4048 struct symtable *st; |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4049 PyFutureFeatures *ff; |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4050 |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4051 ff = PyNode_Future(n, filename); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4052 if (ff == NULL) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4053 return NULL; |
|
20867
40a88989d6cb
Part of SF bug #478003 possible memory leaks in err handling.
Tim Peters <tim.peters@gmail.com>
parents:
20517
diff
changeset
|
4054 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4055 st = symtable_init(); |
|
20867
40a88989d6cb
Part of SF bug #478003 possible memory leaks in err handling.
Tim Peters <tim.peters@gmail.com>
parents:
20517
diff
changeset
|
4056 if (st == NULL) { |
|
40a88989d6cb
Part of SF bug #478003 possible memory leaks in err handling.
Tim Peters <tim.peters@gmail.com>
parents:
20517
diff
changeset
|
4057 PyMem_Free((void *)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
|
4058 return NULL; |
|
20867
40a88989d6cb
Part of SF bug #478003 possible memory leaks in err handling.
Tim Peters <tim.peters@gmail.com>
parents:
20517
diff
changeset
|
4059 } |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4060 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
|
4061 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
|
4062 if (st->st_errors > 0) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4063 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
|
4064 symtable_node(st, n); |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4065 if (st->st_errors > 0) |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4066 goto fail; |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4067 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4068 return st; |
|
17112
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4069 fail: |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4070 PyMem_Free((void *)ff); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4071 st->st_future = NULL; |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4072 PySymtable_Free(st); |
|
76eab2ebce58
Update PyNode_CompileSymtable() to understand future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17104
diff
changeset
|
4073 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
|
4074 } |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4075 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4076 static PyCodeObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
4077 icompile(node *n, struct compiling *base) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4078 { |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4079 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
|
4080 } |
|
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4081 |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4082 static PyCodeObject * |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4083 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
|
4084 PyCompilerFlags *flags) |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4085 { |
| 69 | 4086 struct compiling sc; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4087 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
|
4088 if (!com_init(&sc, filename)) |
| 69 | 4089 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
|
4090 if (base) { |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4091 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
|
4092 sc.c_symtable = base->c_symtable; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4093 /* c_symtable still points to parent's symbols */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4094 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
|
4095 || (sc.c_symtable->st_cur->ste_type == TYPE_FUNCTION)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4096 sc.c_nested = 1; |
|
20491
149a65fa427c
Fix computation of stack depth for classdef and closures.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20432
diff
changeset
|
4097 sc.c_flags |= base->c_flags & PyCF_MASK; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4098 } else { |
|
4129
eedaa59341b9
Name mangling, what the heck!
Guido van Rossum <guido@python.org>
parents:
4003
diff
changeset
|
4099 sc.c_private = NULL; |
|
16799
08d937107fe6
Improved __future__ parser; still more to do
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16783
diff
changeset
|
4100 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
|
4101 if (sc.c_future == NULL) { |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4102 com_free(&sc); |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4103 return NULL; |
|
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4104 } |
|
19252
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4105 if (flags) { |
|
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4106 int merged = sc.c_future->ff_features | |
|
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4107 flags->cf_flags; |
|
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4108 sc.c_future->ff_features = merged; |
|
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4109 flags->cf_flags = merged; |
|
fbf1ae769306
Fix SF bug [ #450909 ] __future__.division fails at prompt
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19187
diff
changeset
|
4110 } |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
4111 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
|
4112 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
|
4113 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
|
4114 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4115 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4116 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
|
4117 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
|
4118 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
|
4119 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
|
4120 } |
| 69 | 4121 compile_node(&sc, n); |
| 4122 com_done(&sc); | |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
1029
diff
changeset
|
4123 if (sc.c_errors == 0) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4124 PyObject *consts, *names, *varnames, *filename, *name, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4125 *freevars, *cellvars; |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4126 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
|
4127 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
|
4128 varnames = PyList_AsTuple(sc.c_varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4129 cellvars = dict_keys_inorder(sc.c_cellvars, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4130 freevars = dict_keys_inorder(sc.c_freevars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4131 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
|
4132 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
|
4133 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
|
4134 if (!PyErr_Occurred()) |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4135 co = PyCode_New(sc.c_argcount, |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4136 sc.c_nlocals, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4137 sc.c_maxstacklevel, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4138 sc.c_flags, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4139 sc.c_code, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4140 consts, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4141 names, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4142 varnames, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4143 freevars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4144 cellvars, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4145 filename, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4146 name, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4147 sc.c_firstlineno, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4148 sc.c_lnotab); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4149 Py_XDECREF(consts); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4150 Py_XDECREF(names); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4151 Py_XDECREF(varnames); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4152 Py_XDECREF(freevars); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4153 Py_XDECREF(cellvars); |
|
5373
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4154 Py_XDECREF(filename); |
|
5880384d7c71
Quickly renamed the remaining files -- this directory is done.
Guido van Rossum <guido@python.org>
parents:
5287
diff
changeset
|
4155 Py_XDECREF(name); |
|
266
b5826bf29677
Changed and exported newcodeobject() interface, for ".pyc" files.
Guido van Rossum <guido@python.org>
parents:
238
diff
changeset
|
4156 } |
|
13884
8eeaff96b4c2
When returning an error from jcompile() (which is passed through by
Guido van Rossum <guido@python.org>
parents:
13873
diff
changeset
|
4157 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
|
4158 /* 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
|
4159 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
|
4160 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
|
4161 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
|
4162 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
|
4163 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
|
4164 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4165 exit: |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4166 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
|
4167 PySymtable_Free(sc.c_symtable); |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4168 sc.c_symtable = NULL; |
|
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4169 } |
| 69 | 4170 com_free(&sc); |
| 4171 return co; | |
| 4172 } | |
|
5041
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4173 |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4174 int |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13585
diff
changeset
|
4175 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
|
4176 { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4177 int size = PyString_Size(co->co_lnotab) / 2; |
| 11290 | 4178 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
|
4179 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
|
4180 int addr = 0; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4181 while (--size >= 0) { |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4182 addr += *p++; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4183 if (addr > addrq) |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4184 break; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4185 line += *p++; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4186 } |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4187 return line; |
|
c497929b2371
Instead of emitting SET_LINENO instructions, generate a line number
Guido van Rossum <guido@python.org>
parents:
5011
diff
changeset
|
4188 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4189 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4190 /* 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
|
4191 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
|
4192 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
|
4193 */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4194 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4195 static int |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4196 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
|
4197 { |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4198 char buf[350]; |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4199 PyObject *v; |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4200 |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4201 if (PyDict_GetItemString(c->c_cellvars, name) != NULL) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4202 return CELL; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4203 if (PyDict_GetItemString(c->c_locals, name) != NULL) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4204 return LOCAL; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4205 if (PyDict_GetItemString(c->c_freevars, name) != NULL) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4206 return FREE; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4207 v = PyDict_GetItemString(c->c_globals, name); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4208 if (v) { |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4209 if (v == Py_None) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4210 return GLOBAL_EXPLICIT; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4211 else { |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4212 return GLOBAL_IMPLICIT; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4213 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4214 } |
|
21066
225c7dd17e37
Fixes for possible buffer overflows in sprintf() usages.
Marc-André Lemburg <mal@egenix.com>
parents:
20947
diff
changeset
|
4215 PyOS_snprintf(buf, sizeof(buf), |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4216 "unknown scope for %.100s in %.100s(%s) " |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4217 "in %s\nsymbols: %s\nlocals: %s\nglobals: %s\n", |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4218 name, c->c_name, |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4219 PyObject_REPR(c->c_symtable->st_cur->ste_id), |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4220 c->c_filename, |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4221 PyObject_REPR(c->c_symtable->st_cur->ste_symbols), |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4222 PyObject_REPR(c->c_locals), |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4223 PyObject_REPR(c->c_globals) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4224 ); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4225 |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4226 Py_FatalError(buf); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4227 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
|
4228 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4229 |
|
16933
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4230 /* Helper functions to issue warnings */ |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4231 |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4232 static int |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4233 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
|
4234 { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4235 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, filename, |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4236 lineno, NULL, NULL) < 0) { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4237 if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) { |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4238 PyErr_SetString(PyExc_SyntaxError, msg); |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4239 PyErr_SyntaxLocation(filename, lineno); |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4240 } |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4241 return -1; |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4242 } |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4243 return 0; |
|
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4244 } |
|
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
|
4245 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4246 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
|
4247 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
|
4248 { |
|
16933
b046a31af2e0
Refactored the warning-issuing code more.
Guido van Rossum <guido@python.org>
parents:
16916
diff
changeset
|
4249 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
|
4250 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
|
4251 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
|
4252 } |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4253 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
|
4254 } |
|
ec9083ac26df
Let's have some sanity. Introduce a helper to issue a symbol table
Guido van Rossum <guido@python.org>
parents:
16853
diff
changeset
|
4255 |
|
16831
27f04d714ecb
Print the offending line of code in the traceback for SyntaxErrors
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16823
diff
changeset
|
4256 /* 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
|
4257 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4258 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
|
4259 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
|
4260 { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4261 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
|
4262 return -1; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4263 c->c_symtable->st_future = c->c_future; |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
4264 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
|
4265 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
|
4266 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
|
4267 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
|
4268 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
|
4269 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
|
4270 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
|
4271 /* 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
|
4272 c->c_symtable->st_nscopes = 1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4273 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
|
4274 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
|
4275 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4276 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4277 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4278 symtable_init_compiling_symbols(struct compiling *c) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4279 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4280 PyObject *varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4281 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4282 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
|
4283 if (varnames == NULL) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4284 varnames = PyList_New(0); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4285 if (varnames == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4286 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4287 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
|
4288 Py_INCREF(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4289 } else |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4290 Py_INCREF(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4291 c->c_varnames = varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4292 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4293 c->c_globals = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4294 if (c->c_globals == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4295 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4296 c->c_freevars = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4297 if (c->c_freevars == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4298 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4299 c->c_cellvars = PyDict_New(); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4300 if (c->c_cellvars == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4301 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4302 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4303 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4304 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4305 struct symbol_info { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4306 int si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4307 int si_ncells; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4308 int si_nfrees; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4309 int si_nimplicit; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4310 }; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4311 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4312 static void |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4313 symtable_init_info(struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4314 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4315 si->si_nlocals = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4316 si->si_ncells = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4317 si->si_nfrees = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4318 si->si_nimplicit = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4319 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4320 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4321 static int |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4322 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
|
4323 struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4324 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4325 PyObject *dict, *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4326 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4327 /* 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
|
4328 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
|
4329 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
|
4330 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
|
4331 */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4332 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
|
4333 /* 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
|
4334 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
|
4335 return 0; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4336 v = PyInt_FromLong(si->si_ncells++); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4337 dict = c->c_cellvars; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4338 } else { |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4339 /* 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
|
4340 anything here. |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4341 */ |
|
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4342 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
|
4343 || (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
|
4344 return 0; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4345 v = PyInt_FromLong(si->si_nfrees++); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4346 dict = c->c_freevars; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4347 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4348 if (v == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4349 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4350 if (PyDict_SetItem(dict, name, v) < 0) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4351 Py_DECREF(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4352 return -1; |
|
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 Py_DECREF(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4355 return 0; |
|
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 |
|
17104
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4358 /* 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
|
4359 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
|
4360 */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4361 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4362 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4363 static int |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4364 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
|
4365 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
|
4366 { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4367 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
|
4368 int i, pos; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4369 |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4370 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
|
4371 argcount++; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4372 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
|
4373 argcount++; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4374 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
|
4375 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
|
4376 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
|
4377 if (list == NULL) { |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4378 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
|
4379 if (list == NULL) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4380 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4381 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
|
4382 Py_INCREF(v); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4383 } else |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4384 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
|
4385 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4386 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4387 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
|
4388 return 0; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4389 /* 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
|
4390 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
|
4391 */ |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4392 d = PyDict_New(); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4393 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
|
4394 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
|
4395 if (v == NULL) |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4396 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4397 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
|
4398 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4399 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
|
4400 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4401 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4402 pos = 0; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4403 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
|
4404 Py_DECREF(list); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4405 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
|
4406 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
|
4407 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
|
4408 Py_DECREF(w); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4409 goto fail; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4410 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4411 Py_DECREF(w); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4412 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4413 Py_DECREF(*cellvars); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4414 *cellvars = d; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4415 return 1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4416 fail: |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4417 Py_DECREF(d); |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4418 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4419 } |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4420 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4421 static int |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4422 symtable_freevar_offsets(PyObject *freevars, int offset) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4423 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4424 PyObject *name, *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4425 int pos; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4426 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4427 /* 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
|
4428 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
|
4429 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
|
4430 pos = 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4431 while (PyDict_Next(freevars, &pos, &name, &v)) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4432 int i = PyInt_AS_LONG(v) + offset; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4433 PyObject *o = PyInt_FromLong(i); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4434 if (o == NULL) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4435 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4436 if (PyDict_SetItem(freevars, name, o) < 0) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4437 Py_DECREF(o); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4438 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4439 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4440 Py_DECREF(o); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4441 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4442 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4443 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4444 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4445 static int |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4446 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
|
4447 PySymtableEntryObject *ste, |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4448 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
|
4449 { |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4450 char buf[300]; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4451 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4452 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
|
4453 || (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
|
4454 return 0; |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4455 |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4456 #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
|
4457 |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4458 #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
|
4459 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4460 #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
|
4461 "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
|
4462 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4463 #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
|
4464 "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
|
4465 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4466 #define ILLEGAL_EXEC_AND_IMPORT_STAR \ |
|
21834
c1d55a627897
Fix missing space between words. Bugfix candidate.
Neal Norwitz <nnorwitz@gmail.com>
parents:
21833
diff
changeset
|
4467 "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
|
4468 "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
|
4469 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4470 /* 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
|
4471 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
|
4472 |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4473 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
|
4474 if (ste->ste_optimized == OPT_IMPORT_STAR) |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4475 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4476 ILLEGAL_IMPORT_STAR, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4477 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4478 ILLEGAL_CONTAINS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4479 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC)) |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4480 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4481 ILLEGAL_BARE_EXEC, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4482 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4483 ILLEGAL_CONTAINS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4484 else { |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4485 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4486 ILLEGAL_EXEC_AND_IMPORT_STAR, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4487 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4488 ILLEGAL_CONTAINS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4489 } |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4490 } else { |
|
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4491 if (ste->ste_optimized == OPT_IMPORT_STAR) |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4492 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4493 ILLEGAL_IMPORT_STAR, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4494 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4495 ILLEGAL_IS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4496 else if (ste->ste_optimized == (OPT_BARE_EXEC | OPT_EXEC)) |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4497 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4498 ILLEGAL_BARE_EXEC, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4499 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4500 ILLEGAL_IS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4501 else { |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4502 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4503 ILLEGAL_EXEC_AND_IMPORT_STAR, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4504 PyString_AS_STRING(ste->ste_name), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
4505 ILLEGAL_IS); |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4506 } |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4507 } |
|
17131
1c90a1cf795c
Make error messages clearer for illegal combinations of nested
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17124
diff
changeset
|
4508 |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4509 PyErr_SetString(PyExc_SyntaxError, buf); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4510 PyErr_SyntaxLocation(c->c_symtable->st_filename, |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4511 ste->ste_opt_lineno); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4512 return -1; |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4513 } |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4514 |
|
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4515 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4516 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
|
4517 struct symbol_info *si) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4518 { |
|
19158
97a3d3d7029f
Refactor future feature handling
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19051
diff
changeset
|
4519 if (c->c_future) |
|
97a3d3d7029f
Refactor future feature handling
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19051
diff
changeset
|
4520 c->c_flags |= c->c_future->ff_features; |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
4521 if (ste->ste_generator) |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
4522 c->c_flags |= CO_GENERATOR; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4523 if (ste->ste_type != TYPE_MODULE) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4524 c->c_flags |= CO_NEWLOCALS; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4525 if (ste->ste_type == TYPE_FUNCTION) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4526 c->c_nlocals = si->si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4527 if (ste->ste_optimized == 0) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4528 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
|
4529 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
|
4530 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
|
4531 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4532 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4533 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4534 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4535 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
|
4536 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
|
4537 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4538 static PyObject *implicit = NULL; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4539 struct symtable *st = c->c_symtable; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4540 PySymtableEntryObject *ste = st->st_cur; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4541 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
|
4542 int i, flags, pos; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4543 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
|
4544 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4545 if (implicit == NULL) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4546 implicit = PyInt_FromLong(1); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4547 if (implicit == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4548 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4549 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4550 v = NULL; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4551 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4552 if (symtable_init_compiling_symbols(c) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4553 goto fail; |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4554 symtable_init_info(&si); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4555 varnames = st->st_cur->ste_varnames; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4556 si.si_nlocals = PyList_GET_SIZE(varnames); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4557 c->c_argcount = si.si_nlocals; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4558 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4559 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
|
4560 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
|
4561 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
|
4562 PyList_GET_ITEM(varnames, i), v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4563 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4564 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
|
4565 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4566 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4567 /* 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
|
4568 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
|
4569 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
|
4570 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
|
4571 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
|
4572 |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4573 if (flags & DEF_FREE_GLOBAL) |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4574 /* undo the original DEF_FREE */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4575 flags &= ~(DEF_FREE | DEF_FREE_CLASS); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4576 |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4577 /* Deal with names that need two actions: |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4578 1. Cell variables that are also locals. |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4579 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
|
4580 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
|
4581 */ |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4582 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
|
4583 symtable_resolve_free(c, name, flags, &si); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4584 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4585 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
|
4586 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
|
4587 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
|
4588 } 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
|
4589 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
|
4590 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
|
4591 } 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
|
4592 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
|
4593 else if (flags & DEF_GLOBAL) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4594 if (flags & DEF_PARAM) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4595 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
|
4596 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
|
4597 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
|
4598 ste->ste_lineno); |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4599 st->st_errors++; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4600 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
|
4601 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4602 if (PyDict_SetItem(c->c_globals, name, Py_None) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4603 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
|
4604 } else if (flags & DEF_FREE_GLOBAL) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4605 si.si_nimplicit++; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4606 if (PyDict_SetItem(c->c_globals, name, implicit) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4607 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
|
4608 } 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
|
4609 v = PyInt_FromLong(si.si_nlocals++); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4610 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4611 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
|
4612 if (PyDict_SetItem(c->c_locals, name, v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4613 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4614 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
|
4615 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
|
4616 if (PyList_Append(c->c_varnames, name) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4617 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
|
4618 } else if (is_free(flags)) { |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4619 if (ste->ste_nested) { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4620 v = PyInt_FromLong(si.si_nfrees++); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4621 if (v == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4622 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
|
4623 if (PyDict_SetItem(c->c_freevars, name, v) < 0) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4624 goto fail; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4625 Py_DECREF(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4626 } else { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4627 si.si_nimplicit++; |
|
19177
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4628 if (PyDict_SetItem(c->c_globals, name, |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4629 implicit) < 0) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4630 goto fail; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4631 if (st->st_nscopes != 1) { |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4632 v = PyInt_FromLong(flags); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4633 if (PyDict_SetItem(st->st_global, |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4634 name, v)) |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4635 goto fail; |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4636 Py_DECREF(v); |
|
50f88ee71d45
Remove st_nested_scopes from struct symtable,
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19160
diff
changeset
|
4637 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4638 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4639 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4640 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4641 |
|
17637
8ff76cf30a8c
Fix 2.1 nested scopes crash reported by Evan Simpson
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17597
diff
changeset
|
4642 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
|
4643 |
|
17104
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4644 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
|
4645 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
|
4646 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
|
4647 return -1; |
|
a488a63cb867
Fix PyFrame_FastToLocals() and counterpart to deal with cells and
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17078
diff
changeset
|
4648 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4649 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
|
4650 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4651 return symtable_update_flags(c, ste, &si); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4652 fail: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4653 /* is this always the right thing to do? */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4654 Py_XDECREF(v); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4655 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
|
4656 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4657 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4658 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
|
4659 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
|
4660 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4661 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
|
4662 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4663 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
|
4664 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
|
4665 return NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4666 st->st_pass = 1; |
|
19160
9d024ae05837
st_nested_scopes was uninitialized trash. Jeremy should fix in a better
Tim Peters <tim.peters@gmail.com>
parents:
19158
diff
changeset
|
4667 |
|
16428
6496844c4a42
Fix symbol table pass to generation SyntaxError exceptions that
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16421
diff
changeset
|
4668 st->st_filename = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4669 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
|
4670 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
|
4671 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
|
4672 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
|
4673 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
|
4674 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
|
4675 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
|
4676 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
|
4677 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
|
4678 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
|
4679 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
|
4680 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
|
4681 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
|
4682 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4683 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4684 void |
|
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4685 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
|
4686 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4687 Py_XDECREF(st->st_symbols); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4688 Py_XDECREF(st->st_stack); |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4689 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
|
4690 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
|
4691 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4692 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4693 /* 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
|
4694 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
|
4695 children. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4696 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4697 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
|
4698 scope are cellvars. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4699 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4700 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
|
4701 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
|
4702 implicit globals. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4703 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4704 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4705 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4706 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4707 symtable_update_free_vars(struct symtable *st) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4708 { |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4709 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
|
4710 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
|
4711 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
|
4712 |
|
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 (ste->ste_type == TYPE_CLASS) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4714 def = DEF_FREE_CLASS; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4715 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4716 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
|
4717 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
|
4718 int pos = 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4719 |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4720 if (list) |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4721 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
|
4722 ((PyVarObject*)list)->ob_size, 0); |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4723 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
|
4724 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
|
4725 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
|
4726 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
|
4727 if (!(is_free(flags))) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4728 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
|
4729 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
|
4730 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
|
4731 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
|
4732 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4733 } |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4734 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
|
4735 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
|
4736 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
|
4737 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4738 } |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4739 } |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4740 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
|
4741 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
|
4742 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
|
4743 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
|
4744 /* 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
|
4745 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
|
4746 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
|
4747 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
|
4748 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
|
4749 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
|
4750 nested scopes. |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4751 */ |
|
17078
7e181eba6b9b
Fixup handling of free variables in methods when the class scope also
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
17076
diff
changeset
|
4752 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
|
4753 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
|
4754 if (flags & DEF_GLOBAL) { |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4755 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
|
4756 name); |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4757 continue; |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4758 } |
|
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4759 } |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4760 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
|
4761 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
|
4762 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
|
4763 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
|
4764 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4765 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4766 } 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
|
4767 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
|
4768 name) < 0) { |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4769 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
|
4770 return -1; |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4771 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4772 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4773 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4774 } |
|
16571
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4775 |
|
2c6417ef4628
In symtable_update_free_vars() do not modify the dictionary while
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16540
diff
changeset
|
4776 Py_XDECREF(list); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4777 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4778 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4779 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4780 /* 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
|
4781 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
|
4782 global in all nested scopes. |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4783 */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4784 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4785 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4786 symtable_check_global(struct symtable *st, PyObject *child, PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4787 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4788 PyObject *o; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4789 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
|
4790 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
|
4791 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4792 if (ste->ste_type == TYPE_CLASS) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4793 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
|
4794 o = PyDict_GetItem(ste->ste_symbols, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4795 if (o == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4796 return symtable_undo_free(st, child, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4797 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
|
4798 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4799 if (is_free(v) || (v & DEF_GLOBAL)) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4800 return symtable_undo_free(st, child, name); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4801 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
|
4802 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
|
4803 name, DEF_FREE); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4804 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4805 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4806 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4807 symtable_undo_free(struct symtable *st, PyObject *id, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4808 PyObject *name) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4809 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4810 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
|
4811 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
|
4812 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
|
4813 |
|
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4814 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
|
4815 if (ste == NULL) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4816 return -1; |
|
16892
f27d3299df39
Fix core dump in example from Samuele Pedroni:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16878
diff
changeset
|
4817 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4818 info = PyDict_GetItem(ste->ste_symbols, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4819 if (info == NULL) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4820 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4821 v = PyInt_AS_LONG(info); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4822 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
|
4823 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
|
4824 DEF_FREE_GLOBAL) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4825 return -1; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4826 } else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4827 /* If the name is defined here or declared global, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4828 then the recursion stops. */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4829 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4830 |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4831 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
|
4832 PySymtableEntryObject *child; |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4833 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
|
4834 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
|
4835 x = symtable_undo_free(st, child->ste_id, name); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4836 if (x < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4837 return x; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4838 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4839 return 0; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4840 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4841 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4842 /* 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
|
4843 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
|
4844 in symtable_exit_scope(). |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4845 */ |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4846 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4847 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4848 symtable_exit_scope(struct symtable *st) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4849 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4850 int end; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4851 |
|
16862
77a5470299db
Add warning/error handlin for problematic nested scopes cases as
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16855
diff
changeset
|
4852 if (st->st_pass == 1) |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4853 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
|
4854 Py_DECREF(st->st_cur); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4855 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
|
4856 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
|
4857 end); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4858 if (PySequence_DelItem(st->st_stack, end) < 0) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4859 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
|
4860 return 0; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4861 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4862 |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
4863 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
|
4864 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
|
4865 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
|
4866 { |
|
16539
a47d93ef103a
Relax the rules for using 'from ... import *' and exec in the presence
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16523
diff
changeset
|
4867 PySymtableEntryObject *prev = NULL; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4868 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4869 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
|
4870 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
|
4871 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
|
4872 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
|
4873 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
|
4874 return; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4875 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4876 } |
|
16754
23c7a0108f59
symtable_update_free_vars(), symtable_undo_free(),
Barry Warsaw <barry@python.org>
parents:
16753
diff
changeset
|
4877 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
|
4878 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
|
4879 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
|
4880 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
|
4881 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
|
4882 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
|
4883 (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
|
4884 st->st_errors++; |
|
16753
51977af230fa
Fix for bug 133489: compiler leaks memory
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16699
diff
changeset
|
4885 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4886 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4887 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4888 static int |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4889 symtable_lookup(struct symtable *st, char *name) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4890 { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4891 char buffer[MANGLE_LEN]; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4892 PyObject *v; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4893 int flags; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4894 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4895 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
|
4896 name = buffer; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4897 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
|
4898 if (v == NULL) { |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4899 if (PyErr_Occurred()) |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4900 return -1; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4901 else |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4902 return 0; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4903 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4904 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4905 flags = PyInt_AS_LONG(v); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4906 return flags; |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4907 } |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4908 |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
4909 static int |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4910 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
|
4911 { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4912 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
|
4913 char buffer[MANGLE_LEN]; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4914 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
|
4915 |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
4916 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
|
4917 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
|
4918 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
|
4919 return -1; |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4920 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
|
4921 Py_DECREF(s); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
4922 return ret; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4923 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4924 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4925 /* Must only be called with mangled names */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4926 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4927 static int |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4928 symtable_add_def_o(struct symtable *st, PyObject *dict, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4929 PyObject *name, int flag) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4930 { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4931 PyObject *o; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4932 int val; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4933 |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4934 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
|
4935 val = PyInt_AS_LONG(o); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4936 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
|
4937 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
|
4938 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
|
4939 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
|
4940 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
|
4941 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
|
4942 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4943 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
|
4944 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4945 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
|
4946 o = PyInt_FromLong(val); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4947 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
|
4948 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
|
4949 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
|
4950 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4951 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
|
4952 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4953 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
|
4954 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
|
4955 return -1; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4956 } else if (flag & DEF_GLOBAL) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4957 /* XXX need to update DEF_GLOBAL for other flags too; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4958 perhaps only DEF_FREE_GLOBAL */ |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4959 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
|
4960 val = PyInt_AS_LONG(o); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4961 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
|
4962 } else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4963 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
|
4964 o = PyInt_FromLong(val); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4965 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
|
4966 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
|
4967 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
|
4968 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4969 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
|
4970 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4971 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
|
4972 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
4973 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
4974 #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
|
4975 |
|
18333
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
4976 /* Look for a yield stmt under n. Return 1 if found, else 0. |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
4977 This hack is used to look inside "if 0:" blocks (which are normally |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
4978 ignored) in case those are the only places a yield occurs (so that this |
|
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
4979 function is a generator). */ |
|
18274
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4980 static int |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4981 look_for_yield(node *n) |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4982 { |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4983 int i; |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4984 |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4985 for (i = 0; i < NCH(n); ++i) { |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4986 node *kid = CHILD(n, i); |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4987 |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4988 switch (TYPE(kid)) { |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4989 |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4990 case classdef: |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4991 case funcdef: |
|
18333
41243cb4ea05
Another "if 0:" hack, this time to complain about otherwise invisible
Tim Peters <tim.peters@gmail.com>
parents:
18274
diff
changeset
|
4992 case lambdef: |
|
18274
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4993 /* Stuff in nested functions and classes can't make |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4994 the parent a generator. */ |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4995 return 0; |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4996 |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4997 case yield_stmt: |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4998 return 1; |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
4999 |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5000 default: |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5001 if (look_for_yield(kid)) |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5002 return 1; |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5003 } |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5004 } |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5005 return 0; |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5006 } |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5007 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5008 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
|
5009 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
|
5010 { |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5011 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
|
5012 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5013 loop: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5014 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
|
5015 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
|
5016 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
|
5017 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
|
5018 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
|
5019 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
|
5020 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
|
5021 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
|
5022 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5023 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5024 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
|
5025 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
|
5026 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
|
5027 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
|
5028 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
|
5029 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
|
5030 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5031 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
|
5032 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
|
5033 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
|
5034 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
|
5035 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
|
5036 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
|
5037 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
|
5038 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
|
5039 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5040 } |
|
16421
aa844711463a
Move a bunch of definitions that were internal to compile.c to
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16408
diff
changeset
|
5041 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
|
5042 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
|
5043 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
|
5044 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
|
5045 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
|
5046 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
|
5047 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5048 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5049 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
|
5050 for (i = 0; i + 3 < NCH(n); i += 4) { |
|
18274
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5051 if (is_constant_false(NULL, (CHILD(n, i + 1)))) { |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5052 if (st->st_cur->ste_generator == 0) |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5053 st->st_cur->ste_generator = |
|
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5054 look_for_yield(CHILD(n, i+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
|
5055 continue; |
|
18274
86dab0d43b73
SF bug #436207: "if 0: yield x" is ignored.
Tim Peters <tim.peters@gmail.com>
parents:
18243
diff
changeset
|
5056 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5057 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
|
5058 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
|
5059 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5060 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
|
5061 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
|
5062 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5063 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
|
5064 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
|
5065 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5066 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
|
5067 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
|
5068 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
|
5069 case exec_stmt: { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5070 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
|
5071 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
|
5072 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
|
5073 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
|
5074 else { |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5075 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
|
5076 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
|
5077 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5078 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
|
5079 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
|
5080 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
|
5081 |
|
f700e6b8de1f
Undo recent change that banned using import to bind a global, as per
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16357
diff
changeset
|
5082 } |
|
16680
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
5083 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
|
5084 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
|
5085 return; |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
5086 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
|
5087 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
|
5088 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
|
5089 } else { |
|
17ed61fd5b65
When running python -O, do not include blocks defined in asserts in
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16677
diff
changeset
|
5090 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
|
5091 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
|
5092 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
|
5093 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5094 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
|
5095 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
|
5096 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
|
5097 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
|
5098 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
|
5099 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
|
5100 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5101 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5102 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
|
5103 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
|
5104 break; |
|
18148
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
5105 case yield_stmt: |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
5106 st->st_cur->ste_generator = 1; |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
5107 n = CHILD(n, 1); |
|
7bc473b2c654
Merging the gen-branch into the main line, at Guido's direction. Yay!
Tim Peters <tim.peters@gmail.com>
parents:
18065
diff
changeset
|
5108 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
|
5109 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
|
5110 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
|
5111 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
|
5112 else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5113 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
|
5114 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
|
5115 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
|
5116 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5117 } else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5118 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
|
5119 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
|
5120 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
|
5121 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
|
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 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5124 goto loop; |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5125 case list_iter: |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5126 n = CHILD(n, 0); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5127 if (TYPE(n) == list_for) { |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5128 st->st_tmpname++; |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5129 symtable_list_comprehension(st, n); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5130 st->st_tmpname--; |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5131 } else { |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5132 REQ(n, list_if); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5133 symtable_node(st, CHILD(n, 1)); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5134 if (NCH(n) == 3) { |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5135 n = CHILD(n, 2); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5136 goto loop; |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5137 } |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5138 } |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5139 break; |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5140 case for_stmt: |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5141 symtable_assign(st, CHILD(n, 1), 0); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5142 for (i = 3; i < NCH(n); ++i) |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5143 if (TYPE(CHILD(n, i)) >= single_input) |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5144 symtable_node(st, CHILD(n, i)); |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5145 break; |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5146 /* The remaining cases fall through to default except in |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5147 special circumstances. This requires the individual cases |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5148 to be coded with great care, even though they look like |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5149 rather innocuous. Each case must double-check TYPE(n). |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5150 */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5151 case argument: |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5152 if (TYPE(n) == argument && NCH(n) == 3) { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5153 n = CHILD(n, 2); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5154 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5155 } |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5156 /* fall through */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5157 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
|
5158 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
|
5159 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
|
5160 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
|
5161 symtable_node(st, CHILD(n, 0)); |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5162 st->st_tmpname--; |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5163 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
|
5164 } |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5165 /* fall through */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5166 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
|
5167 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
|
5168 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
|
5169 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5170 } |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5171 /* fall through */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5172 default: |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5173 /* Walk over every non-token child with a special case |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5174 for one child. |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5175 */ |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5176 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
|
5177 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
|
5178 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
|
5179 } |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5180 for (i = 0; i < NCH(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
|
5181 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
|
5182 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
|
5183 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5184 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5185 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5186 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
|
5187 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
|
5188 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5189 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
|
5190 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5191 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
|
5192 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
|
5193 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
|
5194 } else |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5195 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
|
5196 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
|
5197 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
|
5198 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5199 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5200 /* 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
|
5201 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
|
5202 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
|
5203 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
|
5204 body. |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5205 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5206 varargslist: |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5207 (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
|
5208 | 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
|
5209 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5210 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5211 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
|
5212 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
|
5213 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5214 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
|
5215 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
|
5216 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5217 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
|
5218 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
|
5219 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
|
5220 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5221 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5222 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
|
5223 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
|
5224 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
|
5225 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
|
5226 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5227 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5228 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
|
5229 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
|
5230 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5231 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5232 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5233 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
|
5234 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
|
5235 { |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5236 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
|
5237 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
|
5238 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5239 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
|
5240 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
|
5241 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
|
5242 return; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5243 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5244 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
|
5245 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
|
5246 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
|
5247 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
|
5248 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
|
5249 break; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5250 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5251 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
|
5252 continue; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5253 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5254 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
|
5255 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
|
5256 else { |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5257 char nbuf[30]; |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5258 PyOS_snprintf(nbuf, sizeof(nbuf), ".%d", 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
|
5259 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
|
5260 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
|
5261 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5262 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5263 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
|
5264 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
|
5265 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
|
5266 i++; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5267 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
|
5268 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
|
5269 i += 2; |
|
16137
883cb0e31bb2
prevent symtable_params() from dereferencing off the end of the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16096
diff
changeset
|
5270 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
|
5271 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
|
5272 else |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5273 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
|
5274 } |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5275 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
|
5276 i++; |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5277 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
|
5278 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
|
5279 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5280 } |
|
16250
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5281 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
|
5282 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
|
5283 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
|
5284 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
|
5285 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
|
5286 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
|
5287 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
|
5288 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
|
5289 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
|
5290 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
|
5291 } |
|
aab871635ffa
Fix bug reported by Ka-Ping Yee: The compiler botched parsing function
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16138
diff
changeset
|
5292 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5293 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5294 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5295 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
|
5296 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
|
5297 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5298 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
|
5299 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
|
5300 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5301 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
|
5302 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
|
5303 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
|
5304 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
|
5305 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
|
5306 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
|
5307 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
|
5308 else |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5309 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
|
5310 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5311 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5312 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5313 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5314 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
|
5315 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
|
5316 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5317 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
|
5318 |
|
16916
b0456d3a0f1f
Useful future statement support for the interactive interpreter
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16892
diff
changeset
|
5319 /* 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
|
5320 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
|
5321 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
|
5322 */ |
|
16871
d675d75af839
Warn about global statement at the module level.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16862
diff
changeset
|
5323 |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5324 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
|
5325 char *name = STR(CHILD(n, i)); |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5326 int flags; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5327 |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5328 flags = symtable_lookup(st, name); |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5329 if (flags < 0) |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5330 continue; |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5331 if (flags && flags != DEF_GLOBAL) { |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5332 char buf[500]; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5333 if (flags & DEF_PARAM) { |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5334 PyErr_Format(PyExc_SyntaxError, |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5335 "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
|
5336 name); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
5337 PyErr_SyntaxLocation(st->st_filename, |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5338 st->st_cur->ste_lineno); |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5339 st->st_errors++; |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5340 return; |
|
16853
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5341 } |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5342 else { |
|
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5343 if (flags & DEF_LOCAL) |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5344 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5345 GLOBAL_AFTER_ASSIGN, |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5346 name); |
|
16853
05785bdf289c
Use the new PyErr_WarnExplicit() API to issue better warnings for
Guido van Rossum <guido@python.org>
parents:
16838
diff
changeset
|
5347 else |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5348 PyOS_snprintf(buf, sizeof(buf), |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5349 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
|
5350 symtable_warn(st, buf); |
|
16783
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5351 } |
|
4feea99be777
Add warnings about undefined "global"
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16781
diff
changeset
|
5352 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5353 symtable_add_def(st, name, DEF_GLOBAL); |
|
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5354 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5355 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5356 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5357 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
|
5358 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
|
5359 { |
|
21086
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5360 char tmpname[30]; |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5361 |
|
ea5b0f0b716f
code_repr(), com_addop_varname(), com_list_comprehension(),
Barry Warsaw <barry@python.org>
parents:
21066
diff
changeset
|
5362 PyOS_snprintf(tmpname, sizeof(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
|
5363 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
|
5364 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
|
5365 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
|
5366 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
|
5367 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
|
5368 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5369 |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5370 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
|
5371 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
|
5372 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5373 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
|
5374 /* 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
|
5375 | '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
|
5376 ('*' | 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
|
5377 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
|
5378 */ |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5379 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
|
5380 node *dotname = CHILD(n, 1); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5381 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
|
5382 /* check for bogus imports */ |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5383 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
|
5384 PyErr_SetString(PyExc_SyntaxError, |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5385 LATE_FUTURE); |
|
16838
09f6c1372056
Improve SyntaxErrors for bad future statements. Set file and location
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16831
diff
changeset
|
5386 PyErr_SyntaxLocation(st->st_filename, |
|
16823
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5387 n->n_lineno); |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5388 st->st_errors++; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5389 return; |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5390 } |
|
acbe74f3a786
Presumed correct compiler pass for future statements
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16799
diff
changeset
|
5391 } |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5392 if (TYPE(CHILD(n, 3)) == STAR) { |
|
19018
821e35706c07
Fix SF bug [ #445474 ] warn about import * inside functions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
18631
diff
changeset
|
5393 if (st->st_cur->ste_type != TYPE_MODULE) { |
|
19021
e5754f048f0b
Another bug fix for recent import * warning (caught by Thomas Wouters)
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19019
diff
changeset
|
5394 if (symtable_warn(st, |
|
e5754f048f0b
Another bug fix for recent import * warning (caught by Thomas Wouters)
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19019
diff
changeset
|
5395 "import * only allowed at module level") < 0) |
|
e5754f048f0b
Another bug fix for recent import * warning (caught by Thomas Wouters)
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
19019
diff
changeset
|
5396 return; |
|
19018
821e35706c07
Fix SF bug [ #445474 ] warn about import * inside functions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
18631
diff
changeset
|
5397 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5398 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
|
5399 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
|
5400 } else { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5401 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
|
5402 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
|
5403 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
|
5404 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
|
5405 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
|
5406 else |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5407 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
|
5408 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
|
5409 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5410 } |
|
16781
5a1230de436a
Preliminary support for future nested scopes
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16763
diff
changeset
|
5411 } 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
|
5412 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
|
5413 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
|
5414 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5415 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5416 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5417 |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5418 /* The third argument to symatble_assign() is a flag to be passed to |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5419 symtable_add_def() if it is eventually called. The flag is useful |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5420 to specify the particular type of assignment that should be |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5421 recorded, e.g. an assignment caused by import. |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5422 */ |
|
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5423 |
|
16015
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5424 static void |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5425 symtable_assign(struct symtable *st, node *n, int def_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
|
5426 { |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5427 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
|
5428 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
|
5429 |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5430 loop: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5431 switch (TYPE(n)) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5432 case lambdef: |
|
16357
9f2ca855fa44
Enforce two illegal import statements that were outlawed in the
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16353
diff
changeset
|
5433 /* 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
|
5434 pass will catch this error. */ |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5435 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5436 case power: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5437 if (NCH(n) > 2) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5438 for (i = 2; i < NCH(n); ++i) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5439 if (TYPE(CHILD(n, i)) != DOUBLESTAR) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5440 symtable_node(st, CHILD(n, i)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5441 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5442 if (NCH(n) > 1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5443 symtable_node(st, CHILD(n, 0)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5444 symtable_node(st, CHILD(n, 1)); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5445 } else { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5446 n = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5447 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5448 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5449 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5450 case listmaker: |
|
17076
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5451 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
|
5452 /* 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
|
5453 will catch it. */ |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5454 return; |
|
85d74f040712
Fix crashes in nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16933
diff
changeset
|
5455 } else { |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5456 for (i = 0; i < NCH(n); i += 2) |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5457 symtable_assign(st, CHILD(n, i), def_flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5458 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5459 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5460 case exprlist: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5461 case testlist: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5462 if (NCH(n) == 1) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5463 n = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5464 goto loop; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5465 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5466 else { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5467 int i; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5468 for (i = 0; i < NCH(n); i += 2) |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5469 symtable_assign(st, CHILD(n, i), def_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
|
5470 return; |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5471 } |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5472 case atom: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5473 tmp = CHILD(n, 0); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5474 if (TYPE(tmp) == LPAR || TYPE(tmp) == LSQB) { |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5475 n = CHILD(n, 1); |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5476 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
|
5477 } else if (TYPE(tmp) == NAME) { |
|
20939
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5478 if (strcmp(STR(tmp), "__debug__") == 0) { |
|
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5479 PyErr_SetString(PyExc_SyntaxError, |
|
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5480 ASSIGN_DEBUG); |
|
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5481 PyErr_SyntaxLocation(st->st_filename, |
|
21179
485422900ef0
SF bug #488687 reported by Neal Norwitz
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
21086
diff
changeset
|
5482 n->n_lineno); |
|
20939
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5483 st->st_errors++; |
|
13df8b6c2b80
Fix SF buf #480096: Assign to __debug__ still allowed
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20867
diff
changeset
|
5484 } |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5485 symtable_add_def(st, STR(tmp), DEF_LOCAL | def_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
|
5486 } |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5487 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5488 case dotted_as_name: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5489 if (NCH(n) == 3) |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5490 symtable_add_def(st, STR(CHILD(n, 2)), |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5491 DEF_LOCAL | def_flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5492 else |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5493 symtable_add_def(st, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5494 STR(CHILD(CHILD(n, |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5495 0), 0)), |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5496 DEF_LOCAL | def_flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5497 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5498 case dotted_name: |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5499 symtable_add_def(st, STR(CHILD(n, 0)), DEF_LOCAL | def_flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5500 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5501 case NAME: |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5502 symtable_add_def(st, STR(n), DEF_LOCAL | def_flag); |
|
16257
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5503 return; |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5504 default: |
|
fd8c7203251f
PEP 227 implementation
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16250
diff
changeset
|
5505 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
|
5506 return; |
|
16677
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5507 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
|
5508 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
|
5509 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
|
5510 } |
|
16677
b955e74955d5
Tolerate ill-formed trees in symtable_assign(). Fixes SF bug 132510.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16658
diff
changeset
|
5511 /* 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
|
5512 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
|
5513 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
|
5514 if (TYPE(CHILD(n, i)) >= single_input) |
|
20517
d51fe520e5fd
Fix for SF bug [ #471928 ] global made w/nested list comprehensions
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
20491
diff
changeset
|
5515 symtable_assign(st, CHILD(n, i), def_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
|
5516 } |
|
c832ef72499d
This patch introduces an extra pass to the compiler that generates a
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
16006
diff
changeset
|
5517 } |