this is so fucked up i'm now confident that my parser compiler is literally a dual to a parser compiler for alan turing's double-sided tape dispenser. i don't even know why you'd want to do that!!!!
oh whenever the stack diffs hit certain intermediate points, that corresponds to jumping across the boundary of the start or end of a production case (i.e. starting or ending the expansion of a labelled nonterminal). so parsing an input string in this model (by performing the iterative parse process) assigns each input token back to a corresponding state (a specific literal/nonterminal within a specific production case), and then as transitions are made between consecutive input states, they have stack diffs between them (and a stack diff from start -> input[0] and another from input[-1] -> end)
so you DO have a parse graph which maps the input to a sequence of nonterminal expansions from the nonterminal (production) cases provided by the user. but since it travels through the connecting tissue between input tokens, it supports > 2 independent stacks just as easily as 2 (the stack diffs in the solution will fork to span a region)
i still don't have any practical utility for parsing a turing machine yet, but i can see why you'd want to specify a grammar for it. nonterminal expansions correspond to e.g. function calls, and terminals are basic blocks. and nonterminal cases are used for branching.
well and it's also not "parsing a turing machine". it's parsing a series of instruction pointer locations to recover the call and branch information (???)
i don't think this is decompilation because the instruction pointer grammar is what you might get from the compiler and you need that grammar to make sense of anything
tracing the execution is pretty cool though??? and you consider multiple threads as simply multiple instruction pointer streams
i think the translation of what a turing "tape" value at any given time is the call stack (on one side of the tape head) and branch stack (on the other)????
or maybe just branch list??? and maybe branching and jumping are merged? so it's more like the branch–jump list
and the "reason" why that is the case is because my parser compiler analyzes all pairwise state transitions, and when applied to an input (a finite string of tokens), if it matches the whole thing, it ends up synthesizing a turing tape intended for a turing machine using the same set of internal states as the states i synthesized to represent the set of unique atomic input literals (nonterminals)
(also i realized yesterday i made a massive error years ago for compiling contiguous sequences of tokens in the user-provided grammar)