/*!re2c[:<name>] ... */ یا %{[:<name>] ... %}

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

/*!local:re2c[:<name>] ... */ یا %{local[:<name>] ... %}

یک بلوک محلی مانند یک بلوک سراسری است، اما نام‌ها و پیکربندی‌های موجود در آن دارای دامنه محلی هستند (بر سایر بلوک‌ها تأثیری نمی‌گذارند).

/*!rules:re2c[:<name>] ... */ یا %{rules[:<name>] ... %}

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

/*!use:re2c[:<name>] ... */ یا %{use[:<name>] ... %}

یک بلوک استفاده که به یک بلوک قواعد از پیش تعریف‌شده ارجاع می‌دهد. اگر نام مشخص شده باشد، re2c به دنبال بلوک قواعدی با این نام می‌گردد. در غیر این صورت، جدیدترین بلوک قواعد استفاده می‌شود (خواه نام‌گذاری‌شده باشد یا بدون نام). یک بلوک استفاده می‌تواند تعاریف، پیکربندی‌ها و قواعد خاص خود را اضافه کند، که به موارد موجود در بلوک قواعد مرجع افزوده می‌شوند. پیش از نسخه 2.2 re2c، بلوک‌های استفاده به گزینه -r --reusable نیاز داشتند.

/*!max:re2c[:<name1>[:<name2>...]] ... */ یا %{max[:<name1>[:<name2>...]] ... %}

بلوکی که تعریف YYMAXFILL را تولید می‌کند. یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند هنگام محاسبه مقدار YYMAXFILL کدام بلوک‌ها باید لحاظ شوند (اگر فهرست خالی باشد، همه بلوک‌ها لحاظ می‌شوند). به طور پیش‌فرض، کد تولیدشده یک تعریف ماکرو برای C (#define YYMAXFILL <n>) یا یک متغیر سراسری برای Go (var YYMAXFILL int = <n>) است. این مقدار را می‌توان با پیکربندی اختیاری format سفارشی کرد که یک رشته الگو را مشخص می‌کند که در آن @@{max} (یا به اختصار @@) با مقدار عددی YYMAXFILL جایگزین می‌شود.

/*!maxnmatch:re2c[:<name1>[:<name2>...]] ... */ یا %{maxnmatch[:<name1>[:<name2>...]] ... %}

بلوکی که تعریف YYMAXNMATCH را تولید می‌کند (به گزینه -P --posix-captures نیاز دارد). یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند هنگام محاسبه مقدار YYMAXNMATCH کدام بلوک‌ها باید لحاظ شوند (اگر فهرست خالی باشد، همه بلوک‌ها لحاظ می‌شوند). به طور پیش‌فرض، کد تولیدشده یک تعریف ماکرو برای C (#define YYMAXNMATCH <n>) یا یک متغیر سراسری برای Go (var YYMAXNMATCH int = <n>) است. این مقدار را می‌توان با پیکربندی اختیاری format سفارشی کرد که یک رشته الگو را مشخص می‌کند که در آن @@{max} (یا به اختصار @@) با مقدار عددی YYMAXNMATCH جایگزین می‌شود.

/*!stags:re2c[:<name1>[:<name2>...]] ... */, /*!mtags:re2c[:<name1>[:<name2>...]] ... */ یا %{stags[:<name1>[:<name2>...]] ... %}, %{mtags[:<name1>[:<name2>...]] ... %{

بلوک‌هایی که قطعه‌کدی الگویی را مشخص می‌کنند که به ازای هر متغیر s-tag/m-tag تولیدشده توسط re2c بسط می‌یابد. یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند هنگام محاسبه مجموعه متغیرهای تگ کدام بلوک‌ها باید لحاظ شوند (اگر فهرست خالی باشد، همه بلوک‌ها لحاظ می‌شوند). دو پیکربندی اختیاری وجود دارد: format و separator. پیکربندی format یک رشته الگو را تعیین می‌کند که در آن @@{tag} (یا به اختصار @@) با نام هر متغیر تگ جایگزین می‌شود. پیکربندی separator قطعه‌کدی را مشخص می‌کند که برای پیوند دادن قطعات تولیدشده format برای متغیرهای مختلف تگ استفاده می‌شود.

/*!svars:re2c[:<name1>[:<name2>...]] ... */, /*!mvars:re2c[:<name1>[:<name2>...]] ... */ یا %{svars[:<name1>[:<name2>...]] ... %}, %{mvars[:<name1>[:<name2>...]] ... %{

بلوک‌هایی که قطعه‌کدی الگویی را مشخص می‌کنند که به ازای هر s-tag/m-tag که یا به صراحت در قواعد ذکر شده است (با گزینه --tags) یا به طور ضمنی توسط re2c تولید شده است (با گزینه‌های --captvars یا --posix-captvars) بسط می‌یابد. یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند هنگام محاسبه مجموعه تگ‌ها کدام بلوک‌ها باید لحاظ شوند (اگر فهرست خالی باشد، همه بلوک‌ها لحاظ می‌شوند). دو پیکربندی اختیاری وجود دارد: format و separator. پیکربندی format یک رشته الگو را تعیین می‌کند که در آن @@{tag} (یا به اختصار @@) با نام هر تگ جایگزین می‌شود. پیکربندی separator قطعه‌کدی را مشخص می‌کند که برای پیوند دادن قطعات تولیدشده format برای تگ‌های مختلف استفاده می‌شود.

/*!getstate:re2c[:<name1>[:<name2>...]] ... */ یا %{getstate[:<name1>[:<name2>...]] ... %}

بلوکی که هدایت شرطی بر اساس وضعیت تحلیل‌گر لغوی را تولید می‌کند (به گزینه --storable-state نیاز دارد). یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند کدام بلوک‌ها باید در هدایت وضعیت گنجانده شوند. گذار پیش‌فرض به برچسب شروع اولین بلوک در فهرست می‌رود. اگر فهرست خالی باشد، همه بلوک‌ها گنجانده می‌شوند، و گذار پیش‌فرض به اولین بلوکی در فایل که برچسب شروع دارد می‌رود. این نوع بلوک با گزینه --loop-switch ناسازگار است، زیرا به گذارهای بین‌بلوکی نیاز دارد که بدون goto یا فراخوانی‌های تابع پشتیبانی نمی‌شوند.

/*!conditions:re2c[:<name1>[:<name2>...]] ... */, /*!types:re2c... */ یا %{conditions[:<name1>[:<name2>...]] ... %}, %{types... %}

بلوکی که شمارش شرط‌ها را تولید می‌کند (به گزینه --conditions نیاز دارد). یک فهرست اختیاری از نام‌های بلوک مشخص می‌کند هنگام محاسبه مجموعه شرایط کدام بلوک‌ها باید لحاظ شوند (اگر فهرست خالی باشد، همه بلوک‌ها لحاظ می‌شوند). به طور پیش‌فرض کد تولیدشده یک شمارش YYCONDTYPE است. این کد را می‌توان با پیکربندی‌های اختیاری format و separator سفارشی کرد. پیکربندی format یک رشته الگو را مشخص می‌کند که در آن @@{cond} (یا به اختصار @@) با نام هر شرط، و @@{num} با اندیس عددی آن شرط جایگزین می‌شود. پیکربندی separator قطعه‌کدی را مشخص می‌کند که برای پیوند دادن قطعات تولیدشده format برای شرایط مختلف استفاده می‌شود.

/*!include:re2c <file> */ یا %{include <file> %}

این بلوک امکان گنجاندن <file> را فراهم می‌کند، که باید یک مسیر فایل درون گیومه دوتایی باشد. محتویات فایل به معنای واقعی کلمه در جای بلوک جایگزین می‌شود، دقیقاً به همان روشی که #include در C/C++ کار می‌کند. این بلوک می‌تواند همراه با گزینه --depfile برای تولید وابستگی‌های سیستم ساخت بر روی فایل‌های گنجانده‌شده استفاده شود.

/*!header:re2c:on*/ یا %{header:on %}

این بلوک آغاز فایل سرآیند را مشخص می‌کند. تمام موارد پس از آن و تا بلوک header:off بعدی توسط re2c پردازش شده و در فایل سرآیندی که با گزینه -t --type-header مشخص شده نوشته می‌شود.

/*!header:re2c:off*/ یا %{header:off %}

این بلوک پایان فایل سرآیندی را که با بلوک header:on*/ آغاز شده بود مشخص می‌کند.

/*!ignore:re2c ... */ یا %{ignore ... %}

بلوکی که محتویات آن نادیده گرفته شده و از فایل خروجی حذف می‌شود.

در اینجا فهرست کاملی از پیکربندی‌های پشتیبانی‌شده توسط re2c آورده شده است:

!entry code

کنش ورودی (Entry action) یک بلوک code تعریف‌شده توسط کاربر را به وضعیت آغازین ماشین حالت متناهی فعلی پیوند می‌دهد. اگر از start conditions (شرایط شروع) استفاده شود، کنش ورودی را می‌توان به طور جداگانه برای هر شرط تنظیم کرد. این کنش ممکن است برای انجام مقداردهی اولیه، مثلاً برای ذخیره موقعیت شروع یک نشانه (lexeme)، استفاده شود.

!pre_rule code

کنش پیش‌قاعده (Pre-rule action) یک بلوک code تعریف‌شده توسط کاربر را به ابتدای کنش‌های معنایی تمام قواعد در بلوک فعلی (یا شرط، در صورت استفاده از start conditions) اضافه می‌کند. این کنش می‌تواند برای فاکتور گرفتن بخش مشترک تمام کنش‌های معنایی (مانند ذخیره موقعیت پایانی یک نشانه) به کار رود.

!post_rule code

کنش پس‌قاعده (Post-rule action) یک بلوک code تعریف‌شده توسط کاربر را به انتهای کنش‌های معنایی تمام قواعد در بلوک فعلی (یا شرط، در صورت استفاده از start conditions) ضمیمه می‌کند. این کنش می‌تواند برای درج عبارت‌های تله (trap statements) جهت جلوگیری از جریان کنترل ناخواسته استفاده شود.

در اینجا فهرست کاملی از دستورالعمل‌های پشتیبانی‌شده توسط re2c آورده شده است:

Simple API

این شیوه، API پیش‌فرض برای بک‌اند C/C++ است. این رابط شامل بنیادینه‌های YYCURSOR، YYMARKER، YYCTXMARKER و YYLIMIT است که باید به عنوان اشاره‌گرهایی از نوع YYCTYPE* تعریف شوند.

Record API

(در نسخهٔ 4.0 اضافه شد) رابط Record API در مواردی مفید است که وضعیت تحلیل‌گر لغوی (lexer) باید در یک struct ذخیره شود. این رابط با گزینهٔ --api record یا پیکربندی re2c:api = record فعال می‌شود. این API شامل یک متغیر yyrecord است (این نام را می‌توان با re2c:yyrecord بازنویسی و جایگزین کرد) که باید به عنوان یک struct با فیلدهای yycursor، yymarker، yyctxmarker و yylimit تعریف شود (تنها فیلدهایی که توسط کد تولیدشده استفاده می‌شوند باید تعریف شوند، و نام آن‌ها نیز قابل پیکربندی است).

Generic API

(در نسخهٔ 0.14 اضافه شد) این شیوه منعطف‌ترین API است. این رابط با گزینهٔ --api generic یا پیکربندی re2c:api = generic فعال می‌شود. این API شامل بنیادینه‌هایی برای عملیات‌های عمومی است: YYPEEK، YYSKIP، YYBACKUP، YYBACKUPCTX، YYSTAGP، YYSTAGN، YYMTAGP، YYMTAGN، YYRESTORE، YYRESTORECTX، YYRESTORETAG، YYSHIFT، YYSHIFTSTAG، YYSHIFTMTAG، YYLESSTHAN. YYEND. رابط Generic API از دو سبک پشتیبانی می‌کند که قالبی را که در آن بنیادینه‌ها باید تعریف شوند مشخص می‌سازند:

/*!re2c
  re2c:YYPEEK       = "*cursor";
  re2c:YYSKIP       = "++cursor;";
  re2c:YYBACKUP     = "marker = cursor;";
  re2c:YYRESTORE    = "cursor = marker;";
  re2c:YYBACKUPCTX  = "ctxmarker = cursor;";
  re2c:YYRESTORECTX = "cursor = ctxmarker;";
  re2c:YYRESTORETAG = "cursor = ${tag};";
  re2c:YYLESSTHAN   = "limit - cursor < @@{len}";
  re2c:YYEND        = "limit == cursor";
  re2c:YYSTAGP      = "@@{tag} = cursor;";
  re2c:YYSTAGN      = "@@{tag} = NULL;";
  re2c:YYSHIFT      = "cursor += @@{shift};";
  re2c:YYSHIFTSTAG  = "@@{tag} += @@{shift};";
*/

#define  YYPEEK()                 *cursor
#define  YYSKIP()                 ++cursor
#define  YYBACKUP()               marker = cursor
#define  YYRESTORE()              cursor = marker
#define  YYBACKUPCTX()            ctxmarker = cursor
#define  YYRESTORECTX()           cursor = ctxmarker
#define  YYRESTORETAG(tag)        cursor = tag
#define  YYLESSTHAN(len)          limit - cursor < len
#define  YYEND()                  limit == cursor
#define  YYSTAGP(tag)             tag = cursor
#define  YYSTAGN(tag)             tag = NULL
#define  YYSHIFT(shift)           cursor += shift
#define  YYSHIFTSTAG(tag, shift)  tag += shift

YYCTYPE

نوع نویسه‌های ورودی (واحدهای کد). برای رمزگذاری‌های ASCII، EBCDIC و UTF-8 باید یک عدد صحیح بدون علامت ۱ بایتی باشد. برای UTF-16 یا UCS-2 باید یک عدد صحیح بدون علامت ۲ بایتی باشد. برای UTF-32 باید یک عدد صحیح بدون علامت ۴ بایتی باشد.

YYCURSOR

یک l-value که موقعیت فعلی ورودی را ذخیره می‌کند (یک اشاره‌گر یا یک آفست عدد صحیح در YYINPUT). در ابتدا YYCURSOR باید به نخستین نویسهٔ ورودی اشاره کند، و سپس توسط کد تولیدشده به جلو برده می‌شود. هنگامی که یک قاعده تطبیق می‌یابد، موقعیت YYCURSOR برابر با موقعیت پس از آخرین نویسهٔ تطبیق‌یافته است.

YYLIMIT

یک r-value که موقعیت انتهای ورودی را ذخیره می‌کند (یک اشاره‌گر یا یک آفست عدد صحیح در YYINPUT). در ابتدا YYLIMIT باید به موقعیتِ پس از آخرین نویسهٔ موجود در ورودی اشاره کند. این مقدار توسط کد تولیدشده تغییر نمی‌کند. تحلیل‌گر لغوی YYCURSOR را با YYLIMIT مقایسه می‌کند تا تشخیص دهد آیا نویسه‌های ورودیِ کافی باقی مانده است یا خیر..TP YYMARKER یک l-value که موقعیت آخرین قاعدهٔ تطبیق‌یافته را ذخیره می‌کند (یک اشاره‌گر یا یک آفست عدد صحیح در YYINPUT). برای بازیابی موقعیت YYCURSOR در صورتی که تطبیق طولانی‌تر ناموفق باشد و تحلیل‌گر لغوی نیاز به بازگشت به عقب (rollback) داشته باشد، استفاده می‌شود. مقداردهی اولیه لازم نیست.

YYCTXMARKER

یک l-value که موقعیت بافت پس‌رو (trailing context) را ذخیره می‌کند (یک اشاره‌گر یا یک آفست عدد صحیح در YYINPUT). هیچ مقداردهی اولیه‌ای لازم نیست. YYCTXMARKER تنها در صورتی نیاز است که عملگر پیش‌نگری / استفاده شده باشد.

YYFILL

یک پایهٔ عمومی API با یک متغیر len. YYFILL باید حداقل len نویسهٔ ورودی بیشتر فراهم کند یا با شکست مواجه شود. اگر re2c:eof استفاده شود، len همیشه 1 است و YYFILL باید همیشه به تابع فراخوان بازگردد؛ مقدار بازگشتی صفر نشان‌دهندهٔ موفقیت است. اگر re2c:eof استفاده نشود، مقدار بازگشتی YYFILL نادیده گرفته می‌شود و در صورت شکست نباید بازگردد. حداکثر مقدار len برابر YYMAXFILL است.

YYFN

یک پایه که پیش‌نمونهٔ تابع را در مدل کد --recursive-functions تعریف می‌کند. مقدار آن باید آرایه‌ای از یک یا چند رشته باشد، که در آن هر رشته شامل دو یا سه مؤلفه است که توسط رشتهٔ مشخص‌شده در پیکربندی re2c:fn:sep (معمولاً یک نقطه‌ویرگول) از هم جدا شده‌اند. اولین عنصر آرایه نام تابع و نوع بازگشتی را مشخص می‌کند (برای یک تابع void خالی است). عناصر بعدی آرگومان‌های تابع را تعریف می‌کنند: اول، عبارت برای آرگومان مورداستفاده در بدنهٔ تابع (معمولاً فقط یک نام)؛ دوم، نوع آرگومان؛ سوم، یک پارامتر رسمی اختیاری (پیش‌فرض آن مؤلفهٔ اول است - معمولاً هر دو آرگومان و پارامتر شناسهٔ یکسانی دارند).

YYINPUT

یک r-value که دنبالهٔ نویسه‌های ورودی فعلی (رشته، بافر، و غیره) را ذخیره می‌کند.

YYMAXFILL

یک ثابت عدد صحیح برابر با حداکثر مقدار آرگومانِ YYFILL. این مقدار می‌تواند با یک بلوک max تولید شود.

YYLESSTHAN

یک پایهٔ عمومی API با یک متغیر len. باید به عنوان یک r-value از نوع بولی تعریف شود که اگر و تنها اگر کمتر از len نویسهٔ ورودی باقی مانده باشد، برابر با true است.

YYEND

یک پایهٔ عمومی API بدون هیچ متغیری. باید به عنوان یک r-value از نوع بولی تعریف شود که اگر و تنها اگر به انتهای منطقی ورودی رسیده باشد (به استثنای هرگونه نماد فاصله‌گذاری یا نگهبان)، برابر با true است. YYEND برای پیاده‌سازی نماد $ در عبارات باقاعده استفاده می‌شود. این با YYLESSTHAN تفاوت دارد که برای اطمینان از اینکه تحلیل‌گر لغوی فراتر از انتهای بافر نخواند، به کار می‌رود.

YYPEEK

یک پایهٔ عمومی API بدون متغیر. باید به عنوان یک r-value از نوع YYCTYPE تعریف شود که برابر با نویسه در موقعیت ورودی فعلی است.

YYSKIP

یک پایهٔ عمومی API که باید موقعیت ورودی فعلی را به اندازهٔ یک واحد کد به جلو ببرد.

YYBACKUP

یک پایهٔ عمومی API که باید موقعیت ورودی فعلی را ذخیره کند (تا بعداً با YYRESTORE بازیابی شود).

YYRESTORE

یک پایهٔ عمومی API که باید موقعیت ورودی فعلی را به مقدار ذخیره‌شده توسط YYBACKUP بازیابی کند.

YYBACKUPCTX

یک پایهٔ عمومی API که باید موقعیت ورودی فعلی را به عنوان موقعیت بافت پس‌رو ذخیره کند (تا بعداً با YYRESTORECTX بازیابی شود).

YYRESTORECTX

یک پایهٔ عمومی API که باید موقعیت بافت پس‌رو ذخیره‌شده توسط YYBACKUPCTX را بازیابی کند.

YYRESTORETAG

یک پایهٔ عمومی API با یک متغیر tag که باید موقعیت بافت پس‌رو را به مقدار tag بازیابی کند.

YYSTAGP

یک پایهٔ عمومی API با یک متغیر tag، که در آن tag می‌تواند یک اشاره‌گر یا یک آفست در YYINPUT باشد (برای جزئیات به بخش استخراج تطبیق فرعی مراجعه کنید). YYSTAGP باید tag را روی موقعیت ورودی فعلی تنظیم کند.

YYSTAGN

یک پایهٔ عمومی API با یک متغیر tag، که در آن tag می‌تواند یک اشاره‌گر یا یک آفست در YYINPUT باشد (برای جزئیات به بخش استخراج تطبیق فرعی مراجعه کنید). YYSTAGN باید tag را روی مقداری تنظیم کند که نشان‌دهندهٔ موقعیت ورودیِ ناموجود است.

YYMTAGP

یک پایهٔ عمومی API با یک متغیر tag. YYMTAGP باید موقعیت فعلی را به تاریخچهٔ تطبیق فرعی tag اضافه کند (برای جزئیات به بخش استخراج تطبیق فرعی مراجعه کنید).

YYMTAGN

یک پایهٔ عمومی API با یک متغیر tag. YYMTAGN باید مقداری را که نشان‌دهندهٔ موقعیت ورودی ناموجود است به تاریخچهٔ تطبیق فرعی tag اضافه کند (برای جزئیات به بخش استخراج تطبیق فرعی مراجعه کنید).

YYSHIFT

یک پایهٔ عمومی API با یک متغیر shift که باید موقعیت ورودی فعلی را به اندازهٔ shift نویسه تغییر مکان دهد (مقدار جابه‌جایی ممکن است منفی باشد).

YYCOPYSTAG

یک پایهٔ عمومی API با دو متغیر lhs و rhs که باید متغیر سمت راستِ s-tag یعنی rhs را در متغیر سمت چپِ s-tag یعنی lhs کپی کند. برای بیشتر زبان‌ها این پایه دارای تعریفی پیش‌فرض است که lhs را به rhs تخصیص می‌دهد.

YYCOPYMTAG

یک پایهٔ عمومی API با دو متغیر lhs و rhs که باید متغیر سمت راستِ m-tag یعنی rhs را در متغیر سمت چپِ m-tag یعنی lhs کپی کند. برای بیشتر زبان‌ها این پایه دارای تعریفی پیش‌فرض است که lhs را به rhs تخصیص می‌دهد.

YYSHIFTSTAG

یک پایهٔ عمومی API با دو متغیر tag و shift که باید tag را به اندازهٔ shift واحد کد جابه‌جا کند (مقدار جابه‌جایی ممکن است منفی باشد).

YYSHIFTMTAG

یک پایهٔ عمومی API با دو متغیر tag و shift که باید آخرین مقدار در تاریخچهٔ tag را به اندازهٔ shift واحد کد جابه‌جا کند (مقدار جابه‌جایی ممکن است منفی باشد).

YYMAXNMATCH

یک ثابت عدد صحیح برابر با حداکثر تعداد گروه‌های تسخیرکنندهٔ POSIX در یک قاعده. این مقدار با یک بلوک maxnmatch تولید می‌شود.

YYCONDTYPE

نوع شمارش شرط. می‌تواند با بلوک conditions یا گزینهٔ --header تولید شود.

YYGETACCEPT

یک پایه با یک متغیر var که انتخاب‌کنندهٔ عددی قاعدهٔ پذیرفته‌شده را ذخیره می‌کند. برای بیشتر زبان‌ها این پایه دارای تعریفی پیش‌فرض است که از var می‌خواند.

YYSETACCEPT

یک پایه با دو متغیر: var (یک l-value که انتخاب‌کنندهٔ عددی قاعدهٔ پذیرفته‌شده را ذخیره می‌کند)، و val (مقدار انتخاب‌کننده). برای بیشتر زبان‌ها این پایه دارای تعریفی پیش‌فرض است که var را به val تخصیص می‌دهد.

YYGETCOND

یک r-value از نوع YYCONDTYPE که برابر با شناسهٔ شرط فعلی است.

YYSETCOND

یک پایه با یک متغیر cond که باید شناسهٔ شرط فعلی را به cond تنظیم کند.

YYGETSTATE

یک r-value از نوع عدد صحیح که برابر با وضعیت فعلی تحلیل‌گر لغوی است. باید با مقدار -1 مقداردهی اولیه شود.

YYSETSTATE

یک پایه با یک متغیر state که باید وضعیت فعلی تحلیل‌گر لغوی را روی state تنظیم کند.

YYDEBUG

این پایه فقط با گزینهٔ -d یا --debug-output تولید می‌شود. هدف آن افزودن گزارش‌گیری به کد تولیدشده است (تعریف معمول YYDEBUG یک دستور چاپ است). دستورات YYDEBUG در هر وضعیت تولید می‌شوند و دو متغیر دارند: state (یک نمایهٔ وضعیت DFA یا -1) و symbol (نماد ورودی فعلی).

yyaccept

یک l-value از نوع عدد صحیح بدون علامت که شمارهٔ آخرین قاعدهٔ تطبیق‌یافته را ذخیره می‌کند. تعریف کاربر فقط با گزینهٔ --storable-state ضروری است.

yybm

جدولی حاوی نقشه‌های بیتی فشرده‌شده برای حداکثر ۸ انتقال (مورداستفاده با گزینهٔ --bitmaps). جدول شامل ۲۵۶ عنصر است و توسط واحدهای کد ۱-بایتی نمایه‌گذاری می‌شود. هر عنصر ۸-بیتی مقادیر بولی را برای حداکثر ۸ انتقال با هم ترکیب می‌کند. بیت k-اُم از عنصر n-اُم درست است اگر و تنها اگر واحد کد n-اُم در محدودهٔ انتقال k-اُم باشد. ایدهٔ این نقشهٔ بیتی جایگزینی چندین شاخهٔ if یا موارد switch با یک بررسیِ تک‌بیت در جدول است..TP yych یک l-value از نوع YYCTYPE که نویسه ورودی فعلی را ذخیره می‌کند. تعریف آن توسط کاربر تنها با گزینه -f --storable-state ضروری است.

yyctable

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

yyfill

یک l-value که نتیجه فراخوانی YYFILL را ذخیره می‌کند (این ممکن است برای زبان‌های تابعی محض که در آن‌ها YYFILL یک تابع مونادیک با مقدار بازگشتی پیچیده است، ضروری باشد).

yynmatch

یک l-value از نوع عددی صحیح بدون علامت که تعداد گروه‌های گیرانداز POSIX را در قاعده منطبق‌شده ذخیره می‌کند. تنها با گزینه -P --posix-captures استفاده می‌شود.

yypmatch

آرایه‌ای از l-valueها که برای نگهداری مقادیر برچسب متناظر با پرانتزهای گیرانداز در قاعده منطبق‌شده استفاده می‌شوند. طول آرایه باید حداقل yynmatch * 2 باشد (معمولاً YYMAXNMATCH * 2 انتخاب خوبی است). تنها با گزینه -P --posix-captures استفاده می‌شود.

yystable

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

yystate

یک l-value که همراه با گزینه --loop-switch برای ذخیره وضعیت کنونی DFA استفاده می‌شود.

yytarget

جدول پرش شامل مقصدهای پرش (نشانی‌های برچسب) برای تمامی گذارها از یک وضعیت. این جدول برای هر وضعیت محلی است. تولید جدول‌های yytarget با گزینه --computed-gotos فعال می‌شود.

-? --help -h

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

--api <simple | record | generic>

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

--bit-vectors -b

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

--captures, --leftmost-captures

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

--captvars, --leftmost-captvars

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

--case-insensitive

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

--case-inverted

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

--case-ranges

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

--computed-gotos -g

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

--computed-gotos-relative

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

--conditions --start-conditions -c

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

--depfile FILE

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

--ebcdic --ecb -e

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

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

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

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

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

--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 مفید است. re2c به دنبال FILE در دایرکتوری فایل والد و در مکان‌های include مشخص‌شده با گزینه -I می‌گردد.

--input <default | custom>

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

--input-encoding <ascii | utf8>

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

--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، جایی که وضعیت‌های منفرد همان حالت‌های دستور switch هستند. وضعیت در یک متغیر yystate ذخیره می‌شود. گذارها میان وضعیت‌ها yystate را به برچسب case وضعیت مقصد به‌روزرسانی کرده و اجرا را به ابتدای حلقه ادامه می‌دهند..TP --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) خودداری کند، زیرا تحلیل‌گر لغوی (lexer) از قبل بررسی‌های انتهای ورودی را به شیوه‌ای کارآمدتر انجام می‌دهد. کاربر می‌تواند تعریف امنی از YYPEEK ارائه دهد، یا تعریفی که تنها در بیلدهای release ناامن است؛ در چنین حالتی، گزینه --no-unsafe به جلوگیری از هشدارهای مربوط به بلوک‌های unsafe زائد کمک می‌کند.

--output -o OUTPUT

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

--posix-captures, -P

استخراج زیرتطابق (submatch) را با گروه‌های ضبط به سبک 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" (اسکلت) تولید می‌کند. علاوه‌بر این، فایل‌های ورودی را با رشته‌های مشتق‌شده از دستور زبان باقاعده و نتایج تطابق فشرده‌شده تولید می‌کند که برای تأیید رفتار "skeleton" روی تمام ورودی‌ها استفاده می‌شوند. این گزینه برای یافتن باگ‌ها در بهینه‌سازی‌ها و تولید کد مفید است. این گزینه تنها برای C پشتیبانی می‌شود.

--storable-state -f

تولید یک تحلیل‌گر لغوی که می‌تواند وضعیت درونی خود را ذخیره کند. این قابلیت در تحلیل‌گرهای لغوی مدل push مفید است که وقتی ورودی کافی وجود ندارد توسط یک برنامه بیرونی متوقف می‌شوند و سپس با دردسترس قرار گرفتن ورودی بیشتر از سر گرفته می‌شوند. در این حالت کاربران باید علاوه‌بر این، دستورهای اولیه YYGETSTATE و YYSETSTATE را تعریف کنند، و متغیرهای yych، yyaccept و state باید بخشی از وضعیت ذخیره‌شده لکسر باشند.

--syntax FILE

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

--tags -T

استخراج زیرتطابق را با برچسب‌ها (tags) فعال می‌کند.

--ucs2 --wide-chars -w

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

--utf8 --utf-8 -8

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

--utf16 --utf-16 -x

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

--utf32 --unicode -u

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

--verbose

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

--vernum -V

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

--version -v

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

--single-pass -1

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

--debug-output -d

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

--dump-adfa

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

--dump-cfg

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

--dump-closure-stats

گزینه اشکال‌زدایی: خروجی دادن آمار مربوط به تعداد حالت‌ها در بستار (closure).

--dump-dfa-det

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

--dump-dfa-min

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

--dump-dfa-tagopt

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

--dump-dfa-tree

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

--dump-dfa-raw

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

--dump-interf

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

--dump-nfa

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

--emit-dot -D

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

--dfa-minimization <moore | table>

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

--eager-skip

گزینه داخلی: باعث می‌شود لکسر تولیدشده موقعیت ورودی را به‌صورت مشتاقانه (eagerly) پیش ببرد -- بلافاصله پس از خواندن نماد ورودی. این گزینه رفتار پیش‌فرض را که در آن موقعیت ورودی به‌صورت تنبل (lazily) -- پس از گذار به حالت بعدی -- پیش می‌رود، تغییر می‌دهد.

--no-lookahead

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

--no-optimize-tags

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

--posix-closure <gor1 | gtop>

گزینه داخلی: تعیین الگوریتم کوتاه‌ترین مسیر مورد استفاده برای ساخت بستار اپسیلون (epsilon-closure) با معناشناسی رفع ابهام POSIX: گزینه gor1 (پیش‌فرض) نشان‌دهنده الگوریتم گلدبرگ-رادزیک (Goldberg-Radzik) است، و gtop نشان‌دهنده الگوریتم "ترتیب توپولوژیکی سراسری" (global topological order) است.

--posix-prectable <complex | naive>

گزینه داخلی: مشخص کردن الگوریتم مورد استفاده برای محاسبه جدول اولویت POSIX. الگوریتم complex جدول اولویت را در یک پیمایش از درخت تاریخچه برچسب محاسبه می‌کند و دارای پیچیدگی مرتبه دوم در تعداد حالت‌های TNFA است؛ این گزینه پیش‌فرض است. الگوریتم naive در بدترین حالت دارای پیچیدگی مرتبه سوم در تعداد حالت‌های TNFA است، اما بسیار ساده‌تر از complex بوده و در موارد عادی ممکن است کمی سریع‌تر باشد..TP --stadfa گزینهٔ داخلی، منسوخ‌شده. در گذشته برای فعال‌سازی الگوریتم staDFA به کار می‌رفت، که تفاوت آن با TDFA در این است که عملیات ثبات‌ها به جای انتقال‌ها درون وضعیت‌ها قرار می‌گیرد. بنچمارک‌ها نشان دادند که الگوریتم staDFA کارایی کمتری نسبت به TDFA دارد.

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

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

-W

فعال کردن تمام هشدارها.

-Werror

تبدیل هشدارها به خطا. توجه داشته باشید که این گزینه به تنهایی هیچ هشداری را فعال نمی‌کند؛ بلکه تنها بر هشدارهایی اثر می‌گذارد که تا کنون فعال شده‌اند یا بعداً فعال خواهند شد.

-W<warning>

فعال کردن warning.

-Wno-<warning>

غیرفعال کردن warning.

-Werror-<warning>

فعال کردن warning و در نظر گرفتن آن به عنوان خطا (این گزینه متضمن -W<warning> است).

-Wno-error-<warning>

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

-Wcondition-order

هشدار در صورتی که برنامهٔ تولیدشده فرضیات ضمنی دربارهٔ شماره‌گذاری شرط‌ها داشته باشد. باید از گزینهٔ --header یا بلوک conditions برای تولید نگاشتی از نام شرط‌ها به شماره‌ها استفاده شود و سپس نام‌های شرطِ تولیدشده به‌صورت خودکار به کار روند.

-Wempty-character-class

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

-Wmatch-empty-string

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

-Wswapped-range

هشدار در صورتی که کران پایین یک بازه بزرگ‌تر از کران بالای آن باشد. رفتار پیش‌فرض این است که بدون هشدار، جای کران‌های بازه جابه‌جا می‌شود.

-Wundefined-control-flow

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

-Wunreachable-rules

هشدار دربارهٔ قواعدی که توسط قواعد دیگر پوشانده شده‌اند (shadowed) و هرگز تطبیق نخواهند یافت.

-Wdeprecated-eof_rule

هشدار دربارهٔ قواعد مستقل پایان ورودی $ که بر اثر تغییرات آینده از کار خواهند افتاد و نیاز به اصلاح دارند. در حال حاضر این قواعد هنگام تداخل با قواعد دیگر دارای اولویت هستند، اما پس از معرفی نماد عمومی پایان ورودی $، ترتیب اولویت تغییر خواهد کرد و این قواعد توسط قواعد دیگر پوشانده خواهند شد.

-Wuseless-escape

هشدار در صورتی که یک نماد به اشتباه گریزدهی شده باشد (دارای escape باشد). به‌طور پیش‌فرض، re2c چنین گریزهایی را بی‌صدا نادیده می‌گیرد، اما این حالت می‌تواند نشان‌دهندهٔ یک اشتباه تایپی یا خطا در توالی گریز (escape sequence) باشد.

-Wnondeterministic-tags

هشدار در صورتی که یک برچسب دارای درجهٔ nام از غیرقطعی بودن باشد، که در آن n بزرگ‌تر از ۱ است.

-Wsentinel-in-midrule

هشدار در صورتی که نماد نگهبان در میانهٔ یک قاعده رخ دهد --- این حالت ممکن است باعث خواندن داده‌ها فراتر از انتهای بافر، کرش کردن یا آسیب دیدن حافظه در تحلیل‌گر لغوی تولیدشده شود. این هشدار تنها زمانی اعمال می‌شود که روش نگهبان برای بررسی پایان ورودی استفاده شده باشد. در صورتی که از پیکربندی re2c:sentinel استفاده شود، این مورد به یک خطا تبدیل می‌گردد.

-Wundefined-syntax-config

هشدار در صورتی که فایل نحو مشخص‌شده با گزینهٔ --syntax فاقد تعاریف برخی از پیکربندی‌ها باشد. این ویژگی به نگهداری فایل‌های نحو تعریف‌شده توسط کاربر کمک می‌کند: اگر انتشار جدیدی پیکربندی‌های جدیدی اضافه کند، فایل نحو قدیمی یک هشدار صادر خواهد کرد و کاربر مطلع می‌شود. اگر برخی پیکربندی‌ها استفاده نمی‌شوند و نیازی به تعریف ندارند، باید به صراحت روی <undefined> تنظیم شوند.

پشتیبانی از زبان‌های گوناگون در re2c بر پایه ایده syntax files (فایل‌های نحو) استوار است. یک فایل نحو، یک فایل پیکربندی است که نحو زبان مقصد را تعریف می‌کند -- نه تمام زبان، بلکه بخش کوچکی از آن را که توسط کد تولیدشده استفاده می‌شود. فایل‌های نحو re2c را بسیار انعطاف‌پذیر می‌سازند، اما نباید به عنوان جایگزینی برای پیکربندی‌های re2c: استفاده شوند: هدف آن‌ها تعریف نحو زبان مقصد است، نه سفارشی‌سازی یک تحلیل‌گر لغوی (lexer) خاص. تمام زبان‌های پشتیبانی‌شده دارای فایل‌های نحو پیش‌فرضی هستند که بخشی از توزیع برنامه می‌باشند (زیردایرکتوری include/syntax را ببینید)؛ آن‌ها همچنین در باینری re2c تعبیه شده‌اند. کاربران می‌توانند یک فایل نحو سفارشی ارائه دهند که چند پیکربندی را برای یکی از زبان‌های پشتیبانی‌شده بازنویسی کند، یا می‌توانند تمام پیکربندی‌ها را از نو تعریف کنند (در این حالت باید از گزینه --lang none استفاده شود). فایل‌های نحو حاوی چهار نوع پیکربندی مختلف هستند: فهرست‌های ویژگی، پیکربندی‌های زبان، پیکربندی‌های درجا و الگوهای کد.

فهرست‌های ویژگی (Feature lists)

پیکربندی‌های زبان (Language configurations)

پیکربندی‌های درجا (Inplace configurations)

الگوهای کد (Code templates)

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 ']'

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;

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

// re2c $INPUT -o $OUTPUT
#include <assert.h>
// Expect a null-terminated string.
static int lex(const char *YYCURSOR) {
    int count = 0;
    for (;;) {
    /*!re2c
        re2c:define:YYCTYPE = "unsigned char";
        re2c:yyfill:enable = 0;
        *      { return -1; }
        [\x00] { return count; }
        [a-z]+ { ++count; continue; }
        [ ]+   { continue; }
    */
    }
}
int main() {
    assert(lex("") == 0);
    assert(lex("one two three") == 3);
    assert(lex("f0ur") == -1);
    return 0;
}

// re2c $INPUT -o $OUTPUT
#include <assert.h>
// Expect a null-terminated string.
static int lex(const char *str, unsigned int len) {
    const char *YYCURSOR = str, *YYLIMIT = str + len, *YYMARKER;
    int count = 0;
    for (;;) {
    /*!re2c
        re2c:define:YYCTYPE = "unsigned char";
        re2c:yyfill:enable = 0;
        re2c:eof = 0;
        str = ['] ([^'\\] | [\\][^])* ['];
        *    { return -1; }
        $    { return count; }
        str  { ++count; continue; }
        [ ]+ { continue; }
    */
    }
}
#define TEST(s, r) assert(lex(s, sizeof(s) - 1) == r)
int main() {
    TEST("", 0);
    TEST("'qu\0tes' 'are' 'fine: \\'' ", 3);
    TEST("'unterminated\\'", -1);
    return 0;
}

این مثال از بررسی‌های محدوده با پدینگ برای مدیریت انتهای ورودی استفاده می‌کند (این روش به‌طور پیش‌فرض فعال است). این برنامه تعداد رشته‌های تک‌نقل‌قولیِ جداشده با فاصله را می‌شمارد. پدینگی شامل YYMAXFILL نویسهٔ null به انتهای ورودی الحاق شده است، که مقدار YYMAXFILL به‌طور خودکار توسط یک بلوک max تولید می‌شود. استفاده از null برای پدینگ الزامی نیست --- از هر نویسه‌ای می‌توان استفاده کرد تا زمانی که یک پسوند معتبر برای نشانه (lexeme) تشکیل ندهد (در این مثال پدینگ نباید شامل تک‌نقل‌قول باشد، زیرا ممکن است با پسوند یک رشتهٔ تک‌نقل‌قولی اشتباه گرفته شود). یک قاعدهٔ "stop" وجود دارد که با نخستین نویسهٔ پدینگ (null) تطابق یافته و تحلیل‌گر لغوی را خاتمه می‌دهد (توجه داشته باشید که بررسی می‌کند آیا null در ابتدای پدینگ قرار دارد یا خیر، در غیر این صورت یک خطای نحوی است). بررسی‌های محدوده تنها در حالت‌هایی تولید می‌شوند که توسط مؤلفه‌های قویاً همبندِ اتوماتون زیرین تعیین شده باشند. این بررسی‌ها به شکل (YYLIMIT - YYCURSOR) < n یا با API عمومی به‌صورت YYLESSTHAN(n) هستند، که در آن n حداقل تعداد نویسه‌های مورد نیاز برای ادامهٔ کار تحلیل‌گر لغوی است (همچنین به این معنی است که بررسی بعدی محدوده حداکثر در n نویسهٔ آینده رخ خواهد داد). اگر شرط بررسی درست باشد، تحلیل‌گر لغوی به انتهای ورودی رسیده است و YYFILL(n) را فراخوانی می‌کند که باید یا حداقل n نویسهٔ ورودی را فراهم سازد یا بازگشتی نداشته باشد. در این مثال YYFILL همیشه با شکست مواجه می‌شود و تحلیل‌گر لغوی را با یک خطا پایان می‌دهد (که مشکلی ایجاد نمی‌کند زیرا تمام ورودی در یک بافر جای می‌گیرد). برای مشاهدهٔ مثالی که بافر ورودی را با استفاده از YYFILL بازپر می‌کند، بخش YYFILL with padding را ببینید.

// re2c $INPUT -o $OUTPUT
#include <assert.h>
#include <stdlib.h>
#include <string.h>
/*!max:re2c*/
static int lex(const char *str, unsigned int len) {
    // Make a copy of the string with YYMAXFILL zeroes at the end.
    char *buf = (char*) malloc(len + YYMAXFILL);
    memcpy(buf, str, len);
    memset(buf + len, 0, YYMAXFILL);
    const char *YYCURSOR = buf, *YYLIMIT = buf + len + YYMAXFILL;
    int count = 0;
loop:
    /*!re2c
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYFILL = "goto fail;";
        str = ['] ([^'\\] | [\\][^])* ['];
        [\x00] {
            // Check that it is the sentinel, not some unexpected null.
            if (YYCURSOR - 1 == buf + len) goto exit; else goto fail;
        }
        str  { ++count; goto loop; }
        [ ]+ { goto loop; }
        *    { goto fail; }
    */
fail:
    count = -1;
exit:
    free(buf);
    return count;
}
#define TEST(s, r) assert(lex(s, sizeof(s) - 1) == r)
int main() {
    TEST("", 0);
    TEST("'qu\0tes' 'are' 'fine: \\'' ", 3);
    TEST("'unterminated\\'", -1);
    TEST("'unexpected \0 null\\'", -1);
    return 0;
}

// re2c $INPUT -o $OUTPUT
#include <assert.h>
#include <stdlib.h>
#include <string.h>
static int lex(const char *str, unsigned int len) {
    // For the sake of example create a string without terminating null.
    char *buf = (char*) malloc(len);
    memcpy(buf, str, len);
    const char *cur = buf, *lim = buf + len;
    int count = 0;
    for (;;) {
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:api = custom;
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYPEEK = "cur < lim ? *cur : 0";  // fake null
        re2c:define:YYSKIP = "++cur;";
        *      { count = -1; break; }
        [\x00] { break;; }
        [a-z]+ { ++count; continue;; }
        [ ]+   { continue; }
    */
    }
    free(buf);
    return count;
}
#define TEST(s, r) assert(lex(s, sizeof(s) - 1) == r)
int main() {
    TEST("", 0);
    TEST("one two three ", 3);
    TEST("f0ur", -1);
    return 0;
}

// re2c $INPUT -o $OUTPUT -i
#include <stdint.h>
#include <limits.h>
#include <assert.h>
static const uint64_t ERROR = UINT64_MAX;
#define CHECK(n) if (n > UINT32_MAX) return ERROR;
static uint64_t parse_u32(const char *s) {
    const char *YYCURSOR = s, *YYMARKER;
    uint64_t u = 0;
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:define:YYCTYPE = "unsigned char";
        end = "\x00";
        '0b' / [01]        { goto bin; }
        "0"                { goto oct; }
        "" / [1-9]         { goto dec; }
        '0x' / [0-9a-fA-F] { goto hex; }
        *                  { return ERROR; }
    */
bin:
    /*!re2c
        end   { return u; }
        [01]  { u = u * 2 + (YYCURSOR[-1] - '0'); CHECK(u); goto bin; }
        *     { return ERROR; }
    */
oct:
    /*!re2c
        end   { return u; }
        [0-7] { u = u * 8 + (YYCURSOR[-1] - '0'); CHECK(u); goto oct; }
        *     { return ERROR; }
    */
dec:
    /*!re2c
        end   { return u; }
        [0-9] { u = u * 10 + (YYCURSOR[-1] - '0'); CHECK(u); goto dec; }
        *     { return ERROR; }
    */
hex:
    /*!re2c
        end   { return u; }
        [0-9] { u = u * 16 + (YYCURSOR[-1] - '0');      CHECK(u); goto hex; }
        [a-f] { u = u * 16 + (YYCURSOR[-1] - 'a' + 10); CHECK(u); goto hex; }
        [A-F] { u = u * 16 + (YYCURSOR[-1] - 'A' + 10); CHECK(u); goto hex; }
        *     { return ERROR; }
    */
}
int main() {
    assert(parse_u32("") == ERROR);
    assert(parse_u32("1234567890") == 1234567890);
    assert(parse_u32("0b1101") == 13);
    assert(parse_u32("0x7Fe") == 2046);
    assert(parse_u32("0644") == 420);
    assert(parse_u32("9999999999") == ERROR);
    return 0;
}

شرط‌های شروع با گزینهٔ --start-conditions فعال می‌شوند. آن‌ها روشی برای کدگذاری چندین خودکارهٔ (automata) مرتبط با یکدیگر را درون یک بلوک re2c یکسان فراهم می‌کنند.

هر شرط متناظر با یک خودکارهٔ منفرد است و دارای یک نام منحصربه‌فردِ تعیین‌شده توسط کاربر و یک شمارهٔ داخلی یکتاست که توسط re2c تعریف می‌شود. این شماره‌ها برای جابه‌جایی میان شرط‌ها به کار می‌روند: کد تولیدشده از تعاریف پایه‌ایِ YYGETCOND و YYSETCOND برای دریافت شرط فعلی یا تنظیم آن بر روی شمارهٔ ارائه‌شده استفاده می‌کند. از بلوک conditions، گزینهٔ --header یا پیکربندی re2c:header برای تولید شناسه‌های عددی شرط‌ها استفاده کنید. پیکربندی re2c:cond:enumprefix پیشوند شناسه‌های تولیدشده را مشخص می‌کند.

در حالت شرط (condition mode)، هر قاعده باید پیشوندی از فهرستی از نام‌های شرط‌ها داشته باشد که با کاما از هم جدا شده و درون قلاب‌ها (angle brackets) قرار گرفته‌اند، یا از نویسهٔ عام <*> برای اشاره به تمام شرط‌ها استفاده کند. نحو قواعد به شرح زیر گسترش می‌یابد:

کدی که re2c برای شرط‌ها تولید می‌کند به این بستگی دارد که آیا re2c از رویکرد goto/label برای کدگذاری خودکاره‌ها استفاده می‌کند یا از رویکرد loop/switch.

در زبان‌هایی که دارای دستور goto هستند (مانند C/C++ و Go)، شرط‌ها به‌طور طبیعی به‌صورت بلوک‌هایی از کد با برچسب‌هایی به فرم yyc_<cond> پیاده‌سازی می‌شوند، که در آن cond نام شرط است (پیشوند برچسب را می‌توان با re2c:cond:prefix تغییر داد). انتقال بین شرط‌ها با استفاده از goto و برچسب‌های شرط پیاده‌سازی می‌شود. پیش از تمام شرط‌ها، re2c یک ساختار switch اولیه بر روی YYGETSTATE تولید می‌کند که به وضعیت شروعِ شرط فعلی جهش می‌نماید. قواعد میان‌بر :=> ساختار switch اولیه را دور می‌زنند و مستقیماً به شرط مشخص‌شده جهش می‌کنند (از re2c:cond:goto می‌توان برای تغییر رفتار پیش‌فرض استفاده کرد). قواعد دارای کنش‌های معنایی به‌طور خودکار به شرط بعدی جهش نمی‌کنند؛ این کار باید توسط کد کنشِ تعریف‌شده توسط کاربر انجام شود.

در زبان‌هایی که دستور goto ندارند (مانند Rust)، re2c از متغیر yystate برای ذخیرهٔ شماره‌های شرط مجدداً استفاده می‌کند. هر شرط یک شناسهٔ عددی برابر با شمارهٔ وضعیت شروع خود دریافت می‌کند، و switch میان شرط‌ها تفاوتی با switch بین وضعیت‌های DFA یک شرط واحد ندارد. در این حالت نیازی به switch اولیهٔ مجزا برای شرط نیست. (از آنجا که همین رویکرد برای پیاده‌سازی وضعیت‌های قابل‌ذخیره استفاده می‌شود، در صورت استفادهٔ هم‌زمان از وضعیت‌های قابل‌ذخیره و شرط‌ها، YYGETCOND/YYSETCOND زاید خواهند بود).

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

// re2c $INPUT -o $OUTPUT -ci
#include <stdint.h>
#include <limits.h>
#include <assert.h>
static const uint64_t ERROR = UINT64_MAX;
/*!conditions:re2c*/
static uint64_t parse_u32(const char *s) {
    const char *YYCURSOR = s, *YYMARKER;
    int c = yycinit;
    uint64_t u = 0;
    /*!re2c
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYGETCONDITION = "c";
        re2c:define:YYSETCONDITION = "c = @@;";
        re2c:yyfill:enable = 0;
        <*> * { return ERROR; }
        <init> '0b' / [01]        :=> bin
        <init> "0"                :=> oct
        <init> "" / [1-9]         :=> dec
        <init> '0x' / [0-9a-fA-F] :=> hex
        <bin, oct, dec, hex> "\x00" { return u; }
        <bin> [01]  { u = u * 2  + (YYCURSOR[-1] - '0');      goto yyc_bin; }
        <oct> [0-7] { u = u * 8  + (YYCURSOR[-1] - '0');      goto yyc_oct; }
        <dec> [0-9] { u = u * 10 + (YYCURSOR[-1] - '0');      goto yyc_dec; }
        <hex> [0-9] { u = u * 16 + (YYCURSOR[-1] - '0');      goto yyc_hex; }
        <hex> [a-f] { u = u * 16 + (YYCURSOR[-1] - 'a' + 10); goto yyc_hex; }
        <hex> [A-F] { u = u * 16 + (YYCURSOR[-1] - 'A' + 10); goto yyc_hex; }
        <!*> { if (u > UINT32_MAX) return ERROR; }
    */
}
int main() {
    assert(parse_u32("") == ERROR);
    assert(parse_u32("1234567890") == 1234567890);
    assert(parse_u32("0b1101") == 13);
    assert(parse_u32("0x7Fe") == 2046);
    assert(parse_u32("0644") == 420);
    assert(parse_u32("9999999999") == ERROR);
    return 0;
}

// re2c $INPUT -o $OUTPUT -f
#include <assert.h>
#include <stdio.h>
#include <string.h>
#define DEBUG 0
#define LOG(...) if (DEBUG) fprintf(stderr, __VA_ARGS__);
// Use a small buffer to cover the case when a lexeme doesn't fit.
// In real world use a larger buffer.
#define BUFSIZE 10
typedef struct {
    FILE *file;
    char buf[BUFSIZE + 1], *lim, *cur, *mar, *tok;
    int state;
} State;
typedef enum {END, READY, WAITING, BAD_PACKET, BIG_PACKET} Status;
static Status fill(State *st) {
    const size_t shift = st->tok - st->buf;
    const size_t used = st->lim - st->tok;
    const size_t free = BUFSIZE - used;
    // Error: no space. In real life can reallocate a larger buffer.
    if (free < 1) return BIG_PACKET;
    // Shift buffer contents (discard already processed data).
    memmove(st->buf, st->tok, used);
    st->lim -= shift;
    st->cur -= shift;
    st->mar -= shift;
    st->tok -= shift;
    // Fill free space at the end of buffer with new data.
    const size_t read = fread(st->lim, 1, free, st->file);
    st->lim += read;
    st->lim[0] = 0; // append sentinel symbol
    return READY;
}
static Status lex(State *st, unsigned int *recv) {
    char yych;
    /*!getstate:re2c*/
    for (;;) {
        st->tok = st->cur;
    /*!re2c
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYCURSOR = "st->cur";
        re2c:define:YYMARKER = "st->mar";
        re2c:define:YYLIMIT = "st->lim";
        re2c:define:YYGETSTATE = "st->state";
        re2c:define:YYSETSTATE = "st->state = @@;";
        re2c:define:YYFILL = "return WAITING;";
        re2c:eof = 0;
        packet = [a-z]+[;];
        *      { return BAD_PACKET; }
        $      { return END; }
        packet { *recv = *recv + 1; continue; }
    */
    }
}
void test(const char **packets, Status expect) {
    // Create a "socket" (open the same file for reading and writing).
    const char *fname = "pipe";
    FILE *fw = fopen(fname, "w");
    FILE *fr = fopen(fname, "r");
    setvbuf(fw, NULL, _IONBF, 0);
    setvbuf(fr, NULL, _IONBF, 0);
    // Initialize lexer state: `state` value is -1, all pointers are at the end
    // of buffer.
    State st;
    st.file = fr;
    st.cur = st.mar = st.tok = st.lim = st.buf + BUFSIZE;
    // Sentinel (at YYLIMIT pointer) is set to zero, which triggers YYFILL.
    st.lim[0] = 0;
    st.state = -1;
    // 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.
    Status status;
    unsigned int send = 0, recv = 0;
    for (;;) {
        status = lex(&st, &recv);
        if (status == END) {
            LOG("done: got %u packets\n", recv);
            break;
        } else if (status == WAITING) {
            LOG("waiting...\n");
            if (*packets) {
                LOG("sent packet %u\n", send);
                fprintf(fw, "%s", *packets++);
                ++send;
            }
            status = fill(&st);
            LOG("queue: '%s'\n", st.buf);
            if (status == BIG_PACKET) {
                LOG("error: packet too big\n");
                break;
            }
            assert(status == READY);
        } else {
            assert(status == BAD_PACKET);
            LOG("error: ill-formed packet\n");
            break;
        }
    }
    // Check results.
    assert(status == expect);
    if (status == END) assert(recv == send);
    // Cleanup: remove input file.
    fclose(fw);
    fclose(fr);
    remove(fname);
}
int main() {
    const char *packets1[] = {0};
    const char *packets2[] = {"zero;", "one;", "two;", "three;", "four;", 0};
    const char *packets3[] = {"zer0;", 0};
    const char *packets4[] = {"looooooooooong;", 0};
    test(packets1, END);
    test(packets2, END);
    test(packets3, BAD_PACKET);
    test(packets4, BIG_PACKET);
    return 0;
}

// re2c $INPUT -o $OUTPUT --input-encoding utf8
#include <assert.h>
#include <stdint.h>
// 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 0; }
    *       { return 1; }
*/
static int lex_utf8(const uint8_t *s) {
    const uint8_t *YYCURSOR = s, *YYMARKER;
    /*!use:re2c
        re2c:define:YYCTYPE = uint8_t;
        re2c:encoding:utf8 = 1;
    */
}
static int lex_utf32(const uint32_t *s) {
    const uint32_t *YYCURSOR = s, *YYMARKER;
    /*!use:re2c
        re2c:define:YYCTYPE = uint32_t;
        re2c:encoding:utf32 = 1;
    */
}
int main() {
    static const uint8_t s8[] = // UTF-8
        { 0xe2, 0x88, 0x80, 0x78, 0x20, 0xe2, 0x88, 0x83, 0x79 };
    static const uint32_t s32[] = // UTF32
        { 0x00002200, 0x00000078, 0x00000020, 0x00002203, 0x00000079 };
    assert(lex_utf8(s8) == 0);
    assert(lex_utf32(s32) == 0);
    return 0;
}

ابزار re2c دو روش برای استخراج تطابق‌های فرعی دارد.

در پشت صحنه، تمام این گزینه‌ها به برچسب‌ها و ماشین‌های خودکاره متناهی معین برچسب‌دار با پیش‌نگری (Tagged Deterministic Finite Automata with Lookahead) ترجمه می‌شوند. ایدهٔ اصلی TDFA، به حداقل رساندن سربار استخراج تطابق فرعی است. در حالت حدی، اگر هیچ برچسب یا گروه گیراندازی در عبارت منظم وجود نداشته باشد، TDFA صرفاً یک DFA معمولی خواهد بود. اگر تعداد برچسب‌ها متعادل باشد، این سربار به‌ندرت محسوس است. ماشین TDFA تولیدشده از تعدادی متغیر برچسب (tag variables) استفاده می‌کند که مستقیماً به برچسب‌ها نگاشت نمی‌شوند: یک متغیر واحد ممکن است برای برچسب‌های متفاوتی به کار رود، و یک برچسب ممکن است برای نگهداری تمام مقادیر احتمالی خود به چندین متغیر نیاز داشته باشد. در نهایت، ابهام برطرف شده و برای هر برچسب تنها یک متغیر نهایی باقی می‌ماند. متغیرهای برچسب باید با استفاده از بلوک‌های stags یا mtags تعریف شوند. اگر وضعیت تحلیل‌گر لغوی (lexer) ذخیره می‌شود، متغیرهای برچسب نیز باید بخشی از آن باشند. آن‌ها همچنین باید توسط YYFILL به‌روزرسانی شوند.

برچسب‌های S از عملیات‌های زیر پشتیبانی می‌کنند:

برچسب‌های M از عملیات‌های زیر پشتیبانی می‌کنند:

برچسب‌های S می‌توانند به صورت مقادیر اسکالر (اشاره‌گرها یا آفست‌ها) پیاده‌سازی شوند. برچسب‌های M به نمایش پیچیده‌تری نیاز دارند، چرا که باید دنباله‌ای از مقادیر برچسب را ذخیره کنند. ساده‌ترین و ناکارآمدترین نمایش برای یک m-tag، فهرستی (آرایه، بردار) از مقادیر برچسب است؛ روش کارآمدتر، ذخیرهٔ تمام m-tagها در یک درخت پیشوندی (prefix-tree) است که به صورت آرایه‌ای از گره‌های (v, p) نمایش داده می‌شود، که در آن v مقدار برچسب و p اشاره‌گری به گره والد است.

در اینجا یک مثال ساده از کاربرد s-tagها برای تجزیهٔ نگارش‌های معنایی (semantic versions) متشکل از سه مؤلفهٔ عددی آورده شده است: major، minor و patch (مورد آخر اختیاری است). برای مثال پیچیده‌تری که از YYFILL استفاده می‌کند، به ادامه مراجعه نمایید.

// re2c $INPUT -o $OUTPUT
#include <assert.h>
#include <stddef.h>
typedef struct { int major, minor, patch; } SemVer;
static int s2n(const char *s, const char *e) { // pre-parsed string to number
    int n = 0;
    for (; s < e; ++s) n = n * 10 + (*s - '0');
    return n;
}
static int lex(const char *str, SemVer *ver) {
    const char *YYCURSOR = str, *YYMARKER;
    // User-defined tag variables that are available in semantic action.
    const char *t1, *t2, *t3, *t4, *t5;
    // Autogenerated tag variables used by the lexer to track tag values.
    /*!stags:re2c format = 'const char *@@;\n'; */
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:tags = 1;
        num = [0-9]+;
        @t1 num @t2 "." @t3 num @t4 ("." @t5 num)? [\x00] {
            ver->major = s2n(t1, t2);
            ver->minor = s2n(t3, t4);
            ver->patch = t5 != NULL ? s2n(t5, YYCURSOR - 1) : 0;
            return 0;
        }
        * { return 1; }
    */
}
int main() {
    SemVer v;
    assert(lex("23.34", &v) == 0 && v.major == 23 && v.minor == 34 && v.patch == 0);
    assert(lex("1.2.999", &v) == 0 && v.major == 1 && v.minor == 2 && v.patch == 999);
    assert(lex("1.a", &v) == 1);
    return 0;
}

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

// re2c $INPUT -o $OUTPUT --tags
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <vector>
#define BUFSIZE 4095
struct Input {
    FILE *file;
    char buf[BUFSIZE + 1], *lim, *cur, *mar, *tok;
    // 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 = 'const char *@@;'; */
    bool eof;
};
struct SemVer { int major, minor, patch; };
static bool operator==(const SemVer &x, const SemVer &y) {
    return x.major == y.major && x.minor == y.minor && x.patch == y.patch;
}
static int s2n(const char *s, const char *e) { // pre-parsed string to number
    int n = 0;
    for (; s < e; ++s) n = n * 10 + (*s - '0');
    return n;
}
static int fill(Input &in) {
    if (in.eof) return 1;
    const size_t shift = in.tok - in.buf;
    const size_t used = in.lim - in.tok;
    // Error: lexeme too long. In real life could reallocate a larger buffer.
    if (shift < 1) return 2;
    // Shift buffer contents (discard everything up to the current token).
    memmove(in.buf, in.tok, used);
    in.lim -= shift;
    in.cur -= shift;
    in.mar -= shift;
    in.tok -= shift;
    // Tag variables need to be shifted like other input positions. The check
    // for non-NULL is only needed if some tags are nested inside of alternative
    // or repetition, so that they can have NULL value.
    /*!stags:re2c format = "if (in.@@) in.@@ -= shift;\n"; */
    // Fill free space at the end of buffer with new data from file.
    in.lim += fread(in.lim, 1, BUFSIZE - used, in.file);
    in.lim[0] = 0;
    in.eof = in.lim < in.buf + BUFSIZE;
    return 0;
}
static bool lex(Input &in, std::vector<SemVer> &vers) {
    // User-defined local variables that store final tag values.
    // They are different from tag variables autogenerated with `stags:re2c`,
    // as they are set at the end of match and used only in semantic actions.
    const char *t1, *t2, *t3, *t4;
    for (;;) {
        in.tok = in.cur;
    /*!re2c
        re2c:eof = 0;
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYCURSOR = in.cur;
        re2c:define:YYMARKER = in.mar;
        re2c:define:YYLIMIT = in.lim;
        re2c:define:YYFILL = "fill(in) == 0";
        re2c:tags:expression = "in.@@";
        num = [0-9]+;
        num @t1 "." @t2 num @t3 ("." @t4 num)? [\n] {
            int major = s2n(in.tok, t1);
            int minor = s2n(t2, t3);
            int patch = t4 != NULL ? s2n(t4, in.cur - 1) : 0;
            SemVer ver = {major, minor, patch};
            vers.push_back(ver);
            continue;
        }
        $ { return true; }
        * { return false; }
    */}
}int main() {
    const char *fname = "input";
    const SemVer semver = {1, 22, 333};
    std::vector<SemVer> expect(BUFSIZE, semver), actual;
    // Prepare input file (make sure it exceeds buffer size).
    FILE *f = fopen(fname, "w");
    for (int i = 0; i < BUFSIZE; ++i) fprintf(f, "1.22.333\n");
    fclose(f);
    // Reopen input file for reading.
    f = fopen(fname, "r");
    // Initialize lexer state: all pointers are at the end of buffer.
    Input in;
    in.file = f;
    in.cur = in.mar = in.tok = in.lim = in.buf + BUFSIZE;
    /*!stags:re2c format = "in.@@ = in.lim;\n"; */
    in.eof = false;
    // Sentinel (at YYLIMIT pointer) is set to zero, which triggers YYFILL.
    *in.lim = 0;
    // Run the lexer and check results.
    assert(lex(in, actual) && expect == actual);
    // Cleanup: remove input file.
    fclose(f);
    remove(fname);
    return 0;
}

در اینجا مثالی از به‌کارگیری گروه‌های گیرانداز (capturing groups) برای تجزیه نگارش‌های معنایی آورده شده است.

// re2c $INPUT -o $OUTPUT
#include <assert.h>
#include <stddef.h>
typedef struct { int major, minor, patch; } SemVer;
static int s2n(const char *s, const char *e) { // pre-parsed string to number
    int n = 0;
    for (; s < e; ++s) n = n * 10 + (*s - '0');
    return n;
}
static int lex(const char *str, SemVer *ver) {
    const char *YYCURSOR = str, *YYMARKER;
    // Final tag variables available in semantic action.
    /*!svars:re2c format = 'const char *@@;\n'; */
    // Intermediate tag variables used by the lexer (must be autogenerated).
    /*!stags:re2c format = 'const char *@@;\n'; */
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:captvars = 1;
        num = [0-9]+;
        (num) "." (num) ("." num)? [\x00] {
            (void) yytl0; (void) yytr0; // some variables are unused
            ver->major = s2n(yytl1, yytr1);
            ver->minor = s2n(yytl2, yytr2);
            ver->patch = yytl3 ? s2n(yytl3 + 1, yytr3) : 0;
            return 0;
        }
        * { return 1; }
    */
}
int main() {
    SemVer v;
    assert(lex("23.34", &v) == 0 && v.major == 23 && v.minor == 34 && v.patch == 0);
    assert(lex("1.2.999", &v) == 0 && v.major == 1 && v.minor == 2 && v.patch == 999);
    assert(lex("1.a", &v) == 1);
    return 0;
}

در اینجا مثالی از به‌کارگیری m-tagها برای تجزیه نگارشی با تعداد متغیری از مؤلفه‌ها آورده شده است. متغیرهای برچسب در یک trie ذخیره می‌شوند.

// re2c $INPUT -o $OUTPUT
#include <assert.h>
#include <stddef.h>
#include <vector>
static const int MTAG_ROOT = -1;
// 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).
struct Mtag {
    const char *elem; // tag value
    int pred; // index of the predecessor node or root
};
typedef std::vector<Mtag> MtagTrie;
typedef std::vector<int> Ver; // unbounded number of version components
static int s2n(const char *s, const char *e) { // pre-parsed string to number
    int n = 0;
    for (; s < e; ++s) n = n * 10 + (*s - '0');
    return n;
}
// Append a single value to an m-tag history.
static void add_mtag(MtagTrie &trie, int &mtag, const char *value) {
    Mtag m = {value, mtag};
    mtag = (int)trie.size();
    trie.push_back(m);
}
// Recursively unwind tag histories and collect version components.
static void unfold(const MtagTrie &trie, int x, int y, Ver &ver) {
    // Reached the root of the m-tag tree, stop recursion.
    if (x == MTAG_ROOT && y == MTAG_ROOT) return;
    // Unwind history further.
    unfold(trie, trie[x].pred, trie[y].pred, ver);
    // Get tag values. Tag histories must have equal length.
    assert(x != MTAG_ROOT && y != MTAG_ROOT);
    const char *ex = trie[x].elem, *ey = trie[y].elem;
    if (ex != NULL && ey != NULL) {
        // Both tags are valid pointers, extract component.
        ver.push_back(s2n(ex, ey));
    } else {
        // Both tags are NULL (this corresponds to zero repetitions).
        assert(ex == NULL && ey == NULL);
    }
}
static bool parse(const char *str, Ver &ver) {
    const char *YYCURSOR = str, *YYMARKER;
    MtagTrie mt;
    // User-defined tag variables that are available in semantic action.
    const char *t1, *t2;
    int t3, t4;
    // Autogenerated tag variables used by the lexer to track tag values.
    /*!stags:re2c format = 'const char *@@ = NULL;'; */
    /*!mtags:re2c format = 'int @@ = MTAG_ROOT;'; */
    /*!re2c
        re2c:api:style = free-form;
        re2c:define:YYCTYPE = "unsigned char";
        re2c:define:YYSTAGP = "@@ = YYCURSOR;";
        re2c:define:YYSTAGN = "@@ = NULL;";
        re2c:define:YYMTAGP = "add_mtag(mt, @@, YYCURSOR);";
        re2c:define:YYMTAGN = "add_mtag(mt, @@, NULL);";
        re2c:yyfill:enable = 0;
        re2c:tags = 1;
        num = [0-9]+;
        @t1 num @t2 ("." #t3 num #t4)* [\x00] {
            ver.clear();
            ver.push_back(s2n(t1, t2));
            unfold(mt, t3, t4, ver);
            return true;
        }
        * { return false; }
    */
}
int main() {
    Ver v;
    assert(parse("1", v) && v == Ver({1}));
    assert(parse("1.2.3.4.5.6.7", v) && v == Ver({1, 2, 3, 4, 5, 6, 7}));
    assert(!parse("1.2.", v));
    return 0;
}

// re2c $INPUT -o $OUTPUT -8 --case-ranges -i
#include <assert.h>
#include <stdint.h>
/*!include:re2c "unicode_categories.re" */
static int lex(const char *s) {
    const char *YYCURSOR = s, *YYMARKER;
    /*!re2c
        re2c:define:YYCTYPE = "unsigned char";
        re2c:yyfill:enable = 0;
        // Simplified "Unicode Identifier and Pattern Syntax"
        // (see https://unicode.org/reports/tr31)
        id_start    = L | Nl | [$_];
        id_continue = id_start | Mn | Mc | Nd | Pc | [\u200D\u05F3];
        identifier  = id_start id_continue*;
        identifier { return 0; }
        *          { return 1; }
    */
}
int main() {
    assert(lex("_Ыдентификатор") == 0);
    return 0;
}

// re2c $INPUT -o $OUTPUT -i
#include <assert.h>
/*!include:re2c "definitions.h" */
Result lex(const char *s) {
    const char *YYCURSOR = s, *YYMARKER;
    /*!re2c
        re2c:define:YYCTYPE = "unsigned char";
        re2c:yyfill:enable = 0;
        *      { return FAIL; }
        number { return OK; }
        !include "extra_rules.re.inc";
    */
}
int main() {
    assert(lex("123") == OK);
    assert(lex("123.4567") == OK);
    return 0;
}

ابزار re2c به شما اجازه می‌دهد با استفاده از گزینهٔ --header یا پیکربندی re2c:header و جفت‌بلوک‌هایی به شکل /*!header:re2c:on*/ و /*!header:re2c:off*/، یا %{header:on%} و %{header:off%}، از فایل ورودی .re فایل سرآیند تولید کنید. بلوک اول آغاز فایل سرآیند را مشخص می‌کند و بلوک دوم پایان آن را تعیین می‌نماید. هر آنچه بین این دو بلوک قرار گیرد توسط re2c پردازش می‌شود و کد تولیدشده در فایلی که با گزینهٔ --header یا پیکربندی re2c:header مشخص شده (یا در صورت عدم استفاده از گزینه یا پیکربندی، در stdout) نوشته خواهد شد. تولید خودکار فایل سرآیند ممکن است در مواردی نیاز باشد که re2c برای تولید تعاریفی به کار می‌رود که باید از سایر واحدهای ترجمه (translation units) قابل مشاهده باشند.

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

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