Specifica di un Linguaggio di Programmazione - Gianfranco ...
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
Specifica di un Linguaggio di Programmazione
concisa
Successo di un LP descrizione
comprensibile
Pb livello di formalizzazione (notazione rigorosa per evitare ambiguità):
Formale incomprensibile pb di accettazione del LP (barriera, Es: ALGOL)
Informale comprensibile proliferazione di dialetti (ambiguità)
Pb diversificazione dei destinatari (“audience”) specifica polimorfa:
Revisori (potenziali utenti) successo = f (chiarezza, eleganza, ...)
Implementatori del LP chiaro significato dei costrutti (tutti!)
Utenti del LP necessità del Reference Manual
Linguaggi di Programmazione 2. Specifica 1Specifica di un Linguaggio di Programmazione (ii)
lessico
Definizione di un L (anche naturale) comprende sintassi delle sue frasi
semantica
lessico semantica
Italia 1 Febbraio 2020
Data: DD/DD/DDDD 01/02/2020
USA 2 Gennaio 2020
sintassi
if ( expr ) statement
Selezione in C
“Se valore di expr 0 allora esegui statement”
semantica
Sintassi: non garantisce una frase semanticamente corretta però: semplicità ...
Linguaggi di Programmazione 2. Specifica 2Specifica di un Linguaggio di Programmazione (iii)
Complessità Standardizzazione Formalismo
Lessico piccola si Espressioni regolari
Sintassi media si G non contestuali
Sem. Operazionale
Semantica grossa no Assiomatica
Denotazionale
Sebbene separate nella descrizione, intimamente collegate:
Sintassi: deve “suggerire” la semantica (if, while, + ...)
Semantica: guidata dalla sintassi
Linguaggi di Programmazione 2. Specifica 3Lessico
stringa lessicale = sequenza significativa di caratteri (parola)
Terminologia simbolo = astrazione di una classe di stringhe lessicali (istanze)
pattern = regola per descrivere le istanze di un simbolo
Simbolo Istanze Pattern
while while while
begin begin begin enumerazine
relop < >= != = == { =, !=, =, == }
id partenza tempo m24 X2 lettera seguita da lettere e/o cifre
parte intera seguita opzionalmente da
num 3 25 3.5 4.37E12
parte decimale e/o parte esponenziale
strconst "Hello world!" sequenza di caratteri racchiusa tra "
Linguaggi di Programmazione 2. Specifica 4Specifica dei Simboli
{ 0, 1 } = alfabeto binario
Alfabeto insieme finito di caratteri { a, b, c, d }
ASCII = alfabeto per computer
Unicode
Stringa su un alfabeto sequenza finita di caratteri dell’alfabeto
| x | lunghezza della stringa x
stringa nulla | | = 0
xy x = alfa, y =beta xy = alfabeta
Operatore di concatenazione:
= elemento identità nella concatenazione: x = x = x
pensato come prodotto
x0 =
x1 = x
possibilità di definire l’operatore potenza su stringhe x2 = xx
...
Linguaggi di Programmazione 2. Specifica 5Specifica dei Simboli (ii)
∅ (valenza formale)
Linguaggio insieme di stringhe su un certo alfabeto {}
{ frasi sintatticamente corrette del Pascal }
{ bytes }
Operazione Forma Definizione
Unione LM {x|xL ∨ xM}
Concatenazione LM { xy | x L ∧ y M }
{} se n = 0
Potenza Ln
Ln-1 L se n 1 L L L ... L (n volte)
Chiusura di Kleene L* U
i=0
L i
L0 L1 L2 ...
Chiusura Positiva L +
U
i=1
L i
L1 L2 L3 ...
Linguaggi di Programmazione 2. Specifica 6Specifica dei Simboli (iii)
L = { A, B, ..., Z, a, b, ..., z } linguaggio
Esempio di linguaggio: isomorfismo tra
M = { 0, 1, ..., 9 } alfabeto
1. L M = { lettere e cifre }
2. L M = { stringhe composte da una lettera seguita da una cifra }
3. L3 = { stringhe di 3 lettere }
4. L* = { stringhe di lettere, inclusa }
id 5. L ( L M )* = { stringhe alfanumeriche che iniziano con una lettera }
+
num 6. M = { stringhe di almeno una cifra } = { costanti intere senza segno }
Linguaggi di Programmazione 2. Specifica 7Espressioni Regolari
Potente formalismo per specificare un pattern (id, num, ...)
identificatore = lettera (lettera | cifra)*
espressioni regolari mediante operatori applicati a sottoespressioni ...
Similitudine fino alle espressioni atomiche
espressioni aritmetiche
(34+25) * (12+3)
caratteri numeri
alfabeto
espressioni aritmetiche risultato = numero
Differenza
espressioni regolari “risultato” = { stringhe } = linguaggio
Linguaggi di Programmazione 2. Specifica 8Definizione di Espressione Regolare
Def di espressione regolare (su un alfabeto ) mediante regole induttive:
1. è una espressione regolare che denota il linguaggio { }
2. Se a , allora a è una espressione regolare che denota il linguaggio { a }
3. Se x, y sono expr regolari che denotano rispettivamente L(x), L(y), allora:
(x) è una expr regolare che denota L(x) possibilità di includere parentesi (non intrusive)
(x) | (y) è una expr regolare che denota L(x) L(y)
(x) (y) è una expr regolare che denota L(x) L(y)
(x) è una expr regolare che denota (L(x))*
carattere dell’alfabeto
Regola 2 diversi significati di a espressione regolare
stringa
Associazione Operatore
precedenza
Eliminazione delle parentesi mediante regole di sinistra |
associatività sinistra Concatenazione
sinistra *
● Insieme regolare linguaggio determinato da una espressione regolare
Linguaggi di Programmazione 2. Specifica 9Esempi di Espressioni Regolari
1. = { a, b, c }. Determinare l’expreg corrispondente alle stringhe che contengono esattamente un b:
(a | c)* b (a | c)*
2. = { a, b, c }. Determinare l’expreg corrispondente alle stringhe che contengono al più un b:
(a | c)* (b | ) (a | c)*
Oss: expreg equivalente: (a | c)* | (a | c)* b (a | c)* diverse expreg per lo stesso L!
Formalmente: L(x) = L(y) x y
3. Limite della potenzialità espressiva (insiemi non regolari):
= { a, b }. L = { an b an | n 0 } = { aba, aabaa, aaabaaa, ... } = astrazione di costrutti bilanciati
non specificabile con una espressione regolare non può contare!
non sufficientemente vincolante:
a* b a * complete ma non sound
Linguaggi di Programmazione 2. Specifica 10Proprietà Algebriche
Proprietà algebriche delle espressioni regolari (analogamente alle espressioni aritmetiche)
Proprietà Descrizione
x|y = y|x | è commutativo
x | (y | z) = (x | y) | z | è associativo
(x y) z = x (y z) Concatenazione è associativa
x (y | z) = xy | xz
Proprietà distributiva della concatenazione rispetto a |
(x | y) z = xz | yz
x = x = x = elemento identità per concatenazione
x* = (x | )* Relazione tra ripetizione ed
x** = x* Ripetizione è idempotente
Linguaggi di Programmazione 2. Specifica 11Espressioni Regolari Estese
Non cambia il potere espressivo (però: concisione, scrivibilità)
1. Una o più ripetizioni: x+ xx* (L(x))+
Esempio: Numeri naturali in forma binaria (0|1)+ (0|1)(0|1)*
2. Qualsiasi carattere in :
Esempio: Tutte le stringhe che contengono almeno un b .*b.*
3. Un range di caratteri: [ ... ] [abc] a | b | c [a-z] a | b | ... | z
[0-9] 0 | 1 | ... | 9 [a-zA-Z] {lettere minuscole e maiuscole} [A-Za-z] [A-z] (anche in ASCII)
4. Qualsiasi carattere al di fuori di un certo insieme: ~
~a {a} ~(a | b | c) {a, b, c}
5. Sottoespressioni opzionali: ? ( | ) ? [0-9]+ naturale con possibile segno
(x)? (x | )
Linguaggi di Programmazione 2. Specifica 12Definizioni Regolari
Associazioni di nomi a espressioni regolari (semantica MACRO) modularizzazione
nome1 x1
Nomi distinti
nome2 x2
xi = expreg sui simboli in { nome1, nome2, ..., nomei-1 }
...
Non ricorsive! (altrimenti aumento potere espressivo)
nomen xn
Esempi: lettera [A-Za-z]
1. Identificatori Pascal: cifra [0-9] [A-Za-z] ([A-Za-z] | [0-9])*
id lettera (lettera | cifra)*
intera
2. Numeri con esponente 7.25E-2 = 7.25 * 10-2 = 0.0725 : 3 parti decimale
esponenziale
nat [0-9]
snat (|) ? nat
num snat (“.”nat) ? (E snat) ?
Linguaggi di Programmazione 2. Specifica 13Espressioni Regolari per Token nei LP
Classificazione elementi lessicali:
Keywords = { if, then, while, do, begin, end, procedure, function, case, repeat ... }
Simboli speciali = { +, -, *, /, =, >, >=, !=, ++, --, &&, ||, ... }
Identificatori = { stringhe alfanumeriche che iniziano con una lettera }
Costanti = { 25, .34, 2.7E-3, "alfa", 'a', ... }
Pseudosimboli (spaziatura, commenti)
Keywords: Simboli speciali:
if if plus “+”
then then minus “”
... ...
while while equal ==
keyword if | then | ... | while assign =
plusplus “++”
minusminus “--"
Costanti:
charconst ‘.’
strconst \”(~\”)*\” caso semplice, senza metacaratteri
...
Linguaggi di Programmazione 2. Specifica 14Espressioni Regolari per Token nei LP (ii)
Pascal: { commento } { (~})* }
Commenti: diversi stili C: /* commento */
Ada: -- commento --(~\n)*
/* */
Stile C: ba ... ab (astrazione) ba(b*(a*(a|b)b*)*a*)ab
((ab))* no!
Ambiguità: quando la stessa stringa di caratteri è compatibile con più espressioni regolari
while id
while
Esempi:
noteq
less greater
keywords = reserved words
LP regole di disambiguamento
principio della sottotringa più lunga (maximal munch)
in generale: insufficienti E1 E2
Linguaggi di Programmazione 2. Specifica 15Espressioni Regolari per Token nei LP (iii)
Delimitatori: caratteri sui quali una stringa cessa di rappresentare un simbolo (“confini” dei token)
caratteri speciali alfa=beta
Esempi
spaziatura while a > b do
Def di pseudosimbolo: whitespace (blank | tab | newline | comment)
quando riconosciuto, viene ignorato Linguaggi liberi dal formato
Linguaggi di Programmazione 2. Specifica 16Sintassi
L = { stringhe di caratteri su un certo alfabeto } { frasi }
Regole sintattiche: specificano la struttura delle frasi di L
numerose
naturale regole
Oss: L complesse
artificiale poche (semplici) regole
Convenzione: sintassi descrizione del lessico (unità sintattiche di più basso livello)
sintassi
semantica
lessico
Linguaggi di Programmazione 2. Specifica 17Sintassi (ii)
Def formale di un L per riconoscimento
non pratica!
generazione
1. Riconoscitori del linguaggio
Hp: L su alfabeto R strumento di riconoscimento:
frase (sequenza di token) verdetto
R L
Pb: L infinito R non adatto per enumerare le frasi di L
usato per verificare la correttezza sintattica di un programma
Linguaggi di Programmazione 2. Specifica 18Sintassi (iii)
push
2. Generatori del linguaggio
G strumento per generare le frasi di L: frase (imprevedibile!)
G
Doppio pb R: strumento poco utile per definire L poichè usato “per tentativi”
G: aleatorietà della frase generata
Stretta connessione tra generazione = scoperta della computer science
riconoscimento
Meccanismo di R basato su quello di G
Linguaggi di Programmazione 2. Specifica 19Metodi formali per la definizione della sintassi
1950s: John Backus
Noam Chomsky inventano la stessa notazione in contesti diversi
Chomsky (linguista): specifica 4 classi di strumenti generativi (grammatiche)
definiscono 4 classi di linguaggi
0
1 0 G ricorsivamente enumerabili
2 1 G sensibili al contesto
Classe
2 G non-contestuali sintassi
3 3 G regolari lessico
Linguaggi di Programmazione 2. Specifica 20Metodi formali per la definizione della sintassi (ii)
Backus (1959): presenta ALGOL 58 sintassi specificata in BNF
BNF (Backus-Naur Form) : quasi identica allo strumento 2 di Chomsky
Paradosso: BNF non accettata prontamente dagli utenti dei LP
poi, standard per la descrizione della sintassi dei LP
BNF = linguaggio per descrivere un LP metalinguaggio
Linguaggi di Programmazione 2. Specifica 21BNF
Idea di fondo della notazione BNF: astrazioni per definire le strutture sintattiche
Assegnamento in C: assign var = expr
LHS RHS = { token, stringhe lessicali, astrazioni }
Parafrasi della regola (produzione):
“Un’istanza dell’astrazione assign è definita come un’istanza dell’astrazione
var, seguita dalla stringa lessicale ‘=’, seguita da un’istanza dell’astrazione expr”.
netto = lordo - tara
Necessario definire tutte le astrazioni (tipicamente: ricorsivamente)
Linguaggi di Programmazione 2. Specifica 22BNF (ii)
Nomenclatura: nella produzione astrazione (simbolo) nonterminale
token / stringa lessicale (simbolo) terminale
Def: Grammatica { produzioni }
terminali
Formalmente: G = (T, N, P, A) nonterminali
produzioni
assioma (astrazione di più alto livello)
Astrazione: può essere definita in modi alternative in un’unica regola (leggibilità)
Linguaggi di Programmazione 2. Specifica 23BNF (iii)
1. Selezione in Pascal: if-stat if bool-expr then stat
if-stat if bool-expr then stat else stat
if-stat if bool-expr then stat |
if bool-expr then stat else stat
2. Specifica sintetica di liste (finite ma illimitate)
In matematica: 1, 2,
In BNF ‘’ ricorsione: id-list id | id , id-list (piede ricorsione, passo ricorsivo)
semplice
BNF = strumento
potente
Linguaggi di Programmazione 2. Specifica 24BNF (iv)
BNF = strumento generativo per definire LP
Derivazione “Frase generata mediante una serie di applicazioni delle regole
(riscrittura), partendo dall’assioma”
forma sentenziale
assign id := expr
assign id := expr A := expr
id A | B | C A := id * expr
A := B * expr
expr id + expr | A := B*(A+C)
id * expr | A := B * (expr)
(expr) | A := B * (id + expr)
id A := B * (A + expr)
A := B * (A + id)
A := B * (A + C)
Linguaggi di Programmazione 2. Specifica 25BNF (v)
Rappresentazione della struttura gerarchica delle frasi mediante alberi sintattici
assign
id := expr
A id * expr
B ( expr )
A := B*(A+C)
id + expr
A id
Frase sulle foglie (da sinistra a destra) C
Linguaggi di Programmazione 2. Specifica 26BNF: Linguaggio per tabelle
R S
def R (A: integer, B: string, C: boolean) D E
A B C
def S (D: integer, E: string)
3 alfa true 125 sole
R := {(3, "alfa", true)(5, "beta", false)}
5 beta false 236 luna
S := {(125, "sole")(236, "luna")}
program stat-list
stat-list stat-list stat | stat
stat def-stat | assign-stat
def-stat def id ( def-list )
def-list def-list, domain-decl | domain-decl
domain-decl id: domain
domain integer | string | boolean
assign-stat id := tuple-list
tuple-list tuple-list tuple-const |
tuple-const ( simple-const-list )
simple-const-list simple-const-list, simple-const | simple-const
simple-const intconst | strconst | boolconst
Linguaggi di Programmazione 2. Specifica 27BNF: Linguaggio per tabelle (ii)
program stat-list
stat-list stat-list stat | stat
stat def-stat | assign-stat
def-stat def id ( def-list )
def-list def-list, domain-decl | domain-decl
domain-decl id: domain program
domain integer | string | boolean
assign-stat id := tuple-list stat-list
tuple-list tuple-list tuple-const |
tuple-const ( simple-const-list ) stat
simple-const-list simple-const-list, simple-const | simple-const
stat-list
simple-const intconst | strconst | boolconst
stat-list stat assign-stat
stat-list stat assign-stat
stat def-stat
def-stat )
def id ( def-list
S
def-list , domain-decl
def R (A: integer, B: string, C: boolean)
def S (D: integer, E: string) domain-decl id : domain
R := {(3, "alfa", true)(5, "beta", false)}
S := {(125, "sole")(236, "luna")} E
id : domain string
D
integer
Linguaggi di Programmazione 2. Specifica 28EBNF
Stesso potere espressivo aumento di scrivibilità
leggibilità
Estensioni ® nuovi metacaratteri: [ ] { } ( ) +
1. Opzionalità
if-stat if ( expr ) stat [ else stat ]
2. Ripetizione
id-list id {, id }
3. Disgiunzione
for-stat for var := expr (to | downto) expr do stat
Linguaggi di Programmazione 2. Specifica 29EBNF (ii)
expr expr + term | expr - term | term
BNF:
term term * factor | term / factor | factor
expr term {( + | - ) term}
EBNF:
term factor {( * | / ) factor}
Ripetizione non vuota:
comp-stat begin stat { stat } end
comp-stat begin { stat }+ end
Linguaggi di Programmazione 2. Specifica 30EBNF: Linguaggio per tabelle
R S
def R (A: integer, B: string, C: boolean) D E
A B C
def S (D: integer, E: string)
3 alfa true 125 sole
R := {(3, "alfa", true)(5, "beta", false)}
5 beta false 236 luna
S := {(125, "sole")(236, "luna")}
program {stat }+
stat def-stat | assign-stat
def-stat def id “(“ def-list “)”
def-list domain-decl {, domain-decl }
domain-decl id: domain
domain integer | string | boolean
assign-stat id := “{” {tuple-const} “}”
tuple-const “(“ simple-const {, simple-const } “)”
simple-const intconst | strconst | boolconst
Linguaggi di Programmazione 2. Specifica 31EBNF: Linguaggio per tabelle (ii)
program
stat stat stat stat
def-stat def-stat assign-stat assign-stat
def id ( def-list )
S
domain-decl , domain-decl
id : domain id : domain
D E
integer string
program {stat }+
stat def-stat | assign-stat
def-stat def id “(“ def-list “)” def R (A: integer, B: string, C: boolean)
def-list domain-decl {, domain-decl } def S (D: integer, E: string)
domain-decl id: domain R := {(3, "alfa", true)(5, "beta", false)}
domain integer | string | boolean S := {(125, "sole")(236, "luna")}
assign-stat id := “{” {tuple-const} “}”
tuple-const “(“ simple-const {, simple-const } “)”
simple-const intconst | strconst | boolconst
Linguaggi di Programmazione 2. Specifica 32Diagrammi sintattici
un diagramma unità sintattica (nonterminale)
Diversa rappresentazione grafica per nonterminali
terminali
Selezione Ada: if-stat if cond then stats { else-if } [ else stats ] end if ;
else-if elsif cond then stats
if-stat: if cond then stats end if ;
else-if else stats
else-if: elsif cond then stats
Linguaggi di Programmazione 2. Specifica 33Semantica dinamica
Per descrivere il significato dei programmi
specifica non ambigua del LP (evitamento proliferazione dialetti)
Vantaggi possibilità di generazione automatica del compilatore
supporto alla prova formale di correttezza dei programmi
operazionale
Formalismi: semantica assiomatica
denotazionale
Linguaggi di Programmazione 2. Specifica 34Semantica operazionale
(PL/I, 1972)
Significato di un costrutto descritto dall’esecuzione su macchina reale (< livello)
virtuale (interprete)
Se virtuale necessità di costruire 2 componenti traduttore L L’
macchina virtuale di L’
Macchina virtuale (interprete) di L’:
dati
programma risultati
Interprete
Semantica di una istruzione = cambiamento di stato della macchina virtuale
Linguaggi di Programmazione 2. Specifica 35Semantica operazionale (ii)
Istruzione C Semantica operazionale
for(expr1; expr2; expr3) expr1;
statements
loop: if expr2 = 0 goto out
statements
expr3;
goto loop
out:
Oss: Semantica operazionale espressa algoritmicamente, non matematicamente
Linguaggi di Programmazione 2. Specifica 36Semantica denotazionale
Semantica denotazionale = formalismo rigoroso più usato per descrivere il
significato dei programmi (basato sulla teoria delle funzioni ricorsive)
Idea: astrazione del LP: def dominio matematico
f : istanze della astrazione elementi del dominio
f
applicate sull'albero sintattico!
Oggetti matematici denotano il significato delle corrispondenti entità linguistiche
Linguaggi di Programmazione 2. Specifica 37Semantica denotazionale (ii)
Es: Numeri binari: bnum 0 | 1 | bnum 0 | bnum 1
6 bnum 110 ® possibili diverse semantiche:
• numero binario
3 bnum • and / or logico
0
• vettore di booleani
1 bnum • ...
1
1
N = { naturali } dominio degli oggetti matematici associati
Mb(‘0’) = 0
Mb funzione di mapping Mb(‘1’) = 1
Mb(bnum ‘0’) = 2 * Mb(bnum)
Mb(bnum ‘1’) = 2 * Mb(bnum) + 1
Linguaggi di Programmazione 2. Specifica 38Semantica denotazionale (iii)
Es: Numeri decimali: dnum 0 | 1 | ... | 9 | dnum 0 | dnum 1 | ... | dnum 9
Md(‘0’) = 0, Md(‘1’) = 1, ..., Md(‘9’) = 9
Md(dnum ‘0’) = 10 * Md(dnum)
Md(dnum ‘1’) = 10 * Md(dnum) + 1
...
Md(dnum ‘9’) = 10 * Md(dnum) + 9
Linguaggi di Programmazione 2. Specifica 39Semantica denotazionale (iv)
Stato di un programma {(i1, v1), (i2, v2), ..., (in, vn)} ik = nome di una variabile
vk = valore corrente di ik
stato del programma (eventualmente undef)
(ik, s) funzione che computa vk
Me(dnum, s) = Md(dnum).
Es: Espressione (senza effetti collaterali): Me(var , s) = if (var, s) = undef then
errore
else (var, s).
expr dnum | var | bexpr
Me(bexpr, s) = Mbe(bexpr, s).
bexpr expr1 op expr2
op + | * Mbe(bexpr, s) = if Me(expr1, s) = errore or
Me(expr2, s) = errore then
errore
Interi
elsif Mo(op) = '+' then
Me(expr1, s) + Me(expr2, s)
Dominio associato = Z { errore } else
Me(expr1, s) * Me(expr2, s).
Mo(+) = ('+').
Mo(*) = (‘*’).
Linguaggi di Programmazione 2. Specifica 40Semantica denotazionale (v)
expr dnum | var | bexpr s = {(x,3),(y,4)}
bexpr expr1 op expr2
op + | *
x + 12 * y
expr 51
Me(dnum, s) = Md(dnum).
bexpr 51
Me(var , s) = if (var, s) = undef then
errore
else (var, s). 3 expr op '+' expr 48
Me(bexpr, s) = Mbe(bexpr, s).
var + bexpr 48
Mbe(bexpr, s) = if Me(expr1, s) = errore or
(x)
Me(expr2, s) = errore then
errore 12 expr op '*' expr 4
elsif Mo(op) = '+' then
Me(expr1, s) + Me(expr2, s) dnum * var
else ( 12 ) (y)
Me(expr1, s) * Me(expr2, s).
Mo(+) = ('+').
Mo(*) = (‘*’).
Linguaggi di Programmazione 2. Specifica 41Semantica denotazionale (vi)
valutazione di E
Es: Assegnamento: x := E
setting di x con il valore di E
Ma(x := E, s) =
if Me(E, s) = errore then
errore confronto fra nomi!
else (ik, s) if ik x
s’ = {(i1, v1’), (i2, v2’), ..., (in, vn’)}, k [1 .. n] vk’ =
Me(E, s) otherwise
Linguaggi di Programmazione 2. Specifica 42Semantica denotazionale (vii)
Es: Ciclo a condizione iniziale: while B do L
Assumiamo Mlist : [ istruzioni ] stato
Mbool : expr booleana { true, false, errore }
Mw(while B do L, s) =
if Mbool(B, s) = errore then
errore
(piede della ricorsione) else if Mbool(B, s) = false then s
else if Mlist(L, s) = errore then errore
(ricorsione) else Mw(while B do L, Mlist(L, s))
stato dopo l’esecuzione di L
Oss:
Conversione iterazione ricorsione
Se terminazione: computazione di nulla!
Linguaggi di Programmazione 2. Specifica 43Semantica denotazionale (viii)
Mw(while B do L, s) =
if Mbool(B, s) = errore then
while iPuoi anche leggere
