per esempio il pi uso dell'analisi
ricorsiva discendente prendiamo ad
esempio questa drammatica
notiamo che in questa drammatica abbiamo
che le parti destre delle produzioni di
uno stesso metà simbolo iniziano tutte
con un simbolo terminale diverso quindi
qui sa2 produzioni la prima inizia con
un simbolo terminale p e la seconda con
un simbolo terminale q quindi riescono
immediatamente a distinguere quale di
queste due regole
devo utilizzare stesso discorso per
hicks il primo simbolo qui è un
terminale a quest'altra regola è un
terminale hicks e per ypsilon
anche qui abbiamo due simboli non
terminali diversi per questa regola
quindi in questo caso è semplice
applicare l'analisi ricorsiva
discendente basta guardare il primo
carattere per riuscire a capire quale
delle due regole devo applicare per un
certo non terminale quindi come facciamo
a scrivere un
programma per esempio in un linguaggio c
o c like che risolve questo problema
beh intanto dobbiamo stabilire una
regola chiara su quale regola su quale
funzione legge l'input e quando questo
viene fatto si può fare in maniera
diversa si può decidere che prima di
passare la prima di invocare una
funzione fra le varie che rappresentano
i non terminali quindi avremo una
funzione per hicks una x y uno per s
quindi prima di invocare una di queste
funzioni facciamo la lettura del
prossimo carattere dalla stringa oppure
possa decidere di fare la lettura
durante la funzione quindi la prima
mossa che farà la funzione sarà leggere
un carattere qui si può fare in maniera
diversa
supponiamo di farlo sempre prima e
supponiamo di avere una variabile
globale ch come avevamo fatto in
precedenza per il primo carattere da
analizzare
allora questo significa che il main
prima di invocare la funzione che
rappresenta lo scopo della grammatica
quindi in questa grammatica lo scopo era
pes e quindi avrò una funzione associato
al non terminale s che è appunto lo
scopo della grammatica quindi il main
prima di invocare questa funzione dovrà
effettuare una nextar per leggere il
primo carattere della stringa quindi
l'utilizzo è questo come facciamo a
scrivere il
programma beh allora dovremmo prendere
una regola alla volta e soprattutto un
non terminale alla volta e avere una
funzione per ciascun terminale quindi
avrò una funzione per il non terminale s
e a seconda del carattere che quindi è
già stato letto dal main in questo caso
specifico nel caso dello scopo a seconda
del carattere che è stato eletto devo
scegliere quale regola utilizzare e
questo lo posso fare con un sud che
escono in serie d in tante maniere
diverse quindi guardando la prima regola
esse si riscrive in px questa viene
attivata chiaramente viene utilizzata
quando il primo carattere è una p quindi
se il primo carattere una p che cosa
devo fare
beh consumo ho già consumato diciamo
questo carattere quindi devo controllare
che tutto il resto della frase possa
essere riconosciuto come un sotto
linguaggio generato dal non terminale
hicks quindi devo invocare
essenzialmente la funzione hicks prima
di invocare la funzione secondo le
regole che ci siamo dati dobbiamo
preparare il carattere ch per la
variabile hicks e quindi facciamo una
necstour dopodiché nel caso ci sia
invece il primo carattere che è una qu
allora faccio una cosa assolutamente
analoga quindi leggo il prossimo
carattere e poi invoco la funzione y in
tutti gli altri casi
fornisco risultato falso che rappresenta
il fatto che la stringa non viene
riconosciuta dopo di che passerò al non
terminale successivo quindi all'aics
anche qui avrò una funzione che ha lo
stesso nome del
il terminale è che fornisce ungurian per
dire se la frase viene riconosciuta
oppure no
e anche qui a seconda del valore del
carattere dovrà scegliere dal primo
carattere della stringa dovrà scegliere
quale delle due regole utilizzare allora
se il primo carattere è una allora dovrò
utilizzare la prima regola è che cosa
succede in questa prima regola beh dopo
aver consumato il primo carattere a devo
controllare che ci sia una parte della
frase che può essere riconosciuta come
un linguaggio generato da hicks e quindi
invoco la funzione hicks se questa va a
buon fine fornisce il risultato vero
allora controllo anche la parte
successiva se fornisce il risultato
falso allora evidentemente la frase non
è riconosciuta e quindi fornisco
immediatamente falso
se invece ha fornito risultato vero
allora controllo che il carattere
successivo sia una b quindi se il
carattere successivo è effettivamente
una b allora restituisco vero e prima
come al solito devo effettuare anec star
poi c'è l'altro caso se i xvi riscrive
in piccolo allora in questo caso avrò
una regola che deve semplicemente
consumare questo carattere xp quello che
in realtà è già stato consumato perché
viene letto in precedenza quello che
devo fare è semplicemente effettuare una
nextar per fare l'avanzamento per tutto
quello che avviene dopo
per il resto devo semplicemente fornire
troppo
quindi nel caso ci sia un simbolo
terminale quindi che il simbolo non
terminale si riscriva solo in un simbolo
terminale posso semplicemente fornire
through controllando ovviamente che il
simbolo che viene
che che leggo nella stringa di input sia
proprio quello che mi aspetto in tutti
gli altri casi restituisco falso
chiaramente nel caso della funzione y si
fanno delle cose assolutamente analoga e
quindi si può scrivere una funzione
molto simile a quella della funzione