karl3＠writeme.com wrote:
karl3＠writeme.com wrote:
karl3＠writeme.com wrote: karl3＠writeme.com wrote: karl3＠writeme.com wrote: karl3＠writeme.com wrote: GPT-4 User Come up with an analog to "goto" in python that engages the raw interpreter and/or bytecode systems of python to function. i want to try! it sounds like one preference is to see if it works to create a function that accesses the bytes of its caller's code and uses ctypes to modify them taking a pause cause it feels funny, might do a different thing now i bet however pdb and trace work would be a higher level way without ctypes! they use sys.settrace() which lets one install an event handler for major interpreter actions like line, call, return meanwhile, the frame object does have access to the local variables of callers, so one could have a function that turns callers into coroutines by collecting little chunks of code and evaluating them with injected locals. whenever a goto()-like function is called, execution would return to this alternative-vm that would break functions apart and move between frames by injecting locals into bytecode. it would only return if its original frame were goto'd back into. a little wonky but interesting!
the frame.f_locals[] object is writeable, so one could theoretically update the locals of callers properly if they are changed in a side-vm
ok given claude also suggest a preprocessing approach, i realized one can run global constructor code in python by putting at file scope of a module! so basically you'd have your goto() module instrument your codebase when it is imported. you could for example replace all calls to its goto function with jump instructions by seating new code objects using .__code__ = .__code__.replace(co_code=bytes(...)) . it's a little edgy. you'd have to instrument further imports of code somehow. you could raise exceptions for conditions like using the goto object for anything other than a function call. you could simplify it a little by using something other than a global object, like maybe instead a literal expression like `'__goto' 'label'` or anything, then you don't have to worry about it being otherwise captured or unexpectedly used then the big challenges would be (a) finding all imported code (likely there's a module function to enumerate this); (b) instrumenting compilation of code constructed after you and (c) figuring out what to do about the vm stack after the jump complets {-S