fst-compiler - Online sa Cloud

PROGRAMA:

NAME

fst-compiler, fst-compiler-utf8 - Dalawang compiler para sa SFST programs

SINOPSIS

fst-compiler grammar-file [ output-file ]
fst-compiler-utf8 grammar-file [ output-file ]

Opsyon

-c Itabi ang transducer sa compact na format na ginagamit ng fst-infl2.

-l Itabi ang transduser sa lowmem na format.

-s Lumipat sa ibabaw at layer ng pagsusuri ng transduser. Kailangan mong gamitin ang switch na ito
utos na gamitin fst-infl (fst-infl2, fst-infl3) para sa henerasyon sa halip na pagsusuri.

DESCRIPTION

fst-compiler ay isang compiler para sa finite-state transducer programs. Ito ay bumubuo ng isang pinaliit
may hangganan ng estado transduser na maaaring gamitin sa fst-mor, fst-infl, fst-print, fst-compare,
fst-parse, at fst-sala-sala. Ang compact transducer na representasyon na nabuo gamit ang
ang -c flag, ay sinusuportahan ng fst-infl2, fst-tren, at fst-match. Ang memory-efficient
Ang representasyon ng transduser na nabuo gamit ang -l na bandila, ay sinusuportahan lamang ng fst-
infl3.

Ang unang argumento ng programa ay ang pangalan ng isang file na naglalaman ng transducer program.
Ang programming language ay inilarawan sa ibaba. Ang pangalawang argumento ay ang pangalan ng file
kung saan ang resultang transducer ay isusulat sa binary form. Kung ang pangalawang argumento ay
nawawala, ang output ay isusulat sa stdout.

fst-compiler-utf8 naiiba mula sa fst-compiler sa character encoding lang. fst-compiler-
utf8 sumusuporta sa UTF8 encoding ng source file samantalang fst-compiler ay gagamitin para sa
8-Bit na character code tulad ng latin1 na isang extension ng ASCII code. Impormasyon
ang tungkol sa pag-encode ay naka-imbak sa mga transducer file at ginagamit ng iba pang mga SFST program.

FILE FORMATS

Ang isang transducer program ay binubuo ng isang (opsyonal) sequence ng alpabeto at nagbabago
mga kahulugan na sinusundan ng isang solong transduser pagpapahayag na tumutukoy sa resulta
transduser

Alpabeto

Ang kahulugan ng alpabeto ay binubuo ng keyword na ALPHABET na sinusundan ng = at ilang transduser
expression hal

ALPHABET = [az]:[AZ]

Ang utos na ito ay muling tukuyin ang alpabeto bilang set ng mga pares ng simbolo na nagaganap sa
mga paglipat ng transduser. Mga pangyayari ng dalawang antas na operator, negation operator at
ang mga hindi na-quote na tuldok ay palaging kailangang mauunahan ng isang kahulugan ng alpabeto.

Variable

Mayroong dalawang magkaibang uri ng mga variable. Icon itakda mga variable ay nakapaloob sa pamamagitan ng hash
mga palatandaan (#) at kunin ang mga pagkakasunud-sunod ng simbolo (tingnan sa ibaba) bilang mga halaga:

#UC# = AZ
#LC# = az

Transduser mga variable ay nakapaloob sa pamamagitan ng mga senyales ng dolyar at kumuha ng mga transducer na expression bilang
mga halaga:

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

Ang mga variable na ang pangalan ay nagsisimula sa simbolo na `=' ay espesyal kasunduan mga variable. Kung ang
Ang variable ng kasunduan ay nangyayari nang higit sa isang beses sa isang transducer expression, ito ay palaging magkakaroon
ang parehong halaga. Isaalang-alang ang sumusunod na transducer program:

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

Kinikilala ng resultang transducer ang mga string na aXa, bXb, at cXc. Mga acyclic transducer lamang
(ibig sabihin, ang mga transduser na may limitadong hanay ng mga string mapping) ay maaaring italaga sa kasunduan
mga variable.

Mga Simbolo

Ang isang simbolo ay alinman

- isang solong karakter tulad ng A s 5,

- isang naka-quote na karakter tulad ng \* o \_,

- isang multi-character na simbolo tulad ng o (na laging
nakapaloob sa mga anggulong bracket) o

- isang backslash na sinusundan ng isang numero na kung saan ay ang numeric code ng
itinalagang karakter

- ang null na simbolo <>.

Pagkakasunod-sunod ng simbolo

Ang pagkakasunud-sunod ng simbolo ay isang pagkakasunud-sunod ng mga character, mga simbolo ng maraming karakter at karakter
mga saklaw, hal az \. .

hanay ng simbolo

Ang isang hanay ng simbolo ay alinman

- isang solong simbolo

- isang pagkakasunud-sunod ng simbolo na nakapaloob sa mga square bracket tulad ng [A-Za-z] o

- isang pagkakasunud-sunod ng simbolo na nagsisimula sa ^ at nakapaloob sa mga square bracket tulad ng [^A-Za-z]
(nagtatalaga ng complement ng [a-zA-Z]) o

- ang tuldok (na kumakatawan sa anumang simbolo mula sa alpabeto)

Mga expression ng transduser

Ang isang transducer expression (TE) ay recursively na tinukoy bilang mga sumusunod:

- Ang isang pares ng dalawang hanay ng simbolo na pinaghihiwalay ng isang tutuldok ay isang TE.

[az]:[aZ]

- Ang isang solong hanay ng simbolo tulad ng [az] ay isang TE.
Ito ay isang maikling anyo para sa [az]:[az].

- Dalawang pagkakasunud-sunod ng simbolo na nakapaloob sa mga tirante at pinaghihiwalay ng isang tutuldok ay
isang TE. {a[bc]}:{def} ay katumbas ng a:db:e <>:f | a:dc:e <>:f.

- Ang XY ay isang TE kung ang X at Y ay mga TE.
(Balewalain ang mga blangko maliban kung sinipi ang mga ito.)

- (X) ay isang TE kung X ay isang TE.

- Ang X op ay isang TE ay ang X ay isang TE at ang op ay alinman sa * (star operator ni Kleene), +
(Kleene's plus operator), o ? (opsyonal na operator)

- op X ay isang TE ay X ay isang TE at op ay alinman ! (negation operator), ^
(target na language extraction operator), _ (source language extraction operator), o ^_
(pinagmulan at target na switch operator).

- Ang X op Y ay isang TE ay X at Y ay mga TE at ang op ay alinman sa & (conjunction
operator), | (disjunction operator), || (composition operator), o - (pagbabawas
operator)

- Ang L x op y R ay isang TE kung ang L at R ay mga TE, ang x at y ay mga hanay ng simbolo at
op ay alinman sa => (dalawang antas na paghihigpit), <= (dalawang antas na pamimilit), o <=> (dalawang antas
paghihigpit at pamimilit).

- Ang X op L__R ay isang TE kung ang X, L at R ay mga TE at ang op ay alinman sa ^-> (pataas
kapalit), _-> (pababang kapalit), /-> (pakaliwa na kapalit) o ​​\-> (pakanan
kapalit). Higit pa rito, dapat tukuyin ng L at R ang automata (ibig sabihin, kung aling mga mapa ang kanilang mga string
sa kanilang sarili). Ang mga operator na ito ay tumutugma sa mga nagpapalit na operator ng Karttunen. Kung ang
arrow ay sinusundan ng isang tandang pananong (?), ang kapalit ay nagiging opsyonal.

- X << l ay isang TE kung X ay isang TE, at l ay alinman sa anyo
a o ang anyong a:b kung saan ang a at b ay iisang karakter o simbolo. Ang resulta ay a
transduser kung saan ang l ay malayang ipinasok sa X. Ang transduser ab << c halimbawa ay
katumbas ng c*ac*bc*.

- X op Y L1__R2, ... , LN__RN ay isang TE kung X,Y, L1 hanggang LN at R1
sa pamamagitan ng RN ay mga TE, at ang op ay alinman sa => (pangkalahatang paghihigpit), <= (pangkalahatang pamimilit), ^=>
(pangkalahatang paghihigpit sa ibabaw), ^<= (pangkalahatang pamimilit sa ibabaw), ^<=> (pangkalahatang ibabaw
paghihigpit at pamimilit), _=> (pangkalahatang malalim na paghihigpit), _<= (pangkalahatang malalim na pamimilit),
_<=> (pangkalahatang malalim na paghihigpit at pamimilit). (Ang mga operator na ito ay ipinatupad kasunod
isang mungkahi ni Anssi Yli-Jyra.)

- Ang "fname" ay isang TE. Binabasa ng compiler ang file na pinangalanang fname at lumiliko
ito sa isang transducer ng anyong line1|line2|line3|... kung saan ang linex ay ang x-th na linya ng
ang file. Ang lahat ng mga character maliban sa : at \ ay literal na binibigyang kahulugan (ibig sabihin, hindi bilang
mga operator). Ang TE na ito ay karaniwang ginagamit hal. upang basahin ang listahan ng morpema mula sa isang file.

-" " ay isang TE. Binabasa ng compiler ang isang pre-compiled transducer mula sa
ang file na pinangalanang fname. Ito

Karagdagang Mga Tampok

Nagsisimula ang mga komento sa simbolo na % at umaabot hanggang sa dulo ng linya. Ang mga blangko ay hindi pinapansin
maliban kung sila ay sinipi. Ang mga expression ay nagtatapos sa dulo ng isang linya maliban kung ang dulo ng linya
ay nauunahan ng backslash. Ang utos

#include "fname"

ay maaaring gamitin upang magpasok ng source code mula sa isang file na pinangalanang fname. Ang utos

RE >> "fname"

nag-iimbak ng regular na expression na RE sa file fname. Ang utos

#gumamit ng hopcroft

nagsasabi sa compiler na gamitin ang Hopcroft minimization algorithm mula ngayon, at

#gamitin ang default

babalik sa default na minimization algorithm (Brzozowski). Ang utos

Halimbawa

Narito ang isang halimbawa ng isang simpleng transducer program. Ipagpalagay na ang file na "adj-stems"
naglalaman ng dalawang linya

madali
huli
malaki

susuriin ng transduser na ito nang tama ang mga anyo ng pang-uri na madali, mas madali, pinakamadali at huli,
mamaya, at pinakabagong.

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

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

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

$R$ = $R$ at $R2$

$Stems$ = "adj-stems"

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

$S$ || $R$

EXIT STATUS

fst-compiler nagbabalik ng 0 maliban kung may nangyaring error.

Gumamit ng fst-compiler online gamit ang mga serbisyo ng onworks.net