summaryrefslogtreecommitdiffstats
path: root/Python/ceval.c
Commit message (Collapse)AuthorAgeFilesLines
* Part way to allowing "from __future__ import generators" to communicateTim Peters2001-07-161-13/+24
| | | | | | | | | | that info to code dynamically compiled *by* code compiled with generators enabled. Doesn't yet work because there's still no way to tell the parser that "yield" is OK (unlike nested_scopes, the parser has its fingers in this too). Replaced PyEval_GetNestedScopes by a more-general PyEval_MergeCompilerFlags. Perhaps I should not have? I doubted it was *intended* to be part of the public API, so just did.
* GC for generator objects.Neil Schemenauer2001-07-121-4/+12
|
* This change adjusts the profiling/tracing support so that the commonFred Drake2001-07-031-47/+65
| | | | | | | | | | | | | | | | path (with no profile/trace function) through eval_code2() and eval_frame() avoids several checks. In the common cases of calls, returns, and exception propogation, eval_code2() and eval_frame() used to test two values in the thread-state: the profiling function and the tracing function. With this change, a flag is set in the thread-state if either of these is active, allowing a single check to suffice when both are NULL. This also simplifies the code needed when either function is in use but is already active (to avoid profiling/tracing the profiler/tracer); the flag is set to 0 when the profile/trace code is entered, allowing the same check to suffice for "already in the tracer" for call/return/ exception events.
* Revise the interface to the profiling and tracing support for theFred Drake2001-06-271-134/+65
| | | | | | | | | | | | | | | | | | Python interpreter. This change adds two new C-level APIs: PyEval_SetProfile() and PyEval_SetTrace(). These can be used to install profile and trace functions implemented in C, which can operate at much higher speeds than Python-based functions. The overhead for calling a C-based profile function is a very small fraction of a percent of the overhead involved in calling a Python-based function. The machinery required to call a Python-based profile or trace function been moved to sysmodule.c, where sys.setprofile() and sys.setprofile() simply become users of the new interface. As a side effect, SF bug #436058 is fixed; there is no longer a _PyTrace_Init() function to declare.
* gen_getattr: make the gi_running and gi_frame members discoverable (butTim Peters2001-06-261-4/+17
| | | | not writable -- too dangerous!) from Python code.
* Add "gi_" (generator-iterator) prefix to names of genobject members.Tim Peters2001-06-261-9/+13
| | | | | Makes it much easier to find references via dumb editor search (former "frame" in particular was near-hopeless).
* Change the semantics of "return" in generators, as discussed on theTim Peters2001-06-231-0/+7
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Iterators list and Python-Dev; e.g., these all pass now: def g1(): try: return except: yield 1 assert list(g1()) == [] def g2(): try: return finally: yield 1 assert list(g2()) == [1] def g3(): for i in range(3): yield None yield None assert list(g3()) == [None] * 4 compile.c: compile_funcdef and com_return_stmt: Just van Rossum's patch to compile the same code for "return" regardless of function type (this goes back to the previous scheme of returning Py_None). ceval.c: gen_iternext: take a return (but not a yield) of Py_None as meaning the generator is exhausted.
* gen_iternext(): Don't assume that the current thread state's frame isTim Peters2001-06-231-2/+2
| | | | | not NULL. I don't think it can be NULL from Python code, but if using generators via the C API I expect a NULL frame is possible.
* PyFrameObject: rename f_stackbottom to f_stacktop, since it points toTim Peters2001-06-231-5/+5
| | | | | | | | the next free valuestack slot, not to the base (in America, stacks push and pop at the top -- they mutate at the bottom in Australia <winK>). eval_frame(): assert that f_stacktop isn't NULL upon entry. frame_delloc(): avoid ordered pointer comparisons involving f_stacktop when f_stacktop is NULL.
* Teach the UNPACK_SEQUENCE opcode how to tease an iterable object intoTim Peters2001-06-211-32/+38
| | | | | giving up the goods. NEEDS DOC CHANGES
* Try to avoid creating reference cycles involving generators. Only keep aNeil Schemenauer2001-06-211-14/+27
| | | | | | reference to f_back when its really needed. Do a little whitespace normalization as well. This whole file is a big war between tabs and spaces but now is probably not the time to reindent everything.
* gen_iternext(): repair subtle refcount problem.Tim Peters2001-06-201-0/+5
| | | | | | | | | | | | NeilS, please check! This came from staring at your genbug.py, but I'm not sure it plugs all possible holes. Without this, I caught a frameobject refcount going negative, and it was also the cause (in debug build) of _Py_ForgetReference's attempt to forget an object with already- NULL _ob_prev and _ob_next pointers -- although I'm still not entirely sure how! Part of the difficulty is that frameobjects are stored on a free list that gets recycled very quickly, so if there's a stray pointer to one of them it never looks like an insane frameobject (never goes trough the free() mangling MS debug forces, etc).
* Remove unused code.Neil Schemenauer2001-06-201-9/+0
|
* Merging the gen-branch into the main line, at Guido's direction. Yay!Tim Peters2001-06-181-257/+419
| | | | | Bugfix candidate in inspect.py: it was referencing "self" outside of a method.
* Instead of initializing & interning the strings passed to the profileFred Drake2001-06-161-26/+42
| | | | | | | and trace functions lazily, which incurs extra argument pushing and checks in the C overhead for profiling/tracing, create the strings semi-lazily when the Python code first registers a profile or trace function. This simplifies the trampoline into the profile/trace functions.
* SF bug 433228: repr(list) woes when len(list) bigTim Peters2001-06-161-2/+3
| | | | | | call_object: If the object isn't callable, display its type in the error msg rather than its repr. Bugfix candidate.
* call_trace(): Add an additional parameter -- pointer to a PyObject*Fred Drake2001-06-081-13/+36
| | | | | | | | | | | | | | | that should be used to cache an interned version of the event string passed to the profile/trace function. call_trace() will create interned strings and cache them in using the storage specified by this additional parameter, avoiding a lot of string object creation at runtime when using the profiling or tracing functions. All call sites are modified to pass the additional parameter, and four static PyObject* variables are allocated to cache the interned string objects. This closes SF patch #431257.
* Fix bug reported by Tim Peters on python-dev:Jeremy Hylton2001-05-291-6/+5
| | | | | | | | | | | | | | | Keyword arguments passed to builtin functions that don't take them are ignored. >>> {}.clear(x=2) >>> instead of >>> {}.clear(x=2) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: clear() takes no keyword arguments
* Add a second special case to the inline function call code in eval_code2().Jeremy Hylton2001-05-181-1/+7
| | | | | | If we have a PyCFunction (builtin) and it is METH_VARARGS only, load the args and dispatch to call_cfunction() directly. This provides a small speedup for perhaps the most common function calls -- builtins.
* Make PyIter_Next() a little smarter (wrt its knowledge of iteratorTim Peters2001-05-051-5/+3
| | | | internals) so clients can be a lot dumber (wrt their knowledge).
* improved error message-- names the type of the unexpected objectJeremy Hylton2001-04-271-2/+3
|
* Mondo changes to the iterator stuff, without changing how Python codeGuido van Rossum2001-04-231-27/+16
| | | | | | | | | | | | | | | | | | | | | | | | sees it (test_iter.py is unchanged). - Added a tp_iternext slot, which calls the iterator's next() method; this is much faster for built-in iterators over built-in types such as lists and dicts, speeding up pybench's ForLoop with about 25% compared to Python 2.1. (Now there's a good argument for iterators. ;-) - Renamed the built-in sequence iterator SeqIter, affecting the C API functions for it. (This frees up the PyIter prefix for generic iterator operations.) - Added PyIter_Check(obj), which checks that obj's type has a tp_iternext slot and that the proper feature flag is set. - Added PyIter_Next(obj) which calls the tp_iternext slot. It has a somewhat complex return condition due to the need for speed: when it returns NULL, it may not have set an exception condition, meaning the iterator is exhausted; when the exception StopIteration is set (or a derived exception class), it means the same thing; any other exception means some other error occurred.
* SF but #417587: compiler warnings compiling 2.1.Tim Peters2001-04-211-1/+0
| | | | Repaired *some* of the SGI compiler warnings Sjoerd Mullender reported.
* Iterators phase 1. This comprises:Guido van Rossum2001-04-201-0/+41
| | | | | | | | | | | | | | | | | | | | | | new slot tp_iter in type object, plus new flag Py_TPFLAGS_HAVE_ITER new C API PyObject_GetIter(), calls tp_iter new builtin iter(), with two forms: iter(obj), and iter(function, sentinel) new internal object types iterobject and calliterobject new exception StopIteration new opcodes for "for" loops, GET_ITER and FOR_ITER (also supported by dis.py) new magic number for .pyc files new special method for instances: __iter__() returns an iterator iteration over dictionaries: "for x in dict" iterates over the keys iteration over files: "for x in file" iterates over lines TODO: documentation test suite decide whether to use a different way to spell iter(function, sentinal) decide whether "for key in dict" is a good idea use iterators in map/filter/reduce, min/max, and elsewhere (in/not in?) speed tuning (make next() a slot tp_next???)
* Change error message raised when free variable is not yet bound. ItJeremy Hylton2001-04-131-10/+16
| | | | | | | | | now raises NameError instead of UnboundLocalError, because the var in question is definitely not local. (This affects test_scope.py) Also update the recent fix by Ping using get_func_name(). Replace tests of get_func_name() return value with call to get_func_desc() to match all the other uses.
* Patch by Ping (SF bug 415879, Exception.__init__() causes segfault):Guido van Rossum2001-04-131-3/+2
| | | | | | | | | | | | Calling an unbound method on a C extension class without providing an instance can yield a segfault. Try "Exception.__init__()" or "ValueError.__init__()". This is a simple fix. The error-reporting bits in call_method mistakenly treat the misleadingly-named variable "func" as a function, when in fact it is a method. If we let get_func_name take care of the work, all is fine.
* Fix exception handling for non-PyFunction objects, SF bug 414743.Jeremy Hylton2001-04-111-16/+54
| | | | | | | | Fix based on patch #414750 by Michael Hudson. New functions get_func_name() and get_func_desc() return reasonable names and descriptions for all objects. XXX Even objects that aren't actually callable.
* Extend support for from __future__ import nested_scopesJeremy Hylton2001-03-221-2/+16
| | | | | | | | | | | | | | | | | | | If a module has a future statement enabling nested scopes, they are also enable for the exec statement and the functions compile() and execfile() if they occur in the module. If Python is run with the -i option, which enters interactive mode after executing a script, and the script it runs enables nested scopes, they are also enabled in interactive mode. XXX The use of -i with -c "from __future__ import nested_scopes" is not supported. What's the point? To support these changes, many function variants have been added to pythonrun.c. All the variants names end with Flags and they take an extra PyCompilerFlags * argument. It is possible that this complexity will be eliminated in a future version of the interpreter in which nested scopes are not optional.
* If a code object is compiled with nested scopes, define the CO_NESTED flag.Jeremy Hylton2001-03-221-1/+9
| | | | | Add PyEval_GetNestedScopes() which returns a non-zero value if the code for the current interpreter frame has CO_NESTED defined.
* Use PyObject_IsInstance() to check whether the first argument to anGuido van Rossum2001-03-211-13/+19
| | | | | unbound method is of the right type. Hopefully this solves SF patch #409355 (Meta-class inheritance problem); I have no easy way to test.
* Fix PyFrame_FastToLocals() and counterpart to deal with cells andJeremy Hylton2001-03-211-4/+45
| | | | | | | | | | | | | | 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.
* Variety of small INC/DECREF patches that fix reported memory leaksJeremy Hylton2001-03-131-4/+7
| | | | | | | | | | | | | | | | | | | | | 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().
* Remove trailing comma from 'why_code' enum, which was introduced by theThomas Wouters2001-02-161-1/+1
| | | | continue-inside-try patch. Partly fixes SF bug #132597.
* When calling a PyCFunction that has METH_KEYWORDS defined, don'tJeremy Hylton2001-02-091-10/+0
| | | | | | | | create an empty dictionary if it is called without keyword args. Just pass NULL. XXX I had believed that this caused weird errors, but the test suite runs cleanly.
* SF patch 103596 by Nick Mathewson: rause UnboundLocalError forJeremy Hylton2001-02-051-0/+16
| | | | uninitialized free variables
* Allow 'continue' inside 'try' clauseJeremy Hylton2001-02-011-4/+24
| | | | SF patch 102989 by Thomas Wouters
* Undo recent change that banned using import to bind a global, as perJeremy Hylton2001-02-011-5/+3
| | | | | | | | | | | 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
* SF bug #130532: newest CVS won't build on AIX.Tim Peters2001-01-311-2/+0
| | | | | Removed illegal redefinition of REPR macro; kept the one with the argument name that isn't too easy to confuse with zero <wink>.
* Remove f_closure slot of frameobject and use f_localsplus instead.Jeremy Hylton2001-01-291-4/+16
| | | | | | | | | | | | 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.
* PEP 227 implementationJeremy Hylton2001-01-251-12/+77
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 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.
* clearer error messages for apply() and "no locals"Jeremy Hylton2001-01-191-7/+12
|
* Rich comparisons fall-out:Guido van Rossum2001-01-171-148/+147
| | | | | | | | | | | | - 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.
* This patch makes sure that the function name always appears in the errorKa-Ping Yee2001-01-151-29/+54
| | | | | | | 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.
* Two changes to from...import:Guido van Rossum2001-01-121-30/+54
| | | | | | | | | | | 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.
* Fixed bugs noted by Greg SteinMoshe Zadka2001-01-111-0/+2
| | | | | * x wasn't initialized to NULL * Did not DECREF result from displayhook function
* Implementation of PEP-0217.Moshe Zadka2001-01-111-27/+17
| | | | This closes the PEP, and patch 103170
* Add missing Py_DECREF in fast_cfunction. Partial fix for SF bugCharles G. Waldman2001-01-101-3/+6
| | | | #127699.
* When a PyCFunction that takes only positional parameters is called withFred Drake2001-01-041-18/+19
| | | | | | | | | | 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.
* Revised implementation of CALL_FUNCTION and friends.Jeremy Hylton2001-01-031-296/+429
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 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 :-).
* Fix for SF bug #117241Jeremy Hylton2000-10-301-1/+15
| | | | | | | | | When a method is called with no regular arguments and * args, defer the first arg is subclass check until after the * args have been expanded. N.B. The CALL_FUNCTION implementation is getting really hairy; should review it to see if it can be simplified.
generated by cgit v0.12 at 2024-11-22 13:43:41 (GMT)