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! omigod this sounds really hard. options: - is there a way to halt interpretation during a function? - alternatively, we could use ctypes to modify whatever python uses as an instruction pointer hmmmmmmmmmmmmmmmmm 1304 so, yes, there is a way to halt interpretation during a function, it's called 'yield'. there's also access to the call stack but i think the access is read-only. the problem with 'yield' is: - (a) i think it turns the function into a generator upon use - (b) if it's bundled into a goto() function it will interrupt the goto() body rather than the surrounding code here's a third option: - mutate the source code live using runtime preprocessing like old javascript second language interpreters did options again: - find an in-python way to halt function executation midway - use ctypes to modify the runtime at runtime - post-process the running sourcecode, say in a nonreturning function with injects controlflow to hide its nonreturn but i'm guessing what i originally meant was more along the lines of: - instrument the calling function to behave as if there were a goto statement where your function is called ok so the idea is maybe along the lines of, let's make a goto() function in python that emulates goto in C. the approaches of interest (despite there being many other interesting ones!) are either: (a) validate that callers are decorated with a recompiler or (b) identify the caller and mutate them mid-call to change their behavior although (b) is preferred because it doesn't require a decorator, it might be unreasonable hard i'm not sure. for example it's likely not possible to mutate code mid-call (although it could be); it likely only affects the next call. let's see! this sounds hard :s 1308
def a(): ... b = 1 ... b += 1 ... return b ... import dis dis.dis(a) 1 0 RESUME 0
2 2 LOAD_CONST 1 (1) 4 STORE_FAST 0 (b) 3 6 LOAD_FAST 0 (b) 8 LOAD_CONST 1 (1) 10 BINARY_OP 13 (+=) 14 STORE_FAST 0 (b) 4 16 LOAD_FAST 0 (b) 18 RETURN_VALUE let's see what happens if i remove line 3 from the function and try to inject it using a caller-modifier or something? :s :s :s this won't work
list(a.__code__.co_code) [151, 0, 100, 1, 125, 0, 124, 0, 100, 1, 122, 13, 0, 0, 125, 0, 124, 0, 83, 0]
looks like maybe 151=RESUME_1 100=LOAD_CONST_1 125=STORE_FAST_1 124=LOAD_FAST_1 122=BINARY_OP_3 83=RETURN_VALUE_1 and it uses an indexable stack or something 1313 1317 here's a cool thing you can do. this function disassembles itself. it shows a call to the function to get the stack frame and pass it to the disassembler:
import sys def disassemble_self(): ... dis.dis(sys._getframe().f_code.co_code) ... disassemble_self() 0 RESUME 0 2 LOAD_GLOBAL 0 14 LOAD_METHOD 0 36 LOAD_GLOBAL 2 48 LOAD_METHOD 2 70 PRECALL 0 74 CALL 0 84 LOAD_ATTR 3 94 LOAD_ATTR 4 104 PRECALL 1 108 CALL 1 118 POP_TOP 120 LOAD_CONST 0 122 RETURN_VALUE