re2c:api, re2c:input

همانند گزینهٔ --api است.

re2c:api:sigil

نشانه ("sigil") مورد استفاده برای جای‌نگهدارهای آرگومان در ساختارهای اولیهٔ API را مشخص می‌کند. مقدار پیش‌فرض @@ است. یک جای‌نگهدار با sigil شروع شده و به دنبال آن نام آرگومان درون دو آکولاد قرار می‌گیرد. برای مثال، اگر sigil روی $ تنظیم شود، جای‌نگهدارها به شکل ${name} خواهند بود. APIهای تک‌آرگومانی می‌توانند از نمادگذاری مختصر بدون نام درون آکولادها استفاده کنند. این گزینه می‌تواند با گزینه‌های مختص به هر یک از ساختارهای اولیهٔ API بازنویسی شود، مانند re2c:YYFILL@len برای YYFILL.

re2c:api:style

سبک API را تعیین می‌کند. مقادیر ممکن عبارتند از functions (پیش‌فرض برای C) و free-form (پیش‌فرض برای Go و Rust). در سبک functions ساختارهای اولیهٔ API همراه با فهرست آرگومان‌ها درون پرانتز به دنبال نام ساختار اولیه تولید می‌شوند. آرگومان‌ها تنها برای پارامترهای خودکار تولیدشده فراهم می‌شوند (مانند تعداد نویسه‌های ارسالی به YYFILL)، و نه برای زمینهٔ کلی تحلیل‌گر لغوی، از این رو ساختارهای اولیه بیشتر شبیه ماکروها در C/C++ یا بستارها در Go و Rust عمل می‌کنند. در سبک free-form ساختارهای اولیهٔ API شکل ثابتی ندارند: آن‌ها باید به صورت رشته‌هایی شامل قطعه‌کدهای آزاد با متغیرهای جایگزین‌شده به فرم @@{var} یا @@ تعریف شوند (که متناظر با آرگومان‌ها در سبک تابع‌گونه هستند). این پیکربندی ممکن است برای هر ساختار اولیهٔ API به صورت مجزا بازنویسی شود؛ برای نمونه پیکربندی re2c:YYFILL:naked را برای YYFILL ببینید.

re2c:bit-vectors, re2c:flags:bit-vectors, re2c:flags:b

همانند گزینهٔ --bit-vectors است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:captures, re2c:leftmost-captures

همانند گزینهٔ --leftmost-captures است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:captvars, re2c:leftmost-captvars

همانند گزینهٔ --leftmost-captvars است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:case-insensitive, re2c:flags:case-insensitive

همانند گزینهٔ --case-insensitive است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:case-inverted, re2c:flags:case-inverted

همانند گزینهٔ --case-inverted است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:case-ranges, re2c:flags:case-ranges

همانند گزینهٔ --case-ranges است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:computed-gotos, re2c:flags:computed-gotos, re2c:flags:g

همانند گزینهٔ --computed-gotos است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:computed-gotos:relative, re2c:cgoto:relative

همانند گزینهٔ --computed-gotos-relative است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:computed-gotos:threshold, re2c:cgoto:threshold

در صورت استفاده از goto محاسباتی، این پیکربندی آستانهٔ پیچیدگی‌ای را مشخص می‌کند که باعث تولید جدول‌های پرش به‌جای دستورهای تودرتوی if و نگاشت‌های بیتی می‌شود. مقدار پیش‌فرض 9 است.

re2c:cond:abort

اگر روی یک مقدار عددی صحیح مثبت تنظیم شود، حالت پیش‌فرض در هدایت‌گر وضعیتِ تولیدشده اجرای برنامه را متوقف می‌کند.

re2c:cond:goto

قطعه‌کدی را مشخص می‌کند که برای قواعد میان‌بر خودکار تولیدشدهٔ :=> در شرط‌ها استفاده می‌شود. پیش‌فرض goto @@; است. جای‌نگهدار @@ با نام شرط جایگزین می‌شود (پیکربندی‌های re2c:api:sigil و re2c:cond:goto@cond را ببینید).

re2c:cond:goto@cond

نشانهٔ مورد استفاده برای جایگزینی آرگومان در تعریف re2c:cond:goto را مشخص می‌کند. مقدار پیش‌فرض @@ است. پیکربندی عمومی‌تر re2c:api:sigil را بازنویسی می‌کند.

re2c:cond:divider

جداکنندهٔ بلوک‌های شرط را تعریف می‌کند. مقدار پیش‌فرض /* *********************************** */ است. جای‌نگهدارها با نام شرط جایگزین می‌شوند (پیکربندی‌های re2c:api;sigil و re2c:cond:divider@cond را ببینید).

re2c:cond:divider@cond

نشانهٔ مورد استفاده برای جایگزینی آرگومان در تعریف re2c:cond:divider را مشخص می‌کند. مقدار پیش‌فرض @@ است. پیکربندی عمومی‌تر re2c:api:sigil را بازنویسی می‌کند.

re2c:cond:prefix, re2c:condprefix

پیشوند مورد استفاده برای برچسب‌های شرط را مشخص می‌کند. پیش‌فرض yyc_ است.

re2c:cond:enumprefix, re2c:condenumprefix

پیشوند مورد استفاده برای شناسه‌های شرط را مشخص می‌کند. پیش‌فرض yyc است.

re2c:debug-output, re2c:flags:debug-output, re2c:flags:d

همانند گزینهٔ --debug-output است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:empty-class, re2c:flags:empty-class

همانند گزینهٔ --empty-class است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding:ebcdic, re2c:flags:ecb, re2c:flags:e

همانند گزینهٔ --ebcdic است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding:ucs2, re2c:flags:wide-chars, re2c:flags:w

همانند گزینهٔ --ucs2 است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding:utf8, re2c:flags:utf-8, re2c:flags:8

همانند گزینهٔ --utf8 است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding:utf16, re2c:flags:utf-16, re2c:flags:x

همانند گزینهٔ --utf16 است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding:utf32, re2c:flags:unicode, re2c:flags:u

همانند گزینهٔ --utf32 است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:encoding-policy, re2c:flags:encoding-policy

همانند گزینهٔ --encoding-policy است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:eof

نماد نگهبان مورد استفاده با قاعدهٔ پایان ورودی $ را مشخص می‌کند. مقدار پیش‌فرض -1 است (قاعدهٔ $ استفاده نمی‌شود). مقادیر ممکن دیگر شامل تمامی واحدهای کد معتبر هستند. تنها اعداد ده‌دهی شناسایی می‌شوند.

re2c:header, re2c:flags:type-header, re2c:flags:t

نام فایل سرآیند تولیدشده را به صورت نسبی نسبت به دایرکتوری فایل خروجی مشخص می‌کند. همانند گزینهٔ --header است با این تفاوت که مسیر فایل نسبی است.

re2c:indent:string

رشتهٔ مورد استفاده برای دندانه‌گذاری را مشخص می‌کند. پیش‌فرض یک نویسهٔ تب تک "\t" است. رشتهٔ دندانه‌گذاری تنها باید شامل نویسه‌های فاصلهٔ خالی باشد. برای غیرفعال کردن کامل دندانه‌گذاری، این پیکربندی را روی یک رشتهٔ خالی تنظیم کنید.

re2c:indent:top

حداقل مقدار دندانه‌گذاری برای استفاده را مشخص می‌کند. مقدار پیش‌فرض صفر است. این مقدار باید یک عدد صحیح غیرمنفی باشد.

re2c:invert-captures

همانند گزینهٔ --invert-captures است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:label:prefix, re2c:labelprefix

پیشوند مورد استفاده برای برچسب‌های وضعیت DFA را مشخص می‌کند. پیش‌فرض yy است.

re2c:label:start, re2c:startlabel

تولید برچسب شروع بلوک را کنترل می‌کند. مقدار پیش‌فرض صفر است، به این معنی که برچسب شروع تنها در صورت استفاده تولید می‌شود. یک مقدار عددی صحیح بزرگ‌تر از صفر، حتی اگر برچسب شروع توسط تحلیل‌گر لغوی استفاده نشود، تولید آن را اجباری می‌کند. مقدار رشته‌ای نیز تولید برچسب شروع را اجباری کرده و نام برچسب را روی رشتهٔ مشخص‌شده تنظیم می‌کند. این پیکربندی تنها روی بلوک فعلی اعمال می‌شود (برای بلوک بعدی به مقدار پیش‌فرض بازنشانی می‌شود).

re2c:label:yyFillLabel

پیشوند برچسب‌های YYFILL مورد استفاده همراه با re2c:eof و در حالت وضعیت قابل‌ذخیره را مشخص می‌کند.

re2c:label:yyloop

نام برچسب نشان‌دهندهٔ شروع حلقهٔ تحلیل‌گر لغوی با گزینهٔ --loop-switch را مشخص می‌کند. پیش‌فرض yyloop است.

re2c:label:yyNext

نام برچسب اختیاری را مشخص می‌کند که بعد از سوییچ YYGETSTATE در حالت وضعیت قابل‌ذخیره می‌آید (با re2c:state:nextlabel فعال می‌شود). پیش‌فرض yyNext است.

re2c:lookahead, re2c:flags:lookahead

منسوخ شده است (گزینهٔ منسوخ‌شدهٔ --no-lookahead را ببینید).

re2c:monadic

اگر روی غیرصفر تنظیم شود، تحلیل‌گر لغوی تولیدشده از نشانه‌گذاری مونادیک استفاده خواهد کرد (این پیکربندی مختص به Haskell است).

re2c:nested-ifs, re2c:flags:nested-ifs, re2c:flags:s

همانند گزینهٔ --nested-ifs است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:posix-captures, re2c:flags:posix-captures, re2c:flags:P

همانند گزینهٔ --posix-captures است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:posix-captvars

همانند گزینهٔ --posix-captvars است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:tags, re2c:flags:tags, re2c:flags:T

همانند گزینهٔ --tags است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود.

re2c:tags:expression

عبارت مورد استفاده برای متغیرهای برچسب را مشخص می‌کند. به طور پیش‌فرض re2swift عبارت‌هایی به فرم yyt<N> تولید می‌کند. این حالت ممکن است ناخوشایند باشد، برای مثال اگر متغیرهای برچسب به عنوان فیلدهایی در یک struct تعریف شده باشند. تمامی رخدادهای @@{tag} یا @@ با نام واقعی برچسب جایگزین می‌شوند. برای مثال، re2c:tags:expression = "s.@@"; منجر به تولید عبارت‌هایی به فرم s.yyt<N> در کد تولیدشده می‌شود. همچنین پیکربندی re2c:api:sigil را ببینید..TP re2c:tags:negative عبارت ثابتی را مشخص می‌کند که برای مقدار منفی تگ استفاده می‌شود (معمولاً در صورتی که تگ‌ها آفست‌های عدد صحیح در رشته ورودی باشند، مقدار آن -1 است یا اگر اشاره‌گر باشند، اشاره‌گر تهی خواهد بود).

re2c:tags:prefix

پیشوند نام متغیرهای تگ را مشخص می‌کند. مقدار پیش‌فرض yyt است.

re2c:sentinel

نماد دیده‌بان (sentinel) مورد استفاده برای بررسی‌های پایان ورودی را مشخص می‌کند (زمانی که بررسی‌های محدوده با re2c:yyfill:enable = 0; غیرفعال شده باشند و re2c:eof تنظیم نشده باشد). این پیکربندی بر تولید کد تأثیری ندارد: هدف آن اطمینان از عدم وجود نماد دیده‌بان در میان یک قاعده، و تضمین اینکه تحلیل‌گر لغوی فراتر از انتهای بافر را نخواهد خواند است. مقدار پیش‌فرض -1` است (در این حالت re2swift فرض می‌کند که دیده‌بان صفر است، که رایج‌ترین حالت می‌باشد). فقط اعداد ده‌دهی شناسایی می‌شوند.

re2c:state:abort

اگر روی یک مقدار عدد صحیح مثبت تنظیم شود، شاخهٔ پیش‌فرض (default case) در توزیع وضعیت تولیدشده، اجرای برنامه را لغو (abort) می‌کند و یک شاخهٔ صریح -1 شامل انتقال به ابتدای بلوک خواهد بود.

re2c:state:nextlabel

کنترل می‌کند که آیا بعد از عبارت switch مربوط به YYGETSTATE یک برچسب yyNext قرار گیرد یا خیر (مقدار پیش‌فرض صفر است که با عدم وجود برچسب مطابقت دارد). به عنوان جایگزین می‌توان از re2c:label:start برای تولید یک برچسب شروع مشخص، یا از یک بلوک صریح getstate برای تولید ساختار switch مربوط به YYGETSTATE به صورت جداگانه از بلوک تحلیل‌گر استفاده کرد.

re2c:unsafe, re2c:flags:unsafe

مشابه گزینهٔ --no-unsafe است، اما می‌تواند بر پایهٔ هر بلوک پیکربندی شود. اگر روی صفر تنظیم شود، از تولید پوشش‌های (wrappers) unsafe در اطراف YYPEEK جلوگیری می‌کند. پیش‌فرض مقداری غیرصفر است (پوشش‌ها تولید می‌شوند). این پیکربندی مختص Rust است.

re2c:YYBACKUP, re2c:define:YYBACKUP

عنصر پایهٔ عمومی API به نام YYBACKUP را تعریف می‌کند.

re2c:YYBACKUPCTX, re2c:define:YYBACKUPCTX

عنصر پایهٔ عمومی API به نام YYBACKUPCTX را تعریف می‌کند.

re2c:YYCONDTYPE, re2c:define:YYCONDTYPE

عنصر پایهٔ API به نام YYCONDTYPE را تعریف می‌کند.

re2c:YYCTYPE, re2c:define:YYCTYPE

عنصر پایهٔ API به نام YYCTYPE را تعریف می‌کند.

re2c:YYCTXMARKER, re2c:define:YYCTXMARKER

عنصر پایهٔ API به نام YYCTXMARKER را تعریف می‌کند.

re2c:YYCURSOR, re2c:define:YYCURSOR

عنصر پایهٔ API به نام YYCURSOR را تعریف می‌کند.

re2c:YYDEBUG, re2c:define:YYDEBUG

عنصر پایهٔ API به نام YYDEBUG را تعریف می‌کند.

re2c:YYFILL, re2c:define:YYFILL

عنصر پایهٔ API به نام YYFILL را تعریف می‌کند.

re2c:YYFILL@len, re2c:define:YYFILL@len

علامت ویژه (sigil) مورد استفاده برای جایگزینی آرگومان در تعریف YYFILL را مشخص می‌کند. مقدار پیش‌فرض @@ است. پیکربندی عمومی‌تر re2c:api:sigil را لغو می‌کند.

re2c:YYFILL:naked, re2c:define:YYFILL:naked

پیکربندی عمومی‌تر re2c:api:style را برای YYFILL لغو می‌کند. مقدار صفر متناظر با سبک آزاد API (free-form) است.

re2c:YYFN

عنصر پایهٔ API به نام YYFN را تعریف می‌کند.

re2c:YYINPUT

عنصر پایهٔ API به نام YYINPUT را تعریف می‌کند.

re2c:YYGETCOND, re2c:define:YYGETCONDITION

عنصر پایهٔ API به نام YYGETCOND را تعریف می‌کند.

re2c:YYGETCOND:naked, re2c:define:YYGETCONDITION:naked

پیکربندی عمومی‌تر re2c:api:style را برای YYGETCOND لغو می‌کند. مقدار صفر متناظر با سبک آزاد API است.

re2c:YYGETSTATE, re2c:define:YYGETSTATE

عنصر پایهٔ API به نام YYGETSTATE را تعریف می‌کند.

re2c:YYGETSTATE:naked, re2c:define:YYGETSTATE:naked

پیکربندی عمومی‌تر re2c:api:style را برای YYGETSTATE لغو می‌کند. مقدار صفر متناظر با سبک آزاد API است.

re2c:YYGETACCEPT, re2c:define:YYGETACCEPT

عنصر پایهٔ API به نام YYGETACCEPT را تعریف می‌کند.

re2c:YYLESSTHAN, re2c:define:YYLESSTHAN

عنصر پایهٔ عمومی API به نام YYLESSTHAN را تعریف می‌کند.

re2c:YYLIMIT, re2c:define:YYLIMIT

عنصر پایهٔ API به نام YYLIMIT را تعریف می‌کند.

re2c:YYMARKER, re2c:define:YYMARKER

عنصر پایهٔ API به نام YYMARKER را تعریف می‌کند.

re2c:YYMTAGN, re2c:define:YYMTAGN

عنصر پایهٔ عمومی API به نام YYMTAGN را تعریف می‌کند.

re2c:YYMTAGP, re2c:define:YYMTAGP

عنصر پایهٔ عمومی API به نام YYMTAGP را تعریف می‌کند.

re2c:YYPEEK, re2c:define:YYPEEK

عنصر پایهٔ عمومی API به نام YYPEEK را تعریف می‌کند.

re2c:YYRESTORE, re2c:define:YYRESTORE

عنصر پایهٔ عمومی API به نام YYRESTORE را تعریف می‌کند.

re2c:YYRESTORECTX, re2c:define:YYRESTORECTX

عنصر پایهٔ عمومی API به نام YYRESTORECTX را تعریف می‌کند.

re2c:YYRESTORETAG, re2c:define:YYRESTORETAG

عنصر پایهٔ عمومی API به نام YYRESTORETAG را تعریف می‌کند.

re2c:YYSETCOND, re2c:define:YYSETCONDITION

عنصر پایهٔ API به نام YYSETCOND را تعریف می‌کند.

re2c:YYSETCOND@cond, re2c:define:YYSETCONDITION@cond

علامت ویژه (sigil) مورد استفاده برای جایگزینی آرگومان در تعریف YYSETCOND را مشخص می‌کند. مقدار پیش‌فرض @@ است. پیکربندی عمومی‌تر re2c:api:sigil را لغو می‌کند.

re2c:YYSETCOND:naked, re2c:define:YYSETCONDITION:naked

پیکربندی عمومی‌تر re2c:api:style را برای YYSETCOND لغو می‌کند. مقدار صفر متناظر با سبک آزاد API است.

re2c:YYSETSTATE, re2c:define:YYSETSTATE

عنصر پایهٔ API به نام YYSETSTATE را تعریف می‌کند.

re2c:YYSETSTATE@state, re2c:define:YYSETSTATE@state

علامت ویژه (sigil) مورد استفاده برای جایگزینی آرگومان در تعریف YYSETSTATE را مشخص می‌کند. مقدار پیش‌فرض @@ است. پیکربندی عمومی‌تر re2c:api:sigil را لغو می‌کند.

re2c:YYSETSTATE:naked, re2c:define:YYSETSTATE:naked

پیکربندی عمومی‌تر re2c:api:style را برای YYSETSTATE لغو می‌کند. مقدار صفر متناظر با سبک آزاد API است.

re2c:YYSETACCEPT, re2c:define:YYSETACCEPT

عنصر پایهٔ API به نام YYSETACCEPT را تعریف می‌کند.

re2c:YYSKIP, re2c:define:YYSKIP

عنصر پایهٔ عمومی API به نام YYSKIP را تعریف می‌کند.

re2c:YYSHIFT, re2c:define:YYSHIFT

عنصر پایهٔ عمومی API به نام YYSHIFT را تعریف می‌کند.

re2c:YYCOPYMTAG, re2c:define:YYCOPYMTAG

عنصر پایهٔ عمومی API به نام YYCOPYMTAG را تعریف می‌کند.

re2c:YYCOPYSTAG, re2c:define:YYCOPYSTAG

عنصر پایهٔ عمومی API به نام YYCOPYSTAG را تعریف می‌کند.

re2c:YYSHIFTMTAG, re2c:define:YYSHIFTMTAG

عنصر پایهٔ عمومی API به نام YYSHIFTMTAG را تعریف می‌کند.

re2c:YYSHIFTSTAG, re2c:define:YYSHIFTSTAG

عنصر پایهٔ عمومی API به نام YYSHIFTSTAG را تعریف می‌کند.

re2c:YYSTAGN, re2c:define:YYSTAGN

عنصر پایهٔ عمومی API به نام YYSTAGN را تعریف می‌کند.

re2c:YYSTAGP, re2c:define:YYSTAGP

عنصر پایهٔ عمومی API به نام YYSTAGP را تعریف می‌کند.

re2c:yyaccept, re2c:variable:yyaccept

عنصر پایهٔ API به نام yyaccept را تعریف می‌کند.

re2c:yybm, re2c:variable:yybm

عنصر پایهٔ API به نام yybm را تعریف می‌کند.

re2c:yybm:hex, re2c:variable:yybm:hex

اگر روی مقداری غیرصفر تنظیم شود، نقشه‌های بیتی (bitmaps) برای گزینهٔ --bit-vectors در قالب شانزده‌شانزدهی (hexadecimal) تولید می‌شوند. پیش‌فرض صفر است (نقشه‌های بیتی در قالب ده‌دهی هستند).

re2c:yych, re2c:variable:yych

عنصر پایهٔ API به نام yych را تعریف می‌کند.

re2c:yych:emit, re2c:variable:yych:emit

اگر روی صفر تنظیم شود، تعریف yych تولید نمی‌شود. مقدار پیش‌فرض غیرصفر است.

re2c:yych:conversion, re2c:variable:yych:conversion

اگر روی مقداری غیرصفر تنظیم شود، re2swift به طور خودکار هر بار که yych خوانده می‌شود، یک تبدیل به YYCTYPE تولید می‌کند. پیش‌فرض صفر است (بدون تبدیل).

re2c:yych:literals, re2c:variable:yych:literals

قالب لیترال‌هایی که yych با آن‌ها مطابقت داده می‌شود را مشخص می‌کند. مقادیر ممکن عبارتند از: char (لیترال‌های نویسه‌ای درون گیومه تکی؛ موارد غیرقابل چاپ از توالی‌های گریز که با بک‌اسلش شروع می‌شوند استفاده می‌کنند)، hex (اعداد صحیح شانزده‌شانزدهی) و char_or_hex (ترکیبی از هر دو؛ لیترال‌های نویسه‌ای برای نویسه‌های قابل چاپ و اعداد صحیح شانزده‌شانزدهی برای بقیه).

re2c:yyctable, re2c:variable:yyctable

عنصر پایهٔ API به نام yyctable را تعریف می‌کند..TP re2c:yynmatch, re2c:variable:yynmatch عنصر پایه API با نام yynmatch را تعریف می‌کند.

re2c:yypmatch, re2c:variable:yypmatch

عنصر پایه API با نام yypmatch را تعریف می‌کند.

re2c:yytarget, re2c:variable:yytarget

عنصر پایه API با نام yytarget را تعریف می‌کند.

re2c:yystable, re2c:variable:yystable

منسوخ شده است.

re2c:yystate, re2c:variable:yystate

عنصر پایه API با نام yystate را تعریف می‌کند.

re2c:yyfill, re2c:variable:yyfill

عنصر پایه API با نام yyfill را تعریف می‌کند.

re2c:yyfill:check

اگر روی صفر تنظیم شود، از تولید بررسی پیش از YYFILL برای تعداد نویسه‌های ورودی (تعریف YYLESSTHAN در API عمومی و مقایسه مبتنی بر YYLIMIT در API اشاره‌گر C) جلوگیری می‌کند. مقدار پیش‌فرض غیرصفر است (بررسی را تولید می‌کند).

re2c:yyfill:enable

اگر روی صفر تنظیم شود، تولید YYFILL را (همراه با بررسی آن) لغو می‌کند. این حالت باید زمانی استفاده شود که کل ورودی در یک بخش یکپارچه از حافظه جا می‌شود (نیازی به بافر کردن نیست) و بررسی‌های پایان ورودی به بررسی‌های YYFILL متکی نیستند (برای نمونه، اگر از نویسه نشانگر پایان / sentinel استفاده شود). برای اطمینان از اینکه تحلیل‌گر لغوی تولیدشده نمی‌تواند فراتر از پایان ورودی را بخواند، از هشدارها (گزینه -W) و پیکربندی re2c:sentinel استفاده کنید. مقدار پیش‌فرض غیرصفر است (YYFILL فعال است).

re2c:yyfill:parameter

اگر روی صفر تنظیم شود، از تولید پارامتر ارسالی به YYFILL جلوگیری می‌کند. این پارامتر حداقل تعداد نویسه‌هایی است که باید فراهم شوند. پیش‌فرض غیرصفر است (پارامتر تولید می‌شود). این پیکربندی را می‌توان با re2c:YYFILL:naked یا re2c:api:style بازنویسی کرد.

re2c:yyfn:sep

جداکننده مورد استفاده در عناصر YYFN را مشخص می‌کند (پیش‌فرض نقطه-ویرگول است).

re2c:yyfn:throw

استثناهای پرتاب‌شده توسط تابع YYFN را مشخص می‌کند (پیش‌فرض خالی است، که به معنای پرتاب نشدن هیچ استثنایی است).

-? --help -h

نمایش پیام راهنما.

--api <simple | record | generic>

مشخص کردن API مورد استفاده توسط کد تولیدشده جهت برقراری ارتباط با کد تعریف‌شده توسط کاربر. گزینهٔ simple باید در موارد ساده استفاده شود؛ هنگامی که نیازی به پر کردن مجدد بافر و ذخیره‌سازی وضعیت تحلیل‌گر لغوی (lexer) نیست. گزینهٔ record باید زمانی استفاده شود که وضعیت لکسر باید در یک رکورد (struct، class و غیره) ذخیره شود. گزینهٔ generic باید در سناریوهای پیچیده‌ای به کار رود که دو API دیگر انعطاف‌پذیری کافی ندارند.

--bit-vectors -b

بهینه‌سازی پرش‌های شرطی با استفاده از ماسک‌های بیتی. این گزینه مستلزم --nested-ifs است.

--captures, --leftmost-captures

فعال‌سازی استخراج زیرتطابق با گروه‌های گیرندهٔ حریصانه‌ترینِ چپ‌ترین (leftmost greedy). نتیجه در آرایهٔ yybmatch با ظرفیت 2 * YYMAXNMATCH جمع‌آوری می‌شود، و yynmatch به تعداد گروه‌ها برای قاعدهٔ منطبق‌شده تنظیم می‌گردد.

--captvars, --leftmost-captvars

فعال‌سازی استخراج زیرتطابق با گروه‌های گیرندهٔ حریصانه‌ترینِ چپ‌ترین (leftmost greedy). نتیجه در متغیرهای yytl<k> و yytr<k> برای گروه گیرندهٔ k-اُم گردآوری می‌شود.

--case-insensitive

در نظر گرفتن رشته‌های دارای تک‌نقل‌قول و دونقل‌قول به صورت غیرحساس به بزرگی و کوچکی حروف.

--case-inverted

معکوس کردن معنای رشته‌های دارای تک‌نقل‌قول و دونقل‌قول: رشته‌های با تک‌نقل‌قول حساس به حروف و رشته‌های با دونقل‌قول غیرحساس به بزرگی و کوچکی حروف در نظر گرفته می‌شوند.

--case-ranges

ادغام caseهای متوالی در دستور switch به یک بازه در قالب low ... high. این نحو، یک افزونهٔ زبان C/C++ است که توسط کامپایلرهایی مانند GCC، Clang و Tcc پشتیبانی می‌شود. مزیت اصلی نسبت به استفاده از caseهای تکی، تولید کد کوچک‌تر و سرعت بالاتر در زمان تولید کد است، اگرچه برای برخی کامپایلرها مانند Tcc منجر به کاهش اندازهٔ فایل باینری نیز می‌شود.

--computed-gotos -g

بهینه‌سازی پرش‌های شرطی با استفاده از افزونهٔ غیراستاندارد "computed goto" (که باید توسط کامپایلر پشتیبانی شود). برنامه re2swift جدول‌های پرش را تنها در موارد پیچیده با تعداد زیادی شاخهٔ شرطی تولید می‌کند. آستانهٔ پیچیدگی با پیکربندی cgoto:threshold قابل تنظیم است. آفست‌های نسبی را می‌توان با پیکربندی cgoto:relative فعال کرد. این گزینه مستلزم --bit-vectors است.

--computed-gotos-relative

مشابه --computed-gotos، اما در عوض آفست‌های نسبی را برای جدول‌های پرش تولید می‌کند (که باید توسط کامپایلر پشتیبانی شود). این گزینه مستلزم --computed-gotos است.

--conditions --start-conditions -c

فعال‌سازی پشتیبانی از "شرایط" مشابه Flex: چندین لکسر مرتبط درون یک بلوک. این یک جایگزین برای مشخص‌کردن دستی بلوک‌های مختلف re2swift متصل‌شده با goto یا فراخوانی‌های توابع است.

--depfile FILE

نوشتن اطلاعات وابستگی در FILE در قالب یک قاعدهٔ Makefile به شکل <output-file> : <input-file> [include-file ...]. این قابلیت امکان ردیابی وابستگی‌های ساخت را در حضور بلوک‌ها/دستورهای include فراهم می‌کند، به طوری که به‌روزرسانی فایل‌های include باعث تولید مجدد فایل خروجی می‌شود. این گزینه به گزینهٔ --output وابسته است.

--ebcdic --ecb -e

تولید لکسری که ورودی را با کدگذاری EBCDIC می‌خواند. برنامه re2swift فرض می‌کند که محدودهٔ نویسه‌ها 0 -- 0xFF و اندازهٔ نویسه ۱ بایت است.

--empty-class <match-empty | match-none | error>

تعیین نحوهٔ رفتار re2swift با کلاس‌های نویسهٔ خالی. با مقدار match-empty (پیش‌فرض) کلاس خالی با ورودی خالی تطابق می‌یابد (که غیرمنطقی است، اما برای سازگاری با نسخه‌های قبلی حفظ شده است). با match-none تطبیق کلاس خالی همیشه با شکست مواجه می‌شود. با error کلاس خالی یک خطای کامپایل ایجاد می‌کند.

--encoding-policy <fail | substitute | ignore>

تعیین نحوهٔ رفتار re2swift با جانشین‌های یونیکد (surrogates). با مقدار fail برنامه re2swift با مواجهه با یک جانشین، با خطا متوقف می‌شود. با substitute برنامه re2swift بدون هشدار جانشین‌ها را با کدپوینت خطای 0xFFFD جایگزین می‌کند. با ignore (پیش‌فرض) re2swift با جانشین‌ها مانند کدپوینت‌های معمولی رفتار می‌کند. استاندارد یونیکد بیان می‌کند که جانشین‌های مستقل نامعتبر هستند، اما کتابخانه‌ها و برنامه‌های دنیای واقعی رفتارهای متفاوتی دارند.

--flex-syntax -F

پشتیبانی جزئی از نحو Flex: در این حالت تعاریف نام‌گذاری‌شده نیازی به علامت مساوی و سمی‌کولنِ پایانی ندارند، و در صورت استفاده باید درون آکوالاد قرار گیرند. نام‌های بدون آکوالاد به عنوان رشته‌های محصور در دونقل‌قول در نظر گرفته می‌شوند.

--goto-label

استفاده از مدل کد "goto/label": کدگذاری DFA در قالب بلوک‌های کد برچسب‌دار متصل‌شده با انتقال‌های goto میان بلوک‌ها. این گزینه تنها برای زبان‌هایی پشتیبانی می‌شود که دستور goto دارند.

--header --type-header -t HEADER

تولید یک فایل HEADER. محتوای فایل را می‌توان با استفاده از بلوک‌های ویژهٔ header:on و header:off تعیین کرد. در صورت استفاده از شرایط، شمارشگر مربوط به شرایط (enum) به طور خودکار به انتهای فایل سرایندِ تولیدشده اضافه خواهد شد (مگر اینکه یک بلوک صریح conditions وجود داشته باشد).

-I PATH

افزودن PATH به فهرست مسیرهایی که هنگام جستجوی فایل‌های include استفاده می‌شوند. این گزینه در ترکیب با بلوک یا دستور include مفید است. برنامه re2swift فایل FILE را در دایرکتوری فایل والد و در مسیرهای include تعیین‌شده با گزینهٔ -I جستجو می‌کند.

--input <default | custom>

نام مستعار منسوخ‌شده برای --api. گزینهٔ default متناظر با simple است (در واقع برای اکثر بک‌اندها پیش‌فرض است، اما نه برای همه). گزینهٔ custom متناظر با generic است.

--input-encoding <ascii | utf8>

مشخص کردن نحوهٔ تجزیهٔ عبارت‌های منظم توسط re2swift. با مقدار ascii (پیش‌فرض) re2swift ورودی را به عنوان کدگذاری ASCII در نظر می‌گیرد: هر توالی از واحدهای کد، توالی از نویسه‌های مستقل ۱ بایتی است. با utf8 برنامه re2swift ورودی را به عنوان کدگذاری UTF-8 در نظر گرفته و نویسه‌های چندبایتی را تشخیص می‌دهد.

--invert-captures

معکوس کردن معنای گروه‌های گیرنده و غیرگیرنده. به صورت پیش‌فرض (...) گیرنده و (! ...) غیرگیرنده است. با این گزینه (! ...) گیرنده و (...) غیرگیرنده خواهد بود.

--lang <none | c | d | go | haskell | java | js | ocaml | python | rust | swift | v | zig>

مشخص کردن زبان مقصد. زبان‌های پشتیبانی‌شده عبارتند از C، D، Go، Haskell، Java، JS، OCaml، Python، Rust، Swift، V، Zig (زبان‌های بیشتر را می‌توان از طریق فایل‌های نحوِ تعریف‌شده توسط کاربر اضافه کرد؛ گزینهٔ --syntax را ببینید). گزینهٔ none پیکربندی‌های پیش‌فرض نحو را غیرفعال می‌کند تا زبان مقصد تعریف‌نشده باقی بماند.

--location-format <gnu | msvc>

تعیین قالب مکان در پیام‌ها. با gnu مکان‌ها به صورت 'filename:line:column: ...' چاپ می‌شوند. با msvc مکان‌ها به صورت 'filename(line,column) ...' چاپ می‌شوند. پیش‌فرض gnu است.

--loop-switch

استفاده از مدل کد "loop/switch": کدگذاری DFA در قالب یک حلقه روی دستور switch، که در آن وضعیت‌های جداگانه همان caseهای switch هستند. وضعیت در یک متغیر yystate ذخیره می‌شود. انتقال‌های بین وضعیت‌ها، yystate را به برچسب case وضعیت مقصد به‌روزرسانی کرده و اجرا را به ابتدای حلقه ادامه می‌دهند.

--nested-ifs -s

استفاده از دستورات تو‌در‌توی if به جای دستورات switch در پرش‌های شرطی. این کار معمولاً در کامپایلرهای غیربهینه‌ساز منجر به کدی کارآمدتر می‌شود.

--no-debug-info -i

عدم درج دستورهای خط (line directives) در خروجی. این قابلیت زمانی که کد تولیدشده در یک سیستم کنترل نسخه نگهداری می‌شود مفید است (برای جلوگیری از diffهای حجیم خودکار روی تغییرات کوچک).

--no-generation-date

جلوگیری از چاپ تاریخ در فایل تولیدشده.

--no-version

جلوگیری از چاپ نسخه در فایل تولیدشده.

--no-unsafe

عدم تولید بسته‌بند unsafe روی YYPEEK (این گزینه مختص Rust است). به دلایل کارایی، YYPEEK باید از بررسی محدوده (bounds-checking) خودداری کند، زیرا لکسر پیش از این بررسی‌های پایان ورودی را به روشی کارآمدتر انجام می‌دهد. کاربر ممکن است تعریفی امن از YYPEEK ارائه دهد، یا تعریفی که تنها در بیلد انتشار (release) ناامن باشد، که در این حالت گزینهٔ --no-unsafe به جلوگیری از هشدارهای مربوط به بلوک‌های unsafe زاید کمک می‌کند.

--output -o OUTPUT

مشخص کردن فایل OUTPUT.

--posix-captures, -P

فعال‌سازی استخراج زیرتطابق با گروه‌های گیرندهٔ سبک POSIX. نتیجه در آرایهٔ yybmatch با ظرفیت 2 * YYMAXNMATCH گردآوری شده، و yynmatch به تعداد گروه‌ها برای قاعدهٔ منطبق تنظیم می‌شود.

--posix-captvars

فعال‌سازی استخراج زیرتطابق با گروه‌های گیرندهٔ سبک POSIX. نتیجه در متغیرهای yytl<k> و yytr<k> برای گروه گیرندهٔ k-اُم گردآوری می‌شود.

--recursive-functions

استفاده از مدل کد مبتنی بر توابع هم‌بازگشتی (co-recursive)، که در آن هر وضعیت DFA یک تابع مجزاست که می‌تواند سایر توابع وضعیت یا خودش را فراخوانی کند.

--reusable -r

از نگارش 2.2 منسوخ شده است (بلوک‌های با قابلیت استفاده مجدد اکنون به طور پیش‌فرض مجاز هستند).

--skeleton -S

نادیده گرفتن کد واسط تعریف‌شده توسط کاربر و تولید یک برنامهٔ خودکفای "اسکلت" (skeleton). علاوه بر این، تولید فایل‌های ورودی با رشته‌های مشتق‌شده از گرامر منظم و نتایج تطابق فشرده‌شده که برای اعتبارسنجی رفتار برنامهٔ "اسکلت" روی تمام ورودی‌ها به کار می‌روند. این گزینه برای یافتن باگ‌ها در بهینه‌سازی‌ها و تولید کد مفید است. این گزینه تنها برای C پشتیبانی می‌شود..TP --storable-state -f تولید یک تحلیل‌گر لغوی که می‌تواند وضعیت درونی خود را ذخیره کند. این ویژگی در تحلیل‌گرهای لغوی مبتنی بر مدل push مفید است که در هنگام عدم وجود ورودی کافی توسط برنامه‌ای بیرونی متوقف شده و پس از در دسترس قرار گرفتن ورودی بیشتر، اجرای آن‌ها از سر گرفته می‌شود. در این حالت، کاربران باید علاوه بر این، دستورات اولیهٔ YYGETSTATE و YYSETSTATE را تعریف کنند، و متغیرهای yych، yyaccept و state باید بخشی از وضعیت ذخیره‌شدهٔ تحلیل‌گر لغوی باشند.

--syntax FILE

بارگذاری پیکربندی‌ها از FILE مشخص‌شده و اعمال آن‌ها روی فایل نحو پیش‌فرض. توجه داشته باشید که FILE می‌تواند تنها چند پیکربندی را تعریف کند (اگر برای اصلاح فایل نحو پیش‌فرض استفاده شود)، یا یک بک‌اند زبان کاملاً جدید را تعریف نماید (در حالت دوم توصیه می‌شود از گزینهٔ --lang none استفاده شود).

--tags -T

فعال‌سازی استخراج تطابق‌های فرعی با برچسب‌ها.

--ucs2 --wide-chars -w

تولید یک تحلیل‌گر لغوی که ورودی با کدگذاری UCS2 را می‌خواند. re2swift فرض می‌کند که دامنهٔ نویسه‌ها 0 -- 0xFFFF و اندازهٔ نویسه ۲ بایت است. این گزینه مستلزم --nested-ifs است.

--utf8 --utf-8 -8

تولید یک تحلیل‌گر لغوی که ورودی با کدگذاری UTF-8 را می‌خواند. re2swift فرض می‌کند که دامنهٔ نویسه‌ها 0 -- 0x10FFFF و اندازهٔ نویسه ۱ بایت است.

--utf16 --utf-16 -x

تولید یک تحلیل‌گر لغوی که ورودی با کدگذاری UTF16 را می‌خواند. re2swift فرض می‌کند که دامنهٔ نویسه‌ها 0 -- 0x10FFFF و اندازهٔ نویسه ۲ بایت است. این گزینه مستلزم --nested-ifs است.

--utf32 --unicode -u

تولید یک تحلیل‌گر لغوی که ورودی با کدگذاری UTF32 را می‌خواند. re2swift فرض می‌کند که دامنهٔ نویسه‌ها 0 -- 0x10FFFF و اندازهٔ نویسه ۴ بایت است. این گزینه مستلزم --nested-ifs است.

--verbose

چاپ یک پیام کوتاه در صورت موفقیت.

--vernum -V

نمایش اطلاعات نسخه در قالب MMmmpp (نسخه اصلی، فرعی، وصله).

--version -v

نمایش اطلاعات نسخه.

--single-pass -1

منسوخ شده است. کاری انجام نمی‌دهد (حالت تک‌گذره در حال حاضر پیش‌فرض است).

--debug-output -d

درج فراخوانی‌های YYDEBUG در کد تولیدشده. این قابلیت برای ردگیری اجرای تحلیل‌گر لغوی مفید است.

--dump-adfa

گزینهٔ اشکال‌زدایی: خروجی دادن DFA پس از تونل‌زنی (به قالب .dot).

--dump-cfg

گزینهٔ اشکال‌زدایی: خروجی دادن گراف جریان کنترل متغیرهای برچسب (به قالب .dot).

--dump-closure-stats

گزینهٔ اشکال‌زدایی: خروجی دادن آمار تعداد وضعیت‌ها در بستار.

--dump-dfa-det

گزینهٔ اشکال‌زدایی: خروجی دادن DFA بلافاصله پس از قطعی‌سازی (به قالب .dot).

--dump-dfa-min

گزینهٔ اشکال‌زدایی: خروجی دادن DFA پس از کمینه‌سازی (به قالب .dot).

--dump-dfa-tagopt

گزینهٔ اشکال‌زدایی: خروجی دادن DFA پس از بهینه‌سازی‌های برچسب (به قالب .dot).

--dump-dfa-tree

گزینهٔ اشکال‌زدایی: خروجی دادن DFA در حال ساخت با وضعیت‌هایی که به صورت درخت‌های تاریخچهٔ برچسب نمایش داده شده‌اند (به قالب .dot).

--dump-dfa-raw

گزینهٔ اشکال‌زدایی: خروجی دادن DFA در حال ساخت با مجموعه‌وضعیت‌های بسط‌یافته (به قالب .dot).

--dump-interf

گزینهٔ اشکال‌زدایی: خروجی دادن جدول تداخل حاصل از تحلیل زنده‌بودنِ متغیرهای برچسب.

--dump-nfa

گزینهٔ اشکال‌زدایی: خروجی دادن NFA (به قالب .dot).

--emit-dot -D

به جای خروجی معمول، گراف تحلیل‌گر لغوی را در قالب .dot تولید می‌کند. خروجی را می‌توان با کمک Graphviz به یک تصویر تبدیل کرد (مانند dot -Tpng -odfa.png dfa.dot).

--dfa-minimization <moore | table>

گزینهٔ داخلی: الگوریتم کمینه‌سازی DFA مورد استفاده توسط re2swift. گزینهٔ moore الگوریتم مور است (که پیش‌فرض است). گزینهٔ table الگوریتم "پر کردن جدول" است. هر دو الگوریتم باید صرف‌نظر از نام‌گذاری مجدد وضعیت‌ها، DFA یکسانی تولید کنند؛ پر کردن جدول ساده‌تر و بسیار کندتر است و به عنوان پیاده‌سازی مرجع عمل می‌کند.

--eager-skip

گزینهٔ داخلی: وادار کردن تحلیل‌گر لغوی تولیدشده به پیش بردن مشتاقانهٔ موقعیت ورودی -- بلافاصله پس از خواندن نماد ورودی. این گزینه رفتار پیش‌فرض را تغییر می‌دهد که در آن موقعیت ورودی به صورت تنبلانه -- پس از گذار به وضعیت بعدی -- به جلو برده می‌شود.

--no-lookahead

گزینهٔ داخلی، منسوخ شده. در گذشته برای فعال‌سازی الگوریتم TDFA(0) به کار می‌رفت. بر خلاف TDFA(1)، الگوریتم TDFA(0) از پیش‌نگری یک‌نمادی استفاده نمی‌کند. این الگوریتم عملیات ثبات‌ها را به جای گذارهای خروجی، روی گذارهای ورودی اعمال می‌کند. ارزیابی‌ها نشان دادند که الگوریتم TDFA(0) کارایی کمتری نسبت به TDFA(1) دارد.

--no-optimize-tags

گزینهٔ داخلی: غیرفعال کردن بهینه‌سازی متغیرهای برچسب (مفید برای اشکال‌زدایی).

--posix-closure <gor1 | gtop>

گزینهٔ داخلی: تعیین الگوریتم کوتاه‌ترین مسیر مورد استفاده برای ساخت بستار اپسیلون با معناشناسی رفع ابهام POSIX؛ مقدار gor1 (پیش‌فرض) نشان‌دهندهٔ الگوریتم گلدبرگ-رادزیک (Goldberg-Radzik) است و gtop نشان‌دهندهٔ الگوریتم "ترتیب توپولوژیکی سراسری" می‌باشد.

--posix-prectable <complex | naive>

گزینهٔ داخلی: تعیین الگوریتم مورد استفاده برای محاسبهٔ جدول اولویت POSIX. الگوریتم complex جدول اولویت را در یک پیمایش از درخت تاریخچهٔ برچسب محاسبه می‌کند و دارای پیچیدگی درجه دو بر حسب تعداد وضعیت‌های TNFA است؛ این حالت پیش‌فرض است. الگوریتم naive در بدترین حالت دارای پیچیدگی درجه سه بر حسب تعداد وضعیت‌های TNFA است، اما بسیار ساده‌تر از complex بوده و ممکن است در موارد غیرپاتولوژیک کمی سریع‌تر باشد.

--stadfa

گزینهٔ داخلی، منسوخ شده. در گذشته برای فعال‌سازی الگوریتم staDFA به کار می‌رفت؛ تفاوت این الگوریتم با TDFA در این است که عملیات ثبات‌ها به جای قرارگیری روی گذارها، در وضعیت‌ها قرار می‌گیرند. ارزیابی‌ها نشان دادند که الگوریتم staDFA کارایی کمتری نسبت به TDFA دارد.

--fixed-tags <none | toplevel | all>

گزینهٔ داخلی: مشخص می‌کند که آیا بهینه‌سازی برچسب‌های ثابت باید روی همهٔ برچسب‌ها اعمال شود (all)، روی هیچ‌کدام (none)، یا فقط روی آن‌هایی که در الحاق سطح بالا قرار دارند (toplevel). مقدار پیش‌فرض all است. برچسب‌های "ثابت" برچسب‌هایی هستند که در فاصله‌ای معین نسبت به برچسبی دیگر (موسوم به "پایه") قرار دارند. در چنین حالتی تنها برچسب پایه نیاز به ردیابی دارد، و مقدار برچسب ثابت را می‌توان از حاصل جمع مقدار برچسب پایه با یک آفست ایستا محاسبه کرد. برای برچسب‌هایی که درون ساختار انتخاب (alternative) یا تکرار قرار دارند، بررسی این موضوع نیز لازم است که آیا برچسب پایه مقداری معادل عدم تطابق دارد یا خیر (در این صورت برچسب ثابت نیز باید بدون در نظر گرفتن آفست، روی عدم تطابق تنظیم شود). برای برچسب‌های واقع در الحاق سطح بالا، این بررسی لازم نیست زیرا آن‌ها همیشه مطابقت دارند.

هشدارها را می‌توان به‌صورت جداگانه فعال یا غیرفعال کرد و یا به یک خطا تبدیل نمود.

code-template ::
      name '=' code-exprs ';'
    | CODE_TEMPLATE ';'
    | '<undefined>' ';'
code-exprs ::
      <EMPTY>
    | code-exprs code-expr
code-expr ::
      STRING
    | VARIABLE
    | optional
    | list
optional ::
      '(' CONDITIONAL '?' code-exprs ')'
    | '(' CONDITIONAL '?' code-exprs ':' code-exprs ')'
list ::
      '[' VARIABLE ':' code-exprs ']'
    | '[' VARIABLE '{' NUMBER '}' ':' code-exprs ']'
    | '[' VARIABLE '{' NUMBER ',' NUMBER '}' ':' code-exprs ']'

یک الگوی کد توالی‌ای از رشته‌های لفظی، متغیرها، عناصر اختیاری و فهرست‌ها، یا ارجاعی به الگوی کد دیگر، یا مقدار ویژه <undefined> است. متغیرها جای‌بان‌هایی هستند که در مرحله تولید کد جایگزین می‌شوند. متغیرهای فهرستی خاص هستند: هنگام بسط الگوهای فهرستی، re2swift عبارت‌های سمت راست دونقطه را چند بار تکرار می‌کند، و هر بار رخدادهای متغیر فهرست را با مقداری مخصوص به این تکرار جایگزین می‌سازد. فهرست‌ها دارای کران‌های اختیاری هستند (مقادیر منفی از انتها شمرده می‌شوند، مثلاً -1 به معنای آخرین عنصر است). نام‌های شرطی با یک نقطه شروع می‌شوند. هم شرط‌ها و هم متغیرها می‌توانند محلی (مخصوص به الگوی کد داده‌شده) یا سراسری (مجاز در تمام الگوهای کد) باشند. هنگامی که re2swift فایل نحو را می‌خواند، بررسی می‌کند که هر الگوی کد تنها از متغیرها و شرط‌هایی استفاده کند که در آن مجاز هستند.

به‌عنوان مثال، الگوی کد زیر ساختار if-then-else را برای یک زبان C-مانند تعریف می‌کند:

code:if_then_else =
    [branch{0}: topindent "if " cond " {" nl
        indent [stmt: stmt] dedent]
    [branch{1:-1}: topindent "} else" (.cond ? " if " cond) " {" nl
        indent [stmt: stmt] dedent]
    topindent "}" nl;

در اینجا branch یک متغیر فهرستی است: branch{0} به شاخه نخست بسط می‌یابد (که ویژه است، زیرا بخش else ندارد)، و branch{1:-1} به تمام شاخه‌های باقی‌مانده (در صورت وجود) بسط پیدا می‌کند. stmt نیز یک متغیر فهرستی است: [stmt: stmt] یک فهرست تو‌در‌تو است که به فهرستی از دستورها در بدنه شاخه جاری بسط می‌یابد. topindent، indent، dedent و nl متغیرهای سراسری هستند، و .cond یک شرط محلی است (معنای آن‌ها در ادامه شرح داده شده است). این الگوی کد می‌تواند کد زیر را تولید کند:

if x {
    // do something
} else if y {
    // do something else
} else {
    // don't do anything
}

در ادامه فهرستی از تمام الگوهای کد پشتیبانی‌شده توسط re2swift به همراه متغیرها و شرط‌های محلی آن‌ها آورده شده است. توجه داشته باشید که یک تعریف خاص می‌تواند از متغیرها و شرط‌های محلی استفاده کند، اما ملزم به انجام آن نیست. هر الگوی کد بدون استفاده باید روی <undefined> تنظیم شود.

در اینجا فهرستی از تمام متغیرهای سراسری مجاز در فایل‌های نحو آورده شده است:

در اینجا فهرستی از تمام شرط‌های سراسری مجاز در فایل‌های نحو آمده است:

// re2swift $INPUT -o $OUTPUT
// Expects a null-terminated string.
func lex(_ yyinput: UnsafePointer<UInt8>, _ length: Int) -> Int? {
  var yycursor = 0, yylimit = length, yymarker = 0
  var count = 0
  loop: while true {
    /*!re2c
      re2c:eof = 0;
      re2c:yyfill:enable = 0;
      str = ['] ([^'\\] | [\\][^])* ['];
      str {
        count += 1
        continue loop
      }
      [ ]+ { continue loop }
      *    { return nil }
      $    { return count }
    */
  }
}
func test(_ str: StaticString, _ expect: Int?) {
  assert(lex(str.utf8Start, str.utf8CodeUnitCount) == expect)
}
test("", 0);
test("'qu\0tes' 'are' 'fine: \\'' ", 3);
test("'unterminated\\'", nil);

// re2swift $INPUT -o $OUTPUT
/*!max:re2c*/
func lex(_ str: UnsafeBufferPointer<UInt8>) -> Int? {
  let length = str.count
  // Make a copy of the string with YYMAXFILL zeroes at the end.
  let yyinput = ContiguousArray<UInt8>(str) + repeatElement(0, count: yymaxfill)
  var yycursor = 0, yylimit = length + yymaxfill
  var count = 0
  loop: while true {
    /*!re2c
      re2c:YYFILL  = "return nil";
      str = ['] ([^'\\] | [\\][^])* ['];
      str {
        count += 1
        continue loop
      }
      [\x00] {
        // Check that it's the sentinel, not some unexpected null.
        if yycursor - 1 == length { return count } else { return nil }
      }
      [ ]+ { continue loop }
      *    { return nil }
    */
  }
}
func test(_ str: StaticString, _ expect: Int?) {
  str.withUTF8Buffer {
    assert(lex($0) == expect)
  }
}
test("", 0)
test("'qu\0tes' 'are' 'fine: \\'' ", 3)
test("'unterminated\\'", nil)
test("'unexpected \0 null\\'", nil)

               <-- shift -->
             >-A------------B---------C------------D#-----------E->
             buffer       token    marker         limit,
                                                  cursor
>-A------------B---------C------------D------------E#->
             buffer,  marker        cursor        limit
             token
               <-- shift -->
             >-A------------B---------C------------D#--E (EOF)
             buffer       token    marker         limit,
                                                  cursor
>-A------------B---------C------------D---E#........
             buffer,  marker       cursor limit
             token

// re2swift $INPUT -o $OUTPUT
import Foundation
struct Input {
  static let bufferSize = 4095
  var file: FileHandle
  var yyinput  = ContiguousArray<UInt8>(repeating: 0, count: Self.bufferSize + 1)
  var yylimit  = Self.bufferSize
  var yycursor = Self.bufferSize
  var yymarker = Self.bufferSize
  var token    = -1
  var eof      = false
}
extension Input {
  mutating func lex() -> Int? {
    var count = 0
    loop: while true {
      self.token = self.yycursor
      /*!re2c
        re2c:api = record;
        re2c:eof = 0;
        re2c:yyrecord = "self";
        re2c:YYFILL   = "self.fill() == .ok";
        str = ['] ([^'\\] | [\\][^])* ['];
        str {
          count += 1
          continue loop
        }
        [ ]+ { continue loop }
        $    { return count }
        *    { return nil }
      */
    }
  }
  mutating func fill() -> FillStatus {
    guard !self.eof else {
      return .eof
    }
    let shift = self.token
    let used = self.yylimit - self.token
    let free = Self.bufferSize - used
    // Error: Lexeme too long. In the real world we can reallocate a larger buffer.
    if self.token < 1 {
      return .longLexeme
    }
    // Shift buffer contents, discarding everything up to the current lexeme.
    self.yyinput.replaceSubrange(..<used, with: self.yyinput[shift..<self.yylimit])
    self.yylimit  -= shift
    self.yycursor -= shift
    self.yymarker &-= shift  // May underflow if marker is unused
    self.token = 0
    // Fill free space at the end of buffer with new data from file.
    do {
      if let data = try self.file.read(upToCount: free) {
        self.yyinput.replaceSubrange(self.yylimit..<(self.yylimit + data.count), with: data)
        self.yylimit += data.count
      }
    } catch {
      fatalError("cannot read from file: \(error.localizedDescription)")
    }
    self.yyinput[self.yylimit] = 0  // append sentinel
    self.eof = self.yylimit < Self.bufferSize
    return .ok
  }
  enum FillStatus {
    case ok, eof, longLexeme
  }
}
let fileName = "input"
let content = "'qu\0tes' 'are' 'fine: \\'' "
// Prepare input file: a few times the size of the buffer,
// containing strings with zeroes and escaped quotes.
guard FileManager.default.createFile(
    atPath: fileName,
    contents: Data(String(repeating: content, count: Input.bufferSize).utf8)
) else {
  fatalError("failed to write file \"\(fileName)\"")
}
// Number of quoted strings written to file
let count = 3 * Input.bufferSize
// Initialize lexer state
guard let file = FileHandle(forReadingAtPath: fileName) else {
  throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadNoSuchFile.rawValue)
}
var `in` = Input(file: file)
// Run the lexer
assert(`in`.lex() == count)
// Cleanup: remove input file
try file.close()
try FileManager.default.removeItem(atPath: fileName)

// re2swift $INPUT -o $OUTPUT
func parseUInt32(_ yyinput: UnsafePointer<UInt8>) -> UInt32? {
  var yycursor = 0, yymarker = 0
  /*!re2c
    re2c:yyfill:enable = 0;
    "0b" / [01]        { return parseBin() }
    "0"                { return parseOct() }
    "" / [1-9]         { return parseDec() }
    "0x" / [0-9a-fA-F] { return parseHex() }
    *                  { return nil }
  */
  func add(_ accum: inout UInt64, _ charOrigin: UnicodeScalar, _ base: UInt64, _ offset: UInt64 = 0) {
    let digit = yyinput[yycursor - 1] - UInt8(ascii: charOrigin)
    accum = min(accum * base + UInt64(digit) + offset, UInt64(UInt32.max) + 1)
  }
  func parseBin() -> UInt32? {
    var accum: UInt64 = 0
    parse: while true {
      /*!re2c
        [01] { add(&accum, "0", 2); continue parse }
        *    { return UInt32(exactly: accum) }
      */
    }
  }
  func parseOct() -> UInt32? {
    var accum: UInt64 = 0
    parse: while true {
      /*!re2c
        [0-7] { add(&accum, "0", 8); continue parse }
        *     { return UInt32(exactly: accum) }
      */
    }
  }
  func parseDec() -> UInt32? {
    var accum: UInt64 = 0
    parse: while true {
      /*!re2c
        [0-9] { add(&accum, "0", 10); continue parse }
        *     { return UInt32(exactly: accum) }
      */
    }
  }
  func parseHex() -> UInt32? {
    var accum: UInt64 = 0
    parse: while true {
      /*!re2c
        [0-9] { add(&accum, "0", 16);     continue parse }
        [a-f] { add(&accum, "a", 16, 10); continue parse }
        [A-F] { add(&accum, "A", 16, 10); continue parse }
        *     { return UInt32(exactly: accum) }
      */
    }
  }
}
assert(parseUInt32("") == nil)
assert(parseUInt32("1234567890") == 1234567890)
assert(parseUInt32("0b1101") == 13)
assert(parseUInt32("0x7Fe") == 2046)
assert(parseUInt32("0644") == 420)
assert(parseUInt32("9999999999") == nil)

// re2swift $INPUT -o $OUTPUT -c
/*!conditions:re2c*/
func parseUInt32(_ yyinput: UnsafePointer<UInt8>) -> UInt32? {
  var yycursor = 0, yymarker = 0, yycond = yycinit
  var accum: UInt64 = 0
  loop: while true {
    /*!re2c
      re2c:yyfill:enable = 0;
      <init> '0b' / [01]        :=> bin
      <init> "0"                :=> oct
      <init> "" / [1-9]         :=> dec
      <init> '0x' / [0-9a-fA-F] :=> hex
      <bin> [01]  { add("0", 2);      continue loop }
      <oct> [0-7] { add("0", 8);      continue loop }
      <dec> [0-9] { add("0", 10);     continue loop }
      <hex> [0-9] { add("0", 16);     continue loop }
      <hex> [a-f] { add("a", 16, 10); continue loop }
      <hex> [A-F] { add("A", 16, 10); continue loop }
      <bin, oct, dec, hex> "\x00" { return UInt32(exactly: accum) }
      <*> * { return nil }
    */
  }
  func add(_ charOrigin: UnicodeScalar, _ base: UInt64, _ offset: UInt64 = 0) {
    let digit = yyinput[yycursor - 1] - UInt8(ascii: charOrigin)
    accum = min(accum * base + UInt64(digit) + offset, UInt64(UInt32.max) + 1)
  }
}
assert(parseUInt32("") == nil)
assert(parseUInt32("1234567890") == 1234567890)
assert(parseUInt32("0b1101") == 13)
assert(parseUInt32("0x7Fe") == 2046)
assert(parseUInt32("0644") == 420)
assert(parseUInt32("9999999999") == nil)

• تعریف دستورهای اولیهٔ YYSETSTATE() و YYGETSTATE(state).
• تعریف متغیرهای yych، yyaccept (در صورت استفاده) و state به عنوان بخشی از وضعیت پایدار (persistent) تحلیل‌گر لغوی. متغیر state باید با -1 مقداردهی اولیه شود.
• دستور YYFILL باید به جای تلاش برای تأمین ورودی بیشتر، به برنامهٔ بیرونی بازگردد. کد بازگشتی باید نشان دهد که تحلیل‌گر لغوی به ورودی بیشتری نیاز دارد.
• برنامهٔ بیرونی باید موقعیت‌هایی را که تحلیل‌گر لغوی به ورودی بیشتری نیاز دارد تشخیص داده و واکنش مناسب نشان دهد.
• استفادهٔ اختیاری از بلوک getstate برای تولید سوییچِ YYGETSTATE جدا از تحلیل‌گر لغوی اصلی. این مورد فقط برای زبان‌هایی کار می‌کند که دارای goto هستند (نه در حالت --loop-switch).
• استفاده از re2c:eof و روش sentinel with bounds checks برای مدیریت پایان ورودی. روش مبتنی بر لایه‌گذاری (padding) ممکن است کار نکند زیرا مشخص نیست چه زمانی باید لایه‌گذاری اضافه شود: پایان فعلی ورودی ممکن است پایان نهایی ورودی نباشد، و اضافه کردن زودهنگام لایه‌گذاری ممکن است نشانهٔ لغویِ حریصانه‌ای (greedy lexeme) را که تا حدی خوانده شده قطع کند. علاوه بر این، به دلیل منطق سطح‌بالای برنامه، دریافت ورودی بیشتر ممکن است به پردازش نشانهٔ لغوی در انتهای بافر بستگی داشته باشد (که از قبل به دلیل شرایط پایان ورودی مسدود شده است).

// re2swift $INPUT -o $OUTPUT -f
import Foundation
func log(_ items: Any..., separator: String = " ", terminator: String = "\n") {
#if DEBUG
  var stderr = FileHandle.standardError
  print(items, separator: separator, terminator: terminator, to: &stderr)
#endif
}
extension FileHandle: TextOutputStream {
  public func write(_ string: String) {
    self.write(Data(string.utf8))
  }
}
struct State {
  // Use a small buffer to cover the case when a lexeme doesn't fit,
  // in a real world use case use a larger buffer.
  static let bufferSize = 10
  let file: FileHandle
  // Extra '\0' byte on buffer acts as terminator.
  var yyinput  = ContiguousArray<UInt8>(repeating: 0, count: Self.bufferSize + 1)
  var yylimit  = Self.bufferSize
  var yycursor = Self.bufferSize
  var yymarker = Self.bufferSize
  var token    = Self.bufferSize
  var yystate  = -1
}
extension State {
  mutating func lex(recv: inout Int) -> Status {
    var yych: UInt8 = 0
    lex: while true {
      self.token = self.yycursor
      /*!re2c
        re2c:api = record;
        re2c:eof = 0;
        re2c:variable:yyrecord = "self";
        re2c:YYFILL = "return .waiting";
        packet = [a-z]+[;];
        *      { return .badPacket }
        $      { return .end }
        packet {
          recv += 1
          continue lex
        }
      */
    }
  }
  mutating func fill() -> Status {
    let used = self.yylimit - self.token
    let free = Self.bufferSize - used
    // Error: No space. In the real world we can reallocate a larger buffer.
    if free < 1 {
      return .bigPacket
    }
    // Shift buffer contents, discarding everything up to the current lexeme.
    let shift = self.token
    self.yyinput.replaceSubrange(..<used, with: self.yyinput[shift..<self.yylimit])
    self.yylimit  -= shift
    self.yycursor -= shift
    self.yymarker -= shift
    self.token = 0
    // Fill free space at the end of buffer with new data.
    do {
      if let data = try self.file.read(upToCount: free) {
        self.yyinput.replaceSubrange(self.yylimit..<(self.yylimit + data.count), with: data)
        self.yylimit += data.count
      }
    } catch {
      fatalError("cannot read from file: \(error.localizedDescription)")
    }
    self.yyinput[self.yylimit] = 0  // append sentinel
    return .ready
  }
  enum Status {
    case end, ready, waiting, badPacket, bigPacket
  }
}
func test(_ packets: [StaticString]) -> State.Status {
  // Create a "socket" (open the same file for reading and writing).
  let fname: String = "pipe"
  guard FileManager.default.createFile(atPath: fname, contents: nil),
      let fw = FileHandle(forWritingAtPath: fname) else {
    fatalError("cannot open '\(fname)'")
  }
  guard let fr = FileHandle(forReadingAtPath: fname) else {
    fatalError("cannot read file '\(fname)'")
  }
  defer {
    // Cleanup: remove input file.
    do {
      try fw.close()
      try fr.close()
      try FileManager.default.removeItem(atPath: fname)
    } catch {
      fatalError("error on file cleanup: \(error.localizedDescription)")
    }
  }
  var state = State(file: fr)
  // Main loop. The buffer contains incomplete data which appears packet by
  // packet. When the lexer needs more input it saves its internal state and
  // returns to the caller which should provide more input and resume lexing.
  var send = 0, recv = 0
  while true {
    switch state.lex(recv: &recv) {
      case .end:
        log("done: got \(recv)")
        assert(recv == send)
        return .end
      case .waiting:
        log("waiting...")
        if send < packets.count {
          log("sent packet \(send)")
          packets[send].withUTF8Buffer {
            do {
              try fw.write(contentsOf: $0)
            } catch {
              fatalError("cannot write to \(fname): \(error.localizedDescription)")
            }
          }
          send += 1
        }
        let status = state.fill()
        state.yyinput.withUnsafeBytes {
          let buf = $0.bindMemory(to: CChar.self)
          log("queue: '\(String(utf8String: buf.baseAddress!) ?? "")'")
        }
        if status == .bigPacket {
          log("error: packet too big")
          return .bigPacket
        }
        assert(status == .ready)
      case .badPacket:
        log("error: ill-formed packet")
        return .badPacket
      default:
        fatalError("unreachable")
    }
  }
}
assert(test([]) == .end)
assert(test([ "zero;", "one;", "two;", "three;", "four;" ]) == .end)
assert(test([ "zer0;" ]) == .badPacket)
assert(test([ "looooooooooong;" ]) == .bigPacket)
log("all tests completed successfully")

بلوک‌های چندبار مصرف به شکل /*!rules:re2c[:<name>] ... */ یا %{rules[:<name>] ... %} را می‌توان به هر تعداد دفعات دوباره استفاده کرد و با سایر بلوک‌های re2swift ترکیب نمود. مقدار <name> اختیاری است. یک بلوک قواعد را می‌توان در یک بلوک یا دستورالعمل use به کار برد. کد یک بلوک قواعد در هر نقطه از استفاده تولید می‌شود.

بلوک‌های use با /*!use:re2c[:<name>] ... */ یا %{use[:<name>] ... %} تعریف می‌شوند. مقدار <name> اختیاری است: اگر مشخص نشده باشد، بلوک قواعد مرتبط، جدیدترین بلوک موجود خواهد بود (چه نام‌گذاری شده و چه بدون نام). یک بلوک use می‌تواند تعاریف نام‌گذاری‌شده، پیکربندی‌ها و قواعد خاص خودش را بیفزاید. یک مورد کاربرد مهم برای بلوک‌های use، تحلیل‌گر لغوی (lexer) است که از چندین کدگذاری ورودی مختلف پشتیبانی می‌کند: یک بلوک قواعد یکسان، چندین بار همراه با پیکربندی‌های مختص هر کدگذاری استفاده می‌شود (مثال زیر را ببینید).

دستورالعمل استفاده درون‌بلوکی !use:<name>; می‌تواند از داخل یک بلوک re2swift به کار رود. این دستورالعمل، بلوک ارجاع‌شده <name> را با بلوک فعلی ادغام می‌کند. اگر برخی از قواعد و پیکربندی‌های ادغام‌شده با موارد تعریف‌شده قبلی هم‌پوشانی داشته باشند، تداخل‌ها به شیوه معمول حل می‌شوند: نخستین قاعده تقدم دارد، و جدیدترین پیکربندی جایگزین موارد پیشین می‌شود. یک استثنا، قواعد ویژه *، $ و (در حالت شرط) <!> هستند که برای آن‌ها تعریف محلی بلوک، هرگونه تعریف به ارث‌رسیده را لغو می‌کند. دستورالعمل use امکان ترکیب بلوک‌های مختلف re2swift را با یکدیگر در یک بلوک فراهم می‌سازد (مثال زیر را ببینید).

بلوک‌های نام‌گذاری‌شده و دستورالعمل استفاده درون‌بلوکی در نسخه 2.2 برنامه re2swift اضافه شدند. از آن نسخه به بعد، بلوک‌های چندبار مصرف به‌طور پیش‌فرض مجاز هستند (نیازی به گزینه خاصی نیست). پیش از نسخه 2.2، حالت استفاده مجدد با گزینه -r --reusable فعال می‌شد. پیش از نسخه 1.2 بلوک‌های چندبار مصرف نمی‌توانستند با بلوک‌های عادی ترکیب شوند.

// re2swift $INPUT -o $OUTPUT
// This example shows how to combine reusable re2c blocks: two blocks
// ('colors' and 'fish') are merged into one. The 'salmon' rule occurs
// in both blocks; the 'fish' block takes priority because it is used
// earlier. Default rule * occurs in all three blocks; the local (not
// inherited) definition takes priority.
/*!rules:re2c:colors
  *                            { fatalError("unreachable") }
  "red" | "salmon" | "magenta" { return .color }
*/
/*!rules:re2c:fish
  *                            { fatalError("unreachable") }
  "haddock" | "salmon" | "eel" { return .fish }
*/
func lex(_ yyinput: UnsafePointer<UInt8>) -> What {
  var yycursor = 0, yymarker = 0
  /*!re2c
    re2c:yyfill:enable = 0;
    !use:fish;
    !use:colors;
    * { return .dunno }  // Overrides inherited '*' rules
  */
}
enum What { case color, fish, dunno }
assert(lex("salmon") == .fish)
assert(lex("what?") == .dunno)

// re2swift $INPUT -o $OUTPUT --input-encoding utf8
// This example supports multiple input encodings: UTF-8 and UTF-32.
// Both lexers are generated from the same rules block, and the use
// blocks add only encoding-specific configurations.
/*!rules:re2c
  re2c:yyfill:enable = 0;
  "∀x ∃y" { return true }
  *       { return false }
*/
func lexUTF8(_ yyinput: [UInt8]) -> Bool {
  var yycursor = 0, yymarker = 0
  /*!use:re2c
    re2c:YYCTYPE = UInt8;
    re2c:encoding:utf8 = 1;
  */
}
func lexUTF32(_ yyinput: [UInt32]) -> Bool {
  var yycursor = 0, yymarker = 0
  /*!use:re2c
    re2c:YYCTYPE = UInt32;
    re2c:encoding:utf32 = 1;
  */
}
assert(lexUTF8([ 0xe2, 0x88, 0x80, 0x78, 0x20, 0xe2, 0x88, 0x83, 0x79 ]))  // UTF-8
assert(lexUTF32([ 0x00002200, 0x00000078, 0x00000020, 0x00002203, 0x00000079 ]))  // UTF-32

// re2swift $INPUT -o $OUTPUT
struct SemVer: Equatable { var major: Int, minor: Int, patch: Int }
func lex(_ yyinput: UnsafePointer<UInt8>) -> SemVer? {
  let tagNone = -1
  var yycursor = 0, yymarker = 0
  // Final tag variables available in semantic action.
  /*!svars:re2c format = "var @@ = tagNone\n"; */
  // Intermediate tag variables used by the lexer (must be autogenerated).
  /*!stags:re2c format = 'var @@ = tagNone\n'; */
  /*!re2c
    re2c:yyfill:enable = 0;
    re2c:tags = 1;
    num = [0-9]+;
    @t1 num @t2 "." @t3 num @t4 ("." @t5 num)? [\x00] {
      let s2n = { (range: Range<Int>) in
        range.reduce(0) { accum, idx in
          accum * 10 + Int(yyinput[idx] - UInt8(ascii: "0"))
        }
      }
      return SemVer(
        major: s2n(t1..<t2),
        minor: s2n(t3..<t4),
        patch: t5 != tagNone ? s2n(t5..<(yycursor - 1)) : 0)
    }
    * { return nil }
  */
}
assert(lex("23.34") == SemVer(major: 23, minor: 34, patch: 0))
assert(lex("1.2.999") == SemVer(major: 1, minor: 2, patch: 999))
assert(lex("1.a") == nil)

// re2swift $INPUT -o $OUTPUT --api generic --tags
import Foundation
struct SemVer: Equatable { var major: Int, minor: Int, patch: Int }
struct Input {
  static let bufferSize = 4095
  static let tagNone = -1
  var yyinput  = ContiguousArray<UInt8>(repeating: 0, count: Self.bufferSize + 1)
  var yylimit  = Self.bufferSize
  var yycursor = Self.bufferSize
  var yymarker = Self.bufferSize
  var token    = Self.bufferSize
  // Intermediate tag variables must be part of the lexer state passed to YYFILL.
  // They don't correspond to tags and should be autogenerated by re2c.
  /*!stags:re2c format = "  var @@ = Self.tagNone\n"; */
  var eof = false
  let file: FileHandle
}
extension Input {
  mutating func lex() -> [SemVer]? {
    var semVers = [SemVer]()
    semVers.reserveCapacity(Self.bufferSize)
    // Final tag variables available in semantic action.
    /*!svars:re2c format = "    var @@: Int\n"; */
    parse: while true {
      self.token = self.yycursor
      /*!re2c
        re2c:api  = record;
        re2c:eof  = 0;
        re2c:tags = 1;
        re2c:yyrecord = "self";
        re2c:YYFILL   = "self.fill() == .ok";
        num = [0-9]+;
        num @t1 "." @t2 num @t3 ("." @t4 num)? [\n] {
          semVers.append(SemVer(
            major: self.s2n(self.token..<t1),
            minor: self.s2n(t2..<t3),
            patch: t4 != Self.tagNone ? self.s2n(t4..<(self.yycursor - 1)) : 0
          ))
          continue parse
        }
        $ { return semVers }
        * { return nil }
      */
    }
  }
  func s2n(_ range: Range<Int>) -> Int {
    self.yyinput[range].reduce(0) { accum, digit in
      accum * 10 + Int(digit - UInt8(ascii: "0"))
    }
  }
  mutating func fill() -> FillStatus {
    guard !self.eof else {
      return .eof
    }
    let shift = self.token
    let used = self.yylimit - self.token
    let free = Self.bufferSize - used
    // Error: Lexeme too long. In the real world we could reallocate a larger buffer.
    guard self.token >= 1 else {
      return .longLexeme
    }
    // Shift buffer contents, discarding everything up to the current token.
    self.yyinput.replaceSubrange(..<used, with: self.yyinput[shift..<self.yylimit])
    self.yylimit   -= shift
    self.yycursor  -= shift
    self.yymarker &-= shift  // May underflow is marker is unused
    self.token = 0
    // Tag variables need to be shifted like other input positions. The check
    // for `tagNone` is only needed if some tags are nested inside of alternative
    // or repetition, so that they can have `tagNone` value.
    /*!stags:re2c format = "    if self.@@ != Self.tagNone { self.@@ -= shift }\n"; */
    // Fill free space at the end of the buffer with new data from file.
    do {
      if let data = try self.file.read(upToCount: free) {
        self.yyinput.replaceSubrange(self.yylimit..<(self.yylimit + data.count), with: data)
        self.yylimit += data.count
      }
    } catch {
      fatalError("cannot read from file: \(error.localizedDescription)")
    }
    self.yyinput[self.yylimit] = 0  // append sentinel
    self.eof = self.yylimit < Self.bufferSize
    return .ok
  }
  enum FillStatus {
    case ok, eof, longLexeme
  }
}
extension SemVer: CustomStringConvertible {
  var description: String { "\(self.major).\(self.minor).\(self.patch)" }
}
let fileName = "input"
let semVer = SemVer(major: 1, minor: 22, patch: 333)
let expect = [SemVer](repeating: semVer, count: Input.bufferSize)
// Prepare input file (make sure it exceeds buffer size).
guard FileManager.default.createFile(
    atPath: fileName,
    contents: Data(String(repeating: "\(semVer)\n", count: Input.bufferSize).utf8)
) else {
  fatalError("failed to write file \"\(fileName)\"")
}
// Reopen input file for reading.
guard let file = FileHandle(forReadingAtPath: fileName) else {
  throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadNoSuchFile.rawValue)
}
// Initialize lexer state. Buffer is set to zero, triggering YYFILL.
var `in` = Input(file: file)
// Run the lexer and check the results.
guard let actual = `in`.lex() else {
  fatalError("parser error")
}
assert(actual == expect)
// Cleanup: remove input file.
try file.close()
try FileManager.default.removeItem(atPath: fileName)

// re2swift $INPUT -o $OUTPUT
struct SemVer: Equatable { var major: Int, minor: Int, patch: Int }
func lex(_ yyinput: UnsafePointer<UInt8>) -> SemVer? {
  let tagNone = -1
  var yycursor = 0, yymarker = 0
  // Final tag variables available in semantic action.
  /*!svars:re2c format = "  var @@: Int\n"; */
  // Intermediate tag variables used by the lexer (must be autogenerated).
  /*!stags:re2c format = "  var @@ = tagNone\n"; */
  /*!re2c
    re2c:yyfill:enable = 0;
    re2c:captvars = 1;
    num = [0-9]+;
    (num) "." (num) ("." num)? [\x00] {
      let _ = yytl0; _ = yytr0  // Some variables are unused.
      return SemVer(
        major: s2n(yytl1..<yytr1),
        minor: s2n(yytl2..<yytr2),
        patch: yytl3 != tagNone ? s2n((yytl3 + 1)..<yytr3) : 0)
    }
    * { return nil }
  */
  func s2n(_ range: Range<Int>) -> Int {
    range.reduce(0) { accum, idx in
      accum * 10 + Int(yyinput[idx] - UInt8(ascii: "0"))
    }
  }
}
assert(lex("23.34") == SemVer(major: 23, minor: 34, patch: 0))
assert(lex("1.2.999") == SemVer(major: 1, minor: 2, patch: 999))
assert(lex("1.a") == nil)

// re2swift $INPUT -o $OUTPUT
import Foundation
// Unbounded number of version components.
struct Ver: Equatable { let components: [Int] }
func parse(_ yyinput: UnsafePointer<UInt8>) -> Ver? {
  let tagNone = -1
  var yycursor = 0, yymarker = 0
  var mTagPool = [MTag]()
  // Final tag variables available in semantic action.
  /*!svars:re2c format = "  let @@: Int\n"; */
  /*!mvars:re2c format = "  let @@: MTag?\n"; */
  // Intermediate tag variables used by the lexer (must be autogenerated).
  /*!stags:re2c format = "  var @@ = tagNone\n"; */
  /*!mtags:re2c format = "  var @@: MTag? = nil\n"; */
  /*!re2c
    re2c:tags = 1;
    re2c:yyfill:enable = 0;
    re2c:YYSTAGP = "@@ = yycursor";
    re2c:YYSTAGN = "@@ = tagNone";
    re2c:YYMTAGP = "@@ = add(tag: @@, value: yycursor)";
    re2c:YYMTAGN = "@@ = add(tag: @@, value: tagNone)";
    num = [0-9]+;
    @t1 num @t2 ("." #t3 num #t4)* [\x00] {
      var components = [s2n(t1..<t2)]
      unfold(&components, t3, t4)
      return Ver(components: components)
    }
    * { return nil }
  */
  // Recursively unwind tag histories and collect version components.
  func unfold(_ ver: inout [Int], _ x: MTag?, _ y: MTag?) {
    if x == nil && y == nil {
      // Reached the root of the m-tag tree, stop recursion.
      return
    }
    // Unwind history further.
    unfold(&ver, x?.prev, y?.prev)
    // Get tag values, tag histories must have equal length.
    guard let ex = x?.elem, let ey = y?.elem else {
      fatalError("mismatched history length")
    }
    guard ex != tagNone && ey != tagNone else {
      // Both tags are empty, this corresponds to zero repetitions.
      assert(ex == ey)
      return
    }
    // Both tags are valid indices, extract component.
    ver.append(s2n(ex..<ey))
  }
  // Pre-parsed string to number.
  func s2n(_ range: Range<Int>) -> Int {
    range.reduce(0) { accum, idx in
      accum * 10 + Int(yyinput[idx] - UInt8(ascii: "0"))
    }
  }
  // Append a single value to an m-tag history.
  func add(tag prevTag: MTag?, value: Int) -> MTag {
    let tag = MTag(prev: prevTag, element: value)
    mTagPool.append(tag)
    return tag
  }
}
// An m-tag tree is a way to store histories with an O(1) copy operation.
// Histories naturally form a tree, as they have common start and fork at some
// point. The tree is stored as an array of pairs (tag value, link to parent).
// An m-tag is represented with a single link in the tree (array index).
class MTag {
  weak var prev: MTag?  // Link of predecessor node or root (nil)
  var elem: Int  // Tag value
  init(prev: MTag?, element: Int) {
    self.prev = prev
    self.elem = element
  }
}
assert(parse("1") == Ver(components: [1]))
assert(parse("1.2.3.4.5.6.7") == Ver(components: [1, 2, 3, 4, 5, 6, 7]))
assert(parse("1.2.") == nil)

• ASCII (به‌طور پیش‌فرض فعال است). یک کدگذاری با طول ثابت با فضای کد [0-255] و نقطه‌کدها و واحدهای کد ۱ بایتی است.
• EBCDIC (با --ebcdic یا re2c:encoding:ebcdic فعال می‌شود). یک کدگذاری با طول ثابت با فضای کد [0-255] و نقطه‌کدها و واحدهای کد ۱ بایتی است.
• UCS2 (با --ucs2 یا re2c:encoding:ucs2 فعال می‌شود). یک کدگذاری با طول ثابت با فضای کد [0-0xFFFF] و نقطه‌کدها و واحدهای کد ۲ بایتی است.
• UTF8 (با --utf8 یا re2c:encoding:utf8 فعال می‌شود). یک کدگذاری یونی‌کد با طول متغیر است. اندازه هر واحد کد ۱ بایت است. نقطه‌کدها با ۱ تا ۴ واحد کد نمایش داده می‌شوند.
• UTF16 (با --utf16 یا re2c:encoding:utf16 فعال می‌شود). یک کدگذاری یونی‌کد با طول متغیر است. اندازه هر واحد کد ۲ بایت است. نقطه‌کدها با ۱ تا ۲ واحد کد نمایش داده می‌شوند.
• UTF32 (با --utf32 یا re2c:encoding:utf32 فعال می‌شود). یک کدگذاری یونی‌کد با طول ثابت با فضای کد [0-0x10FFFF] و نقطه‌کدها و واحدهای کد ۴ بایتی است.

enum Result { case ok, fail }
/*!re2c
  number = [1-9][0-9]*;
*/

// re2swift $INPUT -o $OUTPUT -i
/*!include:re2c "definitions.swift" */
func lex(_ yyinput: UnsafePointer<UInt8>) -> Result {
  var yycursor = 0, yymarker = 0
  /*!re2c
    re2c:yyfill:enable = 0;
    *      { return .fail }
    number { return .ok }
    !include "extra_rules.re.inc";
  */
}
assert(lex("123") == .ok)
assert(lex("123.4567") == .ok)

// re2swift $INPUT -o $OUTPUT -i --header lexer/state.swift
/*!header:re2c:on*/
struct LexerState {
  var yyinput: UnsafePointer<UInt8>
  var yycursor: Int
  /*!stags:re2c format = "var @@ = -1"; */
  init(str: UnsafePointer<UInt8>, cur: Int = 0) {
    self.yyinput = str
    self.yycursor = cur
  }
}
/*!header:re2c:off*/
extension LexerState {
  mutating func lex() -> Int {
  let t: Int
  /*!re2c
    re2c:header        = "lexer/state.swift";
    re2c:api           = record;
    re2c:tags          = 1;
    re2c:yyfill:enable = 0;
    re2c:yyrecord      = "self";
    [a]* @t [b]* { return t }
  */
  }
}
@main struct Program {
  static func main() {
    let str: StaticString = "ab"
    var state = LexerState(str: str.utf8Start)
    assert(state.lex() == 1)
  }
}

/* Generated by re2swift */
struct LexerState {
  var yyinput: UnsafePointer<UInt8>
  var yycursor: Int
  var yyt1 = -1
  init(str: UnsafePointer<UInt8>, cur: Int = 0) {
    self.yyinput = str
    self.yycursor = cur
  }
}

• آن‌ها می‌توانند درستی بهینه‌سازی‌های گوناگون re2swift را بررسی کنند (داده‌ها در مراحل اولیهٔ فرایند، پیش از اعمال هرگونه تبدیل روی DFA تولید می‌شوند).
• تولید مجموعه‌ای از داده‌های ورودی با پوشش مناسب می‌تواند هم برای آزمایش و هم برای ارزیابی کارایی (benchmarking) مفید باشد.
• تولید برنامه‌های اجرایی خودکفا به شخص اجازه می‌دهد موارد آزمون کمینه‌شده (minimized test cases) به دست آورد (کد اصلی ممکن است بزرگ باشد یا وابستگی‌های زیادی داشته باشد).