mirrors/cpython
0
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2024-11-25 19:03:49 +08:00
Code Issues Packages Projects Releases Wiki Activity
f6e47ad4bd
cpython/Python/ceval.c

3525 lines
78 KiB
C
Raw Normal View History

Added copyright notice.
1991-02-19 20:39:46 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
/* Execute compiled code */
Initial revision
1990-11-19 01:27:39 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* XXX TO DO:
XXX how to pass arguments to call_trace?
XXX speed up searching for keywords by using a dictionary
XXX document it!
*/
Quickly renamed.
1997-04-30 02:18:01 +08:00
#include "Python.h"
Initial revision
1990-11-19 01:27:39 +08:00
#include "compile.h"
"Compiling" version
1990-12-20 23:06:42 +08:00
#include "frameobject.h"
* Makefile: cosmetics * socketmodule.c: get rid of makepair(); fix makesocketaddr to fix broken recvfrom() * socketmodule: get rid of getStrarg() * ceval.h: move eval_code() to new file eval.h, so compile.h is no longer needed. * ceval.c: move thread comments to ceval.h; always make save/restore thread functions available (for dynloaded modules) * cdmodule.c, listobject.c: don't include compile.h * flmodule.c: include ceval.h * import.c: include eval.h instead of ceval.h * cgen.py: add forground(); noport(); winopen(""); to initgl(). * bltinmodule.c, socketmodule.c, fileobject.c, posixmodule.c, selectmodule.c: adapt to threads (add BGN/END SAVE macros) * stdwinmodule.c: adapt to threads and use a special stdwin lock. * pythonmain.c: don't include getpythonpath(). * pythonrun.c: use BGN/END SAVE instead of direct calls; also more BGN/END SAVE calls etc. * thread.c: bigger stack size for sun; change exit() to _exit() * threadmodule.c: use BGN/END SAVE macros where possible * timemodule.c: adapt better to threads; use BGN/END SAVE; add longsleep internal function if BSD_TIME; cosmetics
1992-08-06 03:58:53 +08:00
#include "eval.h"
Initial revision
1990-11-19 01:27:39 +08:00
#include "opcode.h"
Include macglue.h for some function prototypes, and renamed a few mac-specific functions to have a PyMac_ name.
2000-07-12 05:59:16 +08:00
#ifdef macintosh
#include "macglue.h"
#endif
* mpzmodule.c: removed redundant mpz_print function. * object.[ch], bltinmodule.c, fileobject.c: changed str() to call strobject() which calls an object's __str__ method if it has one. strobject() is also called by writeobject() when PRINT_RAW is passed. * ceval.c: rationalize code for PRINT_ITEM (no change in function!) * funcobject.c, codeobject.c: added compare and hash functionality. Functions with identical code objects and the same global dictionary are equal. Code objects are equal when their code, constants list and names list are identical (i.e. the filename and code name don't count). (hash doesn't work yet since the constants are in a list and lists can't be hashed -- suppose this should really be done with a tuple now we have resizetuple!)
1993-11-05 18:22:19 +08:00
#include <ctype.h>
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
/* Turn this on if your compiler chokes on the big switch: */
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
/* #define CASE_TOO_BIG 1 */
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
Rename DEBUG macro to Py_DEBUG
1996-12-31 00:17:54 +08:00
#ifdef Py_DEBUG
User trace feature.
1992-01-12 10:29:51 +08:00
/* For debugging the interpreter: */
#define LLTRACE 1 /* Low-level trace feature */
#define CHECKEXC 1 /* Double-check exception checking */
Initial revision
1990-11-19 01:27:39 +08:00
#endif
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
* Fixed some subtleties with fastlocals. You can no longer access f_fastlocals in a traceback object (this is a core dump hazard if there are <nil> entries), but instead eval_code() merges the fast locals back into the locals dictionary if it looks like the local variables will be retained. Also, the merge routines save exceptions since this is sometimes needed (alas!). * Added id() to bltinmodule.c, which returns an object's address (identity). Useful to walk arbitrary data structures containing cycles. * Added compile() to bltinmodule.c and compile_string() to pythonrun.[ch]: support to exec/eval arbitrary code objects. The code that defaults globals and locals is moved from run_node in pythonrun.c (which is now identical to eval_node) to eval_code in ceval.c. [XXX For elegance a clean-up session is necessary.]
1993-03-31 01:46:03 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Forward declarations */
lint (added prototypes for all static fns)
1992-03-28 01:29:15 +08:00
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
2000-07-09 11:09:57 +08:00
static PyObject *eval_code2(PyCodeObject *,
PyObject *, PyObject *,
PyObject **, int,
PyObject **, int,
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PyObject **, int,
PyObject *);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
static PyObject *call_object(PyObject *, PyObject *, PyObject *);
static PyObject *call_cfunction(PyObject *, PyObject *, PyObject *);
static PyObject *call_instance(PyObject *, PyObject *, PyObject *);
static PyObject *call_method(PyObject *, PyObject *, PyObject *);
static PyObject *call_eval_code2(PyObject *, PyObject *, PyObject *);
static PyObject *fast_function(PyObject *, PyObject ***, int, int, int);
static PyObject *fast_cfunction(PyObject *, PyObject ***, int);
static PyObject *do_call(PyObject *, PyObject ***, int, int);
static PyObject *ext_do_call(PyObject *, PyObject ***, int, int, int);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
static PyObject *update_keyword_args(PyObject *, int, PyObject ***,PyObject *);
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
static PyObject *update_star_args(int, int, PyObject *, PyObject ***);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
static PyObject *load_args(PyObject ***, int);
#define CALL_FLAG_VAR 1
#define CALL_FLAG_KW 2
lint (added prototypes for all static fns)
1992-03-28 01:29:15 +08:00
#ifdef LLTRACE
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
2000-07-09 11:09:57 +08:00
static int prtrace(PyObject *, char *);
lint (added prototypes for all static fns)
1992-03-28 01:29:15 +08:00
#endif
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
2000-07-09 11:09:57 +08:00
static void call_exc_trace(PyObject **, PyObject**, PyFrameObject *);
static int call_trace(PyObject **, PyObject **,
PyFrameObject *, char *, PyObject *);
static PyObject *loop_subscript(PyObject *, PyObject *);
static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);
static int assign_slice(PyObject *, PyObject *,
PyObject *, PyObject *);
static PyObject *cmp_outcome(int, PyObject *, PyObject *);
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
static PyObject *import_from(PyObject *, PyObject *);
static int import_all_from(PyObject *, PyObject *);
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
2000-07-09 11:09:57 +08:00
static PyObject *build_class(PyObject *, PyObject *, PyObject *);
static int exec_statement(PyFrameObject *,
PyObject *, PyObject *, PyObject *);
static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
static void reset_exc_info(PyThreadState *);
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
static void format_exc_check_arg(PyObject *, char *, PyObject *);
lint (added prototypes for all static fns)
1992-03-28 01:29:15 +08:00
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
#define NAME_ERROR_MSG \
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"name '%.200s' is not defined"
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
#define GLOBAL_NAME_ERROR_MSG \
"global name '%.200s' is not defined"
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
#define UNBOUNDLOCAL_ERROR_MSG \
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"local variable '%.200s' referenced before assignment"
Initial revision
1990-11-19 01:27:39 +08:00
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
/* Dynamic execution profile */
#ifdef DYNAMIC_EXECUTION_PROFILE
#ifdef DXPAIRS
static long dxpairs[257][256];
#define dxp dxpairs[256]
#else
static long dxp[256];
#endif
#endif
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
#ifdef WITH_THREAD
* Makefile: cosmetics * socketmodule.c: get rid of makepair(); fix makesocketaddr to fix broken recvfrom() * socketmodule: get rid of getStrarg() * ceval.h: move eval_code() to new file eval.h, so compile.h is no longer needed. * ceval.c: move thread comments to ceval.h; always make save/restore thread functions available (for dynloaded modules) * cdmodule.c, listobject.c: don't include compile.h * flmodule.c: include ceval.h * import.c: include eval.h instead of ceval.h * cgen.py: add forground(); noport(); winopen(""); to initgl(). * bltinmodule.c, socketmodule.c, fileobject.c, posixmodule.c, selectmodule.c: adapt to threads (add BGN/END SAVE macros) * stdwinmodule.c: adapt to threads and use a special stdwin lock. * pythonmain.c: don't include getpythonpath(). * pythonrun.c: use BGN/END SAVE instead of direct calls; also more BGN/END SAVE calls etc. * thread.c: bigger stack size for sun; change exit() to _exit() * threadmodule.c: use BGN/END SAVE macros where possible * timemodule.c: adapt better to threads; use BGN/END SAVE; add longsleep internal function if BSD_TIME; cosmetics
1992-08-06 03:58:53 +08:00
Changes by Mark Hammond for Windows CE. Mostly of the form #ifdef DONT_HAVE_header_H ... #endif around #include <header.h>.
1999-04-08 00:07:23 +08:00
#ifndef DONT_HAVE_ERRNO_H
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
#include <errno.h>
Changes by Mark Hammond for Windows CE. Mostly of the form #ifdef DONT_HAVE_header_H ... #endif around #include <header.h>.
1999-04-08 00:07:23 +08:00
#endif
Renamed thread.h to pythread.h.
1998-10-02 04:42:43 +08:00
#include "pythread.h"
* Makefile: cosmetics * socketmodule.c: get rid of makepair(); fix makesocketaddr to fix broken recvfrom() * socketmodule: get rid of getStrarg() * ceval.h: move eval_code() to new file eval.h, so compile.h is no longer needed. * ceval.c: move thread comments to ceval.h; always make save/restore thread functions available (for dynloaded modules) * cdmodule.c, listobject.c: don't include compile.h * flmodule.c: include ceval.h * import.c: include eval.h instead of ceval.h * cgen.py: add forground(); noport(); winopen(""); to initgl(). * bltinmodule.c, socketmodule.c, fileobject.c, posixmodule.c, selectmodule.c: adapt to threads (add BGN/END SAVE macros) * stdwinmodule.c: adapt to threads and use a special stdwin lock. * pythonmain.c: don't include getpythonpath(). * pythonrun.c: use BGN/END SAVE instead of direct calls; also more BGN/END SAVE calls etc. * thread.c: bigger stack size for sun; change exit() to _exit() * threadmodule.c: use BGN/END SAVE macros where possible * timemodule.c: adapt better to threads; use BGN/END SAVE; add longsleep internal function if BSD_TIME; cosmetics
1992-08-06 03:58:53 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
extern int _PyThread_Started; /* Flag for Py_Exit */
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
static PyThread_type_lock interpreter_lock = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
static long main_thread = 0;
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_InitThreads(void)
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
{
if (interpreter_lock)
Various changes. * Makefile: svmodule.c.proto and svgen.py are gone, svmodule.c came in their stead. Also, pass -DUSE_DL flag to thread.c and give the user a possibility to add the -DDEBUG to just thread.c. * ceval.c: init_save_thread() can be called more than once now. * svgen.py, svmodule.c.proto, svmodule.c: Removed prototype file and replaced it by the generated file. * thread.c: Added some more checks; added call to DL library when it is also used to tell it where the shared arena is so that DL can use some other area. * threadmodule.c: Call init_save_thread from another place. Also, added new function getlocklock() which does to lock objects what getfilefile does to file objects.
1993-01-06 21:36:38 +08:00
return;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
_PyThread_Started = 1;
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
interpreter_lock = PyThread_allocate_lock();
PyThread_acquire_lock(interpreter_lock, 1);
main_thread = PyThread_get_thread_ident();
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
}
* Makefile: cosmetics * socketmodule.c: get rid of makepair(); fix makesocketaddr to fix broken recvfrom() * socketmodule: get rid of getStrarg() * ceval.h: move eval_code() to new file eval.h, so compile.h is no longer needed. * ceval.c: move thread comments to ceval.h; always make save/restore thread functions available (for dynloaded modules) * cdmodule.c, listobject.c: don't include compile.h * flmodule.c: include ceval.h * import.c: include eval.h instead of ceval.h * cgen.py: add forground(); noport(); winopen(""); to initgl(). * bltinmodule.c, socketmodule.c, fileobject.c, posixmodule.c, selectmodule.c: adapt to threads (add BGN/END SAVE macros) * stdwinmodule.c: adapt to threads and use a special stdwin lock. * pythonmain.c: don't include getpythonpath(). * pythonrun.c: use BGN/END SAVE instead of direct calls; also more BGN/END SAVE calls etc. * thread.c: bigger stack size for sun; change exit() to _exit() * threadmodule.c: use BGN/END SAVE macros where possible * timemodule.c: adapt better to threads; use BGN/END SAVE; add longsleep internal function if BSD_TIME; cosmetics
1992-08-06 03:58:53 +08:00
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_AcquireLock(void)
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
{
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_acquire_lock(interpreter_lock, 1);
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
}
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_ReleaseLock(void)
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
{
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_release_lock(interpreter_lock);
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
}
Moved PyEval_{Acquire,Release}Thread() to within the same #ifdef WITH_THREAD as PyEval_InitThreads(). Removed use of Py_SuppressPrintingFlag.
1997-07-20 03:55:50 +08:00
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_AcquireThread(PyThreadState *tstate)
Moved PyEval_{Acquire,Release}Thread() to within the same #ifdef WITH_THREAD as PyEval_InitThreads(). Removed use of Py_SuppressPrintingFlag.
1997-07-20 03:55:50 +08:00
{
if (tstate == NULL)
Py_FatalError("PyEval_AcquireThread: NULL new thread state");
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_acquire_lock(interpreter_lock, 1);
Moved PyEval_{Acquire,Release}Thread() to within the same #ifdef WITH_THREAD as PyEval_InitThreads(). Removed use of Py_SuppressPrintingFlag.
1997-07-20 03:55:50 +08:00
if (PyThreadState_Swap(tstate) != NULL)
Py_FatalError(
"PyEval_AcquireThread: non-NULL old thread state");
}
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_ReleaseThread(PyThreadState *tstate)
Moved PyEval_{Acquire,Release}Thread() to within the same #ifdef WITH_THREAD as PyEval_InitThreads(). Removed use of Py_SuppressPrintingFlag.
1997-07-20 03:55:50 +08:00
{
if (tstate == NULL)
Py_FatalError("PyEval_ReleaseThread: NULL thread state");
if (PyThreadState_Swap(NULL) != tstate)
Py_FatalError("PyEval_ReleaseThread: wrong thread state");
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_release_lock(interpreter_lock);
Moved PyEval_{Acquire,Release}Thread() to within the same #ifdef WITH_THREAD as PyEval_InitThreads(). Removed use of Py_SuppressPrintingFlag.
1997-07-20 03:55:50 +08:00
}
Charles Waldman's patch to reinitialize the interpreter lock after a fork. This solves the test_fork1 problem. (ceval.c, signalmodule.c, intrcheck.c) SourceForge: [ Patch #101226 ] make threading fork-safe
2000-08-28 01:34:07 +08:00
/* This function is called from PyOS_AfterFork to ensure that newly
created child processes don't hold locks referring to threads which
are not running in the child process. (This could also be done using
pthread_atfork mechanism, at least for the pthreads implementation.) */
void
PyEval_ReInitThreads(void)
{
if (!interpreter_lock)
return;
/*XXX Can't use PyThread_free_lock here because it does too
much error-checking. Doing this cleanly would require
adding a new function to each thread_*.h. Instead, just
create a new lock and waste a little bit of memory */
interpreter_lock = PyThread_allocate_lock();
PyThread_acquire_lock(interpreter_lock, 1);
main_thread = PyThread_get_thread_ident();
}
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
#endif
* Makefile: cosmetics * socketmodule.c: get rid of makepair(); fix makesocketaddr to fix broken recvfrom() * socketmodule: get rid of getStrarg() * ceval.h: move eval_code() to new file eval.h, so compile.h is no longer needed. * ceval.c: move thread comments to ceval.h; always make save/restore thread functions available (for dynloaded modules) * cdmodule.c, listobject.c: don't include compile.h * flmodule.c: include ceval.h * import.c: include eval.h instead of ceval.h * cgen.py: add forground(); noport(); winopen(""); to initgl(). * bltinmodule.c, socketmodule.c, fileobject.c, posixmodule.c, selectmodule.c: adapt to threads (add BGN/END SAVE macros) * stdwinmodule.c: adapt to threads and use a special stdwin lock. * pythonmain.c: don't include getpythonpath(). * pythonrun.c: use BGN/END SAVE instead of direct calls; also more BGN/END SAVE calls etc. * thread.c: bigger stack size for sun; change exit() to _exit() * threadmodule.c: use BGN/END SAVE macros where possible * timemodule.c: adapt better to threads; use BGN/END SAVE; add longsleep internal function if BSD_TIME; cosmetics
1992-08-06 03:58:53 +08:00
/* Functions save_thread and restore_thread are always defined so
dynamically loaded modules needn't be compiled separately for use
with and without threads: */
PyEval_SaveThread() and PyEval_RestoreThread() now return/take a PyThreadState pointer instead of a (frame) PyObject pointer. This makes much more sense. It is backward incompatible, but that's no problem, because (a) the heaviest users are the Py_{BEGIN,END}_ ALLOW_THREADS macros here, which have been fixed too; (b) there are very few direct users; (c) those who use it are there will probably appreciate the change. Also, added new functions PyEval_AcquireThread() and PyEval_ReleaseThread() which allows the threads created by the thread module as well threads created by others (!) to set/reset the current thread, and at the same time acquire/release the interpreter lock. Much saner.
1997-07-19 07:56:58 +08:00
PyThreadState *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_SaveThread(void)
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
{
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
PyThreadState *tstate = PyThreadState_Swap(NULL);
if (tstate == NULL)
Py_FatalError("PyEval_SaveThread: NULL tstate");
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
#ifdef WITH_THREAD
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
if (interpreter_lock)
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_release_lock(interpreter_lock);
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
#endif
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
return tstate;
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
}
void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_RestoreThread(PyThreadState *tstate)
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
{
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
if (tstate == NULL)
Py_FatalError("PyEval_RestoreThread: NULL tstate");
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
#ifdef WITH_THREAD
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
if (interpreter_lock) {
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
int err = errno;
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_acquire_lock(interpreter_lock, 1);
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
errno = err;
}
#endif
Change PyEval_SaveThread() and PyEval_RestoreThread() to always do the tstate swapping. Only the acquiring and releasing of the lock is conditional (twice, under ``#ifdef WITH_THREAD'' and inside ``if (interpreter_lock)'').
1997-10-01 06:03:16 +08:00
PyThreadState_Swap(tstate);
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
}
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
signal handlers or Mac I/O completion routines) can schedule calls
to a function to be called synchronously.
The synchronous function is called with one void* argument.
It should return 0 for success or -1 for failure -- failure should
be accompanied by an exception.
If registry succeeds, the registry function returns 0; if it fails
(e.g. due to too many pending calls) it returns -1 (without setting
an exception condition).
Note that because registry may occur from within signal handlers,
or other asynchronous events, calling malloc() is unsafe!
#ifdef WITH_THREAD
Any thread can schedule pending calls, but only the main thread
will execute them.
#endif
XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
There are two possible race conditions:
(1) nested asynchronous registry calls;
(2) registry calls made while pending calls are being processed.
While (1) is very unlikely, (2) is a real possibility.
The current code is safe against (2), but not against (1).
The safety against (2) is derived from the fact that only one
thread (the main thread) ever takes things out of the queue.
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
XXX Darn! With the advent of thread state, we should have an array
of pending calls per thread in the thread state! Later...
*/
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
#define NPENDINGCALLS 32
static struct {
Use 'void' directly instead of the ANY #define, now that all code is ANSI C. Leave the actual #define in for API compatibility.
2000-07-25 20:56:38 +08:00
int (*func)(void *);
void *arg;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
} pendingcalls[NPENDINGCALLS];
static volatile int pendingfirst = 0;
static volatile int pendinglast = 0;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
static volatile int things_to_do = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
int
Use 'void' directly instead of the ANY #define, now that all code is ANSI C. Leave the actual #define in for API compatibility.
2000-07-25 20:56:38 +08:00
Py_AddPendingCall(int (*func)(void *), void *arg)
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
{
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
static int busy = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
int i, j;
/* XXX Begin critical section */
/* XXX If you want this to be safe against nested
XXX asynchronous calls, you'll have to work harder! */
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
if (busy)
return -1;
busy = 1;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
i = pendinglast;
j = (i + 1) % NPENDINGCALLS;
if (j == pendingfirst)
return -1; /* Queue full */
pendingcalls[i].func = func;
pendingcalls[i].arg = arg;
pendinglast = j;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
things_to_do = 1; /* Signal main loop */
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
busy = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
/* XXX End critical section */
return 0;
}
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
Py_MakePendingCalls(void)
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
{
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
static int busy = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
#ifdef WITH_THREAD
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
if (main_thread && PyThread_get_thread_ident() != main_thread)
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
return 0;
#endif
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (busy)
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
return 0;
busy = 1;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
things_to_do = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
for (;;) {
int i;
Use 'void' directly instead of the ANY #define, now that all code is ANSI C. Leave the actual #define in for API compatibility.
2000-07-25 20:56:38 +08:00
int (*func)(void *);
void *arg;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
i = pendingfirst;
if (i == pendinglast)
break; /* Queue empty */
func = pendingcalls[i].func;
arg = pendingcalls[i].arg;
pendingfirst = (i + 1) % NPENDINGCALLS;
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
if (func(arg) < 0) {
busy = 0;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
things_to_do = 1; /* We're not done yet */
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
return -1;
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
}
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
}
* Python/ceval.c, Include/ceval.h: promote MakePendingCalls to global: Py_MakePendingCalls. Also guard against recursive calls * Include/classobject.h, Objects/classobject.c, Python/{ceval.c,bltinmodule.c}: entirely redone operator overloading. The rules for class instances are now much more relaxed than for other built-in types (whose coerce must still return two objects of the same type)
1994-09-29 17:45:57 +08:00
busy = 0;
* Python/ceval.c (eval_code): added registry of pending functions (to be used by functions that are called asynchronously, like UNIX signal handlers or Mac I/O completion routines)
1994-09-14 21:31:22 +08:00
return 0;
}
add user-modifiable recursion_limit ceval.c: define recurion_limit (static), default value is 2500 define Py_GetRecursionLimit and Py_SetRecursionLimit raise RuntimeError if limit is exceeded PC/config.h: remove plat-specific definition sysmodule.c: add sys.(get|set)recursionlimit
2000-09-01 03:23:01 +08:00
/* The interpreter's recursion limit */
Set the recursion limit to 1000 -- 2500 was not enough, let's be conservative.
2000-09-01 09:52:08 +08:00
static int recursion_limit = 1000;
add user-modifiable recursion_limit ceval.c: define recurion_limit (static), default value is 2500 define Py_GetRecursionLimit and Py_SetRecursionLimit raise RuntimeError if limit is exceeded PC/config.h: remove plat-specific definition sysmodule.c: add sys.(get|set)recursionlimit
2000-09-01 03:23:01 +08:00
Cosmetics on Py_Get/SetRecursionLimit (for the style guide)
2000-09-01 19:07:19 +08:00
int
Py_GetRecursionLimit(void)
add user-modifiable recursion_limit ceval.c: define recurion_limit (static), default value is 2500 define Py_GetRecursionLimit and Py_SetRecursionLimit raise RuntimeError if limit is exceeded PC/config.h: remove plat-specific definition sysmodule.c: add sys.(get|set)recursionlimit
2000-09-01 03:23:01 +08:00
{
return recursion_limit;
}
Cosmetics on Py_Get/SetRecursionLimit (for the style guide)
2000-09-01 19:07:19 +08:00
void
Py_SetRecursionLimit(int new_limit)
add user-modifiable recursion_limit ceval.c: define recurion_limit (static), default value is 2500 define Py_GetRecursionLimit and Py_SetRecursionLimit raise RuntimeError if limit is exceeded PC/config.h: remove plat-specific definition sysmodule.c: add sys.(get|set)recursionlimit
2000-09-01 03:23:01 +08:00
{
recursion_limit = new_limit;
}
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Status code for main loop (reason for stack unwind) */
enum why_code {
WHY_NOT, /* No error */
WHY_EXCEPTION, /* Exception occurred */
WHY_RERAISE, /* Exception re-raised by 'finally' */
WHY_RETURN, /* 'return' statement */
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
WHY_BREAK, /* 'break' statement */
Remove trailing comma from 'why_code' enum, which was introduced by the continue-inside-try patch. Partly fixes SF bug #132597.
2001-02-16 19:52:31 +08:00
WHY_CONTINUE /* 'continue' statement */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
};
Initial revision
1990-11-19 01:27:39 +08:00
Nuke all remaining occurrences of Py_PROTO and Py_FPROTO.
2000-07-09 11:09:57 +08:00
static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
static int unpack_sequence(PyObject *, int, PyObject **);
Cleanup: - fix bug in Py_MakePendingCalls() with threading - fix return type of do_raise - remove build_slice (same as PySlice_New) - remove code inside #if 0 - remove code inside #ifdef CHECK_STACK - remove code inside #ifdef SUPPORT_OBSOLETE_ACCESS - comment about newimp.py should refer to ni.py
1997-01-21 13:34:20 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
{
return eval_code2(co,
globals, locals,
Quickly renamed.
1997-04-30 02:18:01 +08:00
(PyObject **)NULL, 0,
(PyObject **)NULL, 0,
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
(PyObject **)NULL, 0,
NULL);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
/* Interpreter main loop */
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
eval_code2(PyCodeObject *co, PyObject *globals, PyObject *locals,
PyObject **args, int argcount, PyObject **kws, int kwcount,
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PyObject **defs, int defcount, PyObject *closure)
Initial revision
1990-11-19 01:27:39 +08:00
{
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
#ifdef DXPAIRS
int lastopcode = 0;
#endif
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyObject **stack_pointer;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
register unsigned char *next_instr;
Initialized opcode and oparg to silence a gcc -Wall warning.
2000-08-07 14:34:45 +08:00
register int opcode=0; /* Current opcode */
register int oparg=0; /* Current opcode argument, if any */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
register enum why_code why; /* Reason for block stack unwind */
register int err; /* Error status -- nonzero if error */
Quickly renamed.
1997-04-30 02:18:01 +08:00
register PyObject *x; /* Result object -- NULL if error */
register PyObject *v; /* Temporary objects popped off stack */
register PyObject *w;
register PyObject *u;
register PyObject *t;
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
register PyObject *stream = NULL; /* for PRINT opcodes */
Quickly renamed.
1997-04-30 02:18:01 +08:00
register PyFrameObject *f; /* Current frame */
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
register PyObject **fastlocals, **freevars;
Whoops! One the "redundant" initializations removed by Vladimir in the previous patch wasn't -- there was a path through the code that bypassed all initializations. Thanks to Just for reporting the bug!
1998-11-24 05:09:51 +08:00
PyObject *retval = NULL; /* Return value */
Use PyThreadState_GET() macro.
1998-12-22 02:33:30 +08:00
PyThreadState *tstate = PyThreadState_GET();
Changes to support other object types besides strings as the code string of code objects, as long as they support the (readonly) buffer interface. By Greg Stein.
1998-10-08 03:42:25 +08:00
unsigned char *first_instr;
User trace feature.
1992-01-12 10:29:51 +08:00
#ifdef LLTRACE
(I suggest a recompile after getting this, the ceval.c bugfix may be crucial!) * Makefile: removed superfluous AR=ar, fixed misleading comment. * ceval.c: fixed debugging code; save/restore errors in locals_2_fast. * intrcheck.c: for SunOS etc., turn off syscall resumption. * regexpr.h: bump number of registers to 100.
1993-04-15 23:33:52 +08:00
int lltrace;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#endif
Rename DEBUG macro to Py_DEBUG
1996-12-31 00:17:54 +08:00
#if defined(Py_DEBUG) || defined(LLTRACE)
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* Make it easier to find out where we are with a debugger */
Quickly renamed.
1997-04-30 02:18:01 +08:00
char *filename = PyString_AsString(co->co_filename);
Add some debugging features if DEBUG defined (fetch the filename as a string so I can see it with dbx, and set f_lineno); call abort() when detecting an "undetected" error.
1992-09-04 04:29:45 +08:00
#endif
Initial revision
1990-11-19 01:27:39 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Code access macros */
"Compiling" version
1990-12-20 23:06:42 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#define GETCONST(i) Getconst(f, i)
#define GETNAME(i) Getname(f, i)
#define GETNAMEV(i) Getnamev(f, i)
Changes to support other object types besides strings as the code string of code objects, as long as they support the (readonly) buffer interface. By Greg Stein.
1998-10-08 03:42:25 +08:00
#define INSTR_OFFSET() (next_instr - first_instr)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#define NEXTOP() (*next_instr++)
#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
Changes to support other object types besides strings as the code string of code objects, as long as they support the (readonly) buffer interface. By Greg Stein.
1998-10-08 03:42:25 +08:00
#define JUMPTO(x) (next_instr = first_instr + (x))
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#define JUMPBY(x) (next_instr += (x))
"Compiling" version
1990-12-20 23:06:42 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Stack manipulation macros */
Initial revision
1990-11-19 01:27:39 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#define STACK_LEVEL() (stack_pointer - f->f_valuestack)
#define EMPTY() (STACK_LEVEL() == 0)
#define TOP() (stack_pointer[-1])
#define BASIC_PUSH(v) (*stack_pointer++ = (v))
#define BASIC_POP() (*--stack_pointer)
Initial revision
1990-11-19 01:27:39 +08:00
User trace feature.
1992-01-12 10:29:51 +08:00
#ifdef LLTRACE
#define PUSH(v) (BASIC_PUSH(v), lltrace && prtrace(TOP(), "push"))
#define POP() (lltrace && prtrace(TOP(), "pop"), BASIC_POP())
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
#else
#define PUSH(v) BASIC_PUSH(v)
#define POP() BASIC_POP()
#endif
Initial revision
1990-11-19 01:27:39 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* Local variable macros */
#define GETLOCAL(i) (fastlocals[i])
Quickly renamed.
1997-04-30 02:18:01 +08:00
#define SETLOCAL(i, value) do { Py_XDECREF(GETLOCAL(i)); \
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
GETLOCAL(i) = value; } while (0)
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* Start of code */
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
#ifdef USE_STACKCHECK
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->recursion_depth%10 == 0 && PyOS_CheckStack()) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_MemoryError, "Stack overflow");
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
return NULL;
}
#endif
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (globals == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_SystemError, "eval_code2: NULL globals");
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
return NULL;
* Fixed some subtleties with fastlocals. You can no longer access f_fastlocals in a traceback object (this is a core dump hazard if there are <nil> entries), but instead eval_code() merges the fast locals back into the locals dictionary if it looks like the local variables will be retained. Also, the merge routines save exceptions since this is sometimes needed (alas!). * Added id() to bltinmodule.c, which returns an object's address (identity). Useful to walk arbitrary data structures containing cycles. * Added compile() to bltinmodule.c and compile_string() to pythonrun.[ch]: support to exec/eval arbitrary code objects. The code that defaults globals and locals is moved from run_node in pythonrun.c (which is now identical to eval_node) to eval_code in ceval.c. [XXX For elegance a clean-up session is necessary.]
1993-03-31 01:46:03 +08:00
}
(I suggest a recompile after getting this, the ceval.c bugfix may be crucial!) * Makefile: removed superfluous AR=ar, fixed misleading comment. * ceval.c: fixed debugging code; save/restore errors in locals_2_fast. * intrcheck.c: for SunOS etc., turn off syscall resumption. * regexpr.h: bump number of registers to 100.
1993-04-15 23:33:52 +08:00
#ifdef LLTRACE
Quickly renamed.
1997-04-30 02:18:01 +08:00
lltrace = PyDict_GetItemString(globals, "__lltrace__") != NULL;
(I suggest a recompile after getting this, the ceval.c bugfix may be crucial!) * Makefile: removed superfluous AR=ar, fixed misleading comment. * ceval.c: fixed debugging code; save/restore errors in locals_2_fast. * intrcheck.c: for SunOS etc., turn off syscall resumption. * regexpr.h: bump number of registers to 100.
1993-04-15 23:33:52 +08:00
#endif
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
f = PyFrame_New(tstate, /*back*/
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
co, /*code*/
Variety of small INC/DECREF patches that fix reported memory leaks with free variables. Thanks to Martin v. Loewis for finding two of the problems. This fixes SF buf 405583. There is also a C API change: PyFrame_New() is reverting to its pre-2.1 signature. The change introduced by nested scopes was a mistake. XXX Is this okay between beta releases? cell_clear(), the GC helper, must decref its reference to break cycles. frame_dealloc() must dealloc all cell vars and free vars in addition to locals. eval_code2() setup code must INCREF cells it copies out of the closure. The STORE_DEREF opcode implementation must DECREF the object it passes to PyCell_Set().
2001-03-13 09:58:22 +08:00
globals, locals);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (f == NULL)
return NULL;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
tstate->frame = f;
Two small changes: - Use co->... instead of f->f_code->...; save an extra lookup of what we already have in a local variable). - Remove test for nlocals > 0 before setting fastlocals to f->f_localsplus; 0 is a rare case and the assignment is safe even then.
1997-01-28 07:42:36 +08:00
fastlocals = f->f_localsplus;
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
freevars = f->f_localsplus + f->f_nlocals;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (co->co_argcount > 0 ||
co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
int i;
int n = argcount;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *kwdict = NULL;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (co->co_flags & CO_VARKEYWORDS) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
kwdict = PyDict_New();
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (kwdict == NULL)
goto fail;
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
i = co->co_argcount;
if (co->co_flags & CO_VARARGS)
i++;
SETLOCAL(i, kwdict);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
if (argcount > co->co_argcount) {
if (!(co->co_flags & CO_VARARGS)) {
Give more detailed error message when the argument count isn't right.
1997-11-20 00:05:40 +08:00
PyErr_Format(PyExc_TypeError,
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
"%.200s() takes %s %d "
"%sargument%s (%d given)",
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
PyString_AsString(co->co_name),
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
defcount ? "at most" : "exactly",
co->co_argcount,
kwcount ? "non-keyword " : "",
co->co_argcount == 1 ? "" : "s",
argcount);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
goto fail;
}
n = co->co_argcount;
}
for (i = 0; i < n; i++) {
x = args[i];
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
SETLOCAL(i, x);
}
if (co->co_flags & CO_VARARGS) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
u = PyTuple_New(argcount - n);
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
if (u == NULL)
goto fail;
SETLOCAL(co->co_argcount, u);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
for (i = n; i < argcount; i++) {
x = args[i];
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
PyTuple_SET_ITEM(u, i-n, x);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
}
for (i = 0; i < kwcount; i++) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *keyword = kws[2*i];
PyObject *value = kws[2*i + 1];
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
int j;
Fix PR117. The error message is "keywords must be strings". Perhaps not as descriptive as what Barry suggests, but this also catches the (in my opinion important) case where some other C code besides apply() constructs a kwdict that doesn't have the right format. All the other possibilities of getting it wrong (non-dict, wrong keywords etc) are already caught so this makes sense to check here.
1999-10-26 08:12:20 +08:00
if (keyword == NULL || !PyString_Check(keyword)) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
PyErr_Format(PyExc_TypeError,
"%.200s() keywords must be strings",
PyString_AsString(co->co_name));
Fix PR117. The error message is "keywords must be strings". Perhaps not as descriptive as what Barry suggests, but this also catches the (in my opinion important) case where some other C code besides apply() constructs a kwdict that doesn't have the right format. All the other possibilities of getting it wrong (non-dict, wrong keywords etc) are already caught so this makes sense to check here.
1999-10-26 08:12:20 +08:00
goto fail;
}
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* XXX slow -- speed up using dictionary? */
for (j = 0; j < co->co_argcount; j++) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyObject *nm = PyTuple_GET_ITEM(
co->co_varnames, j);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
int cmp = PyObject_RichCompareBool(
keyword, nm, Py_EQ);
if (cmp > 0)
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
else if (cmp < 0)
goto fail;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
PyObject_Compare can raise an exception now.
1997-05-23 08:06:51 +08:00
/* Check errors from Compare */
if (PyErr_Occurred())
goto fail;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (j >= co->co_argcount) {
if (kwdict == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Format(PyExc_TypeError,
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"%.200s() got an unexpected "
"keyword argument '%.400s'",
PyString_AsString(co->co_name),
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
PyString_AsString(keyword));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
goto fail;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyDict_SetItem(kwdict, keyword, value);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
else {
if (GETLOCAL(j) != NULL) {
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PyErr_Format(PyExc_TypeError,
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
"%.200s() got multiple "
"values for keyword "
"argument '%.400s'",
PyString_AsString(co->co_name),
PyString_AsString(keyword));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
goto fail;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(value);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
SETLOCAL(j, value);
}
}
if (argcount < co->co_argcount) {
int m = co->co_argcount - defcount;
for (i = argcount; i < m; i++) {
if (GETLOCAL(i) == NULL) {
Give more detailed error message when the argument count isn't right.
1997-11-20 00:05:40 +08:00
PyErr_Format(PyExc_TypeError,
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
"%.200s() takes %s %d "
"%sargument%s (%d given)",
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
PyString_AsString(co->co_name),
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
((co->co_flags & CO_VARARGS) ||
defcount) ? "at least"
: "exactly",
m, kwcount ? "non-keyword " : "",
m == 1 ? "" : "s", i);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
goto fail;
}
}
if (n > m)
i = n - m;
else
i = 0;
for (; i < defcount; i++) {
if (GETLOCAL(m+i) == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *def = defs[i];
Py_INCREF(def);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
SETLOCAL(m+i, def);
}
}
}
}
else {
if (argcount > 0 || kwcount > 0) {
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
PyErr_Format(PyExc_TypeError,
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
"%.200s() takes no arguments (%d given)",
PyString_AsString(co->co_name),
argcount + kwcount);
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
goto fail;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
}
Fix PyFrame_FastToLocals() and counterpart to deal with cells and frees. Note there doesn't seem to be any way to test LocalsToFast(), because the instructions that trigger it are illegal in nested scopes with free variables. Fix allocation strategy for cells that are also formal parameters. Instead of emitting LOAD_FAST / STORE_DEREF pairs for each parameter, have the argument handling code in eval_code2() do the right thing. A side-effect of this change is that cell variables that are also arguments are listed at the front of co_cellvars in the order they appear in the argument list.
2001-03-22 00:43:47 +08:00
/* Allocate and initialize storage for cell vars, and copy free
vars into frame. This isn't too efficient right now. */
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
if (f->f_ncells) {
Fix PyFrame_FastToLocals() and counterpart to deal with cells and frees. Note there doesn't seem to be any way to test LocalsToFast(), because the instructions that trigger it are illegal in nested scopes with free variables. Fix allocation strategy for cells that are also formal parameters. Instead of emitting LOAD_FAST / STORE_DEREF pairs for each parameter, have the argument handling code in eval_code2() do the right thing. A side-effect of this change is that cell variables that are also arguments are listed at the front of co_cellvars in the order they appear in the argument list.
2001-03-22 00:43:47 +08:00
int i = 0, j = 0, nargs, found;
char *cellname, *argname;
PyObject *c;
nargs = co->co_argcount;
if (co->co_flags & CO_VARARGS)
nargs++;
if (co->co_flags & CO_VARKEYWORDS)
nargs++;
/* Check for cells that shadow args */
for (i = 0; i < f->f_ncells && j < nargs; ++i) {
cellname = PyString_AS_STRING(
PyTuple_GET_ITEM(co->co_cellvars, i));
found = 0;
while (j < nargs) {
argname = PyString_AS_STRING(
PyTuple_GET_ITEM(co->co_varnames, j));
if (strcmp(cellname, argname) == 0) {
c = PyCell_New(GETLOCAL(j));
if (c == NULL)
goto fail;
GETLOCAL(f->f_nlocals + i) = c;
found = 1;
break;
}
j++;
}
if (found == 0) {
c = PyCell_New(NULL);
if (c == NULL)
goto fail;
SETLOCAL(f->f_nlocals + i, c);
}
}
/* Initialize any that are left */
while (i < f->f_ncells) {
c = PyCell_New(NULL);
if (c == NULL)
goto fail;
SETLOCAL(f->f_nlocals + i, c);
i++;
}
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
}
if (f->f_nfreevars) {
int i;
Variety of small INC/DECREF patches that fix reported memory leaks with free variables. Thanks to Martin v. Loewis for finding two of the problems. This fixes SF buf 405583. There is also a C API change: PyFrame_New() is reverting to its pre-2.1 signature. The change introduced by nested scopes was a mistake. XXX Is this okay between beta releases? cell_clear(), the GC helper, must decref its reference to break cycles. frame_dealloc() must dealloc all cell vars and free vars in addition to locals. eval_code2() setup code must INCREF cells it copies out of the closure. The STORE_DEREF opcode implementation must DECREF the object it passes to PyCell_Set().
2001-03-13 09:58:22 +08:00
for (i = 0; i < f->f_nfreevars; ++i) {
PyObject *o = PyTuple_GET_ITEM(closure, i);
Py_INCREF(o);
freevars[f->f_ncells + i] = o;
}
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
}
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->sys_tracefunc != NULL) {
/* tstate->sys_tracefunc, if defined, is a function that
will be called on *every* entry to a code block.
User trace feature.
1992-01-12 10:29:51 +08:00
Its return value, if not None, is a function that
will be called at the start of each executed line
of code. (Actually, the function must return
itself in order to continue tracing.)
The trace functions are called with three arguments:
a pointer to the current frame, a string indicating
why the function is called, and an argument which
depends on the situation. The global trace function
(sys.trace) is also called whenever an exception
is detected. */
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (call_trace(&tstate->sys_tracefunc,
&f->f_trace, f, "call",
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_None/*XXX how to compute arguments now?*/)) {
User trace feature.
1992-01-12 10:29:51 +08:00
/* Trace function raised an error */
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
goto fail;
User trace feature.
1992-01-12 10:29:51 +08:00
}
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
}
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->sys_profilefunc != NULL) {
/* Similar for sys_profilefunc, except it needn't return
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
itself and isn't called for "line" events */
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (call_trace(&tstate->sys_profilefunc,
(PyObject**)0, f, "call",
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_None/*XXX*/)) {
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
goto fail;
User trace feature.
1992-01-12 10:29:51 +08:00
}
}
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
add user-modifiable recursion_limit ceval.c: define recurion_limit (static), default value is 2500 define Py_GetRecursionLimit and Py_SetRecursionLimit raise RuntimeError if limit is exceeded PC/config.h: remove plat-specific definition sysmodule.c: add sys.(get|set)recursionlimit
2000-09-01 03:23:01 +08:00
if (++tstate->recursion_depth > recursion_limit) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
--tstate->recursion_depth;
PyErr_SetString(PyExc_RuntimeError,
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"maximum recursion depth exceeded");
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
tstate->frame = f->f_back;
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(f);
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
return NULL;
}
Changes to support other object types besides strings as the code string of code objects, as long as they support the (readonly) buffer interface. By Greg Stein.
1998-10-08 03:42:25 +08:00
_PyCode_GETCODEPTR(co, &first_instr);
next_instr = first_instr;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
stack_pointer = f->f_valuestack;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
why = WHY_NOT;
err = 0;
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = Py_None; /* Not a reference, just anything non-NULL */
Remove the last gcc -Wall warning about possible use of an uninitialized variable. w should be initialized before entering the bytecode interpretation loop since we only need one initialization to satisfy the compiler.
2000-10-11 21:54:07 +08:00
w = NULL;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
for (;;) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* Do periodic things. Doing this every time through
the loop would add too much overhead, so we do it
only every Nth instruction. We also do it if
``things_to_do'' is set, i.e. when an asynchronous
event needs attention (e.g. a signal handler or
async I/O handler); see Py_AddPendingCall() and
Py_MakePendingCalls() above. */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (things_to_do || --tstate->ticker < 0) {
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
tstate->ticker = tstate->interp->checkinterval;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (things_to_do) {
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
if (Py_MakePendingCalls() < 0) {
why = WHY_EXCEPTION;
goto on_error;
}
}
Logic for enabling mac-specific signal handling fixed (Jack)
1997-05-20 23:57:49 +08:00
#if !defined(HAVE_SIGNAL_H) || defined(macintosh)
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* If we have true signals, the signal handler
will call Py_AddPendingCall() so we don't
have to call sigcheck(). On the Mac and
DOS, alas, we have to call it. */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyErr_CheckSignals()) {
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
why = WHY_EXCEPTION;
goto on_error;
}
Only call sigcheck() at the ticker code if we don't have true signals. This is safe now that both intrcheck() and signalmodule.c schedule a sigcheck() call via Py_AddPendingCall(). This gives another 7% speedup (never run such a test twice ;-).
1997-01-21 14:15:24 +08:00
#endif
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
#ifdef WITH_THREAD
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
if (interpreter_lock) {
/* Give another thread a chance */
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
if (PyThreadState_Swap(NULL) != tstate)
Py_FatalError("ceval: tstate mix-up");
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_release_lock(interpreter_lock);
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
/* Other threads may run now */
Thanks to Chris Herborth, the thread primitives now have proper Py* names in the source code (they already had those for the linker, through some smart macros; but the source still had the old, un-Py names).
1998-12-22 03:32:43 +08:00
PyThread_acquire_lock(interpreter_lock, 1);
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
if (PyThreadState_Swap(tstate) != NULL)
Py_FatalError("ceval: orphan tstate");
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
}
#endif
Initial revision
1990-11-19 01:27:39 +08:00
}
* Makefile adapted to changes below. * split pythonmain.c in two: most stuff goes to pythonrun.c, in the library. * new optional built-in threadmodule.c, build upon Sjoerd's thread.{c,h}. * new module from Sjoerd: mmmodule.c (dynamically loaded). * new module from Sjoerd: sv (svgen.py, svmodule.c.proto). * new files thread.{c,h} (from Sjoerd). * new xxmodule.c (example only). * myselect.h: bzero -> memset * select.c: bzero -> memset; removed global variable
1992-08-04 20:41:02 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Extract opcode and argument */
Add some debugging features if DEBUG defined (fetch the filename as a string so I can see it with dbx, and set f_lineno); call abort() when detecting an "undetected" error.
1992-09-04 04:29:45 +08:00
Rename DEBUG macro to Py_DEBUG
1996-12-31 00:17:54 +08:00
#if defined(Py_DEBUG) || defined(LLTRACE)
Add some debugging features if DEBUG defined (fetch the filename as a string so I can see it with dbx, and set f_lineno); call abort() when detecting an "undetected" error.
1992-09-04 04:29:45 +08:00
f->f_lasti = INSTR_OFFSET();
#endif
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
opcode = NEXTOP();
if (HAS_ARG(opcode))
oparg = NEXTARG();
Charles G. Waldman <cgw@fnal.gov>: Add the EXTENDED_ARG opcode to the virtual machine, allowing 32-bit arguments to opcodes instead of being forced to stick to the 16-bit limit. This is especially useful for machine-generated code, which can be too long for the SET_LINENO parameter to fit into 16 bits. This closes the implementation portion of SourceForge patch #100893.
2000-08-24 08:32:09 +08:00
dispatch_opcode:
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
#ifdef DYNAMIC_EXECUTION_PROFILE
#ifdef DXPAIRS
dxpairs[lastopcode][opcode]++;
lastopcode = opcode;
#endif
dxp[opcode]++;
#endif
Initial revision
1990-11-19 01:27:39 +08:00
User trace feature.
1992-01-12 10:29:51 +08:00
#ifdef LLTRACE
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Instruction tracing */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
User trace feature.
1992-01-12 10:29:51 +08:00
if (lltrace) {
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (HAS_ARG(opcode)) {
printf("%d: %d, %d\n",
(int) (INSTR_OFFSET() - 3),
opcode, oparg);
}
else {
printf("%d: %d\n",
(int) (INSTR_OFFSET() - 1), opcode);
}
}
#endif
"Compiling" version
1990-12-20 23:06:42 +08:00
/* Main switch on opcode */
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
switch (opcode) {
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
/* BEWARE!
It is essential that any operation that fails sets either
x to NULL, err to nonzero, or why to anything but WHY_NOT,
and that no operation that succeeds does this! */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
/* case STOP_CODE: this is an error! */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case POP_TOP:
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case ROT_TWO:
v = POP();
w = POP();
PUSH(v);
PUSH(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case ROT_THREE:
v = POP();
w = POP();
x = POP();
PUSH(v);
PUSH(x);
PUSH(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case ROT_FOUR:
u = POP();
v = POP();
w = POP();
x = POP();
PUSH(u);
PUSH(x);
PUSH(w);
PUSH(v);
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
case DUP_TOP:
v = TOP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(v);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case DUP_TOPX:
switch (oparg) {
case 1:
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
x = TOP();
Py_INCREF(x);
PUSH(x);
continue;
case 2:
x = POP();
Py_INCREF(x);
w = TOP();
Py_INCREF(w);
PUSH(x);
PUSH(w);
PUSH(x);
continue;
case 3:
x = POP();
Py_INCREF(x);
w = POP();
Py_INCREF(w);
v = TOP();
Py_INCREF(v);
PUSH(w);
PUSH(x);
PUSH(v);
PUSH(w);
PUSH(x);
continue;
case 4:
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
x = POP();
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
Py_INCREF(x);
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
w = POP();
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
Py_INCREF(w);
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
v = POP();
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
Py_INCREF(v);
u = TOP();
Py_INCREF(u);
PUSH(v);
PUSH(w);
PUSH(x);
PUSH(u);
PUSH(v);
PUSH(w);
PUSH(x);
continue;
case 5:
x = POP();
Py_INCREF(x);
w = POP();
Py_INCREF(w);
v = POP();
Py_INCREF(v);
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
u = POP();
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
Py_INCREF(u);
t = TOP();
Py_INCREF(t);
PUSH(u);
PUSH(v);
PUSH(w);
PUSH(x);
PUSH(t);
PUSH(u);
PUSH(v);
PUSH(w);
PUSH(x);
continue;
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
default:
Do a better job at staying on-screen :P (Sorry, it's late here.) I'm assuming here that the ANSI-C adjacent-string-concatenation technique is allowable, now that Python requires an ANSI C compiler.
2000-10-12 07:26:11 +08:00
Py_FatalError("invalid argument to DUP_TOPX"
" (bytecode corruption?)");
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
}
Attempt to fix bogus gcc -Wall warnings reported by Marc-Andre Lemburg, by making the DUP_TOPX code utterly straightforward. This also gets rid of all normal-case internal DUP_TOPX if/branches, and allows replacing one POP() with TOP() in each case, so is a good idea regardless.
2000-10-11 15:04:49 +08:00
break;
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case UNARY_POSITIVE:
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Positive(v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case UNARY_NEGATIVE:
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Negative(v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case UNARY_NOT:
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
err = PyObject_IsTrue(v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
if (err == 0) {
Py_INCREF(Py_True);
PUSH(Py_True);
continue;
}
else if (err > 0) {
Py_INCREF(Py_False);
PUSH(Py_False);
err = 0;
continue;
}
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case UNARY_CONVERT:
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyObject_Repr(v);
Py_DECREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case UNARY_INVERT:
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Invert(v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
changes for complex and power (**) operator
1996-01-12 09:13:16 +08:00
case BINARY_POWER:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Power(v, w, Py_None);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
changes for complex and power (**) operator
1996-01-12 09:13:16 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
changes for complex and power (**) operator
1996-01-12 09:13:16 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_MULTIPLY:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Multiply(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_DIVIDE:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Divide(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_MODULO:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Remainder(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_ADD:
w = POP();
v = POP();
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
if (PyInt_Check(v) && PyInt_Check(w)) {
/* INLINE: int + int */
register long a, b, i;
Use PyInt_AS_LONG macro instead of explicit inlining.
1998-12-05 02:51:36 +08:00
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
i = a + b;
if ((i^a) < 0 && (i^b) < 0) {
PyErr_SetString(PyExc_OverflowError,
"integer addition");
x = NULL;
}
else
x = PyInt_FromLong(i);
}
else
x = PyNumber_Add(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_SUBTRACT:
w = POP();
v = POP();
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
if (PyInt_Check(v) && PyInt_Check(w)) {
/* INLINE: int - int */
register long a, b, i;
Use PyInt_AS_LONG macro instead of explicit inlining.
1998-12-05 02:51:36 +08:00
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
i = a - b;
if ((i^a) < 0 && (i^~b) < 0) {
PyErr_SetString(PyExc_OverflowError,
"integer subtraction");
x = NULL;
}
else
x = PyInt_FromLong(i);
}
else
x = PyNumber_Subtract(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BINARY_SUBSCR:
w = POP();
v = POP();
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
if (PyList_Check(v) && PyInt_Check(w)) {
/* INLINE: list[int] */
long i = PyInt_AsLong(w);
if (i < 0)
# In case BINARY_SUBSCR, use proper PyList_GET* macros instead of inlining.
1998-07-08 23:02:37 +08:00
i += PyList_GET_SIZE(v);
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
if (i < 0 ||
# In case BINARY_SUBSCR, use proper PyList_GET* macros instead of inlining.
1998-07-08 23:02:37 +08:00
i >= PyList_GET_SIZE(v)) {
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
PyErr_SetString(PyExc_IndexError,
"list index out of range");
x = NULL;
}
else {
# In case BINARY_SUBSCR, use proper PyList_GET* macros instead of inlining.
1998-07-08 23:02:37 +08:00
x = PyList_GET_ITEM(v, i);
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
Py_INCREF(x);
}
}
else
x = PyObject_GetItem(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case BINARY_LSHIFT:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Lshift(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case BINARY_RSHIFT:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Rshift(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case BINARY_AND:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_And(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case BINARY_XOR:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Xor(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
case BINARY_OR:
w = POP();
v = POP();
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
x = PyNumber_Or(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Added shift and mask ops.
1991-10-24 22:59:31 +08:00
break;
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_POWER:
w = POP();
v = POP();
x = PyNumber_InPlacePower(v, w, Py_None);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_MULTIPLY:
w = POP();
v = POP();
x = PyNumber_InPlaceMultiply(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_DIVIDE:
w = POP();
v = POP();
x = PyNumber_InPlaceDivide(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_MODULO:
w = POP();
v = POP();
x = PyNumber_InPlaceRemainder(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_ADD:
w = POP();
v = POP();
if (PyInt_Check(v) && PyInt_Check(w)) {
/* INLINE: int + int */
register long a, b, i;
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
i = a + b;
if ((i^a) < 0 && (i^b) < 0) {
PyErr_SetString(PyExc_OverflowError,
"integer addition");
x = NULL;
}
else
x = PyInt_FromLong(i);
}
else
x = PyNumber_InPlaceAdd(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_SUBTRACT:
w = POP();
v = POP();
if (PyInt_Check(v) && PyInt_Check(w)) {
/* INLINE: int - int */
register long a, b, i;
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
i = a - b;
if ((i^a) < 0 && (i^~b) < 0) {
PyErr_SetString(PyExc_OverflowError,
"integer subtraction");
x = NULL;
}
else
x = PyInt_FromLong(i);
}
else
x = PyNumber_InPlaceSubtract(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_LSHIFT:
w = POP();
v = POP();
x = PyNumber_InPlaceLshift(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_RSHIFT:
w = POP();
v = POP();
x = PyNumber_InPlaceRshift(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_AND:
w = POP();
v = POP();
x = PyNumber_InPlaceAnd(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_XOR:
w = POP();
v = POP();
x = PyNumber_InPlaceXor(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
case INPLACE_OR:
w = POP();
v = POP();
x = PyNumber_InPlaceOr(v, w);
Py_DECREF(v);
Py_DECREF(w);
PUSH(x);
if (x != NULL) continue;
break;
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
case SLICE+0:
Initial revision
1990-11-19 01:27:39 +08:00
case SLICE+1:
case SLICE+2:
case SLICE+3:
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-SLICE) & 2)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
w = POP();
else
w = NULL;
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-SLICE) & 1)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
v = POP();
else
v = NULL;
Initial revision
1990-11-19 01:27:39 +08:00
u = POP();
"Compiling" version
1990-12-20 23:06:42 +08:00
x = apply_slice(u, v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_XDECREF(v);
Py_XDECREF(w);
Initial revision
1990-11-19 01:27:39 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
case STORE_SLICE+0:
Initial revision
1990-11-19 01:27:39 +08:00
case STORE_SLICE+1:
case STORE_SLICE+2:
case STORE_SLICE+3:
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-STORE_SLICE) & 2)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
w = POP();
else
w = NULL;
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-STORE_SLICE) & 1)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
v = POP();
else
v = NULL;
Initial revision
1990-11-19 01:27:39 +08:00
u = POP();
"Compiling" version
1990-12-20 23:06:42 +08:00
t = POP();
err = assign_slice(u, v, w, t); /* u[v:w] = t */
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(t);
Py_DECREF(u);
Py_XDECREF(v);
Py_XDECREF(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (err == 0) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
case DELETE_SLICE+0:
Initial revision
1990-11-19 01:27:39 +08:00
case DELETE_SLICE+1:
case DELETE_SLICE+2:
case DELETE_SLICE+3:
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-DELETE_SLICE) & 2)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
w = POP();
else
w = NULL;
"Compiling" version
1990-12-20 23:06:42 +08:00
if ((opcode-DELETE_SLICE) & 1)
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
v = POP();
else
v = NULL;
Initial revision
1990-11-19 01:27:39 +08:00
u = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = assign_slice(u, v, w, (PyObject *)NULL);
"Compiling" version
1990-12-20 23:06:42 +08:00
/* del u[v:w] */
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_XDECREF(v);
Py_XDECREF(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (err == 0) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case STORE_SUBSCR:
w = POP();
v = POP();
u = POP();
/* v[w] = u */
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
err = PyObject_SetItem(v, w, u);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_DECREF(v);
Py_DECREF(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (err == 0) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case DELETE_SUBSCR:
w = POP();
v = POP();
/* del v[w] */
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
err = PyObject_DelItem(v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (err == 0) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case PRINT_EXPR:
v = POP();
Implementation of PEP-0217. This closes the PEP, and patch 103170
2001-01-11 13:41:27 +08:00
w = PySys_GetObject("displayhook");
if (w == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"lost sys.displayhook");
err = -1;
Fixed bugs noted by Greg Stein * x wasn't initialized to NULL * Did not DECREF result from displayhook function
2001-01-11 19:55:37 +08:00
x = NULL;
Implementation of PEP-0217. This closes the PEP, and patch 103170
2001-01-11 13:41:27 +08:00
}
if (err == 0) {
x = Py_BuildValue("(O)", v);
if (x == NULL)
err = -1;
}
if (err == 0) {
w = PyEval_CallObject(w, x);
Fixed bugs noted by Greg Stein * x wasn't initialized to NULL * Did not DECREF result from displayhook function
2001-01-11 19:55:37 +08:00
Py_XDECREF(w);
Implementation of PEP-0217. This closes the PEP, and patch 103170
2001-01-11 13:41:27 +08:00
if (w == NULL)
err = -1;
Quickly renamed.
1997-04-30 02:18:01 +08:00
}
Py_DECREF(v);
Implementation of PEP-0217. This closes the PEP, and patch 103170
2001-01-11 13:41:27 +08:00
Py_XDECREF(x);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Implementation of PEP-0217. This closes the PEP, and patch 103170
2001-01-11 13:41:27 +08:00
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
case PRINT_ITEM_TO:
w = stream = POP();
/* fall through to PRINT_ITEM */
Initial revision
1990-11-19 01:27:39 +08:00
case PRINT_ITEM:
v = POP();
eval_code2(): Guido provides this patch for his suggested elaboration of extended print. If the file object being printed to is None, then sys.stdout is used.
2000-08-29 12:56:13 +08:00
if (stream == NULL || stream == Py_None) {
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
w = PySys_GetObject("stdout");
if (w == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"lost sys.stdout");
err = -1;
}
Last-minute fix for Jim H: don't die after del sys.stdout
1997-12-31 13:53:15 +08:00
}
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
if (w != NULL && PyFile_SoftSpace(w, 1))
Py_FlushLine and PyFile_WriteString now return error indicators instead of calling PyErr_Clear(). Add checking of those errors.
1997-05-23 06:26:18 +08:00
err = PyFile_WriteString(" ", w);
if (err == 0)
err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (err == 0 && PyString_Check(v)) {
* mpzmodule.c: removed redundant mpz_print function. * object.[ch], bltinmodule.c, fileobject.c: changed str() to call strobject() which calls an object's __str__ method if it has one. strobject() is also called by writeobject() when PRINT_RAW is passed. * ceval.c: rationalize code for PRINT_ITEM (no change in function!) * funcobject.c, codeobject.c: added compare and hash functionality. Functions with identical code objects and the same global dictionary are equal. Code objects are equal when their code, constants list and names list are identical (i.e. the filename and code name don't count). (hash doesn't work yet since the constants are in a list and lists can't be hashed -- suppose this should really be done with a tuple now we have resizetuple!)
1993-11-05 18:22:19 +08:00
/* XXX move into writeobject() ? */
Quickly renamed.
1997-04-30 02:18:01 +08:00
char *s = PyString_AsString(v);
int len = PyString_Size(v);
use Py_CHARMASK
1995-02-11 01:01:56 +08:00
if (len > 0 &&
isspace(Py_CHARMASK(s[len-1])) &&
* mpzmodule.c: removed redundant mpz_print function. * object.[ch], bltinmodule.c, fileobject.c: changed str() to call strobject() which calls an object's __str__ method if it has one. strobject() is also called by writeobject() when PRINT_RAW is passed. * ceval.c: rationalize code for PRINT_ITEM (no change in function!) * funcobject.c, codeobject.c: added compare and hash functionality. Functions with identical code objects and the same global dictionary are equal. Code objects are equal when their code, constants list and names list are identical (i.e. the filename and code name don't count). (hash doesn't work yet since the constants are in a list and lists can't be hashed -- suppose this should really be done with a tuple now we have resizetuple!)
1993-11-05 18:22:19 +08:00
s[len-1] != ' ')
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFile_SoftSpace(w, 0);
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
Py_XDECREF(stream);
stream = NULL;
if (err == 0)
continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
case PRINT_NEWLINE_TO:
w = stream = POP();
/* fall through to PRINT_NEWLINE */
Initial revision
1990-11-19 01:27:39 +08:00
case PRINT_NEWLINE:
eval_code2(): Guido provides this patch for his suggested elaboration of extended print. If the file object being printed to is None, then sys.stdout is used.
2000-08-29 12:56:13 +08:00
if (stream == NULL || stream == Py_None) {
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
w = PySys_GetObject("stdout");
if (w == NULL)
PyErr_SetString(PyExc_RuntimeError,
"lost sys.stdout");
}
if (w != NULL) {
err = PyFile_WriteString("\n", w);
Py_FlushLine and PyFile_WriteString now return error indicators instead of calling PyErr_Clear(). Add checking of those errors.
1997-05-23 06:26:18 +08:00
if (err == 0)
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
PyFile_SoftSpace(w, 0);
Modified most (but not yet all) I/O to always go through sys.stdout or sys.stderr or sys.stdin, and to work with any object as long as it has a write() (respectively readline()) methods. Some functions that took a FILE* argument now take an object* argument.
1992-09-26 05:59:05 +08:00
}
PEP 214, Extended print Statement, has been accepted by the BDFL. eval_code2(): Implement new bytecodes PRINT_ITEM_TO and PRINT_NEWLINE_TO, as per accepted SF patch #100970. Also update graminit.c based on related Grammar/Grammar changes.
2000-08-21 23:44:01 +08:00
Py_XDECREF(stream);
stream = NULL;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Support for three-token characters (**=, >>=, <<=) which was written by Michael Hudson, and support in general for the augmented assignment syntax. The graminit.c patch is large!
2000-08-25 04:11:32 +08:00
#ifdef CASE_TOO_BIG
default: switch (opcode) {
#endif
Initial revision
1990-11-19 01:27:39 +08:00
case BREAK_LOOP:
"Compiling" version
1990-12-20 23:06:42 +08:00
why = WHY_BREAK;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Use PyObject_IsInstance() to check whether the first argument to an unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
2001-03-22 03:17:22 +08:00
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
case CONTINUE_LOOP:
retval = PyInt_FromLong(oparg);
why = WHY_CONTINUE;
break;
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
case RAISE_VARARGS:
u = v = w = NULL;
switch (oparg) {
case 3:
u = POP(); /* traceback */
/* Fallthrough */
case 2:
v = POP(); /* value */
/* Fallthrough */
case 1:
w = POP(); /* exc */
Make first raise argument optional
1998-04-10 05:39:57 +08:00
case 0: /* Fallthrough */
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
why = do_raise(w, v, u);
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
break;
default:
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_SystemError,
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
"bad RAISE_VARARGS oparg");
why = WHY_EXCEPTION;
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
break;
}
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
case LOAD_LOCALS:
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if ((x = f->f_locals) == NULL) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
"no locals");
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
PUSH(x);
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case RETURN_VALUE:
"Compiling" version
1990-12-20 23:06:42 +08:00
retval = POP();
why = WHY_RETURN;
Initial revision
1990-11-19 01:27:39 +08:00
break;
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
case EXEC_STMT:
w = POP();
v = POP();
u = POP();
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
err = exec_statement(f, u, v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_DECREF(v);
Py_DECREF(w);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case POP_BLOCK:
"Compiling" version
1990-12-20 23:06:42 +08:00
{
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTryBlock *b = PyFrame_BlockPop(f);
"Compiling" version
1990-12-20 23:06:42 +08:00
while (STACK_LEVEL() > b->b_level) {
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
}
}
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case END_FINALLY:
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyInt_Check(v)) {
why = (enum why_code) PyInt_AsLong(v);
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
if (why == WHY_RETURN ||
why == CONTINUE_LOOP)
"Compiling" version
1990-12-20 23:06:42 +08:00
retval = POP();
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
else if (PyString_Check(v) || PyClass_Check(v)) {
"Compiling" version
1990-12-20 23:06:42 +08:00
w = POP();
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
u = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Restore(v, w, u);
"Compiling" version
1990-12-20 23:06:42 +08:00
why = WHY_RERAISE;
fix bogus DECREF in finally clause
1995-07-29 07:06:00 +08:00
break;
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
else if (v != Py_None) {
PyErr_SetString(PyExc_SystemError,
"Compiling" version
1990-12-20 23:06:42 +08:00
"'finally' pops bad exception");
why = WHY_EXCEPTION;
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
case BUILD_CLASS:
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
u = POP();
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
v = POP();
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
w = POP();
x = build_class(u, v, w);
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
PUSH(x);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_DECREF(v);
Py_DECREF(w);
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case STORE_NAME:
Define and use GETNAMEV macro.
1991-04-04 02:59:50 +08:00
w = GETNAMEV(oparg);
Initial revision
1990-11-19 01:27:39 +08:00
v = POP();
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if ((x = f->f_locals) == NULL) {
clearer error messages for apply() and "no locals"
2001-01-19 11:25:05 +08:00
PyErr_Format(PyExc_SystemError,
"no locals found when storing %s",
Undo recent change that banned using import to bind a global, as per discussion on python-dev. 'from mod import *' is still banned except at the module level. Fix value for special NOOPT entry in symtable. Initialze to 0 instead of None, so that later uses of PyInt_AS_LONG() are valid. (Bug reported by Donn Cave.) replace local REPR macros with PyObject_REPR in object.h
2001-02-02 04:20:45 +08:00
PyObject_REPR(w));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = PyDict_SetItem(x, w, v);
Py_DECREF(v);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case DELETE_NAME:
Changed many calls to dict stufff to dict2 variants. *** Somehow the call to printobject was changed back to fwrite?!?! ***
1991-08-16 17:56:04 +09:00
w = GETNAMEV(oparg);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if ((x = f->f_locals) == NULL) {
clearer error messages for apply() and "no locals"
2001-01-19 11:25:05 +08:00
PyErr_Format(PyExc_SystemError,
"no locals when deleting %s",
Undo recent change that banned using import to bind a global, as per discussion on python-dev. 'from mod import *' is still banned except at the module level. Fix value for special NOOPT entry in symtable. Initialze to 0 instead of None, so that later uses of PyInt_AS_LONG() are valid. (Bug reported by Donn Cave.) replace local REPR macros with PyObject_REPR in object.h
2001-02-02 04:20:45 +08:00
PyObject_REPR(w));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if ((err = PyDict_DelItem(x, w)) != 0)
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
format_exc_check_arg(PyExc_NameError,
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
NAME_ERROR_MSG ,w);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
Merge UNPACK_LIST and UNPACK_TUPLE into a single UNPACK_SEQUENCE, since they did the same anyway. I'm not sure what to do with Tools/compiler/compiler/* -- that isn't part of distutils, is it ? Should it try to be compatible with old bytecode version ?
2000-08-12 06:15:52 +08:00
case UNPACK_SEQUENCE:
Initial revision
1990-11-19 01:27:39 +08:00
v = POP();
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
if (PyTuple_Check(v)) {
if (PyTuple_Size(v) != oparg) {
PyErr_SetString(PyExc_ValueError,
"unpack tuple of wrong size");
why = WHY_EXCEPTION;
}
else {
for (; --oparg >= 0; ) {
w = PyTuple_GET_ITEM(v, oparg);
Py_INCREF(w);
PUSH(w);
}
Initial revision
1990-11-19 01:27:39 +08:00
}
}
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
else if (PyList_Check(v)) {
if (PyList_Size(v) != oparg) {
PyErr_SetString(PyExc_ValueError,
"unpack list of wrong size");
why = WHY_EXCEPTION;
}
else {
for (; --oparg >= 0; ) {
w = PyList_GET_ITEM(v, oparg);
Py_INCREF(w);
PUSH(w);
}
}
Initial revision
1990-11-19 01:27:39 +08:00
}
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
else if (PySequence_Check(v)) {
if (unpack_sequence(v, oparg,
stack_pointer + oparg))
stack_pointer += oparg;
else
why = WHY_EXCEPTION;
Initial revision
1990-11-19 01:27:39 +08:00
}
else {
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
PyErr_SetString(PyExc_TypeError,
"unpack non-sequence");
why = WHY_EXCEPTION;
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case STORE_ATTR:
* Changed all copyright messages to include 1993. * Stubs for faster implementation of local variables (not yet finished) * Added function name to code object. Print it for code and function objects. THIS MAKES THE .PYC FILE FORMAT INCOMPATIBLE (the version number has changed accordingly) * Print address of self for built-in methods * New internal functions getattro and setattro (getattr/setattr with string object arg) * Replaced "dictobject" with more powerful "mappingobject" * New per-type functio tp_hash to implement arbitrary object hashing, and hashobject() to interface to it * Added built-in functions hash(v) and hasattr(v, 'name') * classobject: made some functions static that accidentally weren't; added __hash__ special instance method to implement hash() * Added proper comparison for built-in methods and functions
1993-03-29 18:43:31 +08:00
w = GETNAMEV(oparg);
Initial revision
1990-11-19 01:27:39 +08:00
v = POP();
u = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = PyObject_SetAttr(v, w, u); /* v.w = u */
Py_DECREF(v);
Py_DECREF(u);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case DELETE_ATTR:
* Changed all copyright messages to include 1993. * Stubs for faster implementation of local variables (not yet finished) * Added function name to code object. Print it for code and function objects. THIS MAKES THE .PYC FILE FORMAT INCOMPATIBLE (the version number has changed accordingly) * Print address of self for built-in methods * New internal functions getattro and setattro (getattr/setattr with string object arg) * Replaced "dictobject" with more powerful "mappingobject" * New per-type functio tp_hash to implement arbitrary object hashing, and hashobject() to interface to it * Added built-in functions hash(v) and hasattr(v, 'name') * classobject: made some functions static that accidentally weren't; added __hash__ special instance method to implement hash() * Added proper comparison for built-in methods and functions
1993-03-29 18:43:31 +08:00
w = GETNAMEV(oparg);
Initial revision
1990-11-19 01:27:39 +08:00
v = POP();
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
err = PyObject_SetAttr(v, w, (PyObject *)NULL);
/* del v.w */
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added STORE_GLOBAL and DELETE_GLOBAL. Exceptions may now also be tuples.
1991-12-10 21:52:46 +08:00
case STORE_GLOBAL:
w = GETNAMEV(oparg);
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = PyDict_SetItem(f->f_globals, w, v);
Py_DECREF(v);
Added STORE_GLOBAL and DELETE_GLOBAL. Exceptions may now also be tuples.
1991-12-10 21:52:46 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Added STORE_GLOBAL and DELETE_GLOBAL. Exceptions may now also be tuples.
1991-12-10 21:52:46 +08:00
case DELETE_GLOBAL:
w = GETNAMEV(oparg);
Quickly renamed.
1997-04-30 02:18:01 +08:00
if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
Added STORE_GLOBAL and DELETE_GLOBAL. Exceptions may now also be tuples.
1991-12-10 21:52:46 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case LOAD_CONST:
"Compiling" version
1990-12-20 23:06:42 +08:00
x = GETCONST(oparg);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case LOAD_NAME:
Changed many calls to dict stufff to dict2 variants. *** Somehow the call to printobject was changed back to fwrite?!?! ***
1991-08-16 17:56:04 +09:00
w = GETNAMEV(oparg);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if ((x = f->f_locals) == NULL) {
clearer error messages for apply() and "no locals"
2001-01-19 11:25:05 +08:00
PyErr_Format(PyExc_SystemError,
"no locals when loading %s",
Undo recent change that banned using import to bind a global, as per discussion on python-dev. 'from mod import *' is still banned except at the module level. Fix value for special NOOPT entry in symtable. Initialze to 0 instead of None, so that later uses of PyInt_AS_LONG() are valid. (Bug reported by Donn Cave.) replace local REPR macros with PyObject_REPR in object.h
2001-02-02 04:20:45 +08:00
PyObject_REPR(w));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItem(x, w);
"Compiling" version
1990-12-20 23:06:42 +08:00
if (x == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItem(f->f_globals, w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (x == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItem(f->f_builtins, w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (x == NULL) {
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PyExc_NameError,
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
NAME_ERROR_MSG ,w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
break;
}
}
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
PUSH(x);
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
case LOAD_GLOBAL:
Changed many calls to dict stufff to dict2 variants. *** Somehow the call to printobject was changed back to fwrite?!?! ***
1991-08-16 17:56:04 +09:00
w = GETNAMEV(oparg);
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItem(f->f_globals, w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (x == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItem(f->f_builtins, w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (x == NULL) {
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PyExc_NameError,
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
GLOBAL_NAME_ERROR_MSG ,w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
break;
}
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Initial revision
1990-11-19 01:27:39 +08:00
break;
* Changed all copyright messages to include 1993. * Stubs for faster implementation of local variables (not yet finished) * Added function name to code object. Print it for code and function objects. THIS MAKES THE .PYC FILE FORMAT INCOMPATIBLE (the version number has changed accordingly) * Print address of self for built-in methods * New internal functions getattro and setattro (getattr/setattr with string object arg) * Replaced "dictobject" with more powerful "mappingobject" * New per-type functio tp_hash to implement arbitrary object hashing, and hashobject() to interface to it * Added built-in functions hash(v) and hasattr(v, 'name') * classobject: made some functions static that accidentally weren't; added __hash__ special instance method to implement hash() * Added proper comparison for built-in methods and functions
1993-03-29 18:43:31 +08:00
case LOAD_FAST:
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
x = GETLOCAL(oparg);
Changes to speed up local variables enormously, by avoiding dictionary lookup (opcode.h, ceval.[ch], compile.c, frameobject.[ch], pythonrun.c, import.c). The .pyc MAGIC number is changed again. Added get_menu_text to flmodule.
1993-03-30 21:18:41 +08:00
if (x == NULL) {
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(
PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(co->co_varnames, oparg)
);
Changes to speed up local variables enormously, by avoiding dictionary lookup (opcode.h, ceval.[ch], compile.c, frameobject.[ch], pythonrun.c, import.c). The .pyc MAGIC number is changed again. Added get_menu_text to flmodule.
1993-03-30 21:18:41 +08:00
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(x);
Changes to speed up local variables enormously, by avoiding dictionary lookup (opcode.h, ceval.[ch], compile.c, frameobject.[ch], pythonrun.c, import.c). The .pyc MAGIC number is changed again. Added get_menu_text to flmodule.
1993-03-30 21:18:41 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
* Changed all copyright messages to include 1993. * Stubs for faster implementation of local variables (not yet finished) * Added function name to code object. Print it for code and function objects. THIS MAKES THE .PYC FILE FORMAT INCOMPATIBLE (the version number has changed accordingly) * Print address of self for built-in methods * New internal functions getattro and setattro (getattr/setattr with string object arg) * Replaced "dictobject" with more powerful "mappingobject" * New per-type functio tp_hash to implement arbitrary object hashing, and hashobject() to interface to it * Added built-in functions hash(v) and hasattr(v, 'name') * classobject: made some functions static that accidentally weren't; added __hash__ special instance method to implement hash() * Added proper comparison for built-in methods and functions
1993-03-29 18:43:31 +08:00
break;
case STORE_FAST:
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
v = POP();
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
SETLOCAL(oparg, v);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Changes to speed up local variables enormously, by avoiding dictionary lookup (opcode.h, ceval.[ch], compile.c, frameobject.[ch], pythonrun.c, import.c). The .pyc MAGIC number is changed again. Added get_menu_text to flmodule.
1993-03-30 21:18:41 +08:00
case DELETE_FAST:
DELETE_FAST should issue an exception when the local variable is undefined.
1998-05-13 04:27:36 +08:00
x = GETLOCAL(oparg);
if (x == NULL) {
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(
PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(co->co_varnames, oparg)
);
DELETE_FAST should issue an exception when the local variable is undefined.
1998-05-13 04:27:36 +08:00
break;
}
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
SETLOCAL(oparg, NULL);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
case LOAD_CLOSURE:
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
x = freevars[oparg];
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
Py_INCREF(x);
PUSH(x);
break;
case LOAD_DEREF:
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
x = freevars[oparg];
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
w = PyCell_Get(x);
SF patch 103596 by Nick Mathewson: rause UnboundLocalError for uninitialized free variables
2001-02-06 01:23:16 +08:00
if (w == NULL) {
if (oparg < f->f_ncells)
v = PyTuple_GetItem(co->co_cellvars,
oparg);
else
v = PyTuple_GetItem(
co->co_freevars,
oparg - f->f_ncells);
format_exc_check_arg(
PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
v);
err = -1;
break;
}
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PUSH(w);
break;
case STORE_DEREF:
w = POP();
Remove f_closure slot of frameobject and use f_localsplus instead. This change eliminates an extra malloc/free when a frame with free variables is created. Any cell vars or free vars are stored in f_localsplus after the locals and before the stack. eval_code2() fills in the appropriate values after handling initialization of locals. To track the size the frame has an f_size member that tracks the total size of f_localsplus. It used to be implicitly f_nlocals + f_stacksize.
2001-01-30 06:51:52 +08:00
x = freevars[oparg];
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PyCell_Set(x, w);
Variety of small INC/DECREF patches that fix reported memory leaks with free variables. Thanks to Martin v. Loewis for finding two of the problems. This fixes SF buf 405583. There is also a C API change: PyFrame_New() is reverting to its pre-2.1 signature. The change introduced by nested scopes was a mistake. XXX Is this okay between beta releases? cell_clear(), the GC helper, must decref its reference to break cycles. frame_dealloc() must dealloc all cell vars and free vars in addition to locals. eval_code2() setup code must INCREF cells it copies out of the closure. The STORE_DEREF opcode implementation must DECREF the object it passes to PyCell_Set().
2001-03-13 09:58:22 +08:00
Py_DECREF(w);
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
continue;
Initial revision
1990-11-19 01:27:39 +08:00
case BUILD_TUPLE:
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyTuple_New(oparg);
"Compiling" version
1990-12-20 23:06:42 +08:00
if (x != NULL) {
for (; --oparg >= 0;) {
Initial revision
1990-11-19 01:27:39 +08:00
w = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTuple_SET_ITEM(x, oparg, w);
Initial revision
1990-11-19 01:27:39 +08:00
}
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Initial revision
1990-11-19 01:27:39 +08:00
}
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BUILD_LIST:
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyList_New(oparg);
"Compiling" version
1990-12-20 23:06:42 +08:00
if (x != NULL) {
for (; --oparg >= 0;) {
Initial revision
1990-11-19 01:27:39 +08:00
w = POP();
In BUILD_LIST, use PyList_SET_ITEM() instead of PyList_SetItem(); and get rid of redundant error check.
1998-08-04 23:27:50 +08:00
PyList_SET_ITEM(x, oparg, w);
Initial revision
1990-11-19 01:27:39 +08:00
}
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Initial revision
1990-11-19 01:27:39 +08:00
}
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case BUILD_MAP:
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_New();
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case LOAD_ATTR:
* Changed all copyright messages to include 1993. * Stubs for faster implementation of local variables (not yet finished) * Added function name to code object. Print it for code and function objects. THIS MAKES THE .PYC FILE FORMAT INCOMPATIBLE (the version number has changed accordingly) * Print address of self for built-in methods * New internal functions getattro and setattro (getattr/setattr with string object arg) * Replaced "dictobject" with more powerful "mappingobject" * New per-type functio tp_hash to implement arbitrary object hashing, and hashobject() to interface to it * Added built-in functions hash(v) and hasattr(v, 'name') * classobject: made some functions static that accidentally weren't; added __hash__ special instance method to implement hash() * Added proper comparison for built-in methods and functions
1993-03-29 18:43:31 +08:00
w = GETNAMEV(oparg);
Initial revision
1990-11-19 01:27:39 +08:00
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyObject_GetAttr(v, w);
Py_DECREF(v);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case COMPARE_OP:
w = POP();
v = POP();
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
if (PyInt_Check(v) && PyInt_Check(w)) {
/* INLINE: cmp(int, int) */
register long a, b;
register int res;
Use PyInt_AS_LONG macro instead of explicit inlining.
1998-12-05 02:51:36 +08:00
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
Huge speedup by inlining some common integer operations: int+int, int-int, int <compareop> int, and list[int]. (Unfortunately, int*int is way too much code to inline.) Also corrected a NULL that should have been a zero.
1997-07-18 07:12:42 +08:00
switch (oparg) {
case LT: res = a < b; break;
case LE: res = a <= b; break;
case EQ: res = a == b; break;
case NE: res = a != b; break;
case GT: res = a > b; break;
case GE: res = a >= b; break;
case IS: res = v == w; break;
case IS_NOT: res = v != w; break;
default: goto slow_compare;
}
x = res ? Py_True : Py_False;
Py_INCREF(x);
}
else {
slow_compare:
x = cmp_outcome(oparg, v, w);
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case IMPORT_NAME:
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
w = GETNAMEV(oparg);
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyDict_GetItemString(f->f_builtins, "__import__");
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
if (x == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_ImportError,
Used operators from abstract.h where possible (arithmetic operators, get/set/del item). This removes a pile of duplication. There's no abstract operator for 'not' but I removed the function call for it anyway -- it's a little faster in-line.
1997-05-06 23:06:49 +08:00
"__import__ not found");
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
break;
}
Replace the run-time 'future-bytecode-stream-inspection' hack to find out how 'import' was called with a compiletime mechanism: create either a tuple of the import arguments, or None (in the case of a normal import), add it to the code-block constants, and load it onto the stack before calling IMPORT_NAME.
2000-08-28 04:31:27 +08:00
u = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
w = Py_BuildValue("(OOOO)",
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
w,
f->f_globals,
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
f->f_locals == NULL ?
Py_None : f->f_locals,
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
u);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
if (w == NULL) {
x = NULL;
break;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyEval_CallObject(x, w);
Py_DECREF(w);
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
case IMPORT_STAR:
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFrame_FastToLocals(f);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if ((x = f->f_locals) == NULL) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
clearer error messages for apply() and "no locals"
2001-01-19 11:25:05 +08:00
"no locals found during 'import *'");
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
break;
}
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
err = import_all_from(x, v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFrame_LocalsToFast(f, 0);
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
Py_DECREF(v);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (err == 0) continue;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
case IMPORT_FROM:
w = GETNAMEV(oparg);
v = TOP();
x = import_from(v, w);
PUSH(x);
if (x != NULL) continue;
break;
Initial revision
1990-11-19 01:27:39 +08:00
case JUMP_FORWARD:
"Compiling" version
1990-12-20 23:06:42 +08:00
JUMPBY(oparg);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case JUMP_IF_FALSE:
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = PyObject_IsTrue(TOP());
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
if (err > 0)
err = 0;
else if (err == 0)
"Compiling" version
1990-12-20 23:06:42 +08:00
JUMPBY(oparg);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
else
break;
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case JUMP_IF_TRUE:
Quickly renamed.
1997-04-30 02:18:01 +08:00
err = PyObject_IsTrue(TOP());
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
if (err > 0) {
err = 0;
"Compiling" version
1990-12-20 23:06:42 +08:00
JUMPBY(oparg);
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
}
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
else if (err == 0)
;
else
break;
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case JUMP_ABSOLUTE:
"Compiling" version
1990-12-20 23:06:42 +08:00
JUMPTO(oparg);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case FOR_LOOP:
/* for v in s: ...
On entry: stack contains s, i.
On exit: stack contains s, i+1, s[i];
but if loop exhausted:
Free parse tree after compiling. Added support for class definitions. Reorganized main interpreter loop to fetch op and arg once at the head. Use two bytes for arguments (see ceval.c).
1990-11-19 01:33:06 +08:00
s, i are popped, and we jump */
Initial revision
1990-11-19 01:27:39 +08:00
w = POP(); /* Loop index */
v = POP(); /* Sequence object */
"Compiling" version
1990-12-20 23:06:42 +08:00
u = loop_subscript(v, w);
if (u != NULL) {
Initial revision
1990-11-19 01:27:39 +08:00
PUSH(v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyInt_FromLong(PyInt_AsLong(w)+1);
Initial revision
1990-11-19 01:27:39 +08:00
PUSH(x);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
PUSH(u);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Initial revision
1990-11-19 01:27:39 +08:00
}
else {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
Py_DECREF(w);
"Compiling" version
1990-12-20 23:06:42 +08:00
/* A NULL can mean "s exhausted"
but also an error: */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyErr_Occurred())
"Compiling" version
1990-12-20 23:06:42 +08:00
why = WHY_EXCEPTION;
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
else {
"Compiling" version
1990-12-20 23:06:42 +08:00
JUMPBY(oparg);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
}
Initial revision
1990-11-19 01:27:39 +08:00
}
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
case SETUP_LOOP:
case SETUP_EXCEPT:
"Compiling" version
1990-12-20 23:06:42 +08:00
case SETUP_FINALLY:
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
STACK_LEVEL());
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
continue;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
"Compiling" version
1990-12-20 23:06:42 +08:00
case SET_LINENO:
User trace feature.
1992-01-12 10:29:51 +08:00
#ifdef LLTRACE
if (lltrace)
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
printf("--- %s:%d \n", filename, oparg);
"Compiling" version
1990-12-20 23:06:42 +08:00
#endif
User trace feature.
1992-01-12 10:29:51 +08:00
f->f_lineno = oparg;
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (f->f_trace == NULL)
continue;
/* Trace each line of code reached */
f->f_lasti = INSTR_OFFSET();
err = call_trace(&f->f_trace, &f->f_trace,
Quickly renamed.
1997-04-30 02:18:01 +08:00
f, "line", Py_None);
Initial revision
1990-11-19 01:27:39 +08:00
break;
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
case CALL_FUNCTION:
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
{
int na = oparg & 0xff;
int nk = (oparg>>8) & 0xff;
int n = na + 2 * nk;
PyObject **pfunc = stack_pointer - n - 1;
PyObject *func = *pfunc;
f->f_lasti = INSTR_OFFSET() - 3; /* For tracing */
/* Always dispatch PyCFunction first, because
these are presumed to be the most frequent
callable object.
*/
if (PyCFunction_Check(func)) {
if (PyCFunction_GET_FLAGS(func) == 0) {
x = fast_cfunction(func,
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
&stack_pointer, na);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
} else {
x = do_call(func, &stack_pointer,
na, nk);
}
} else {
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
if (PyMethod_Check(func)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
&& PyMethod_GET_SELF(func) != NULL) {
/* optimize access to bound methods */
PyObject *self = PyMethod_GET_SELF(func);
Py_INCREF(self);
func = PyMethod_GET_FUNCTION(func);
Py_INCREF(func);
Py_DECREF(*pfunc);
*pfunc = self;
na++;
n++;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
} else
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
Py_INCREF(func);
if (PyFunction_Check(func)) {
x = fast_function(func, &stack_pointer,
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
n, na, nk);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
} else {
x = do_call(func, &stack_pointer,
na, nk);
}
Py_DECREF(func);
}
while (stack_pointer > pfunc) {
w = POP();
Py_DECREF(w);
}
PUSH(x);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
if (x != NULL)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
continue;
break;
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
case CALL_FUNCTION_VAR:
case CALL_FUNCTION_KW:
case CALL_FUNCTION_VAR_KW:
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
{
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
int na = oparg & 0xff;
int nk = (oparg>>8) & 0xff;
int flags = (opcode - CALL_FUNCTION) & 3;
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
int n = na + 2 * nk;
PyObject **pfunc, *func;
if (flags & CALL_FLAG_VAR)
n++;
if (flags & CALL_FLAG_KW)
n++;
pfunc = stack_pointer - n - 1;
func = *pfunc;
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
f->f_lasti = INSTR_OFFSET() - 3; /* For tracing */
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
if (PyMethod_Check(func)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
&& PyMethod_GET_SELF(func) != NULL) {
PyObject *self = PyMethod_GET_SELF(func);
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
Py_INCREF(self);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
func = PyMethod_GET_FUNCTION(func);
Py_INCREF(func);
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
Py_DECREF(*pfunc);
*pfunc = self;
na++;
n++;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
} else
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
Py_INCREF(func);
x = ext_do_call(func, &stack_pointer, flags, na, nk);
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
Py_DECREF(func);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
while (stack_pointer > pfunc) {
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
w = POP();
Py_DECREF(w);
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
}
PUSH(x);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
if (x != NULL)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
continue;
slightly modified version of Greg Ewing's extended call syntax patch executive summary: Instead of typing 'apply(f, args, kwargs)' you can type 'f(*arg, **kwargs)'. Some file-by-file details follow. Grammar/Grammar: simplify varargslist, replacing '*' '*' with '**' add * & ** options to arglist Include/opcode.h & Lib/dis.py: define three new opcodes CALL_FUNCTION_VAR CALL_FUNCTION_KW CALL_FUNCTION_VAR_KW Python/ceval.c: extend TypeError "keyword parameter redefined" message to include the name of the offending keyword reindent CALL_FUNCTION using four spaces add handling of sequences and dictionaries using extend calls fix function import_from to use PyErr_Format
2000-03-29 07:49:17 +08:00
break;
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
case MAKE_FUNCTION:
v = POP(); /* code object */
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = PyFunction_New(v, f->f_globals);
Py_DECREF(v);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* XXX Maybe this should be a separate opcode? */
if (x != NULL && oparg > 0) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
v = PyTuple_New(oparg);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (v == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(x);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
x = NULL;
break;
}
while (--oparg >= 0) {
w = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTuple_SET_ITEM(v, oparg, w);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
err = PyFunction_SetDefaults(x, v);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
PUSH(x);
break;
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
case MAKE_CLOSURE:
{
int nfree;
v = POP(); /* code object */
x = PyFunction_New(v, f->f_globals);
nfree = PyTuple_GET_SIZE(((PyCodeObject *)v)->co_freevars);
Py_DECREF(v);
/* XXX Maybe this should be a separate opcode? */
if (x != NULL && nfree > 0) {
v = PyTuple_New(nfree);
if (v == NULL) {
Py_DECREF(x);
x = NULL;
break;
}
while (--nfree >= 0) {
w = POP();
PyTuple_SET_ITEM(v, nfree, w);
}
err = PyFunction_SetClosure(x, v);
Py_DECREF(v);
}
if (x != NULL && oparg > 0) {
v = PyTuple_New(oparg);
if (v == NULL) {
Py_DECREF(x);
x = NULL;
break;
}
while (--oparg >= 0) {
w = POP();
PyTuple_SET_ITEM(v, oparg, w);
}
err = PyFunction_SetDefaults(x, v);
Py_DECREF(v);
}
PUSH(x);
break;
}
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
case BUILD_SLICE:
if (oparg == 3)
w = POP();
else
w = NULL;
v = POP();
u = POP();
Cleanup: - fix bug in Py_MakePendingCalls() with threading - fix return type of do_raise - remove build_slice (same as PySlice_New) - remove code inside #if 0 - remove code inside #ifdef CHECK_STACK - remove code inside #ifdef SUPPORT_OBSOLETE_ACCESS - comment about newimp.py should refer to ni.py
1997-01-21 13:34:20 +08:00
x = PySlice_New(u, v, w);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(u);
Py_DECREF(v);
Py_XDECREF(w);
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
PUSH(x);
Add "if (x != NULL) continue;" (or similar for err==0) before the break to most cases, as suggested by Tim Peters. This gives another 8-10% speedup.
1997-01-18 10:46:13 +08:00
if (x != NULL) continue;
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
break;
Charles G. Waldman <cgw@fnal.gov>: Add the EXTENDED_ARG opcode to the virtual machine, allowing 32-bit arguments to opcodes instead of being forced to stick to the 16-bit limit. This is especially useful for machine-generated code, which can be too long for the SET_LINENO parameter to fit into 16 bits. This closes the implementation portion of SourceForge patch #100893.
2000-08-24 08:32:09 +08:00
case EXTENDED_ARG:
opcode = NEXTOP();
oparg = oparg<<16 | NEXTARG();
goto dispatch_opcode;
break;
Changes for slice and ellipses
1996-07-31 00:49:37 +08:00
Initial revision
1990-11-19 01:27:39 +08:00
default:
"Compiling" version
1990-12-20 23:06:42 +08:00
fprintf(stderr,
"XXX lineno: %d, opcode: %d\n",
User trace feature.
1992-01-12 10:29:51 +08:00
f->f_lineno, opcode);
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_SystemError, "unknown opcode");
"Compiling" version
1990-12-20 23:06:42 +08:00
why = WHY_EXCEPTION;
Initial revision
1990-11-19 01:27:39 +08:00
break;
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
#ifdef CASE_TOO_BIG
}
#endif
"Compiling" version
1990-12-20 23:06:42 +08:00
} /* switch */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
on_error:
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Quickly continue if no error occurred */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why == WHY_NOT) {
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (err == 0 && x != NULL) {
#ifdef CHECKEXC
Always test for an error return (usually NULL or -1) without setting an exception.
1999-03-10 00:16:45 +08:00
/* This check is expensive! */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyErr_Occurred())
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
fprintf(stderr,
"XXX undetected error\n");
else
#endif
continue; /* Normal, fast path */
}
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
why = WHY_EXCEPTION;
Quickly renamed.
1997-04-30 02:18:01 +08:00
x = Py_None;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
err = 0;
}
/* Double-check exception status */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (!PyErr_Occurred()) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
Always test for an error return (usually NULL or -1) without setting an exception.
1999-03-10 00:16:45 +08:00
"error return without exception set");
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
why = WHY_EXCEPTION;
}
}
Always test for an error return (usually NULL or -1) without setting an exception.
1999-03-10 00:16:45 +08:00
#ifdef CHECKEXC
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
else {
Always test for an error return (usually NULL or -1) without setting an exception.
1999-03-10 00:16:45 +08:00
/* This check is expensive! */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyErr_Occurred()) {
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
fprintf(stderr,
"XXX undetected error (why=%d)\n",
why);
why = WHY_EXCEPTION;
}
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
#endif
/* Log traceback info if this is a real exception */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why == WHY_EXCEPTION) {
User trace feature.
1992-01-12 10:29:51 +08:00
f->f_lasti = INSTR_OFFSET() - 1;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (HAS_ARG(opcode))
User trace feature.
1992-01-12 10:29:51 +08:00
f->f_lasti -= 2;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTraceBack_Here(f);
User trace feature.
1992-01-12 10:29:51 +08:00
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
if (f->f_trace)
call_exc_trace(&f->f_trace, &f->f_trace, f);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->sys_profilefunc)
call_exc_trace(&tstate->sys_profilefunc,
(PyObject**)0, f);
Whoops! One the "redundant" initializations removed by Vladimir in the previous patch wasn't -- there was a path through the code that bypassed all initializations. Thanks to Just for reporting the bug!
1998-11-24 05:09:51 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why == WHY_RERAISE)
why = WHY_EXCEPTION;
/* Unwind stacks if a (pseudo) exception occurred */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
while (why != WHY_NOT && f->f_iblock > 0) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTryBlock *b = PyFrame_BlockPop(f);
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
/* For a continue inside a try block,
don't pop the block for the loop. */
Use PyObject_IsInstance() to check whether the first argument to an unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
2001-03-22 03:17:22 +08:00
PyFrame_BlockSetup(f, b->b_type, b->b_level,
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
b->b_handler);
why = WHY_NOT;
JUMPTO(PyInt_AS_LONG(retval));
Py_DECREF(retval);
break;
}
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
while (STACK_LEVEL() > b->b_level) {
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(v);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
why = WHY_NOT;
JUMPTO(b->b_handler);
break;
}
if (b->b_type == SETUP_FINALLY ||
Change the Don Beaudry hack into the Don B + Jim F hack; now, if *any* base class is special it gets invoked. Make gcc -Wall happy.
1996-12-06 07:17:11 +08:00
(b->b_type == SETUP_EXCEPT &&
why == WHY_EXCEPTION)) {
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why == WHY_EXCEPTION) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *exc, *val, *tb;
PyErr_Fetch(&exc, &val, &tb);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (val == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
val = Py_None;
Py_INCREF(val);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
/* Make the raw exception data
available to the handler,
so a program can emulate the
Python main loop. Don't do
this for 'finally'. */
if (b->b_type == SETUP_EXCEPT) {
eval_code2(), set_exc_info(): Call PyErr_NormalizeException() the former rather than the latter, since PyErr_NormalizeException takes PyObject** and I didn't want to change the interface for set_exc_info (but I did want the changes propagated to eval_code2!).
1997-08-29 06:36:40 +08:00
PyErr_NormalizeException(
&exc, &val, &tb);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
set_exc_info(tstate,
exc, val, tb);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
PUSH(tb);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
PUSH(val);
PUSH(exc);
}
else {
Allow 'continue' inside 'try' clause SF patch 102989 by Thomas Wouters
2001-02-02 06:48:12 +08:00
if (why == WHY_RETURN ||
why == CONTINUE_LOOP)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
PUSH(retval);
Quickly renamed.
1997-04-30 02:18:01 +08:00
v = PyInt_FromLong((long)why);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
PUSH(v);
}
why = WHY_NOT;
JUMPTO(b->b_handler);
break;
}
} /* unwind stack */
/* End the loop if we still have an error (or return) */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (why != WHY_NOT)
break;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
} /* main loop */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Pop remaining stack entries */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
while (!EMPTY()) {
v = POP();
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(v);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
User trace feature.
1992-01-12 10:29:51 +08:00
if (why != WHY_RETURN)
retval = NULL;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
if (f->f_trace) {
User trace feature.
1992-01-12 10:29:51 +08:00
if (why == WHY_RETURN) {
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
if (call_trace(&f->f_trace, &f->f_trace, f,
"return", retval)) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(retval);
User trace feature.
1992-01-12 10:29:51 +08:00
retval = NULL;
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
why = WHY_EXCEPTION;
User trace feature.
1992-01-12 10:29:51 +08:00
}
}
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->sys_profilefunc && why == WHY_RETURN) {
if (call_trace(&tstate->sys_profilefunc, (PyObject**)0,
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
f, "return", retval)) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(retval);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
retval = NULL;
why = WHY_EXCEPTION;
}
User trace feature.
1992-01-12 10:29:51 +08:00
}
Kill all local variables on function return. This closes a gigantic leak of memory and file descriptors (thanks for Roj for reporting that!). Alas, the speed goes down by 5%. :-(
1997-01-22 05:18:36 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
reset_exc_info(tstate);
--tstate->recursion_depth;
Change the control flow for error handling in the function prelude to jump to the "Kill locals" section at the end. Add #ifdef macintosh bandaid to make sure we call sigcheck() on the Mac.
1997-01-24 12:19:24 +08:00
fail: /* Jump here from prelude on failure */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
/* Restore previous frame and release the current one */
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
tstate->frame = f->f_back;
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(f);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
User trace feature.
1992-01-12 10:29:51 +08:00
return retval;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
static void
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
set_exc_info(PyThreadState *tstate,
PyObject *type, PyObject *value, PyObject *tb)
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
{
PyFrameObject *frame;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
PyObject *tmp_type, *tmp_value, *tmp_tb;
cmp_exception gets promoted (essentially) to the C API function PyErr_GivenExceptionMatches(). set_exc_info(): make sure to normalize exceptions. do_raise(): Use PyErr_NormalizeException() if type is a class. loop_subscript(): Use PyErr_ExceptionMatches() instead of raw pointer compare for PyExc_IndexError.
1997-08-23 05:26:19 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
frame = tstate->frame;
if (frame->f_exc_type == NULL) {
/* This frame didn't catch an exception before */
/* Save previous exception of this thread in this frame */
if (tstate->exc_type == NULL) {
Py_INCREF(Py_None);
tstate->exc_type = Py_None;
}
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
tmp_type = frame->f_exc_type;
tmp_value = frame->f_exc_value;
tmp_tb = frame->f_exc_traceback;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
Py_XINCREF(tstate->exc_type);
Py_XINCREF(tstate->exc_value);
Py_XINCREF(tstate->exc_traceback);
frame->f_exc_type = tstate->exc_type;
frame->f_exc_value = tstate->exc_value;
frame->f_exc_traceback = tstate->exc_traceback;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
}
/* Set new exception for this thread */
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
Py_XINCREF(type);
Py_XINCREF(value);
Py_XINCREF(tb);
tstate->exc_type = type;
tstate->exc_value = value;
tstate->exc_traceback = tb;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* For b/w compatibility */
PySys_SetObject("exc_type", type);
PySys_SetObject("exc_value", value);
PySys_SetObject("exc_traceback", tb);
}
static void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
reset_exc_info(PyThreadState *tstate)
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
{
PyFrameObject *frame;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
PyObject *tmp_type, *tmp_value, *tmp_tb;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
frame = tstate->frame;
if (frame->f_exc_type != NULL) {
/* This frame caught an exception */
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
Py_XINCREF(frame->f_exc_type);
Py_XINCREF(frame->f_exc_value);
Py_XINCREF(frame->f_exc_traceback);
tstate->exc_type = frame->f_exc_type;
tstate->exc_value = frame->f_exc_value;
tstate->exc_traceback = frame->f_exc_traceback;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* For b/w compatibility */
PySys_SetObject("exc_type", frame->f_exc_type);
PySys_SetObject("exc_value", frame->f_exc_value);
PySys_SetObject("exc_traceback", frame->f_exc_traceback);
}
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
tmp_type = frame->f_exc_type;
tmp_value = frame->f_exc_value;
tmp_tb = frame->f_exc_traceback;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
frame->f_exc_type = NULL;
frame->f_exc_value = NULL;
frame->f_exc_traceback = NULL;
Plug leak of stack frame object in exception handling code. Also delay DECREF calls until after the structures have been updated (for reentrancy awareness).
1997-05-21 01:06:11 +08:00
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
}
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
/* Logic for the raise statement (too complicated for inlining).
This *consumes* a reference count to each of its arguments. */
Cleanup: - fix bug in Py_MakePendingCalls() with threading - fix return type of do_raise - remove build_slice (same as PySlice_New) - remove code inside #if 0 - remove code inside #ifdef CHECK_STACK - remove code inside #ifdef SUPPORT_OBSOLETE_ACCESS - comment about newimp.py should refer to ni.py
1997-01-21 13:34:20 +08:00
static enum why_code
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
do_raise(PyObject *type, PyObject *value, PyObject *tb)
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
{
Make first raise argument optional
1998-04-10 05:39:57 +08:00
if (type == NULL) {
/* Reraise */
PyThreadState *tstate = PyThreadState_Get();
type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
value = tstate->exc_value;
tb = tstate->exc_traceback;
Py_XINCREF(type);
Py_XINCREF(value);
Py_XINCREF(tb);
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
/* We support the following forms of raise:
raise <class>, <classinstance>
raise <class>, <argument tuple>
raise <class>, None
raise <class>, <argument>
raise <classinstance>, None
raise <string>, <object>
raise <string>, None
An omitted second argument is the same as None.
In addition, raise <tuple>, <anything> is the same as
raising the tuple's first item (and it better have one!);
this rule is applied recursively.
Finally, an optional third argument can be supplied, which
gives the traceback to be substituted (useful when
re-raising an exception after examining it). */
/* First, check the traceback argument, replacing None with
NULL. */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (tb == Py_None) {
Py_DECREF(tb);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
tb = NULL;
}
else if (tb != NULL && !PyTraceBack_Check(tb)) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_TypeError,
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"raise: arg 3 must be a traceback or None");
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
goto raise_error;
}
/* Next, replace a missing value with None */
if (value == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
value = Py_None;
Py_INCREF(value);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
}
/* Next, repeatedly, replace a tuple exception with its first item */
Quickly renamed.
1997-04-30 02:18:01 +08:00
while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
PyObject *tmp = type;
type = PyTuple_GET_ITEM(type, 0);
Py_INCREF(type);
Py_DECREF(tmp);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
}
cmp_exception gets promoted (essentially) to the C API function PyErr_GivenExceptionMatches(). set_exc_info(): make sure to normalize exceptions. do_raise(): Use PyErr_NormalizeException() if type is a class. loop_subscript(): Use PyErr_ExceptionMatches() instead of raw pointer compare for PyExc_IndexError.
1997-08-23 05:26:19 +08:00
if (PyString_Check(type))
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
;
cmp_exception gets promoted (essentially) to the C API function PyErr_GivenExceptionMatches(). set_exc_info(): make sure to normalize exceptions. do_raise(): Use PyErr_NormalizeException() if type is a class. loop_subscript(): Use PyErr_ExceptionMatches() instead of raw pointer compare for PyExc_IndexError.
1997-08-23 05:26:19 +08:00
else if (PyClass_Check(type))
PyErr_NormalizeException(&type, &value, &tb);
Quickly renamed.
1997-04-30 02:18:01 +08:00
else if (PyInstance_Check(type)) {
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
/* Raising an instance. The value should be a dummy. */
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (value != Py_None) {
PyErr_SetString(PyExc_TypeError,
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
"instance exception may not have a separate value");
goto raise_error;
}
else {
/* Normalize to raise <class>, <instance> */
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(value);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
value = type;
Quickly renamed.
1997-04-30 02:18:01 +08:00
type = (PyObject*) ((PyInstanceObject*)type)->in_class;
Py_INCREF(type);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
}
}
else {
/* Not something you can raise. You get an exception
anyway, just not what you specified :-) */
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_TypeError,
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
"exceptions must be strings, classes, or instances");
goto raise_error;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Restore(type, value, tb);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
if (tb == NULL)
return WHY_EXCEPTION;
else
return WHY_RERAISE;
raise_error:
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(value);
Py_XDECREF(type);
Py_XDECREF(tb);
Moved the raise logic out of the main interpreter loop to a separate function. The raise logic has one additional feature: if you raise <class>, <value> where <value> is not an instance, it will construct an instance using <value> as argument. If <value> is None, <class> is instantiated without arguments. If <value> is a tuple, it is used as the argument list. This feature is intended to make it easier to upgrade code from using string exceptions to using class exceptions; without this feature, you'd have to change every raise statement from ``raise X'' to ``raise X()'' and from ``raise X, y'' to ``raise X(y)''. The latter is still the recommended form (because it has no ambiguities about the number of arguments), but this change makes the transition less painful.
1996-12-11 02:07:35 +08:00
return WHY_EXCEPTION;
}
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
static int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
unpack_sequence(PyObject *v, int argcnt, PyObject **sp)
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
{
int i;
PyObject *w;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
for (i = 0; i < argcnt; i++) {
if (! (w = PySequence_GetItem(v, i))) {
if (PyErr_ExceptionMatches(PyExc_IndexError))
PyErr_SetString(PyExc_ValueError,
"unpack sequence of wrong size");
goto finally;
}
*--sp = w;
}
/* we better get an IndexError now */
if (PySequence_GetItem(v, i) == NULL) {
if (PyErr_ExceptionMatches(PyExc_IndexError)) {
PyErr_Clear();
return 1;
}
/* some other exception occurred. fall through to finally */
}
else
PyErr_SetString(PyExc_ValueError,
"unpack sequence of wrong size");
/* fall through */
finally:
unpack_sequence(): In finally clause, watch out for Py_DECREF evaluating its arguments twice.
1997-08-26 06:30:51 +08:00
for (; i > 0; i--, sp++)
Py_DECREF(*sp);
eval_code2(): collapsed the implementations of UNPACK_TUPLE and UNPACK_LIST byte codes and added a third code path that allows generalized sequence unpacking. Now both syntaxes: a, b, c = seq [a, b, c] = seq can be used to unpack any sequence with the exact right number of items. unpack_sequence(): out-lined implementation of generalized sequence unpacking. tuple and list unpacking are still inlined.
1997-08-26 06:13:04 +08:00
return 0;
}
User trace feature.
1992-01-12 10:29:51 +08:00
#ifdef LLTRACE
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
static int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
prtrace(PyObject *v, char *str)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
printf("%s ", str);
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyObject_Print(v, stdout, 0) != 0)
PyErr_Clear(); /* Don't know what else to do */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
printf("\n");
Add useless 'return 1' to prtrace() to shut up VC++.
2000-05-04 08:55:17 +08:00
return 1;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
#endif
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
static void
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
call_exc_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f)
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
{
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *type, *value, *traceback, *arg;
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
int err;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Fetch(&type, &value, &traceback);
Test for NULL coming out of err_get() in call_exc_trace()
1992-04-09 22:58:08 +08:00
if (value == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
value = Py_None;
Py_INCREF(value);
Test for NULL coming out of err_get() in call_exc_trace()
1992-04-09 22:58:08 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
arg = Py_BuildValue("(OOO)", type, value, traceback);
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
if (arg == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Restore(type, value, traceback);
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
return;
}
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
err = call_trace(p_trace, p_newtrace, f, "exception", arg);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(arg);
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
if (err == 0)
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Restore(type, value, traceback);
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
else {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(type);
Py_XDECREF(value);
Py_XDECREF(traceback);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
}
}
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
/* PyObject **p_trace: in/out; may not be NULL;
may not point to NULL variable initially
PyObject **p_newtrace: in/out; may be NULL;
may point to NULL variable;
may be same variable as p_newtrace */
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
static int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
call_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f,
char *msg, PyObject *arg)
User trace feature.
1992-01-12 10:29:51 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyThreadState *tstate = f->f_tstate;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *args, *what;
PyObject *res = NULL;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (tstate->tracing) {
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
/* Don't do recursive traces */
if (p_newtrace) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(*p_newtrace);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
*p_newtrace = NULL;
}
return 0;
User trace feature.
1992-01-12 10:29:51 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
args = PyTuple_New(3);
3rd arg for raise; INCOMPLETE keyword parameter passing (currently f(kw=value) is seen as f('kw', value))
1995-07-08 06:53:21 +08:00
if (args == NULL)
Renamed a local label that was accidentally grandly renamed to 'Py_Cleanup' back to 'cleanup'.
1997-08-05 10:18:01 +08:00
goto cleanup;
Quickly renamed.
1997-04-30 02:18:01 +08:00
what = PyString_FromString(msg);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
if (what == NULL)
Renamed a local label that was accidentally grandly renamed to 'Py_Cleanup' back to 'cleanup'.
1997-08-05 10:18:01 +08:00
goto cleanup;
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(f);
PyTuple_SET_ITEM(args, 0, (PyObject *)f);
PyTuple_SET_ITEM(args, 1, what);
User trace feature.
1992-01-12 10:29:51 +08:00
if (arg == NULL)
Quickly renamed.
1997-04-30 02:18:01 +08:00
arg = Py_None;
Py_INCREF(arg);
PyTuple_SET_ITEM(args, 2, arg);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
tstate->tracing++;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFrame_FastToLocals(f);
res = PyEval_CallObject(*p_trace, args); /* May clear *p_trace! */
PyFrame_LocalsToFast(f, 1);
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
tstate->tracing--;
Renamed a local label that was accidentally grandly renamed to 'Py_Cleanup' back to 'cleanup'.
1997-08-05 10:18:01 +08:00
cleanup:
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(args);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
if (res == NULL) {
/* The trace proc raised an exception */
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyTraceBack_Here(f);
Py_XDECREF(*p_trace);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
*p_trace = NULL;
if (p_newtrace) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(*p_newtrace);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
*p_newtrace = NULL;
}
call_trace(): A fix for PR#73, if an exception occurred in the tracefunc (or profilefunc -- we're not sure which), zap the global trace and profile funcs so that we can't get into recursive loop when instantiating the resulting class based exception.
1999-09-09 00:26:33 +08:00
/* to be extra double plus sure we don't get recursive
* calls inf either tracefunc or profilefunc gets an
* exception, zap the global variables.
*/
Py_XDECREF(tstate->sys_tracefunc);
tstate->sys_tracefunc = NULL;
Py_XDECREF(tstate->sys_profilefunc);
tstate->sys_profilefunc = NULL;
(Hopefully) fix bug in reference count in call_exc_trace() plus minor rearrangements found during debugging
1992-04-05 22:18:13 +08:00
return -1;
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
}
else {
if (p_newtrace) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_XDECREF(*p_newtrace);
if (res == Py_None)
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
*p_newtrace = NULL;
else {
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(res);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
*p_newtrace = res;
}
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(res);
New trace implementation; and profile (in a similat vein).
1992-03-24 02:19:28 +08:00
return 0;
(Hopefully) fix bug in reference count in call_exc_trace() plus minor rearrangements found during debugging
1992-04-05 22:18:13 +08:00
}
User trace feature.
1992-01-12 10:29:51 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_GetBuiltins(void)
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
{
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
PyThreadState *tstate = PyThreadState_Get();
PyFrameObject *current_frame = tstate->frame;
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
if (current_frame == NULL)
The last of the mass checkins for separate (sub)interpreters. Everything should now work again. See the comments for the .h files mass checkin (e.g. pystate.h) for more detail.
1997-08-02 11:10:38 +08:00
return tstate->interp->builtins;
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
else
return current_frame->f_builtins;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_GetLocals(void)
* Fixed some subtleties with fastlocals. You can no longer access f_fastlocals in a traceback object (this is a core dump hazard if there are <nil> entries), but instead eval_code() merges the fast locals back into the locals dictionary if it looks like the local variables will be retained. Also, the merge routines save exceptions since this is sometimes needed (alas!). * Added id() to bltinmodule.c, which returns an object's address (identity). Useful to walk arbitrary data structures containing cycles. * Added compile() to bltinmodule.c and compile_string() to pythonrun.[ch]: support to exec/eval arbitrary code objects. The code that defaults globals and locals is moved from run_node in pythonrun.c (which is now identical to eval_node) to eval_code in ceval.c. [XXX For elegance a clean-up session is necessary.]
1993-03-31 01:46:03 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyFrameObject *current_frame = PyThreadState_Get()->frame;
* Fixed some subtleties with fastlocals. You can no longer access f_fastlocals in a traceback object (this is a core dump hazard if there are <nil> entries), but instead eval_code() merges the fast locals back into the locals dictionary if it looks like the local variables will be retained. Also, the merge routines save exceptions since this is sometimes needed (alas!). * Added id() to bltinmodule.c, which returns an object's address (identity). Useful to walk arbitrary data structures containing cycles. * Added compile() to bltinmodule.c and compile_string() to pythonrun.[ch]: support to exec/eval arbitrary code objects. The code that defaults globals and locals is moved from run_node in pythonrun.c (which is now identical to eval_node) to eval_code in ceval.c. [XXX For elegance a clean-up session is necessary.]
1993-03-31 01:46:03 +08:00
if (current_frame == NULL)
return NULL;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyFrame_FastToLocals(current_frame);
* Fixed some subtleties with fastlocals. You can no longer access f_fastlocals in a traceback object (this is a core dump hazard if there are <nil> entries), but instead eval_code() merges the fast locals back into the locals dictionary if it looks like the local variables will be retained. Also, the merge routines save exceptions since this is sometimes needed (alas!). * Added id() to bltinmodule.c, which returns an object's address (identity). Useful to walk arbitrary data structures containing cycles. * Added compile() to bltinmodule.c and compile_string() to pythonrun.[ch]: support to exec/eval arbitrary code objects. The code that defaults globals and locals is moved from run_node in pythonrun.c (which is now identical to eval_node) to eval_code in ceval.c. [XXX For elegance a clean-up session is necessary.]
1993-03-31 01:46:03 +08:00
return current_frame->f_locals;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_GetGlobals(void)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyFrameObject *current_frame = PyThreadState_Get()->frame;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (current_frame == NULL)
return NULL;
else
return current_frame->f_globals;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_GetFrame(void)
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyFrameObject *current_frame = PyThreadState_Get()->frame;
Quickly renamed.
1997-04-30 02:18:01 +08:00
return (PyObject *)current_frame;
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
}
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_GetRestricted(void)
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyFrameObject *current_frame = PyThreadState_Get()->frame;
__builtins__ mods (and sys_checkinterval for ceval.c)
1995-01-10 01:53:26 +08:00
return current_frame == NULL ? 0 : current_frame->f_restricted;
}
Py_FlushLine and PyFile_WriteString now return error indicators instead of calling PyErr_Clear(). Add checking of those errors.
1997-05-23 06:26:18 +08:00
int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
Py_FlushLine(void)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *f = PySys_GetObject("stdout");
Py_FlushLine and PyFile_WriteString now return error indicators instead of calling PyErr_Clear(). Add checking of those errors.
1997-05-23 06:26:18 +08:00
if (f == NULL)
return 0;
if (!PyFile_SoftSpace(f, 0))
return 0;
return PyFile_WriteString("\n", f);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
/* External interface to call any callable object.
The arg must be a tuple or NULL. */
Add interface to call a Python function (or other callable) object from C.
1991-07-28 06:32:34 +09:00
Inline PyObject_CallObject (Marc-Andre Lemburg).
1997-08-30 23:02:50 +08:00
#undef PyEval_CallObject
/* for backward compatibility: export this interface */
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_CallObject(PyObject *func, PyObject *arg)
Add interface to call a Python function (or other callable) object from C.
1991-07-28 06:32:34 +09:00
{
Quickly renamed.
1997-04-30 02:18:01 +08:00
return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
}
Inline PyObject_CallObject (Marc-Andre Lemburg).
1997-08-30 23:02:50 +08:00
#define PyEval_CallObject(func,arg) \
PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
{
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyObject *result;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (arg == NULL)
Quickly renamed.
1997-04-30 02:18:01 +08:00
arg = PyTuple_New(0);
else if (!PyTuple_Check(arg)) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_TypeError,
"argument list must be a tuple");
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
return NULL;
}
else
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(arg);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (kw != NULL && !PyDict_Check(kw)) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_TypeError,
"keyword list must be a dictionary");
Charles Waldman writes: """ Running "test_extcall" repeatedly results in memory leaks. One of these can't be fixed (at least not easily!), it happens since this code: def saboteur(**kw): kw['x'] = locals() d = {} saboteur(a=1, **d) creates a circular reference - d['x']['d']==d The others are due to some missing decrefs in ceval.c, fixed by the patch attached below. Note: I originally wrote this without the "goto", just adding the missing decref's where needed. But I think the goto is justified in keeping the executable code size of ceval as small as possible. """ [I think the circular reference is more like kw['x']['kw'] == kw. --GvR]
2000-04-22 05:17:39 +08:00
Py_DECREF(arg);
empty kw dict is ok for builtins
1995-08-04 12:14:47 +08:00
return NULL;
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
result = call_object(func, arg, kw);
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(arg);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
return result;
}
/* How often is each kind of object called? The answer depends on the
program. An instrumented call_object() was used to run the Python
regression test suite. The results were:
4200000 PyCFunctions
390000 fast_function() calls
94000 other functions
480000 all functions (sum of prev two)
150000 methods
100000 classes
Tests on other bodies of code show that PyCFunctions are still
most common, but not by such a large margin.
*/
static PyObject *
call_object(PyObject *func, PyObject *arg, PyObject *kw)
{
ternaryfunc call;
PyObject *result;
if (PyMethod_Check(func))
result = call_method(func, arg, kw);
else if (PyFunction_Check(func))
result = call_eval_code2(func, arg, kw);
else if (PyCFunction_Check(func))
result = call_cfunction(func, arg, kw);
else if (PyClass_Check(func))
result = PyInstance_New(func, arg, kw);
else if (PyInstance_Check(func))
result = call_instance(func, arg, kw);
else if ((call = func->ob_type->tp_call) != NULL)
result = (*call)(func, arg, kw);
else {
PyErr_Format(PyExc_TypeError, "object is not callable: %s",
PyString_AS_STRING(PyObject_Repr(func)));
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (result == NULL && !PyErr_Occurred())
PyErr_SetString(PyExc_SystemError,
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
"NULL result without error in call_object");
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
return result;
Add interface to call a Python function (or other callable) object from C.
1991-07-28 06:32:34 +09:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
call_cfunction(PyObject *func, PyObject *arg, PyObject *kw)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyCFunctionObject* f = (PyCFunctionObject*)func;
PyCFunction meth = PyCFunction_GET_FUNCTION(func);
PyObject *self = PyCFunction_GET_SELF(func);
int flags = PyCFunction_GET_FLAGS(func);
When a PyCFunction that takes only positional parameters is called with an empty keywords dictionary (via apply() or the extended call syntax), the keywords dict should be ignored. If the keywords dict is not empty, TypeError should be raised. (Between the restructuring of the call machinery and this patch, an empty dict in this situation would trigger a SystemError via PyErr_BadInternalCall().) Added regression tests to detect errors for this.
2001-01-05 06:33:02 +08:00
if (flags & METH_KEYWORDS) {
return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
}
When a PyCFunction that takes only positional parameters is called with an empty keywords dictionary (via apply() or the extended call syntax), the keywords dict should be ignored. If the keywords dict is not empty, TypeError should be raised. (Between the restructuring of the call machinery and this patch, an empty dict in this situation would trigger a SystemError via PyErr_BadInternalCall().) Added regression tests to detect errors for this.
2001-01-05 06:33:02 +08:00
if (kw != NULL && PyDict_Size(kw) != 0) {
PyErr_Format(PyExc_TypeError,
"%.200s() takes no keyword arguments",
f->m_ml->ml_name);
return NULL;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
When a PyCFunction that takes only positional parameters is called with an empty keywords dictionary (via apply() or the extended call syntax), the keywords dict should be ignored. If the keywords dict is not empty, TypeError should be raised. (Between the restructuring of the call machinery and this patch, an empty dict in this situation would trigger a SystemError via PyErr_BadInternalCall().) Added regression tests to detect errors for this.
2001-01-05 06:33:02 +08:00
if (flags & METH_VARARGS) {
return (*meth)(self, arg);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
if (!(flags & METH_VARARGS)) {
When a PyCFunction that takes only positional parameters is called with an empty keywords dictionary (via apply() or the extended call syntax), the keywords dict should be ignored. If the keywords dict is not empty, TypeError should be raised. (Between the restructuring of the call machinery and this patch, an empty dict in this situation would trigger a SystemError via PyErr_BadInternalCall().) Added regression tests to detect errors for this.
2001-01-05 06:33:02 +08:00
/* the really old style */
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
int size = PyTuple_GET_SIZE(arg);
if (size == 1)
arg = PyTuple_GET_ITEM(arg, 0);
else if (size == 0)
arg = NULL;
return (*meth)(self, arg);
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
/* should never get here ??? */
PyErr_BadInternalCall();
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
call_instance(PyObject *func, PyObject *arg, PyObject *kw)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
if (call == NULL) {
PyInstanceObject *inst = (PyInstanceObject*) func;
PyErr_Clear();
PyErr_Format(PyExc_AttributeError,
"%.200s instance has no __call__ method",
PyString_AsString(inst->in_class->cl_name));
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
return NULL;
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
res = call_object(call, arg, kw);
Py_DECREF(call);
return res;
}
static PyObject *
call_method(PyObject *func, PyObject *arg, PyObject *kw)
{
PyObject *self = PyMethod_GET_SELF(func);
PyObject *class = PyMethod_GET_CLASS(func);
PyObject *result;
func = PyMethod_GET_FUNCTION(func);
if (self == NULL) {
/* Unbound methods must be called with an instance of
the class (or a derived class) as first argument */
Use PyObject_IsInstance() to check whether the first argument to an unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
2001-03-22 03:17:22 +08:00
int ok;
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
if (PyTuple_Size(arg) >= 1)
self = PyTuple_GET_ITEM(arg, 0);
Use PyObject_IsInstance() to check whether the first argument to an unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
2001-03-22 03:17:22 +08:00
if (self == NULL)
ok = 0;
else {
ok = PyObject_IsInstance(self, class);
if (ok < 0)
return NULL;
}
if (!ok) {
PyObject* fn = ((PyFunctionObject*) func)->func_name;
PyErr_Format(PyExc_TypeError,
"unbound method %s%smust be "
"called with instance as first argument",
fn ? PyString_AsString(fn) : "",
fn ? "() " : "");
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_INCREF(arg);
Use PyObject_IsInstance() to check whether the first argument to an unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
2001-03-22 03:17:22 +08:00
}
else {
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
int argcount = PyTuple_Size(arg);
PyObject *newarg = PyTuple_New(argcount + 1);
int i;
if (newarg == NULL)
return NULL;
Py_INCREF(self);
PyTuple_SET_ITEM(newarg, 0, self);
for (i = 0; i < argcount; i++) {
PyObject *v = PyTuple_GET_ITEM(arg, i);
Py_XINCREF(v);
PyTuple_SET_ITEM(newarg, i+1, v);
}
arg = newarg;
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
result = call_object(func, arg, kw);
Py_DECREF(arg);
return result;
}
static PyObject *
call_eval_code2(PyObject *func, PyObject *arg, PyObject *kw)
{
PyObject *result;
PyObject *argdefs;
PyObject **d, **k;
int nk, nd;
argdefs = PyFunction_GET_DEFAULTS(func);
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (argdefs != NULL && PyTuple_Check(argdefs)) {
d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
nd = PyTuple_Size(argdefs);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
else {
d = NULL;
nd = 0;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (kw != NULL) {
int pos, i;
Quickly renamed.
1997-04-30 02:18:01 +08:00
nk = PyDict_Size(kw);
k = PyMem_NEW(PyObject *, 2*nk);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (k == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_NoMemory();
Py_DECREF(arg);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
return NULL;
}
pos = i = 0;
Quickly renamed.
1997-04-30 02:18:01 +08:00
while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
i += 2;
nk = i/2;
/* XXX This is broken if the caller deletes dict items! */
}
else {
k = NULL;
nk = 0;
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
result = eval_code2(
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
(PyCodeObject *)PyFunction_GET_CODE(func),
PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
Quickly renamed.
1997-04-30 02:18:01 +08:00
&PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
k, nk, d, nd,
PyFunction_GET_CLOSURE(func));
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Vladimir Marangozov's long-awaited malloc restructuring. For more comments, read the patches@python.org archives. For documentation read the comments in mymalloc.h and objimpl.h. (This is not exactly what Vladimir posted to the patches list; I've made a few changes, and Vladimir sent me a fix in private email for a problem that only occurs in debug mode. I'm also holding back on his change to main.c, which seems unnecessary to me.)
2000-05-04 07:44:39 +08:00
if (k != NULL)
PyMem_DEL(k);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
return result;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
/* The two fast_xxx() functions optimize calls for which no argument
tuple is necessary; the objects are passed directly from the stack.
fast_cfunction() is called for METH_OLDARGS functions.
fast_function() is for functions with no special argument handling.
*/
static PyObject *
fast_cfunction(PyObject *func, PyObject ***pp_stack, int na)
{
PyCFunction meth = PyCFunction_GET_FUNCTION(func);
PyObject *self = PyCFunction_GET_SELF(func);
if (na == 0)
return (*meth)(self, NULL);
Add missing Py_DECREF in fast_cfunction. Partial fix for SF bug #127699.
2001-01-11 06:11:59 +08:00
else if (na == 1) {
PyObject *arg = EXT_POP(*pp_stack);
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PyObject *result = (*meth)(self, arg);
Add missing Py_DECREF in fast_cfunction. Partial fix for SF bug #127699.
2001-01-11 06:11:59 +08:00
Py_DECREF(arg);
return result;
} else {
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyObject *args = load_args(pp_stack, na);
PyObject *result = (*meth)(self, args);
Py_DECREF(args);
return result;
}
}
static PyObject *
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
{
PyObject *co = PyFunction_GET_CODE(func);
PyObject *globals = PyFunction_GET_GLOBALS(func);
PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
PyObject *closure = PyFunction_GET_CLOSURE(func);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
PyObject **d = NULL;
int nd = 0;
if (argdefs != NULL) {
d = &PyTuple_GET_ITEM(argdefs, 0);
nd = ((PyTupleObject *)argdefs)->ob_size;
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
return eval_code2((PyCodeObject *)co, globals,
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
(PyObject *)NULL, (*pp_stack)-n, na,
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-26 04:06:59 +08:00
(*pp_stack)-2*nk, nk, d, nd,
closure);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
}
static PyObject *
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
PyObject *func)
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
{
PyObject *kwdict = NULL;
if (orig_kwdict == NULL)
kwdict = PyDict_New();
else {
kwdict = PyDict_Copy(orig_kwdict);
Py_DECREF(orig_kwdict);
}
if (kwdict == NULL)
return NULL;
while (--nk >= 0) {
int err;
PyObject *value = EXT_POP(*pp_stack);
PyObject *key = EXT_POP(*pp_stack);
if (PyDict_GetItem(kwdict, key) != NULL) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
PyObject* fn = ((PyFunctionObject*) func)->func_name;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
PyErr_Format(PyExc_TypeError,
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
"%.200s%s got multiple values "
"for keyword argument '%.400s'",
fn ? PyString_AsString(fn) : "function",
fn ? "()" : "", PyString_AsString(key));
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
Py_DECREF(key);
Py_DECREF(value);
Py_DECREF(kwdict);
return NULL;
}
err = PyDict_SetItem(kwdict, key, value);
Py_DECREF(key);
Py_DECREF(value);
if (err) {
Py_DECREF(kwdict);
return NULL;
}
}
return kwdict;
}
static PyObject *
update_star_args(int nstack, int nstar, PyObject *stararg,
PyObject ***pp_stack)
{
PyObject *callargs, *w;
callargs = PyTuple_New(nstack + nstar);
if (callargs == NULL) {
return NULL;
}
if (nstar) {
int i;
for (i = 0; i < nstar; i++) {
PyObject *a = PyTuple_GET_ITEM(stararg, i);
Py_INCREF(a);
PyTuple_SET_ITEM(callargs, nstack + i, a);
}
}
while (--nstack >= 0) {
w = EXT_POP(*pp_stack);
PyTuple_SET_ITEM(callargs, nstack, w);
}
return callargs;
}
static PyObject *
load_args(PyObject ***pp_stack, int na)
{
PyObject *args = PyTuple_New(na);
PyObject *w;
if (args == NULL)
return NULL;
while (--na >= 0) {
w = EXT_POP(*pp_stack);
PyTuple_SET_ITEM(args, na, w);
}
return args;
}
static PyObject *
do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
{
PyObject *callargs = NULL;
PyObject *kwdict = NULL;
PyObject *result = NULL;
if (nk > 0) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
kwdict = update_keyword_args(NULL, nk, pp_stack, func);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
if (kwdict == NULL)
goto call_fail;
}
callargs = load_args(pp_stack, na);
if (callargs == NULL)
goto call_fail;
result = call_object(func, callargs, kwdict);
call_fail:
Py_XDECREF(callargs);
Py_XDECREF(kwdict);
return result;
}
static PyObject *
ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
{
int nstar = 0;
PyObject *callargs = NULL;
PyObject *stararg = NULL;
PyObject *kwdict = NULL;
PyObject *result = NULL;
if (flags & CALL_FLAG_KW) {
kwdict = EXT_POP(*pp_stack);
if (!(kwdict && PyDict_Check(kwdict))) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
PyObject* fn = ((PyFunctionObject*) func)->func_name;
PyErr_Format(PyExc_TypeError,
"%s%s argument after ** must be a dictionary",
fn ? PyString_AsString(fn) : "function",
fn ? "()" : "");
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
goto ext_call_fail;
}
}
if (flags & CALL_FLAG_VAR) {
stararg = EXT_POP(*pp_stack);
if (!PyTuple_Check(stararg)) {
PyObject *t = NULL;
t = PySequence_Tuple(stararg);
if (t == NULL) {
if (PyErr_ExceptionMatches(PyExc_TypeError)) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
PyObject* fn =
((PyFunctionObject*) func)->func_name;
PyErr_Format(PyExc_TypeError,
"%s%s argument after * must be a sequence",
fn ? PyString_AsString(fn) : "function",
fn ? "()" : "");
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
}
goto ext_call_fail;
}
Py_DECREF(stararg);
stararg = t;
}
nstar = PyTuple_GET_SIZE(stararg);
}
if (nk > 0) {
This patch makes sure that the function name always appears in the error message, and tries to make the messages more consistent and helpful when the wrong number of arguments or duplicate keyword arguments are supplied. Comes with more tests for test_extcall.py and and an update to an error message in test/output/test_pyexpat.
2001-01-16 06:14:16 +08:00
kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
Revised implementation of CALL_FUNCTION and friends. More revision still needed. Much of the code that was in the mainloop was moved to a series of helper functions. PyEval_CallObjectWithKeywords was split into two parts. The first part now only does argument handling. The second part is now named call_object and delegates the call to a call_(function,method,etc.) helper. XXX The call_XXX helper functions should be replaced with tp_call functions for the respective types. The CALL_FUNCTION implementation contains three kinds of optimization: 1. fast_cfunction and fast_function are called when the arguments on the stack can be passed directly to eval_code2() without copying them into a tuple. 2. PyCFunction objects are dispatched immediately, because they are presumed to occur more often than anything else. 3. Bound methods are dispatched inline. The method object contains a pointer to the function object that will be called. The function is called from within the mainloop, which may allow optimization #1 to be used, too. The extened call implementation -- f(*args) and f(**kw) -- are implemented as a separate case in the mainloop. This allows the common case of normal function calls to execute without wasting time on checks for extended calls, although it does introduce a small amount of code duplication. Also, the unused final argument of eval_code2() was removed. This is probably the last trace of the access statement :-).
2001-01-04 07:52:36 +08:00
if (kwdict == NULL)
goto ext_call_fail;
}
callargs = update_star_args(na, nstar, stararg, pp_stack);
if (callargs == NULL)
goto ext_call_fail;
result = call_object(func, callargs, kwdict);
ext_call_fail:
Py_XDECREF(callargs);
Py_XDECREF(kwdict);
Py_XDECREF(stararg);
return result;
}
Better error message if stride used on normal sequence object
1996-07-31 02:40:29 +08:00
#define SLICE_ERROR_MSG \
"standard sequence type does not support step size other than one"
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
loop_subscript(PyObject *v, PyObject *w)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Quickly renamed.
1997-04-30 02:18:01 +08:00
PySequenceMethods *sq = v->ob_type->tp_as_sequence;
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
int i;
Moved cmp_member() to abstract.c, as PySequence_Contains() [with swapped arguments]. Also make sure that no use of a function pointer gotten from a tp_as_sequence or tp_as_mapping structure is made without checking it for NULL first.
1998-05-22 08:52:29 +08:00
if (sq == NULL || sq->sq_item == NULL) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_TypeError, "loop over non-sequence");
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
i = PyInt_AsLong(w);
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
v = (*sq->sq_item)(v, i);
if (v)
return v;
cmp_exception gets promoted (essentially) to the C API function PyErr_GivenExceptionMatches(). set_exc_info(): make sure to normalize exceptions. do_raise(): Use PyErr_NormalizeException() if type is a class. loop_subscript(): Use PyErr_ExceptionMatches() instead of raw pointer compare for PyExc_IndexError.
1997-08-23 05:26:19 +08:00
if (PyErr_ExceptionMatches(PyExc_IndexError))
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_Clear();
call_object: print message before abort()
1994-08-30 16:01:59 +08:00
return NULL;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
/* Extract a slice index from a PyInt or PyLong, the index is bound to
the range [-INT_MAX+1, INTMAX]. Returns 0 and an exception if there is
and error. Returns 1 on success.*/
int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
_PyEval_SliceIndex(PyObject *v, int *pi)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
if (v != NULL) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
long x;
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
if (PyInt_Check(v)) {
x = PyInt_AsLong(v);
} else if (PyLong_Check(v)) {
x = PyLong_AsLong(v);
if (x==-1 && PyErr_Occurred()) {
PyObject *long_zero;
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
int cmp;
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
if (!PyErr_ExceptionMatches(
PyExc_OverflowError)) {
/* It's not an overflow error, so just
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
signal an error */
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
return 0;
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
/* Clear the OverflowError */
PyErr_Clear();
/* It's an overflow error, so we need to
check the sign of the long integer,
set the value to INT_MAX or 0, and clear
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
the error. */
/* Create a long integer with a value of 0 */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
long_zero = PyLong_FromLong(0L);
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
if (long_zero == NULL) return 0;
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
/* Check sign */
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
cmp = PyObject_RichCompareBool(v, long_zero,
Py_GT);
Py_DECREF(long_zero);
if (cmp < 0)
return 0;
else if (cmp > 0)
Allow using long integers as slice indexes
2000-02-24 06:18:48 +08:00
x = INT_MAX;
else
x = 0;
}
} else {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_TypeError,
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"slice indices must be integers");
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
return 0;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
/* Truncate -- very long indices are truncated anyway */
if (x > INT_MAX)
x = INT_MAX;
else if (x < -INT_MAX)
x = 0;
*pi = x;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
return 1;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
int ilow = 0, ihigh = INT_MAX;
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
if (!_PyEval_SliceIndex(v, &ilow))
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return NULL;
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
if (!_PyEval_SliceIndex(w, &ihigh))
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
return NULL;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
return PySequence_GetSlice(u, ilow, ihigh);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
static int
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
/* u[v:w] = x */
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
int ilow = 0, ihigh = INT_MAX;
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
if (!_PyEval_SliceIndex(v, &ilow))
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
return -1;
Trent Mick: Change static slice_index() to extern _PyEval_SliceIndex() (with different return value interpretation: 0 for failure, 1 for success).
2000-05-08 22:06:50 +08:00
if (!_PyEval_SliceIndex(w, &ihigh))
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return -1;
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
if (x == NULL)
return PySequence_DelSlice(u, ilow, ihigh);
else
return PySequence_SetSlice(u, ilow, ihigh, x);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
cmp_outcome(int op, register PyObject *v, register PyObject *w)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
int res = 0;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
switch (op) {
case IS:
case IS_NOT:
res = (v == w);
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
if (op == (int) IS_NOT)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
res = !res;
break;
case IN:
case NOT_IN:
Moved cmp_member() to abstract.c, as PySequence_Contains() [with swapped arguments]. Also make sure that no use of a function pointer gotten from a tp_as_sequence or tp_as_mapping structure is made without checking it for NULL first.
1998-05-22 08:52:29 +08:00
res = PySequence_Contains(w, v);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
if (res < 0)
return NULL;
Changes so that user-defined classes can implement operations invoked by special syntax: you can now define your own numbers, sequences and mappings.
1992-08-12 23:35:34 +08:00
if (op == (int) NOT_IN)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
res = !res;
break;
case EXC_MATCH:
cmp_exception gets promoted (essentially) to the C API function PyErr_GivenExceptionMatches(). set_exc_info(): make sure to normalize exceptions. do_raise(): Use PyErr_NormalizeException() if type is a class. loop_subscript(): Use PyErr_ExceptionMatches() instead of raw pointer compare for PyExc_IndexError.
1997-08-23 05:26:19 +08:00
res = PyErr_GivenExceptionMatches(v, w);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
break;
default:
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
return PyObject_RichCompare(v, w, op);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
v = res ? Py_True : Py_False;
Py_INCREF(v);
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
return v;
}
"Compiling" version
1990-12-20 23:06:42 +08:00
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
static PyObject *
import_from(PyObject *v, PyObject *name)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
PyObject *x;
x = PyObject_GetAttr(v, name);
if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
PyErr_Format(PyExc_ImportError,
"cannot import name %.230s",
PyString_AsString(name));
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
}
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
return x;
}
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
static int
import_all_from(PyObject *locals, PyObject *v)
{
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
PyObject *all = PyObject_GetAttrString(v, "__all__");
PyObject *dict, *name, *value;
int skip_leading_underscores = 0;
int pos, err;
if (all == NULL) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
return -1; /* Unexpected error */
PyErr_Clear();
dict = PyObject_GetAttrString(v, "__dict__");
if (dict == NULL) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
return -1;
PyErr_SetString(PyExc_ImportError,
"from-import-* object has no __dict__ and no __all__");
return -1;
}
all = PyMapping_Keys(dict);
Py_DECREF(dict);
if (all == NULL)
return -1;
skip_leading_underscores = 1;
Lots of changes, most minor (fatal() instead of abort(), use of err_fetch/err_restore and so on). But... NOTE: import.c has been rewritten and all the DL stuff is now in the new file importdl.c.
1995-01-03 03:04:15 +08:00
}
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
for (pos = 0, err = 0; ; pos++) {
name = PySequence_GetItem(all, pos);
if (name == NULL) {
if (!PyErr_ExceptionMatches(PyExc_IndexError))
err = -1;
else
PyErr_Clear();
break;
}
if (skip_leading_underscores &&
PyString_Check(name) &&
PyString_AS_STRING(name)[0] == '_')
{
Py_DECREF(name);
continue;
}
value = PyObject_GetAttr(v, name);
if (value == NULL)
err = -1;
else
err = PyDict_SetItem(locals, name, value);
Py_DECREF(name);
Py_XDECREF(value);
Apply SF patch #101135, adding 'import module as m' and 'from module import name as n'. By doing some twists and turns, "as" is not a reserved word. There is a slight change in semantics for 'from module import name' (it will now honour the 'global' keyword) but only in cases that are explicitly undocumented.
2000-08-18 06:55:00 +08:00
if (err != 0)
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
break;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Two changes to from...import: 1) "from M import X" now works even if M is not a real module; it's basically a getattr() operation with AttributeError exceptions changed into ImportError. 2) "from M import *" now looks for M.__all__ to decide which names to import; if M.__all__ doesn't exist, it uses M.__dict__.keys() but filters out names starting with '_' as before. Whether or not __all__ exists, there's no restriction on the type of M.
2001-01-13 00:24:03 +08:00
Py_DECREF(all);
return err;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
"Compiling" version
1990-12-20 23:06:42 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
static PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
build_class(PyObject *methods, PyObject *bases, PyObject *name)
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
{
Reverse the search order for the Don Beaudry hook so that the first class wins. Makes more sense.
1997-08-23 00:56:16 +08:00
int i, n;
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (!PyTuple_Check(bases)) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
"build_class with non-tuple bases");
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (!PyDict_Check(methods)) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
"build_class with non-dictionary");
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
return NULL;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (!PyString_Check(name)) {
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyErr_SetString(PyExc_SystemError,
Thomas Heller fixes a typo in an error message.
2000-03-31 21:52:29 +08:00
"build_class with non-string name");
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
return NULL;
}
Reverse the search order for the Don Beaudry hook so that the first class wins. Makes more sense.
1997-08-23 00:56:16 +08:00
n = PyTuple_Size(bases);
for (i = 0; i < n; i++) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *base = PyTuple_GET_ITEM(bases, i);
if (!PyClass_Check(base)) {
Change the Don Beaudry hack into the Don B + Jim F hack; now, if *any* base class is special it gets invoked. Make gcc -Wall happy.
1996-12-06 07:17:11 +08:00
/* Call the base's *type*, if it is callable.
This code is a hook for Donald Beaudry's
and Jim Fulton's type extensions. In
Spelling fixes supplied by Rob W. W. Hooft. All these are fixes in either comments, docstrings or error messages. I fixed two minor things in test_winreg.py ("didn't" -> "Didn't" and "Didnt" -> "Didn't"). There is a minor style issue involved: Guido seems to have preferred English grammar (behaviour, honour) in a couple places. This patch changes that to American, which is the more prominent style in the source. I prefer English myself, so if English is preferred, I'd be happy to supply a patch myself ;)
2000-07-16 20:04:32 +08:00
unextended Python it will never be triggered
Extend the "Don Beaudry hack" with "Guido's corollary" -- if the base class has a __class__ attribute, call that to create the new class. This allows us to write metaclasses purely in C!
1997-07-31 11:54:02 +08:00
since its types are not callable.
Ditto: call the bases's *class*, if it has
one. This makes the same thing possible
without writing C code. A true meta-object
protocol! */
PyObject *basetype = (PyObject *)base->ob_type;
PyObject *callable = NULL;
if (PyCallable_Check(basetype))
callable = basetype;
else
callable = PyObject_GetAttrString(
base, "__class__");
if (callable) {
PyObject *args;
PyObject *newclass = NULL;
args = Py_BuildValue(
"(OOO)", name, bases, methods);
if (args != NULL) {
newclass = PyEval_CallObject(
callable, args);
Py_DECREF(args);
}
Make new gcc -Wall happy
1998-04-11 06:27:42 +08:00
if (callable != basetype) {
Extend the "Don Beaudry hack" with "Guido's corollary" -- if the base class has a __class__ attribute, call that to create the new class. This allows us to write metaclasses purely in C!
1997-07-31 11:54:02 +08:00
Py_DECREF(callable);
Make new gcc -Wall happy
1998-04-11 06:27:42 +08:00
}
Extend the "Don Beaudry hack" with "Guido's corollary" -- if the base class has a __class__ attribute, call that to create the new class. This allows us to write metaclasses purely in C!
1997-07-31 11:54:02 +08:00
return newclass;
Change the Don Beaudry hack into the Don B + Jim F hack; now, if *any* base class is special it gets invoked. Make gcc -Wall happy.
1996-12-06 07:17:11 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_TypeError,
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
"base is not a class object");
return NULL;
Moved support functions after main function; added prototypes; Fixed 'needspace' hack to use a flag in the stdout file object; added local and global variable lookup cases.
1991-04-04 18:40:29 +08:00
}
Initial revision
1990-11-19 01:27:39 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
return PyClass_New(bases, methods, name);
Several changes in one: (1) dictionaries/mappings now have attributes values() and items() as well as keys(); at the C level, use the new function mappinggetnext() to iterate over a dictionary. (2) "class C(): ..." is now illegal; you must write "class C: ...". (3) Class objects now know their own name (finally!); and minor improvements to the way how classes, functions and methods are represented as strings. (4) Added an "access" statement and semantics. (This is still experimental -- as long as you don't use the keyword 'access' nothing should be changed.)
1993-05-19 22:50:45 +08:00
}
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
static int
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
PyObject *locals)
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
{
int n;
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyObject *v;
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
int plain = 0;
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
((n = PyTuple_Size(prog)) == 2 || n == 3)) {
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
/* Backward compatibility hack */
Quickly renamed.
1997-04-30 02:18:01 +08:00
globals = PyTuple_GetItem(prog, 1);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
if (n == 3)
Quickly renamed.
1997-04-30 02:18:01 +08:00
locals = PyTuple_GetItem(prog, 2);
prog = PyTuple_GetItem(prog, 0);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (globals == Py_None) {
globals = PyEval_GetGlobals();
if (locals == Py_None) {
locals = PyEval_GetLocals();
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
plain = 1;
}
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
else if (locals == Py_None)
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
locals = globals;
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (!PyString_Check(prog) &&
This patch adds a new Python C API called PyString_AsStringAndSize() which implements the automatic conversion from Unicode to a string object using the default encoding. The new API is then put to use to have eval() and exec accept Unicode objects as code parameter. This closes bugs #110924 and #113890. As side-effect, the traditional C APIs PyString_Size() and PyString_AsString() will also accept Unicode objects as parameters.
2000-09-20 05:04:18 +08:00
!PyUnicode_Check(prog) &&
Quickly renamed.
1997-04-30 02:18:01 +08:00
!PyCode_Check(prog) &&
!PyFile_Check(prog)) {
PyErr_SetString(PyExc_TypeError,
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
"exec: arg 1 must be a string, file, or code object");
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
return -1;
}
if (!PyDict_Check(globals)) {
PyErr_SetString(PyExc_TypeError,
"exec: arg 2 must be a dictionary or None");
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
return -1;
}
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
if (!PyDict_Check(locals)) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
PyErr_SetString(PyExc_TypeError,
Ka-Ping Yee <ping@lfw.org>: Changes to error messages to increase consistency & clarity. This (mostly) closes SourceForge patch #101839.
2000-10-25 03:57:45 +08:00
"exec: arg 3 must be a dictionary or None");
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
return -1;
}
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyDict_GetItemString(globals, "__builtins__") == NULL)
Massive changes for separate thread state management. All per-thread globals are moved into a struct which is manipulated separately.
1997-05-06 04:56:21 +08:00
PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
Quickly renamed.
1997-04-30 02:18:01 +08:00
if (PyCode_Check(prog)) {
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
}
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
else if (PyFile_Check(prog)) {
Quickly renamed.
1997-04-30 02:18:01 +08:00
FILE *fp = PyFile_AsFile(prog);
char *name = PyString_AsString(PyFile_Name(prog));
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
v = PyRun_File(fp, name, Py_file_input, globals, locals);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
}
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
else {
This patch adds a new Python C API called PyString_AsStringAndSize() which implements the automatic conversion from Unicode to a string object using the default encoding. The new API is then put to use to have eval() and exec accept Unicode objects as code parameter. This closes bugs #110924 and #113890. As side-effect, the traditional C APIs PyString_Size() and PyString_AsString() will also accept Unicode objects as parameters.
2000-09-20 05:04:18 +08:00
char *str;
if (PyString_AsStringAndSize(prog, &str, NULL))
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
return -1;
This patch adds a new Python C API called PyString_AsStringAndSize() which implements the automatic conversion from Unicode to a string object using the default encoding. The new API is then put to use to have eval() and exec accept Unicode objects as code parameter. This closes bugs #110924 and #113890. As side-effect, the traditional C APIs PyString_Size() and PyString_AsString() will also accept Unicode objects as parameters.
2000-09-20 05:04:18 +08:00
v = PyRun_String(str, Py_file_input, globals, locals);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
}
Fix a bug in exec_statement() noted incidentally by Tim Peters in PR#175 -- when exec is passed a code object, it didn't sync the locals from the dictionary back into their fast representation. Also took the time to remove some repetitive code there and to do the syncing even when an exception is raised (since a partial effect should still be synced).
2000-01-13 06:45:54 +08:00
if (plain)
PyFrame_LocalsToFast(f, 0);
keyword arguments and faster calls
1995-07-18 22:51:37 +08:00
if (v == NULL)
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
return -1;
Quickly renamed.
1997-04-30 02:18:01 +08:00
Py_DECREF(v);
* bltinmodule.c: removed exec() built-in function. * Grammar: add exec statement; allow testlist in expr statement. * ceval.c, compile.c, opcode.h: support exec statement; avoid optimizing locals when it is used * fileobject.{c,h}: add getfilename() internal function.
1993-10-19 01:06:59 +08:00
return 0;
}
call __import__() with 4 args instead of 1
1995-02-14 17:42:43 +08:00
Rich comparisons fall-out: - Use PyObject_RichCompare*() where possible: when comparing keyword arguments, in _PyEval_SliceIndex(), and of course in cmp_outcome(). Unrelated stuff: - Removed all trailing whitespace. - Folded some long lines.
2001-01-17 23:42:30 +08:00
static void
Better error message with UnboundLocalError
2000-08-31 04:25:01 +08:00
format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
{
char *obj_str;
if (!obj)
return;
obj_str = PyString_AsString(obj);
if (!obj_str)
return;
PyErr_Format(exc, format_str, obj_str);
}
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
#ifdef DYNAMIC_EXECUTION_PROFILE
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
getarray(long a[256])
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
{
int i;
PyObject *l = PyList_New(256);
if (l == NULL) return NULL;
for (i = 0; i < 256; i++) {
PyObject *x = PyInt_FromLong(a[i]);
if (x == NULL) {
Py_DECREF(l);
return NULL;
}
PyList_SetItem(l, i, x);
}
for (i = 0; i < 256; i++)
a[i] = 0;
return l;
}
PyObject *
Mass ANSIfication of function definitions. Doesn't cover all 'extern' declarations yet, those come later.
2000-07-23 02:47:25 +08:00
_Py_GetDXProfile(PyObject *self, PyObject *args)
Patches for (two forms of) optional dynamic execution profiling -- i.e., counting opcode frequencies, or (with DXPAIRS defined) opcode pair frequencies. Define DYNAMIC_EXECUTION_PROFILE on the command line (for this file and for sysmodule.c) to enable.
1997-01-24 21:49:28 +08:00
{
#ifndef DXPAIRS
return getarray(dxp);
#else
int i;
PyObject *l = PyList_New(257);
if (l == NULL) return NULL;
for (i = 0; i < 257; i++) {
PyObject *x = getarray(dxpairs[i]);
if (x == NULL) {
Py_DECREF(l);
return NULL;
}
PyList_SetItem(l, i, x);
}
return l;
#endif
}
#endif
Reference in New Issue Copy Permalink