Terry Reedy
2/17/2010 8:58:00 PM
On 2/17/2010 11:04 AM, Dan Yamins wrote:
> Really, nobody has any idea about this? (Sorry to repost.)
> On Tue, Feb 16, 2010 at 7:29 PM, Dan Yamins <dyamins@gmail.com
> <mailto:dyamins@gmail.com>> wrote:
>
> Hi:
>
> I'm wondering what the best way to wrap and modify function calls
> is. Essentially what I want to achieve is to have a function like
> this:
>
> def Wrap(frame,event,arg):
> if event == 'call':
> result = PerformCheck(GetArgumentsFromFrame(frame))
> if Condition(result):
> return result
> else:
> return [normal function call]
>
> called whenever a "call" event is about to occur.
For yourself as interpreter, execute the above for every call.
For CPython, alternative 1 is to create a custom interpreter to change
(wrap) the interpretation of the call-function bytecode in the ceval
loop. That is its 'call event', and I believe this would catch every
explicit f(args) call and only such calls.
Python has no general metasyntax for changing the semantics of its
syntax. The __xx__ methods are special cases for the corresponding
operators *and* the corresponding user-defined class. The '__call__'
method of a class applies to instances of that class. Alternative 2:
class func_wrap:
def __init__(self, func):
self._func = func
def __call__(self, args, kwds):
result = PerformCheck(args, kwds)
if Condition(result):
return result
else:
return self._func(*args,**kwds)
Now wrap *every* function you are interested in. Builtin functions are
no problem; methods of builtin classes cannont be wrapped without
subclassing.
Terry Jan Reedy
> When I say "return result" I mean: return that data object instead
> of what the function would have returned, and prevent execution of
> the function.
>
> Is there any way to do this using sys.settrace? Or perhaps
> something from the bdb or pbd module?
>
>
> In other words, what I'm looking for is a way to intercept all function
> calls with a "wrapper" -- like one can do using settrace and other
> debugging methods -- but, unlike the debugging methods, have the
> "wrapping" function actually be able to intervene in the stack and, for
> instance, conditionally replace the function call's return with
> something determined in the wrapping function and prevent the function
> call's execution. I want to be able to do this by setting a single
> system-wide (or at any rate, thread-wide) value, like with settrace, and
> not have to modify individual functions one by one.
>
> Could I, for example, set a settrace function that somehow modifies the
> stack? Or is there some much better way to do this? Or, if someone can
> tell me that this can't be done without having to roll my own
> implementation of the Python interpreter, that would be great to know too.
>
> Thanks again,
> Dan
>