Analisi di testo sensibile al contesto complesso

Sto cercando di imparare come gestire la sensibilità al contesto complessa durante l'analisi. Supponiamo che tu abbia questo semplice esempio di codice:

var x = 10
var y = x + 10
var z = y + 10
var a = z + 10
var b = a + 10
var c = b + 10

Se fosse semplicemente un JavaScript, le variabili valuterebbero questo:

x == 10
y == 20
z == 30
a == 40
b == 50
c == 60

Tuttavia, voglio renderlo molto più sensibile al contesto aggiungendovi una certa complessità arbitraria. Supponiamo che aggiungiamo la seguente regola parser :

If somewhere in the code there is the expression c = b + 10 and y = x, then make a be 5 more than whatever it is set to, as well as converting it to a string.

Ciò significherebbe risolvere il problema in questo modo:

x == 10
y == 20
z == 30
a == "45"
b == "4510"
c == "451010"

Spero che questo esempio non abbia alcuni casi limite per renderlo facile da analizzare. Quello che spero di ottenere è come analizzare in modo efficiente le espressioni .

Dalla mia comprensione, questa è la sensibilità al contesto. Diciamo che il parser è stato rinato in parole / valori e spazi, quindi siamo rimasti con solo token non spaziali. Abbiamo la regola che cerca c = b + 10 e y = x quando arriviamo a a . Quindi quando arriviamo a a , cerchiamo in giro . Guardiamo avanti e indietro e tutto intorno cercando di trovare le espressioni. Scopriamo che c = b + 10 è avanti con un bel numero di token e y = x è dietro a qualche token. Ora immagina che questo file sia lungo 10.000 righe con funzioni complesse e simili, quindi dovrebbe eseguire la scansione dell'intero file ovunque per capirlo, una volta arrivato a var a . Ora immagina di avere più di una regola, ma 100 regole, quindi è costantemente in scansione su tutto il file.

Mi chiedo quale tipo di modello dovrebbe essere usato per gestire questo. Sembra che ci siano almeno due grandi cose che puoi fare per dare una mano. Il primo è quello di costruire una comprensione del testo mentre si va dall'inizio alla posizione corrente . Quindi sapremmo che la regola è presente per y = x (e c = b + 10 ), quindi dovremmo cercare questo in ogni fase del percorso, magari creando una sorta di struttura dati. Una volta trovato, potremmo avere un modo per cercarlo rapidamente una volta che abbiamo trovato var a . Ma non abbiamo ancora c = b + 10 fino alla fine del file. Quindi è come se dovessimo saltare tutto in qualche modo e "leggere" analizzare il resto finché non troviamo c = b + 10 , o lo analizziamo completamente facendo a = 40 e b = 50 , ecc., Finché non troviamo finalmente c = b + 10 , e poi tornare a var a e ri-analizzare con la nuova comprensione . Qualcosa del genere. Il problema è che tutti questi modi sembrano molto elaborati e complicati da comprendere.

Chiedendosi se si potrebbe far luce sui migliori approcci o tecniche su come gestirlo. Non necessariamente algoritmi specifici come immagino sia complicato, ma forse pensieri su dove guardare o come avvicinarsi.

Per approfondire, dì che abbiamo avuto queste regole:

(1) If somewhere in the code there is the expression c = b + 10 and y = x, then make a be 5 more than whatever it is set to, as well as converting it to a string. (2) If b == "4510" then make y == 25, and propagate the rest...

Potrebbe continuare ad andare in circolo come una cosa da iterazione a virgola fissa. Finché non arrivi finalmente al parsing finale. Un'interpretazione influisce sulla prossima influenza sulla successiva fino a quando non si assesta. Sembra che potrebbe esserci un sistema.

Ti stai chiedendo se esiste un qualche tipo di sistema per questo, come "l'iterazione del punto fisso su parser top-down o bottom-up con stato globale e sensibilità al contesto".