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

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

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

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

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

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

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

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

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

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

/*!maxnmatch:re2c[:<name1>[:<name2>...]] ... */ or %{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>...]] ... */ or %{stags[:<name1>[:<name2>...]] ... %}, %{mtags[:<name1>[:<name2>...]] ... %{

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

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

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

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

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

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

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

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

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

/*!header:re2c:on*/ or %{header:on %}

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

/*!header:re2c:off*/ or %{header:off %}

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

/*!ignore:re2c ... */ or %{ignore ... %}

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

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

!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) استفاده کرد تا از جریان کنترل ناخواسته جلوگیری شود.

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

Simple API

(در نسخهٔ 4.0 افزوده شد) این یک API پایه‌ای است که می‌تواند با گزینهٔ --api simple یا پیکربندی re2c:api = simple فعال شود. این رابط شامل عناصر اولیهٔ زیر است: YYINPUT (که باید به‌صورت دنباله‌ای از واحدهای کد، مانند یک رشته تعریف شود) و YYCURSOR، YYMARKER، YYCTXMARKER، YYLIMIT (که باید به‌صورت اندیس‌هایی در YYINPUT تعریف شوند).

Record API

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

Generic API

این انعطاف‌پذیرترین API و رابط پیش‌فرض برای backend زبان Go است. این رابط شامل عناصر اولیه برای عملیات عمومی است: YYPEEK، YYSKIP، YYBACKUP، YYBACKUPCTX، YYSTAGP، YYSTAGN، YYMTAGP، YYMTAGN، YYRESTORE، YYRESTORECTX، YYRESTORETAG، YYSHIFT، YYSHIFTSTAG، YYSHIFTMTAG، YYLESSTHAN، YYEND. رابط Generic API از دو سبک پشتیبانی می‌کند که نحوهٔ تعریف عناصر اولیه را تعیین می‌کنند:

/*!re2c
  re2c:YYPEEK       = "data[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} = -1";
  re2c:YYSHIFT      = "cursor += @@{shift}";
  re2c:YYSHIFTSTAG  = "@@{tag} += @@{shift}";
*/

YYPEEK := func() byte { return data[cursor] }
YYSKIP := func() { cursor++ }
YYBACKUP := func() { marker = cursor }
YYRESTORE := func() { cursor = marker }
YYBACKUPCTX := func() { ctxmarker = cursor }
YYRESTORECTX := func() { cursor = ctxmarker }
YYLESSTHAN := func(n int) bool { return limit-cursor < n }
YYEND := func(n int) bool { return limit == cursor }
YYSHIFT := func(n int) { cursor += n }

YYCTYPE

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

YYCURSOR

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

YYLIMIT

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

YYMARKER

یک l-value که موقعیت آخرین قاعدهٔ تطبیق‌یافته را ذخیره می‌کند (یک اشاره‌گر یا آفست عدد صحیح در YYINPUT). از این متغیر برای بازگرداندن موقعیت YYCURSOR در صورتی استفاده می‌شود که تطبیق طولانی‌تر با شکست مواجه شود و تحلیل‌گر لغوی نیاز به عقب‌گرد (rollback) داشته باشد. نیازی به مقداردهی اولیه نیست..TP 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 از نوع دودویی (boolean) تعریف شود که اگر و تنها اگر کمتر از 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

نوع شمارش شرط (condition enum). می‌تواند با بلوک 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-ام درست (true) است اگر و تنها اگر n-امین واحد کد در محدوده k-امین گذار باشد. ایده این نقشه بیتی جایگزینی چندین شاخه if یا حالت switch با بررسی یک تک‌بیت در جدول است.

yych

یک l-value از نوع YYCTYPE که نویسه ورودی جاری را ذخیره می‌کند. تعریف توسط کاربر تنها با گزینه -f --storable-state ضروری است..TP 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

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

--computed-gotos -g

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

--computed-gotos-relative

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

--conditions --start-conditions -c

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

--depfile FILE

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

--ebcdic --ecb -e

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

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

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

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

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

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

--input <default | custom>

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

--input-encoding <ascii | utf8>

مشخص کردن نحوهٔ تجزیه عبارت‌های منظم توسط re2go. با ascii (پیش‌فرض) re2go ورودی را با کدگذاری ASCII پردازش می‌کند: هر دنباله‌ای از واحدهای کد، دنباله‌ای از نویسه‌های مستقل ۱ بایتی است. با utf8، re2go ورودی را با کدگذاری 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، جایی که هر وضعیت جداگانه یک case از switch است. وضعیت در متغیر yystate ذخیره می‌شود. گذارهای بین وضعیت‌ها، مقدار yystate را به برچسب case وضعیت مقصد به‌روزرسانی کرده و اجرای برنامه را به ابتدای حلقه ادامه می‌دهند..TP --nested-ifs -s استفاده از عبارت‌های if تودرتو به جای عبارت‌های switch در پرش‌های شرطی. این مورد معمولاً در کامپایلرهای غیربهینه‌ساز منجر به تولید کُد کارآمدتری می‌شود.

--no-debug-info -i

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

--no-generation-date

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

--no-version

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

--no-unsafe

عدم تولید پوشش unsafe روی YYPEEK (این گزینه مختص Rust است). به دلایل کارایی، YYPEEK باید از بررسی مرزها (bounds-checking) خودداری کند، چرا که تحلیل‌گر لغوی از قبل بررسی‌های پایان ورودی را به روشی کارآمدتر انجام می‌دهد. کاربر می‌تواند یک تعریف امن از YYPEEK ارائه دهد، یا تعریفی که تنها در ساخت‌های نهایی (release builds) ناامن است؛ در این حالت گزینهٔ --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") خودکفا. علاوه بر این، تولید فایل‌های ورودی با رشته‌های مشتق‌شده از گرامر باقاعده و نتایج تطابق فشرده‌شده که برای اعتبارسنجی رفتار "skeleton" روی تمام ورودی‌ها به کار می‌روند. این گزینه برای یافتن باگ‌ها در بهینه‌سازی‌ها و تولید کُد مفید است. این گزینه تنها برای C پشتیبانی می‌شود.

--storable-state -f

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

--syntax FILE

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

--tags -T

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

--ucs2 --wide-chars -w

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

--utf8 --utf-8 -8

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

--utf16 --utf-16 -x

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

--utf32 --unicode -u

تولید تحلیل‌گر لغوی که ورودی با کدگذاری UTF32 را می‌خواند. re2go فرض می‌کند که محدودهٔ نویسه 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 پس از کمینه‌سازی (در قالب .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 مورداستفاده توسط re2go. گزینهٔ moore الگوریتم مور (Moore) است (که پیش‌فرض است). گزینهٔ table الگوریتم "پر کردن جدول" است. هر دو الگوریتم باید به جز برچسب‌گذاری مجدد وضعیت‌ها، DFA یکسانی تولید کنند؛ پر کردن جدول ساده‌تر و بسیار کندتر بوده و به عنوان پیاده‌سازی مرجع عمل می‌کند.

--eager-skip

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

--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 است و ممکن است در موارد غیرپاتولوژیک کمی سریع‌تر باشد..TP --stadfa گزینه داخلی، منسوخ‌شده. در گذشته برای فعال‌سازی الگوریتم staDFA استفاده می‌شد، که تفاوت آن با TDFA در این است که عملیات‌های ثبات به جای گذارها، در وضعیت‌ها قرار می‌گیرند. ارزیابی‌ها نشان دادند که الگوریتم staDFA کارایی کمتری نسبت به TDFA دارد.

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

گزینه داخلی: مشخص می‌کند که آیا بهینه‌سازی برچسب ثابت (fixed-tag) باید روی همهٔ برچسب‌ها (all)، هیچ‌کدام از آن‌ها (none)، یا فقط برچسب‌های موجود در الحاق سطح بالا (toplevel) اعمال شود یا خیر. مقدار پیش‌فرض all است. برچسب‌های "ثابت" برچسب‌هایی هستند که در فاصلهٔ ثابتی از برچسب دیگری (به نام "base" یا پایه) قرار دارند. در چنین مواردی فقط برچسب پایه نیاز به رهگیری دارد و مقدار برچسب ثابت می‌تواند از طریق مقدار برچسب پایه به‌علاوهٔ یک آفست ایستا محاسبه شود. برای برچسب‌هایی که تحت انشعاب یا تکرار هستند، بررسی این‌که آیا برچسب پایه مقدار عدم تطابق (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

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

-Wmatch-empty-string

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

-Wswapped-range

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

-Wundefined-control-flow

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

-Wunreachable-rules

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

-Wdeprecated-eof_rule

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

-Wuseless-escape

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

-Wnondeterministic-tags

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

-Wsentinel-in-midrule

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

-Wundefined-syntax-config

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

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

فهرست ویژگی‌ها (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
}

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
// Expect a null-terminated string.
func lex(yyinput string) int {
    yycursor := 0
    count := 0
    for { /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        *      { return -1 }
        [\x00] { return count }
        [a-z]+ { count += 1; continue }
        [ ]+   { continue }
    */
    }
}
func main() {
    assert_eq := func(x, y int) { if x != y { panic("error") } }
    assert_eq(lex("\000"), 0)
    assert_eq(lex("one two three\000"), 3)
    assert_eq(lex("f0ur\000"), -1)
}

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
// Expects a null-terminated string.
func lex(yyinput string) int {
    var yycursor, yymarker int
    yylimit := len(yyinput) - 1 // lim points at the terminating null
    count := 0
    for { /*!re2c
        re2c:YYCTYPE = byte;
        re2c:yyfill:enable = 0;
        re2c:eof = 0;
        str = ['] ([^'\\] | [\\][^])* ['];
        *    { return -1 }
        $    { return count }
        str  { count += 1; continue }
        [ ]+ { continue }
    */
    }
}
func main() {
    assert_eq := func(x, y int) { if x != y { panic("error") } }
    assert_eq(lex("\000"), 0)
    assert_eq(lex("'qu\000tes' 'are' 'fine: \\'' \000"), 3)
    assert_eq(lex("'unterminated\\'\000"), -1)
}

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

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
import "strings"
/*!max:re2c*/
// Expects YYMAXFILL-padded string.
func lex(str string) int {
    // Pad string with YYMAXFILL zeroes at the end.
    yyinput := str + strings.Repeat("\000", int(YYMAXFILL))
    yycursor := 0
    yylimit := len(yyinput)
    count := 0
    for { /*!re2c
        re2c:YYCTYPE = byte;
        re2c:YYFILL = "return -1";
        str = ['] ([^'\\] | [\\][^])* ['];
        [\x00] {
            // Check that it is the sentinel, not some unexpected null.
            if yycursor - 1 == len(str) { return count } else { return -1 }
        }
        str  { count += 1; continue }
        [ ]+ { continue }
        *    { return -1 }
    */
    }
}
func main() {
    assert_eq := func(x, y int) { if x != y { panic("error") } }
    assert_eq(lex(""), 0)
    assert_eq(lex("'qu\000tes' 'are' 'fine: \\'' "), 3)
    assert_eq(lex("'unterminated\\'"), -1)
    assert_eq(lex("'unexpected \000 null\\'"), -1)
}

//go:generate re2go $INPUT -o $OUTPUT
package main
// Returns "fake" terminating null if cursor has reached limit.
func peek(str string, cur int) byte {
    if cur >= len(str) {
        return 0 // fake null
    } else {
        return str[cur]
    }
}
// Expects a string without terminating null.
func lex(str string) int {
    var cur int
    count := 0
    for { /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        re2c:YYPEEK = "peek(str, cur)";
        re2c:YYSKIP = "cur += 1";
        *      { return -1 }
        [\x00] { return count }
        [a-z]+ { count += 1; continue }
        [ ]+   { continue }
    */
    }
}
func main() {
    assert_eq := func(x, y int) { if x != y { panic("error") } }
    assert_eq(lex(""), 0)
    assert_eq(lex("one two three"), 3)
    assert_eq(lex("f0ur"), -1)
}

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

همهٔ این موارد در هر شرایطی استفاده نمی‌شوند، اما در صورت استفاده، باید توسط YYFILL به‌روزرسانی شوند. تمام موقعیت‌های فعال در بازهٔ میان token و cursor قرار دارند، بنابراین هر آنچه میان ابتدای بافر و token است می‌تواند دور ریخته شود، بخش میان token تا limit باید به ابتدای بافر منتقل شود، و فضای خالی انتهای بافر باید با داده‌های جدید پر گردد. برای جلوگیری از فراخوانی‌های مکرر YYFILL، بهتر است تا حد امکان نویسه‌های ورودی بیشتری پر شوند (حتی اگر نویسه‌های کمتری برای از سرگیری کار لکسر کافی باشد). جزئیات پیاده‌سازی YYFILL بسته به روش مدیریت پایان فایل (EOF) مورد استفاده، کمی متفاوت است: حالت قاعدهٔ EOF تا حدی ساده‌تر از حالت بررسی محدوده (bounds-checking) با فاصله‌گذاری (padding) است. همچنین توجه داشته باشید که اگر گزینهٔ -f --storable-state به کار رود، YYFILL دارای معناشناسی متفاوتی خواهد بود (که در بخش وضعیت قابل ذخیره‌سازی توضیح داده شده است).

//go:generate re2go $INPUT -o $OUTPUT
package main
import (
    "os"
    "strings"
)
const BUFSIZE uint = 4096
type Input struct {
    file     *os.File
    yyinput  []byte
    yycursor uint
    yymarker uint
    yylimit  uint
    token    uint
    eof      bool
}
func fill(in *Input) int {
    if in.eof { return -1 } // unexpected EOF
    // Error: lexeme too long. In real life can reallocate a larger buffer.
    if in.token < 1 { return -2 }
    // Shift buffer contents (discard everything up to the current token).
    copy(in.yyinput[0:], in.yyinput[in.token:in.yylimit])
    in.yycursor -= in.token
    in.yymarker -= in.token
    in.yylimit -= in.token
    in.token = 0
    // Fill free space at the end of buffer with new data from file.
    n, _ := in.file.Read(in.yyinput[in.yylimit:BUFSIZE])
    in.yylimit += uint(n)
    in.yyinput[in.yylimit] = 0
    // If read less than expected, this is the end of input.
    in.eof = in.yylimit < BUFSIZE
    return 0
}
func lex(yyrecord *Input) int {
    count := 0
    for {
        yyrecord.token = yyrecord.yycursor
    /*!re2c
        re2c:api = record;
        re2c:eof = 0;
        re2c:YYCTYPE = byte;
        re2c:YYFILL = "fill(yyrecord) == 0";
        str = ['] ([^'\\] | [\\][^])* ['];
        *    { return -1 }
        $    { return count }
        str  { count += 1; continue }
        [ ]+ { continue }
    */
    }
}
func main() () {
    fname := "input"
    content := "'qu\000tes' 'are' 'fine: \\'' ";
    // Prepare input file: a few times the size of the buffer, containing
    // strings with zeroes and escaped quotes.
    f, _ := os.Create(fname)
    f.WriteString(strings.Repeat(content, int(BUFSIZE)))
    f.Seek(0, 0)
    count := 3 * int(BUFSIZE) // number of quoted strings written to file
    // Prepare lexer state: all offsets are at the end of buffer.
    in := &Input{
        file:     f,
        // Sentinel at `yylimit` offset is set to zero, which triggers YYFILL.
        yyinput:  make([]byte, BUFSIZE+1),
        yycursor: BUFSIZE,
        yymarker: BUFSIZE,
        yylimit:  BUFSIZE,
        token:    BUFSIZE,
        eof:      false,
    }
    // Run the lexer.
    if lex(in) != count { panic("error"); }
    // Cleanup: remove input file.
    f.Close();
    os.Remove(fname);
}

در حالت پیش‌فرض (زمانی که از قاعده EOF استفاده نمی‌شود)، YYFILL یک دستور اولیه شبه‌تابع است که یک آرگومان می‌پذیرد و هیچ مقداری برنمی‌گرداند. فراخوانی YYFILL با شرط (YYLIMIT - YYCURSOR) < n در API اشاره‌گر C و YYLESSTHAN(n) در API عمومی (generic API) فعال می‌شود. آرگومان ارسال‌شده به YYFILL حداقل تعداد نویسه‌هایی است که باید تأمین شوند. اگر در انجام این کار ناموفق باشد، YYFILL نباید کنترل را به lexer بازگرداند (به همین دلیل بهتر است به صورت ماکرویی پیاده‌سازی شود که در صورت شکست، از تابع فراخواننده خارج شود). در صورت فراخوانی موفقیت‌آمیز YYFILL، موقعیت حد (limit) باید روی یک موقعیت پس از آخرین موقعیت ورودی در بافر، یا روی انتهای پدینگ YYMAXFILL تنظیم شود (در حالتی که YYFILL با موفقیت حداقل n نویسه را خوانده باشد، اما این مقدار برای پر کردن کل بافر کافی نباشد). تصاویر زیر موقعیت‌های نسبی ورودی را در بافر قبل و بعد از فراخوانی YYFILL نشان می‌دهند (پدینگ YYMAXFILL در تصویر دوم با نمادهای # مشخص شده است).

               <-- shift -->                 <-- need -->
             >-A------------B---------C-----D-------E---F--------G->
             buffer       token    marker cursor  limit
>-A------------B---------C-----D-------E---F--------G->
             buffer,  marker cursor               limit
             token
               <-- shift -->                 <-- need -->
             >-A------------B---------C-----D-------E-F        (EOF)
             buffer       token    marker cursor  limit
>-A------------B---------C-----D-------E-F###############
             buffer,  marker cursor                   limit
             token                        <- YYMAXFILL ->

در اینجا نمونه‌ای از برنامه‌ای آورده شده است که فایل ورودی input.txt را در قطعات ۴۰۹۶ بایتی خوانده و از بررسی مرزها (bounds-checking) همراه با پدینگ استفاده می‌کند.

//go:generate re2go $INPUT -o $OUTPUT
package main
import (
    "os"
    "strings"
)
/*!max:re2c*/
const BUFSIZE uint = 4096
type Input struct {
    file     *os.File
    yyinput  []byte
    yycursor uint
    yylimit  uint
    token    uint
    eof      bool
}
func fill(in *Input, need uint) int {
    if in.eof { return -1 } // unexpected EOF
    // Error: lexeme too long. In real life can reallocate a larger buffer.
    if in.token < need { return -2 }
    // Shift buffer contents (discard everything up to the current token).
    copy(in.yyinput[0:], in.yyinput[in.token:in.yylimit])
    in.yycursor -= in.token
    in.yylimit -= in.token
    in.token = 0
    // Fill free space at the end of buffer with new data from file.
    n, _ := in.file.Read(in.yyinput[in.yylimit:BUFSIZE])
    in.yylimit += uint(n)
    // If read less than expected, this is end of input => add zero padding
    // so that the lexer can access characters at the end of buffer.
    if in.yylimit < BUFSIZE {
        in.eof = true
        for i := uint(0); i < YYMAXFILL; i += 1 { in.yyinput[in.yylimit+i] = 0 }
        in.yylimit += YYMAXFILL
    }
    return 0
}
func lex(yyrecord *Input) int {
    count := 0
    for {
        yyrecord.token = yyrecord.yycursor
    /*!re2c
        re2c:api = record;
        re2c:YYCTYPE = byte;
        re2c:YYFILL = "if r := fill(yyrecord, @@); r != 0 { return r }";
        str = ['] ([^'\\] | [\\][^])* ['];
        [\x00] {
            // Check that it is the sentinel, not some unexpected null.
            if yyrecord.token == yyrecord.yylimit - YYMAXFILL { return count } else { return -1 }
        }
        str  { count += 1; continue }
        [ ]+ { continue }
        *    { return -1 }
    */
    }
}
func main() () {
    fname := "input"
    content := "'qu\000tes' 'are' 'fine: \\'' ";
    // Prepare input file: a few times the size of the buffer, containing
    // strings with zeroes and escaped quotes.
    f, _ := os.Create(fname)
    f.WriteString(strings.Repeat(content, int(BUFSIZE)))
    f.Seek(0, 0)
    count := 3 * int(BUFSIZE) // number of quoted strings written to file
    // Prepare lexer state: all offsets are at the end of buffer.
    // This immediately triggers YYFILL, as the YYLESSTHAN condition is true.
    in := &Input{
        file:     f,
        yyinput:  make([]byte, BUFSIZE+YYMAXFILL),
        yycursor: BUFSIZE,
        yylimit:  BUFSIZE,
        token:    BUFSIZE,
        eof:      false,
    }
    // Run the lexer.
    if lex(in) != count { panic("error"); }
    // Cleanup: remove input file.
    f.Close();
    os.Remove(fname);
}

//go:generate re2go $INPUT -o $OUTPUT -i --api simple
package main
import "errors"
const u32Limit uint64 = 1<<32
var (
    eSyntax   = errors.New("syntax error")
    eOverflow = errors.New("overflow error")
)
func parse_u32(yyinput string) (uint32, error) {
    var yycursor, yymarker int
    result := uint64(0)
    add := func(base uint64, offset byte) {
        result = result * base + uint64(yyinput[yycursor-1] - offset)
        if result >= u32Limit {
            result = u32Limit
        }
    }
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        end = "\x00";
        '0b' / [01]        { goto bin }
        "0"                { goto oct }
        ""   / [1-9]       { goto dec }
        '0x' / [0-9a-fA-F] { goto hex }
        *                  { goto err }
    */
bin:
    /*!re2c
        end   { goto end }
        [01]  { add(2, '0'); goto bin }
        *     { goto err }
    */
oct:
    /*!re2c
        end   { goto end }
        [0-7] { add(8, '0'); goto oct }
        *     { goto err }
    */
dec:
    /*!re2c
        end   { goto end }
        [0-9] { add(10, '0'); goto dec }
        *     { goto err }
    */
hex:
    /*!re2c
        end   { goto end }
        [0-9] { add(16, '0');    goto hex }
        [a-f] { add(16, 'a'-10); goto hex }
        [A-F] { add(16, 'A'-10); goto hex }
        *     { goto err }
    */
end:
    if result < u32Limit {
        return uint32(result), nil
    } else {
        return 0, eOverflow
    }
err:
    return 0, eSyntax
}
func main() {
    test := func(num uint32, str string, err error) {
        if n, e := parse_u32(str); !(n == num && e == err) {
            panic("error")
        }
    }
    test(1234567890, "1234567890\000", nil)
    test(13, "0b1101\000", nil)
    test(0x7fe, "0x007Fe\000", nil)
    test(0644, "0644\000", nil)
    test(0, "9999999999\000", eOverflow)
    test(0, "123??\000", eSyntax)
}

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

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

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

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

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

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

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

//go:generate re2go -c $INPUT -o $OUTPUT -i --api simple
package main
import "errors"
var (
    eSyntax   = errors.New("syntax error")
    eOverflow = errors.New("overflow error")
)
/*!conditions:re2c*/
const u32Limit uint64 = 1<<32
func parse_u32(yyinput string) (uint32, error) {
    var yycursor, yymarker int
    result := uint64(0)
    yycond := yycinit
    add := func(base uint64, offset byte) {
        result = result * base + uint64(yyinput[yycursor-1] - offset)
        if result >= u32Limit {
            result = u32Limit
        }
    }
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        re2c:YYGETCOND = "cond";
        re2c:YYSETCOND = "cond = @@";
        <*> * { return 0, eSyntax }
        <init> '0b' / [01]        :=> bin
        <init> "0"                :=> oct
        <init> ""   / [1-9]       :=> dec
        <init> '0x' / [0-9a-fA-F] :=> hex
        <bin, oct, dec, hex> "\x00" {
            if result < u32Limit {
                return uint32(result), nil
            } else {
                return 0, eOverflow
            }
        }
        <bin> [01]  { add(2, '0');     goto yyc_bin }
        <oct> [0-7] { add(8, '0');     goto yyc_oct }
        <dec> [0-9] { add(10, '0');    goto yyc_dec }
        <hex> [0-9] { add(16, '0');    goto yyc_hex }
        <hex> [a-f] { add(16, 'a'-10); goto yyc_hex }
        <hex> [A-F] { add(16, 'A'-10); goto yyc_hex }
    */
}
func main() {
    test := func(num uint32, str string, err error) {
        if n, e := parse_u32(str); !(n == num && e == err) {
            panic("error")
        }
    }
    test(1234567890, "1234567890\000", nil)
    test(13, "0b1101\000", nil)
    test(0x7fe, "0x007Fe\000", nil)
    test(0644, "0644\000", nil)
    test(0, "9999999999\000", eOverflow)
    test(0, "123??\000", eSyntax)
}

//go:generate re2go -f $INPUT -o $OUTPUT
package main
import (
    "fmt"
    "os"
)
// Use a small buffer to cover the case when a lexeme doesn't fit.
// In real world use a larger buffer.
const BUFSIZE int = 10
type State struct {
    file     *os.File
    yyinput  []byte
    yycursor int
    yymarker int
    yylimit  int
    token    int
    yystate  int
}
const (
    lexEnd = iota
    lexReady
    lexWaitingForInput
    lexPacketBroken
    lexPacketTooBig
)
func fill(st *State) int {
    shift := st.token
    used := st.yylimit - st.token
    free := BUFSIZE - used
    // Error: no space. In real life can reallocate a larger buffer.
    if free < 1 { return lexPacketTooBig }
    // Shift buffer contents (discard already processed data).
    copy(st.yyinput[0:], st.yyinput[shift:shift+used])
    st.yycursor -= shift
    st.yymarker -= shift
    st.yylimit -= shift
    st.token -= shift
    // Fill free space at the end of buffer with new data.
    n, _ := st.file.Read(st.yyinput[st.yylimit:BUFSIZE])
    st.yylimit += n
    st.yyinput[st.yylimit] = 0 // append sentinel symbol
    return lexReady
}
func lex(yyrecord *State, recv *int) int {
    var yych byte
    /*!getstate:re2c*/
loop:
    yyrecord.token = yyrecord.yycursor
    /*!re2c
        re2c:api = record;
        re2c:eof = 0;
        re2c:YYFILL = "return lexWaitingForInput";
        packet = [a-z]+[;];
        *      { return lexPacketBroken }
        $      { return lexEnd }
        packet { *recv = *recv + 1; goto loop }
    */
}
func test(expect int, packets []string) {
    // Create a pipe (open the same file for reading and writing).
    fname := "pipe"
    fw, _ := os.Create(fname)
    fr, _ := os.Open(fname)
    // Initialize lexer state: `state` value is -1, all offsets are at the end
    // of buffer.
    st := &State{
        file:     fr,
        // Sentinel at `yylimit` offset is set to zero, which triggers YYFILL.
        yyinput:  make([]byte, BUFSIZE+1),
        yycursor: BUFSIZE,
        yymarker: BUFSIZE,
        yylimit:  BUFSIZE,
        token:    BUFSIZE,
        yystate:  -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.
    var status int
    send := 0
    recv := 0
    for {
        status = lex(st, &recv)
        if status == lexEnd {
            break
        } else if status == lexWaitingForInput {
            if send < len(packets) {
                fw.WriteString(packets[send])
                send += 1
            }
            status = fill(st)
            if status != lexReady {
                break
            }
        } else if status == lexPacketBroken {
            break
        }
    }
    // Check results.
    if status != expect || (status == lexEnd && recv != send) {
        panic(fmt.Sprintf("got %d, want %d", status, expect))
    }
    // Cleanup: remove input file.
    fr.Close()
    fw.Close()
    os.Remove(fname)
}
func main() {
    test(lexEnd, []string{})
    test(lexEnd, []string{"zero;", "one;", "two;", "three;", "four;"})
    test(lexPacketBroken, []string{"??;"})
    test(lexPacketTooBig, []string{"looooooooooooong;"})
}

Tags

گزینهٔ نخست استفاده از tagهای مستقل به فرم @stag یا #mtag است، که در آن stag و mtag نام‌های اختیاری تعریف‌شده توسط کاربر هستند. برچسب‌ها با گزینهٔ -T --tags یا پیکربندی re2c:tags = 1 فعال می‌شوند. از نظر معنایی برچسب‌ها نشانگرهای موقعیت هستند: آن‌ها می‌توانند در هر کجای یک عبارت منظم درج شوند و به موقعیت متناظر (یا موقعیت‌های چندگانه) در رشتهٔ ورودی متصل گردند. ‏S-tagها به آخرین موقعیت تطبیق‌یافته متصل می‌شوند، و m-tagها به فهرستی از موقعیت‌ها متصل می‌گردند (آن‌ها ممکن است در زیرعبارت‌های تکرارشونده استفاده شوند، جایی که یک موقعیت واحد در عبارت منظم متناظر با چندین موقعیت در رشتهٔ ورودی است). تمام برچسب‌ها باید توسط کاربر تعریف شوند، چه به صورت دستی یا به کمک بلوک‌های svars و mvars. اگر بیش از یک راه برای تطبیق برچسب‌ها در برابر ورودی وجود داشته باشد، ابهام با استفاده از راهبرد ابهام‌زدایی چپ‌ترینِ حریصانه (leftmost greedy) حل می‌شود.

Captures

گزینهٔ دوم استفاده از گروه‌های گیرانداز (capturing groups) است. آن‌ها با گزینهٔ --captures یا پیکربندی re2c:captures = 1 فعال می‌شوند. دو نوع برای سیاست‌های ابهام‌زدایی متفاوت وجود دارد: --leftmost-captures (پیش‌فرض) برای سیاست چپ‌ترینِ حریصانه، و --posix-captures برای سیاست طولانی‌ترین تطبیق POSIX. در این حالت تمام زیرعبارت‌های درون پرانتز به عنوان گروه‌های گیرانداز در نظر گرفته می‌شوند، و می‌توان از یک علامت تعجب برای مشخص کردن گروه‌های غیرگیرانداز استفاده کرد: (! ... ). با گزینهٔ --invert-captures یا پیکربندی re2c:invert-captures = 1 معنای علامت تعجب وارونه می‌شود. تعداد گروه‌ها برای قاعدهٔ منطبق‌شده در یک متغیر به نام yynmatch ذخیره می‌شود (کل عبارت منظم گروه شمارهٔ صفر است)، و نتایج زیرتطبیق در آرایهٔ yypmatch ذخیره می‌گردند. هر دو متغیر yynmatch و yypmatch باید توسط کاربر تعریف شوند، و اندازهٔ yypmatch باید حداقل [yynmatch * 2] باشد. از بلوک maxnmatch برای تعریف YYMAXNMATCH استفاده کنید؛ ثابتی که برابر با بیشترین مقدار yynmatch در میان تمام قواعد است.

Captvars

راه دیگر برای استفاده از گروه‌های گیرانداز، گزینهٔ --captvars یا پیکربندی re2c:captvars = 1 است. تنها تفاوت با --captures در روشی است که کد تولیدشده نتایج زیرتطبیق را ذخیره می‌کند: به جای yynmatch و yypmatch، ابزار re2go متغیرهای yytl<k> و yytr<k> را برای k-امین گروه گیرانداز تولید می‌کند (کاربر باید این‌ها را با استفاده از یک بلوک svars اعلان کند). گیراندازی با متغیرها از دو سیاست ابهام‌زدایی پشتیبانی می‌کند: --leftmost-captvars یا re2c:leftmost-captvars = 1 برای سیاست چپ‌ترینِ حریصانه (حالت پیش‌فرض) و --posix-captvars یا re2c:posix-captvars برای سیاست طولانی‌ترین تطبیق POSIX.

• ذخیرهٔ موقعیت ورودی در یک s-tag: عبارت t = YYCURSOR با API اشاره‌گر C یا یک عملیات تعریف‌شده توسط کاربر YYSTAGP(t) با API جنریک
• ذخیرهٔ مقدار پیش‌فرض در یک s-tag: عبارت t = NULL با API اشاره‌گر C یا یک عملیات تعریف‌شده توسط کاربر YYSTAGN(t) با API جنریک
• کپی کردن یک s-tag به دیگری: t1 = t2

• افزودن موقعیت ورودی به یک m-tag: یک عملیات تعریف‌شده توسط کاربر YYMTAGP(t) با هر دو API پیش‌فرض و جنریک
• افزودن مقدار پیش‌فرض به یک m-tag: یک عملیات تعریف‌شده توسط کاربر YYMTAGN(t) با هر دو API پیش‌فرض و جنریک
• کپی کردن یک m-tag به دیگری: t1 = t2

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
import "reflect"
type SemVer struct { major, minor, patch int }
func s2n(s string) int { // convert pre-parsed string to a number
    n := 0
    for _, c := range s { n = n*10 + int(c-'0') }
    return n
}
func parse(yyinput string) *SemVer {
    var yycursor, yymarker int
    // Final tag variables available in semantic action.
    /*!svars:re2c format = 'var @@ int;'; */
    // Intermediate tag variables used by the lexer (must be autogenerated).
    /*!stags:re2c format = 'var @@ int;'; */
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        re2c:tags = 1;
        num = [0-9]+;
        @t1 num @t2 "." @t3 num @t4 ("." @t5 num)? [\x00] {
            major := s2n(yyinput[t1:t2])
            minor := s2n(yyinput[t3:t4])
            patch := 0
            if t5 != -1 { patch = s2n(yyinput[t5:yycursor-1]) }
            return &SemVer{major, minor, patch}
        }
        * { return nil }
    */
}
func main() {
    assert_eq := func(x, y *SemVer) {
        if !reflect.DeepEqual(x, y) { panic("error") }
    }
    assert_eq(parse("23.34\000"), &SemVer{23, 34, 0})
    assert_eq(parse("1.2.9999\000"), &SemVer{1, 2, 9999})
    assert_eq(parse("1.a\000"), nil)
}

//go:generate re2go $INPUT -o $OUTPUT --tags
package main
import (
    "os"
    "reflect"
    "strings"
)
const BUFSIZE int = 4095
type Input struct {
    file     *os.File
    yyinput  []byte
    yycursor int
    yymarker int
    yylimit  int
    token    int
    // 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 = "\t@@ int\n"; */
    eof      bool
}
type SemVer struct { major, minor, patch int }
func s2n(s []byte) int { // convert pre-parsed string to a number
    n := 0
    for _, c := range s { n = n*10 + int(c-'0') }
    return n
}
func fill(in *Input) int {
    if in.eof { return -1 } // unexpected EOF
    // Error: lexeme too long. In real life can reallocate a larger buffer.
    if in.token < 1 { return -2 }
    // Shift buffer contents (discard everything up to the current token).
    copy(in.yyinput[0:], in.yyinput[in.token:in.yylimit])
    in.yycursor -= in.token
    in.yymarker -= in.token
    in.yylimit -= in.token
    // Tag variables need to be shifted like other input positions. The check
    // for -1 is only needed if some tags are nested inside of alternative or
    // repetition, so that they can have -1 value.
    /*!stags:re2c format = "\tif in.@@ != -1 { in.@@ -= in.token }\n"; */
    in.token = 0
    // Fill free space at the end of buffer with new data from file.
    n, _ := in.file.Read(in.yyinput[in.yylimit:BUFSIZE])
    in.yylimit += n
    in.yyinput[in.yylimit] = 0
    // If read less than expected, this is the end of input.
    in.eof = in.yylimit < BUFSIZE
    return 0
}
func parse(in *Input) []SemVer {
    // Final tag variables available in semantic action.
    /*!svars:re2c format = "var @@ int;"; */
    vers := make([]SemVer, 0)
    for {
        in.token = in.yycursor
    /*!re2c
        re2c:api = record;
        re2c:eof = 0;
        re2c:yyrecord = in;
        re2c:YYCTYPE = byte;
        re2c:YYFILL = "fill(in) == 0";
        num = [0-9]+;
        num @t1 "." @t2 num @t3 ("." @t4 num)? [\n] {
            major := s2n(in.yyinput[in.token:t1])
            minor := s2n(in.yyinput[t2:t3])
            patch := 0
            if t4 != -1 { patch = s2n(in.yyinput[t4:in.yycursor-1]) }
            vers = append(vers, SemVer{major, minor, patch})
            continue
        }
        $ { return vers }
        * { return nil }
    */
    }
}
func main() () {
    fname := "input"
    content := "1.22.333\n";
    expect := make([]SemVer, 0, BUFSIZE)
    for i := 0; i < BUFSIZE; i += 1 { expect = append(expect, SemVer{1, 22, 333}) }
    // Prepare input file (make sure it exceeds buffer size).
    f, _ := os.Create(fname)
    f.WriteString(strings.Repeat(content, BUFSIZE))
    f.Seek(0, 0)
    // Initialize lexer state: all offsets are at the end of buffer.
    in := &Input{
        file:     f,
        // Sentinel at `yylimit` offset is set to zero, which triggers YYFILL.
        yyinput:  make([]byte, BUFSIZE+1),
        yycursor: BUFSIZE,
        yymarker: BUFSIZE,
        yylimit:  BUFSIZE,
        token:    BUFSIZE,
        eof:      false,
    }
    // Run the lexer and check results.
    if !reflect.DeepEqual(parse(in), expect) { panic("error"); }
    // Cleanup: remove input file.
    f.Close();
    os.Remove(fname);
}

در اینجا نمونه‌ای از استفاده از گروه‌های ضبط (capturing groups) برای تجزیه نسخه‌بندی‌های معنایی آورده شده است.

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
import "reflect"
type SemVer struct { major, minor, patch int }
func s2n(s string) int { // convert pre-parsed string to a number
    n := 0
    for _, c := range s { n = n*10 + int(c-'0') }
    return n
}
func parse(yyinput string) *SemVer {
    var yycursor, yymarker int
    // Final tag variables used in semantic action.
    /*!svars:re2c format = 'var @@ int;'; */
    // Intermediate tag variables used by the lexer (must be autogenerated).
    /*!stags:re2c format = 'var @@ int;'; */
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        re2c:captvars = 1;
        num = [0-9]+;
        (num) "." (num) ("." num)? [\x00] {
            _ = yytl0; _ = yytr0; // some variables are unused
            major := s2n(yyinput[yytl1:yytr1])
            minor := s2n(yyinput[yytl2:yytr2])
            patch := 0
            if yytl3 != -1 { patch = s2n(yyinput[yytl3+1:yytr3]) }
            return &SemVer{major, minor, patch}
        }
        * { return nil }
    */
}
func main() {
    assert_eq := func(x, y *SemVer) {
        if !reflect.DeepEqual(x, y) { panic("error") }
    }
    assert_eq(parse("23.34\000"), &SemVer{23, 34, 0})
    assert_eq(parse("1.2.9999\000"), &SemVer{1, 2, 9999})
    assert_eq(parse("1.a\000"), nil)
}

//go:generate re2go $INPUT -o $OUTPUT --api simple
package main
import "reflect"
const (
    mtagRoot int = -1
    tagNone int = -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).
type mtagElem struct {
    elem int
    pred int
}
type mtagTrie = []mtagElem
type Ver = []int // unbounded number of version components
func s2n(s string) int { // convert pre-parsed string to a number
    n := 0
    for _, c := range s { n = n*10 + int(c-'0') }
    return n
}
// Append a single value to an m-tag history.
func add_mtag(trie *mtagTrie, mtag int, value int) int {
    *trie = append(*trie, mtagElem{value, mtag})
    return len(*trie) - 1
}
// Recursively unwind tag histories and collect version components.
func unwind(trie mtagTrie, x int, y int, str string) Ver {
    // Reached the root of the m-tag tree, stop recursion.
    if x == mtagRoot && y == mtagRoot {
        return []int{}
    }
    // Unwind history further.
    ver := unwind(trie, trie[x].pred, trie[y].pred, str)
    // Get tag values. Tag histories must have equal length.
    if x == mtagRoot || y == mtagRoot {
        panic("tag histories have different length")
    }
    ex := trie[x].elem
    ey := trie[y].elem
    if ex != tagNone && ey != tagNone {
        // Both tags are valid string indices, extract component.
        ver = append(ver, s2n(str[ex:ey]))
    } else if !(ex == tagNone && ey == tagNone) {
        panic("both tags should be tagNone")
    }
    return ver
}
func parse(yyinput string) []int {
    var yycursor, yymarker int
    trie := make([]mtagElem, 0)
    // Final tag variables available in semantic action.
    /*!svars:re2c format = 'var @@ int;'; */
    /*!mvars:re2c format = "var @@ int;"; */
    // Intermediate tag variables used by the lexer (must be autogenerated).
    /*!stags:re2c format = 'var @@ int'; separator = "\n\t"; */
    /*!mtags:re2c format = "\t@@ := mtagRoot\n"; */
    /*!re2c
        re2c:tags = 1;
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        re2c:YYMTAGP = "@@ = add_mtag(&trie, @@, yycursor)";
        re2c:YYMTAGN = "@@ = add_mtag(&trie, @@, tagNone)";
        num = [0-9]+;
        @t1 num @t2 ("." #t3 num #t4)* [\x00] {
            ver := make([]int, 0)
            ver = append(ver, s2n(yyinput[t1:t2]))
            ver = append(ver, unwind(trie, t3, t4, yyinput)...)
            return ver
        }
        * { return nil }
    */
}
func main() {
    assert_eq := func(x, y []int) {
        if !reflect.DeepEqual(x, y) { panic("error") }
    }
    assert_eq(parse("1\000"), []int{1})
    assert_eq(parse("1.2.3.4.5.6.7\000"), []int{1, 2, 3, 4, 5, 6, 7})
    assert_eq(parse("1.\000"), nil)
}

//go:generate re2go $INPUT -o $OUTPUT -8si --api simple
package main
/*!include:re2c "unicode_categories.re" */
func lex(yyinput string) int {
    var yycursor, yymarker int
    /*!re2c
        re2c:yyfill:enable = 0;
        re2c:YYCTYPE = byte;
        // 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 }
    */
}
func main() {
    if lex("_Ыдентификатор\000") != 0 {
        panic("error")
    }
}

//go:generate re2go $INPUT -o $OUTPUT -i --api simple
package main
/*!include:re2c "definitions.go" */
func lex(yyinput string) int {
    var yycursor, yymarker int
    /*!re2c
        re2c:YYCTYPE = byte;
        re2c:yyfill:enable = 0;
        *      { return ResultFail }
        number { return ResultOk }
        !include "extra_rules.re.inc";
    */
}
func main() {
    assert_eq := func(x, y int) { if x != y { panic("error") } }
    assert_eq(lex("123\000"), ResultOk)
    assert_eq(lex("123.4567\000"), ResultOk)
}

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

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

// Code generated by re2c, DO NOT EDIT.
package lexer
type State struct {
    Data string
    Cur, Mar, Tag1 int
}

با گزینهٔ -S, --skeleton، برنامهٔ re2go تمام کدهای غیر re2go را نادیده گرفته و یک برنامهٔ C خودکفا تولید می‌کند که می‌تواند در ادامه کامپایل و اجرا شود. این برنامه شامل کد تحلیل‌گر لغوی و داده‌های ورودی است. برای هر DFA ساخته‌شده (بلاک یا شرط)، re2go یک تحلیل‌گر لغوی مستقل و دو فایل تولید می‌کند: یک فایل .input شامل رشته‌های مشتق‌شده از DFA و یک فایل .keys با نتایج تطابق مورد انتظار. برنامه هر تحلیل‌گر لغوی را روی فایل .input متناظر اجرا کرده و نتایج را با موارد مورد انتظار مقایسه می‌کند. برنامه‌های اسکلت به دلایل متعددی بسیار مفید هستند:

دشواری تولید داده‌های ورودی در این است که به‌جز در ساده‌ترین حالت‌ها، تعداد رشته‌های ورودی ممکن بسیار زیاد است (حتی اگر طول رشته محدود باشد). re2go این مشکل را با تولید رشته‌های کافی برای پوشش تقریباً تمام گذارهای DFA حل می‌کند. این ابزار از الگوریتم زیر استفاده می‌کند: ابتدا یک اسکلت از DFA می‌سازد. برای کدگذاری‌هایی با اندازه واحد کد ۱ بایتی (مانند ASCII، UTF-8 و EBCDIC)، اسکلت دقیقاً یک رونوشت از DFA اصلی است. برای کدگذاری‌هایی با واحدهای کد چندبایتی، اسکلت رونوشتی از DFA با حذف برخی گذارها است: بدین صورت که re2go حداکثر ۲۵۶ واحد کد را برای هر بازهٔ پیوسته و مجزا که متناظر با یک گذار DFA است در نظر می‌گیرد. مقادیر انتخاب‌شده به‌صورت یکنواخت توزیع شده و شامل کران‌های بازه نیز هستند. re2go به جای تلاش برای پوشش تمام مسیرهای ممکن در اسکلت (که نشدنی است)، مسیرهای کافی برای پوشش همهٔ گذارهای اسکلت را تولید می‌کند و بدین ترتیب پرش‌های شرطی متناظر را در تحلیل‌گر لغوی فعال می‌سازد. پیاده‌سازی این الگوریتم به حدود ۱ گیگابایت گذار محدود شده و مقدار ثابتی حافظه مصرف می‌کند (re2go داده‌ها را به محض تولید در فایل می‌نویسد).