.\" 2000 PTM Przemek Borys
.TH FLEX 1 "Kwiecie 1995" "Wersja 2.5"
.SH NAZWA
flex \- szybki generator analizatora leksykalnego
.SH SKADNIA
.B flex
.B [\-bcdfhilnpstvwBFILTV78+? \-C[aefFmr] \-ooutput \-Pprefix \-Sskeleton]
.B [\-\-help \-\-version]
.I [filename ...]
.SH WPROWADZENIE
Podrcznik ten opisuje narzdzie
.IR flex .
Jest ono przeznaczone do generowania programw, dokonywujcych dopasowywania
wzorcw na tekcie. Podrcznik zawiera zarwno sekcje przewodnikowe jak i
informacyjne.
.nf

    Opis
	krtki przegld moliwoci narzdzia

    Proste Przykady

    Format Pliku Wejciowego

    Wzorce
	rozszerzone wyraenia regularne uywane przez flex

    Sposb Dopasowywania Wejcia
	reguy okrelania, co dopasowano

    Akcje
	jak podawa, co robi po dopasowaniu wzorca

    Generowany Skaner
	szczegy o skanerze, tworzonym przez fleksa; jak kontrolowa rdo
	wejciowe 

    Warunki Startowe
        wprowadzanie do skanerw kontekstu i obsuga "mini-skanerw"

    Wielokrotne Bufory Wejciowe
	jak obsugiwa wiele rde wejciowych; jak skanowa z acuchw
	zamiast z plikw

    Reguy Koca Pliku
	specjalne reguy dopasowywane do koca wejcia

    Rne Makra
	og makr dostpnych z poziomu akcji

    Wartoci Dostpne Uytkownikowi
	og wartoci dostpnych z poziomu akcji

    czenie z Yacc
	czenie skanerw flex z analizatorami yacc

    Opcje
	opcje linii polece fleksa i dyrektywa "%option"

    Kwestie wydajnociowe
	jak przyspiesza skanery

    Generowanie Skanerw C++
	eksperymentalna waciwo generowania klas skanerw C++

    Niezgodnoci z Lex i POSIX
	czym flex rni si od standardw AT&T lex i POSIX lex

    Diagnostyka
	objanienie komunikatw o bdach, generowanych przez flex (lub
	skanery)

    Pliki
	pliki uywane przez flex

    Niedostatki / Bdy
	znane problemy fleksa

    Zobacz Take
	pozostaa dokumentacja i zwizane z fleksem narzdzia

    Autor
	informacja kontaktu z autorem

.fi
.SH OPIS
.I flex
jest narzdziem przeznaczonym do generowania
.I skanerw:
programw, rozpoznajcych wzorce leksykalne tekstu.
.I flex
odczytuje podane pliki wejciowe (lub stdin gdy nie s podane) i pobiera z
nich opis generowanego skanera. Opis skada si z par wyrae regularnych i
kodu C. Pary te nazywane s
.IR reguami .
.I flex
jako wyjcie generuje plik rdowy C o nazwie
.BR lex.yy.c .
Definiuje on funkcj
.B yylex().
Plik ten musi kompilowany i konsolidowany z bibliotek
.BR \-lfl .
Po uruchomieniu pliku wykonywalnego, program analizuje wejcie w
poszukiwaniu wyrae regularnych. Gdy tylko takie si znajdzie, wykonywany
jest odpowiedni fragment kodu C.
.SH PROSTE PRZYKADY
.PP
Przedstawmy teraz troch prostych przykadw aby oby si z uywaniem
.I flex.
Nastpujcy plik wejciowy
.I flex
okrela skaner, ktry za kadym razem gdy napotka acuch
"username", podmieni go nazw uytkownika:
.nf

    %%
    username    printf( "%s", getlogin() );

.fi
Domylnie tekst, ktrego 
.I flex
nie moe dopasowa jest kopiowany na wyjcie. Skaner bdzie wic kopiowa
swj plik wejciowy na wyjcie, podmieniajc wszelkie pojawienia "username".
W tym przykadzie wejcia mamy tylko jedn regu. Wzorcem jest "username",
a akcj jest "printf".
Znaki "%%" oznaczaj pocztek regu.
.PP
Oto kolejny prosty przykad:
.nf

            int num_lines = 0, num_chars = 0;

    %%
    \\n      ++num_lines; ++num_chars;
    .       ++num_chars;

    %%
    main()
            {
            yylex();
            printf( "# of lines = %d, # of chars = %d\\n",
                    num_lines, num_chars );
            }

.fi
Ten skaner zlicza liczb znakw i liczb linijek swojego wejcia (nie daje
adnego wyjcia, nie liczc kocowego raportu). Pierwsza linia deklaruje
dwie zmienne globalne, "num_lines" i "num_chars", ktre s dostpne
wewntrz funkcji
.B yylex()
i
.BR main() ,
zadeklarowanej po drugim "%%". Mamy tu dwie reguy: pierwsza
dopasowuje si do nowej linii ("\\n") i inkrementuje licznik linii oraz
znakw; druga dopasowuje si do dowolnego znaku innego ni nowa linia
(wyraenie regularne ".") i zwiksza licznik liczby znakw.
.PP
A oto troch bardziej skomplikowany przykad:
.nf

    /* skaner dla zabawkowego Pascalo-podobnego jzyka */

    %{
    /* potrzebujemy tego do wywoania atof() */
    #include <math.h>
    %}

    DIGIT    [0-9]
    ID       [a-z][a-z0-9]*

    %%

    {DIGIT}+    {
                printf( "Liczba cakowita: %s (%d)\\n", yytext,
                        atoi( yytext ) );
                }

    {DIGIT}+"."{DIGIT}*        {
                printf( "Liczba zmiennoprzecinkowa: %s (%g)\\n", yytext,
                        atof( yytext ) );
                }

    if|then|begin|end|procedure|function        {
                printf( "Sowo kluczowe: %s\\n", yytext );
                }

    {ID}        printf( "Identyfikator: %s\\n", yytext );

    "+"|"-"|"*"|"/"   printf( "Operator: %s\\n", yytext );

    "{"[^}\\n]*"}"     /* zjedz jednolinijkowe komentarze */

    [ \\t\\n]+          /* zjedz biae spacje */

    .           printf( "Nierozpoznany znak: %s\\n", yytext );

    %%

    main( argc, argv )
    int argc;
    char **argv;
        {
        ++argv, --argc;  /* pomi nazw programu */
        if ( argc > 0 )
                yyin = fopen( argv[0], "r" );
        else
                yyin = stdin;
        
        yylex();
        }

.fi
S to pocztki prostego skanera dla jzyka podobnego do Pascala. Rozrnia
poszczeglne rodzaje
.I tokenw
i informuje co zobaczy.
.PP
Szczegy tego przykadu zostan wyjanione w nastpnych sekcjach.
.SH FORMAT PLIKU WEJCIOWEGO
Plik wejciowy
.I fleksa
skada si z trzech sekcji, rozdzielanych liniami z acuchem
.BR %% :
.nf

    definicje
    %%
    reguy
    %%
    kod uytkownika

.fi
Sekcja
.I definicji
zawiera definicje prostych
.IR nazw ,
upraszczajcych pniej specyfikacj skanera. Zawiera te deklaracje
.IR "warunkw pocztkowych" ,
ktre objaniono w dalszej sekcji.
.PP
Definicje nazw maj posta:
.nf

    nazwa definicja

.fi
gdzie "nazwa" jest sowem, rozpoczynajcym si od litery lub podkrelenia ('_').
Pozostae znaki mog by literami, cyframi, podkreleniami lub mylnikami.
Definicja jest pobierana od momentu pojawienia si pierwszego znaku, ktry
nie jest spacj i ktry znajduje si za nazw. Definicja rozciga si do
koca linii. Do takiej definicji mona si nastpnie odwoywa przy uyciu
konwencji "{nazwa}", ktra jest automatycznie rozwijana w "(definicj)". Na
przykad
.nf

    DIGIT    [0-9]
    ID       [a-z][a-z0-9]*

.fi
definiuje "DIGIT" jako wyraenie regularne, pasujce do pojedynczej cyfry, a
"ID" jako wyraenie regularne odpowiadajce literze z doklejonymi ewentualnymi
literami lub cyframi.
Pniejsze odniesienie do
.nf

    {DIGIT}+"."{DIGIT}*

.fi
jest rwnowane
.nf

    ([0-9])+"."([0-9])*

.fi
i dopasowuje jedn lub wicej cyfr, po ktrych wystpuje kropka i ewentualnie
nastpne cyfry.
.PP
Sekcja
.I regu
wejcia
.I fleksa
zawiera szereg regu w postaci:
.nf

    wzorzec   akcja

.fi
Przed wzorcem nie moe wystpi wcicie, a akcja musi rozpoczyna si w tej samej
linii.
.PP
Dla dalszego opisu akcji patrz dalej.
.PP
W kocu, sekcja kodu uytkownika jest zwyczajnie kopiowana do
.B lex.yy.c
(bez dokonywania w niej zmian).
Jest to uywane do funkcji pomocniczych, ktre woaj lub s woane przez
skaner. Obecno tej sekcji jest opcjonalna; jeli nie istnieje, to ostatni
.B %%
pliku wejciowego moe by pominity.
.PP
Jeli w sekcjach definicji lub regu znajduje si jaki
.I wcity
(indentowany) tekst lub tekst ujty w
.B %{
i
.BR %} ,
to jest on kopiowany dosownie na wyjcie (po usuniciu %{}).
Znaki %{} musz pojawi si samodzielnie w liniach bez wci.
.PP
W sekcji regu, tekst wcity lub tekst %{}, znajdujcy si przed pierwsz
regu moe suy deklarowaniu zmiennych lokalnych dla procedury
skanujcej oraz (po deklaracjach) kodu, ktry ma by wywoywany za kadym
uruchomieniem procedury skanujcej.
Pozostae przypadki wcitego tekstu lub tekstu %{} sekcji regu s nadal
kopiowane na wyjcie, lecz ich znaczenie nie jest dokadnie zdefiniowane i
mog spowodowa bdy kompilacji (waciwo ta jest obecna dla zgodnoci z
.IR POSIX ;
zobacz niej inne tego typu waciwoci).
.PP
W sekcji definicji na wyjcie kopiowane s rwnie nie-wcite bloki 
komentarza, ujte midzy znaki "/*" i "*/".
.SH WZORCE
Wzorce wejciowe s pisane z uyciem rozszerzonego zestawu wyrae
regularnych. S to:
.nf

    x          dopasowuje znak 'x'
    .          dowolny znak poza now lini
    [xyz]      "klasa znakw"; w tym przypadku wzorzec odpowiada
                 zarwno 'x', 'y' jak i 'z'
    [abj-oZ]   "klasa znakw" z zakresem; odpowiada ona
                 'a', 'b', dowolnej literze od 'j' do 'o' oraz 'Z'
    [^A-Z]     zanegowana "klasa znakw" tj. dowolny znak poza 
                 wymienionymi w klasie. W tym wypadku dowolny znak oprcz
		 duych liter
    [^A-Z\\n]  dowolny znak oprcz duych liter lub nowej linii
    r*         zero lub wicej r'w, gdzie r jest wyraeniem regularnym
    r+         jeden lub wicej r'w
    r?         zero lub jeden r (tj. "opcjonalny r")
    r{2,5}     od dwu do piciu r
    r{2,}      dwa lub wicej r
    r{4}       dokadnie 4 r
    {nazwa}    rozwinicie definicji "nazwa" (patrz wyej)
    "[xyz]\\"foo"
               acuch literalny: [xyz]"foo
    \\X        Jeli X to 'a', 'b', 'f', 'n', 'r', 't' lub 'v',
		 to nastpuje interpretacja ANSI-C \\x. W przeciwnym
		 wypadku uywany jest literalny 'X' (uywane do cytowania
		 operatorw--np. '*').
    \\0        znak NUL (kod ASCII 0)
    \\123      znak o wartoci semkowej 123
    \\x2a      znak o wartoci szesnastkowej 2a
    (r)        dopasuj r; nawiasy s uywane do przeciania priorytetw
	         (patrz niej)


    rs         wyraenie regularne r, za ktrym nastpuje wyraenie
		 regularne s; nazywa si to "czeniem"


    r|s        r lub s


    r/s        r, lecz tylko jeli za nim nastpuje s. Tekst dopasowywany
		 przez s jest zaczany do okrelania czy ta regua miaa
		 "najdusze dopasowanie", lecz potem jest zwracany do
		 wejcia przed wykonaniem akcji. Tak wic akcja widzi tylko
		 tekst dopasowany przez r. Ten rodzaj wzorca jest nazywany
		 "doklejonym kontekstem". (Istniej pewne kombinacje r/s,
		 ktrych flex nie potrafi waciwie dopasowa; zobacz uwagi
		 w dalszej sekcji Niedostatki / Bdy w okolicach
		 "niebezpiecznego kontekstu doklejonego".)
    ^r         r, lecz tylko na pocztku linii (tj. zaraz po rozpoczciu
		 skanowania, lub po wyskanowaniu nowej linii).
    r$         r, lecz tylko na kocu linii (tj. tu przed now lini).
		 Rwnowane "r/\\n".

	       Zauwa, e notacja nowej linii fleksa jest dokadnie tym,
	       co byo uywane jako '\\n' przez kompilator C, uyty do 
	       kompilacji fleksa; w praktyce na niektrych systemach DOS
	       musisz wyfiltrowa \\r lub jawnie uywa r/\\r\\n zamiast
	       "r$".


    <s>r       r, lecz tylko dla warunku pocztkowego s (zobacz niej
		 dyskusj o warunkach pocztkowych)
    <s1,s2,s3>r
               to samo, lecz jeli dowolny z warunkw pocztkowych s1,
                 s2 lub s3
    <*>r       r w dowolnym warunku pocztkowym, nawet wykluczajcym


    <<EOF>>    koniec pliku
    <s1,s2><<EOF>>
               koniec pliku w warunkach pocztkowych s1 lub s2

.fi
Zauwa, e w obrbie klasy znakw wszystkie operatory wyrae regularnych
trac swoje znaczenie specjalne (nie liczc cytowania '\\', znakw klasy '-',
']' oraz '^' na pocztku klasy).
.PP
Wymienione wyej wyraenia regularne s pogrupowane zgodnie z priorytetami,
liczc od najwyszego do najniszego (z gry na d). Te, ktre zgrupowano
razem maj jednakowy priorytet. Na przykad,
.nf

    foo|bar*

.fi
jest rwnowane
.nf

    (foo)|(ba(r*))

.fi
poniewa operator '*' ma wyszy priorytet ni czenie, a czenie ma wyszy
priorytet ni alternatywa ('|'). Wzorzec ten pasuje wic
.I albo
do acucha "foo"
.I albo
do "ba", po ktrym moe nastpi zero lub wicej r.
W celu dopasowania "foo" lub zero lub wicej "bar"'w, uyj:
.nf

    foo|(bar)*

.fi
a eby dopasowa zero lub wicej "foo"-lub-"bar"'w:
.nf

    (foo|bar)*

.fi
.PP
Poza znakami i zakresami znakw, klasy znakw mog te zawiera specjalne
.I wyraenia.
Wyraenia te s ujmowane w ograniczniki
.B [:
i
.B :]
(ktre musz dodatkowo pojawia si wewntrz '[' i ']' klasy znakw; inne
elementy w klasie znakw te mog si pojawi).
Prawidowymi wyraeniami s:
.nf

    [:alnum:] [:alpha:] [:blank:]
    [:cntrl:] [:digit:] [:graph:]
    [:lower:] [:print:] [:punct:]
    [:space:] [:upper:] [:xdigit:]

.fi
Wyraenia te oznaczaj zestaw znakw, odpowiadajcy rwnowanemu standardowi
funkcji 
.B isXXX
jzyka C. Przykadowo
.B [:alnum:]
oznacza wszystkie znaki, dla ktrych
.B isalnum(3)
zwraca prawd - tj. wszelkie znaki alfabetyczne lub numeryczne.
Niektre systemy nie udostpniaj
.BR isblank(3) .
Flex definiuje
.B [:blank:]
jako spacj lub tabulacj.
.PP
Na przykad nastpujce klasy s sobie rwnowane:
.nf

    [[:alnum:]]
    [[:alpha:][:digit:]
    [[:alpha:]0-9]
    [a-zA-Z0-9]

.fi
Jeli twj skaner jest niewraliwy na wielko znakw (flaga
(flaga
.BR \-i ),
to
.B [:upper:]
i
.B [:lower:]
s rwnowane
.BR [:alpha:] .
.PP
Troch uwag o wzorcach:
.IP -
Zanegowana klasa znakw, taka jak wyej wymienione przykadowe "[^A-Z]"
.IR "bdzie pasowa do nowej linii" ,
chyba e "\\n" (lub rwnowana sekwencja specjalna) jest jednym z jawnie
obecnych w klasie znakw (np. "[^A-Z\\n]"). Odbiega to od sposobu traktowania
zanegowanych klas znakw przez inne narzdzia operujce na wyraeniach
regularnych, lecz niestety niespjno jest ugruntowana historycznie.
Dopasowywanie nowej linii oznacza, e wzorzec w rodzaju [^"]* moe dopasowa
si do caego wejcia, chyba e istnieje w nim drugi cudzysw.
.IP -
Regua moe mie najwyej jedn instancj dowizanego kontekstu (operatory
'/' lub '$'). Wzorce warunku pocztkowego '^' oraz "<<EOF>>" mog pojawi
si tylko na pocztku wzorca i dodatkowo, podobnie jak '/' i '$', nie mog
by grupowane w nawiasy. Znak '^', ktry nie pojawia si na pocztku reguy,
lub '$', nie znajdujcy si na kocu traci swoje specjalne znaczenie.
.IP
Nastpujce wzorce s niedozwolone:
.nf

    foo/bar$
    <sc1>foo<sc2>bar

.fi
Zauwa, e pierwszy z nich moe by zapisany jako "foo/bar\\n".
.IP
Nastpujce wzorce powoduj, e '$' lub '^' s traktowane jak zwyke znaki:
.nf

    foo|(bar$)
    foo|^bar

.fi
Jeli oczekiwan wartoci jest "foo" lub "bar-z-now-lini", to uy mona
nastpujcego wzorca (akcja specjalna | jest wyjaniona niej):
.nf

    foo      |
    bar$     /* tu rozpoczyna si akcja */

.fi
Podobna sztuczka powinna zadziaa dla dopasowywania foo lub
bar-na-pocztku-linii.
.SH JAK DOPASOWYWANE JEST WEJCIE
Po uruchomieniu skanera, analizuje on swoje wejcie w poszukiwaniu acuchw
odpowiadajcych ktremu z jego wzorcw. Jeli znajdzie wicej ni jeden
pasujcy wzorzec, wybiera ten, ktry pasuje do najwikszej iloci tekstu (w
reguach z dowizanym kontekstem oznacza to te dugo czci dowizanej,
mimo faktu, e zostanie ona zwrcona na wejcie. Jeli znajdzie dwa lub
wicej dopasowa o tej samej dugoci, to wybierana jest pierwsza regua.
.PP
Po okreleniu dopasowania, tekst dopasowania (zwany dalej
.IR tokenem )
jest udostpniany we wskanikowej zmiennej globalnej
.BR yytext ,
a jego dugo w globalnej zmiennej cakowitej
.BR yyleng .
Wykonywana jest te odpowiadajca wzorcowi
.I akcja
(szczegowy opis akcji jest dalej), a nastpnie pozostaa cz wejcia
jest dopasowywana do kolejnego wzorca.
.PP
Jeli dopasowanie nie zostanie znalezione, wykonana zostanie
.IR "regua domylna" :
nastpny znak wejcia jest uwaany za dopasowany i kopiowany na stdout.
Tak wic najprostszym poprawnym plikiem wejciowym
.I fleksa
jest:
.nf

    %%

.fi
Generuje to skaner, ktry po prostu kopiuje swoje wejcie (jeden znak naraz)
na wyjcie.
.PP
Zauwa, e
.B yytext
moe by definiowane na dwa sposoby: jako 
.I wskanik
do znakw lub jako
.I tablica
znakw.
Uywanie konkretnej definicji mona kontrolowa, wczajc do pliku
wejciowego w pierwszej sekcji specjalne dyrektywy
.B %pointer
lub
.BR %array .
Domylnie uywana jest dyrektywa
.BR %pointer ,
chyba e uywa si opcji
.B -l
zgodnoci z leksem i wtedy 
.B yytext
staje si tablic.
Korzyci z uywania 
.B %pointer
jest zwikszenie szybkoci skanowania i zlikwidowanie przepenie bufora
przy dopasowywaniu duych tokenw (chyba e zabraknie pamici dynamicznej).
Wad jest ograniczenie sposobu modyfikowania przez akcje zmiennej
.B yytext
(zobacz nastpn sekcj) i to, e wywoania funkcji
.B unput()
niszcz aktualn zawarto
.BR yytext ,
co moe przyprawia o bl gowy podczas portowania skanerw midzy
rnymi wersjami 
.IR lex .
.PP
Zalet
.B %array
jest moliwo modyfikowania
.B yytext
i to, e woanie
.B unput()
nie niszczy
.BR yytext .
Poza tym, istniejce programy
.I lex
czasami zewntrznie zagldaj do
.B yytext
przy uyciu deklaracji w postaci:
.nf
    extern char yytext[];
.fi
Definicja ta jest bdna przy uyciu z
.BR %pointer ,
lecz prawidowa dla
.BR %array .
.PP
.B %array
definiuje
.B yytext
jako tablic
.B YYLMAX
znakw, co domylnie jest do du wartoci. Moesz zmienia rozmiar przez
proste #definiowanie
.B YYLMAX
na inn warto w pierwszej sekcji wejciowego pliku
.IR fleksa .
Jak wspomniano wyej, dla
.B %pointer
yytext wzrasta dynamicznie, by przechowywa due tokeny. Chocia
oznacza to, e skaner
.B %pointer
moe zbiera due tokeny (jak np. cae bloki komentarzy), to zakop sobie w
pamici, e za kadym razem gdy skaner zmienia rozmiar
.B yytext
to musi rwnie reskanowa cay token od pocztku, wic moe si to okaza
powolne.
.B yytext
w chwili obecnej
.I nie
zwiksza dynamicznie rozmiaru jeli wywoanie
.B unput()
powoduje wepchnicie z powrotem zbyt duego bloku tekstu. Zamiast
tego pojawia si bd wykonania.
.PP
Zauwa te, e postaci
.B %array
nie mona uywa z klasami skanerw C++
(zobacz opcj
.B c++
poniej).
.SH AKCJE
Kady wzorzec reguy ma odpowiadajc mu akcj, ktra moe by dowoln
instrukcj jzyka C. Wzorzec koczy si na pierwszym niecytowanym znaku
biaej spacji; reszta linijki jest akcj. Jeli akcja jest pusta, to token
wejciowy jest zwyczajnie odrzucany. Na przykad oto program, kasujcy
wszystkie pojawienia acucha "wytnij mnie":
.nf

    %%
    "wytnij mnie"

.fi
(Wszystkie pozostae znaki wejcia zostan skopiowane na wyjcie, gdy
dopasuj si do reguy domylnej.)
.PP
Oto program, ktry kompresuje wielokrotne spacje i tabulacje do pojedynczej
spacji. Program wycina te wszystkie biae spacje z koca linii:
.nf

    %%
    [ \\t]+        putchar( ' ' );
    [ \\t]+$       /* ignoruj ten token */

.fi
.PP
Jeli akcja zawiera znak '{', to rozciga si ona a do zamykajcego '}',
nawet na przestrzeni wielu linii.
.I flex 
ma pewne wiadomoci o acuchach C i komentarzach, wic nie zostanie
ogupione przez klamry, ktre mog si w nich znajdowa. Poza tym dozwolone
s te akcje, ktre zaczynaj si od
.B %{
i zawieraj tekst akcji a do nastpnego
.B %}
(niezalenie od zwyczajnych klamer wewntrz akcji).
.PP
Akcja skadajca si wycznie z pionowej kreski ('|') oznacza
"taka sama, jak akcja nastpnej reguy". Dla zobrazowania patrz niej.
.PP
Akcje mog zawiera kod C, wczajc w to instrukcje
.BR return ,
przeznaczone do zwracania wartoci do procedury, ktra wywoaa
.BR yylex() .
Przy kadym wywoaniu
.B yylex()
kontynuuje przetwarzanie tokenw od miejsca, w ktrym ostatnio przerwa
a do osignicia koca pliku lub wywoania return.
.PP
Akcje mog spokojnie modyfikowa zmienn
.BR yytext ;
nie mog jej jednak wydua (dodawanie znakw do jej koca nadpisze dalsze
znaki strumienia wejciowego). Odmiennie jest natomiast przy uywaniu
.B %array
(patrz wyej); wtedy
.B yytext
mona spokojnie modyfikowa w dowolny sposb.
.PP
Podobnie do powyszej zmiennej, mona spokojnie modyfikowa
.BR yyleng ,
lecz naley uwaa by nie robi tego jeli akcja uywa 
.B yymore()
(patrz niej).
.PP
Istnieje wiele dyrektyw specjalnych, ktre mona zawrze w akcji:
.IP -
.B ECHO
kopiuje wejcie yytext na wyjcie skanera.
.IP -
.B BEGIN
z doklejon nazw warunku pocztkowego umieszcza skaner w odpowiednim
warunku pocztkowym (patrz niej).
.IP -
.B REJECT
Kieruje skaner na dziaanie w "drugiej najlepszej" regule, ktra zostaa
dopasowana do wzorca wejciowego (lub prefiksu wejcia). Regua jest
wybierana wedug zasad opisanych w "Jak dopasowywane jest wejcie", po czym
nastpuje odpowiednie ustawienie
.B yytext
oraz
.BR yyleng . 
Moe to by albo ta regua, ktra dopasowaa si do takiej samej iloci
tekstu, jak poprzednia, lecz wystpia pniej w pliku wejciowym fleksa,
albo taka, ktra dopasowaa si do mniejszej iloci tekstu.
Na przykad, nastpujcy przykad bdzie liczy sowa wejciowe i woa
funkcj special() dla kadego "frob":
.nf

            int word_count = 0;
    %%

    frob        special(); REJECT;
    [^ \\t\\n]+   ++word_count;

.fi
Bez dyrektywy
.BR REJECT ,
sowa "frob" wejcia nie byyby zliczane jako sowa, gdy skaner normalnie
wykonuje tylko jedn akcj na token. Dozwolonych jest wiele komend
.BR REJECT ,
z ktrych kada wyszukuje najbardziej pasujcego nastpc. Na przykad
poniszy skaner skanujc token "abcd" zapisze na wyjciu "abcdabcaba":
.nf

    %%
    a        |
    ab       |
    abc      |
    abcd     ECHO; REJECT;
    .|\\n     /* zjedz nietrafione znaki */

.fi
(Pierwsze trzy reguy maj wspln akcj z czwart, gdy uywaj akcji specjalnej '|'.)
.B REJECT
jest do kosztown waciwoci jeli chodzi o wydajno skanera; jeli
jest uywane w ktrej z akcji skanera, to spowolni
.I wszystkie
dopasowania skanera. Co wicej,
.B REJECT
nie moe by uywany z opcjami
.I -Cf
i
.I -CF
(zobacz niej).
.IP
Zauwa te, e, w przeciwiestwie do innych akcji specjalnych,
.B REJECT
jest
.IR odgazieniem ;
kod akcji wystpujcy bezporednio po nim
.I nie
zostanie wykonany.
.IP -
.B yymore()
mwi skanerowi, e przy nastpnym dopasowaniu reguy, odpowiadajcy token
powinien by
.I doklejony
do biecej wartoci
.BR yytext .
Na przykad, przy wejciu "mega-kludge", poniszy przykad na wyjciu
wypisze "mega-mega-kludge":
.nf

    %%
    mega-    ECHO; yymore();
    kludge   ECHO;

.fi
Pierwsze "mega-" jest dopasowane i wydrukowane na wyjcie. Nastpnie
dopasowane jest "kludge", lecz poprzednie "mega-" wci znajduje si na
pocztku
.B yytext
i komenda
.B ECHO
dla "kludge" wydrukuje w rzeczywistoci "mega-kludge".
.PP
Dwie uwagi na temat
.BR yymore() .
Po pierwsze,
.B yymore()
zaley od wartoci
.IR yyleng ,
odzwierciedlajcej rozmiar biecego tokenu. Zatem jeli uywasz 
.BR yymore() ,
nie modyfikuj tej zmiennej.
Po drugie, obecno
.B yymore()
w akcji skanera wpywa na pewne pogorszenie wydajnoci w szybkoci
dokonywania przez skaner dopasowa.
.IP -
.B yyless(n)
zwraca wszystkie poza pierwszymi
.I n
znakami biecego tokenu z powrotem do strumienia wejciowego, skd
zostan one powtrnie przeskanowane przy dopasowywaniu nastpnego wzorca.
.B yytext
i
.B yyleng
s odpowiednio dostrajane (tj.
.B yyleng
bdzie teraz rwne
.IR n ).
Na przykad, przy wejciu "foobar", nastpujcy kod wypisze "foobarbar":
.nf

    %%
    foobar    ECHO; yyless(3);
    [a-z]+    ECHO;

.fi
Podanie
.B yyless
argumentu zerowego powoduje reskanowanie caego obecnego acucha
wejciowego. O ile nie zmienisz sposobu kolejnego przetwarzania przez skaner
wejcia (przy uyciu np.
.BR BEGIN ),
spowoduje to nieskoczon ptl.
.PP
Zwr uwag, e
.B yyless
jest makrem i moe by uywane tylko z pliku wejciowego fleksa, a nie z
innych plikw rdowych.
.IP -
.B unput(c)
wstawia znak
.I c
z powrotem do strumienia wejciowego. Bdzie to nastpny skanowany znak.
Ponisza akcja pobierze biecy token i spowoduje, e zostanie reskanowany
po ujciu w nawiasy.
.nf

    {
    int i;
    /* Kopiuj yytext, gdy unput() niszczy jego zawarto */
    char *yycopy = strdup( yytext );
    unput( ')' );
    for ( i = yyleng - 1; i >= 0; --i )
        unput( yycopy[i] );
    unput( '(' );
    free( yycopy );
    }

.fi
Zwr uwag, e skoro kady
.B unput()
wstawia dany znak na
.I pocztek
strumienia, to wstawianie znakw musi odbywa si tyem-na-przd.
.PP
Wanym potencjalnym problemem uywania
.B unput()
jest fakt, e jeli uywasz dyrektywy
.B %pointer
(domylne), wywoanie
.B unput()
.I niszczy
zawarto
.I yytext,
poczynajc od znaku najbardziej z prawej, idc w lewo za kadym wywoaniem.
Jeli potrzebujesz zachowa warto yytext po uyciu tej funkcji,
(jak w powyszym przykadzie),
musisz skopiowa jej zawarto gdzie indziej lub zbudowa skaner z uyciem
.BR %array .
.PP
Na koniec, zauwa te, e nie moesz wstawia tak znakw
.BR EOF .
Nie mona t metod zaznacza koca pliku w strumieniu.
.IP -
.B input()
odczytuje nastpny znak ze strumienia wejciowego. Na przykad, ponisze jest
jednym ze sposobw poerania komentarzy jzyka C:
.nf

    %%
    "/*"        {
                register int c;

                for ( ; ; )
                    {
                    while ( (c = input()) != '*' &&
                            c != EOF )
                        ;    /* zeryj tekst komentarza */

                    if ( c == '*' )
                        {
                        while ( (c = input()) == '*' )
                            ;
                        if ( c == '/' )
                            break;    /* znalazem koniec */
                        }

                    if ( c == EOF )
                        {
                        error( "EOF w komentarzu" );
                        break;
                        }
                    }
                }

.fi
(Zauwa, e jeli skaner jest skompilowany z uyciem
.BR C++ ,
to
.B input()
nazywa si
.BR yyinput() .
Jest tak w celu zapobieenia zderzeniu nazwy ze strumieniem
.B C++
poprzez nazw
.IR input .)
.IP -
.B YY_FLUSH_BUFFER
wyprnia wewntrzny bufor skanera. Przy nastpnym razie gdy skaner bdzie
dopasowywa si do tokenu, najpierw napeni na nowo bufor z uyciem
.B YY_INPUT
(zobacz niej Generowany Skaner).  Akcja ta jest szczeglnym przypadkiem
bardziej oglnej funkcji
.BR yy_flush_buffer() ,
opisanej niej w sekcji Wielokrotne Bufory Wejciowe.
.IP -
.B yyterminate()
moe by uywane zamiast instrukcji return akcji. Koczy dziaanie skanera i
zwraca 0 do wywoujcego skaner, wskazujc, e "wszystko zrobione".
Domylnie,
.B yyterminate()
jest wywoywane rwnie po napotkaniu koca pliku. Jest to makro i moe by
redefiniowane.
.SH GENEROWANY SKANER
Wynikiem dziaania fleksa jest plik
.BR lex.yy.c ,
zawierajcy procedur skanujc
.B yylex()
oraz zestaw tablic, uywanych przez niego do dopasowywania tokenw i par
procedur i makr. Domylnie
.B yylex()
jest deklarowany jako
.nf

    int yylex()
        {
        ... tu rne definicje i akcje ...
        }

.fi
(Jeli twoje rodowisko obsuguje prototypy funkcji, to bdzie to
"int yylex( void )".) Definicj t mona zmieni definiujc
makro "YY_DECL". Na przykad
.nf

    #define YY_DECL float lexscan( a, b ) float a, b;

.fi
informuje fleksa, by nada procedurze skanujcej nazw
.I lexscan
i e procedura ta ma zwraca typ float i pobiera dwa argumenty (te typu
float). Zwr uwag, e jeli podajesz argumenty procedurze skanujcej,
uywajc deklaracji w niezaprototypowanym stylu K&R, musisz zakoczy
definicj rednikiem (;).
.PP
Przy kadym wywoaniu
.BR yylex() ,
nastpuje skanowanie tokenw z globalnego pliku wejciowego
.I yyin
(ktry domylnie wskazuje na stdin). Wczytywanie trwa a do osignicia
koca pliku, lub a do napotkania w ktrej z akcji instrukcji
.IR return .
.PP
Jeli skaner osiga koniec pliku, to kolejne wywoania s niezdefiniowane.
Sposobem na skorygowanie tego jest przekierowanie
.I yyin
na nowy plik wejciowy (w tym wypadku skanowanie nastpuje z nowego pliku)
lub wywoanie
.BR yyrestart() .
.B yyrestart()
pobiera jeden argument: wskanik
.B FILE *
(ktry moe by nil, jeli ustawie
.B YY_INPUT
na skanowanie ze rda innego ni
.I yyin),
i inicjalizuje
.I yyin
na pocztek tego pliku. W zasadzie nie ma rnicy midzy zwykym
przypisaniem
.I yyin
do nowego pliku i uyciem
.BR yyrestart() ;
Procedura ta jest dostpna z uwagi na kompatybilno z poprzednimi wersjami
.IR flex ,
a take dlatego, e moe by uywana do przeczania plikw wejciowych w
rodku skanowania.
Moe by te uywana do porzucania biecego bufora wejciowego poprzez
wywoanie z argumentem
.IR yyin ;
lepszym rozwizaniem jest jednak uycie
.B YY_FLUSH_BUFFER
(patrz wyej).
Zauwa, e
.B yyrestart()
.I nie
resetuje warunku pocztkowego na
.B INITIAL
(zobacz niej Warunki Pocztkowe).
.PP
Jeli
.B yylex()
koczy skanowanie z powodu wywoania instrukcji
.I return
w jednej z akcji, skaner moe by woany ponownie i wznowi dziaanie tam,
gdzie skoczy.
.PP
Domylnie (i dla celw wydajnoci) skaner zamiast pojedynczych
.I getc()
wykonuje odczyty blokowe z
.IR yyin .
Sposb pobierania wejcia moe by kontrolowany przez definiowanie makra
.BR YY_INPUT .
Sekwencja wywoujca YY_INPUT to "YY_INPUT(buf,wynik,max_rozmiar)".  Jej
wynikiem jest umieszczenie co najwyej
.I max_rozmiar
znakw w tablicy znakowej
.I buf
i zwrcenie w zmiennej cakowitej
.I wynik
albo liczby wczytanych znakw albo staej YY_NULL (0 w systemach uniksowych),
okrelajcej EOF. Domylnie, YY_INPUT czyta z globalnego wskanika "yyin".
.PP
Przykadowa definicja YY_INPUT (w sekcji definicji pliku wejciowego):
.nf

    %{
    #define YY_INPUT(buf,wynik,max_rozmiar) \\
        { \\
        int c = getchar(); \\
        wynik = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \\
        }
    %}

.fi
Definicja ta zmieni przetwarzanie wejcia tak, by naraz pojawia si tylko
jeden znak.
.PP
W momencie, gdy skaner uzyska od YY_INPUT warunek koca pliku, to woa
funkcj
.BR yywrap() .
Jeli
.B yywrap()
zwrci zero, to zakada, e funkcja posza dalej i skonfigurowaa
.I yyin
do wskazywania na nowy plik, a skanowanie trwa dalej. Jeli zwrci warto
niezerow, skaner koczy dziaanie, zwracajc 0 do funkcji wywoujcej.
Zauwa, e w kadym przypadku warunek pocztkowy pozostaje niezmieniony;
.I nie
przechodzi on w
.BR INITIAL .
.PP
Jeli nie chcesz podawa wasnej wersji
.BR yywrap() ,
to musisz albo uy opcji
.B %option noyywrap
(wtedy skaner zachowuje si, jakby 
.B yywrap()
zwracao 1), albo konsolidowa z
.BR \-lfl ,
uzyskujc tak domyln wersj funkcji, zawsze zwracajcej 1.
.PP
Do skanowania z buforw pamiciowych (a nie z plikw) przeznaczone s trzy
procedury:
.BR yy_scan_string() ,
.B yy_scan_bytes()
oraz
.BR yy_scan_buffer() .
Zobacz niej dyskusj w sekcji Wielokrotne Bufory Wejciowe.
.PP
Swoje wyjcie
.B ECHO
skaner zapisuje do globalnego strumienia
.I yyout
(domylnie stdout), ktry mona przedefiniowa dziki zwykemu
przypisaniu tej zmiennej do innego wskanika
.BR FILE .
.SH WARUNKI POCZTKOWE
.I flex
daje mechanizm warunkowej aktywacji regu. Reguy rozpoczynajce si od
"<sc>" wcz si tylko jeli skaner znajduje si w warunku pocztkowym
"sc". Na przykad,
.nf

    <STRING>[^"]*        { /* zjedz ciao acucha ... */
                ...
                }

.fi
bdzie aktywne tylko jeli skaner jest w warunku pocztkowym "STRING", a 
.nf

    <INITIAL,STRING,QUOTE>\\.        { /* obsu cytowanie ... */
                ...
                }

.fi
bdzie aktywne tylko jeli obecnym warunkiem pocztkowym jest albo
"INITIAL", albo "STRING" albo "QUOTE".
.PP
Warunki pocztkowe s deklarowane w sekcji definicji wejcia przy uyciu
niewcitych linii, zaczynajcych si od
.B %s
lub
.BR %x ,
za ktrymi nastpuje lista nazw.
Pierwsza posta deklaruje
.I wczajce
warunki pocztkowe, a druga
.IR wykluczajce . 
Warunek pocztkowy wcza si przy uyciu akcji
.BR BEGIN .
Reguy uywajce danego warunku pocztkowego bd aktywne a do wywoania
nastpnej akcji
.BR BEGIN .
Jeli warunek pocztkowy jest
.I wczajcy ,
to reguy bez warunkw pocztkowych bd rwnie aktywne.
Jeli jest
.IR wykluczajcy ,
to wykonywane bd
.I tylko
reguy odpowiadajce warunkowi pocztkowemu.
Zestaw regu opierajcych si na tym samym wykluczajcym warunku
pocztkowym, opisuje skaner, ktry jest niezaleny od wszelkich innych regu
wejcia fleksa.
Z uwagi na to, warunki wykluczajce uatwiaj tworzenie "mini-skanerw",
ktre skanuj czci wejcia, odmienne syntaktycznie od reszty (np.
komentarze).
.PP
W rozrnieniu warunkw wczajcych i wykluczajcych istnieje wci pewna
niejasno: oto przykad, ilustrujcy ich powizanie. Zestaw regu:
.nf

    %s przyklad
    %%

    <przyklad>foo  rob_cos();

    bar            cos_innego();

.fi
jest rwnowany
.nf

    %x przyklad
    %%

    <przyklad>foo   rob_cos();

    <INITIAL,przyklad>bar    cos_innego();

.fi
Bez uycia kwalifikatora
.BR <INITIAL,przyklad> ,
wzorzec
.I bar
w drugim przykadzie nie byby aktywny (tj. nie dopasowaby si) w warunku
pocztkowym
.BR przyklad .
Jeli uylibymy do kwalifikowania \fIbar\fR tylko
.BR <przyklad> ,
to byoby aktywny tylko w warunku pocztkowym
.BR przyklad , 
ale nie w 
.BR INITIAL ,
podczas gdy w pierwszym przykadzie jest aktywny w obydwu, gdy
warunek pocztkowy
.B przyklad
jest w nim
.I wczajcy
.BR (%s) .
.PP
Zauwa te, e specjalny specyfikator
.B <*>
pasuje do dowolnego warunku pocztkowego. Tak wic, powysze mona zapisa
rwnie nastpujco:
.nf

    %x przyklad
    %%

    <przyklad>foo   rob_cos();

    <*>bar    cos_innego();

.fi
.PP
Regua domylna (wykonywania
.B ECHO
na kadym niedopasowanym znaku) pozostaje aktywna w warunkach pocztkowych.
Jest to w sumie rwnowane:
.nf

    <*>.|\\n     ECHO;

.fi
.PP
.B BEGIN(0)
zwraca do stanu oryginalnego, w ktrym aktywne s tylko reguy bez warunku
pocztkowego. Stan ten jest oznaczany jako warunek pocztkowy "INITIAL",
wic mona go ustawi rwnie poprzez
.BR BEGIN(INITIAL) .
(Nawiasy wok nazwy warunku pocztkowego nie s wymagane, lecz s w dobrym
tonie.)
.PP
Akcje
.B BEGIN
mog by podawane jako kod wcity na pocztku sekcji regu. Na przykad,
nastpujcy kod spowoduje, e skaner wejdzie w warunek pocztkowy "SPECIAL"
za kadym razem, gdy wywoane zostanie
.B yylex()
a zmienna globalna
.I enter_special
bdzie ustawiona na prawd:
.nf

            int enter_special;

    %x SPECIAL
    %%
            if ( enter_special )
                BEGIN(SPECIAL);

    <SPECIAL>blahblahblah
    ...i kolejne ruguy...

.fi
.PP
Dla zilustrowania wykorzystania warunkw pocztkowych, oto skaner, ktry
daje dwie rne interpretacje acucha "123.456". Domylnie bdzie traktowa
go jako 3 elementy, liczb cakowit 123, kropk i liczb cakowit "456".
Jeli jednak acuch zostanie poprzedzony lini z napisem
"expect-floats", to bdzie go traktowa jako pojedynczy element
zmiennoprzecinkowy (123.456).
.nf

    %{
    #include <math.h>
    %}
    %s expect

    %%
    expect-floats        BEGIN(expect);

    <expect>[0-9]+"."[0-9]+      {
                printf( "znalazem zmiennoprzecinkow, = %f\\n",
                        atof( yytext ) );
                }
    <expect>\\n           {
                /* jest to koniec linii, wic
                 * potrzebujemy kolejnego "expect-number"
                 * przed rozpoznawaniem dalszych liczb
                 */
                BEGIN(INITIAL);
                }

    [0-9]+      {
                printf( "znalazem cakowit, = %d\\n",
                        atoi( yytext ) );
                }

    "."         printf( "znalazem kropk\\n" );

.fi
Oto skaner, ktry rozpoznaje komentarze C podczas zliczania linii.
.nf

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^*\\n]*        /* zjedz wszystko, co nie jest '*'     */
    <comment>"*"+[^*/\\n]*   /* zjedz '*'-ki, po ktrych nie ma '/' */
    <comment>\\n             ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

.fi
Skaner ten moe mie problemy z dopasowaniem maksymalnej iloci tekstu w
kadej z regu. Oglnie, przy pisaniu szybkich skanerw, prbuj dopasowywa
w kadej regule tyle, ile si da.
.PP
Zauwa, e nazwy warunkw pocztkowych s tak naprawd wartociami
cakowitymi i mog by tak przechowywane. Tak wic powysze mona
rozwin w nastpujcym stylu:
.nf

    %x comment foo
    %%
            int line_num = 1;
            int comment_caller;

    "/*"         {
                 comment_caller = INITIAL;
                 BEGIN(comment);
                 }

    ...

    <foo>"/*"    {
                 comment_caller = foo;
                 BEGIN(comment);
                 }

    <comment>[^*\\n]*        /* zjedz wszystko co nie jest '*'   */
    <comment>"*"+[^*/\\n]*   /* zjedz '*', po ktrych nie ma '/' */
    <comment>\\n             ++line_num;
    <comment>"*"+"/"        BEGIN(comment_caller);

.fi
Co wicej, moesz mie dostp do biecego warunku pocztkowego poprzez
makro
.B YY_START
(o wartoci cakowitej).
Na przykad, powysze przypisania do
.I comment_caller
mona by zapisa jako
.nf

    comment_caller = YY_START;

.fi
Flex jako alias do
.B YY_START
daje
.B YYSTATE
(gdy jest to nazwa, uywana przez AT&T
.IR lex ).
.PP
Zauwa, e warunki pocztkowe nie maj wasnej przestrzeni nazw; %s i %x-y
deklaruj nazwy podobnie jak #define.
.PP
Na deser, oto przykad dopasowywania cytowanych w stylu C napisw przy
uyciu wykluczajcych warunkw pocztkowych, wcznie z rozwijanymi
sekwencjami specjalnymi (lecz bez sprawdzania czy acuch nie jest za
dugi):
.nf

    %x str

    %%
            char string_buf[MAX_STR_CONST];
            char *string_buf_ptr;


    \\"      string_buf_ptr = string_buf; BEGIN(str);

    <str>\\"        { /* zobaczyem zamykajcy cytat - gotowe */
            BEGIN(INITIAL);
            *string_buf_ptr = '\\0';
            /* zwr typ i warto tokenu staej acuchowej do
             * analizatora
             */
            }

    <str>\\n        {
            /* bd - niezakoczona staa acuchowa */
            /* generuj komunikat o bdzie */
            }

    <str>\\\\[0-7]{1,3} {
            /* semkowa sekwencja specjalna */
            int result;

            (void) sscanf( yytext + 1, "%o", &result );

            if ( result > 0xff )
                    /* bd, staa poza zakresem */

            *string_buf_ptr++ = result;
            }

    <str>\\\\[0-9]+ {
            /* generuj bd - za sekwencja specjalna; co jak
             * '\\48' lub '\\0777777'
             */
            }

    <str>\\\\n  *string_buf_ptr++ = '\\n';
    <str>\\\\t  *string_buf_ptr++ = '\\t';
    <str>\\\\r  *string_buf_ptr++ = '\\r';
    <str>\\\\b  *string_buf_ptr++ = '\\b';
    <str>\\\\f  *string_buf_ptr++ = '\\f';

    <str>\\\\(.|\\n)  *string_buf_ptr++ = yytext[1];

    <str>[^\\\\\\n\\"]+        {
            char *yptr = yytext;

            while ( *yptr )
                    *string_buf_ptr++ = *yptr++;
            }

.fi
.PP
Czsto, np. w niektrych przykadach powyej mona skoczy piszc grup
regu, rozpoczynajcych si od tych samych warunkw pocztkowych. Flex
uatwia cao wprowadzajc pojcie
.I zakresu
warunku pocztkowego.
Zakres rozpoczyna si od:
.nf

    <SCs>{

.fi
gdzie
.I SCs
jest list jednego lub wicej warunkw pocztkowych. Wewntrz zakresu
warunku pocztkowego kada regua dostaje automatycznie przedrostek
.I <SCs>
a do napotkania
.IR '}' ,
ktry odpowiada startowemu
.I '{'.
W ten sposb na przykad
.nf

    <ESC>{
        "\\\\n"   return '\\n';
        "\\\\r"   return '\\r';
        "\\\\f"   return '\\f';
        "\\\\0"   return '\\0';
    }

.fi
jest rwnowane:
.nf

    <ESC>"\\\\n"  return '\\n';
    <ESC>"\\\\r"  return '\\r';
    <ESC>"\\\\f"  return '\\f';
    <ESC>"\\\\0"  return '\\0';

.fi
Zakresy warunkw pocztkowych mog by zagniedane.
.PP
Do obsugi stosw warunkw pocztkowych s przeznaczone trzy procedury:
.TP
.B void yy_push_state(int new_state)
wrzuca biecy warunek pocztkowy na stos warunkw pocztkowych i przecza
si w stan
.IR new_state ,
zupenie jak po uyciu
.B BEGIN new_state
(pamitaj, e nazwy warunkw pocztkowych s rwnie liczbami cakowitymi).
.TP
.B void yy_pop_state()
zdejmuje warto ze stosu i przecza si na ni przez
.BR BEGIN .
.TP
.B int yy_top_state()
zwraca wierzchoek stosu bez zmiany zawartoci stosu.
.PP
Stos warunkw pocztkowych ronie dynamicznie i nie ma adnych wbudowanych
ogranicze. Po wyczerpaniu pamici, wykonywanie programu jest przerywane.
.PP
Aby korzysta ze stosw warunkw pocztkowych, skaner musi zawiera
dyrektyw
.B %option stack
(zobacz niej rozdzia Opcje).
.SH WIELOKROTNE BUFORY WEJCIOWE
Niektre skanery (te, obsugujce pliki doczane "include") wymagaj
odczytu z wielu strumieni wejciowych. Poniewa skanery
.I flex
wykonuj sporo buforowania, nie mona jednoznacznie zdecydowa skd bdzie
wykonywany nastpny odczyt przez proste napisanie
.BR YY_INPUT ,
ktre jest wraliwe na kontekst skanowania.
.B YY_INPUT
wywoywane jest tylko gdy skaner osiga koniec swojego bufora, ktry moe
by daleko po wyskanowaniu instrukcji takiej jak "include", wymagajcej
przeczenia rda wejcia.
.PP
Aby zaatwi niektre z tych problemw,
.I flex
daje mechanizm tworzenia i przeczania midzy wielokrotnymi buforami
wejciowymi. Bufor wejciowy jest tworzony z uyciem funkcji
.nf

    YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )

.fi
ktra pobiera wskanik
.I FILE
i rozmiar size, a nastpnie tworzy bufor zwizany z danym plikiem, ktrego
wielko (w znakach) jest okrelona parametrem rozmiaru.
(w razie wtpliwoci uyj
.B YY_BUF_SIZE
jako rozmiaru). Funkcja zwraca uchwyt
.BR YY_BUFFER_STATE ,
ktry moe by potem przekazywany do innych procedur (zobacz niej). Typ
.B YY_BUFFER_STATE
jest wskanikiem do struktury
.B struct yy_buffer_state
wic mona bezpiecznie inicjalizowa zmienne YY_BUFFER_STATE na
.B ((YY_BUFFER_STATE) 0)
i odnosi si do struktury w celu poprawnego zadeklarowania buforw
wejciowych w plikach rdowych innych ni ten od twojego skanera. Zauwa,
e wskanik
.I FILE
w wywoaniu
.B yy_create_buffer
jest uywany tylko jako warto
.I yyin
widzianego przez
.BR YY_INPUT ;
jeli redefiniujesz
.B YY_INPUT
tak, eby nie uywao
.IR yyin ,
to moesz spokojnie przekaza tu zerowy wskanik
.IR FILE .
Zadany bufor do skanowania wybiera si za pomoc:
.nf

    void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )

.fi
co przecza bufor wejciowy skanera tak, e kolejne tokeny bd pochodziy
z bufora
.I new_buffer.
Zauwa, e
.B yy_switch_to_buffer()
moe by uywane przez yywrap() do zestawiania rnych rzeczy we wznowionym
skanowaniu zamiast otwierania nowego pliku i ustawiania na nim
.IR yyin .
Zauwa te, e przeczanie rde wejciowych przez
.B yy_switch_to_buffer()
lub
.B yywrap()
.I nie
zmienia warunku pocztkowego.
.nf

    void yy_delete_buffer( YY_BUFFER_STATE buffer )

.fi
uywane jest do odzyskania miejsca zwizanego z buforem (
.B buffer
moe by wartoci nil, ale wtedy funkcja ta nic nie robi.)
Mona te czyci biec zawarto bufora, stosujc:
.nf

    void yy_flush_buffer( YY_BUFFER_STATE buffer )

.fi
Funkcja ta niszczy zawarto bufora, wic przy nastpnej prbie dopasowania
tokenu z bufora, skaner najpierw wypeni bufor na nowo uywajc
.BR YY_INPUT .
.PP
.B yy_new_buffer()
jest synonimem
.BR yy_create_buffer() ,
udostpnionym dla zgodnoci z C++ narzdziami
.I new
i
.IR delete ,
sucymi do tworzenia i niszczenia obiektw dynamicznych.
.PP
Na koniec makro
.B YY_CURRENT_BUFFER
zwraca uchwyt
.B YY_BUFFER_STATE
do biecego bufora.
.PP
A oto przykad uywania tych waciwoci w skanerze, rozwijajcym pliki
zaczane (waciwo
.B <<EOF>>
jest opisywana niej):
.nf

    /* stan "incl" jest uywany do wybierania nazwy zaczanego pliku
     */
    %x incl

    %{
    #define MAX_INCLUDE_DEPTH 10
    YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
    int include_stack_ptr = 0;
    %}

    %%
    include             BEGIN(incl);

    [a-z]+              ECHO;
    [^a-z\\n]*\\n?        ECHO;

    <incl>[ \\t]*      /* zjedz bia spacj */
    <incl>[^ \\t\\n]+   { /* mam nazw pliku zacznika */
            if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
                {
                fprintf( stderr, "Zbyt zagniedone zaczniki" );
                exit( 1 );
                }

            include_stack[include_stack_ptr++] =
                YY_CURRENT_BUFFER;

            yyin = fopen( yytext, "r" );

            if ( ! yyin )
                error( ... );

            yy_switch_to_buffer(
                yy_create_buffer( yyin, YY_BUF_SIZE ) );

            BEGIN(INITIAL);
            }

    <<EOF>> {
            if ( --include_stack_ptr < 0 )
                {
                yyterminate();
                }

            else
                {
                yy_delete_buffer( YY_CURRENT_BUFFER );
                yy_switch_to_buffer(
                     include_stack[include_stack_ptr] );
                }
            }

.fi
Do zestawiania buforw wejciowych dla skanowania acuchw z pamici
zamiast plikw istniej trzy procedury. Kada z nich tworzy nowy bufor
wejciowy do skanowania acucha i zwraca odpowiadajcy uchwyt
.B YY_BUFFER_STATE
(ktry powiniene skasowa stosujc
.B yy_delete_buffer()
po zakoczeniu dziaania). Przeczaj one te przetwarzanie na nowy bufor
przy uyciu
.BR yy_switch_to_buffer() ,
wic nastpne wywoanie
.B yylex()
rozpocznie skanowanie acucha.
.TP
.B yy_scan_string(const char *str)
skanuje acuch zakoczony zerem.
.TP
.B yy_scan_bytes(const char *bytes, int len)
skanuje
.I len
bajtw (dopuszczalne zera w rodku) poczwszy od pozycji
.I bytes.
.PP
Zauwa, e obydwie funkcje tworz i skanuj
.I kopie
oryginalnych danych. (Jest to podane, gdy
.B yylex()
modyfikuje zawarto skanowanego bufora.) Kopiowania mona unikn,
stosujc:
.TP
.B yy_scan_buffer(char *base, yy_size_t size)
ktre skanuje bufor na miejscu, zaczynajc od
.IR base ,
a w dugoci
.I size
bajtw, z ktrych dwa bajty
.I musz
by znakami
.B YY_END_OF_BUFFER_CHAR
(ASCII NUL).
Ostatnie dwa bajty nie s skanowane; tak wic skanowanie przebiega od
.B base[0]
do
.B base[size-2]
wcznie.
.IP
Jeli nie ustawisz odpowiednio
.I base
to 
.B yy_scan_buffer()
zwraca wskanik nil zamiast tworzy nowy bufor wejciowy.
.IP
Typ
.B yy_size_t
jest typem cakowitym, na ktry rzutuje si wyraenie cakowite, okrelajce
rozmiar bufora.
.SH REGUY END-OF-FILE
Specjalna regua "<<EOF>>" okrela akcje, ktre naley wykona po
osigniciu koca pliku i gdy yywrap() zwraca zero (tj. wskazuje brak dalszych
plikw do przetworzenia). Akcja musi si zakoczy zrobieniem jednej z
czterech rzeczy:
.IP -
przypisaniem
.I yyin
do nowego pliku wejciowego (w poprzednich wersjach fleksa po dokonaniu
przypisania naleao wywoa specjaln akcj
.B YY_NEW_FILE;
nie jest to ju wymagane);
.IP -
wywoaniem instrukcji
.IR return ;
.IP -
wywoaniem specjalnej akcji
.BR yyterminate() ;
.IP -
przeczeniem na nowy bufor za pomoc 
.BR yy_switch_to_buffer() .
.PP
Reguy <<EOF>> nie mog by uywane z innymi wzorcami; mog one by
kwalifikowane jedynie list warunkw pocztkowych. Jeli podana jest
niekwalifikowana regua <<EOF>>, to dotyczy ona
.I wszystkich
warunkw pocztkowych, ktre nie maj jeszcze akcji <<EOF>>. Aby poda
regu <<EOF>> tylko dla pocztkowego warunku pocztkowego uyj
.nf

    <INITIAL><<EOF>>

.fi
.PP
Te reguy przydatne s do apania rzeczy takich, jak niezamknite
cytaty. Przykad:
.nf

    %x quote
    %%

    ...inne reguy cytatowe...

    <quote><<EOF>>   {
             error( "nie zamknity cytat" );
             yyterminate();
             }
    <<EOF>>  {
             if ( *++filelist )
                 yyin = fopen( *filelist, "r" );
             else
                yyterminate();
             }

.fi
.SH RӯNE MAKRA
Mona zdefiniowa makro
.BR YY_USER_ACTION ,
ktre suy do podania akcji wykonywanej zawsze przed akcj
dopasowanej reguy. Na przykad moe by #definiowane do wywoywania
procedury konwertujcej yytext na mae litery.
Gdy wywoywane jest
.BR YY_USER_ACTION ,
zmienna
.I yy_act
okrela numer dopasowanej reguy (reguy s numerowane od 1). Zamy, e
chcesz wyprofilowa jak czsto jest uywana kada z regu. Rozwizaniem jest
nastpujcy kawaek kodu:
.nf

    #define YY_USER_ACTION ++ctr[yy_act]

.fi
gdzie
.I ctr
jest tablic przechowujc zawarto rnych regu. Zauwa, e makro
.B YY_NUM_RULES
daje ogln liczb regu (cznie z regu domyln, nawet jeli uywasz
.B \-s),
wic poprawn deklaracj
.I ctr
jest:
.nf

    int ctr[YY_NUM_RULES];

.fi
.PP
Makro
.B YY_USER_INIT
suy do podania akcji, ktra bdzie wykonywana zawsze przed
pierwszym skanem (i przed wewntrznymi inicjalizacjami skanera). Na przykad
mona to wykorzysta do woania procedury czytajcej tablice danych lub
otwierajcej plik raportowy.
.PP
Makro
.B yy_set_interactive(is_interactive)
moe by uywane do sterowania czy biecy bufor jest uwaany za
.IR interaktywny .
Bufor interaktywny jest przetwarzany wolniej, lecz musi by uywany gdy
wejcie rzeczywicie jest interaktywne. Zapobiega to problemom zwizanym z
oczekiwaniem na wypenienie buforw
(zobacz niej dyskusj flagi
.BR \-I ).
Warto niezerowa w wywoaniu makra zaznacza bufor jako interaktywny, a zero
to wycza. Zauwa, e uycie tego makra przesania
.B %option always-interactiv
lub
.B %option never-interactive
(zobacz niej Opcje).
Przed rozpoczciem skanowania bufora, ktry jest (lub nie jest)
interaktywny, naley wywoa funkcj
.BR yy_set_interactive() .
.PP
Makro
.B yy_set_bol(at_bol)
moe by wykorzystywane do sterowania czy biecy kontekst skanujcy bufora
dla nastpnego dopasowania tokena jest dokonywany jak gdyby od pocztku
linii. Niezerowa warto argumentu powoduje, e reguy zakotwiczone w '^'
staj si aktywne, a warto zerowa je dezaktywuje.
.PP
Makro
.B YY_AT_BOL()
zwraca prawd jeli nastpny token skanowany z biecego bufora bdzie mia
aktywne reguy '^'. W przeciwnym wypadku zwraca fasz.
.PP
W niektrych generowanych skanerach akcje s zebrane wszystkie w jedn
wielk instrukcj switch i s rozdzielone makrem
.BR YY_BREAK ,
ktre mona redefiniowa. Domylnie jest to po prostu "break".
Redefiniowanie
.B YY_BREAK
umoliwia uytkownikom C++ zadeklarowanie, by makro nie robio niczego
(uwaajc przy tym szczeglnie, by kada regua koczya si instrukcj
"break" lub "return"!). Mona tak zapobiec cierpieniom spowodowanym
ostrzeeniami o tym, e przez zakoczenie akcji reguy instrukcj return,
.B YY_BREAK
jest nieosigalne.
.SH WARTOCI DOSTPNE DLA UYTKOWNIKA
Sekcja ta zestawia rne wartoci dostpne dla uytkownika w akcjach
reguowych.
.IP -
.B char *yytext
zawiera biecy tekst tokenu. Moe by modyfikowany, lecz nie moe by
wyduany (nie mona dokleja dodatkowych znakw na kocu).
.IP
Jeli w pierwszej sekcji opisu skanera pojawi si dyrektywa specjalna
.B %array
to
.B yytext
zostanie zadeklarowane jako
.BR char yytext[YYLMAX] ,
gdzie
.B YYLMAX
jest makrodefinicj, ktr mona przedefiniowa w pierwszej sekcji (warto
domylna to oglnie 8KB). Uywanie
.B %array
daje wolniejsze skanery, lecz warto
.B yytext
staje si odporna na wywoania
.I input()
i
.IR unput() ,
ktre potencjalnie niszcz jego warto kiedy
.B yytext
jest wskanikiem znakowym. Przeciwn dyrektyw do
.B %array
jest
.BR %pointer ,
ktra jest dyrektyw domyln.
.IP
Dyrektywy
.B %array
nie mona uywa do generowania klas skanera C++
(flaga
.BR \-+ ).
.IP -
.B int yyleng
przechowuje dugo biecego tokenu.
.IP -
.B FILE *yyin
jest plikiem, z ktrego
.I flex
domylnie odczytuje wejcie. Moe by redefiniowany, lecz taki zabieg ma
sens tylko nim rozpocznie si skanowanie lub po napotkaniu EOF. Zmienianie
tej wartoci w rodku skanowania moe da nieoczekiwane rezultaty
spowodowane buforowaniem wejcia. Zamiast tego uyj wtedy
.BR yyrestart() .
Po zakoczeniu skanowania przez napotkanie koca pliku, mona przypisa
warto
.I yyin
do nowego pliku wejciowego i wywoa ponownie skaner by dokoczy
skanowanie.
.IP -
.B void yyrestart( FILE *new_file )
moe by woane do wskazywania
.I yyin
na nowy plik wejciowy. Przeczenie na nowy plik jest natychmiastowe
(wszelkie poprzednio buforowane wejcie jest tracone). Zauwa, e woanie
.B yyrestart()
z argumentem
.I yyin
porzuca biecy bufor wejciowy i kontynuuje skanowanie tego samego pliku
wejciowego.
.IP -
.B FILE *yyout
jest plikiem, do ktrego kierowane jest wyjcie akcji
.BR ECHO .
Uytkownik moe mu przypisa inn warto.
.IP -
.B YY_CURRENT_BUFFER
zwraca uchwyt
.B YY_BUFFER_STATE
do biecego bufora.
.IP -
.B YY_START
zwraca warto cakowit, odpowiadajc biecemu warunkowi pocztkowemu.
Wartoci tej mona uywa dalej z
.B BEGIN
do powrotu do tego warunku.
.SH CZENIE Z YACC
Jednym z podstawowych zastosowa
.I fleksa
jest wsptowarzyszenie generatorowi analizatorw
.IR yacc .
Analizatory skadni
.I yacc
oczekuj wywoania procedury o nazwie
.B yylex()
celem znalezienia kolejnego tokenu wejciowego. Procedura powinna zwrci
typ nastpnego tokenu oraz wstawi zwizan z nim warto do globalnej
zmiennej
.B yylval.
Aby uywa
.I fleksa
z
.I yaccem,
naley yaccowi przekaza  opcj
.BR \-d ,
co kae mu generowa plik
.B y.tab.h
zawierajcy definicje wszystkich
.BR %tokenw (%tokens)
pojawiajcych si w wejciu
.IR yacc .
Plik ten jest nastpnie zaczany do skanera
.IR fleksowego .
Na przykad jeli jednym z tokenw jest "TOK_NUMBER", to cz skanera moe
wyglda tak:
.nf

    %{
    #include "y.tab.h"
    %}

    %%

    [0-9]+        yylval = atoi( yytext ); return TOK_NUMBER;

.fi
.SH OPCJE
.I flex
ma nastpujce opcje:
.TP
.B \-b
Generuje informacje zapasowe do
.I lex.backup.
Oto lista stanw skanera, ktre wymagaj kopii zapasowych oraz znaki
wejciowe dla ktrych to zachodzi. Dodajc reguy mona usun stany
zapasowe. Jeli wyeliminowane zostan
.I wszystkie
stany zapasowe, a uyte bdzie
.B \-Cf
lub
.BR \-CF ,
wygenerowany skaner bdzie dziaa szybciej (zobacz flag
.BR \-p ).
Opcj to powinni si martwi jedynie uytkownicy wyciskajcy ostatnie poty
ze swoich skanerw. (Zobacz sekcj o Rozwaaniach nad Wydajnoci.)
.TP
.B \-c
nieuywana i niezalecana opcja dla zgodnoci z POSIX-em.
.TP
.B \-d
powoduje, e generowany skaner dziaa w trybie
.IR debug .
Za kadym razem po rozpoznaniu wzorca, gdy globalna zmienna
.B yy_flex_debug
jest niezerowa (co jest domylne), skaner zapisze na stderr lini w postaci:
.nf

    --accepting rule at line 53 ("dopasowany tekst")

.fi
Numer linii odnosi si do pooenia reguy w pliku definiujcym skaner (tj.
w pliku, potraktowanym fleksem). Komunikaty s rwnie generowane gdy skaner
robi kopie zapasowe, przyjmuje domyln regu, dochodzi do koca bufora
(lub napotyka NUL; w tym momencie obydwa [zdarzenia] wygldaj jednakowo z
punktu widzenia skanera) lub osiga koniec pliku.
.TP
.B \-f
okrela
.IR "szybki skaner" .
Nie dokonywana jest kompresja tabel i pomijane jest stdio. W efekcie kod
jest duy, lecz szybki. Opcja ta jest rwnowana
.B \-Cfr
(zobacz niej).
.TP
.B \-h
generuje zestawienie "pomocy" opcji fleksa na stdout i koczy dziaanie.
.B \-?
i
.B \-\-help
s rwnowanikami
.B \-h.
.TP
.B \-i
nakazuje fleksowi generowania skanera niewraliwego na wielko znakw.
Wielko liter we wzorcach zostanie zignorowany, a tokeny wejcia bd
dopasowywane niezalenie od wielkoci. Dopasowany tekst znajdujcy si w
.I yytext
bdzie mia zachowan oryginaln wielko liter.
.TP
.B \-l
wcza maksymaln zgodno z oryginaln implementacj
.I leksa
z AT&T. Zauwa, e nie oznacza to penej zgodnoci. Uycie tej opcji
kosztuje sporo wydajnoci i eliminuje z uycia opcje
.BR \-+ , -f , -F , -Cf
lub
.BR -CF .
Dla szczegw o zapewnianej zgodnoci, zobacz niej sekcj o niezgodnociach
midzy Leksem i POSIX-em. Opcja ta powoduje te z#definiowanie nazwy
.B YY_FLEX_LEX_COMPAT
w generowanym skanerze.
.TP
.B \-n
kolejna ignorowana opcja dodana dla zgodnoci z POSIX-em.
.TP
.B \-p
generuje raport o wydajnoci na stderr. Raport skada si z komentarzy o
waciwociach pliku wejciowego
.IR fleksa ,
wic powoduje znaczn utrat wydajnoci skanera. Jeli podasz t flag
dwukrotnie, uzyskasz te komentarze o waciwociach, ktre doprowadziy do
drugorzdnych utrat wydajnoci.
.IP
Zauwa, e uycie
.BR REJECT ,
.BR "%option yylineno" ,
i zmiennego wiszcego kontekstu (variable trailing context) (zobacz  niej
sekcj o Niedostatkach / Bdach) powoduje znaczn utrat wydajnoci; uywanie
.IR yymore() ,
operatora
.B ^
i flagi
.B \-I
powoduje pomniejsze utraty wydajnoci.
.TP
.B \-s
powoduje, e domylna regua (powodujca echo niedopasowanego wejcia
skanera na stdout) nie jest wykonywana. Jeli skaner napotka wejcie,
ktrego nie moe dopasowa do regu, przerywa dziaanie z bdem. Opcja ta
jest przydatna do znajdowania dziur w zbiorze regu skanera.
.TP
.B \-t
nakazuje
.I fleksowi
zapisanie wygenerowanego skanera na standardowe wyjcie zamiast do pliku
.BR lex.yy.c .
.TP
.B \-v
nakazuje
.I fleksowi
pisanie na 
.I stderr
zestawienia statystyk dotyczcych generowanego skanera.
Wikszo statystyk jest pozbawiona znaczenia dla typowego uytkownika, lecz
pierwsza z linijek wskazuje wersj fleksa (to samo co zgasza opcja \-V), a
nastpna linia flagi uyte do generowania skanera, z domylnymi wcznie.
.TP
.B \-w
powstrzymuje komunikaty o ostrzeeniach.
.TP
.B \-B
nakazuje fleksowi generowanie skanera
.IR wsadowego ,
czyli odwrotno skanerw
.IR interaktywnych ,
generowanych przez
.B \-I
(zobacz niej). Oglnie, opcji
.B \-B
uywa si majc
.IR pewno ,
e skaner nigdy nie bdzie uywany interaktywnie i chcc wycisn jeszcze
.I troszeczk
wicej wydajnoci. Jeli chcesz zyska wicej wydajnoci, powiniene uy
opcji
.B \-Cf
lub
.B \-CF
(opisanych niej), ktre wczaj
.B \-B
i tak automatycznie.
.TP
.B \-F
mwi, e naley uy reprezentacji tablicy
.ul
szybkiego skanera (i stdio ma by pominite). Reprezentacja ta jest mniej
wicej tak szybka jak reprezentacja penej tablicy
.BR (-f) ,
i dla niektrych zestaww wzorcw bdzie znacznie mniejsza (a dla innych
wiksza). Oglnie, jeli wzorzec zawiera zarwno "sowa kluczowe" jak i
apic-wszystko regu "identyfikatora", tak jak poniszy zestaw:
.nf

    "case"    return TOK_CASE;
    "switch"  return TOK_SWITCH;
    ...
    "default" return TOK_DEFAULT;
    [a-z]+    return TOK_ID;

.fi
to lepiej uy reprezentacji penej tablicy. Jeli obecna jest tylko regua
"identyfikatora" i uywasz potem hasza lub podobnej rzeczy do wykrywania
sw kluczowych, to lepiej uy opcji
.BR -F .
.IP
Opcja ta odpowiada
.B \-CFr
(zobacz niej).  Nie mona jej uywa z
.BR \-+ .
.TP
.B \-I
nakazuje
.I fleksowi
generowanie skanera
.IR interaktywnego .
Skaner interaktywny patrzy naprzd do wyboru dopasowania jedynie jeli musi.
Okazuje si, e patrzenie o jeden dodatkowy znak dalej, nawet jeli skaner
ma ju do do dopasowania tokenu jest troch szybsze ni wersja minimalna.
Lecz skanery patrzce naprzd daj dziadowsk wydajno interaktywn; na
przykad gdy uytkownik wpisze now lini, to nie jest ona rozpoznawana jako
token nowej linii dopki nie wprowadzony zostanie 
.I nastpny
token, co oznacza czsto wpisanie caej kolejnej linii.
.IP
Skanery
.I fleksa
s domylnie
.IR interaktywne ,
chyba e uyjesz opcji kompresji tablicy
.B \-Cf
lub
.BR \-CF " (zobacz niej)."
Jest tak dlatego, e jeli oczekujesz wysokiej wydajnoci, to powiniene
uy jednej z tych opcji, a jeli tego nie zrobie,
.I flex
zakada, e jeste gotw powici troch wydajnoci na rzecz intuicyjnego
zachowania interaktywnego. Zauwa te, e 
.I nie moesz
uy
.B \-I
w poczeniu z
.B \-Cf
lub
.BR \-CF .
Z tej przyczyny opcja ta nie jest w rzeczywistoci wymagana; jest domylnie
wczona dla tych przypadkw, dla ktrych jest dopuszczalna.
.IP
Opcj
.B \-B
moesz wymusi by skaner
.I nie
by interaktywny
(zobacz powyej).
.TP
.B \-L
nakazuje
.I fleksowi
nie generowa dyrektyw
.BR #line .
Bez tej opcji
.I flex
przyprawia generowany skaner dyrektywami #line, wic komunikaty o bdach w
akcjach bd poprawnie pooone wzgldem oryginalnego pliku wejciowego
.I fleksa
(jeli bdy wynikaj z kodu w pliku wejciowym) lub [wzgldem] 
.B lex.yy.c
(jeli bdy s win
.I fleksa
-- powiniene zgosi takie bdy pod adres e-mail podany poniej.)
.TP
.B \-T
powoduje, e
.I flex
dziaa w trybie
.IR ledzenia .
Bdzie generowa na stderr wiele komunikatw o postaci wejcia i
wynikajcych ze niedeterministycznych i deterministycznych automatach
skoczonych. Opcja ta jest uywana zwykle w opiece nad
.IR fleksem .
.TP
.B \-V
drukuje numer wersji na
.I stdout
i koczy dziaanie.
.B \-\-version
jest synonimem
.BR \-V .
.TP
.B \-7
nakazuje
.I fleksowi
generowanie skanera 7-bitowego, tj. takiego ktry moe rozpoznawa w swoim
wejciu tylko znaki 7-bitowe. Zalet uywania
.B \-7
jest to, e tablice skanera bd o poow mniejsze ni wygenerowane opcj
.B \-8
(zobacz niej). Wad jest to, e skanery takie czsto si zawieszaj lub
zaamuj jeli na ich wejciu znajdzie si znak 8-bitowy.
.IP
Zauwa jednak, e jeli generujesz skaner z uyciem opcji kompresji tablic
.B \-Cf
lub
.BR \-CF ,
to uycie
.B \-7
zachowa jedynie niewielki rozmiar przestrzeni tablic, a spowoduje, e skaner
bdzie znaczco mniej przenony.
Domylnym zachowaniem
.I fleksa
jest generowanie skanerw 8-bitowych, chyba e uyto opcji
.B \-Cf
lub
.BR \-CF ,
i wtedy
.I flex
generuje domylnie skaner 7-bitowy, chyba e twoja maszyna zawsze bya
skonfigurowana na generowanie skanerw 8-bitowych (co czsto si zdarza poza
USA). To, czy flex wygenerowa skaner 7 czy 8 bitowy, mona okreli,
sprawdzajc zestawienie flag w wyjciu
.BR \-v ,
co opisano wyej.
.IP
Zauwa, e jeli uywasz
.B \-Cfe
lub
.BR \-CFe ,
flex wci domylnie generuje skaner 8-bitowy, gdy po kompresji pene
tablice 8-bitowe nie s wiele wiksze od 7-bitowych.
.TP
.B \-8
nakazuje
.I fleksowi
generowanie skanera 8-bitowego, tj. takiego, ktry rozpoznaje znaki
8-bitowe. Flaga ta jest wymagana jedynie dla skanerw wygenerowanych z
uyciem
.B \-Cf
lub
.BR \-CF ,
gdy w innych wypadkach jest ona przyjmowana jako domylna.
.IP
.TP
.B \-+
okrela, e chcesz by fleks wygenerowa klas skanera w C++. Zobacz sekcj o
generowaniu skanerw C++.
.TP 
.B \-C[aefFmr]
steruje poziomem kompresji tablic, balansujc midzy maymi a szybkimi
skanerami.
.IP
.B \-Ca
("wyrwnaj") nakazuje fleksowi powici rozmiar tablic w wygenerowanych
skanerach na rzecz szybkoci, gdy elementy tablic mog by lepiej wyrwnane
pod ktem dostpu do pamici i oblicze. Na niektrych architekturach RISC
pobieranie i operowanie na dugich sowach jest efektywniejsze ni na
mniejszych jednostkach, takich jak krtkie sowa. Opcja ta moe podwoi
rozmiar tablic uywanych przez twj skaner.
.IP
.B \-Ce
Nakazuje
.I fleksowi
budowanie klas
.IR rwnowanoci ,
tj. zestaww znakw o identycznych waciwociach leksykalnych (np. jeli
jedynym wystpieniem cyfr w pliku wejciowym fleksa jest klasa znakw
"[0-9]", to cyfry z przedziay od 0 do 9 zostan wstawione do tej samej
klasy rwnowanoci. Klasy takie zwykle znacznie redukuj ostateczne
rozmiary tablic/obiektw (zwykle 2-5 razy) i s cakiem tanie od strony
wydajnociowej (jedno podgldnicie w tablicy na skanowany znak).
.IP
.B \-Cf
okrela, e naley generowa
.I pene
tablice skanera -
.I flex
nie ma ich kompresowa poprzez branie korzyci z podobnych funkcji przej
dla rnych stanw.
.IP
.B \-CF
okrela, e naley uy alternatywnej, szybkiej reprezentacji skanera
(opisanej pod flag
.BR \-F ).
Opcja ta nie moe by uywana z
.BR \-+ .
.IP
.B \-Cm
nakazuje
.I fleksowi
budowanie klas
.I meta-rwnowanoci,
ktre s zbiorami klas rwnowanoci (lub znakw, jeli klasy rwnowanoci
nie s uywane), ktre s czsto uywane wsplnie. Klasy takie s czsto
dobr rzecz podczas uywania skompresowanych tablic, lecz maj one ju
umiarkowany wpyw na wydajno (dwa lub jeden test "if" i jedno
podgldnicie tablicy na skanowany znak).
.IP
.B \-Cr
powoduje, e generowany skaner
.I omija
uycie standardowej biblioteki I/O dla wejcia. Zamiast woa
.B fread()
lub
.BR getc() ,
skaner bdzie uywa wywoania systemowego
.BR read() ,
zyskujc tak troch na wydajnoci (w skali zalenej od systemu). W
rzeczywistoci jest to bez znaczenia, chyba e uywasz te
.B \-Cf
lub
.BR \-CF .
Wykorzystanie
.B \-Cr
moe te spowodowa dziwne zachowanie jeli np. odczytasz z
.I yyin
z pomoc stdio przed wywoaniem skanera (skaner pominie tekst pozostawiony
przez twoje odczyty w buforze wejciowym stdio).
.IP
.B \-Cr
nie dziaa jeli zdefiniujesz
.B YY_INPUT
(zobacz wyej Generowany Skaner).
.IP
Samotne
.B \-C
okrela, e tablice skanera powinny by kompresowane, lecz nie naley uywa
klas rwnowanoci i klas metarwnowanoci.
.IP
Opcje
.B \-Cf
lub
.B \-CF
i
.B \-Cm
nie maj sensu razem - nie ma sytuacji dla klas metarwnowanoci jeli
tablica nie jest kompresowana. Poza tym opcje mona swobodnie czy.
.IP
Domylnym ustawieniem jest
.B \-Cem,
ktre okrela, e
.I flex
powinien generowa klasy rwnowanoci i metarwnowanoci. Ustawienie to
daje najwyszy stopie kompresji tablic. Kosztem wikszych tablic mona
uzyska szybciej wykonujce si skanery. Nastpujce zestawienie jest mniej
wicej prawdziwe:
.nf

    najwolniejsze i najmniejsze
          -Cem
          -Cm
          -Ce
          -C
          -C{f,F}e
          -C{f,F}
          -C{f,F}a
    najszybsze i najwiksze

.fi
Zauwa, e skanery z najmniejszymi tablicami s zwykle najszybciej
generowane i kompilowane, wic podczas prac rozwojowych prawdopodobnie
najchtniej uyjesz domylnej, maksymalnej kompresji.
.IP
.B \-Cfe
jest czsto dobrym kompromisem midzy szybkoci a rozmiarem dla skanerw
gotowych do wdroenia (production scanners).
.TP
.B \-ooutput
nakazuje fleksowi zapisanie skanera do pliku
.B output
zamiast do
.BR lex.yy.c .
Jeli poczysz
.B \-o
z opcj
.BR \-t ,
to skaner jest zapisywany na stdout, lecz jego dyrektywy
.B #line
(zobacz wyej opcj
.BR \\-L ),
odnosz si do pliku
.BR output .
.TP
.B \-Pprefiks
zmienia domylny przedrostek
.I "yy"
uywany przez 
.I fleksa
dla wszystkich zmiennych i funkcji globalnych na
.IR prefiks .
Na przykad
.B \-Pfoo
zmienia nazw
.B yytext
na
.BR footext .
Zmienia to te nazw domylnego pliku wyjciowego z
.B lex.yy.c
na
.BR lex.foo.c .
A oto wszystkie nazwy, ktrych dotyczy takie zachowanie:
.nf

    yy_create_buffer
    yy_delete_buffer
    yy_flex_debug
    yy_init_buffer
    yy_flush_buffer
    yy_load_buffer_state
    yy_switch_to_buffer
    yyin
    yyleng
    yylex
    yylineno
    yyout
    yyrestart
    yytext
    yywrap

.fi
(Jeli uywasz skanera C++, to dotyczy to bdzie tylko
.B yywrap
i
.BR yyFlexLexer .)
Wewntrz samego skanera mona wci uywa jednej i drugiej konwencji
nazywania; jednak z zewntrz dozwolone s tylko nazwy zmodyfikowane.
.IP
Opcja ta umoliwia atwe czenie w cao rnych programw
.I fleksa
w jeden plik wykonywalny. Zauwa jednak, e uywanie tej opcji zmienia te
nazw
.BR yywrap() ,
wic \fImusisz\fR teraz albo udostpni wasn wersj tej procedury dla
swojego skanera, albo uy
.BR "%option noyywrap" ,
gdy konsolidacja z
.B \-lfl
nie daje ju funkcji domylnej.
.TP
.B \-Sskeleton_file
przesania domylny plik szkieletowy, na podstawie ktrego
.I flex
buduje swoje skanery. Nie bdziesz uywa tej opcji, chyba e zajmujesz si
rozwojem fleksa.
.PP
.I flex
daje te mechanizm kontrolowania opcji z samej specyfikacji skanera, zamiast
linii polece. Dziaa to przez wczanie dyrektyw
.B %option
w pierwszej sekcji specyfikacji skanera. W jednej dyrektywie
.B %option
mona podawa wiele opcji, a w samej pierwszej sekcji pliku wejciowego
fleksa mona uywa wielu dyrektyw.
.PP
Wikszo opcji jest podawana po prostu jako nazwy, poprzedzone opcjonalnie
sowem "no" (bez biaych spacji w rodku), ktre neguje ich znaczenie.
Cz jest rwnowana flagom fleksa lub ich negacjom:
.nf

    7bit            -7
    8bit            -8
    align           -Ca
    backup          -b
    batch           -B
    c++             -+

    caseful lub
    case-sensitive  przeciwne do -i (domylne)

    case-insensitive lub
    caseless        -i

    debug           -d
    default         przeciwne do -s
    ecs             -Ce
    fast            -F
    full            -f
    interactive     -I
    lex-compat      -l
    meta-ecs        -Cm
    perf-report     -p
    read            -Cr
    stdout          -t
    verbose         -v
    warn            przeciwne do -w
                    (dla -w uyj "%option nowarn")

    array           rwnowane "%array"
    pointer         rwnowane "%pointer" (domylne)

.fi
Niektre
.B %opcje
daj waciwoci niedostpne gdzie indziej:
.TP
.B always-interactive
nakazuje fleksowi generowanie skanera, ktry zawsze uwaa swoje wejcie za
"interaktywne". Normalnie przy kadym pliku wejciowym skaner woa
.B isatty()
do okrelenia czy wejcie skanera jest interaktywne i powinno by czytane
po znaku. Po uyciu tej opcji wywoanie takie nie jest robione.
.TP
.B main
nakazuje fleksowi udostpni domylny program
.B main()
dla skanera, ktry po prostu woa
.BR yylex() .
Opcja ta implikuje
.B noyywrap
(zobacz niej).
.TP
.B never-interactive
nakazuje fleksowi generowanie skanera, ktry zawsze uwaa swoje wejcie za
"nieinteraktywne" (znw, nie jest woane
.BR isatty() ).
Opcja ta jest przeciwna do
.B always-interactive.
.TP
.B stack
wcza uywanie stosw warunkw pocztkowych (zobacz wyej Warunki
Pocztkowe).
.TP
.B stdinit
jeli jest ustawione (np.
.BR "%option stdinit" )
to zachodzi inicjalizacja
.I yyin
i
.I yyout
na
.I stdin
i
.IR stdout ,
zamiast domylnych
.I nil.
Niektre istniejce programy
.I lex
zale od tego zachowania, nawet jeli nie jest ono zgodne z ANSI C,
ktre nie wymagaj staych czasu kompilacji
.I stdin
i
.IR stdout .
.TP
.B yylineno
nakazuje
.I fleksowi
generowanie skanera, ktry przechowuje liczb obecnie odczytanych linii w
zmiennej globalnej
.B yylineno.
Opcja ta jest wymuszana przez
.BR "%option lex-compat" .
.TP
.B yywrap
jeli nie jest ustawione (np.
.BR "%option noyywrap" ),
to skaner nie woa
.B yywrap()
na kocu pliku, lecz po prostu przyjmuje, e nie ma ju plikw do skanowania
(dopki uytkownik nie wskae yyin na nowy plik i nie wywoa
.B yylex()
ponownie).
.PP
.I flex
skanuje akcje regu w celu okrelenia czy uywasz waciwoci
.B REJECT
lub
.BR yymore() .
Opcje
.B reject
i
.B yymore
mog przesoni jego decyzj na tak, jak ustawisz przy uyciu opcji,
zarwno ustawiajc je (np.
.BR "%option reject" )
do wskazania, e waciwo jest rzeczywicie uywana, lub
wyczajc je, wskazujc, e waciwo nie jest uywana (np.
.BR "%option noyymore" ).
.PP
Trzy opcje pobieraj wartoci acuchowe, offsetowane znakiem '=':
.nf

    %option outfile="ABC"

.fi
jest rwnowane
.BR -oABC ,
a
.nf

    %option prefix="XYZ"

.fi
jest rwnowane
.BR -PXYZ .
Poza tym,
.nf

    %option yyclass="foo"

.fi
dotyczy tylko skanerw C++ (opcja
.BR \-+ ).
Mwi to fleksowi, e
.B foo
jest wyprowadzone jako podklasa
.B yyFlexLexer,
wic
.I flex
bdzie umieszcza twoje akcje w funkcji skadowej
.B foo::yylex()
zamiast w
.BR yyFlexLexer::yylex() .
Powoduje to te generowanie funkcji skadowej
.BR yyFlexLexer::yylex() ,
emitujcej po wywoaniu bd dziaania (przez wywoanie
.BR yyFlexLexer::LexerError()) .
Dla dalszych informacji zobacz te niej Generowanie Skanerw C++.
.PP
Istniej opcje dla purystw, nie chccych widzie w swoich skanerach
niepotrzebnych procedur. Kada z nastpujcych opcji (np.
(np.,
.BR "%option nounput" ),
powoduje, e dana procedura nie pojawia si w wygenerowanym skanerze:
.nf

    input, unput
    yy_push_state, yy_pop_state, yy_top_state
    yy_scan_buffer, yy_scan_bytes, yy_scan_string

.fi
(chocia
.B yy_push_state()
i podobne i tak nie pojawi si dopki nie uyjesz
.BR %option stack) .
.SH ROZWAANIA NAD WYDAJNOCI
Podstawowym zadaniem przy projektowaniu
.I fleksa
byo zapewnienie, e bdzie generowa wydajne skanery. Zosta
zoptymalizowany do dobrej wsppracy z wielkimi zestawami regu. Poza
omawianymi ju wpywami opcji kompresji
.BR \-C ,
istnieje jeszcze kilka akcji/opcji wpywajcych na wydajno. S to, od
najkosztowniejszej do najmniej kosztownej:
.nf

    REJECT
    %option yylineno
    arbitralny wiszcy kontekst

    zestawy wzorcw, wymagajce cofania
    %array
    %option interactive
    %option always-interactive

    '^' operator rozpoczcia linii
    yymore()

.fi
z ktrych pierwsze trzy s bardzo kosztowne, a ostatnie dwa w miar tanie.
Zauwa te, e
.B unput()
jest implementowane jako wywoanie procedurowe, ktre prawdopodobnie
wykonuje sporo pracy, podczas gdy
.B yyless()
jest tanim makrem; wic jeli wstawiasz z powrotem nadmiarowy wyskanowany
tekst, uyj
.BR yyless() .
.PP
.B REJECT
powinno by unikane za wszelk cen z punktu widzenia wydajnoci.
Jest to szczeglnie kosztowna opcja.
.PP
Pozbycie si cofania jest trudne i moe czsto prowadzi do bdw w
skomplikowanych skanerach. W praktyce zaczyna si od uycia flagi
.B \-b 
do wygenerowania pliku
.IR lex.backup .
Na przykad dla wejcia
.nf

    %%
    foo        return TOK_KEYWORD;
    foobar     return TOK_KEYWORD;

.fi
plik ten wyglda tak:
.nf

    State #6 is non-accepting -
     associated rule line numbers:
           2       3
     out-transitions: [ o ]
     jam-transitions: EOF [ \\001-n  p-\\177 ]

    State #8 is non-accepting -
     associated rule line numbers:
           3
     out-transitions: [ a ]
     jam-transitions: EOF [ \\001-`  b-\\177 ]

    State #9 is non-accepting -
     associated rule line numbers:
           3
     out-transitions: [ r ]
     jam-transitions: EOF [ \\001-q  s-\\177 ]

    Compressed tables always back up.

.fi
Pierwszych kilka linii mwi, e istnieje stan skanera, w ktrym moe on
przyj 'o', lecz nie moe przyj innego znaku i e w tym stanie aktualnie
skanowany tekst nie pasuje do adnej reguy. Stan ten pojawia si podczas
prby dopasowania regu z linijek 2 i 3 pliku wejciowego. Jeli skaner jest
w tym stanie i odczyta cokolwiek innego ni 'o', to bdzie musia si cofn
i okreli, ktra regua pasuje. Po chwili skrobania si w gow mona
zauway, e musi to by stan, gdy skaner zobaczy "fo". W tej sytuacji
otrzymanie czegokolwiek innego ni 'o' spowoduje cofnicie do prostego
dopasowania 'f' (regua domylna).
.PP
Komentarz odnonie stanu #8 mwi, e istnieje problem przy skanowaniu
"foob". Rzeczywicie, jeli pojawi si dowolny znak inny ni 'a', to skaner
bdzie musia si cofn do przyjmowania "foo". Podobnie sprawa ma si ze
stanem #9, mwicym o "fooba", po ktrym nie nastpuje 'r'.
.PP
Ostatni komentarz przypomina nam, e usuwanie cofania nie ma sensu jeli nie
uywamy
.B \-Cf
lub
.BR \-CF ,
gdy nie daje to adnego zysku wydajnoci na skanerach kompresowanych.
.PP
Sposobem usuwania cofania jest dodawanie regu dla "bdw":
.nf

    %%
    foo         return TOK_KEYWORD;
    foobar      return TOK_KEYWORD;

    fooba       |
    foob        |
    fo          {
                /* faszywy alarm, nie jest to sowo kluczowe */
                return TOK_ID;
                }

.fi
.PP
Eliminowanie cofania mona przeprowadzi rwnie przy uyciu reguy
"ap-wszystko":
.nf

    %%
    foo         return TOK_KEYWORD;
    foobar      return TOK_KEYWORD;

    [a-z]+      return TOK_ID;

.fi
Jest to, tam gdzie mona je zastosowa, najlepsze rozwizanie.
.PP
Komunikaty cofania czsto ukadaj si w kaskady. W skomplikowanych zbiorach
regu mona dosta setki komunikatw. Mimo to, jeli mona je zdeszyfrowa, to
ich usuwanie wymaga tylko tuzina regu (atwo si jednak pomyli i spowodowa, e
regua obsugi bdu bdzie pasowa do prawidowego tokena. Moliwe, e przysze
implementacje fleksa bd automatycznie zajmoway si usuwaniem cofania).
.PP
Wane jest pamitanie, e korzyci z eliminacji tego problemu
zyskujesz dopiero po zlikwidowaniu
.I kadej
instancji cofania. Pozostawienie cho jednej oznacza, e nie zyskujesz
niczego.
.PP
.I Zmienny
wiszcy kontekst (gdzie zarwno prowadzca jak i koczca cz nie maj
ustalonej dugoci) wprowadza utrat wydajnoci zblion do
.B REJECT
(tzn. znaczn). Dlatego gdy tylko mona, to zapisz tak regu:
.nf

    %%
    mouse|rat/(cat|dog)   run();

.fi
jako:
.nf

    %%
    mouse/cat|dog         run();
    rat/cat|dog           run();

.fi
lub jako
.nf

    %%
    mouse|rat/cat         run();
    mouse|rat/dog         run();

.fi
zwr uwag, e specjalna akcja '|'
.I nie
powoduje adnych oszczdnoci, a wrcz moe pogorszy spraw (zobacz niej
Niedostatki / Bdy).
.LP
Innym obszarem, gdzie uytkownik moe zwiksza wydajno skanera jest to,
e im dusze s dopasowywane tokeny, tym szybciej dziaa skaner. Jest tak
dlatego, e przetwarzanie dugich tokenw wikszoci znakw wejciowych
zachodzi w wewntrznej (krtkiej) ptli skanujcej i rzadko musi przechodzi
przez dodatkow prac zwizan z ustawianiem rodowiska skanujcego (np.
.BR yytext )
dla akcji. Przypomnij sobie skaner komentarzy C:
.nf

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^*\\n]*
    <comment>"*"+[^*/\\n]*
    <comment>\\n             ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

.fi
Mona to przyspieszy nastpujco:
.nf

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^*\\n]*
    <comment>[^*\\n]*\\n      ++line_num;
    <comment>"*"+[^*/\\n]*
    <comment>"*"+[^*/\\n]*\\n ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

.fi
Teraz zamiast sytuacji, gdzie nowa linia wymaga przetwarzania nastpnej
akcji, rozpoznawanie nowych linii jest "rozrzucone" na inne reguy.
Umoliwia to zachowanie jak najduszego dopasowania. Zauwa, e
.I dodawanie
regu
.I nie
spowalnia skanera! Jego szybko jest niezalena od liczby regu i (w
porwnaniu do rozwaa z pocztku sekcji) ich stopnia skomplikowania (z
zastrzeeniem do operatorw takich jak '*' i '|').
.PP
Ostateczny przykad przyspieszania skanera: zamy, e chcesz skanowa plik
zawierajcy identyfikatory i sowa kluczowe w liczbie jednego na lini, bez
adnych obcych znakw i chcesz rozpoznawa wszystkie sowa kluczowe.
Naturalnym odruchem pocztkowym jest:
.nf

    %%
    asm      |
    auto     |
    break    |
    ... etc ...
    volatile |
    while    /* to jest sowo kluczowe */

    .|\\n     /* a to nie... */

.fi
Aby wyeliminowa ledzenie wstecz, wprowad regu ap-wszystko:
.nf

    %%
    asm      |
    auto     |
    break    |
    ... etc ...
    volatile |
    while    /* to sowo kluczowe */

    [a-z]+   |
    .|\\n     /* a to nie... */

.fi
Obecnie, jeli mamy zagwarantowane, e mamy dokadnie jedno sowo w linii,
moemy zredukowa cakowit liczb dopasowa o poow przez wczanie w
rozpoznawanie tokenw apanie nowych linii.
.nf

    %%
    asm\\n    |
    auto\\n   |
    break\\n  |
    ... etc ...
    volatile\\n |
    while\\n  /* to sowo kluczowe */

    [a-z]+\\n |
    .|\\n     /* a to nie... */

.fi
Trzeba by tu ostronym, gdy wanie wprowadzilimy do skanera cofanie. W
szczeglnoci, jeli
.I my
wiemy, e w wejciu nie bdzie nigdy znakw innych ni litery i nowe linie,
to
.I flex
nie moe tego wiedzie i bdzie planowa ewentualno cofania podczas
skanowania tokenu w rodzaju "auto", po ktrym nie nastpi nowa linia lub
litera. W poprzednim wypadku nastpioby po prostu dopasowanie reguy
"auto", lecz teraz nie ma "auto", ale "auto\\n". Aby wyeliminowa moliwo
cofania, moemy albo zduplikowa wszystkie reguy bez kocowych nowych
linii albo, jeli nie spodziewamy si takiego wejcia i nie [interesuje nas]
jego klasyfikacja, moemy wprowadzi regu ap-wszystko, ktra nie zawiera
nowej linii.
.nf

    %%
    asm\\n    |
    auto\\n   |
    break\\n  |
    ... etc ...
    volatile\\n |
    while\\n  /* to sowo kluczowe */

    [a-z]+\\n |
    [a-z]+   |
    .|\\n     /* a to nie... */

.fi
Po kompilacji z
.BR \-Cf ,
jest to prawie tak szybkie, jak tylko moliwe dla
.I fleksa
dla tego problemu.
.PP
Ostatnia uwaga:
.I flex
jest wolny przy dopasowywaniu NUL-w, szczeglnie jeli token zawiera ich
wiele. 
Najlepiej pisa reguy, dopasowujce
.I krtkie
fragmenty takich tekstw.
.PP
Kolejna ostatnia uwaga o wydajnoci: jak wspomniano wyej w sekcji Jak
Dopasowywane jest Wejcie, dynamiczne zmiany rozmiarw
.B yytext
do przyjmowania duych tokenw jest powolne, gdy obecnie wymaga by taki
token by reskanowany od pocztku. Tak wic jeli wydajno jest istotna, to
powiniene dopasowywa "due" fragmenty tekstu, lecz nie "olbrzymie".
Granic midzy tymi pojciami jest okoo 8K znakw/token.
.SH GENEROWANIE SKANERW C++
.I flex
daje dwie drogi tworzenia skanerw przeznaczonych dla C++. Pierwsz z nich
jest proste skompilowanie fleksowego skanera kompilatorem C++ zamiast
kompilatora C. Nie powiniene napotka adnych bdw kompilacji (jeli si
pojawi, to zgo to pod adres wskazany niej, w sekcji o autorze). Moesz
wwczas w akcjach swoich regu uywa kodu C++ zamiast C. Zauwa, e
domylnym rdem dla skanera pozostaje
.IR yyin ,
a domylnym echem jest wci
.IR yyout .
Obydwa urzdzenia s zmiennymi
.IR "FILE *" ,
a nie strumieniami C++.
.PP
Mona te uy
.I fleksa
do generowania klasy skanera C++. Suy do tego opcja
.B \-+
(lub, rwnowanie
.BR "%option c++" ),
co jest przyjmowane automatycznie jeli nazwa pliku wykonywalnego fleksa
koczy si plusem, jak np.
.IR flex++ .
Przy uyciu tej opcji, flex generuje skaner do pliku
.B lex.yy.cc
zamiast
.BR lex.yy.c .
Generowany skaner zawiera plik nagwkowy
.IR FlexLexer.h ,
ktry definiuje interfejsy do dwch klas C++.
.PP
Pierwsza klasa,
.BR FlexLexer ,
daje abstrakcyjn klas bazow, definiujc oglny interfejs klasy skanera.
Daje nastpujce funkcje skadowe:
.TP
.B const char* YYText()
zwraca tekst ostatnio dopasowanego tokenu, rwnowanik
.BR yytext .
.TP
.B int YYLeng()
zwraca dugo ostatnio dopasowanego tokenu, rwnowanik
.BR yyleng .
.TP
.B int lineno() const
zwraca numer aktualnej linii wejciowej
(zobacz
.BR "%option yylineno" ),
lub
.B 1
jeli
.B %option yylineno
nie zostao uyte.
.TP
.B void set_debug( int flag )
ustawia flag debuggujc dla skanera, rwnowanik przypisania do
.B yy_flex_debug
(zobacz wyej sekcj o opcjach). Zauwa, e aby wcza w skanerze
informacje diagnostyczne, musisz skompilowa go z uyciem
.BR "%option debug" .
.TP
.B int debug() const
zwraca biece ustawienie flagi debuggujcej.
.PP
Udostpniane s te funkcje skadowe rwnowane
.BR yy_switch_to_buffer() ,
.B yy_create_buffer()
(chocia pierwszym argumentem jest wskanik
.BR istream* ,
a nie
.BR FILE* ),
.BR yy_flush_buffer() ,
.B yy_delete_buffer()
i
.B yyrestart()
(i znowu, pierwszym argumentem jest wskanik
.BR istream* ).
.PP
Kolejn klas zdefiniowan w
.I FlexLexer.h
jest
.BR yyFlexLexer ,
ktry jest klas pochodn
.BR FlexLexer .
Zaiwera nastpujce dodatkowe funkcje skadowe:
.TP
.B
yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
buduje obiekt
.B yyFlexLexer
stosujc podane strumienie jako wejcie i wyjcie. Jeli nie zostan
podane, to strumienie bd odpowiaday odpowiednio
.B cin
i
.BR cout .
.TP
.B virtual int yylex()
odgrywa t sam rol co
.B yylex()
dla normalnych skanerw fleksa: skanuje strumie wejciowy, konsumuje tokeny
a akcja reguy nie zwrci wartoci. Jeli z
.B yyFlexLexer
wyprowadzisz podklas
.B S
i zechcesz dosta si do funkcji i zmiennych skadowych
.B S
z wntrza
.BR yylex() ,
to musisz uy
.B %option yyclass="S"
by poinformowa
.IR fleksa ,
e bdziesz uywa podklasy zamiast 
.BR yyFlexLexer .
W tym wypadku zamiast generowa
.BR yyFlexLexer::yylex() ,
.I flex
generuje
.B S::yylex()
(oraz generuje prosty
.BR yyFlexLexer::yylex() ,
ktry woa
.B yyFlexLexer::LexerError()
po wywoaniu).
.TP
.B
virtual void switch_streams(istream* new_in = 0,
.B
ostream* new_out = 0)
przypisuje
.B yyin
do
.B new_in
(jeli jest nie-nil)
oraz
.B yyout
do
.B new_out
(ditto), kasujc poprzedni bufor wejciowy jeli przypisywana jest nowa
warto
.B yyin .
.TP
.B
int yylex( istream* new_in, ostream* new_out = 0 )
najpierw przecza strumienie wejciowe poprzez
.BR "switch_streams( new_in, new_out )" ,
a nastpnie zwraca warto
.BR yylex() .
.PP
Poza tym,
.B yyFlexLexer
definiuje nastpujce chronione (protected) funkcje wirtualne, ktre mona
przedefiniowa w klasach pochodnych, by dostosowa skaner:
.TP
.B
virtual int LexerInput( char* buf, int max_size )
odczytuje maksymalnie
.B max_size
znakw do
.B buf
i zwraca liczb odczytanych znakw. Aby wskaza koniec wejcia zwracane jest
0 znakw. Zauwa, e skanery "interaktywne" (zobacz flagi
.B \-B
oraz
.BR \-I )
definiuj makro
.BR YY_INTERACTIVE .
Jeli redefiniujesz
.B LexerInput()
i potrzebujesz bra rne akcje, zalenie od tego czy skaner skanuje rdo
interaktywne czy nie, to moesz sprawdza obecno tej nazwy poprzez
.BR #ifdef .
.TP
.B
virtual void LexerOutput( const char* buf, int size )
zapisuje
.B size
znakw z bufora
.B buf
ktry, o ile jest zakoczony zerem, moe zawiera te "wewntrzne" zera
jeli reguy skanera mog apa tekst z wewntrznymi zerami.
.TP
.B
virtual void LexerError( const char* msg )
zgasza komunikat bdu krytycznego. Domylna wersja tej funkcji zapisuje
komunikat do strumienia
.B cerr
i koczy dziaanie programu.
.PP
Zauwa, e obiekt
.B yyFlexLexer
zawiera swj
.I peny
stan skanowania. Tak wic mona uywa takich obiektw do tworzenia 
wielobienych (reentrant) skanerw. Moesz uywa wielu instancji tej samej
klasy
.BR yyFlexLexer ,
jak rwnie moesz w jednym programie czy wiele klas skanerw w cao,
uywajc opisanej wyej opcji
.B \-P .
.PP
Dla skanerw C++ nie jest dostpna waciwo
.BR %array ,
trzeba wic uywa
.B %pointer
(tj. wartoci domylnej).
.PP
Oto przykad prostego skanera C++:
.nf

        // Przykad uycia klasy skanera C++

    %{
    int mylineno = 0;
    %}

    string  \\"[^\\n"]+\\"

    ws      [ \\t]+

    alpha   [A-Za-z]
    dig     [0-9]
    name    ({alpha}|{dig}|\\$)({alpha}|{dig}|[_.\\-/$])*
    num1    [-+]?{dig}+\\.?([eE][-+]?{dig}+)?
    num2    [-+]?{dig}*\\.{dig}+([eE][-+]?{dig}+)?
    number  {num1}|{num2}

    %%

    {ws}    /* pomi spacje i tabulacje */

    "/*"    {
            int c;

            while((c = yyinput()) != 0)
                {
                if(c == '\\n')
                    ++mylineno;

                else if(c == '*')
                    {
                    if((c = yyinput()) == '/')
                        break;
                    else
                        unput(c);
                    }
                }
            }

    {number}  cout << "number " << YYText() << '\\n';

    \\n        mylineno++;

    {name}    cout << "name " << YYText() << '\\n';

    {string}  cout << "string " << YYText() << '\\n';

    %%

    int main( int /* argc */, char** /* argv */ )
        {
        FlexLexer* lexer = new yyFlexLexer;
        while(lexer->yylex() != 0)
            ;
        return 0;
        }
.fi
Jeli chcesz tworzy wiele (rnych) klas leksera, powiniene uy flagi
.B \-P
(lub opcji
.BR prefiks= )
do zmiany nazwy kadego
.B yyFlexLexer
na inny
.BR xxFlexLexer .
Nastpnie moesz zacza
.B <FlexLexer.h>
do swoich innych rde, raz na klas leksera, zmieniajc najpierw nazw
.B yyFlexLexer
w nastpujcy sposb:
.nf

    #undef yyFlexLexer
    #define yyFlexLexer xxFlexLexer
    #include <FlexLexer.h>

    #undef yyFlexLexer
    #define yyFlexLexer zzFlexLexer
    #include <FlexLexer.h>

.fi
o ile (na przykad) uyjesz opcji
.B %option prefix="xx"
dla jednego ze swoich skanerw, a
.B %option prefix="zz"
dla drugiego.
.PP
WANE: obecna posta klasy skanujcej jest
.I eksperymentalna
i moe zmienia si midzy gwnymi wydaniami.
.SH NIEZGODNOCI Z LEX I POSIX
.I flex
jest przerbk narzdzia
.I lex
z AT&T Unix (jednake obie te implementacje nie maj wsplnego kodu). Posiada pewne
rozszerzenia i niezgodnoci, ktre s istotne dla tych, ktrzy chc pisa
skanery dziaajce z oboma. Flex jest w peni zgodny ze
specyfikacj POSIX
.I lex
poza szczegem, e gdy uywa
.B %pointer
(domylne), to wywoanie
.B unput()
niszczy zawarto
.BR yytext ,
co jest niezgodne ze specyfikacj POSIX.
.PP
W sekcji tej omwimy wszystkie znane obszary niezgodnoci fleksa z AT&T lex
i specyfikacj POSIX.
.PP
.I fleksowa opcja
.B \-l
wcza maksymaln zgodno z oryginalnym AT&T
.IR lex ,
okupujc to jednak znacznymi stratami wydajnoci generowanego skanera.
Niej zaznaczymy, ktre niezgodnoci mona pokona uywajc opcji
.BR \-l .
.PP
.I flex
jest w peni zgodny z
.I leksem
poza nastpujcymi wyjtkami:
.IP -
Nieudokumentowana zmienna wewntrzna skanera
.I lex
o nazwie
.B yylineno
nie jest obsugiwana bez
.B \-l
lub
.BR "%option yylineno" .
.IP
.B yylineno
powinno by obsugiwane na poziomie buforowym, a nie na skanerowym
(pojedyncza zmienna globalna).
.IP
.B yylineno
nie jest czci specyfikacji POSIX.
.IP -
Procedura
.B input()
nie jest redefiniowalna chocia moe by woana do czytania znakw
nastpujcym po tym, co dopasowano do reguy. Jeli
.B input()
napotka koniec pliku, to wykonywane jest normalne przetwarzanie
.BR yywrap() .
``Prawdziwy'' koniec pliku jest sygnalizowany przez
.B input()
zwrceniem wartoci
.IR EOF .
.IP
Wejcie jest natomiast sterowane przez definiowanie makra
.BR YY_INPUT .
.IP
Ograniczenie
.IR fleksa ,
e
.B input()
nie moe by redefiniowany jest zgodne ze specyfikacj POSIX, ktra
po prostu nie okrela innego adnego sposobu sterowania wejciem skanera ni
poprzez dokonanie pocztkowego przypisania do 
.I yyin.
.IP -
Procedura
.B unput()
nie jest redefiniowalna. Ograniczenie to jest zgodne z POSIX.
.IP -
Skanery
.I fleksa
nie s tak wielobiene (reentrant) jak skanery
.IR lex . 
W szczeglnoci, jeli masz interaktywny skaner i obsug przerwa, ktra robi
dugi skok ze skanera, a skaner jest nastpnie woany ponownie, to moesz
uzyska nastpujcy komunikat:
.nf

    fatal flex scanner internal error--end of buffer missed

.fi
Aby wej na nowo do skanera, uyj najpierw
.nf

    yyrestart( yyin );

.fi
Zauwa, e wywoanie to wyrzuci wszelkie buforowane wejcie; zwykle jednak
nie jest to problem przy skanerach interaktywnych.
.IP
Zauwa te, e klasy skanerw C++
.I s
wielobiene (reentrant), wic uywajc opcji C++ powiniene ich uywa. Zobacz
sekcj o generowaniu skanerw C++.
.IP -
.B output()
nie jest obsugiwany. Wyjcie makra
.B ECHO
jest wykonywane do wskanika plikowego
.I yyout
(domylnie
.IR stdout ).
.IP
.B output()
nie jest czci specyfikacji POSIX.
.IP -
.I lex
nie obsuguje wykluczajcych warunkw pocztkowych (%x), cho znajduj si one w
specyfikacji POSIX.
.IP -
Przy rozwijaniu definicji,
.I flex
ujmuje je w nawiasy.
W leksie, nastpujce:
.nf

    NAME    [A-Z][A-Z0-9]*
    %%
    foo{NAME}?      printf( "Znalazem\\n" );
    %%

.fi
nie dopasuje si do acucha "foo", gdy makro jest rozwijane tak, e regua
odpowiada "foo[A-Z][A-Z0-9]*?", a pierwszestwo jest takie, e '?' jest
wizany z "[A-Z0-9]*". We fleksie regua zostaaby rozwinita do
"foo([A-Z][A-Z0-9]*)?" i acuch "foo" zostaby dopasowany.
.IP
Zauwa, e jeli definicja rozpoczyna si od
.B ^
lub koczy si na
.B $
to
.I nie
jest rozwijana w nawiasach, aby umoliwi tym operatorom pojawienie si w
definicjach bez utraty ich znaczenia. Ale operatory
.BR <s> ,
.B /
i
.B <<EOF>>
nie mog by uywane w definicji fleksa.
.IP
Uywanie
.B \-l
skutkuje
.I leksowym
zachowaniem braku nawiasw wok definicji.
.IP
POSIX nakazuje ujmowanie definicji w nawiasy.
.IP -
Niektre implementacje
.I leksa
umoliwiaj rozpoczynanie akcji regu w osobnej linii jeli wzorzec reguy
ma doklejon bia spacj:
.nf

    %%
    foo|bar<tu spacja>
      { foobar_action(); }

.fi
.I flex
nie obsuguje tej waciwoci.
.IP -
.I Leksowe
.B %r
(generuj skaner Ratfor) nie jest obsugiwane. Nie jest czci specyfikacji
POSIX.
.IP -
Po wywoaniu
.BR unput() ,
.I yytext
jest niezdefiniowane a do dopasowania nastpnego tokenu, chyba e skaner
uywa
.BR %array .
Inaczej ma si sprawa z
.I leksem
lub specyfikacj POSIX. Opcja
.B \-l
zaatwia t niezgodno.
.IP -
Pierwszestwo operatora
.B {}
(zakresu numerycznego) jest inne.
.I lex
interpretuje "abc{1,3}" jako "dopasuj 1, 2 lub 3 pojawienia 'abc'", a
.I flex
interpretuje to jako "dopasuj 'ab' z doklejonym jednym, dwoma lub trzema
znakami 'c'". Interpretacja fleksowa jest zgodna ze specyfikacj POSIX.
.IP -
Pierwszestwo operatora
.B ^
jest inne.
.I lex
interpretuje "^foo|bar" jako "dopasuj albo 'foo' z pocztku linii albo 'bar'
gdziekolwiek", podczas gdy
.I flex
rozumie to jako "dopasuj 'foo' lub 'bar' jeli pojawi si na pocztku
linii". To drugie jest zgodne ze specyfikacj POSIX.
.IP -
Specjalne deklaracje rozmiaru-tablicy, takie jak
.BR %a ,
obsugiwane przez
.I lex
nie s wymagane przez skanery
.IR fleksa ;
.I flex
je ignoruje.
.IP -
Nazwa
.bd
FLEX_SCANNER
jest #definiowana, wic skanery mog by pisane z przeznaczeniem do uycia z 
.I fleksem
lub
.IR leksem .
Skanery zawieraj rwnie
.B YY_FLEX_MAJOR_VERSION
i
.B YY_FLEX_MINOR_VERSION
wskazujc na wersj
.IR fleksa ,
ktra wygenerowaa skaner (na przykad dla wydania 2.5 definiowane s
odpowiednio liczby 2 i 5).
.PP
Nastpujce waciwoci
.I fleksa
nie s zawarte w specyfikacjach
.I lex
ani POSIX:
.nf

    Skanery C++
    %option
    zakresy warunkw pocztkowych
    stosy warunkw pocztkowych
    skanery interaktywne/nieinteraktywne
    yy_scan_string() i koledzy
    yyterminate()
    yy_set_interactive()
    yy_set_bol()
    YY_AT_BOL()
    <<EOF>>
    <*>
    YY_DECL
    YY_START
    YY_USER_ACTION
    YY_USER_INIT
    dyrektywy #line
    %{} wok akcji
    wiele akcji w linii

.fi
plus prawie wszystkie flagi fleksa. Ostatnia waciwo listy odnosi si do
faktu, e we fleksie mona wstawia wiele akcji do jednej linii,
rozdzielajc je rednikami, podczas gdy w
.IR leksie ,
nastpujca instrukcja
.nf

    foo    handle_foo(); ++num_foos_seen;

.fi
jest (raczej niespodziewanie) obcinana do
.nf

    foo    handle_foo();

.fi
.I flex
nie obcina akcji. Akcje ktre nie s objte klamrami kocz si zwyczajnie
na kocu linii.
.SH DIAGNOSTYKA
.PP
.I warning, rule cannot be matched
(ostrzeenie, regua nie moe by dopasowana) wskazuje, e podana regua nie
moe by dopasowana gdy wystpuje za innymi reguami, ktre zawsze
dopasuj jej tekst. Na przykad nastpujce foo nie moe by dopasowane, gdy
pojawia si po regule ap-wszystko:
.nf

    [a-z]+    got_identifier();
    foo       got_foo();

.fi
Uycie w skanerze
.B REJECT
powstrzyma to ostrzeenie.
.PP
.IR warning ,
.B \-s
.I option given but default rule can be matched
(ostrzeenie, podano opcj \-s, lecz dopasowana moe by regua domylna)
oznacza, e moliwe jest (przypuszczalnie tylko w konkretnym warunku
pocztkowym), e regua domylna (dopasowania dowolnego znaku) jest jedyn,
ktra dopasuje si do konkretnego wejcia. Poniewa podano
.BR \-s ,
zakada si, e nie jest to celowe.
.PP
.I reject_used_but_not_detected undefined
lub
.I yymore_used_but_not_detected undefined
(niezdefiniowana fraza pierwsza lub druga) -
te bdy pojawiaj si podczas kompilacji. Wskazuj one, e
skaner uywa
.B REJECT
lub
.BR yymore() , 
lecz
.I flex
nie poinformowa o tym fakcie. Znaczy to, e
.I flex
przeskanowa pierwsze dwie sekcji w poszukiwaniu pojawienia si tych akcji,
ale ich nie znalaz, bo jako je przemycie (np. przez plik #include). Uyj
.B %option reject
lub
.B %option yymore
do wskazania fleksowi, e naprawd uywasz tych waciwoci.
.PP
.I flex scanner jammed
\- skaner skompilowany z
.B \-s
napotka acuch wejciowy, ktry nie zosta dopasowany do adnej z jego
regu. Bd ten moe si pojawi te z powodu problemw wewntrznych.
.PP
.I token too large, exceeds YYLMAX
(token zbyt duy, przekracza YYLMAX) -
twj skaner uywa
.B %array
a jedna z jego regu dopasowaa si do acucha duszego ni staa
.B YYLMAX
(domylnie 8K). Moesz zwikszy t warto zwikszajc #definicj staej
.B YYLMAX
w sekcji definicji swojego wejcia
.IR fleksa .
.PP
.I scanner requires \-8 flag to
.I use the character 'x' 
(skaner wymaga flagi \-8 do uywania znaku 'x') -
specyfikacja twojego skanera zawiera rozpoznawanie znaku 8-bitowego
.IR 'x' ,
a nie podana zostaa flaga \-8, w wyniku czego skaner uy 7-bit z powodu
wykorzystania opcji kompresji tablic
.B \-Cf
lub
.BR \-CF .
Dla szczegw zobacz dyskusj flagi
.BR \-7 .
.PP
.I flex scanner push-back overflow
\- uye
.B unput()
do wepchnicia z powrotem tak dugiego tekstu, e bufor skanera nie potrafi
przetrzyma wepchnitego tekstu i biecego tokena w
.B yytext.
Idealny skaner powinien dynamicznie zmieni rozmiar bufora, lecz obecnie tak
si nie dzieje.
.PP
.I input buffer overflow, can't enlarge buffer because scanner uses REJECT
(przekroczenie bufora wejciowego nie moe powikszy bufora gdy skaner
uywa REJECT) -
skaner pracowa nad dopasowaniem bardzo duego tokenu i potrzebowa
rozszerzy bufor wejciowy. Nie dziaa to ze skanerami, uywajcymi
.B
REJECT.
.PP
.I fatal flex scanner internal error--end of buffer missed
(krytyczny bd wewntrzny skanera flex -- rozminito si z kocem bufora) -
Moe si to pojawi w skanerze, ktry jest uruchomiony po dugim skoku z
ramki aktywacji skanera. Przed powrotem do skanera uyj:
.nf

    yyrestart( yyin );

.fi
albo, jak wspomniano wyej, przecz si na uywanie skanerw C++.
.PP
.I too many start conditions in <> construct!
(zbyt wiele warunkw pocztkowych w konstrukcji <>) -
w konstrukcji <> pojawio si wicej warunkw pocztkowych ni istnieje w
rzeczywistoci (wic przynajmniej jeden z nich pojawi si dwukrotnie).
.SH PLIKI
.TP
.B \-lfl
biblioteka, z ktr musz by czone skanery.
.TP
.I lex.yy.c
generowany skaner (nazywany na niektrych systemach
.IR lexyy.c ).
.TP
.I lex.yy.cc
generowana klasa skanera C++, po uyciu
.BR -+ .
.TP
.I <FlexLexer.h>
plik nagwkowy definiujcy klas bazow skanera C++,
.B FlexLexer
i klas pochodn,
.BR yyFlexLexer .
.TP
.I flex.skl
skaner szkieletowy. Plik ten jest uywany tylko przy budowaniu fleksa, nie
przy jego uruchamianiu.
.TP
.I lex.backup
informacje wspierajce (backing-up) dla flagi
.B \-b
(nazywany jest mianem
.I lex.bck
na niektrych systemach).
.SH NIEDOSTATKI / BDY
.PP
Niektre wzorce wiszcego kontekstu nie mog by poprawnie dopasowane i
generuj komunikaty ostrzegawcze ("dangerous trailing context")
(niebezpieczny wiszcy kontekst). S to wzorce, gdzie zakoczenie pierwszej
czci reguy dopasowuje si do pocztku drugiej czci, takie jak
"zx*/xy*", gdzie 'x*' dopasowuje 'x' na pocztku wiszcego kontekstu.
(Zauwa, e projekt POSIX-a okrela, e dopasowany w takich wzorcach tekst jest
niezdefiniowany.)
.PP
Dla niektrych regu wiszcego kontekstu, czci ktre s w rzeczywistoci
okrelonej dugoci nie s tak rozpoznawane. Prowadzi to do wspomnianej
wyej straty wydajnoci. W szczeglnoci, czci uywajce '|' lub {n}
(takie jak "foo{3}") zawsze s uwaane za zmienno-dugociowe.
.PP
czenie wiszcego kontekstu z akcj specjaln '|' moe spowodowa, e
.I ustalony
(fixed) wiszcy kontekst zostanie zmieniony w bardziej kosztowny, 
.I zmienny
wiszcy kontekst. Na przykad nastpujce:
.nf

    %%
    abc      |
    xyz/def

.fi
.PP
Uywanie
.B unput()
uszkadza yytext i yyleng, chyba e uyto dyrektywy
.B %array
lub opcji
.BR \-l . 
.PP
Dopasowywanie wzorcw NUL-i jest znacznie wolniejsze ni dopasowywanie innych
znakw.
.PP
Dynamiczne zmiany rozmiaru bufora s wolne i wymagaj reskanowania caego
tekstu dopasowanego dotd przez biecy (zwykle duy) token.
.PP
Z powodu buforowania wejcia i czytania z wyprzedzeniem, nie mona czy
z reguami fleksa wywoa <stdio.h>, np.
.BR getchar() .
Zamiast tego woaj
.BR input() . 
.PP
Wpisy caej tablicy (total table entries) wymieniane przez flag
.B \-v
nie zawieraj niektrych wpisw, potrzebnych do okrelania, ktra regua
zostaa dopasowana. Liczba wpisw jeli skaner nie uywa \fBREJECT\fR
jest rwna liczbie stanw DFA, a w przeciwnym wypadku jest troch wiksza.
.PP
.B REJECT
nie moe by uywany z opcjami
.B \-f
lub
.BR \-F .
.PP
Wewntrzne algorytmy
.I fleksa
wymagaj udokumentowania.
.SH ZOBACZ TAKE
.PP
lex(1), yacc(1), sed(1), awk(1).
.PP
John Levine, Tony Mason, and Doug Brown,
.IR "Lex & Yacc" ,
O'Reilly and Associates.  Upewnij si, e bierzesz 2-gie wydanie.
.PP
M. E. Lesk and E. Schmidt,
.I LEX \- Lexical Analyzer Generator
.PP
Alfred Aho, Ravi Sethi and Jeffrey Ullman,
.I Compilers: Principles, Techniques and Tools,
Addison-Wesley (1986).  Opisuje techniki dopasowywania wzorcw uywane przez
.I fleksa
(deterministyczne automaty skoczone).
.SH AUTOR
Vern Paxson, z pomoc wielu pomysw i inspiracji od
Vana Jacobsona.  Oryginaln wersj napisa Jef Poskanzer. 
Reprezentacja szybkiej tablicy jest czciow implementacj projektu
Vana Jacobsona. Implementacja zostaa wykonana przez
Kevina Gonga and Verna Paxsona.
.PP
Podzikowania dla wielu beta testerw, komentatorw i kontrybutorw fleksa,
z ktrych szczeglnie zasuone s nastpujce osoby:
Francois Pinard,
Casey Leedom,
Robert Abramovitz,
Stan Adermann, Terry Allen, David Barker-Plummer, John Basrai,
Neal Becker, Nelson H.F. Beebe, benson@odi.com,
Karl Berry, Peter A. Bigot, Simon Blanchard,
Keith Bostic, Frederic Brehm, Ian Brockbank, Kin Cho, Nick Christopher,
Brian Clapper, J.T. Conklin,
Jason Coughlin, Bill Cox, Nick Cropper, Dave Curtis, Scott David
Daniels, Chris G. Demetriou, Theo Deraadt,
Mike Donahue, Chuck Doucette, Tom Epperly, Leo Eskin,
Chris Faylor, Chris Flatters, Jon Forrest, Jeffrey Friedl,
Joe Gayda, Kaveh R. Ghazi, Wolfgang Glunz,
Eric Goldman, Christopher M. Gould, Ulrich Grepel, Peer Griebel,
Jan Hajic, Charles Hemphill, NORO Hideo,
Jarkko Hietaniemi, Scott Hofmann,
Jeff Honig, Dana Hudes, Eric Hughes, John Interrante,
Ceriel Jacobs, Michal Jaegermann, Sakari Jalovaara, Jeffrey R. Jones,
Henry Juengst, Klaus Kaempf, Jonathan I. Kamens, Terrence O Kane,
Amir Katz, ken@ken.hilco.com, Kevin B. Kenny,
Steve Kirsch, Winfried Koenig, Marq Kole, Ronald Lamprecht,
Greg Lee, Rohan Lenard, Craig Leres, John Levine, Steve Liddle,
David Loffredo, Mike Long,
Mohamed el Lozy, Brian Madsen, Malte, Joe Marshall,
Bengt Martensson, Chris Metcalf,
Luke Mewburn, Jim Meyering, R. Alexander Milowski, Erik Naggum,
G.T. Nicol, Landon Noll, James Nordby, Marc Nozell,
Richard Ohnemus, Karsten Pahnke,
Sven Panne, Roland Pesch, Walter Pelissero, Gaumond
Pierre, Esmond Pitt, Jef Poskanzer, Joe Rahmeh, Jarmo Raiha,
Frederic Raimbault, Pat Rankin, Rick Richardson,
Kevin Rodgers, Kai Uwe Rommel, Jim Roskind, Alberto Santini,
Andreas Scherer, Darrell Schiebel, Raf Schietekat,
Doug Schmidt, Philippe Schnoebelen, Andreas Schwab,
Larry Schwimmer, Alex Siegel, Eckehard Stolz, Jan-Erik Strvmquist,
Mike Stump, Paul Stuart, Dave Tallman, Ian Lance Taylor,
Chris Thewalt, Richard M. Timoney, Jodi Tsai,
Paul Tuinenga, Gary Weik, Frank Whaley, Gerhard Wilhelms, Kent Williams, Ken
Yap, Ron Zellar, Nathan Zelle, David Zuhn,
oraz ci, ktrych nazwiska wyleciay z moich zdolnoci archiwizowania poczty,
lecz ktrych wkad jest rwnie wany.
.PP
Keith Bostic, Jon Forrest, Noah Friedman,
John Gilmore, Craig Leres, John Levine, Bob Mulcahy, G.T.
Nicol, Francois Pinard, Rich Salz i Richard Stallman pomogli z rnymi
problemami dystrybucji.
.PP
Esmond Pitt and Earle Horton pomg z wsparciem 8-bit;
Benson Margulies i Fred Burke pomogli z wsparciem C++;
Kent Williams i Tom Epperly pomogli z wsparciem klas C++;
Ove Ewerlid pomg z wsparciem NUL-w;
Eric Hughes pomg z wielokrotnymi buforami.
.PP
Praca ta bya pocztkowo wykonywana gdy byem z Real Time Systems Group
w Lawrence Berkeley Laboratory w Berkeley, CA. Wielkie dziki
do wszystkich za wsparcie, ktre uzyskaem.
.PP
Komentarze lij do vern@ee.lbl.gov.