fst-compiler - Online nel cloud

PROGRAMMA:

NOME

fst-compiler, fst-compiler-utf8 - Due compilatori per programmi SFST

SINOSSI

fst-compilatore file-grammatica [ file di uscita ]
fst-compilatore-utf8 file-grammatica [ file di uscita ]

VERSIONI

-c Memorizzare il trasduttore in formato compatto utilizzato da fst-infl2.

-l Memorizzare il trasduttore in formato lowmem.

-s Scambia la superficie e lo strato di analisi del trasduttore. Devi usare questo interruttore in
per usare fst-infla (fst-infl2, fst-infl3) per la generazione piuttosto che per l'analisi.

DESCRIZIONE

fst-compilatore è un compilatore per programmi di trasduttori a stati finiti. Genera una riduzione al minimo
trasduttore a stato finito che può essere utilizzato con prima mattina, prima-infl, prima stampa, fst-confronto,
fst-analisi, ed primo reticolo. La rappresentazione del trasduttore compatto che viene generata con
il flag -c, è supportato da fst-infl2, fst-treno, ed prima partita. La memoria efficiente
la rappresentazione del trasduttore che viene generata con il flag -l, è supportata solo da prima
infl3.

Il primo argomento del programma è il nome di un file che contiene il programma del trasduttore.
Il linguaggio di programmazione è descritto di seguito. Il secondo argomento è il nome del file
in cui il trasduttore risultante verrà scritto in forma binaria. Se un secondo argomento è
mancante, l'output verrà scritto in normale.

fst-compilatore-utf8 differisce dalla fst-compilatore solo nella codifica dei caratteri. fst-compilatore-
utf8 supporta la codifica UTF8 dei file sorgente mentre fst-compilatore deve essere utilizzato per
Codici di caratteri a 8 bit come latin1 che sono un'estensione del codice ASCII. Informazione
sulla codifica è memorizzato nei file del trasduttore e utilizzato dagli altri programmi SFST.

RISORSE FORMATI

Un programma trasduttore consiste in una sequenza (opzionale) di alfabeto ed variabile
definizioni seguite da un singolo trasduttore espressione che definisce il risultato
trasduttore.

Alfabeto

Una definizione alfabetica è costituita dalla parola chiave ALPHABET seguita da = e da qualche trasduttore
espressione eg

ALFABETO = [az]:[AZ]

Questo comando ridefinisce l'alfabeto come l'insieme di coppie di simboli che si verificano sul
transizioni del trasduttore. Occorrenze di operatori a due livelli, operatori di negazione e
i periodi non quotati devono essere sempre preceduti da una definizione alfabetica.

Variabili

Ci sono due diversi tipi di variabili. Simbolo set variabili sono racchiusi da hash
segni (#) e prendere sequenze di simboli (vedi sotto) come valori:

#UC# = AZ
#LC# = az

Trasduttore variabili sono racchiusi da simboli del dollaro e accettano le espressioni del trasduttore come
valori:

$MAP$ = [az]:[AZ]+
$MAP$ = [#LC#]:[#UC#]+

Le variabili il cui nome inizia con il simbolo `=' sono speciali accordo variabili. Se uno
variabile accordo si verifica più di una volta in un'espressione trasduttore, avrà sempre
lo stesso valore. Considera il seguente programma di trasduttori:

$=1$ = [abc]
$=1$ X $=1$

Il trasduttore del risultato riconosce le stringhe aXa, bXb e cXc. Solo trasduttori aciclici
(cioè trasduttori con un insieme finito di mappature di stringhe) possono essere assegnati all'accordo
variabili.

Simboli

Un simbolo è o

- un singolo carattere come A s 5,

- un carattere tra virgolette come \* o \_,

- un simbolo multi-carattere come o (che è sempre
racchiuso tra parentesi angolari) o

- una barra rovesciata seguita da un numero che è il codice numerico del
carattere designato

- il simbolo nullo <>.

Sequenza di simboli

Una sequenza di simboli è una sequenza di caratteri, simboli a più caratteri e caratteri
intervalli, ad esempio az \. .

gamma di simboli

Un intervallo di simboli è o

- un unico simbolo

- una sequenza di simboli racchiusa tra parentesi quadre come [A-Za-z] o

- una sequenza di simboli che inizia con ^ e racchiusa tra parentesi quadre come [^A-Za-z]
(che designa il complemento di [a-zA-Z]) o

- il punto (che rappresenta qualsiasi simbolo dell'alfabeto)

Espressioni del trasduttore

Un'espressione di trasduttore (TE) è definita ricorsivamente come segue:

- Una coppia di due intervalli di simboli separati da due punti è un TE.

[az]:[aZ]

- Un singolo intervallo di simboli come [az] è un TE.
È una forma abbreviata per [az]:[az].

- Due sequenze di simboli racchiuse tra parentesi graffe e separate da due punti sono
ha mangiato. {a[bc]}:{def} è equivalente a a:db:e <>:f | a:dc:e <>:f.

- XY è un TE se X e Y sono TE.
(Gli spazi vengono ignorati a meno che non vengano citati.)

- (X) è un TE se X è un TE.

- X op è un TE è X è un TE e op è o * (operatore stella di Kleene), +
(operatore più di Kleene), o ? (operatore opzionale)

- op X è un TE è X è un TE e op è o ! (operatore di negazione), ^
(operatore di estrazione della lingua di destinazione), _ (operatore di estrazione della lingua di origine) o ^_
(operatore di commutazione sorgente e destinazione).

- X op Y è un TE è X e Y sono TE e op è uno & (congiunzione
operatore), | (operatore di disgiunzione), || (operatore di composizione), o - (sottrazione
operatore)

- L x op y R è un TE se L e R sono TE, xey sono intervalli di simboli e
op è => (restrizione a due livelli), <= (coercizione a due livelli) o <=> (coercizione a due livelli)
restrizione e coercizione).

- X op L__R è un TE se X, L e R sono TE e op è ^-> (verso l'alto
sostituzione), _-> (sostituzione verso il basso), /-> (sostituzione verso sinistra) o \-> (sostituzione verso destra
sostituzione). Inoltre, L e R devono definire automi (cioè che mappano le loro stringhe
su se stessi). Questi operatori corrispondono agli operatori di sostituzione di Karttunen. Se la
la freccia è seguita da un punto interrogativo (?), la sostituzione diventa facoltativa.

- X << l è un TE se X è un TE e l è una delle due forme
a o la forma a:b dove aeb sono singoli caratteri o simboli. Il risultato è un
trasduttore dove l è stato inserito liberamente in X. Il trasduttore ab << c per esempio è
equivalente a c*ac*bc*.

- X op Y L1__R2, ... , LN__RN è un TE se X,Y, L1 tramite LN e R1
attraverso RN sono TE e op è => (restrizione generale), <= (coercizione generale), ^=>
(restrizione generale della superficie), ^<= (coercizione generale della superficie), ^<=> (superficie generale
restrizione e coercizione), _=> (restrizione generale profonda), _<= (coercizione generale profonda),
_<=> (restrizione generale profonda e coercizione). (Questi operatori sono stati implementati in seguito
un suggerimento di Anssi Yli-Jyra.)

- "fname" è un TE. Il compilatore legge il file denominato fname e gira
in un trasduttore della forma riga1|riga2|riga3|... dove rigax è la x-esima riga di
il file. Tutti i caratteri diversi da : e \ sono interpretati letteralmente (cioè non come
operatori). Questo TE è tipicamente usato, ad esempio, per leggere una lista di morfemi da un file.

- " " è un TE. Il compilatore legge un trasduttore precompilato da
il file denominato fname. Questo

Ulteriori caratteristiche

I commenti iniziano con il simbolo % e si estendono fino alla fine della riga. Gli spazi vuoti vengono ignorati
a meno che non siano citati. Le espressioni terminano alla fine di una riga a meno che alla fine della riga
è preceduto da una barra rovesciata. Il comando

#include "nomef"

può essere utilizzato per inserire il codice sorgente da un file denominato fname. Il comando

RE >> "fname"

memorizza l'espressione regolare RE nel file fname. Il comando

#usa hopcroft

dice al compilatore di usare l'algoritmo di minimizzazione Hopcroft d'ora in poi, e

#usa predefinito

torna all'algoritmo di minimizzazione predefinito (Brzozowski). Il comando

ESEMPIO

Ecco un esempio di un semplice programma di trasduttori. Supponendo che il file "adj-stems"
contiene le due righe

facile
in ritardo
big

questo trasduttore analizzerà correttamente le forme dell'aggettivo facile, facile, facile e tardiva,
più tardi, e più tardi.

ALFABETO = [a-zA-Z] y:ie:<> :<>

$R$ = y<=>i ( :<> e)

$R2$ = e<=><> ( :<> e)

$R$ = $R$ e $R2$

$Gambi$ = "radici-adj"

$S$ = $Gambi$ ( :<>| :{er}| :{est})

$S$ || $ R $

EXIT STATUS

fst-compilatore restituisce 0 a meno che non si verifichi qualche errore.

Usa fst-compiler online usando i servizi onworks.net