re2c - מקוון בענן

תָכְנִית:

שֵׁם

re2c - המרת ביטויים רגולריים לקוד C/C++

תַקצִיר

re2c [אופציות] קובץ

תיאור

re2c הוא מחולל lexer עבור C/C++. זה מוצא מפרטי ביטוי רגולרי בתוך
הערות C/C++ ומחליף אותן ב-DFA מקודד קשה. המשתמש חייב לספק חלק
קוד ממשק על מנת לשלוט ולהתאים אישית את ה-DFA שנוצר.

אפשרויות

-? -h - עזרה
פנה לעזרה קצרה.

-b --וקטורי סיביות
מרמז -s. השתמש גם בוקטורי סיביות בניסיון לשדל קוד טוב יותר מה-
מַהְדֵר. שימושי ביותר עבור מפרטים עם יותר מכמה מילות מפתח (למשל עבור
רוב שפות התכנות).

-c --תנאים
משמש לתמיכה בתמיכה במצב דמוי (f)lex.

-d --פלט באגים
יוצר מנתח המשליך מידע על המיקום הנוכחי ובו
מצב המנתח נמצא בזמן ניתוח הקלט. זה שימושי לאיפוי באגים בבעיות מנתח
ומדינות. אם אתה משתמש במתג זה, עליך להגדיר מאקרו YYDEBUG כי הוא
נקראת כמו פונקציה עם שני פרמטרים: לבטל את YYDEBUG (int מדינה, char נוֹכְחִי).
הפרמטר הראשון מקבל את המצב או -1 והפרמטר השני מקבל את
קלט בסמן הנוכחי.

-D --פלוט-נקודה
פלט נתוני נקודות Graphviz. לאחר מכן ניתן לעבד אותו עם למשל נקודה -Tpng input.dot >
output.png. שים לב שסורקים עם מצבים רבים עלולים לקרוס נקודה.

-e --ecb
צור מנתח התומך ב-EBCDIC. הקוד שנוצר יכול להתמודד עם כל
תו עד 0xFF. במצב זה re2c מניח שגודל תו הקלט הוא 1
בייט. מתג זה אינו תואם -w, -x, -u ו -8.

-f --מצב ניתן לאחסון
צור סורק עם תמיכה במצב ניתן לאחסון.

-F --פלקס-תחביר
תמיכה חלקית בתחביר גמיש. כאשר הדגל הזה פעיל אז הגדרות בשם
חייב להיות מוקף בפלטה מתולתלת וניתן להגדיר אותו ללא סימן שוויון ואת
חצי נקודתיים מסתיימת. במקום זה מתייחסים לשמות כמחרוזות ישירות במירכאות כפולות.

-g --מחשב-גוטוס
צור סורק המשתמש בתכונת ה-goto המחושבת של GCC. זה re2c
יוצר טבלאות קפיצה בכל פעם שההחלטה היא במורכבות מסוימת (למשל, הרבה
אם יש צורך בתנאים אחרים). זה ניתן לשימוש רק עם GCC ומייצר
פלט שלא ניתן להידור עם אף מהדר אחר. שימו לב שזה מרמז -b
וכי ניתן להגדיר את סף המורכבות באמצעות התצורה במקום
cgoto:threshold.

-i --no-debug-info
לא פלט #קַו מֵידָע. זה שימושי כאשר אתה רוצה להשתמש בכלי CMS עם
מה היא re2c פלט שאולי תרצה אם אינך דורש מהמשתמשים שלך re2c
עצמם כאשר בונים מהמקור שלך.

-o תפוקה --output=פלט
ציין את תפוקה קובץ.

-r --רב פעמי
מאפשר שימוש חוזר בהגדרות הסורק עם /*!use:re2c */ לאחר /*!rules:re2c */,
מצב זה מס /*!re2c */ בלוק ובדיוק אחד /*!rules:re2c */ חייב להיות נוכח.
הכללים נשמרים ומשמשים את כולם /*!use:re2c */ בלוק שאחריו.
בלוקים אלה יכולים להכיל תצורות במקום, במיוחד re2c:flags:e,
re2c:flags:w, re2c:flags:x, re2c:flags:u ו re2c:flags:8. ככה זה אפשרי
ליצור את אותו סורק מספר פעמים עבור סוגי תווים שונים, שונים
מנגנוני קלט או מנגנוני פלט שונים. ה /*!use:re2c */ בלוקים יכולים
מכילים גם כללים נוספים שיצורפו למערכת הכללים ב
/*!rules:re2c */.

-s --מקוננות-אם
צור אם מקוננים עבור מתגים מסוימים. מהדרים רבים זקוקים לסיוע זה כדי ליצור
קוד טוב יותר.

-t HEADER --type-header=HEADER
צור HEADER קובץ המכיל סוגים עבור תמיכת התנאים דמויי (f)lex.
זה יכול להיות מופעל רק כאשר -c בשימוש.

-u --unicode
צור מנתח שתומך ב-UTF-32. הקוד שנוצר יכול להתמודד עם כל חוקי
תו Unicode עד 0x10FFFF. במצב זה re2c מניח את תו הקלט הזה
הגודל הוא 4 בתים. מתג זה אינו תואם -e, -w, -x ו -8. זה מרמז
-s.

-v --גִרְסָה
הצג מידע על גרסה.

-V --ורנום
הצג את הגרסה כמספר XXYYZZ.

-w --תווים רחבים
צור מנתח שתומך ב-UCS-2. הקוד שנוצר יכול להתמודד עם כל חוקי
תו Unicode עד 0xFFFF. במצב זה re2c מניח את תו הקלט הזה
הגודל הוא 2 בתים. מתג זה אינו תואם -e, -x, -u ו -8. זה מרמז
-s.

-x --utf-16
צור מנתח שתומך ב-UTF-16. הקוד שנוצר יכול להתמודד עם כל חוקי
תו Unicode עד 0x10FFFF. במצב זה re2c מניח את תו הקלט הזה
הגודל הוא 2 בתים. מתג זה אינו תואם -e, -w, -u ו -8. זה מרמז
-s.

-8 --utf-8
צור מנתח שתומך ב-UTF-8. הקוד שנוצר יכול להתמודד עם כל חוקי
תו Unicode עד 0x10FFFF. במצב זה re2c מניח את תו הקלט הזה
הגודל הוא 1 בייט. מתג זה אינו תואם -e, -w, -x ו -u.

--לא רגיש רישיות
כל המחרוזות אינן תלויות רישיות, כך שכל הביטויים "-" מטופלים באותו אופן
'-ביטויים הם.

--היפוך מקרה
הפוך את המשמעות של מחרוזות במירכאות בודדות וכפולות. עם סינגל מתג זה
מרכאות הן תלויות רישיות ומירכאות כפולות הן לא תלויות רישיות.

--ללא תאריך-דור
דחק פלט תאריך בקובץ שנוצר.

--ללא תאריך-דור
דיכוי פלט גרסה בקובץ שנוצר.

--קידוד-מדיניות מְדִינִיוּת
ציין כיצד re2c חייב לטפל בפונדקאות Unicode. מְדִינִיוּת יכול להיות אחד מהבאים:
להיכשל (הפסק עם שגיאה כאשר נתקלת בפונדקאית), תחליף (תחליף בשקט
סרוגייט עם נקודת קוד שגיאה 0xFFFD), להתעלם (התייחס לפונדקאות כקוד רגיל
נקודות). כברירת מחדל re2c מתעלם מפונדקאיות (למען תאימות לאחור). Unicode
הסטנדרט אומר שפונדקאות עצמאיות הן נקודות קוד לא חוקיות, אך שונות
ספריות ותוכניות מתייחסות אליהם אחרת.

--קֶלֶט קלט
ציין API של קלט re2c. קלט יכול להיות אחד מהבאים: ברירת מחדל, מנהג.

-S --שֶׁלֶד
במקום להטביע קוד שנוצר על ידי re2c במקור C/C++, צור א
תוכנית עצמאית עבור אותו DFA. שימושי ביותר עבור נכונות ו
בדיקת ביצועים.

--מחלקה ריקה מְדִינִיוּת
מה לעשות אם המשתמש מזין מחלקת תווים ריקה. מְדִינִיוּת יכול להיות אחד מה
הבא: גפרורים ריק (תאם קלט ריק: די לא הגיוני, אבל זה
ברירת מחדל מסיבה של תאימות לאחור), התאמה-אין (לא מצליח להתאים על אף אחד
קֶלֶט), שגיאה (שגיאת קומפילציה). שימו לב שישנן דרכים שונות לבנות
מחלקה ריקה, למשל: [], [^\x00-\xFF], [\x00-\xFF][\x00-\xFF].

---dfa-מזעור <טבלה | מור>
אלגוריתם פנימי בשימוש על ידי re2c כדי למזער DFA (ברירת המחדל היא מור). שני השולחן
מילוי והאלגוריתמים של מור צריכים לייצר DFA זהה (עד מצבים
תיוג מחדש). אלגוריתם מילוי טבלה הוא הרבה יותר פשוט ואיטי; זה משמש בתור א
יישום התייחסות.

-1 --מעבר יחיד
הוצא משימוש ולא עושה כלום (מעבר יחיד הוא כברירת מחדל כעת).

-W הפעל את כל האזהרות.

-שגיאה
הפוך אזהרות לשגיאות. שימו לב שהאפשרות הזו לא מפעילה אף אחת
אזהרות, זה משפיע רק על האזהרות שהופעלו עד כה או יהיו
מופעל מאוחר יותר.

-W
הפעל יחיד אזהרה.

-לא-
כבה את הפרט אזהרה.

-שגיאה-
הפעל יחיד אזהרה והתייחס לזה כאל שגיאה (זה מרמז -W).

-לא-שגיאה-
אל תתייחס לפרט הזה אזהרה כשגיאה. זה לא מכבה את האזהרה
עצמו.

-Wcondition-order
אזהרה אם התוכנית שנוצרה מניחה הנחות מרומזות לגבי מספור תנאים.
צריך להשתמש בשניהם -ט, --type-header אפשרות או /*!types:re2c*/ הנחיה ל
ליצור מיפוי של שמות תנאים למספרים ולהשתמש במצב שנוצר אוטומטית
שמות.

-מעמד-אופי-רטוב
אזהרה אם הביטוי הרגולרי מכיל מחלקת תווים ריקה. מהנקודה הרציונלית
אין הגיון בניסיון להתאים למחלקת תווים ריקה: זה צריך תמיד
לְהִכָּשֵׁל. עם זאת, מסיבות תאימות לאחור re2c מאפשר אופי ריק
מחלקה ומתייחסת אליו כמחרוזת ריקה. להשתמש --מחלקה ריקה אפשרות לשנות ברירת מחדל
התנהגות.

-מחרוזת Wmatch-ריק
אזהרה אם הביטוי הרגולרי בכלל ניתן ל- null (תואם מחרוזת ריקה). אם DFA
פועל בלולאה והתאמה ריקה היא לא מכוונת (מיקום הקלט אינו מתקדם
באופן ידני), lexer עלול להיתקע בלולאה נצחית.

- טווח הוחלף
אזהרה אם הגבול התחתון של הטווח גדול מהגבול העליון. בְּרִירַת מֶחדָל re2c התנהגות היא ל
להחליף בשקט את גבולות הטווח.

-זרימת שליטה לא מוגדרת
אזהרה אם כמה מחרוזות קלט גורמות לזרימת בקרה לא מוגדרת ב-lexer (הפגום
דפוסים מדווחים). זו הטעות המסוכנת והנפוצה ביותר. זה יכול להיות
לתקן בקלות על ידי הוספת כלל ברירת מחדל * (לכלל זה יש את העדיפות הנמוכה ביותר, תואם
כל יחידת קוד וצורכת בדיוק יחידת קוד אחת).

בריחה חסרת תועלת
הזהר אם סמל נמלט כאשר הוא לא אמור להיות. כברירת מחדל, re2c מתעלם בשקט
escape, אבל זה גם עשוי להצביע על שגיאת הקלדה או שגיאה ברצף ה-escape.

ממשק CODE

על המשתמש לספק קוד ממשק בצורה של קוד C/C++ (מאקרו, פונקציות,
משתנים וכו') או בצורה של במקום תצורות. אילו סמלים יש להגדיר
והן אופציונליות תלויות במקרה שימוש מסוים.

YYCONDTYPE
In -c מצב שבו אתה יכול להשתמש -t כדי ליצור קובץ המכיל את הספירה המשמשת כ
תנאים. כל אחד מהערכים מתייחס לתנאי של קבוצת כללים.

YYCTXMARKER
l-ערך של סוג YYCTYPE *. הקוד שנוצר חוסך מעקב אחורה של הקשר
מידע ב YYCTXMARKER. המשתמש צריך להגדיר מאקרו זה רק אם הוא סורק
המפרט משתמש בהקשר עוקב באחד או יותר מהביטויים הרגולריים שלו.

YYCTYPE
סוג המשמש להחזקת סמל קלט (יחידת קוד). בְּדֶרֶך כְּלַל char or לא חתום char ל
ASCII, EBCDIC ו-UTF-8, לא חתום קצר עבור UTF-16 או UCS-2 ו לא חתום int ל
UTF-32.

YYCURSOR
l-ערך של סוג YYCTYPE * שמצביע על סמל הקלט הנוכחי. הנוצר
הקוד מתקדם YYCURSOR כמו סמלים מותאמים. בכניסה, YYCURSOR מניחים
הצבע על התו הראשון של האסימון הנוכחי. ביציאה, YYCURSOR יצביע על
התו הראשון של האסימון הבא.

YYDEBUG (מדינה, נוֹכְחִי)
זה נחוץ רק אם -d צוין דגל. זה מאפשר לנפות באגים בקלות
מנתח שנוצר על ידי קריאה לפונקציה המוגדרת על ידי משתמש עבור כל מצב. הפונקציה
צריכה להיות החתימה הבאה: לבטל את YYDEBUG (int מדינה, char נוֹכְחִי). ה
הפרמטר הראשון מקבל את המצב או -1 והפרמטר השני מקבל את
קלט בסמן הנוכחי.

YYFILL (n)
הקוד שנוצר "קורא" YYFILL (n) כאשר המאגר זקוק למילוי (מחדש): לפחות
n יש לספק תווים נוספים. YYFILL (n) צריך להתאים YYCURSOR,
YYLIMIT, YYMARKER ו YYCTXMARKER לפי צורך. שים לב שלתכנות טיפוסי
שפות n יהיה האורך של מילת המפתח הארוכה ביותר פלוס אחת. המשתמש יכול למקם
הערה לטופס /*!max:re2c*/ להכניס YYMAXFILL הגדרה שמוגדרת ל
ערך האורך המרבי.

YYGETCONDITION ()
הגדרה זו משמשת כדי לקבל את המצב לפני הזנת קוד הסורק מתי
באמצעות -c החלף. יש לאתחל את הערך עם ערך מהספירה
YYCONDTYPE הקלד.

YYGETSTATE ()
המשתמש צריך להגדיר מאקרו זה רק אם -f צוין דגל. בתוך זה
במקרה, הקוד שנוצר "קורא" YYGETSTATE () ממש בתחילת הסורק
על מנת לקבל את המצב השמור. YYGETSTATE () חייב להחזיר מספר שלם חתום. ה
הערך חייב להיות אחד -1, המציין שהסורק הוזן בפעם הראשונה,
או ערך שנשמר בעבר על ידי YYSETSTATE (ים). במקרה השני, הסורק יעשה זאת
לחדש את הפעולות מיד אחרי איפה האחרון YYFILL (n) נקרא.

YYLIMIT
ביטוי של סוג YYCTYPE * שמסמן את סוף המאגר YYLIMIT[-1] האם ה
התו האחרון במאגר). הקוד שנוצר משווה שוב ושוב YYCURSOR ל
YYLIMIT כדי לקבוע מתי המאגר זקוק למילוי (מחדש).

YYMARKER
l-ערך של סוג YYCTYPE *. הקוד שנוצר שומר מידע מעקב לאחור
YYMARKER. ייתכן שחלק מהסורקים הקלים לא ישתמשו בזה.

YYMAXFILL
זה יוגדר אוטומטית על ידי /*!max:re2c*/ בלוקים כפי שהוסבר לעיל.

YYSETCONDITION (ג)
הגדרה זו משמשת להגדרת התנאי בכללי מעבר. זו רק הוויה
משמש מתי -c פעיל ונעשה שימוש בכללי מעבר.

YYSETSTATE (ים)
המשתמש צריך להגדיר מאקרו זה רק אם -f צוין דגל. בתוך זה
במקרה, הקוד שנוצר "קורא" YYSETSTATE רגע לפני שמתקשרים YYFILL (n). ה
פרמטר YYSETSTATE הוא מספר שלם חתום המזהה באופן ייחודי את הספציפי
מופע של YYFILL (n) זה עומד להיקרא. אם המשתמש ירצה לשמור את
מצב הסורק ויש YYFILL (n) לחזור למתקשר, כל שעליו לעשות הוא
לאחסן את המזהה הייחודי הזה במשתנה. מאוחר יותר, כאשר הנסרק נקרא
שוב, זה יתקשר YYGETSTATE () ולחדש את הביצוע בדיוק מהמקום שבו הפסיקה. ה
הקוד שנוצר יכיל את שניהם YYSETSTATE (ים) ו YYGETSTATE אפילו YYFILL (n)
מושבת.

תחביר

קוד עבור re2c מורכב מסט של RULES, שמות הגדרות ו במקום תצורות.

RULES
כללים מורכבים מביטוי רגולרי (ראה רגיל ביטויים) יחד עם גוש של
קוד C/C++ שיש להפעיל כאשר הביטוי הרגולרי המשויך מותאם. אתה
יכול להתחיל את הקוד עם סד מתולתל פותח או ברצף :=. כאשר הקוד
אז עם סד מתולתל re2c סופר את עומק הפלטה ומפסיק לחפש קוד
אוטומטית. אחרת פלטה מתולתלת אסור ו re2c מפסיק לחפש קוד ב
השורה הראשונה שאינה מתחילה ברווח לבן. אם שני כללים או יותר חופפים, ה
הכלל הראשון עדיף.
הבעה רגילה { C / C ++ קוד }

הבעה רגילה := C / C ++ קוד

יש כלל מיוחד אחד: כלל ברירת מחדל *
* { C / C ++ קוד }

* := C / C ++ קוד

שימו לב לכלל ברירת המחדל הזה * שונה מ [^]: לכלל ברירת המחדל יש את העדיפות הנמוכה ביותר, תואם
כל יחידת קוד (תקפה או לא חוקית) וצורכת תמיד תו אחד; בזמן [^]
מתאים לכל נקודת קוד חוקית (לא יחידת קוד) ויכול לצרוך מספר יחידות קוד. למעשה,
כאשר נעשה שימוש בקידוד באורך משתנה, * היא הדרך האפשרית היחידה להתאים קלט לא חוקי
דמות (ראה קידודים לפרטים).

If -c פעיל אז לכל ביטוי רגולרי קודמת רשימה של פסיקים מופרדים
שמות תנאים. מלבד כללי שמות רגילים ישנם שני מקרים מיוחדים: <*> (כללים כאלה
ממוזגים לכל התנאים) ו <> (לכלל כזה לא יכול להיות רגיל משויך
ביטוי, הקוד שלו מתמזג לכל הפעולות). כללים לא ריקים עשויים לפרט יותר
המצב החדש. במקרה הזה re2c יפיק את הקוד הדרוש כדי לשנות את
מצב אוטומטי. כללים יכולים להשתמש :=> כקיצור דרך להפקה אוטומטית של קוד
שלא רק קובע את מצב התנאי החדש אלא גם ממשיך את הביצוע עם החדש
מדינה. אין להשתמש בכלל קיצור בלולאה שבה יש קוד בין ההתחלה
של הלולאה וה- re2c לחסום אלא אם כן re2c:cond:goto שונה ל להמשיך. אם הקוד הוא
הכרחי לפני כל הכללים (אם כי לא קפיצות פשוטות) אתה יכול לעשות זאת באמצעות
פסאודו חוקים.
הבעה רגילה { C / C ++ קוד }

הבעה רגילה := C / C ++ קוד

* { C / C ++ קוד }

* := C / C ++ קוד

הבעה רגילה => מצב { C / C ++ קוד }

הבעה רגילה => מצב := C / C ++ קוד

* => מצב { C / C ++ קוד }

* => מצב := C / C ++ קוד

הבעה רגילה :=> מצב

<*> הבעה רגילה { C / C ++ קוד }

<*> הבעה רגילה := C / C ++ קוד

<*> * { C / C ++ קוד }

<*> * := C / C ++ קוד

<*> הבעה רגילה => מצב { C / C ++ קוד }

<*> הבעה רגילה => מצב := C / C ++ קוד

<*> * => מצב { C / C ++ קוד }

<*> * => מצב := C / C ++ קוד

<*> הבעה רגילה :=> מצב

<> { C / C ++ קוד }

<> := C / C ++ קוד

<> => מצב { C / C ++ קוד }

<> => מצב := C / C ++ קוד

<> :=> מצב

<> :=> מצב

<! רשימת תנאים> { C / C ++ קוד }

<! רשימת תנאים> := C / C ++ קוד

{ C / C ++ קוד }

:= C / C ++ קוד

שמות הגדרות
ההגדרות הנקובות הן בצורה:
שם = הבעה רגילה;

If -F פעיל, אז ההגדרות הנקובות הן גם בצורה:
שם { הבעה רגילה }

במקום תצורות
re2c:condprefix = yyc;
מאפשר לציין את הקידומת המשמשת עבור תוויות תנאי. זהו הטקסט הזה
מוצמד לתווית תנאי כלשהי בקובץ הפלט שנוצר.

re2c:condenumprefix = yyc;
מאפשר לציין את הקידומת המשמשת לערכי תנאי. זהו הטקסט הזה
מוצמד לכל ערך enum תנאי בקובץ הפלט שנוצר.

re2c:cond:divider = /* *********************************** */ ;
מאפשר להתאים אישית את המחלק עבור בלוקי תנאים. אתה יכול להשתמש @@ לשים את
שם התנאי או התאם אישית את מציין המיקום באמצעות re2c:cond:divider@cond.

re2c:cond:divider@cond = @@;
מציין את מציין המיקום שיוחלף בשם התנאי ב
re2c:cond:divider.

re2c:cond:goto = goto @@; ;
מאפשר להתאים אישית את הצהרות ה-goto של מצב שבו נעשה שימוש :=> כללי סגנון.
אתה יכול להשתמש @@ לשים את שם התנאי או להתאים את מציין המיקום באמצעות
re2c:cond:goto@cond. אתה יכול גם לשנות את זה ל ממשי, מה שיאפשר לך
כדי להמשיך עם מחזור הלולאה הבא כולל כל קוד בין התחלה של לולאה ל-re2c
לַחסוֹם.

re2c:cond:goto@cond = @@;
מציין את מציין המיקום שיוחלף בתווית התנאי ב
re2c:cond:goto.

re2c:indent:top = 0;
מציין את המספר המינימלי של הזחה לשימוש. דורש ערך מספרי
גדול או שווה לאפס.

re2c:indent:string = \t ;
מציין את המחרוזת לשימוש עבור הזחה. דורש מחרוזת שאמורה להכיל
רק רווח לבן אלא אם כן אתה צריך את זה עבור כלים חיצוניים. הדרך הקלה ביותר לפרט
רווחים הוא לכלול אותם במרכאות בודדות או כפולות. אם אתה לא רוצה
הזחה בכלל אתה יכול פשוט להגדיר את זה ל"".

re2c:yych:conversion = 0;
כאשר הגדרה זו אינה אפס, אז re2c יוצר אוטומטית קוד המרה
בכל פעם שנקרא yych. במקרה זה יש להגדיר את הסוג באמצעות
re2c:define:YYCTYPE.

re2c:yych:emit = 1;
דור של yych ניתן לדכא על ידי הגדרת זה ל-0.

re2c:ybm:hex = 0;
אם מוגדר לאפס, נעשה שימוש בטבלה עשרונית אחרת תהיה טבלה הקסדצימלית
נוצר.

re2c:yyfill:enable = 1;
הגדר את זה לאפס כדי לדכא את היצירה של YYFILL (n). בעת שימוש זה הקפד
ודא שהסורק שנוצר אינו קורא מאחורי קלט. מאפשר זאת
התנהגות עשויה להכניס בעיות אבטחה לתוכניות שלך.

re2c:yyfill:check = 1;
זה יכול להיות מוגדר 0 כדי לדכא פלט של התנאי המקדים באמצעות YYCURSOR ו
YYLIMIT מה שהופך שימושי כאשר YYLIMIT + YYMAXFILL תמיד נגיש.

re2c:define:YYFILL = YYFILL ;
החלפה עבור YYFILL. שים לב שכברירת מחדל re2c יוצר טיעון בסוגריים ו
נקודה-פסיק אחרי YYFILL. אם אתה צריך לעשות YYFILL אמירה שרירותית יותר
מאשר שיחה, קבע re2c:define:YYFILL:עירום ללא אפס ולהשתמש
re2c:define:YYFILL@len לציון פרמטר פורמלי בתוך YYFILL הגוף.

re2c:define:YYFILL@len = @@ ;
כל התרחשות של טקסט זה בתוך YYFILL יוחלף בממשי
ויכוח.

re2c:yyfill:parameter = 1;
שולט על ארגומנט בסוגריים לאחר YYFILL. אם אפס, האגרומנט מושמט. אם
שאינו אפס, ארגומנט נוצר אלא אם כן re2c:define:YYFILL:עירום מוגדר ללא אפס.

re2c:define:YYFILL:עירום = 0;
שולט על ארגומנט בסוגריים ופסיקים אחרי YYFILL. אם אפס, גם אגרומנט וגם
נקודה-פסיק מושמטים. אם אינו אפס, ארגומנט נוצר אלא אם כן
re2c:yyfill:parameter מוגדר לאפס ונקודה-פסיק נוצר ללא תנאי.

re2c:startlabel = 0;
אם מוגדר למספר שלם שאינו אפס, תווית ההתחלה של בלוקי הסורק הבאים תהיה
להיווצר גם אם לא נעשה בו שימוש על ידי הסורק עצמו. אחרת הרגיל yy0 כמו
תווית התחלה נוצרת רק במידת הצורך. אם מוגדר לערך טקסט אז תווית
עם הטקסט הזה ייווצר ללא קשר אם תווית ההתחלה הרגילה היא
בשימוש או לא. הגדרה זו מאופסת ל-0 לאחר תווית התחלה
נוצר.

re2c:labelprefix = yy ;
מאפשר לשנות את הקידומת של תוויות ממוספרות. ברירת המחדל היא yy ויכול להיות
הגדר כל מחרוזת שהיא תווית חוקית.

re2c:state:abort = 0;
כאשר לא אפס ותחליף -f פעיל אז ה YYGETSTATE בלוק יכיל א
מקרה ברירת מחדל שמבטל ו-1 מקרה משמש לאתחול.

re2c:state:nextlabel = 0;
משמש כאשר -f פעיל כדי לשלוט אם ה YYGETSTATE בלוק אחריו א
yyNext: קו תווית. במקום להשתמש yyNext אתה יכול בדרך כלל גם להשתמש בתצורה
תווית מפתיעה כדי לאלץ תווית התחלה מסוימת או ברירת מחדל yy0 כתווית התחלה.
במקום להשתמש בתווית ייעודית לרוב עדיף להפריד בין YYGETSTATE
קוד מקוד הסורק בפועל על ידי הצבת א /*!getstate:re2c*/ איך? 'או' מה.

re2c:cgoto:threshold = 9;
מתי -g הוא פעיל ערך זה מציין את סף המורכבות שמפעיל
יצירת טבלאות קפיצה במקום להשתמש ב-IF's מקוננות ושדות סיביות של החלטה. ה
סף מושווה מול הערכה מחושבת של אם-ים נחוצים כאשר כל
מפת סיביות בשימוש מחלק את הסף ב-2.

re2c:yych:conversion = 0;
כאשר הקלט משתמש בתווים חתומים ו -s or -b מתגים הם למעשה re2c
מאפשר להמיר אוטומטית לסוג התו הלא חתום שהוא אז
הכרחי לאופי היחיד הפנימי שלו. כאשר הגדרה זו היא אפס או ריקה
מחרוזת ההמרה מושבתת. באמצעות מספר שאינו אפס ההמרה מתבצעת
החל מ- YYCTYPE. אם זה נתון על ידי תצורה במקום הערך הזה
בשימוש. אחרת זה יהיה (YYCTYPE) ושינויים בתצורה זו אינם
יותר אפשרי. כאשר הגדרה זו היא מחרוזת יש לציין את הסוגרים. עַכשָׁיו
בהנחה שהקלט שלך הוא א char * buffer ואתה משתמש במתגים שהוזכרו לעיל
אתה יכול להגדיר YYCTYPE ל לא חתום char והגדרה זו ל-1 או (לא חתום
לְהַשְׁחִיר).

re2c:define:YYCONDTYPE = YYCONDTYPE ;
ספירה המשמשת לתמיכה במצב עם -c מצב.

re2c:define:YYCTXMARKER = YYCTXMARKER ;
מאפשר להחליף את ההגדרה YYCTXMARKER ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:define:YYCTYPE = YYCTYPE ;
מאפשר להחליף את ההגדרה YYCTYPE ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:define:YYCURSOR = YYCURSOR ;
מאפשר להחליף את ההגדרה YYCURSOR ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:define:YYDEBUG = YYDEBUG ;
מאפשר להחליף את ההגדרה YYDEBUG ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:define:YYGETCONDITION = YYGETCONDITION ;
החלפה עבור YYGETCONDITION. שים לב שכברירת מחדל re2c מייצר פלטה לאחר
YYGETCONDITION. הגדר re2c:define:YYGETCONDITION:עירום ללא אפס כדי להשמיט סוגרים.

re2c:define:YYGETCONDITION:עירום = 0;
שולט על הפלטה לאחר YYGETCONDITION. אם אפס, סוגרים מושמטים. אם לא אפס,
נוצרים פלטה.

re2c:define:YYSETCONDITION = YYSETCONDITION ;
החלפה עבור YYSETCONDITION. שים לב שכברירת מחדל re2c מייצר טיעון ב
פלטה ונקודה-פסיק אחרי YYSETCONDITION. אם אתה צריך לעשות YYSETCONDITION an
הצהרה שרירותית ולא קריאה, קבע re2c:define:YYSETCONDITION:עירום ל
לא אפס ושימוש re2c:define:YYSETCONDITION@cond כדי לציין פרמטר פורמלי בפנים
of YYSETCONDITION הגוף.

re2c:define:YYSETCONDITION@cond = @@ ;
כל התרחשות של טקסט זה בתוך YYSETCONDITION יוחלף ב-
טיעון ממשי.

re2c:define:YYSETCONDITION:עירום = 0;
שולט על ארגומנט בסוגריים ופסיקים אחרי YYSETCONDITION. אם אפס, שניהם
אגרומנט ונקודה-פסיק נשמטים. אם אינו אפס, גם הארגומנט וגם נקודה-פסיק
נוצר.

re2c:define:YYGETSTATE = YYGETSTATE ;
החלפה עבור YYGETSTATE. שים לב שכברירת מחדל re2c מייצר פלטה לאחר
YYGETSTATE. הגדר re2c:define:YYGETSTATE:עירום ללא אפס כדי להשמיט סוגרים.

re2c:define:YYGETSTATE:עירום = 0;
שולט על הפלטה לאחר YYGETSTATE. אם אפס, סוגרים מושמטים. אם לא אפס, פלטה
נוצרים.

re2c:define:YYSETSTATE = YYSETSTATE ;
החלפה עבור YYSETSTATE. שים לב שכברירת מחדל re2c יוצר טיעון בסוגריים
ונקודה-פסיק אחרי YYSETSTATE. אם אתה צריך לעשות YYSETSTATE שרירותי
הצהרה במקום שיחה, קבע re2c:define:YYSETSTATE:עירום ללא אפס ולהשתמש
re2c:define:YYSETSTATE@cond לציון פרמטר פורמלי בתוך YYSETSTATE הגוף.

re2c:define:YYSETSTATE@state = @@ ;
כל התרחשות של טקסט זה בתוך YYSETSTATE יוחלף בממשי
ויכוח.

re2c:define:YYSETSTATE:עירום = 0;
שולט על ארגומנט בסוגריים ופסיקים אחרי YYSETSTATE. אם אפס, שניהם עגמת נפש
ונקודה-פסיק מושמטים. אם אינו אפס, נוצרים גם ארגומנט וגם נקודה-פסיק.

re2c:define:YYLIMIT = YYLIMIT ;
מאפשר להחליף את ההגדרה YYLIMIT ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:define:YYMARKER = YYMARKER ;
מאפשר להחליף את ההגדרה YYMARKER ובכך להימנע מכך על ידי הגדרת ה
ערך לקוד הדרוש בפועל.

re2c:label:yyFillLabel = yyFillLabel ;
מאפשר להחליף את שם התווית yyFillLabel.

re2c:label:yyNext = yyNext ;
מאפשר להחליף את שם התווית yyNext.

re2c:variable:yyaccept = yyaccept;
מאפשר להחליף את שם המשתנה יאקבל.

re2c:variable:yybm = yybm ;
מאפשר להחליף את שם המשתנה yybm.

re2c:variable:yych = yych ;
מאפשר להחליף את שם המשתנה yych.

re2c:variable:yyctable = yyctable ;
כאשר שניהם -c ו -g פעילים אז re2c משתמש במשתנה זה כדי ליצור סטטי
קפיצה שולחן עבור YYGETCONDITION.

re2c:variable:yystable = yystable ;
הוצא משימוש.

re2c:variable:yytarget = yytarget ;
מאפשר להחליף את שם המשתנה yytarget.

רגיל ביטויים
"פו" מחרוזת מילולית "פו". ניתן להשתמש ברצפי בריחה של ANSI-C.

'פו' מחרוזת מילולית "פו" (תווים [a-zA-Z] מטופלים ללא רגישות רישיות). בריחה ANSI-C
ניתן להשתמש ברצפים.

[xyz] כיתת אופי; במקרה זה, הביטוי הרגולרי תואם גם x, y, או z.

[abj-oZ]
מחלקת תווים עם טווח בתוכה; התאמות a, b, כל מכתב מ j דרך o or Z.

[^כיתה]
כיתת תווים הפוכה.

r \ s להתאים לכל r שלא s. r ו s חייב להיות ביטויים רגולריים שיכולים להיות
מתבטא כשיעורי אופי.

r* אפס או יותר מופעים של r.

r+ מופע אחד או יותר של r.

r? אופציונלי r.

(R) r; סוגריים משמשים כדי לעקוף את הבכורה.

r s r אחריו s (שִׁרשׁוּר).

r | s או r or s (חֲלוּפָה).

r / s r אבל רק אם אחריו s. שים לב ש s אינו חלק מהטקסט המותאם.
סוג זה של ביטוי רגולרי נקרא "הקשר נגרר". הקשר נגרר יכול
להיות רק סוף של כלל ולא חלק מהגדרה בעלת שם.

r{n} גפרורים r בדיוק n פעמים.

r{n,} גפרורים r לפחות n פעמים.

r{n,m} גפרורים r לפחות n פעמים, אך לא יותר מ m פעמים.

. להתאים לכל דמות מלבד קו חדש.

שם תואם הגדרה בשם כפי שצוינה על ידי שם רק אם -F כבוי. אם -F הוא פעיל
ואז זה מתנהג כאילו הוא היה מוקף במירכאות כפולות ותואם את המחרוזת
"שֵׁם".

מחלקות תווים ומילולי מחרוזת עשויים להכיל תו אוקטלי או הקסדצימלי
הגדרות והקבוצה הבאה של רצפי בריחה: \a, \b, \f, \n, \r, \t, \v, \\.
תו אוקטלי מוגדר על ידי קו נטוי אחורי ואחריו שלוש הספרות האוקטליות שלו (למשל \ 377).
תווים הקסדצימליים מ-0 עד 0xFF מוגדרים באמצעות קו נטוי אחורי, אותיות קטנות x ושתיים
ספרות הקסדצימליות (למשל \ x12). תווים הקסדצימליים מ-0x100 עד 0xFFFF מוגדרים על ידי
נטוי אחורי, אותיות קטנות \u או מארז עליון \X וארבע ספרות הקסדצימליות (למשל
\ u1234). תווים הקסדצימליים מ-0x10000 עד 0xFFFFffff מוגדרים על ידי קו נטוי אחורי,
מארז עליון \U ושמונה ספרות הקסדצימליות (למשל \U12345678).

כלל "כל" הנייד היחיד הוא כלל ברירת המחדל *.

סורק עִם ניתן לאחסון מדינות

כאשר -f דגל מצוין, re2c יוצר סורק שיכול לאחסן את מצבו הנוכחי,
לחזור אל המתקשר, ובהמשך לחדש את הפעולות בדיוק מהמקום שבו הפסיקה.

פעולת ברירת המחדל של re2c הוא דגם "משיכה", שבו הסורק מבקש קלט נוסף
בכל פעם שהוא צריך את זה. עם זאת, מצב פעולה זה מניח שהסורק הוא
"בעלים" של לולאת הניתוח, וזה אולי לא תמיד נוח.

בדרך כלל, אם יש מעבד מקדים לפני הסורק בזרם, או בשביל זה
לא משנה כל מקור פרוצדורלי אחר של נתונים, הסורק אינו יכול "לבקש" נתונים נוספים אלא אם כן
גם הסורק וגם המקור חיים בשרשור נפרד.

השמיים -f הדגל שימושי בדיוק למצב הזה: הוא מאפשר למשתמשים לעצב סורקים שפועלים
מודל "דחיפה", כלומר שבו נתונים מוזנים לסורק נתח אחר נתח. כאשר הסורק
נגמרים הנתונים לצרוך, הוא פשוט מאחסן את מצבו וחוזר למתקשר. מתי יותר
נתוני קלט מוזנים לסורק, הוא ממשיך לפעול בדיוק מהמקום בו הפסיק.

שינויים נדרשים בהשוואה למודל ה"משיכה":

· על המשתמש לספק פקודות מאקרו YYSETSTATE () ו YYGETSTATE (מדינה).

· -f אפשרות מעכבת הכרזה על yych ו יאקבל. אז המשתמש צריך להצהיר
אלה. כמו כן המשתמש צריך לשמור ולשחזר את אלה. בדוגמה
examples/push_model/push.re אלה מוכרזים כשדות מהמחלקה (C++) שבה ה-
סורק היא שיטה, ולכן אין צורך לשמור/לשחזר אותם במפורש. עבור C הם
ניתן למשל ליצור פקודות מאקרו שבוחרות שדות ממבנה המועבר כפרמטר.
לחלופין, ניתן להכריז עליהם כמשתנים מקומיים, לשמור עם YYFILL (n) כשזה
מחליט לחזור ולשחזר בכניסה לפונקציה. כמו כן, זה יכול להיות יותר
יעיל להציל את המדינה ממנה YYFILL (n) כי YYSETSTATE (מדינה) נקרא
ללא תנאים. YYFILL (n) אולם אינו מקבל היו כפרמטר, כך היינו צריכים
לאחסן מצב במשתנה מקומי על ידי YYSETSTATE (מדינה).

· שנה YYFILL (n) לחזור (מהפונקציה שקוראת לזה) אם יש צורך בקלט נוסף.

· שנה את המתקשר כדי לזהות אם יש צורך בקלט נוסף ולהגיב כראוי.

· הקוד שנוצר יכיל בלוק מתג המשמש לשחזור המצב האחרון
על ידי קפיצה מאחורי הגוון YYFILL (n) שִׂיחָה. קוד זה נוצר באופן אוטומטי
באפילוג של הראשון /*!re2c */ לַחסוֹם. אפשר להפעיל יצירת
YYGETSTATE () חסום מוקדם יותר על ידי הצבת א /*!getstate:re2c*/ תגובה. זה במיוחד
שימושי כאשר יש לעטוף את קוד הסורק בתוך לולאה.

עיין examples/push_model/push.re עבור סורק דגם "דחיפה". הקוד שנוצר יכול להיות
כוונון באמצעות תצורות במקום מצב: הפלה ו state:nextlabel.

סורק עִם מַצָב תמיכה

אתה יכול להקדים לביטויים רגולריים רשימה של שמות תנאים בעת שימוש ב- -c
החלף. במקרה הזה re2c יוצר בלוקים של סורק עבור כל מצב. איפה כל אחד מה
לבלוקים שנוצרו יש תנאי מוקדם משלו. התנאי המוקדם ניתן על ידי הממשק
לְהַגדִיר YYGETCONDITON() וחייב להיות מסוג YYCONDTYPE.

ישנם שני סוגי כללים מיוחדים. ראשית, כללי התנאי <*> מתמזגים לכולם
תנאים (שים לב שיש להם עדיפות נמוכה יותר מכללים אחרים של תנאי זה). ו
שנית, רשימת התנאים הריקה מאפשרת לספק בלוק קוד שאין לו a
חלק סורק. כלומר זה לא מאפשר שום ביטוי רגולרי. ערך התנאי
ההתייחסות לבלוק המיוחד הזה הוא תמיד זה עם ערך הספירה 0. בדרך זו
ניתן להשתמש בקוד של כלל מיוחד זה כדי לאתחל סורק. זה בשום אופן לא
הכרחי שיהיו את הכללים האלה: אבל לפעמים זה מועיל להיות מסור
מצב מצב לא מאותחל.

כללים לא ריקים מאפשרים לציין את התנאי החדש, מה שהופך אותם לכללי מעבר.
מלבד יצירת קריאות להגדרה YYSETCONDTITION אין קוד מיוחד אחר
נוצר.

יש עוד סוג של כללים מיוחדים שמאפשרים לחבר קוד לכל בלוק קוד של
כל הכללים של קבוצה מסוימת של תנאים או לכל בלוקי הקוד לכל הכללים. זה יכול להיות
מועיל כאשר פעולה כלשהי נפוצה בין הכללים. למשל זה יכול לשמש לאחסון
אורך המחרוזת הסרוקה. כללי ההגדרה המיוחדים האלה מתחילים בסימן קריאה
ואחריו רשימה של תנאים <! מַצָב, ... > או כוכב . כאשר re2c
יוצר את הקוד לכלל שבמצב שלו אין כלל הגדרה והגדרה עם כוכב
הכלל קיים, אז הקוד הזה ישמש כקוד הגדרה.

קידודים

re2c תומך בקידוד הבא: ASCII (ברירת מחדל), EBCDIC (-e), UCS-2 (-w), UTF-16
(-x), UTF-32 (-u) ו-UTF-8 (-8). ראה גם תצורה במקום re2c:flags.

יש להבהיר את המושגים הבאים כאשר מדברים על קידוד. נקודת קוד היא an
מספר מופשט, המייצג סמל קידוד יחיד. יחידת קוד היא היחידה הקטנה ביותר
של זיכרון, המשמש בטקסט המקודד (זה מתאים לתו אחד בקלט
זרם). ניתן להזדקק ליחידת קוד אחת או יותר כדי לייצג נקודת קוד בודדת, בהתאם
על הקידוד. בקידוד באורך קבוע, כל נקודת קוד מיוצגת בשווה
מספר יחידות קוד. בקידוד באורך משתנה, נקודות קוד שונות יכולות להיות
מיוצג עם מספר שונה של יחידות קוד.

ASCII הוא קידוד באורך קבוע. מרחב הקוד שלו כולל 0x100 נקודות קוד, מ-0 עד
0xFF. נקודת קוד אחת מיוצגת בדיוק עם יחידת קוד אחת בת 1, שיש לה
אותו ערך כמו נקודת הקוד. מידה של YYCTYPE חייב להיות 1 בייט.

EBCDIC הוא קידוד באורך קבוע. מרחב הקוד שלו כולל 0x100 נקודות קוד, מ-0 עד
0xFF. נקודת קוד אחת מיוצגת בדיוק עם יחידת קוד אחת בת 1, שיש לה
אותו ערך כמו נקודת הקוד. מידה של YYCTYPE חייב להיות 1 בייט.

UCS-2 הוא קידוד באורך קבוע. מרחב הקוד שלו כולל 0x10000 נקודות קוד, מ-0 עד
0xFFFF. נקודת קוד אחת מיוצגת בדיוק עם יחידת קוד אחת של 2 בתים, שיש לה
אותו ערך כמו נקודת הקוד. מידה של YYCTYPE חייב להיות 2 בתים.

UTF-16 הוא קידוד באורך משתנה. מרחב הקוד שלו כולל את כל נקודות הקוד של Unicode,
מ-0 ל-0xD7FF ומ-0xE000 ל-0x10FFFF. נקודת קוד אחת מיוצגת עם
יחידת קוד אחת או שתיים של 2 בתים. מידה של YYCTYPE חייב להיות 2 בתים.

UTF-32 הוא קידוד באורך קבוע. מרחב הקוד שלו כולל את כל נקודות הקוד של Unicode, מ-0
ל-0xD7FF ומ-0xE000 ל-0x10FFFF. נקודת קוד אחת מיוצגת עם בדיוק
יחידת קוד אחת של 4 בתים. מידה של YYCTYPE חייב להיות 4 בתים.

UTF-8 הוא קידוד באורך משתנה. מרחב הקוד שלו כולל את כל נקודות הקוד של Unicode,
מ-0 ל-0xD7FF ומ-0xE000 ל-0x10FFFF. נקודת קוד אחת מיוצגת עם
רצף של אחד, שניים, שלוש או ארבע יחידות קוד של 1 בייט. מידה של YYCTYPE חייב להיות בן 1
בייט.

ב-Unicode, ערכים מטווח 0xD800 עד 0xDFFF (פונדקאות) אינם קוד Unicode חוקי
נקודות, כל רצף מקודד של יחידות קוד, שתמפה לנקודות קוד Unicode ב-
טווח 0xD800-0xDFFF, אינו בנוי. המשתמש יכול לשלוט כיצד re2c מתייחס בצורה גרועה כזו
רצפים עם --קידוד-מדיניות דגל (ראה אפשרויות להסבר מלא).

עבור קידודים מסוימים, יש יחידות קוד, שלעולם לא מופיעות בזרם מקודד חוקי (למשל
0xFF בייט ב-UTF-8). אם הסורק שנוצר חייב לבדוק אם יש קלט לא חוקי, הדבר האמיתי היחיד
הדרך לעשות זאת היא להשתמש בכלל ברירת המחדל *. שימו לב, כלל הטווח המלא הזה [^] לא יתפוס פסול
יחידות קוד כאשר נעשה שימוש בקידוד באורך משתנה ([^] פירושו "כל נקודות הקוד התקפות", בעוד
כלל ברירת מחדל * פירושו "כל יחידות הקוד האפשריות").

גנרית קלט API

re2c פועל בדרך כלל על קלט באמצעות פרימיטיבים דמויי מצביע YYCURSOR, YYMARKER,
YYCTXMARKER ו YYLIMIT.

API לקלט כללי (מופעל עם --קֶלֶט מנהג מתג) מאפשר להתאים אישית את הקלט
פעולות. במצב זה, re2c יביע את כל הפעולות על קלט במונחים של
הפרימיטיבים הבאים:

┌────────────────┬──────────────────────────────── ──┐
│YYPEEK () │ קבל תו קלט נוכחי │
├────────────────┼──────────────────────────────── ──┤
│YYSKIP () │ התקדמו לדמות הבאה │
├────────────────┼──────────────────────────────── ──┤
│YYBACKUP () │ מיקום קלט זרם גיבוי │
├────────────────┼──────────────────────────────── ──┤
│YYBACKUPCTX () │ מיקום קלט זרם גיבוי │
│ │ להקשר נגרר │
├────────────────┼──────────────────────────────── ──┤
│YYRESTORE () │ שחזור מיקום הקלט הנוכחי │
├────────────────┼──────────────────────────────── ──┤
│YYRESTORECTX () │ שחזור מיקום הקלט הנוכחי │
│ │ להקשר נגרר │
├────────────────┼──────────────────────────────── ──┤
│YYLESSTHAN (n) │ בדוק אם פחות מ n קלט │
נותרו │ │ תווים │
└────────────────┴──────────────────────────────── ──┘

כמה קישורים שימושיים המספקים כמה דוגמאות:

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

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

השתמש ב-re2c באינטרנט באמצעות שירותי onworks.net