re2c - Online sa Cloud

PROGRAMA:

NAME

re2c - i-convert ang mga regular na expression sa C/C++ code

SINOPSIS

re2c [OPSYON] FILE

DESCRIPTION

re2c ay isang lexer generator para sa C/C++. Nakahanap ito ng mga pagtutukoy ng regular na expression sa loob ng
Mga komento ng C/C++ at pinapalitan ang mga ito ng isang hard-coded na DFA. Ang gumagamit ay dapat magbigay ng ilan
interface code upang makontrol at ma-customize ang nabuong DFA.

Opsyon

-? -h - Tumulong
Humingi ng maikling tulong.

-b --bit-vectors
Nagpapahiwatig -s. Gumamit din ng mga bit vector sa pagtatangkang suyuin ang mas mahusay na code mula sa
compiler. Pinaka-kapaki-pakinabang para sa mga pagtutukoy na may higit sa ilang mga keyword (hal para sa
karamihan sa mga programming language).

-c --kondisyon
Ginamit upang suportahan ang (f)lex-like condition support.

-d --debug-output
Gumagawa ng parser na nagtatapon ng impormasyon tungkol sa kasalukuyang posisyon at kung saan
sabihin ang parser ay habang pina-parse ang input. Ito ay kapaki-pakinabang upang i-debug ang mga isyu sa parser
at estado. Kung gagamitin mo ang switch na ito kailangan mong tukuyin ang isang macro YYDEBUG iyon ay
tinatawag na tulad ng isang function na may dalawang mga parameter: walang bisa YYDEBUG (int.) estado, tangke kasalukuyang).
Ang unang parameter ay tumatanggap ng estado o -1 at ang pangalawang parameter ay tumatanggap ng
input sa kasalukuyang cursor.

-D --naglalabas-tuldok
Maglabas ng Graphviz dot data. Maaari itong maiproseso gamit ang hal tuldok -Tpng input.dot >
output.png. Pakitandaan na ang mga scanner na may maraming estado ay maaaring mag-crash ng tuldok.

-e --ecb
Bumuo ng parser na sumusuporta sa EBCDIC. Ang nabuong code ay maaaring makitungo sa anuman
character hanggang 0xFF. Sa ganitong mode re2c ipinapalagay na ang laki ng input ng character ay 1
byte. Ang switch na ito ay hindi tugma sa -w, -x, -u at -8.

-f --storable-state
Bumuo ng scanner na may suporta para sa storable na estado.

-F --flex-syntax
Bahagyang suporta para sa flex syntax. Kapag aktibo ang flag na ito, pinangalanan ang mga kahulugan
dapat na napapalibutan ng mga kulot na braces at maaaring tukuyin nang walang katumbas na tanda at ang
pagwawakas ng semi colon. Sa halip, ang mga pangalan ay itinuturing bilang mga direktang double quoted na string.

-g --computed-gotos
Bumuo ng scanner na gumagamit ng computed goto feature ng GCC. Yan ay re2c
bumubuo ng mga jump table sa tuwing ang isang desisyon ay may partikular na kumplikado (hal
kung kinakailangan ang mga kundisyon). Ito ay magagamit lamang sa GCC at gumagawa
output na hindi maaaring isama sa anumang iba pang compiler. Tandaan na ito ay nagpapahiwatig -b
at na ang threshold ng pagiging kumplikado ay maaaring i-configure gamit ang inplace na configuration
cgoto:threshold.

-i --no-debug-info
Huwag output #linya impormasyon. Ito ay kapaki-pakinabang kapag gusto mong gumamit ng CMS tool na may
ang re2c output na maaaring gusto mo kung hindi mo kailangan na magkaroon ang iyong mga user re2c
kanilang sarili kapag bumubuo mula sa iyong pinagmulan.

-o oUTPUT --output=OUTPUT
tukuyin ang oUTPUT file.

-r --magagamit muli
Nagbibigay-daan sa muling paggamit ng mga kahulugan ng scanner na may /*!use:re2c */ pagkatapos /*!rules:re2c */. Sa
itong mode no /*!re2c */ block at eksaktong isa /*!rules:re2c */ dapat nandiyan.
Ang mga patakaran ay ini-save at ginagamit ng bawat /*!use:re2c */ block na sumusunod.
Ang mga bloke na ito ay maaaring maglaman ng mga inplace na configuration, lalo na re2c:flags:e,
re2c:flags:w, re2c:flags:x, re2c:flags:u at re2c:flags:8. Sa ganoong paraan posible
upang gumawa ng parehong scanner nang maraming beses para sa iba't ibang uri ng character, magkaiba
mga mekanismo ng input o iba't ibang mekanismo ng output. Ang /*!use:re2c */ maaari ng mga bloke
naglalaman din ng mga karagdagang panuntunan na idaragdag sa hanay ng mga panuntunan sa
/*!rules:re2c */.

-s --nested-ifs
Bumuo ng mga nested if para sa ilang switch. Maraming compiler ang nangangailangan ng tulong na ito para makabuo
mas magandang code.

-t HEADER --type-header=HEADER
Gumawa ng HEADER file na naglalaman ng mga uri para sa (f)lex-like condition support.
Maa-activate lang ito kapag -c ay ginagamit.

-u --unicode
Bumuo ng parser na sumusuporta sa UTF-32. Ang nabuong code ay maaaring makitungo sa anumang wastong
Unicode character hanggang 0x10FFFF. Sa ganitong mode re2c ipinapalagay na input character
ang laki ay 4 bytes. Ang switch na ito ay hindi tugma sa -e, -w, -x at -8. Ito ay nagpapahiwatig
-s.

-v --bersyon
Ipakita ang impormasyon ng bersyon.

-V --vernum
Ipakita ang bersyon bilang isang numerong XXYYZZ.

-w --wide-chars
Bumuo ng parser na sumusuporta sa UCS-2. Ang nabuong code ay maaaring makitungo sa anumang wastong
Unicode character hanggang 0xFFFF. Sa ganitong mode re2c ipinapalagay na input character
ang laki ay 2 bytes. Ang switch na ito ay hindi tugma sa -e, -x, -u at -8. Ito ay nagpapahiwatig
-s.

-x --utf-16
Bumuo ng parser na sumusuporta sa UTF-16. Ang nabuong code ay maaaring makitungo sa anumang wastong
Unicode character hanggang 0x10FFFF. Sa ganitong mode re2c ipinapalagay na input character
ang laki ay 2 bytes. Ang switch na ito ay hindi tugma sa -e, -w, -u at -8. Ito ay nagpapahiwatig
-s.

-8 --utf-8
Bumuo ng parser na sumusuporta sa UTF-8. Ang nabuong code ay maaaring makitungo sa anumang wastong
Unicode character hanggang 0x10FFFF. Sa ganitong mode re2c ipinapalagay na input character
ang laki ay 1 byte. Ang switch na ito ay hindi tugma sa -e, -w, -x at -u.

--case-insensitive
Ang lahat ng mga string ay case insensitive, kaya lahat ng "-expression ay ginagamot sa parehong paraan
'-ang mga ekspresyon ay.

--case-inverted
Baligtarin ang kahulugan ng single at double quoted strings. Gamit itong switch single
case sensitive ang mga quotes at case insensitive ang double quotes.

--no-generation-date
Pigilan ang output ng petsa sa nabuong file.

--no-generation-date
Pigilan ang output ng bersyon sa nabuong file.

--encoding-patakaran PATAKARAN
Tukuyin kung paano re2c dapat tratuhin ang Unicode surrogates. PATAKARAN maaaring isa sa mga sumusunod:
mabigo (i-abort nang may pagkakamali kapag nakatagpo ng kahalili), kapalit (tahimik na kapalit
pumalit sa error code point 0xFFFD), huwag pansinin ( ituring ang mga kahalili bilang normal na code
puntos). Bilang default re2c binabalewala ang mga kahalili (para sa paatras na pagkakatugma). Unicode
sabi ng standard na ang mga standalone surrogates ay mga invalid na code point, ngunit iba
iba ang pakikitungo sa kanila ng mga aklatan at programa.

--input INPUT
Tukuyin ang re2c input API. INPUT maaaring isa sa mga sumusunod: default, pasadya.

-S --balangkas
Sa halip na i-embed ang re2c-generated code sa C/C++ source, bumuo ng a
self-contained na programa para sa parehong DFA. Pinaka kapaki-pakinabang para sa kawastuhan at
subukan ang performance.

--walang laman-klase PATAKARAN
Ano ang gagawin kung ang user ay nagpasok ng walang laman na klase ng character. PATAKARAN maaaring isa sa mga
sumusunod: posporo-walang laman (itugma ang walang laman na input: medyo hindi makatwiran, ngunit ito ang
default para sa pabalik na dahilan ng compatibility), tugma-wala (hindi tumugma sa alinman
input), mali (error sa compilation). Tandaan na mayroong iba't ibang paraan upang bumuo
walang laman na klase, hal: [], [^\x00-\xFF], [\x00-\xFF][\x00-\xFF].

--dfa-minimization <mesa | moore>
Panloob na algorithm na ginagamit ng re2c upang mabawasan ang DFA (mga default sa Moore). Parehong mesa
pagpuno at ang mga algorithm ni Moore ay dapat gumawa ng magkaparehong DFA (hanggang sa mga estado
muling pag-label). Ang algorithm sa pagpuno ng talahanayan ay mas simple at mas mabagal; ito ay nagsisilbing a
pagpapatupad ng sanggunian.

-1 --single-pass
Hindi na ginagamit at walang ginagawa (sa default ngayon ang solong pass).

-W I-on ang lahat ng babala.

-Werror
Gawing mga error ang mga babala. Tandaan na ang opsyong ito kasama ay hindi nag-o-on ng anuman
mga babala, naaapektuhan lamang nito ang mga babalang naka-on sa ngayon o magiging
naka-on mamaya.

-W
I-on ang indibidwal babala.

-Wno-
I-off ang indibidwal babala.

-Werror-
I-on ang indibidwal babala at ituring ito bilang error (ito ay nagpapahiwatig -W).

-Wno-error-
Huwag tratuhin ang partikular na ito babala bilang pagkakamali. Hindi nito pinapatay ang babala
mismo.

-Wkondisyon-order
Magbabala kung ang nabuong programa ay gumagawa ng mga implicit na pagpapalagay tungkol sa pagnunumero ng kundisyon.
Dapat gamitin ng isa ang alinman -t, --type-header pagpipilian o /*!types:re2c*/ direktiba sa
bumuo ng pagmamapa ng mga pangalan ng kundisyon sa mga numero at gumamit ng autogenerated na kundisyon
mga pangalan.

-Wempty-character-class
Magbabala kung ang regular na expression ay naglalaman ng walang laman na klase ng character. Mula sa makatwirang punto
of view na sinusubukang itugma ang walang laman na klase ng character ay walang saysay: dapat palagi
mabibigo. Gayunpaman, para sa pabalik na mga dahilan ng pagiging tugma re2c nagbibigay-daan sa walang laman na karakter
klase at tinatrato ito bilang walang laman na string. Gamitin --walang laman-klase opsyon upang baguhin ang default
pag-uugali.

-Wmatch-empty-string
Magbabala kung ang regular na expression sa isang panuntunan ay nullable (tumutugma sa walang laman na string). Kung ang DFA
tumatakbo sa isang loop at walang laman na tugma ay hindi sinasadya (input posisyon sa hindi advanced
mano-mano), maaaring ma-stuck si lexer sa eternal loop.

-Wswapped-range
Magbabala kung ang hanay na lower bound ay mas malaki kaysa sa upper bound. Default re2c pag-uugali ay upang
tahimik na magpalit ng mga hangganan ng saklaw.

-Wundefined-control-flow
Magbabala kung ang ilang input string ay nagdudulot ng hindi natukoy na daloy ng kontrol sa lexer (ang may sira
ang mga pattern ay iniulat). Ito ang pinaka-mapanganib at karaniwang pagkakamali. Maaari itong maging
madaling maayos sa pamamagitan ng pagdaragdag ng default na panuntunan * (Ang panuntunang ito ay may pinakamababang priyoridad, mga tugma
anumang unit ng code at gumagamit ng eksaktong isang unit ng code).

-Wuseless-escape
Magbabala kung ang isang simbolo ay tumakas nang hindi dapat. Bilang default, tahimik na binabalewala ng re2c
pagtakas, ngunit maaari rin itong magpahiwatig ng typo o error sa pagkakasunud-sunod ng pagtakas.

Interface CODE

Ang user ay dapat magbigay ng interface code alinman sa anyo ng C/C++ code (macros, functions,
mga variable, atbp.) o sa anyo ng SA LUGAR KONFIGURASYON. Aling mga simbolo ang dapat tukuyin
at alin ang opsyonal ay depende sa isang partikular na kaso ng paggamit.

YYCONDTYPE
In -c mode na magagamit mo -t upang bumuo ng isang file na naglalaman ng enumeration na ginamit bilang
kundisyon. Ang bawat isa sa mga halaga ay tumutukoy sa isang kundisyon ng isang set ng panuntunan.

YYCTXMARKER
l-halaga ng uri YYCTYPE *. Ang nabuong code ay nagse-save ng trailing context backtracking
impormasyon sa YYCTXMARKER. Kailangan lang tukuyin ng user ang macro na ito kung isang scanner
Ang pagtutukoy ay gumagamit ng sumusunod na konteksto sa isa o higit pa sa mga regular na expression nito.

YYCTYPE
Uri na ginagamit upang hawakan ang isang input na simbolo (code unit). Karaniwan tangke or hindi naka -ignign tangke para
ASCII, EBCDIC at UTF-8, hindi naka -ignign maikli para sa UTF-16 o UCS-2 at hindi naka -ignign int para
UTF-32.

YYCURSOR
l-halaga ng uri YYCTYPE * na tumuturo sa kasalukuyang simbolo ng input. Ang nabuo
pagsulong ng code YYCURSOR bilang mga simbolo ay tugma. Sa pagpasok, YYCURSOR ay ipinapalagay na
ituro ang unang character ng kasalukuyang token. Paglabas, YYCURSOR ituturo sa
ang unang karakter ng sumusunod na token.

YYDEBUG (estado, kasalukuyang)
Ito ay kailangan lamang kung ang -d ang bandila ay tinukoy. Nagbibigay-daan ito sa isa na madaling i-debug ang
nabuong parser sa pamamagitan ng pagtawag sa isang function na tinukoy ng gumagamit para sa bawat estado. Ang function
dapat mayroong sumusunod na lagda: walang bisa YYDEBUG (int.) estado, tangke kasalukuyang). ang
natatanggap ng unang parameter ang estado o -1 at natatanggap ng pangalawang parameter ang
input sa kasalukuyang cursor.

YYFILL (n)
Ang nabuong code na "mga tawag"" YYFILL (n) kapag ang buffer ay nangangailangan ng (muling) pagpuno: hindi bababa sa
n karagdagang mga character ay dapat na ibinigay. YYFILL (n) dapat mag-adjust YYCURSOR,
YYLIMIT, YYMARKER at YYCTXMARKER kung kinakailangan. Tandaan na para sa karaniwang programming
wika n ang magiging haba ng pinakamahabang keyword plus one. Ang gumagamit ay maaaring maglagay
isang komento ng form /*!max:re2c*/ ipasok YYMAXFILL kahulugan na nakatakda sa
ang maximum na halaga ng haba.

YYGETCONDITION ()
Ang define na ito ay ginagamit upang makuha ang kundisyon bago ipasok ang scanner code kung kailan
paggamit -c lumipat. Dapat na masimulan ang value na may value mula sa enumeration
YYCONDTYPE uri.

YYGETSTATE ()
Kailangan lang tukuyin ng user ang macro na ito kung ang -f ang bandila ay tinukoy. Sa ganyan
kaso, ang nabuong code na "mga tawag" YYGETSTATE () sa pinakasimula ng scanner
upang makuha ang naligtas na estado. YYGETSTATE () dapat magbalik ng sign integer. Ang
ang halaga ay dapat alinman sa -1, na nagpapahiwatig na ang scanner ay ipinasok sa unang pagkakataon,
o isang halaga na dati nang na-save ni YYSETSTATE (Mga). Sa pangalawang kaso, gagawin ng scanner
ipagpatuloy ang mga operasyon pagkatapos kung saan ang huli YYFILL (n) ay tinawag.

YYLIMIT
Ekspresyon ng uri YYCTYPE * na nagmamarka sa dulo ng buffer YYLIMIT[-1] ay ang
huling karakter sa buffer). Ang nabuong code ay paulit-ulit na naghahambing YYCURSOR sa
YYLIMIT upang matukoy kung kailan kailangan ng buffer (muling) pagpuno.

YYMARKER
l-halaga ng uri YYCTYPE *. Ang nabuong code ay nagse-save ng backtracking na impormasyon sa
YYMARKER. Maaaring hindi ito gamitin ng ilang madaling scanner.

YYMAXFILL
Ito ay awtomatikong tutukuyin ng /*!max:re2c*/ mga bloke tulad ng ipinaliwanag sa itaas.

YYSETCONDITION (C)
Ginagamit ang define na ito upang itakda ang kundisyon sa mga panuntunan sa paglipat. Ito ay pagiging lamang
ginamit nang -c ay aktibo at ginagamit ang mga panuntunan sa paglipat.

YYSETSTATE (Mga)
Kailangan lang tukuyin ng user ang macro na ito kung ang -f ang bandila ay tinukoy. Sa ganyan
kaso, ang nabuong code na "mga tawag" YYSETSTATE bago tumawag YYFILL (n). ang
parameter sa YYSETSTATE ay isang nilagdaang integer na natatanging kinikilala ang partikular
halimbawa ng YYFILL (n) malapit na itong tawagin. Kung nais ng user na i-save ang
estado ng scanner at mayroon YYFILL (n) bumalik sa tumatawag, ang kailangan lang niyang gawin ay
iimbak ang natatanging identifer na iyon sa isang variable. Mamaya, kapag ang scanner ay tinatawag na
muli, tatawag ito YYGETSTATE () at ipagpatuloy ang pagpapatupad kung saan ito tumigil. Ang
ang nabuong code ay maglalaman ng pareho YYSETSTATE (Mga) at YYGETSTATE kahit na YYFILL (n)
ay hindi pinagana.

SINTAX

Code para sa re2c ay binubuo ng isang set ng MGA ALITUNTUNIN, PINANGALANAN Kahulugan at SA LUGAR KONFIGURASYON.

MGA ALITUNTUNIN
Ang mga panuntunan ay binubuo ng isang regular na expression (tingnan REGULAR MGA PAGPAPAHAYAG) kasama ang isang bloke ng
C/C++ code na isasagawa kapag ang nauugnay na regular na expression ay tumugma. Ikaw
maaaring simulan ang code gamit ang isang pambungad na kulot na brace o ang pagkakasunod-sunod :=. Kapag ang code
may kulot na brace noon re2c binibilang ang lalim ng brace at huminto sa paghahanap ng code
awtomatiko. Kung hindi bawal ang mga kulot na braces at re2c huminto sa paghahanap ng code sa
ang unang linya na hindi nagsisimula sa whitespace. Kung mag-overlap ang dalawa o higit pang mga panuntunan, ang
ang unang tuntunin ay ginustong.
regular-expression { C / C ++ code }

regular-expression := C / C ++ code

May isang espesyal na panuntunan: default na panuntunan *
* { C / C ++ code }

* := C / C ++ code

Tandaan na ang default na panuntunan * naiiba mula sa [^]: ang default na panuntunan ay may pinakamababang priyoridad, mga tugma
anumang unit ng code (alinman sa wasto o hindi wasto) at palaging gumagamit ng isang character; habang [^]
tumutugma sa anumang wastong code point (hindi code unit) at maaaring kumonsumo ng maraming unit ng code. Sa katunayan,
kapag ginagamit ang variable-length na encoding, * ay ang tanging posibleng paraan upang tumugma sa di-wastong input
karakter (tingnan MGA ENCODING para sa mga detalye).

If -c ay aktibo pagkatapos ang bawat regular na expression ay pinangungunahan ng isang listahan ng pinaghihiwalay ng kuwit
mga pangalan ng kondisyon. Bukod sa normal na mga panuntunan sa pagbibigay ng pangalan, mayroong dalawang espesyal na kaso: <*> (mga ganyang tuntunin
ay pinagsama sa lahat ng kundisyon) at <> (Hindi maaaring magkaroon ng nauugnay na regular ang naturang panuntunan
expression, ang code nito ay pinagsama sa lahat ng mga aksyon). Ang mga hindi walang laman na panuntunan ay maaaring higit pang tukuyin
ang bagong kondisyon. Kung ganoon re2c ay bubuo ng kinakailangang code upang baguhin ang
awtomatikong kondisyon. Maaaring gamitin ang mga panuntunan :=> bilang isang shortcut upang awtomatikong makabuo ng code
na hindi lamang nagtatakda ng bagong estado ng kundisyon ngunit nagpapatuloy din sa pagpapatupad sa bago
estado. Ang isang shortcut na panuntunan ay hindi dapat gamitin sa isang loop kung saan mayroong code sa pagitan ng simula
ng loop at ang re2c harangan maliban kung re2c:cond:goto ay binago sa magpatuloy. Kung ang code ay
kinakailangan bago ang lahat ng mga patakaran (bagaman hindi simpleng pagtalon) maaari mong doso sa pamamagitan ng paggamit
pseudo-rules.
regular-expression { C / C ++ code }

regular-expression := C / C ++ code

* { C / C ++ code }

* := C / C ++ code

regular-expression => kalagayan { C / C ++ code }

regular-expression => kalagayan := C / C ++ code

* => kalagayan { C / C ++ code }

* => kalagayan := C / C ++ code

regular-expression :=> kalagayan

<*> regular-expression { C / C ++ code }

<*> regular-expression := C / C ++ code

<*> * { C / C ++ code }

<*> * := C / C ++ code

<*> regular-expression => kalagayan { C / C ++ code }

<*> regular-expression => kalagayan := C / C ++ code

<*> * => kalagayan { C / C ++ code }

<*> * => kalagayan := C / C ++ code

<*> regular-expression :=> kalagayan

<> { C / C ++ code }

<> := C / C ++ code

<> => kalagayan { C / C ++ code }

<> => kalagayan := C / C ++ code

<> :=> kalagayan

<> :=> kalagayan

<! listahan ng kondisyon> { C / C ++ code }

<! listahan ng kondisyon> := C / C ++ code

{ C / C ++ code }

:= C / C ++ code

PINANGALANAN Kahulugan
Ang mga pinangalanang kahulugan ay nasa anyo:
pangalan = regular-expression;

If -F ay aktibo, at ang mga pinangalanang kahulugan ay nasa anyo din:
pangalan { regular-expression }

SA LUGAR KONFIGURASYON
re2c:condprefix = yc;
Nagbibigay-daan sa isa na tukuyin ang prefix na ginamit para sa mga label ng kundisyon. Iyon ang tekstong ito
prepended sa anumang label ng kundisyon sa nabuong output file.

re2c:condenumprefix = yc;
Nagbibigay-daan sa isa na tukuyin ang prefix na ginamit para sa mga halaga ng kundisyon. Iyon ang tekstong ito
prepended sa anumang halaga ng kundisyon enum sa nabuong output file.

re2c:cond:divider = /* *********************************** */ ;
Nagbibigay-daan sa isa na i-customize ang devider para sa mga bloke ng kundisyon. Pwede mong gamitin @@ upang ilagay ang
pangalan ng kundisyon o i-customize ang placeholder na ginagamit re2c:cond:divider@cond.

re2c:cond:divider@cond = @@;
Tinutukoy ang placeholder na papalitan ng pangalan ng kundisyon sa
re2c:cond:divider.

re2c:cond:goto = pumunta @@; ;
Binibigyang-daan ang isa na i-customize ang kundisyon na ginamit sa mga pahayag ng goto :=> mga tuntunin sa istilo.
Maaari mong gamitin ang @@ upang ilagay ang pangalan ng kundisyon o i-ustomize ang ginagamit ng placeholder
re2c:cond:goto@cond. Maaari mo ring palitan ito ng magpatuloy;, na magpapahintulot sa iyo
upang magpatuloy sa susunod na loop cycle kasama ang anumang code sa pagitan ng loop start at re2c
harangan.

re2c:cond:goto@cond = @@;
Tinutukoy ang placeholder na papalitan ng label ng kundisyon sa
re2c:cond:goto.

re2c:indent:top = 0;
Tinutukoy ang minimum na bilang ng indentation na gagamitin. Nangangailangan ng numeric na halaga
mas malaki sa o katumbas ng zero.

re2c:indent:string = \t ;
Tinutukoy ang string na gagamitin para sa indentation. Nangangailangan ng string na dapat maglaman
whitespace lang maliban kung kailangan mo ito para sa mga panlabas na tool. Ang pinakamadaling paraan upang tukuyin
spaces ay upang isama ang mga ito sa isa o dobleng panipi. Kung ayaw mo ng kahit ano
indentation sa lahat maaari mo lamang itong itakda sa "".

re2c:yych:conversion = 0;
Kapag hindi zero ang setting na ito, kung gayon re2c awtomatikong bumubuo ng code ng conversion
tuwing nababasa si ych. Sa kasong ito ang uri ay dapat tukuyin gamit
re2c:define:YYCTYPE.

re2c:yych:emit = 1;
Pagbuo ng yych maaaring pigilan sa pamamagitan ng pagtatakda nito sa 0.

re2c:yybm:hex = 0;
Kung nakatakda sa zero, ang isang decimal na talahanayan ay ginagamit kung hindi ang isang hexadecimal na talahanayan ay magiging
nabuo

re2c:yyfill:enable = 1;
Itakda ito sa zero para sugpuin ang pagbuo ng YYFILL (n). Kapag ginagamit ito siguraduhing
i-verify na ang nabuong scanner ay hindi nagbabasa sa likod ng input. Hinahayaan ito
Ang pag-uugali ay maaaring magpakilala ng malubhang isyu sa seguridad sa iyong mga programa.

re2c:yyfill:check = 1;
Ito ay maaaring itakda 0 upang sugpuin ang output ng pre condition gamit YYCURSOR at
YYLIMIT na nagiging kapaki-pakinabang kapag YYLIMIT + YYMAXFILL ay laging naa-access.

re2c:define:YYFILL = YYFILL ;
Pagpapalit para sa YYFILL. Tandaan na bilang default re2c bumubuo ng argument sa braces at
tuldok-kuwit pagkatapos YYFILL. Kung kailangan mong gumawa YYFILL isang arbitrary na pahayag sa halip
kaysa sa isang tawag, itakda re2c:define:YYFILL:hubad sa non-zero at gamitin
re2c:define:YYFILL@len upang tukuyin ang pormal na parameter sa loob ng YYFILL katawan.

re2c:define:YYFILL@len = @@ ;
Anumang paglitaw ng tekstong ito sa loob ng YYFILL ay papalitan ng aktwal
argumento.

re2c:yyfill:parameter = 1;
Kinokontrol ang argumento sa mga braces pagkatapos YYFILL. Kung zero, aalisin ang agrument. Kung
non-zero, ang argument ay nabuo maliban kung re2c:define:YYFILL:hubad ay nakatakda sa non-zero.

re2c:define:YYFILL:hubad = 0;
Kinokontrol ang argumento sa mga braces at semicolon pagkatapos YYFILL. Kung zero, parehong agrument at
inalis ang semicolon. Kung hindi zero, ang argument ay nabuo maliban kung
re2c:yyfill:parameter ay nakatakda sa zero at ang semicolon ay nabuo nang walang kondisyon.

re2c:startlabel = 0;
Kung nakatakda sa isang hindi zero na integer pagkatapos ay ang panimulang label ng susunod na mga bloke ng scanner ay
mabubuo kahit na hindi ginagamit ng scanner mismo. Kung hindi ang normal yy0 gaya ng
ang start label ay binubuo lamang kung kinakailangan. Kung nakatakda sa isang halaga ng teksto pagkatapos ay isang label
na may tekstong iyon ay bubuo kahit na ang normal na label ng pagsisimula ay
ginagamit man o hindi. Nire-reset ang setting na ito sa 0 pagkatapos magkaroon ng panimulang label
nabuo

re2c:labelprefix = yy ;
Nagbibigay-daan sa isa na baguhin ang prefix ng mga may bilang na label. Ang default ay yy at maaaring maging
itakda ang anumang string na isang wastong label.

re2c:state:abort = 0;
Kapag hindi zero at lumipat -f ay aktibo pagkatapos ay ang YYGETSTATE ang bloke ay maglalaman ng a
default na kaso na nag-abort at isang -1 na kaso ang ginagamit para sa pagsisimula.

re2c:state:nextlabel = 0;
Ginamit noong -f ay aktibo upang kontrolin kung ang YYGETSTATE bloke ay sinusundan ng a
yySusunod: linya ng label. Sa halip na gamitin yySusunod kadalasan maaari mo ring gamitin ang configuration
startlabel upang pilitin ang isang partikular na label ng pagsisimula o default sa yy0 bilang panimulang label.
Sa halip na gumamit ng nakalaang label ay kadalasang mas mahusay na paghiwalayin ang YYGETSTATE
code mula sa aktwal na code ng scanner sa pamamagitan ng paglalagay ng a /*!getstate:re2c*/ komento

re2c:cgoto:threshold = 9;
Kailan -g ay aktibo ang value na ito ay tumutukoy sa complexity threshold na nagti-trigger
pagbuo ng mga jump table sa halip na gumamit ng nested if's at decision bitfields. Ang
ang threshold ay inihambing laban sa isang kinakalkula na pagtatantya ng kung kailangan kung saan ang bawat
hinahati ng ginamit na bitmap ang threshold ng 2.

re2c:yych:conversion = 0;
Kapag ang input ay gumagamit ng mga sign na character at -s or -b ang mga switch ay may bisa re2c
nagbibigay-daan sa isa na awtomatikong mag-convert sa unsigned character type na noon
kinakailangan para sa panloob na solong karakter nito. Kapag ang setting na ito ay zero o isang walang laman
string ang conversion ay hindi pinagana. Gamit ang isang hindi zero na numero ang conversion ay kinuha
mula YYCTYPE. Kung iyon ay ibinigay sa pamamagitan ng isang inplace na configuration na ang halaga ay pagiging
ginamit. Kung hindi ito ay magiging (YYCTYPE) at ang mga pagbabago sa pagsasaayos na iyon ay hindi
mas matagal posible. Kapag ang setting na ito ay isang string, dapat tukuyin ang mga braces. Ngayon
ipagpalagay na ang iyong input ay a tangke * buffer at gumagamit ka ng mga switch sa itaas
maaari mong itakda YYCTYPE sa hindi naka -ignign tangke at ang setting na ito sa alinman sa 1 o (hindi pinirmahan
char).

re2c:define:YYCONDTYPE = YYCONDTYPE ;
Enumerasyon na ginamit para sa suporta sa kundisyon sa -c mode.

re2c:define:YYCTXMARKER = YYCTXMARKER ;
Nagbibigay-daan sa isa na i-overwrite ang define YYCTXMARKER at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:define:YYCTYPE = YYCTYPE ;
Nagbibigay-daan sa isa na i-overwrite ang define YYCTYPE at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:define:YYCURSOR = YYCURSOR ;
Nagbibigay-daan sa isa na i-overwrite ang define YYCURSOR at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:define:YYDEBUG = YYDEBUG ;
Nagbibigay-daan sa isa na i-overwrite ang define YYDEBUG at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:define:YYGETCONDITION = YYGETCONDITION ;
Pagpapalit para sa YYGETCONDITION. Tandaan na bilang default re2c bumubuo ng mga braces pagkatapos
YYGETCONDITION. Itakda re2c:define:YYGETCONDITION:hubad sa non-zero para tanggalin ang mga braces.

re2c:define:YYGETCONDITION:hubad = 0;
Kinokontrol ang mga braces pagkatapos YYGETCONDITION. Kung zero, aalisin ang mga braces. Kung hindi zero,
nabuo ang mga braces.

re2c:define:YYSETCONDITION = YYSETCONDITION ;
Pagpapalit para sa YYSETCONDITION. Tandaan na bilang default re2c bumubuo ng argumento sa
braces at semicolon pagkatapos YYSETCONDITION. Kung kailangan mong gumawa YYSETCONDITION an
arbitrary na pahayag sa halip na isang tawag, itinakda re2c:define:YYSETCONDITION:hubad sa
non-zero at paggamit re2c:define:YYSETCONDITION@cond upang tukuyin ang pormal na parameter sa loob
of YYSETCONDITION katawan.

re2c:define:YYSETCONDITION@cond = @@ ;
Anumang paglitaw ng tekstong ito sa loob ng YYSETCONDITION ay papalitan ng
aktwal na argumento.

re2c:define:YYSETCONDITION:hubad = 0;
Kinokontrol ang argumento sa mga braces at semicolon pagkatapos YYSETCONDITION. Kung zero, pareho
agrument at semicolon ay tinanggal. Kung hindi zero, parehong argumento at semicolon ay
nabuo

re2c:define:YYGETSTATE = YYGETSTATE ;
Pagpapalit para sa YYGETSTATE. Tandaan na bilang default re2c bumubuo ng mga braces pagkatapos
YYGETSTATE. Itakda re2c:define:YYGETSTATE:hubad sa non-zero para tanggalin ang mga braces.

re2c:define:YYGETSTATE:hubad = 0;
Kinokontrol ang mga braces pagkatapos YYGETSTATE. Kung zero, aalisin ang mga braces. Kung hindi zero, braces
ay nabuo.

re2c:define:YYSETSTATE = YYSETSTATE ;
Pagpapalit para sa YYSETSTATE. Tandaan na bilang default re2c bumubuo ng argument sa braces
at semicolon pagkatapos YYSETSTATE. Kung kailangan mong gumawa YYSETSTATE isang arbitraryo
pahayag sa halip na isang tawag, itakda re2c:define:YYSETSTATE:hubad sa non-zero at gamitin
re2c:define:YYSETSTATE@cond upang tukuyin ang pormal na parameter sa loob ng YYSETSTATE katawan.

re2c:define:YYSETSTATE@state = @@ ;
Anumang paglitaw ng tekstong ito sa loob ng YYSETSTATE ay papalitan ng aktwal
argumento.

re2c:define:YYSETSTATE:hubad = 0;
Kinokontrol ang argumento sa mga braces at semicolon pagkatapos YYSETSTATE. Kung zero, parehong agrument
at tuldok-kuwit ay tinanggal. Kung hindi zero, parehong argumento at semicolon ay nabuo.

re2c:define:YYLIMIT = YYLIMIT ;
Nagbibigay-daan sa isa na i-overwrite ang define YYLIMIT at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:define:YYMARKER = YYMARKER ;
Nagbibigay-daan sa isa na i-overwrite ang define YYMARKER at sa gayon ay iniiwasan ito sa pamamagitan ng pagtatakda ng
halaga sa aktwal na code na kailangan.

re2c:label:yyFillLabel = yyFillLabel ;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng label yyFillLabel.

re2c:label:yySusunod = yySusunod ;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng label yySusunod.

re2c:variable:yyaccept = yyaccept;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng variable yyaccept.

re2c:variable:yybm = yybm ;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng variable yybm.

re2c:variable:yych = yych ;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng variable yych.

re2c:variable:yyctable = yyctable ;
Kapag pareho -c at -g aktibo noon re2c ginagamit ang variable na ito upang makabuo ng isang static
jump table para sa YYGETCONDITION.

re2c:variable:ystable = ystable ;
Hindi na ginagamit.

re2c:variable:yytarget = yytarget ;
Nagbibigay-daan sa isa na i-overwrite ang pangalan ng variable yytarget.

REGULAR MGA PAGPAPAHAYAG
"foo" literal na string "foo". Maaaring gamitin ang ANSI-C escape sequence.

'foo' literal na string "foo" (mga character [a-zA-Z] na itinuturing na case-insensitive). pagtakas ng ANSI-C
maaaring gamitin ang mga sequence.

[xyz] klase ng karakter; sa kasong ito, ang regular na expression ay tumutugma sa alinman x, y, O z.

[abj-oZ]
klase ng character na may saklaw dito; mga posporo a, b, anumang liham mula sa j sa pamamagitan ng o or Z.

[^class]
baligtad na klase ng karakter.

r \ s tumugma sa alinman r na hindi s. r at s dapat na mga regular na expression na maaaring
ipinahayag bilang mga klase ng karakter.

r* zero o higit pang mga paglitaw ng r.

r+ isa o higit pang mga pangyayari ng r.

r? opsyonal r.

(r) r; ang mga panaklong ay ginagamit upang i-override ang precedence.

r s r sinundan ng s (pagsasama-sama).

r | s alinman sa r or s (alternatibo).

r / s r ngunit kung ito ay sinusunod lamang ng s. Tandaan na s ay hindi bahagi ng katugmang teksto.
Ang ganitong uri ng regular na expression ay tinatawag na "trailing context". Ang sumusunod na konteksto ay maaari
maging katapusan lamang ng isang tuntunin at hindi bahagi ng isang pinangalanang kahulugan.

r{n} posporo r tamang-tama n beses.

r{n,} posporo r kahit n beses.

r{n,m} posporo r kahit n beses, ngunit hindi hihigit sa m beses.

. tumugma sa anumang karakter maliban sa bagong linya.

pangalan tumutugma sa pinangalanang kahulugan gaya ng tinukoy ni pangalan kung -F ay naka-off. Kung -F ay aktibo
pagkatapos ay kumikilos ito na parang nakapaloob sa double quotes at tumutugma sa string
"pangalan".

Ang mga klase ng character at string literal ay maaaring maglaman ng octal o hexadecimal na character
mga kahulugan at ang sumusunod na hanay ng mga pagkakasunud-sunod ng pagtakas: \a, \b, \f, \n, \r, \t, \v, \\, Sa
Ang octal na character ay tinukoy ng isang backslash na sinusundan ng tatlong octal na digit nito (hal \377).
Ang mga hexadecimal na character mula 0 hanggang 0xFF ay tinutukoy ng backslash, isang lower cased x at dalawang
hexadecimal digit (hal \x12). Ang mga hexadecimal na character mula 0x100 hanggang 0xFFFF ay tinutukoy ng
backslash, isang lower cased \u o isang upper cased \X at apat na hexadecimal digit (hal
\u1234). Ang mga hexadecimal na character mula 0x10000 hanggang 0xFFFFffff ay tinutukoy ng backslash, isang
upper cased \U at walong hexadecimal digit (hal \U12345678).

Ang tanging portable na "anumang" panuntunan ay ang default na panuntunan *.

PARA MAG-SCAN SA NAKATATAG MGA ESTADO

Kapag ang -f ang bandila ay tinukoy, re2c bumubuo ng isang scanner na maaaring mag-imbak ng kasalukuyang estado nito,
bumalik sa tumatawag, at pagkatapos ay ipagpatuloy ang mga operasyon nang eksakto kung saan ito tumigil.

Ang default na operasyon ng re2c ay isang "pull" na modelo, kung saan ang scanner ay humihingi ng karagdagang input
sa tuwing kailangan nito. Gayunpaman, ipinapalagay ng mode ng operasyon na ito na ang scanner ay ang
"may-ari" ang loop ng pag-parse, at maaaring hindi iyon palaging maginhawa.

Karaniwan, kung mayroong isang preprocessor sa unahan ng scanner sa stream, o para doon
mahalaga ang anumang iba pang pamamaraang pinagmumulan ng data, ang scanner ay hindi maaaring "humingi" ng higit pang data maliban kung
parehong scanner at source ay nakatira sa magkahiwalay na mga thread.

Ang -f Ang flag ay kapaki-pakinabang para lamang sa sitwasyong ito: hinahayaan nito ang mga user na magdisenyo ng mga scanner na gumagana
isang "push" na modelo, ibig sabihin, kung saan ang data ay pinapakain sa scanner chunk sa pamamagitan ng chunk. Kapag ang scanner
nauubusan ng data na ubusin, iniimbak lamang nito ang estado nito, at bumalik sa tumatawag. Kapag mas
Ang data ng input ay ipinadala sa scanner, nagpapatuloy ito sa mga operasyon nang eksakto kung saan ito tumigil.

Mga pagbabagong kailangan kumpara sa "pull" na modelo:

· Ang user ay kailangang magbigay ng mga macro YYSETSTATE () at YYGETSTATE (estado).

· Ang -f pinipigilan ng opsyon ang deklarasyon ng yych at yyaccept. Kaya ang gumagamit ay kailangang magpahayag
ang mga ito. Gayundin ang gumagamit ay kailangang i-save at ibalik ang mga ito. Sa halimbawa
examples/push_model/push.re ang mga ito ay idineklara bilang mga patlang ng (C++) na klase kung saan ang
Ang scanner ay isang paraan, kaya hindi nila kailangang i-save/i-restore nang tahasan. Para kay C sila
maaaring gawin halimbawa ng mga macro na pumipili ng mga patlang mula sa isang istraktura na ipinasa bilang parameter.
Bilang kahalili, maaari silang ideklara bilang mga lokal na variable, na nai-save gamit ang YYFILL (n) kapag ito
nagpasya na bumalik at ibalik sa pagpasok sa function. Gayundin, maaaring higit pa
mahusay na iligtas ang estado mula sa YYFILL (n) dahil sa YYSETSTATE (estado) ay tinatawag na
walang pasubali. YYFILL (n) gayunpaman ay hindi nakukuha ay bilang parameter, kaya magkakaroon tayo
upang mag-imbak ng estado sa isang lokal na variable sa pamamagitan ng YYSETSTATE (estado).

· Baguhin YYFILL (n) upang bumalik (mula sa function na tinatawag ito) kung kailangan ng higit pang input.

· Baguhin ang tumatawag upang makilala kung higit pang input ang kailangan at tumugon nang naaangkop.

· Ang nabuong code ay maglalaman ng switch block na ginagamit upang ibalik ang huling estado
sa pamamagitan ng pagtalon sa likod ng corrspoding YYFILL (n) tawag. Ang code na ito ay awtomatikong nabuo
sa epilog ng una /*!re2c */ harangan. Posibleng ma-trigger ang henerasyon ng
YYGETSTATE () harangan nang mas maaga sa pamamagitan ng paglalagay ng a /*!getstate:re2c*/ komento. Lalo na ito
kapaki-pakinabang kapag ang scanner code ay dapat na nakabalot sa loob ng isang loop.

Mangyaring tingnan ang examples/push_model/push.re para sa "push" model scanner. Ang nabuong code ay maaaring
na-tweak gamit ang mga inplace na configuration estado: abort at estado: nextlabel.

PARA MAG-SCAN SA KONDISYON SUPORTA

Maaari mong unahan ang mga regular na expression na may listahan ng mga pangalan ng kundisyon kapag ginagamit ang -c
lumipat. Sa kasong ito re2c bumubuo ng mga bloke ng scanner para sa bawat kondisyon. Kung saan ang bawat isa sa
ang nabuong mga bloke ay may sariling paunang kondisyon. Ang precondition ay ibinibigay ng interface
magtakda YYGETCONDITON() at dapat ay uri YYCONDTYPE.

Mayroong dalawang espesyal na uri ng panuntunan. Una, ang mga patakaran ng kondisyon <*> ay pinagsama sa lahat
kundisyon (tandaan na mas mababa ang priyoridad ng mga ito kaysa sa ibang mga tuntunin ng kundisyong iyon). At
pangalawa ang walang laman na listahan ng kundisyon ay nagpapahintulot sa isa na magbigay ng isang bloke ng code na walang a
bahagi ng scanner. Ibig sabihin hindi nito pinapayagan ang anumang regular na expression. Ang halaga ng kondisyon
ang tumutukoy sa espesyal na bloke na ito ay palaging ang may halaga ng enumeration na 0. Sa ganitong paraan
ang code ng espesyal na panuntunang ito ay maaaring gamitin upang simulan ang isang scanner. Ito ay hindi sa anumang paraan
kinakailangan na magkaroon ng mga alituntuning ito: ngunit kung minsan ay nakakatulong na magkaroon ng isang nakatuon
hindi inisyal na estado ng kondisyon.

Ang mga walang laman na panuntunan ay nagbibigay-daan sa isa na tukuyin ang bagong kundisyon, na ginagawang mga panuntunan sa paglipat.
Bukod sa pagbuo ng mga tawag para sa define YYSETCONDTITION walang ibang espesyal na code
nabuo

May isa pang uri ng mga espesyal na panuntunan na nagbibigay-daan sa isa na ihanda ang code sa anumang bloke ng code ng
lahat ng mga panuntunan ng isang tiyak na hanay ng mga kundisyon o sa lahat ng mga bloke ng code sa lahat ng mga panuntunan. Ito ay maaaring
nakakatulong kapag ang ilang operasyon ay karaniwan sa mga panuntunan. Halimbawa, maaari itong magamit upang mag-imbak
ang haba ng na-scan na string. Ang mga espesyal na panuntunan sa pag-setup ay nagsisimula sa tandang padamdam
sinusundan ng alinman sa isang listahan ng mga kundisyon <! kondisyon, ... > o isang bituin . Kailan re2c
bumubuo ng code para sa isang panuntunan kung saan ang estado ay walang panuntunan sa pag-setup at isang star'd setup
ang panuntunan ay naroroon, kaysa ang code na iyon ay gagamitin bilang setup code.

MGA ENCODING

re2c sumusuporta sa mga sumusunod na pag-encode: ASCII (default), EBCDIC (-e), UCS-2 (-w), UTF-16
(-x), UTF-32 (-u) at UTF-8 (-8). Tingnan din ang inplace na configuration re2c: mga bandila.

Ang mga sumusunod na konsepto ay dapat na linawin kapag pinag-uusapan ang tungkol sa pag-encode. Ang code point ay isang
abstract na numero, na kumakatawan sa isang simbolo ng pag-encode. Ang unit ng code ay ang pinakamaliit na yunit
ng memorya, na ginagamit sa naka-encode na teksto (ito ay tumutugma sa isang character sa input
stream). Maaaring kailanganin ang isa o higit pang mga unit ng code upang kumatawan sa isang solong code point, depende
sa encoding. Sa fixed-length na pag-encode, ang bawat code point ay kinakatawan ng katumbas
bilang ng mga yunit ng code. Sa variable-length na pag-encode, maaaring magkaiba ang mga punto ng code
kinakatawan ng iba't ibang bilang ng mga unit ng code.

ASCII ay isang fixed-length na pag-encode. Kasama sa espasyo ng code nito ang 0x100 code point, mula 0 hanggang
0xFF. Ang isang code point ay kinakatawan ng eksaktong isang 1-byte code unit, na mayroon
ang parehong halaga ng code point. Sukat ng YYCTYPE dapat ay 1 byte.

EBCDIC ay isang fixed-length na pag-encode. Kasama sa espasyo ng code nito ang 0x100 code point, mula 0 hanggang
0xFF. Ang isang code point ay kinakatawan ng eksaktong isang 1-byte code unit, na mayroon
ang parehong halaga ng code point. Sukat ng YYCTYPE dapat ay 1 byte.

UCS-2 ay isang fixed-length na pag-encode. Kasama sa espasyo ng code nito ang 0x10000 code point, mula 0 hanggang
0xFFFF. Ang isang code point ay kinakatawan ng eksaktong isang 2-byte code unit, na mayroon
ang parehong halaga ng code point. Sukat ng YYCTYPE dapat ay 2 bytes.

UTF-16 ay isang variable-length na encoding. Kasama sa espasyo ng code nito ang lahat ng Unicode code point,
mula 0 hanggang 0xD7FF at mula 0xE000 hanggang 0x10FFFF. Isang code point ang kinakatawan ng
isa o dalawang 2-byte na unit ng code. Sukat ng YYCTYPE dapat ay 2 bytes.

UTF-32 ay isang fixed-length na pag-encode. Kasama sa code space nito ang lahat ng Unicode code point, mula 0
hanggang 0xD7FF at mula 0xE000 hanggang 0x10FFFF. Ang isang punto ng code ay kinakatawan nang eksakto
isang 4-byte code unit. Sukat ng YYCTYPE dapat ay 4 bytes.

UTF-8 ay isang variable-length na encoding. Kasama sa espasyo ng code nito ang lahat ng Unicode code point,
mula 0 hanggang 0xD7FF at mula 0xE000 hanggang 0x10FFFF. Isang code point ang kinakatawan ng
pagkakasunud-sunod ng isa, dalawa, tatlo o apat na 1-byte na unit ng code. Sukat ng YYCTYPE dapat 1
byte.

Sa Unicode, ang mga value mula sa range na 0xD800 hanggang 0xDFFF (mga surrogates) ay hindi wastong Unicode code
mga punto, anumang naka-encode na pagkakasunud-sunod ng mga unit ng code, na imamapa sa mga punto ng Unicode code sa
saklaw na 0xD800-0xDFFF, ay hindi maganda ang anyo. Makokontrol ng user kung paano re2c tinatrato ang gayong hindi magandang porma
mga pagkakasunod-sunod na may --encoding-patakaran bandila (tingnan Opsyon para sa buong paliwanag).

Para sa ilang pag-encode, may mga unit ng code, na hindi kailanman nangyayari sa wastong naka-encode na stream (hal
0xFF byte sa UTF-8). Kung dapat suriin ng nabuong scanner kung may di-wastong input, ang tanging totoo
paraan upang gawin ito ay ang paggamit ng default na panuntunan *. Tandaan, ang buong saklaw na panuntunan [^] hindi mahuhuli na hindi wasto
mga unit ng code kapag ginagamit ang variable-length na encoding ([^] ay nangangahulugang "lahat ng wastong code point", habang
default na panuntunan * nangangahulugang "lahat ng posibleng unit ng code").

PANGKALAHATANG INPUT API

re2c karaniwang gumagana sa input gamit ang pointer-like primitives YYCURSOR, YYMARKER,
YYCTXMARKER at YYLIMIT.

Generic input API (pinagana sa --input pasadya switch) ay nagbibigay-daan sa isa na i-customize ang input
mga operasyon. Sa mode na ito, re2c ay ipahayag ang lahat ng mga operasyon sa input sa mga tuntunin ng
sumusunod na primitives:

┌────────────────┬──────────────────────────────── ──┐
│YYPEEK () │ kumuha ng kasalukuyang input na character │
├────────────────┼──────────────────────────────── ──┤
│YYSKIP () │ sumulong sa susunod na karakter │
├────────────────┼──────────────────────────────── ──┤
│YYBACKUP () │ backup kasalukuyang posisyon ng input │
├────────────────┼──────────────────────────────── ──┤
│YYBACKUPTXX () │ backup kasalukuyang posisyon ng input │
│ │ para sa sumusunod na konteksto │
├────────────────┼──────────────────────────────── ──┤
│YYRESTORE () │ ibalik ang kasalukuyang posisyon ng input │
├────────────────┼──────────────────────────────── ──┤
│YYRESTORECTX () │ ibalik ang kasalukuyang posisyon ng input │
│ │ para sa sumusunod na konteksto │
├────────────────┼──────────────────────────────── ──┤
│YYLESSTHAN (n) │ suriin kung mas mababa sa n input │
│ │ character ang natitira │
└────────────────┴──────────────────────────────── ──┘

Ang ilang mga kapaki-pakinabang na link na nagbibigay ng ilang halimbawa:

1. http://skvadrik.github.io/aleph_null/posts/re2c/2015-01-13-input_model.html

2. http://skvadrik.github.io/aleph_null/posts/re2c/2015-01-15-input_model_custom.html

Gumamit ng re2c online gamit ang mga serbisyo ng onworks.net