ניתוח תחבירי (Parsing) - המשך

שיפורים לאלגוריתם LR(0)

תזכורת: אלגוריתם LR(k) bottom-up, מבוסס טבלאות, סורק את הקלט משמאל (L) לימין, מניב את הגזירה הימנית (R) ביותר, וזקוק ל-lookahead בגודל k. המקרה הפשוט ביותר הוא אלגוריתם LR(0).

אלגוריתם LR(0) קלט טבלת פעולות Parser מחסנית טבלת goto פלט

דקדוק פשוט לדוגמא... נשתמש בדקדוק הבא לצורך הדגמה: E → 1 E E → 1 מורחב וממוספר: (0) S → E (1) E → 1 E (2) E → 1

מכונת המצבים מצב 0 (התחלתי) מצב 1 clos({S → ∙ E}) = clos({E → 1 ∙ E, 1 מצב 2 clos({S → E ∙}) = {S → E ∙} E $ 1 2 3 מצב 3 clos({E → 1 E ∙}) = {E → 1 E ∙}

בניית טבלאות action ו-goto מתחילים מטבלת המעברים...

בניית טבלאות action ו-goto מתחילים מטבלת המעברים. מוסיפים acc במקום המתאים... goto פעולות E $ 1 2 3

בניית טבלאות action ו-goto מתחילים מטבלת המעברים. מוסיפים acc במקום המתאים. כל מעבר על-סמך אסימון הופך לפעולת shift... goto פעולות E $ 1 2 3 acc

בניית טבלאות action ו-goto מתחילים מטבלת המעברים. מוסיפים acc במקום המתאים. כל מעבר על-סמך אסימון הופך לפעולת shift. לכל מצב עם פריט A → α ∙, מוסיפים reduce מתאים לכל השורה... goto פעולות E $ 1 2 s1 3 acc

בניית טבלאות action ו-goto מתחילים מטבלת המעברים. מוסיפים acc במקום המתאים. כל מעבר על-סמך אסימון הופך לפעולת shift. לכל מצב עם פריט A→α∙ מוסיפים reduce מתאים לכל השורה. מזהים קונפליקט. goto פעולות E $ 1 2 s1 3 r2 r2/s1 acc r1

ממה נובע הקונפליקט? הקונפליקט קיים כשהמכונה במצב 1 וקיים האסימון 1 בקלט. מצב 1 כולל את הפריטים: E → 1 ∙ E, E → 1 ∙, E → ∙ 1 E, E → ∙ 1 אם במצב 1 רואים אסימון 1 בקלט, מבצעים shift ומתקדמים עם הפריטים E→∙1E, E→∙1 למצב הכולל פריטים E→1∙,E→1∙E. זהו בעצם חזרה למצב 1. לא, רגע. בלי שום קשר לקלט, כשאנחנו במצב 1, מבצעים reduce לכלל הגזירה E → 1 בגלל הפריט E→1∙.

LR(0) לא יכול להכריע בין שני המצבים. אבל לנו די פשוט לקבל החלטה: אחרי E לא יכול לבוא האסימון 1. במילים אחרות: 1 ∉ follow(E). לכן, אם יש 1 בהמשך הקלט, ברור שלא צריך לגזור E. במילים אחרות, מבצעים shift ולא reduce.

תיקון פשוט ל-LR(0) נתקן את LR(0) כך: צעד ה-reduce המקורי בבניית הטבלה: לכל מצב עם פריט ∙A → α , מוסיפים reduce מתאים לכל השורה. הופך להיות: לכל מצב עם פריט ∙A → α , מוסיפים reduce מתאים בשורה זו, לכל עמודה שהאסימון שבראשה שייך ל-follow(A).

האלגוריתם המשופר נקרא Simple LR(1) בקיצור: SLR(1), ועוד יותר בקיצור: SLR. יכול לזהות יותר שפות מ-LR(0) ללא קונפליקטים. ... אבל עדיין לא מספיק חזק עבור מרבית שפות התכנות.

עוד דוגמא נתבונן בדקדוק (החד-משמעי) הבא: (0) S’ → S (1) S → L = R (2) S → R (3) L → * R (4) L → id (5) R → L (ניתן לחשוב עליו כעל דקדוק להשמות בשפת C, כאשר L ו-R הם l-value ו-r-value, בהתאמה. הוסיפו R→EXPR להשלמת התמונה).

מכונת המצבים מצב 3 S → R ∙ R מצב 0 S’ → ∙ S S → ∙ L = R S → ∙ R L → ∙ id R → ∙ L S מצב 9 S → L = R ∙ מצב 1 S’ → S ∙ L מצב 2 S → L ∙ = R R → L ∙ = R * id מצב 5 L → id ∙ מצב 6 S → L = ∙ R R → ∙ L L → ∙ * R L → ∙ id מצב 4 L → * ∙ R R → ∙ L L → ∙ * R L → ∙ id * R * id L L id מצב 7 L → * R ∙ מצב 8 R → L ∙

אם יש = בקלט, ניתן לבצע shift 6. הקונפליקט מצב 2 S → L ∙ = R R → L ∙ נתבונן במצב 2: אם יש = בקלט, ניתן לבצע shift 6. לעבור מפריט S → L ∙ = R לפריט S → L = ∙ R. אבל ניתן גם לבצע reduce לפי כלל גזירה 5: R → L. קונפליקט shift/reduce. האסימון = נמצא ב-follow(R) (לאור S → L = R → * R = R ), ולכן הקונפליקט קיים גם ב-SLR(1). = מצב 6

איך מתגברים על הקונפליקט? הבעיה היא ש-SLR מתייחס ל-follow האפשרי המשתנה שיתקבל לאחר ה-reduce בלבד, ומתעלם משאר המחסנית. אם בראש המחסנית נמצא הסמל α, וקיים כלל A→α, SLR בודק את follow(A) מול האסימון שבקלט. ("ראש המחסנית" בדיון זה מתייחס לסמלים שבמחסנית ומתעלם מהמצבים שבה). אבל אולי בהמשך המחסנית, מעבר ל-α, נמצאים סמלים שעומדים בסתירה לאסימון שבקלט? למשל, אם שני הסמלים שבראש המחסנית הם βα, ואסימון הקלט לא שייך ל-follow(βA)? follow(βA)  follow(A)

איך מתגברים על הקונפליקט? בדוגמא שלנו, אפשר להגיע למצב 2 רק ישירות ממצב 0: כלומר ההקשר לביצוע reduce לפי R→L במצב 2, הוא הגזירות S → R → L; מכאן שנצפה לראות $ בקלט, לא =. )אין תבנית המתחילה ב- ... = R; אם נבצע reduce נתקע עם =.) זאת בהשוואה לביצוע reduce לפי R→L במצב 8, הנובע מהגזירות S → L = R →…, שאז נצפה גם ל-$ וגם ל- =. מצב 0 מצב 2 S → L ∙ = R R → L ∙ L

אלגוריתם Canonical LR (CLR) הרעיון: לפרק את המצבים של LR(0) למצבים "עדינים" יותר, המכילים גם lookahead. לשם כך נגדיר מהו פריט LR(1), ונגדיר את פונקצית הסגור עבור פריטי LR(1). מעבר לכך, שאר האלגוריתם נותר ללא שינוי.

פריט LR(1) הגדרה: פריט LR(1) מורכב מזוג סדור: פריט LR(0) ואסימון (או סימן סוף הקלט, $). מכלל גזירה עם n רכיבים מצד ימין, בדקדוק בו קיימים t אסימונים, ניתן לקבל (n+1)·(t+1) פריטי LR(1). למשל מהכלל L → id מהדקדוק הקודם נקבל 8 פריטי LR(1): [L → ∙ id, *] [L → ∙ id, =] [L → ∙ id, id] [L → ∙ id, $] [L → id ∙, *] [L → id ∙, =] [L → id ∙, id] [L → id ∙, $]

מה משמעותו של פריט LR(1)? גם הפעם, פריט מסמל את מצבו של ה-parser. משמעותו: זיהינו את מה שנמצא משמאל לנקודה; אנו מצפים כעת למצוא את מה שנמצא מימין לה, ולאחר מכאן את האסימון המצורף לפריט. למשל, הפריט: [S→ L ∙ = R, id] פירושו: פגשנו L, אנו מצפים ל- = ולאחר מכן ל- R (כלומר, סדרה הנגזרת מ-R), ואח"כ ל- id.

סגור של פריטי LR(1) הגדרה: קבוצת הסגור של קבוצת פריטי LR(1): קבוצת פריטי LR(1) שבה, עבור כל פריט LR(1) מהצורה [A → α∙Bβ , a] בקבוצת הסגור, ועבור כל כלל מהצורה B→δ וכל אסימון b בדקדוק (כולל $), כך ש- b  FIRST(βa) , גם הפריט [B → ∙δ , b] נמצא בקבוצת הסגור. המצב הראשון מתקבל מסגור של הפריט [S’→ ∙S , $]

בניית הטבלאות כמו ב-SLR, מתחילים מטבלת המעברים של האוטומט. הופכים כל מעבר בעמודה של אסימון לפעולת shift. עמודות המשתנים הן טבלת ה-goto. ה-acc מושם בעמודת $, בשורה של כללים המכילים את הפריט [S’ → S∙, $]. עבור כל מצב המכיל פריט מהצורה [A → α∙,a], וכלל A→α שמספרו m (m>0), שמים reduce m בשורה של מצב זה, בעמודה של אסימון a.

למשל, עבור דקדוק הדוגמא שלנו... טבלת goto טבלת הפעולות L R S $ = * id 2 3 1 s4 s5 acc r5 s6 r2 8 7 4 r4 5 9 12 s10 s11 6 r3 13 10 11 r1

מדוע יש יותר מצבים ב-CLR לעומת SLR? איך נראה CLR(k) עבור k>1? כדאי להבין... מדוע יש יותר מצבים ב-CLR לעומת SLR? איך נראה CLR(k) עבור k>1? האם כל דקדוק חד-משמעי חסר-הקשר ניתן לניתוח ע"י מנתח CLR(k)?