polygen-1.0.6.ds2/ 0000755 0001750 0001750 00000000000 10340431123 013171 5 ustar enrico enrico polygen-1.0.6.ds2/ita/ 0000755 0001750 0001750 00000000000 10340430663 013756 5 ustar enrico enrico polygen-1.0.6.ds2/ita/HOWTO-Refman.html 0000644 0001750 0001750 00000466046 10340417034 016767 0 ustar enrico enrico
I
|
e seguite dal punto e
virgola ;
che funge da
terminatore: S ::=
la mela | il mango | l'arancia ;
la mela
il mango
l'arancia
S
(detto non terminale) permette la generazione dei
simboli la mela
, il mango
oppure l'arancia
(detti terminali).la mela
è pari
ad 1 volta su 3, così come per il mango
e l'arancia
:
perciò in presenza di 3 produzioni si ha 1 probabilità su 3 per
ciascuna di esse; in presenza di 5 produzioni si ha una probabilità su
5, ecc. S ::=
il Animale mangia Frutto ;
Animale ::=
gatto | cane ;
Frutto ::= la
mela | il mango ;
il gatto mangia la mela
il cane mangia il mango
S
come
iniziale, pertanto qualunque grammatica deve presentare almeno
la definizione di esso. S ::= Fido "Fido" ;
Fido ::=
bassotto | pastore |
alano ;
bassotto Fido
pastore Fido
alano Fido
S ::=
"(" (mela |
pera) ")" ;
( mela )
( pera )
::=
,
è possibile specificare una sottoproduzione di qualunque forma tra
parentesi tonde:S ::= la (
pera
| mela | banana
) e' sul (
tavolo
|
davanzale
) ;
la pera e' sul tavolo
la pera e' sul davanzale
la mela e' sul tavolo
la mela e' sul davanzale
la banana e' sul tavolo
la banana e' sul davanzale
S ::= la (pera | mela) e' sul (tavolo | davanzale) [del salotto |
della cucina] ;
la pera e' sul tavolo
la pera e' sul tavolo del salotto
la pera e' sul tavolo della cucina
la pera e' sul davanzale
ecc.(*
e *)
. Tale testo verrà completamente
ignorato dal Polygen. S ::= la
mela | la pera (*
| la banana *) | il mango ;
(* anche questo e' un commento *)
la mela
la pera
il mango
^
può essere
prefisso, suffisso o infisso in qualunque punto di una produzione
per istruire il programma a non inserire un carattere di spazio
nell'output generato: S ::=
"(" ^ (mela |
pera) ^ ")" ;
(mela)
(pera)
S ::= la
bottega del Prodotto ;
Prodotto ::= ^lo sciroppo | ^le
arance | salame ;
la bottega dello sciroppo
la bottega delle arancie
la bottega del salame
_
è la parola chiave che specifica la produzione vuota,
formalmente chiamata epsilon. S ::=
palla | _ ;
palla
_
_
in sè, né in un
carattere di spazio, ma nell'assenza di output. S ::= [palla] ;
palla
_
a
oppure
nulla.+
prefisso ad una qualunque produzione aumenta la probabilità che
questa venga generata rispetto alle altre della stessa serie;
simmetricamente, il simbolo meno -
diminuisce la probabilità. Un numero a piacere di +
e -
può essere specificato: S ::= il
gatto mangia (+ la mela |- la pera |
l'arancia |-- il limone) ;
il gatto mangia la mela
il gatto mangia la pera
il gatto mangia l'arancia
il gatto mangia il limone
S
viene
internamente interpretata come: S ::= il
gatto mangia ( la mela | la mela | la mela | la mela
| la pera | la pera
| l'arancia |
l'arancia | l'arancia
| il limone)
;
la mela
venga generata è maggiore rispetto a quella de l'arancia
,
che è maggiore di quella de la pera
, a sua volta
maggiore de il limone
. S ::=
gatto soriano | cane Razza ;
Razza ::=
pastore | dalmata
|
bastardo ;
PRODUCE gatto soriano
cane pastore
cane dalmata
cane bastardo
gatto soriano
sia generato è pari a
1 su 2; non vale però lo stesso per cane pastore, cane
dalmata
e cane bastardo
, sebbene un utente
possa ritenere ragionevole che siano tutti generabili con la
medesima probabilità.gatto soriano
e cane
Razza
si spartiscono equamente la
produzione di S
, ovvero la
probabilità con cui viene generato gatto soriano
è la
stessa (pari ad 1 su 2) con cui viene generato uno tra cane
pastore, cane dalmata
e cane bastardo
. Nella
fattispecie la distribuzione delle probabilità per ogni
produzione possibile appare come segue:
gatto soriano |
1/2 |
cane pastore |
1/2 * 1/3 = 1/6 |
cane dalmata |
1/2 * 1/3 = 1/6 |
cane bastardo |
1/2 * 1/3 = 1/6 |
S
nel modo seguente: S ::=
gatto soriano | cane pastore | cane dalmata |
cane bastardo ;
S ::=
gatto soriano | cane >Razza ;
Razza ::=
pastore | dalmata
|
bastardo ;
>
,
il programma opera, nella fase di preprocessing a monte della
generazione, la trasformazione di cui sopra, cambiando la distribuzione
delle probabilità nel seguente modo:
gatto soriano |
1/4 |
cane pastore |
1/4 |
cane dalmata |
1/4 |
cane bastardo |
1/4 |
S ::= il (gatto | cane
|
canarino
|
toro
|
lupo
|
gallo)
|
lo storione
|
la
(
capra
|
pecora) ;
lo storione
per un motivo
analogo a quello esposto in sezione 2.0.4.1. Per portare
l'eterogeneità dell'output al (ragionevolmente desiderabile) livello
in cui ciascun animale possa essere prodotto con la medesima
probabilità, sarebbe necessario evitare l'utilizzo delle parentesi
tonde, le quali danno luogo a sole 3 macro-produzioni, e
specificare l'articolo accanto ad ogni nome di animale; in altre
parole, quindi, rinunciare all'architettura originale della grammatica.>
istruisce il programma a delegare al preprocessore l'onere di operare
l'unfolding della sottoproduzione immediatamente seguente, permettendo
all'utente di mantenere inalterata l'architettura della grammatica
sorgente. S ::= il
>
(gatto | cane
|
canarino
|
toro
|
lupo
|
gallo)
|
lo storione
|
la
>
(
capra
|
pecora
)
;
S ::= il
gatto | il cane
|
il canarino
|
il toro
|
il lupo
|
il gallo
|
lo storione
|
la
capra
|
la pecora ;
S ::= M:
>
(
il (gatto | cane
>
(pastore | dalmata) |
canarino
|
toro
|
lupo
|
gallo)
|
lo storione
)
|
F: la
>
(
capra
|
pecora) ;
S ::= M:
il gatto |
M:
il
cane pastore
|
M:
il cane dalmata
|
M:
il canarino
|
M:
il toro
|
M:
il lupo
|
M:
il gallo
|
M:
lo
storione
|
F: la
capra
|
F:
pecora ;
>
è pertanto soggetta prima alla
permutazione, la quale mantiene valida l'azione dell'unfolding
specificata, che viene eseguita successivamente nella nuova posizione
all'interno della sequenza. S ::= >{il >(cane| gatto)} e
{
la
(
pecora
|
capra
)}
;
S ::= il
cane e la
(
pecora
|
capra
)
|
il gatto e la
(
pecora
|
capra
)
|
la
(
pecora
|
capra
)
e il cane
|
la
(
pecora
|
capra
)
e il gatto
;
S ::=
>
>> il
(
cane
|
gatto
)
| la (pecora | capra) << | lo storione ;
S ::= il
cane
|
il
gatto
|
la
pecora
|
la
capra
|
lo
storione
;
S ::= Nome.S mangia Nome.P | (Nome mangiano Nome).P ;
Nome ::= (S: il | P: i) (lup | gatt) ^ (S: o | P: i) ;
il lupo mangia i lupi
il lupo mangia i gatti
il gatto mangia i lupi
il gatto mangia i gatti
i lupi mangiano i lupi
i lupi mangiano i gatti
i gatti mangiano i lupi
i gatti mangiano i gatti
S ::= (Ogg.M | Ogg.F).S | (Ogg.M | Ogg.F).P ;
Ogg ::= M: ((Art Sost).il | (Art Sost).lo)
| F: Art Sost ;
Art ::= M: (il: (S: il | P: i) | lo: (S: lo | P: gli))
| F: (S: la | P: le) ;
Sost ::= M: ( il: (lup ^ Decl.2 | can ^ Decl.3))
| lo: (gnom ^ Decl.2 | zabaion ^ Decl.3))
| F: pecor ^ Decl.1 ;
Decl ::= 1: (S: a | P: e) | 2: (S: o | P: i) | 3: (S: e | P: i) ;
il lupo
il cane
lo gnomo
lo zabaione
la pecora
i lupi
i cani
gli gnomi
gli zabaioni
le pecore
S
, P
,M
ed F
si riferiscono
rispettivamente alle forme singolare, plurale, maschile e
femminile, è stato possibile declinare correttamente sostantivi
appartenenti a classi differenti ed associare l'articolo appropriato.Sost
opportuna.S
si
occupa sostanzialmente di attivare le combinazioni delle
etichette S,P
e M,F
per Ogg
.
Per evitare la frequente scomodità di dover compiere simili
operazioni è possibile specificare a destra del punto tra
parentesi tonde una serie di etichette separate dal pipe,
anziché una singola etichetta. S ::= Ogg.(M|F).(S|P) ;
+
e -
. S ::= Ogg.(+M|--F).(S|-P) ;
S ::= (Ogg.M |
Ogg.M |
Ogg.M |
Ogg.M |
Ogg.F).S
|
(Ogg.M |
Ogg.M |
Ogg.M |
Ogg.M |
Ogg.F).S
|
(Ogg.M |
Ogg.M |
Ogg.M |
Ogg.M |
Ogg.F).P
;
S ::= Cifra | S.nz [^S.] ;
Cifra ::= z: 0 | nz: >(
1| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9) ;
0
1
23
23081993
112358
20020723
ecc.\
che istruisce il programma a
trasformare in maiuscola (nel caso in cui già non lo sia) la prima
lettera del simbolo terminale immediatamente successivo. S ::= \ pippo (e' | "." \) Eulogia
^
"."
;
Eulogia
::=
proprio un bell'uomo
|
davvero un signore ;
Pippo e' proprio un bell'uomo.
Pippo. Proprio un bell'uomo.
Pippo e' davvero un signore.
Pippo. Davvero un signore.
\
persiste fino al successivo simbolo terminale risultato della
produzione, pertanto ogni altro atomo (epsilon, concatenazione o
l'operatore \
stesso) che si
interpone agirà come di consueto: S ::= a \ ^ \ _ b
PRODUCE
{
e }
sottoproduzioni che vengono
automaticamente sottoposte ad una permutazione. S ::=
se
{
e'
}
{
quindi
}
{
egli
}
;
PRODUCE
S ::=
{
tra 10 minuti
}
^,
{
alle 3 in punto
}^,
{{io} {
partiro'
}
solo
}
;
PRODUCE
S ::=
{
tra 10 minuti
}
^,
{
alle 3 in punto
}^,
({io} {
partiro'
}
solo
)
;
PRODUCE
>>
e <<
:
ciascun atomo, a qualunque livello, per cui ha senso l'unfolding (vedi
sezione 2.0.4) è soggetto ad un
unfolding appunto. Il risultato è l'appiattimento totale di qualunque
sottoproduzione e simbolo non terminale specificati all'interno delle
doppie parentesi acute: S ::=
senti >> M:
(
il
(
cane| gatto
(
soriano
|
persiano)
|
colibri'
)
|
lo
(
storione
| sciacallo
)
)
|
F:
la
(
pecora
|
raganella
|
Animale
)
<< ;
Animale
::=
capra
|
mucca da
(
latte
|
carne
)
;
S
viene tradotto in: S ::=
senti
(
M:
il cane
|
M:
il gatto soriano
|
M:
il gatto persiano
|
M:
il colibri'
|
M:
lo storione
|
M:
lo sciacallo
|
F:
la pecora
|
F:
la raganella
|
F:
la capra
|
F:
la mucca da
(
latte
|
carne
)
)
;
>
per ogni sottoproduzione o
simbolo non terminale di una sottoproduzione, non sempre è possibile
tuttavia operare ricorsivamente l'unfolding di ogni singolo atomo
senza dare luogo ad errori. Il linguaggio supportato dal Polygen
permette a tale proposito di bloccare l'unfolding (di un atomo
per cui tale operazione avrebbe senso) tramite l'operatore prefisso <
. S ::=
senti >> M:
(
il
(
cane | gatto
<(
soriano
|
persiano)
|
colibri'
)
|
lo
(
storione
| sciacallo
)
)
|
F:
la
(
pecora
|
raganella
)
<< ;
S
viene tradotto in: S ::=
senti
(
M:
il cane
|
M:
il gatto
(
soriano
|
persiano)
|
M:
il colibri'
|
M:
lo storione
|
M:
lo sciacallo
|
F:
la pecora
|
F:
la raganella
)
;
::=
introduce
un binding, già ampiamente discusso in questo manuale, cosiddetto debole o chiusura.ESEMPIO
S ::=
Frutto
e
Frutto
;
Frutto
::= la mela | il
mango | l'arancia ;
PRODUCE
la mela e la mela
Frutto
non
subisce una generazione immediata ma viene chiusa insieme all'ambiente
corrente secondo le regole di scoping. Ogni occorrenza del simbolo
Frutto
in
un ambiente discendente (od il medesimo, come nell'esempio) provoca la
generazione della produzione associata
nell'ambiente
chiuso assieme ad essa.:=
introduce
una seconda forma di binding detta forte
o sospensione o assegnazione.ESEMPIO
S ::=
Frutto
e
Frutto
;
Frutto
:= la mela | il
mango | l'arancia ;
PRODUCE
la mela e la mela
Frutto
viene
sospesa e chiusa insieme all'ambiente corrente secondo le regole di
scoping. Durante la generazione, alla prima occorrenza del simbolo
Frutto
in
un ambiente discendente (od il medesimo, come nell'esempio) la
produzione associata viene generata una
sola volta nell'ambiente chiuso assieme ad essa ed il risultato,
immodificabile, della generazione risposto nell'ambiente; ogni
successiva occorrenza dello stesso non terminale produrrà sempre lo
stesso risultato.ESEMPIO
S ::=
A
A
;
A := a | a
^
A
;
PRODUCE
a a
aa aa;
.
Com'è già stato accennato e come è ragionevole aspettarsi, tali binding
vengono introdotti nell'ambiente (vuoto) secondo un rapporto di mutua
ricorsione: ciascuna produzione legata ad un non termianale può infatti
fare riferimento a qualunque simbolo non terminale definito a
top-level, a monte o a valle, incluso quello a cui essa stessa è legata.ESEMPIO
S ::=
S | A
|
B
|
s
;
A ::=
S | A
|
B
|
a
;
B :=
S | A
|
B
|
b ;
;
, la cui ultima occorrenza
separa l'ultimo binding dal corpo.ESEMPIO
S ::=
sono (X
:= Agg
;
Molto
::=
molto [
Molto
]
;
X ^ "," anzi
Molto
X
| decisamente
Molto
Agg
)
e
Agg
;
Agg
::=
bello
|
simpatico
;
PRODUCE
sono bello, anzi molto bello e simpaticoX
e Molto
sono
locali alla sottoproduzione che li definisce, mentre Agg
è utlizzato sia dal corpo di tale
sottoproduzione che dal corpo di S
. X
è un simbolo
introdotto localmente il cui unisco scopo è in qualche modo fissare la generazione di Agg
, che nell'ambiente a top-level è
definita tramite un binding debole (vedi sezione 2.0.10.1): in generale l'utilizzo degli
scope assieme alle varie forme di binding aggiunge molta potenza al
linguaggio ed aumenta le possibilità di ingegnerizzazione di una
grammatica.ESEMPIO
S ::=
sono (X
:= Agg
;
(
Molto
::=
molto [
Molto
]
;
X ^ "," anzi
Molto
X
| decisamente
Molto
Agg
)
)
e
Agg
;
Agg
::=
bello
|
simpatico
;
ESEMPIO
S ::=
(
X
::=
a
|
b
;
A)
;
A ::=
X
X
;
X
:=
x
|
y
;
PRODUCE
X
nella sottoproduzione di S
non
ha alcun effetto sulla generazione di A
,
che è stata chiusa assieme
all'ambiente in cui è stata definita (vedi sezione 2.0.10.1), ovvero quello a
top-level, in cui la
X
è legata alla produzione x
|
y
.ESEMPIO
S ::=
(
X
::=
a
|
b
;
(
X
::=
x
|
y
;
X))
;
PRODUCE
x
All'interno della secondo sottoproduzione innestata non
c'è visibilità della definizione esterna di X
.
Le medesime regole di applicano ovviamente anche all'ambiente top-level.ESEMPIO
S ::=
(
X
::=
a
|
b
;
(
X
::=
x
[
X
]
;
X))
;
PRODUCE
X
nel secondo binding innestato viene
dunque vista come un ricorsione, non come un riferimento alla
X
dell'ambiente padre.ESEMPIO
S ::=
(
X
::=
x
[
A
]
;
A
::= a
[X]
; (
X
::=
y
[
A
]
;
A
::=
b [X]; X))
;
PRODUCE
S ::= (sei
(
M:
un |
F:
una)
(
M:
bel
|
F:
bella
)
ragazz ^
(
M:
o
|
F:
a)).(M|F)
;
,
separa gli atomi che
rappresentano le possibili scelte: S ::= sei
un
,
una
bel
,
bella
ragazz ^
o
,
a
;
,
viene tradotta in una sottoproduzione che consiste in tante produzioni
separate da |
quanti sono gli
atomi nel gruppo e dove ognuna di tali produzioni presenta l'i-esimo atomo di ogni gruppo, per
ogni i. L'esempio di cui sopra
viene tradotto in: S ::= sei
un bel ragazz
^
o | sei una bella ragazz
^
a
;
S ::=
non
potro'
,
(ho potuto) mai
,
_ venire da te ;
S ::=
una ragazza m^ (o^)+
lto
carina ;
S ::= (a | b)+
;
S ::= (X
:=
a | b; (X)+)
;
S ::= Cifra [^ S] ;
Cifra ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 ;
0
23
853211
000000
00011122335
ecc. S1 ::=
gatto | cane |
cammello ;
S2 ::= gatto | (cane | cammello) ;
gatto
cane
cammello
S1
la
distribuzione delle probabilità è:gatto | 1/3 |
cane | 1/3 |
cammello | 1/3 |
S2
invece:gatto | 1/2 |
cane | 1/2 * 1/2 = 1/4 |
cammello | 1/2 * 1/2 = 1/4 |
+
o
al -
per le sottoproduzioni
tra parentesi quadrate. S ::= la (+ _ | bella) casa ;
la casa
la bella casa
+
o la -
a piacere.bella
. S ::= A | B ;
A ::= a ;
Questa grammatica dà luogo ad un errore, in quanto B
non è definito. S ::= S | A ;
A ::= B ;
B ::= S | A;
S ::= a | A ;
A ::= B ;
B ::= A ;
a
, è altresì possibile che venga imboccato
un percorso che non terminerà mai: è perciò importante che anche simili
casi siano segnalati da un messaggio di errore.>
di unfolding (vedi la sezione 2.0.4.1) ad un
simbolo non terminale che produrrebbe una ricorsione ciclica. S ::= >A ;
A ::= >B ;
B ::= >S ;
S ::= A ;
A ::=
A
^ | _ ;
_
A ::=
mela | pera |
capra ;
A ::= mandarino | anguria ;
S
::=
(A ::= mela | pera | capra ; A ::= mandarino | anguria
;
il
A
)
;
I
I
non
permette l'utilizzo dell'opzione -info
del programma. S ::= [a] ;
a
_
S ::= a A.z ;
A
::= x: x | y: y ;
S ::= a {b} c ;
S ::= >(b c) ;
S ::= >
A
A
A
;
A := a | b ;
S
è il simbolo non terminale iniziale. S ::= DECLS
DECL ::= Nonterm "::=" PRODS
| Nonterm ":=" PRODS
DECLS ::= (DECL ";")+
PRODS ::= PROD ("|" PROD)+
PROD ::= ("+" | "-")* SEQ
LABELS ::= LABEL ("|" LABEL)*
LABEL ::=
("+" | "-")*
Label
SEQ ::= [Label ":"]
(ATOMS)+
ATOMS ::=
ATOM ("," ATOM)*
ATOM ::= Term
| "^"
| "_"
| "\"
| UNFOLDABLE
| ">" UNFOLDABLE
| "<" UNFOLDABLE
| ATOM "."
| ATOM DotLabel
| ATOM ".(" LABELS ")"
UNFOLDABLE ::= Nonterm
| "("
SUB ")" ["+"]
| "[" SUB "]"
| "{" SUB "}"
| ">>" SUB
"<<"
SUB ::=
[DECLS
] PRODS
S ::= DECLS
DECL ::= Nonterm "::=" PRODS
| Nonterm ":=" PRODS
DECLS ::= (DECL ";")+
PRODS ::= SEQ
("|" SEQ)*
SEQ ::= [Label ":"] (ATOM)+
ATOM ::= Nonterm
| Term
| "^"
| "_"
| "(" SUB ")"
| ATOM "."
| ATOM DotLabel
SUB ::= [DECLS] PRODS
Term ::= [a-z 0-9 '][a-z A-Z 0-9 ']*
| " [A-Z a-z 0-9 ( ) _ - ? .
, ! : \ & # + * / % $ � [ ] { } ~ @ ; : | < > =
^ ' \ "]* "
Nonterm ::= [A-Z][A-Z a-z 0-9]*
Label ::= [A-Z a-z 0-9]+
DotLabel ::= . Label
Term
di cui in sezione 4.1.3 riconosce tra virgolette
il backslash \
, che funge da carattere escape. E'
possibile che un simbolo terminale tra virgolette contenga sequenze
escape tra le seguenti:\\ | backslash |
\" | virgolette |
\n | new line |
\r | carriage return |
\b | backspace |
\t | tab |
\xyz
|
codice ASCII decimale xyz
|
sintassi concreta |
sintassi astratta |
L: A11,... , An1 ...
A1n , ... , Anm |
L: ( A11...A1m | ... |
An1...Amn ) |
A.( + (a1)-(b1)
l1|...| +(an)-(bn)
ln) |
(X ::= A; X.l1 |(1)
... |(w1) X.l1 | ... | X.ln |(1)
... |(wn) X.ln) dove wi = ai - bi
- min {a1-b1
... an-bn } |
+(a1)-(b1)
P1 | ... | +(an)-(bn)
Pn |
P1 | (1)
... | (w1)
P1 |
... |
Pn | (1)
... | (wn)
Pn
dove wi = ai - bi
- min {a1-b1
... an-bn } |
[ D;
P
] |
(_ | (
D; P
)) |
(
D; P
)+ |
( X ::=
( D; P
)
(_ | X ) ; X ) |
>>
D; P
<<
|
(D; P'
) dove P' = f(A ) per ogni atomo A in P con f( A ) = A
se A non appartiene all'insieme degli atormi unfoldablef( <U ) = U
se U appartiene all'insieme degli atomi unfoldablef( U ) = > f(U ) se U appartiene all'insieme degli atomi unfoldable
|
P1 | ... | A1 { D1 ; Q1}.
... An { Dn
; Q n }. | ... | Pn |
P1 | ... | ( A1 ( D1 ; Q11 ) .
... An ( D1 ; Q1 n ) . ln
|
... | Dn
;
Dn
;
)
| ... | Pn dove Qji è
l' i-esimo elemento della j-esima Q1..
Q n(con
i = 1..n, j = 1..n!) |
P1 | ... | L: A >( D; Q1 | ... | Qm).l B | ... | Pn |
( D; P1 | ... | L: A (Q1).l B | ... | L: A (Qm).l B | ... | Pn )
|
P1 | ... | L: A >X.l B | ... | Pn D; Q1 | ... | Qm |
( D; P1 | ... | L: A (Q1).l B | ... | L: A (Qm).l B | ... | Pn )
|
P , Q |
produzioni o serie di produzioni |
A , B |
atomi o (sotto)sequenze di atomi |
D |
dichirazione o serie di
dichiarazioni |
L , l |
etichette |
X , Y |
simboli non terminali |
+(n)-(m) |
giustapposizione di n operatori + e m operatori - |
P | (1)
... | (n)
P |
ripetizione di n produzioni P |
I
|
and followed by a semicolon ;
, which acts as terminator: S ::= the apple | an orange
;
the apple
an orange
S
(said non-terminal) allows the generation of symbols the
apple
as well as an orange
(said terminal).the apple
to be generated
is equal to 1 every 3 times; and the same for an orange
:
thus, when 2 productions occur, we have 1 in 2 chances each; when 5 occur,
we have 1 in 5, etc. S ::= the Animal is eating
a Animal ;
Animale ::= cat | dog ;
the cat is eating a cat
the cat is eating a dog
the dog is eating a cat
the dog is eating a dog
S
as the starting one: every grammar must therefore define it at least
unless another starting symbol has been specified as argument to the program. S ::= a Pet called "Pet"
;
Pet ::= cat | pig | dog ;
a cat called Pet
a pig called Pet
a dog called Pet
S ::= "(" (apple | orange) ")" ;
( apple )
( orange )
::=
in a definition, a subproduction of any form can be specified between
round brackets:S ::= an (
apple
| orange
) is on the (
table
|
desk
) ;
an apple is on the table
an orange is on the table
an apple is on the desk
an orange is on the desk
S ::= an (apple | orange) is on the
(table | desk) [in the (living | dining) room] ;
an apple is on the table
an apple is on the table in the living room
an apple is on the table in the dining room
an orange is on the table
an orange is on the table in the living room
ecc.(*
and *)
keywords. Such text will be completely ignored by PolyGen. S ::= apple | rainge
(* | banana *) |
mango ;
(* this is comment
too *)
apple
orange
mango
^
can be either prefixed or suffixed to as well as infixed in any point
within a production in order to make the program not insert a white space
character in the output string: S ::= "(" ^ (apple | orange) ^ ")" ;
(apple)
(orange)
S ::= "I" Verb ^ e Verb ^ ing ;
Verb ::= lov | hat ;
I love hating
I love loving
I hate hating
I hate loving
_
stands for the empty production, formally called epsilon. S ::= ball | _ ;
ball
_
S ::= [palla] ;
palla
_
a
or nothing as
output.+
, when prefixed to a (sub)production (however nested), raises the probability
for it to be generated, in respect to the others of that very series;
simmetrically, the minus keyword -
lowers it down. Any number of +
and -
keywords may be specified: S ::= the cat is eating (+
an apple |- an orange | some meat |-- a
lemon) ;
the cat is eating an apple
the cat is eating an orange
the cat is eating some meat
the cat is eating a lemon
S
is internally interpretet as follows: S ::= the cat is eating (
an apple | an apple | an apple | an apple
| an orange | an orange
|
some meat | some meat | some meat
|
a lemon) ;
an apple
to be generated is higher than an
orange
, which is higher that some meat
, on its turn
higher than a lemon
. S ::= ugly cat | nice
Animal ;
Animal ::= dog | bull | pig ;
PRODUCES ugly cat
nice dog
nice bull
nice pig
ugly
cat
to be generated is 1 every 2 times, but it is not the same
for nice dog
, nice bull
and nice pig
,
even though a user may find it reasonable for all them to be generated
with the same probability.ugly cat
and nice
Animal
equally sharing the unit of
prabability of S
: thus the
chances for ugly cat
to be generated is equal to the chances
for nice Animal
, i.e. one among nice
dog
, nice bull
and nice pig
. In the
example above the probability distribution appears as follows:
ugly cat |
1/2 |
nice dog |
1/2 * 1/3 = 1/6 |
nice bull |
1/2 * 1/3 = 1/6 |
nice pig |
1/2 * 1/3 = 1/6 |
S
this
way: S ::=
ugly cat | nice dog | nice bull | nice
pig ;
for unfolding
non-terminal symbols: S ::= ugly cat | nice
>
Animal ;
Animal ::= dog | bull | pig ;
>
keyword
to a non-terminal symbol, during the preprocessing phase the program performs
the translation above, changing the probability distribution as follows:
ugly cat |
1/4 |
nice dog |
1/4 |
nice bull |
1/4 |
nice pig |
1/4 |
S ::= (walk
|
pass)
through
|
look at
|
(
go
|
come
|
move
|
link
|
run
)
to
;
look
at
will be generated for the same reason discussed in section 2.0.4.1. In order to take output
etherogeneity to the desired level, that is where each single verb may
be produced with the same probability, the user should avoid round bracket
usage at all, so that there would be no more 3 macro-productions, and should
suffix the proper preposition to each verb.>
makes the program delegate to the preprocessor the unfolding of the following
subproduction, allowing the user to keep the original source architecture
unchanged. S ::= >(walk
|
pass)
through
|
look
at
|
>(
go
|
come
|
move
|
link
|
run
)
to
;
S ::=
walk through
|
pass through
|
look
at
|
go
to
|
come to
|
move to
|
link to
|
run
to
;
Digit ::=
z: 0 | nz: >(
1
| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9) ;
Digit ::=
z: 0 | nz:
1 |
nz:
2 |
nz:
3
|
nz:
4 |
nz:
5 |
nz:
6
|
nz:
7 |
nz:
8 |
nz:
9 ;
>
operator is therefore
first permutated, while the unfolding holds and is then performed
at the new position within the sequence. S ::= >{the >(dog | cat)} and
{
a
(
fish
|
bull
)}
;
S ::=
the dog and a
(
fish
|
bull
)
|
the
cat and a
(
fish
|
bull
)
|
a
(
fish
|
bull
)
and the dog
|
a
(
fish
|
bull
)
and the cat
;
S ::=
> >> the
(
dog
|
cat
)
| a (fish | bull) << | an alligator ;
S ::=
the dog
|
the cat
|
a fish
|
a bull
|
an alligator
;
S ::= Verb.inf | Verb.ing ;
Verb ::= (inf: to) (eat | drink | jump) (ing: ^ing) ;
to eat
to drink
to jump
eating
drinking
jumping
S ::= (Conjug.S | Conjug.P).sp |
(Conjug.S | Conjug.P).pp
;
Conjug ::= (Pronoun Verb).1 |
(Pronoun Verb).2 |
(Pronoun Verb).3
;
Pronoun ::= S: (1: "I" | 2: you | 3: (he | she | it))
|
P:
(1: we | 2: you | 3: they)
;
Verb ::= (pp: Be) (eat | drink) (sp:
(S: (3: ^s)) | pp: ^ing) ;
Be ::= S: (1: am | 2: are | 3: is) | P: are ;
I eat
you eat
he eats
she eats
it eats
we eat
they eat
I am eating
you are eating
he is eating
we are eating
etc.1,2,3,S
and P
respectively identify
syntactical forms for the first, second and third persons, singular and
plural, we managed to correctly conjugate both simple present and present
progressive tenses according to a pronoun.Verb
.S
simply activates
all combos of label pairs S,P
and sp,pp
for the production
of Conjug
. In order to avoid
such frequent uncomfortable solutions you're allowed to specifiy, on the
right of the dot operator, a set of labels in round brackets interleaved
by the pipe keyword. S ::= Conjug.(S|P).(sp|pp) ;
+
and
-
keywords. S ::= Ogg.(+S|--P).(sp|-pp) ;
S ::= (Conjug.S |
Conjug
.S |
Conjug
.S
|
Conjug
.S
|
Conjug
.P).sp
|
(Conjug.S |
Conjug
.S
|
Conjug
.S
|
Conjug
.S
|
Conjug
.P).sp
|
(Conjug.S |
Conjug
.S |
Conjug
.S
|
Conjug
.S
|
Conjug
.P).pp
;
\
, which makes the program
perform the capitalization of the very following terminal symbol, i.e. switching
its first letter to uppercase. S
::= \ smith (is | "." \) Eulogy
^ "."
;
Eulogy
::=
rather a smart man
|
really
a gentleman ;
Smith is rather a smart man.
Smith. Rather a smart man.
Smith is really a gentleman.
Smith. Really a gentleman.
S
::= a \ ^ \ _
b
PRODUCES
{
and }
, the program automatically performs all
the permutations among them. S
::= whether
{
is
}
{
therefore
}
{
he
}
;
PRODUCES
S
::=
{
in
10 minutes
}
^,
{
at
3 o'clock
}^,
{"I" {will depart} {
alone
}
}
;
PRODUCES
S
::=
{
in
10 minutes
}
^,
{
at
3 o'clock
}^,
("I"
{
will depart} {
alone
}
)
;
PRODUCES
>>
and <<
: any atom, however
nested, for which the unfolding operation makes sense (see section 2.0.4) is unfolded. As a result, the complete
flattening of every subproduction and non-terminal symbol is done: S
::= look at >>
the
(
dog
|
(
sorian
|
persian
)
cat
)
|
a
(
cow
|
bull
|
Animal
)
<< ;
Animal
::=
pig
|
(
weird
|
ugly
)
chicken ;
S
is translated
into:S ::=
look at
(
the dog
|
the
sorian
cat
|
the
persian
cat
|
a
cow
|
a
bull
|
a
pig
|
a
(
weird
|
ugly
)
chicken
)
;
>
operator for every subproduction or non-terminal symbol within a given subproduction;
on the other hand, it still is sometimes impossible to perform a deep unfolding
of every (sub)atom without generating (unintentional) errors. The PolyGen
grammar definition language allows therefore the user to lock the
unfolding (of an atom for which such operation would make sense) by means
of the prefix operator <
. S
::= look at >>
the
(
dog
|
<
(
sorian
|
persian
)
cat
)
|
a
(
cow
|
bull
|
<
Animal
)
<< ;
Animal
::=
pig
|
(
weird
|
ugly
)
chicken ;
S
is
translated into:S ::=
look at
(
the dog
|
the
(
sorian
|
persian
)
cat
|
a
cow
|
a
bull
|
a
Animal
)
;
S ::= Digit [^ S] ;
Digit ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 ;
0
23
853211
000000
00011122335
etc. S1 ::= canarin | cow | camel ;
S2 ::= canarin | (cow | camel) ;
canarin
cow
camel
S1
and S2
outputs are equal, the probability distribution
for the former is:cat |
1/3 |
cow |
1/3 |
camel |
1/3 |
cat |
1/2 |
cow |
1/2 * 1/2 = 1/4 |
camel |
1/2 * 1/2 = 1/4 |
(cow | camel)
is interpreted someway as a whole block by
the program. S ::= a (+ _ | beautiful) house ;
a house
a beautiful house
beautiful.
S ::= Digit | S.nz [^ S.] ;
Digit ::= z: 0 | nz: {
1 | 2
| 3 | 4 | 5 | 6 | 7 | 8 | 9} ;
0
1
23
23081993
112358
20020723
ecc. S ::= A | B ;
A ::= a ;
B
is not defined. S ::= S | A ;
A ::= B ;
B ::= S | A ;
S ::= a | A ;
A ::= B
;
B ::= A
;
a
, it is still possible for a non-terminating path
to be entered: such cases are therefore signaled by an error message too.>
(see section 2.0.4.1) to a non-terminal
symbol that would cause a cyclic recursion.
S ::= >A ;
A ::= >B ;
B ::= >S ;
S ::= A.3 ;
A ::= 1: a | 2: b ;
_
A ::= apple | orange | banana ;
A ::= mandarin | melon ;
A
is defined twice.I
I
does not allow the usage of the program -info
option. S ::= A.3 | c ;
A ::= 1: a | 2: b ;
c
_
S
::= a {b} c ;
S
is the starting non-terminal symbol. S ::= DEF
| DEF S
DEF ::= Nonterm "::=" PRODS ";"
PRODS ::= PROD
| PROD "|" PRODS
PROD ::= SEQ
| MODIF SEQ
MODIF ::= "+"
| "-"
| "+" MODIF
| "-" MODIF
LABELS ::= LABEL
| LABEL "|" LABELS
LABEL ::= Label
| MODIF Label
SEQ ::= ATOMS
| Label ":" ATOMS
ATOMS ::= ATOM
| ATOM ATOMS
ATOM ::= Term
| "^"
| "_"
| "\"
| UNFOLDABLE
| ">" UNFOLDABLE
| "<" UNFOLDABLE
| ATOM "."
| ATOM DotLabel
| ATOM ".(" LABELS ")"
UNFOLDABLE ::= Nonterm
| "(" PRODS ")"
| "[" PRODS "]"
| "{" PRODS "}"
| ">>" PRODS "<<"
S ::= DEF
| DEF S
DEF ::= Nonterm "::=" PRODS ";"
PRODS ::= SEQ
| SEQ "|" PRODS
SEQ ::= ATOMS
| Label ":" ATOMS
ATOMS ::= ATOM
| ATOM ATOMS
ATOM ::= Nonterm
| Term
| "^"
| "_"
| "(" PRODS ")"
| ATOM "."
| ATOM DotLabel
Term ::= [a-z 0-9 , '][a-z A-Z 0-9 , ']*
| " [A-Z a-z 0-9 ( ) _ - ? . , ! : \ & # +
* / % $ � [ ] { } ~ @ ; : | < > = ^ ' \ "]* "
Nonterm ::= [A-Z][A-Z a-z 0-9 _]*
Label ::= [A-Z a-z 0-9 _]+
DotLabel ::= . Label
Nonterm
in section 4.1.3 recognizes the backslash character
within quotes. A terminal symbol is therefore allowed to contain any
escape sequence among the following:\\ | backslash |
\" | quote |
\n | new line |
\r | carriage return |
\b | backspace |
\t | tab |
\xyz
|
ASCII decimal code xyz
|
concrete syntax |
abstract syntax |
|
1 |
A.( + (a1)-(b1)
l1|...| +(an)-(bn)
ln) |
(A.l1 | (1)
... | (w1)
A.l1
|
... | A.ln | (1)
... | (wn)
A.ln ) where wi = ai -
bi - min {a1-b1
... an-bn } |
2 |
+(a1)-(b1)
P1 | ... | +(an)-(bn)
Pn |
P1 | (1)
... | (w1)
P1 |
... |
Pn | (1)
... | (wn)
Pn
where wi = ai -
bi - min {a1-b1
... an-bn } |
3 |
[ P
] |
(_ | ( P
)) |
4 |
>>
P
<<
|
( P'
) where P' is isomorph to P where unfoldable
atoms are unfolded |
5 |
P1 | ... | A1
{Q1}.
... An { Q n }.
|
... | Pn |
P1 | ... | A1
(Q11 ) .
... An ( Q1 n ) . ln
| ... |
| ... | Pn where Qji
is the i-th element of the j-th
permutation Q1..
Q n(with
i = 1..n, j = 1..n!) |
6 |
P1 | ... | L: A >(Q1 | ... | Qm).l B | ... | Pn |
P1 | ... | L: A (Q1).l B | ... | L: A (Qm).l B | ... | Pn |
6 |
P1 | ... | L: A >X.l B | ... | Pn |
P1 | ... | L: A (Q1).l B | ... | L: A (Qm).l B | ... | Pn |
P , Q |
productions or series of productions |
A , B |
atoms o atom (sub)sequences |
L , l |
labels |
X , Y |
non-terminali symbols |
+(n)-(m) |
juxtaposition of n and m, respectively,
+ and -
operators
|
P | (1)
... | (n)
P |
n-lengthened series of productions P
|