איתן אביאור תורת הקומפילציה 1 ניתוח התחביר lexical analyser מנתח לקסיקאלי syntax analyser מנתח תחביר ניתוח )analysis( semantic analyser מנתח משמעות מייצר קוד ביניים intermediate code generator code optimizer code generator תורת הקומפילציה מייעל קוד מייצר.

Download Report

Transcript איתן אביאור תורת הקומפילציה 1 ניתוח התחביר lexical analyser מנתח לקסיקאלי syntax analyser מנתח תחביר ניתוח )analysis( semantic analyser מנתח משמעות מייצר קוד ביניים intermediate code generator code optimizer code generator תורת הקומפילציה מייעל קוד מייצר.

Slide 1

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪1‬‬


Slide 2

‫ניתוח התחביר‬
lexical analyser

‫מנתח לקסיקאלי‬

syntax analyser

‫מנתח תחביר‬

‫ניתוח‬
)analysis(

semantic analyser ‫מנתח משמעות‬

‫מייצר קוד ביניים‬
intermediate code generator
code optimizer
code generator
2

‫תורת הקומפילציה‬

‫מייעל קוד‬
‫מייצר קוד‬

‫חיבור‬
)synthesis(
‫איתן אביאור‬


Slide 3

‫תחביר (‪ )Syntax‬של שפות מחשב‬
‫נוח לתאר את התחביר של שפת מחשב בעזרת דקדוק חסר הקשר‬
‫• דקדוק נותן מפרט תחבירי מדויק וקל להבנה של השפה‬
‫• מתוך דקדוקים בעלי תכונות מסוימות ניתן לבנות באופן אוטומטי‬
‫פורסים יעילים‬
‫– בתהליך הבניה ניתן לגלות מצבים של רב‪-‬משמעות תחבירית‬
‫• דקדוק מתוכנן היטב מאפשר כתיבת תוכניות בעלות מבנה טוב‬
‫המאפשר תרגומן לקוד מכונה נכון ויעיל‬
‫• דקדוק מסודר מאפשר לעדכן את הגדרת השפה עם הזמן באופן‬
‫נוח‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪3‬‬


Slide 4

‫היררכיה בהגדרת התחביר של שפה‬
‫• הגדרת תמניות באמצעות ביטויים רגולרים ע"מ לפשט את‬
‫הגדרת השפה ובנית המהדר‬
‫• הגדרת התחביר באמצעות דקדוק חסר הקשר‬
‫• הוספת כללים שאינם ניתנים להבעה ע"י דקדוק חסר הקשר‬
‫כגון‪" :‬אין להשתמש במזהה לפני שהוצהר עליו"‬
‫או הצורך בהתאמה בין הארגומנטים והפרמטרים של פונקציה‬
‫(ראה דיון ב‪ ASU-‬עמ' ‪)179−181‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪4‬‬


Slide 5

‫ניתוח התחביר ─ מטרה‬
‫‪ .1‬קבלת זרם התמניות מהמנתח הלקסיקאלי‬
‫‪ .2‬ניתוח זרם התמניות ע"פ כללי הגזירה ויצירת עץ הפריסה‬
‫‪ .3‬מציאת שגיאות תחביר והיחלצות מהן‬

‫‪ .4‬עדכון טבלת הסמלים‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪5‬‬


Slide 6

‫ניתוח החיבור ─ השיטה‬
‫• תיאור הפסוקים בשפה באמצעות דקדוק חסר הקשר‬
‫• ניתוח זרם התמניות ע"י הפעלת אלגוריתמים לפריסה‬
‫‪stmt  if ( expr ) stmt‬‬
‫‪| if ( expr ) stmt else stmt‬‬
‫‪| while ( expr ) stmt‬‬

‫‪stmt‬‬
‫‪stmt‬‬
‫‪expr‬‬
‫‪args‬‬

‫;)(‪if (id relop num) id‬‬

‫איתן אביאור‬

‫מנתח התחביר‬

‫תורת הקומפילציה‬

‫‪expr‬‬

‫; ) ( ‪if ( id relop num ) id‬‬

‫‪6‬‬


Slide 7

‫יחס גומלין של מנתח התחביר‬
‫קוד‬
‫ביניים‬

‫שאר חלקי עץ הפריסה מנתח‬
‫תחביר‬
‫הצד הקדמי‬

‫תמנית‬
‫דרישה לתמנית‬
‫הבאה‬

‫מנתח‬
‫לקסיקאלי‬

‫תוכנית‬
‫המקור‬

‫טבלת‬
‫סמלים‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪7‬‬


Slide 8

‫שיטות לביצוע פריסה‬
‫• קיימות שיטות לפריסה אוניברסלית של כל דקדוק נתון‬
‫– אינן יעילות לבנית מהדרים בפועל‬
‫• קיימות שיטות לפריסה של דקדוקים בעלי תכונות מיוחדות‬
‫– פריסה מלמעלה למטה (‪)top-down‬‬
‫• למשל עבור דקדוקי ‪LL‬‬
‫• שימושית לבניה ידנית של פורס‬
‫– פריסה מלמטה למעלה (‪)bottom-up‬‬
‫• למשל עבור דקדוקי ‪LR‬‬
‫• שימושית לבניה אוטומטית של פורס‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪8‬‬


Slide 9

‫משימות נוספות המתבצעות‬
‫תוך כדי הפריסה‬
‫הפורס‬
‫• מפעיל את הסורק ע"מ לייצר עבורו את זרם התמניות‬
‫• מפעיל את "שאר חלקי הצד הקדמי"‬

‫– ניתוח המשמעות‬
‫– עדכון טבלת הסמלים‬
‫– יצירת קוד ביניים‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪9‬‬


Slide 10

‫טיפול בשגיאות‬
‫• סוגי השגיאות‬
‫• יעדי מטפל השגיאות‬
‫• שיטות לטיפול בשגיאות‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪10‬‬


Slide 11

‫סוגי שגיאות‬
‫•‬
‫•‬
‫•‬
‫•‬

‫לקסיקאליות ─ למשל‪ :‬איות לא נכון של מזהה‪ ,‬מלת מפתח או אופרטור‬
‫תחביריות ─ למשל‪ :‬חוסר איזון של סוגריים בביטוי אריתמטי‬
‫משמעות ─ למשל‪ :‬אופרטור המופעל על אופרנד בלתי‪-‬מתאים‬
‫לוגיות ─ למשל‪ :‬רקורסיה אינסופית‬

‫חלק ניכר מהשגיאות המתגלות הן שגיאות תחביר‪:‬‬
‫• הרבה שגיאות הן אכן שגיאות תחביר‬
‫• ניתן לגלות בקלות שגיאות תחביר ואף לתקן חלק מהן‬
‫• קשה לגלות ולתקן שגיאות משמעות ושגיאות לוגיות‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪11‬‬


Slide 12

‫יעדי מטפל השגיאות‬
‫• דיווח על הימצאות שגיאה במקום מסוים בבירור ובדייקנות‬
‫• התאוששות מהשגיאה מהר ככל הניתן ע"מ לגלות שגיאות נוספות‬
‫• אסור שיאיט באופן משמעותי עיבוד של תוכניות נכונות‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪12‬‬


Slide 13

‫שיטות לטיפול בשגיאות‬
‫• מצב פניקה (‪)panic mode‬‬
‫• רמת הביטוי (‪)phrase level‬‬
‫• כללי גזירה לשגיאות (‪)error productions‬‬

‫• תיקון גלובלי (‪)global correction‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪13‬‬


Slide 14

‫התאוששות ממצב פניקה‬
‫(‪)Panic Mode Recovery‬‬
‫•‬
‫•‬

‫•‬
‫•‬

‫בעת שהפורס מגלה שגיאת תחביר הוא נכנס ל"מצב פניקה"‪,‬‬
‫ומדלג על כל התמניות עד שהוא מגיע לתמנית סינכרון‬
‫תמנית סינכרון (‪ ─ )synchronization token‬תמנית הבאה בסוף‬
‫מבנה (משפט‪ ,‬סדרת משפטים) והמציינת את סופו‬
‫;‬
‫דוגמאות‪ :‬נקודה‪-‬פסיק‬
‫סוגר מסולסל ימני {‬
‫‪end‬‬
‫מלת מפתח‬
‫שיטה טובה בהנחה שמשפט מכיל לרוב רק שגיאת תחביר אחת‬
‫מונעת כניסה ללולאה אינסופית של הפורס‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪14‬‬


Slide 15

‫התאוששות ברמת הביטוי‬
‫(‪)Phrase Level Recovery‬‬
‫בעת שהפורס מגלה שגיאה הוא מנסה לתקן אותה‬
‫ע"י החלפת הרישא של המשך הקלט במחרוזת אחרת‬
‫דוגמאות‪:‬‬

‫החלפת פסיק בנקודה‪-‬פסיק‬
‫מחיקת תו מיותר‬
‫הוספת סימן חסר‬

‫יש להיזהר לא להגיע למצב של לולאה אינסופית‬
‫(למשל אם הטיפול בשגיאה הוא תמיד הוספת תו לפני שאר הקלט)‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪15‬‬


Slide 16

‫התאוששות ע"י כללי גזירה לשגיאות‬
‫(‪)Error Production Recovery‬‬
‫• הדקדוק יכיל מראש כללי גזירה לשגיאות נפוצות‬
‫• בכללים האלה תשולבנה מראש הפעולות לביצוע‬
‫בעת גילוי שגיאות אלה‬
‫דוגמה‪:‬‬
‫‪stmt  if ( expr ) then stmt else stmt‬‬
‫שימוש בכלל הגזירה הזה מעיד על הימצאות ‪ then‬מיותר‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪16‬‬


Slide 17

‫תיקון גלובלי‬
‫(‪)Global Correction‬‬
‫מציאת התוכנית הנכונה הקרובה ביותר לתוכנית המקורית‬
‫• יש להגדיר מטריקה בין תוכניות‪,‬‬
‫למשל ע"י מספר השינויים הבסיסים שיש לבצע במעבר מתוכנית‬
‫לתוכנית‬
‫– שינוי בסיסי‪ :‬החלפת תו‪ ,‬מחיקת תו‪ ,‬הוספת תו‪ ,‬היפוך תווים‬
‫• טכניקה יקרה מאוד ליישום באופן גלובלי על כל התוכנית‬
‫• עשויה להיות שימושית כטכניקה מקומית בשיטת ההתאוששות‬
‫ברמת הביטוי‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪17‬‬


Slide 18

‫דקדוק (‪)Grammar‬‬
‫ושפה (‪)Language‬‬
‫‪G = T, N, P, S‬‬
‫‪ ─ G‬דקדוק (‪─ )grammar‬‬
‫האלף‪-‬בית‬
‫‪ ─ T‬קבוצת טרמינלים (‪─ )terminals‬‬
‫‪ ─ N‬קבוצת נונטרמינלים (‪T  N =  ─ )nonterminals‬‬
‫מהצורה ‪  ‬‬
‫‪ ─ P‬כללי גזירה (‪─ )productions‬‬
‫כאשר ‪ ‬ו‪ -‬הן מחרוזות של טרמינלים ו‪/‬או נונטרמינלים‪,‬‬
‫או ש‪ -‬הוא ‪( ε‬המסמן את המחרוזת הריקה)‬
‫‪SN‬‬
‫‪ ─ S‬סמל ההתחלה (‪─ )start symbol‬‬

‫)‪ ─ L(G‬שפה (‪ ─ )language‬אוסף כל המחרוזות מעל האלף‪-‬בית‬
‫הניתנות ליצור ע"י הדקדוק (בהמשך הגדרה יותר מדוייקת)‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪18‬‬


Slide 19

‫חוסר הקשר‬
‫(‪)Context Freedom‬‬
‫דקדוק חסר הקשר (‪― )context free grammar‬‬
‫דקדוק בו כל כללי הגזירה הם מהצורה ‪A  ‬‬
‫כאשר ‪ A‬הינו נונטרמינל יחיד (‪ ‬כמו קודם)‬
‫דקדוק חסר הקשר ניתן להכרה ע"י אוטומט מחסנית‬
‫שפה חסרת הקשר (‪― )context free language‬‬
‫שפה שעבורה קיים דקדוק חסר הקשר המייצר אותה‬

‫רוב המבנים של שפות התכנות הקיימות ניתנים לתיאור‬
‫באמצעות דקדוק חסר הקשר‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪19‬‬


Slide 20

‫פורס (‪)Parser‬‬
‫• כלי המנתח את תוכניות המקור ע"פ דקדוק השפה‬
‫• הטרמינלים ─ התמניות הנוצרות ע"י הסורק (‪)scanner‬‬
‫• הנונטרמינלים ─ משתנים המתארים צורות שונות של פסוקים‬
‫ומבנים בשפה‬
‫‪expr  expr op expr‬‬
‫דוגמה‪:‬‬
‫) ‪expr  ( expr‬‬
‫טרמינלים‪:‬‬
‫) ( ‪‬‬

‫‪/‬‬

‫‪‬‬

‫‪-‬‬

‫‪+‬‬

‫‪id‬‬

‫נונטרמינלים‪:‬‬
‫‪op‬‬
‫איתן אביאור‬

‫‪expr‬‬
‫תורת הקומפילציה‬

‫‪expr  - expr‬‬
‫‪expr  id‬‬
‫‪op  +‬‬
‫ ‪op ‬‬‫‪op  ‬‬
‫‪op  /‬‬
‫‪op  ‬‬

‫‪20‬‬


Slide 21

‫קונבנציות סימון‬
‫‪ (1‬טרמינלים‬
‫א‪ .‬אותיות קטנות מתחילת האלף‪-‬בית הלטיני‬
‫‪a b c ...‬‬

‫ב‪ .‬סמלי פעולה‬

‫‪+ -  / ...‬‬

‫ג‪ .‬סמלי פיסוק‬

‫‪( ) , ; ...‬‬

‫ד‪ .‬הספרות‬

‫‪0 1 ... 9‬‬

‫ה‪ .‬מחרוזות בגופן בולט‬

‫‪...‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪if‬‬

‫‪id‬‬

‫‪21‬‬


Slide 22

‫המשך סימון‬
‫‪(2‬‬
‫א‪.‬‬
‫ב‪.‬‬
‫ג‪.‬‬
‫‪(3‬‬
‫א‪.‬‬
‫ב‪.‬‬

‫ג‪.‬‬

‫נונטרמינלים‬
‫‪A B C ...‬‬
‫אותיות גדולות מתחילת האלף‪-‬בית הלטיני‬
‫‪S‬‬
‫האות ‪ S‬המסמנת את סמל ההתחלה‬
‫‪stmt expr op . . .‬‬
‫מחרוזות של אותיות קטנות נוטות‬
‫מטה‪-‬משתנים‬
‫‪X Y Z ...‬‬
‫אותיות גדולות מסוף האלף‪-‬בית הלטיני‬
‫מסמנות סמלי דקדוק (כלומר טרמינלים או נונטרמינלים)‬
‫‪u v ...z‬‬
‫אותיות קטנות מסוף האלף‪-‬בית הלטיני‬
‫מסמנות מחרוזות של טרמינלים‬
‫‪   ...‬‬
‫אותיות קטנות מתחילת האלף‪-‬בית היווני‬
‫מסמנות מחרוזות של סמלי דקדוק‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪22‬‬


Slide 23

‫המשך סימון‬
‫‪ (4‬אלטרנטיבה‬
‫הסימן | המשמש לקיצור‬
‫‪A  1 | 2 | . . . | k‬‬

‫‪A  1‬‬
‫‪A  2‬‬
‫‪...‬‬
‫‪A  k‬‬

‫‪ (5‬סמל ההתחלה‬
‫סמל ההתחלה הינו הצד השמאלי של כלל הגזירה הראשון‬
‫(אלא אם ציון אחרת)‬
‫דוגמה‬
‫‪E  E A E | ( E ) | - E | id‬‬
‫‪A  + | - |  | / | ‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪23‬‬


Slide 24

‫גזירה (‪)Derivation‬‬
‫סדרה של צעדים על מחרוזת המורכבת מטרמינלים ונונטרמינלים‬
‫בה בכל צעד מוחלף סמל ‪ X‬המופיע במחרוזת‬
‫בתת‪-‬מחרוזת ‪ ,‬תוך שימוש בכלל גזירה ‪X  ‬‬
‫‪ ‬צעד גזירה‬
‫נסמן‪:‬‬
‫‪‬‬
‫‪‬‬
‫סדרת צעדי גזירה‬
‫‪+‬‬
‫‪‬‬
‫סדרה לא ריקה של צעדי גזירה‬
‫דוגמה‪:‬‬
‫)‪-(E)  -(E A E)  -(E + E)  -(E + id)  -(id + id‬‬
‫)‪-(id + id‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪‬‬
‫‪‬‬
‫)‪-(E‬‬
‫‪24‬‬


Slide 25

‫שפה (‪)Language‬‬
‫•‬

‫•‬
‫•‬
‫•‬

‫•‬

‫שפה )‪ L(G‬הנוצרת ע"י דקדוק ‪ G‬היא אוסף כל המחרוזות של‬
‫טרמינלים הנגזרות מסמל ההתחלה של דקדוק‬
‫‪+‬‬
‫‪L(G) = { w | S ‬‬
‫}‪w‬‬
‫המחרוזת ‪ w‬נקראת משפט (‪ )sentence‬בשפה‬
‫דקדוקים שקולים (‪ ─ )equivalent‬שני דקדוקים המייצרים אותה‬
‫שפה‬
‫‪ ─ sentential‬מחרוזת ‪ ‬של סמלי דקדוק הנגזרת מסמל ההתחלה‬
‫‪‬‬
‫‪S‬‬
‫‪‬‬
‫משפט (‪ )sentence‬הוא ‪ sentential‬המורכב מטרמינלים בלבד‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪25‬‬


Slide 26

‫גזירה משמאל (‪)Leftmost‬‬
‫וגזירה מימין (‪)Rightmost‬‬
‫•‬

‫•‬

‫•‬

‫בכל צעד גזירה יש לקבל שתי החלטות‪:‬‬
‫‪ (1‬איזה נונטרמינל לגזור‬
‫‪ (2‬באיזה כלל גזירה (מבין כללי הגזירה של אותו נונטרמינל)‬
‫נשתמש‬
‫כאשר בשלב ‪ 1‬בוחרים את הנונטרמינל השמאלי ביותר במחרוזת‬
‫הגזירה נקראת גזירה שמאלית (‪ )leftmost‬ומסומנת ע"י ‪‬‬
‫‪lm‬‬
‫‪A: wA  w‬‬
‫) *‪( w  T‬‬
‫‪lm‬‬
‫כאשר בשלב ‪ 1‬בוחרים את הנונטרמינל הימני ביותר במחרוזת‬
‫הגזירה נקראת גזירה ימנית (‪ )rightmost‬ומסומנת ע"י ‪‬‬
‫‪rm‬‬
‫‪A: Au ‬‬
‫‪u‬‬
‫) *‪( u  T‬‬
‫‪rm‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪26‬‬


Slide 27

‫גזירה משמאל ומימין ─ המשך‬
‫‪‬‬

‫הסימון ‪   ‬מדגיש כי ‪ ‬נגזרת מ‪  -‬בסדרה של צעדי גזירה שמאליים‬
‫‪lm‬‬

‫‪‬‬

‫הסימון ‪   ‬מדגיש כי ‪ ‬נגזרת מ‪  -‬בסדרה של צעדי גזירה ימניים‬
‫‪rm‬‬

‫דוגמאות‪:‬‬

‫איתן אביאור‬

‫) ‪- ( id + E‬‬

‫‪‬‬

‫)‪-(E+E‬‬

‫) ‪- ( E + id‬‬

‫‪‬‬

‫)‪-(E+E‬‬

‫תורת הקומפילציה‬

‫‪lm‬‬

‫‪rm‬‬

‫‪27‬‬


Slide 28

‫גזירה ועץ פריסה‬
‫בנית עץ פריסה שקולה לגזירה‬
‫‪B‬‬
‫כלל הגזירה‪:‬‬
‫‪B  ‬‬
‫צעד הגזירה‪:‬‬
‫מתבטא בעץ‪ :‬ביצירת בנים לצומת המסומן ב‪B-‬‬
‫אם ‪   ε‬אזי מספר הבנים הוא באורך ‪ ‬והסדר שלהם הוא כסדרם ב‪ -‬‬
‫אם ‪  = ε‬נוצר בן יחיד המסומן ב‪ε-‬‬
‫עדכון‬
‫‪E‬‬
‫עץ הפריסה‪:‬‬

‫כלל הגזירה‪:‬‬
‫צעד הגזירה‪:‬‬
‫איתן אביאור‬

‫‪E+E‬‬

‫‪‬‬

‫‪E‬‬

‫‪−‬‬

‫)‬

‫‪E‬‬

‫(‬

‫‪E‬‬

‫‪+‬‬

‫‪E‬‬

‫‪E‬‬

‫)‪-(E)  -(E+E‬‬
‫תורת הקומפילציה‬

‫‪28‬‬


Slide 29

‫רב‪-‬משמעות (‪)Ambiguity‬‬
‫דקדוק רב‪-‬משמעי (‪─ )ambigous‬‬
‫דקדוק המייצר יותר מעץ פריסה יחיד למחרוזת כלשהי‬
‫הרב‪-‬משמעות עשויה לנבוע מהבחירה של צעד ‪( 1‬איזה נונטרמינל לגזור)‬
‫אבל גם אם מחליטים על גזירה שמאלית (או ימנית)‬
‫היא עשויה לנבוע מצעד ‪( 2‬באיזה כלל גזירה להשתמש)‬
‫דוגמה‪:‬‬
‫‪E E+E‬‬
‫‪E EE‬‬
‫‪ id + E‬‬
‫‪E+E E‬‬
‫‪ id + E  E‬‬
‫‪ id + E  E‬‬
‫‪ id + id  E‬‬
‫‪ id + id  E‬‬
‫‪ id + id  id‬‬
‫‪ id + id  id‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪29‬‬


Slide 30

‫רב‪-‬משמעות ─ המשך‬
‫‪E‬‬

‫‪E‬‬

‫‪E‬‬

‫‪‬‬

‫‪E‬‬

‫‪id‬‬

‫‪E‬‬

‫‪+‬‬

‫‪id‬‬

‫‪E‬‬

‫‪E‬‬

‫‪id‬‬

‫‪id‬‬

‫‪E‬‬

‫‪+‬‬

‫‪E‬‬

‫‪‬‬

‫‪E‬‬

‫‪id‬‬

‫‪id‬‬

‫דקדוק רב‪-‬משמעי עשוי להטעות אותנו במציאת המשמעות של המשפט‬
‫ולכן רצוי להימנע מדקדוק רב‪-‬משמעות‬
‫לחילופין ניתן לנסח כללי חדות (‪ )disambiguating rules‬הבוררים את‬
‫עץ הפריסה הרצוי מתוך העצים הפורסים האפשריים‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪30‬‬


Slide 31

‫רב משמעות ─ דוגמה‬
:)dangling else( ‫ המתנדנד‬else-‫בעית ה‬
‫דקדוק‬
stmt  if expr then stmt
| if expr then stmt else stmt
| other
‫המשפט‬
if E1 then S1 else if E2 then S2 else S3
stmt
if expr then stmt else
E1

S1

if expr then stmt else stmt

E2
31

‫נפרס ע"י עץ פריסה‬

stmt

S2
‫תורת הקומפילציה‬

S3
‫איתן אביאור‬


Slide 32

‫רב משמעות ─ המשך דוגמה‬
‫אולם המשפט‬
if E1 then if E2 then S1 else S2
:‫נפרס ע"י שני עצים אפשריים‬
stmt
stmt
if expr then
if expr then

stmt

else stmt

E1

E1

S2
if expr then stmt

if expr then stmt else stmt
E2
32

stmt

S1

E2

S1

S2
‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 33

‫סילוק רב‪-‬משמעות‬
‫• שפות התכנות שבהם משפטי תנאי כנ"ל מעדיפות את עץ הפריסה‬
‫השמאלי‬
‫• כלומר‪ ,‬ה‪ else-‬צריך להיות משויך ל‪ then-‬הקרוב אליו ביותר‬
‫• כלומר‪ ,‬לא ייתכן שבין ‪ then‬ו‪ else-‬המשויך לו יהיה ‪ then‬אשר אין‬
‫לו ‪ else‬משויך‬
‫הדקדוק הבא מאפשר היווצרות של העץ השמאלי בלבד‬
‫‪matched_stmt‬‬
‫‪unmatched_stmt‬‬
‫‪if expr then matched_stmt else matched_stmt‬‬
‫‪other‬‬
‫‪if expr then stmt‬‬
‫‪if expr then matched_stmt else unmatched_stmt‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪‬‬
‫|‬
‫‪matched_stmt ‬‬
‫|‬
‫‪unmatched_stmt ‬‬
‫|‬
‫‪stmt‬‬

‫‪33‬‬


Slide 34

‫רקורסיה שמאלית‬
‫(‪)Left Recursion‬‬
‫‪+‬‬
‫‪A‬‬
‫• כאשר דקדוק מאפשר גזירה‪A  :‬‬
‫נאמר כי קיימת בו רקורסיה שמאלית (‪)left recursion‬‬

‫• פורסים העובדים מלמעלה למטה מתקשים להתמודד עם מצב כזה‪,‬‬
‫ועלולים להיכנס לרקורסיה אינסופית‬
‫‪A  A |  :‬‬
‫• רקורסיה שמאלית פשוטה ‪A  A‬‬
‫ניתנת לסילוק ע"י החלפת הכלל בצמד כללים‪:‬‬
‫’‪A  A‬‬

‫‪A’  A’ | ε‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪34‬‬


Slide 35

‫דוגמה לסילוק רקורסיה‬
‫שמאלית פשוטה‬
‫הדקדוק‪:‬‬
‫‪E  E+T | T‬‬
‫‪T  TF | F‬‬
‫‪F  ( E ) | id‬‬

‫ניתן לכתיבה מחדש כך‪:‬‬
‫’‪T E‬‬
‫‪+ T E’ | ε‬‬
‫’‪F T‬‬
‫‪ F T’ | ε‬‬
‫‪( E ) | id‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪E ‬‬
‫‪E’ ‬‬
‫‪T ‬‬
‫‪T’ ‬‬
‫‪F ‬‬
‫‪35‬‬


Slide 36

‫רקורסיה שמאלית מיידית‬
‫הכלל‪:‬‬
‫‪A  A1 | A2 | . . . | Am‬‬
‫‪| 1 | 2 | . . . | n‬‬

‫כאשר שום ‪ i‬לא מתחיל ב‪ A-‬וכל ‪ i‬שונה מ‪ε-‬‬
‫ניתן להחלפה ע"י הכללים‪:‬‬
‫’‪A  1A’ | 2 A’ | . . . | nA‬‬
‫‪A’  1A’ | 2A’ | . . . | mA’ | ε‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪36‬‬


Slide 37

‫סילוק רקורסיה שמאלית כללית‬
‫‪+‬‬
‫‪‬‬
‫נניח כי ‪ G‬חסר מעגלים (לא מתקיים ‪)A A‬‬

‫וכי אין בו כללי ‪( ε‬אין כללים מהצורה ‪) A  ε‬‬
‫(ניתן לסלק את אלה מראש‪ ,‬ראה ‪ ASU‬תרג' ‪ 4.20‬ו‪)4.22-‬‬
‫האלגוריתם הבא מסלק רקורסיה שמאלית כללית‬
‫‪ .1‬סדר את הנונטרמינלים בסדר כלשהו ‪A1, A2, . . . , An‬‬
‫‪ .2‬עבור כל ‪i  [1 .. n] Ai‬‬
‫ועבור כל ‪j  [1 .. i-1] Aj‬‬
‫‪Ai  Aj ‬‬
‫אם קיים כלל ‪ P‬מהצורה‬
‫‪Aj  1 | 2 | . . . | k‬‬
‫וכן קיימים כללים‬
‫החלף את ‪ P‬בכלל ‪Ai  1  | 2  | . . . | n ‬‬
‫סלק רקורסיה שמאלית מכללי ‪Ai‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪37‬‬


Slide 38

‫פירוק שמאלי (‪)Left Factoring‬‬
‫הדקדוק‬
‫‪stmt  if expr then stmt else stmt‬‬
‫‪| if expr then stmt‬‬
‫מותיר במבוכה פורס מנבא מפני שכאשר הפורס רואה את התמנית ‪if‬‬
‫איננו יודע באיזה משני כללי הגזירה להשתמש‬
‫‪A   1 |  2‬‬
‫באופן כללי אם קיים כלל‪:‬‬
‫’‪A   A‬‬
‫נחליף אותו בצמד הכללים‪:‬‬
‫‪A’  1 | 2‬‬
‫כלומר נדחה את ההכרעה בין ‪ 1‬ו‪ 2-‬לשלב מאוחר יותר בפריסה‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪38‬‬


Slide 39

‫פירוק שמאלי ─ המשך‬
‫ובאופן כללי‪:‬‬
‫לכל נונטרמינל ‪:A‬‬
‫• מצא את הרישא ‪ ‬הארוכה ביותר המשותפת לשתים או יותר אלטרנטיבות של ‪A‬‬
‫• אם ‪   ε‬אזי קיימת רישא משותפת אמיתית‬
‫• כלל ‪ A‬נראה מהצורה‬
‫‪A   1 |  2 | . . . |   n |  1 |  2 | . . . |  m‬‬
‫כאשר ‪ ‬איננה רישא של אף ‪i‬‬
‫• החלף את כלל הנ"ל בכללים הבאים‪:‬‬
‫‪A   A’ | 1 |  2 | . . . | m‬‬
‫‪A’  1 | 2 | . . . |  n‬‬
‫• חזור על צעדים אלה עד שלא תהיה יותר רישא משותפת אמיתית לאלטרנטיבות‬
‫של ‪A‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪39‬‬


Slide 40

‫פריסה מלמעלה למטה‬
‫‪Top Down Parsing‬‬
‫• שיטה לפריסה המתאימה לבניה ידנית של פורסים‬
‫• תשתמש בגזירה שמאלית‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪40‬‬


Slide 41

‫ירידה רקורסיבית‬
‫(‪)Recursive Descent‬‬
‫אתחול‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫‪.5‬‬

‫איתן אביאור‬

‫המקום הנוכחי בקלט‪ :‬בהתחלה‬
‫בנה עץ פריסה ריק‬
‫הכנס את ‪ S‬כשורש העץ‬
‫פרוס את ‪S‬‬
‫ודא שהגעת לסוף הקלט‬

‫תורת הקומפילציה‬

‫‪41‬‬


Slide 42

‫ירידה רקורסיבית ‪ ‬המשך‬
‫פריסה רקורסיבית‬
‫‪ .1‬הצומת לפריסה הוא ‪V‬‬
‫‪ .2‬סמן את המקום הנוכחי בקלט‪P :‬‬
‫‪ .3‬עבור כל הכללים ‪ V  ‬בצע‪:‬‬
‫‪ .a‬חזור בקלט למקום ‪P‬‬
‫‪ .b‬בטל כל הבנים של ‪( V‬אם יש)‬
‫‪ .c‬הוסף ל‪ V-‬בנים לפי ‪‬‬
‫‪ .d‬לכל בן של ‪( V‬משמאל לימין)‪:‬‬
‫‪ .i‬אם הבן הוא נונטרמינל ‪ ‬פרוס אותו‬
‫‪ .ii‬אחרת (טרמינל) אם הוא זהה לקלט הבא ‪ ‬התקדם בקלט‬
‫‪ .iii‬אחרת (נסיגה) ‪ ‬חזור לצעד ‪3‬‬
‫‪ V .e‬נפרס היטב ‪ ‬חזור מהרקורסיה‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪42‬‬


Slide 43

‫ דוגמה‬ ‫ירידה רקורסיבית‬
cad

S
c

A
S

d

S
c

A

cad
d

S cad S  cAd :‫הדקדוק‬
A  ab  a
cad
:‫הקלט‬

cad

c A d
a

c A d

b
S

c

a
43

A

cad

S
a
cad

S
d

b

S

c A d

cad c

A

a

‫תורת הקומפילציה‬

cad
d

cad

S
c A d
a

‫איתן אביאור‬


Slide 44

‫נסיגה (‪)Backtracking‬‬
‫•‬

‫•‬
‫•‬
‫•‬

‫הפורס בחר כלל גזירה שגוי‪ ,‬ונאלץ לחזור אחורה‪:‬‬
‫– לבטל צמתים בעץ‬
‫– לחזור אחורה בקלט‬
‫ישנם דקדוקים חסרי הקשר שלא ניתן לפרוס אותם מלמעלה למטה‬
‫ללא נסיגות‬
‫ישנן שפות חסרות הקשר שעבורן אין דקדוק שניתן לפריסה‬
‫מלמעלה למטה ללא נסיגות‬
‫ישנן שפות שעבורן ניתן לכתוב דקדוק הניתן לפריסה מלמעלה‬
‫למטה ללא נסיגות‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪44‬‬


Slide 45

‫פורס מנבא‬
‫(‪)Predictive Parser‬‬
‫פורס מנבא (‪ ― )Predictive Parser‬פורס יורד רקורסיבית ללא נסיגות‬
‫• מתאים בד"כ להוראות הבקרה של רוב שפות התכנות‬
‫‪stmt  if expr then stmt else stmt‬‬
‫‪ while expr do stmt‬‬
‫‪ begin stmt_list end‬‬
‫‪stmt_list  stmt stmt_list  ‬‬
‫• ע"פ הקלט הבא ניתן תמיד לבחור באופן חד‪-‬משמעי את כלל הגזירה‬
‫המתאים‪ ,‬ועל כן אין צורך בנסיגות‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪45‬‬


Slide 46

‫דיאגרמת מעבר‬
‫(‪)Transition Diagrams‬‬
‫לפורסים מנבאים‬
‫• דיאגרמה אחת לכל נונטרמינל‬
‫• תוויות הקשתות הן טרמינלים ונונטרמינלים‬
‫• הפריסה‬

‫– מתחילים בדיאגרמה של סמל ההתחלה‬
‫– מעבר ע"פ קשת טרמינל ‪ ‬ניתן לעבור בקשת זו אם הקלט הבא‬
‫הוא התמנית המתאימה‬

‫– מעבר ע"פ קשת נונטרמינל ‪ ‬קריאה לנוהל שיפרוס את‬
‫הנונטרמינל ע"פ הדיאגרמה שלו‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪46‬‬


Slide 47

‫בנית דיאגרמת מעבר‬
‫‪ .1‬סלק רקורסיה שמאלית מהדקדוק‬
‫‪ .2‬בצע פירוק שמאלי של הדקדוק‬
‫‪ .3‬לכל נונטרמינל ‪:A‬‬

‫‪ .1‬ייצר מצב התחלה ומצב סיום (חזרה)‬
‫‪ .2‬לכל כלל ‪ A  x1x2…xn‬ייצר מסלול ממצב ההתחלה למצב‬
‫הסיום כך שהקשתות על המסלול מסומנות‪x1, x2, … xn :‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪47‬‬


Slide 48

‫דיאגרמת מעבר לפריסה ‪ ‬דוגמה‬
‫הדקדוק‪:‬‬

‫הדיאגרמות‪:‬‬

‫’‪E  T E‬‬
‫‪E’  + T E’ | ε‬‬
‫’‪T  F T‬‬
‫‪T’   F T’ | ε‬‬
‫‪F’  ( E ) | id‬‬

‫‪6‬‬

‫’‪E‬‬

‫‪5‬‬

‫‪9‬‬

‫‪13‬‬

‫‪17‬‬
‫איתן אביאור‬

‫‪2‬‬

‫תורת הקומפילציה‬

‫’‪T‬‬

‫)‬

‫‪12‬‬

‫‪16‬‬

‫’‪E‬‬

‫‪T‬‬
‫‪‬‬
‫’‪T‬‬

‫‪F‬‬
‫‪‬‬

‫‪E‬‬
‫‪id‬‬

‫‪1‬‬

‫‪4‬‬

‫‪8‬‬

‫‪11‬‬

‫‪15‬‬

‫‪T‬‬

‫‪+‬‬

‫‪F‬‬
‫‪‬‬

‫(‬

‫‪0‬‬

‫‪3‬‬

‫‪7‬‬

‫‪10‬‬

‫‪14‬‬

‫‪E:‬‬

‫‪E’ :‬‬

‫‪T:‬‬

‫‪T’ :‬‬

‫‪F:‬‬
‫‪48‬‬


Slide 49

‫פישוט דיאגרמות מעבר לפריסה‬
‫’‪E‬‬

‫‪6‬‬

‫‪+‬‬

‫‪4‬‬

‫‪E’ :‬‬

‫‪3‬‬

‫‪5‬‬

‫‪4‬‬

‫‪6‬‬

‫’‪E‬‬

‫‪2‬‬

‫‪T‬‬

‫‪1‬‬

‫‪0‬‬

‫‪+‬‬
‫‪3‬‬

‫איתן אביאור‬

‫‪T‬‬

‫‪‬‬

‫‪6‬‬

‫‪6‬‬

‫‪5‬‬

‫‪4‬‬

‫‪‬‬

‫‪3‬‬

‫‪‬‬

‫‪T‬‬

‫‪‬‬

‫‪T‬‬

‫‪+‬‬

‫‪E’ :‬‬

‫‪+‬‬

‫‪3‬‬

‫‪E’ :‬‬

‫‪‬‬

‫‪E:‬‬
‫‪T‬‬

‫‪T‬‬

‫‪0‬‬

‫‪E:‬‬

‫‪5‬‬
‫‪6‬‬

‫תורת הקומפילציה‬

‫‪+‬‬

‫‪3‬‬

‫‪T‬‬

‫‪0‬‬

‫‪E:‬‬

‫‪‬‬
‫‪49‬‬


Slide 50

‫פריסה מנבאת לא‪-‬רקורסיבית‬
‫‪a + b $‬‬
‫תוכנית פריסה מנבאת‬

‫פלט‬

‫טבלת פריסה ‪M‬‬

‫כיצד בונים ?‬
‫בינתיים ‪‬‬
‫תעלומה‬
‫איתן אביאור‬

‫קלט‬
‫‪ X‬מחסנית‬
‫‪Y‬‬
‫‪Z‬‬
‫‪$‬‬

‫טבלת הפריסה‬
‫• שורה לכל נונטרמינל‬
‫• עמודה לכל טרמינל ועמודה ל‪$-‬‬
‫• הכניסה ]‪ M[X,a‬מכילה את כלל(י) הגזירה שניתן‬
‫ליישם כאשר יש לגזור את ‪ X‬והקלט הבא הוא ‪a‬‬
‫תורת הקומפילציה‬

‫‪50‬‬


Slide 51

‫אלגוריתם לפריסה‬
‫רקורסיבית‬-‫מנבאת לא‬
append $ to w ;
w ‫מחרוזת‬
push ( $ );
G ‫ עבור הדקדוק‬M ‫וטבלת פריסה‬
push ( S );
i = 0;
;w ‫ גזירה שמאלית של‬ w  L(G) ‫אם‬
do {
‫ שגיאה‬ ‫אחרת‬
X = top () ;
a = wi ;
if ( X is terminal or $ ) {
if ( X == a ) {
pop () ;
i ++ ;
} else error () ;
} else /* X is nonterminal */
if ( M[X, a] == “X  Y1Y2…Yk” ( {
pop () ;
push ( Yk, Yk-1, ... Y1 ) ;
output “X  Y1 Y2 … Yk ” ;
} else error () ;
51
‫תורת הקומפילציה‬
} while ( X != $ ) ;

:‫קלט‬

:‫פלט‬

‫איתן אביאור‬


Slide 52

‫רב‪-‬משמעות בטבלת מעברים‬
‫• אם כניסה בטבלה מכילה יותר מאשר כלל אחד‬
‫נוצרת רב‪-‬משמעות‪ ,‬והאלגוריתם הופך לאי‪-‬דטרמיניסטי‬
‫• ניתן לקבוע כללים צדדים ליישוב רב‪-‬משמעות‪ ,‬כגון‪:‬‬

‫– יש להעדיף כלל ‪) ≠ ( X  ‬‬
‫על פני כלל ‪X  ‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪52‬‬


Slide 53

‫ דוגמה‬ ‫טבלת מעברים‬
Nonterminal
E
E’
T
T’
F
STACK
$E
$E’ T
$E’ T’ F
$E’ T’ id
$E’ T’
$E’
$E’ T +
$E’ T
$E’ T’ F
53

Input Symbol

)
E  T E’

+

id
E  T E’

E’  +T E’
T  F T’

id + id  id$
id + id  id$
id + id  id$
id + id  id$
+ id  id$
+ id  id$
+ id  id$
id  id$
id  id$

$

E’  

E’  

T’  

T’  

T  F T’
T’  

T’  F T’

F  id
INPUT

(

F(E)
OUTPUT

E  T E’
T  F T’
F  id
T’  
E’  + T E’

STACK
$E’ T’ id
$E’ T’
$E’ T F 
$E’ T’ F
$E’ T’ id
$E’ T’
$E’
$

T  F T’
‫תורת הקומפילציה‬

INPUT
id  id$
 id$
 id$
id$
id$
$
$
$

OUTPUT
F  id
T’   F T’
F  id

T’  
E’  
END
‫איתן אביאור‬


Slide 54

‫‪ First‬ו‪Follow-‬‬
‫•‬
‫•‬
‫•‬
‫•‬

‫)‪ — First(‬קבוצת הטרמינלים שמתחילים מחרוזות הנגזרות מ‪-‬‬
‫אם ‪ ε‬‬
‫‪  ‬אז גם )‪ε  First(‬‬
‫)‪ — Follow(A‬קבוצת הטרמינלים שיכולים להופיע בצמוד ל‪ A-‬מימין‬
‫‪‬‬
‫‪S‬‬
‫בנגזרת כלשהי‪ ,‬כלומר‪ a  Follow(A) :‬אם ‪Aa‬‬
‫אם ‪ A‬‬
‫‪ S ‬אז גם )‪$  Follow(A‬‬

‫שים לב‬
‫)‪ a  Follow(A‬‬

‫‪‬‬
‫‪S  Aa‬‬

‫)‪ $  Follow(A‬‬

‫‪‬‬
‫‪S  A‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪‬‬
‫‪S  Aa‬‬
‫‪‬‬
‫‪ ε‬‬
‫‪‬‬
‫‪S  A‬‬
‫‪‬‬
‫‪ ε‬‬
‫‪54‬‬


Slide 55

First ‫אלגוריתם לחישוב‬
‫של טרמינלים ונונטרמינלים‬
for each terminal t
First (t) = { t };
while ( ! done ) {
if ) “X  ” is a production (
First (X) = {  } ;
if ) “X  Y1 Y2 … Yk“ is a production ( {
First (X) = First (Y1) - {  };
for ( i=1; i < k; i ++ )
if (   First (Yi) )
First (X) = First (Yi+1) - {  };
else break ;
if ( i == k    First (Yk))
First (X) = {  } ;
}
}
55

‫תורת הקומפילציה‬

‫ המשנה‬= ‫כל ביצוע‬
First-‫את קבוצת ה‬
done = 0 -‫גורם ל‬
‫בהתחלת הלולאה‬
)‫(מיד לאחר הבדיקה‬
‫מציבים באופטימיות‬
done = 1

‫איתן אביאור‬


Slide 56

‫ של סדרת הסמלים‬First ‫חישוב‬
  X1 X2 . . . Xn
First () = First (X1)  {  } ;
for ( i = 1; i < n; i ++ ) {
if (   First (Xi) )
First () = First (Xi+1)  {  }
else break ;
if ( i == n    First (Xn) )
First () = {  } ;

56

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 57

Follow ‫אלגוריתם לחישוב‬
‫ משתנה כמו קודם‬done
Follow (S) = { $ } ;
while ( !done ) {
if ) “A  B” is a production )
Follow (B) = First ()  {  } ;
if ) “A  B” is a production 
) “A  B” is a production    First () ) )
Follow (B) = Follow (A);
}
 
β
57

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 58

‫דוגמה‬
E 
E’ 
T 
T’ 
F 
First
First ( E ) = { ( ,
First (E’ ) = { + ,
First ( T ) = { ( ,
First (T’ ) = {  ,
First ( F ) = { ( ,
58

id }
ε}
id }
ε}
id }

‫הדקדוק‬

T E’
+ T E’ | ε
F T’
 F T’ | ε
( E ) | id
Follow
Follow ( E ) = {
)
Follow (E’ ) = {
)
Follow ( T ) = {
+,)
Follow (T’ ) = {
+,)
Follow ( F ) = { + ,  , )
‫תורת הקומפילציה‬

,$}
,$}
,$}
,$}
,$}
‫איתן אביאור‬


Slide 59

‫אלגוריתם לבנית טבלת פריסה‬
foreach ( production “A  ” ( {
foreach ( terminal a  First () )
M [A, a] += “A  ” ;
(   First () ) {

if

foreach ( terminal b  Follow (A)
M [A, b] += “A  ” ;
if

( $  Follow (A) )
M[A, $] += “A  ” ;

}
}
59

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 60

‫רב משמעות בטבלה‬
‫דקדוק רקורסיבי שמאלי או דקדוק רב‪-‬משמעי‬
‫מייצרים לפחות כניסה אחת רב‪-‬משמעית בטבלה‬
‫‪S  i E t S S’ | a‬‬
‫‪S’  e S | ε‬‬
‫‪E  b‬‬

‫הדקדוק‪:‬‬
‫הטבלה‪:‬‬
‫‪$‬‬
‫‪S’  ‬‬

‫‪t‬‬

‫‪Input Symbol‬‬
‫‪e‬‬
‫‪i‬‬
‫’‪S  i E t S S‬‬
‫‪S’  ε‬‬
‫‪S’  eS‬‬

‫‪b‬‬

‫‪a‬‬
‫‪Sa‬‬

‫‪Non‬‬
‫‪terminal‬‬
‫‪S‬‬
‫’‪S‬‬

‫‪Eb‬‬

‫‪E‬‬

‫פתרון הרב‪-‬משמעות אפשרי במקרה זה ע"י העדפת הכלל ‪ S’  eS‬על הכלל ‪S’  ε‬‬
‫בהתאם למוסכמה ש‪ else-‬משוייך ל‪ then-‬הקרוב אליו ביותר‬
‫בחירת הכלל ‪ S’  ε‬תגרום לכך שהסמל ‪ e‬לעולם לא יוכנס למחסנית ולא יוצא מהקלט‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪60‬‬


Slide 61

‫דקדוקי )‪LL(1‬‬
‫דקדוק הניתן לפריסה בתנאים הבאים נקרא )‪:LL(1‬‬
‫( ‪) Left to right scan‬‬
‫‪  L‬קריאת הקלט משמאל לימין‬
‫( ‪) Left most derivation‬‬
‫‪  L‬גזירה שמאלית‬
‫( ‪) 1 lookahead symbol‬‬
‫‪  1‬ראית סמל אחד קדימה בלבד‬
‫משפט‬
‫לדקדוק )‪ LL(1‬ניתן לבנות טבלת פריסה ללא כניסות רב‪-‬משמעותיות‬
‫משפט‬
‫דקדוק הוא )‪ LL(1‬אם"ם לכל שני כללים ‪A   A  ‬‬
‫‪‬‬
‫‪ a  β‬‬
‫‪ aT : ‬‬
‫‪a  .1‬‬
‫‪   ‬‬
‫‪  ) .2‬‬
‫‪(‬‬
‫‪‬‬
‫‪‬‬
‫‪if (       a ) then a  Follow (A) .3‬‬
‫‪ ‬לצערנו לא כל דקדוק ניתן להבאה למצב )‪LL(1‬‬
‫‪ ‬לא תמיד ניתן למצוא כללי העדפה חיצוניים‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪61‬‬


Slide 62

‫פריסה מלמטה למעלה‬
‫(‪)Bottom-Up Parsing‬‬
‫• שיטה לפריסה המתאימה לבניה‬
‫אוטומטית של פורסים‬
‫• תשתמש בגזירה ימנית‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪62‬‬


Slide 63

‫דוגמה לגזירה מלמטה למעלה‬
‫הדקדוק‬

‫‪S  aABe‬‬
‫‪A  Abcb‬‬
‫‪B  d‬‬

‫משפט הקלט‬

‫‪abbcde‬‬
‫נגזר ע"י‬
‫‪abbcde‬‬
‫‪aAbcde‬‬
‫‪aAde‬‬
‫‪aABe‬‬
‫’‪S‬‬
‫איתן אביאור‬

‫‪‬‬
‫‪‬‬
‫‪rm‬‬
‫‪‬‬
‫‪rm‬‬
‫‪‬‬
‫‪rm‬‬
‫‪rm‬‬

‫תורת הקומפילציה‬

‫‪63‬‬


Slide 64

‫מטפל (‪)Handler‬‬
‫מטפל (‪ )handler‬של נגזרת ימנית ‪ ‬הוא כלל ‪A  β‬‬
‫ומקום בתוך ‪ ‬בו ‪ β‬נמצאת וניתן להחליפה ב‪A-‬‬
‫ע"מ לייצר את הנגזרת הקודמת ל‪ -‬בגזירה ימנית של ‪‬‬
‫‪‬‬
‫• כלומר‪ ,‬אם ‪ αβw‬‬
‫‪‬‬
‫‪S rm‬‬
‫‪αAw rm‬‬
‫אזי ‪ A  β‬במקום שאחרי ‪ α‬הוא מטפל של המחרוזת ‪αβw‬‬
‫(‪ w‬מכילה רק טרמינלים מפני שמדובר בגזירה ימנית)‬
‫• נאמר מטפל ולא ה‪-‬מטפל מפני שבדקדוק רב‪-‬משמעי עשויות להיות שתי גזירות‬
‫ימניות ‪ αβw‬‬
‫‪S rm‬‬
‫‪‬‬
‫• בדקדוק חד‪-‬משמעי לכל נגזרת ימנית יש רק מטפל אחד‬
‫• לא תמיד ה‪ β-‬השמאלית ביותר בנגזרת ‪ ‬מתאימה להחלפה מפני שהחלפת‬
‫אותה ‪ β‬ב‪ A-‬עשויה להביא למשהו שלא ניתן לגזור מסמל ההתחלה‬
‫(מזכיר לנו את בעיית הנסיגות בגזירה יורדת)‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪64‬‬


Slide 65

‫דוגמה ל"מטפל" שגוי‬
S  aABe
A  Abcb
B  d

‫הדקדוק‬

‫משפט הקלט‬

abbcde
‫נגזר ע"י‬
abbcde

rm a A b c d e
 a AA c d e
rm
 a AA c B e
rm
 ERROR

rm
65

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 66

‫דוגמה לפריסה מלמטה למעלה‬
id1 + id2  id3
‫נגזרת ימנית‬

‫טיפול‬

‫הקלט‬

‫כלל הגזירה‬

id1 + id2  id3

id1

E  id

E + id2  id3

id2

E  id

E + E  id3

id3

E  id

E + E E

EE

EEE

E+E

E+E

EE+E

EE+E
EEE
E(E)
E  id

‫הדקדוק‬

E

66

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 67

‫דוגמה לפריסה מלמטה למעלה‬
‫המשך‬
‫הדקדוק‬

‫‪EE+E‬‬
‫‪EEE‬‬
‫)‪E(E‬‬
‫‪E  id‬‬

‫מאחר והדקדוק רב‪-‬משמעי‬
‫ניתן לגזור גם באופן זה‪:‬‬

‫הקלט‬

‫‪id1 + id2  id3‬‬

‫כלל הגזירה‬

‫נגזרת ימנית‬

‫טיפול‬

‫‪E  id‬‬

‫‪id1‬‬

‫‪id1 + id2  id3‬‬

‫‪E  id‬‬

‫‪id2‬‬

‫‪E + id2  id3‬‬

‫‪E+E‬‬

‫‪E + E  id3‬‬

‫‪EE+E‬‬
‫‪E  id‬‬
‫‪EEE‬‬

‫‪id3‬‬

‫‪E  id3‬‬

‫‪EE‬‬

‫‪E E‬‬
‫‪E‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪67‬‬


Slide 68

‫פריסת "הזזה ורדוקציה"‬
‫(‪)Shift-Reduce‬‬
‫לרשות הפורס נתונה מחסנית שלתוכה ניתן להכניס סמלי דקדוק‬
‫הפורס פועל באמצעות ‪ 4‬הפעולות‪:‬‬
‫‪  shift .1‬סמל הקלט מוזז ונדחף למחסנית‬
‫‪  reduce .2‬החלפת תת‪-‬מחרוזת (של סמלי הדקדוק) שבראש‬
‫המחסנית במטפל שלה‬
‫‪  accept .3‬עצירה במצב מקבל‬
‫‪  error .4‬גילוי שגיאות תחביר‬
‫מחסנית‬
‫קלט‬
‫‪$‬‬
‫‪w$‬‬
‫אתחול‬
‫‪$S‬‬
‫‪$‬‬
‫סיום מוצלח‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪68‬‬


Slide 69

‫דוגמה להפעלת שיטת‬
Shift-Reduce
‫מחסנית‬
(1) $

‫פעולה‬

id1 + id2  id3$ shift

(2) $id1

+ id2  id3$ reduce by E  id

(3) $E

+ id2  id3$ shift

(4) $E +

id2  id3$ shift

(5) $E + id2

 id3$ reduce by E  id

(6) $E + E

 id3$ shift

(7) $E + E 

69

‫קלט‬

id3$ shift

(8) $E + E  id3

$ reduce by E  id

(9) $E + E  E

$ reduce by E  E  E

(10) $E + E

$ reduce by E  E + E

(11) $E

$ accept
‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 70

‫קונפליקטים‬
‫‪ .1‬קונפליקט ‪shift/reduce‬‬
‫‪ ‬הפורס מתלבט מה לעשות בצעד הבא‬
‫פעולת ‪ shift‬או פעולת ‪reduce‬‬
‫‪ .2‬קונפליקט ‪reduce/reduce‬‬
‫‪ ‬הפורס מתלבט באיזה רדוקציה כדאי לו לבחור בצעד הבא‬

‫דקדוק שנוצרים בו קונפליקטים איננו )‪( LR(k‬יוגדר בהמשך)‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪70‬‬


Slide 71

‫דוגמה לקונפליקט‬
‫‪Shift/Reduce‬‬
‫דקדוק רב‪-‬משמעי איננו יכול להיות ‪LR‬‬
‫הדקדוק‬
‫‪stmt  if expr then stmt‬‬
‫‪ if expr then stmt else stmt‬‬
‫‪ other‬‬
‫מחסנית‬
‫קלט‬
‫המצב‬
‫‪. . . if expr then stmt‬‬
‫‪else . . . $‬‬
‫‪ ‬זהו קונפליקט ‪ shift/reduce‬האם לבצע רדוקציה ע"פ הכלל‬
‫הראשון או הזזה פעמיים ואח"כ רדוקציה לפי הכלל השני‬
‫‪ ‬במקרה זה ניתן לפתור את הקונפליקט ע"י כלל צדדי הקובע כי‬
‫במצב כזה יש להעדיף את פעולת ה‪ shift-‬ע"מ לשייך את ה‪else-‬‬
‫ל‪ then-‬הקרוב אליו‬
‫‪ ‬לא תמיד ניתן למצוא כללים כאלה‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪71‬‬


Slide 72

‫דוגמה לקונפליקט‬
Reduce/Reduce
‫• נניח כי קריאה לשגרה וכן פניה למערך נכתבים בתחביר דומה תוך‬
ARR (I, J) ‫ וכן‬FUNC (A, B)
:‫שימוש בסוגריים ופסיקים‬
‫ לכל מזהה‬id ‫• הסורק מייצר תמנית‬
(1)
stmt  id ( parameter_list )
‫הדקדוק‬
(2)
stmt  expr := expr
(3) parameter_list  parameter_list , parameter
(4) parameter_list  parameter
(5)
parameter  id
(6)
expr  id ( expr_list )
(7)
expr  id
(8)
expr_list  expr_list , expr
(9)
expr_list  expr

72

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 73

‫דוגמה ‪ ‬המשך‬
‫• אם הקלט הוא‪:‬‬

‫)‪A(I, J‬‬

‫• זרם התמניות יהיה‪:‬‬
‫•‬

‫) ‪id ( id , id‬‬

‫במצב‬
‫קלט‬
‫‪, id ) . . .‬‬

‫מחסנית‬
‫‪. . . id ( id‬‬

‫לא ברור באיזה כלל צריך להשתמש לצורך הרדוקציה ( ‪ 5‬או ‪)7‬‬
‫• פתרון אפשרי ‪ ‬הסורק יבדיל בין שמות שגרות ומערכים‬
‫תוך שימוש בטבלת סמלים וייצר תמנית שונה לכל מקרה‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪73‬‬


Slide 74

‫רישא בת‪-‬קימא (‪)Viable Prefix‬‬
‫רישא בת‪-‬קימא (‪ )viable prefix‬‬
‫רישא של נגזרת ימנית שעשויה להופיע במחסנית‬
‫של פורס הזזה ורדוקציה‬
‫כלומר‪:‬‬
‫רישא של נגזרת ימנית שאיננה ממשיכה‬
‫מעבר למטפל הימני ביותר בנגזרת‬
‫מכאן‬
‫תמיד ניתן להוסיף טרמינלים לסופה של רישא בת‪-‬קימא‬
‫ע"מ לקבל נגזרת ימנית שלמה‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪74‬‬


Slide 75

‫פורס ‪LR‬‬
‫פורס )‪:LR(k‬‬
‫‪  L‬קריאת הקלט משמאל לימין‬

‫( ‪) Left to right scan‬‬

‫‪  R‬גזירה ימנית‬

‫( ‪) Rightmost derivation‬‬

‫‪  k‬ראית ‪ k‬סמלים קדימה‬

‫( ‪) k lookahead symbol‬‬

‫כאשר משמיטים את ‪ k‬הכוונה ל‪LR(1)-‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪75‬‬


Slide 76

‫יתרונות פורסי ‪LR‬‬
‫• ניתן לזהות באמצעותם כמעט את כל המבנים של שפות תכנות‬
‫הניתנים לתיאור באמצעות דקדוק חסר הקשר‬
‫• השיטה המוכרת הכללית ביותר לפריסה בהזזה ורדוקציה ללא‬
‫נסיגות ואשר ניתנת למימוש יעיל‬
‫• אוסף הדקדוקים הניתנים לפריסה בשיטה זו מכיל ממש את אוסף‬
‫הדקדוקים הניתנים לפריסה ע"י פורס מנבא‬

‫• פורס ‪ LR‬יכול למצוא שגיאות תחביר מוקדם ככל שניתן בזמן‬
‫סריקה של הקלט משמאל לימין‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪76‬‬


Slide 77

‫חסרון שיטת ‪LR‬‬
‫השיטה מסובכת מדי כדי לבנות פורס באופן ידני‬
‫יש להשתמש בכלי מיוחד לבנית פורס‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪77‬‬


Slide 78

‫מודל פורס ‪LR‬‬
‫‪a1 . . . ai . . . an $‬‬
‫פלט‬

‫קלט‬
‫‪ sm‬מחסנית‬

‫תוכנית פריסה‬

‫‪LR‬‬

‫‪Xm‬‬
‫‪sm-1‬‬
‫‪Xm-1‬‬
‫‪...‬‬

‫‪goto‬‬
‫איתן אביאור‬

‫‪action‬‬
‫תורת הקומפילציה‬

‫‪s0‬‬
‫‪78‬‬


Slide 79

‫תוכנית הפריסה בשיטת ‪LR‬‬
‫לרשות תוכניות הפריסה‪:‬‬
‫זרם התמניות‬
‫קלט ‪‬‬
‫כללי הגזירה בסדר הפוך לגזירה‬
‫פלט ‪‬‬
‫(מלמטה למעלה)‬
‫המכילה סמלי דקדוק ומצבים‬
‫מחסנית ‪‬‬
‫טבלאות פריסה ‪ action ‬ו‪goto-‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪79‬‬


Slide 80

‫תוכנית הפריסה בשיטת ‪LR‬‬
‫המשך‬
‫המחסנית‬
‫• במחסנית קיימים לסירוגין סמלי דקדוק ומצבים‬
‫• המצב שנמצא בראש המחסנית הוא המצב בו נמצאת התוכנית כרגע‬
‫• ניתן לבנות אוטומט שע"פ תוכן הסמלים במחסנית (המכילה רק‬
‫סמלים) יוכל להציע באיזה מטפל יש להשתמש ברדוקציה הבאה‬
‫• המצב בראש המחסנית מסמל את מצבו של אותו אוטומט‬
‫• עקרונית‪ ,‬ניתן לוותר על הכנסת הסמלים למחסנית‪ ,‬ולהסתפק‬
‫במצבים‬

‫תצורה (‪  )configuration‬זוג הסדרות המייצגות את תוכן המחסנית‬
‫והקלט שנותר ‪ s0X1s1X2s2 . . . Xms m , aiai+1 . . . an$ ‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪80‬‬


Slide 81

‫טבלאות הפריסה בשיטת ‪LR‬‬
‫טבלת ‪action‬‬
‫כאשר המצב בראש המחסנית הינו ‪ sm‬וסמל הקלט הבא הינו ‪,ai‬‬
‫הכניסה ]‪ action [sm, ai‬יכולה להכיל אחד מארבעה ערכים‪:‬‬
‫‪shift s‬‬
‫‪ .1‬הזז ‪ s( s‬הינו שם המצב)‬
‫‪reduce A  α‬‬
‫‪ .2‬בצע רדוקציה ע"פ כלל ‪A  α‬‬
‫‪accept‬‬
‫‪ .3‬קבל‬
‫‪error‬‬
‫‪ .4‬שגיאה‬
‫טבלת ‪goto‬‬
‫כניסה ]‪ goto [s, A‬בטבלה זו מכילה מצב (או שהיא ריקה)‬
‫‪ s‬הינו מצב ו‪ A-‬הוא נונטרמינל‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪81‬‬


Slide 82

LR ‫אלגוריתם הפריסה בשיטת‬

82

input is w$ ;
i = 1;
while ( 1 ) {
t = top ( );
a = wi;
if
( action [ t, a ] == “shift s” ( {
push ( a ) ;
push ( s );
i ++ ;
} elseif ( action [ t, a ] == “reduce A  β“( {
pop ( 2 * | β | ) ;
t = top ( ) ;
push ( A ) ;
push ( goto [ t, A ]) ;
output “A  β” ;
} elseif ( action [ t, a ] == “accept” ( {
return ;
} else error ( ) ;
}
‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 83

‫דוגמה לפריסה בשיטת ‪LR‬‬
‫הדקדוק‬
‫‪E+T‬‬
‫‪T‬‬
‫‪TF‬‬
‫‪F‬‬
‫)‪(E‬‬
‫‪id‬‬

‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬

‫‪E‬‬
‫‪E‬‬
‫‪T‬‬
‫‪T‬‬
‫‪F‬‬
‫‪F‬‬

‫)‪(1‬‬
‫)‪(2‬‬
‫)‪(3‬‬
‫)‪(4‬‬
‫)‪(5‬‬
‫)‪(6‬‬

‫‪goto‬‬
‫‪E T F‬‬
‫‪1 2 3‬‬

‫‪3‬‬

‫הערות‬
‫א‪ si .‬פירושו הזז‬
‫למחסנית מצב ‪i‬‬
‫ב‪ rj .‬פירושו רדוקציה‬
‫לפי כלל גזירה ‪j‬‬
‫ג‪ acc .‬פירושו לקבל‬
‫איתן אביאור‬
‫כניסה ריקה היא שגיאה‬
‫ד‪.‬‬

‫‪3‬‬
‫‪10‬‬

‫‪2‬‬

‫‪8‬‬

‫‪9‬‬

‫תורת הקומפילציה‬

‫טבלת הפריסה‬
‫‪action‬‬
‫מצב‬
‫‪id +‬‬
‫‪‬‬
‫(‬
‫)‬
‫‪$‬‬
‫‪0‬‬
‫‪s5‬‬
‫‪s4‬‬
‫‪1‬‬
‫‪s6‬‬
‫‪acc‬‬
‫‪2‬‬
‫‪r2 s7‬‬
‫‪r2‬‬
‫‪r2‬‬
‫‪3‬‬
‫‪r4 r4‬‬
‫‪r4‬‬
‫‪r4‬‬
‫‪4‬‬
‫‪s5‬‬
‫‪s4‬‬
‫‪5‬‬
‫‪r6 r6‬‬
‫‪r6‬‬
‫‪r6‬‬
‫‪6‬‬
‫‪s5‬‬
‫‪s4‬‬
‫‪7‬‬
‫‪s5‬‬
‫‪s4‬‬
‫‪8‬‬
‫‪s6‬‬
‫‪s11‬‬
‫‪9‬‬
‫‪r1 s7‬‬
‫‪r1‬‬
‫‪r1‬‬
‫‪10‬‬
‫‪r3 r3‬‬
‫‪r3‬‬
‫‪r3‬‬
‫‪11‬‬
‫‪r5 r5‬‬
‫‪r5‬‬
‫‪r5‬‬
‫‪83‬‬


Slide 84

‫תצורת הפורס עד לקבלה‬
‫מחסנית‬
(1) 0

‫קלט‬

‫פעולה‬

id  id + id $ shift

(2) 0 id 5

 id + id $ reduce by F  id

(3) 0 F 3

 id + id $ reduce by T  F

(4) 0 T 2

 id + id $ shift

(5) 0 T 2  7

id + id $ shift

(6) 0 T 2  7 id 5

+ id $ reduce by F  id

(7) 0 T 2  7 F 10

+ id $ reduce by T  T  F

(8)

0T2

+ id $ reduce by E  T

(9)

0E1

+ id $ shift

(10) 0 E 1 + 6

‫המשך‬
‫דוגמה‬
‫הקלט‬
id  id + id

id $ shift

(11) 0 E 1 + 6 id 5

$ reduce by F  id

(12) 0 E 1 + 6 F 3

$ reduce by T  F

(13) 0 E 1 + 6 T 9

$ EE+F

84 0 E 1
(14)

$ ‫הקומפילציה‬
accept ‫תורת‬

‫איתן אביאור‬


Slide 85

‫בנית טבלת הפריסה ‪LR‬‬
‫שלוש שיטות מוכרות‪:‬‬
‫• ‪ SLR‬‬

‫פשוטה למימוש אבל פחות חזקה‬

‫• ‪ LR‬קאנוני ‪ ‬הכי חזקה אבל גם הכי יקרה‬
‫• ‪ LALR‬‬

‫איתן אביאור‬

‫באמצע מבחינת המחיר והחוזק‪,‬‬
‫מתאימה לרוב שפות התכנות‬

‫תורת הקומפילציה‬

‫‪85‬‬


Slide 86

‫פריט )‪(Item‬‬
‫פריט )‪ )LR(0) item( LR(0‬‬
‫כלל גזירה שנעוצה בו נקודה במקום כלשהו בצידו הימני‬
‫דוגמה‬
‫‪A  xyz‬‬
‫הכלל‪:‬‬
‫הפריטים‪:‬‬

‫הכלל‬
‫איתן אביאור‬

‫‪A  ‬‬

‫‪·xyz‬‬
‫‪x·yz‬‬
‫‪xy·z‬‬
‫·‪xyz‬‬

‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬

‫‪A‬‬
‫‪A‬‬
‫‪A‬‬
‫‪A‬‬

‫מייצר רק פריט אחד‪:‬‬
‫תורת הקומפילציה‬

‫· ‪A ‬‬
‫‪86‬‬


Slide 87

‫פריט – המשך‬
‫ניתן לייצג פריט ע"י שני מספרים‪:‬‬
‫א‪ .‬כלל הגזירה‬
‫ב‪ .‬מקום הנקודה‬
‫משמעות הפריט‪:‬‬
‫ראינו עד עתה קלט המתאים לגזירת הרישא שמאלה לנקודה‬
‫ואנו מקווים לראות בהמשך קלט המתאים לסיפא שמימין לנקודה‬
‫• הפריטים הם מצבים אפשריים של אוטומט ‪ NFA‬המזהה רישאות‬
‫בנות‪-‬קיימא‪.‬‬
‫• קבוצות פריטים הן מצבי אוטומט ‪ DFA‬שנוצר ע"י אלגוריתם "בנית‬
‫תת‪-‬קבוצות"‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪87‬‬


Slide 88

‫‪  SLR‬הגדרות‬
‫דקדוק מורחב (‪  )augmented‬דקדוק שהוסף לו כלל ‪S’  S‬‬
‫• ‪ S‬הינו סמל ההתחלה הישן ו‪ S’-‬הינו סמל ההתחלה החדש‬
‫• התכלית לוודא שיש רק כלל גזירה אחד פשוט שכאשר משתמשים‬

‫בו יודעים שהגזירה מלמטה למעלה הצליחה‬
‫פעולת סגור (‪  )closure‬תוגדר להלן‬
‫פעולת ‪  goto‬תוגדר להלן‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪88‬‬


Slide 89

‫‪  SLR‬פעולת סגור (‪)Closure‬‬
‫’‪  G‬דקדוק חסר הקשר מורחב‬
‫‪  I‬קבוצת פריטים של ’‪G‬‬
‫) ‪  closure ( I‬קבוצת הפריטים המכילה את‪:‬‬
‫א‪ .‬כל מה שקיים ב‪ I-‬עצמה‬
‫ב‪ .‬אם ) ‪A  α · B β  closure ( I‬‬
‫‪ B  ‬הוא כלל גזירה‬
‫ואם‬
‫אזי גם ) ‪B  ·   closure ( I‬‬
‫המשמעות‬
‫כאשר ראינו בקלט ‪ α‬ואנו מצפים עתה לראות ‪B β‬‬
‫ניתן גם לומר כי אנו מצפים לראות עתה בקלט ‪( ‬ואח"כ ‪)β‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪89‬‬


Slide 90

‫ דוגמה‬ ‫ סגור‬ SLR
‫הדקדוק‬

E’ 
E 
E 
T 
T 
F 
F 
90

·E
·E+T
·T
·TF
·F
·(E)
· id

E’  E
E E+T |T
T TF |F
F  ( E ) | id
:‫ כולל‬closure { [ E’  · E ] }

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 91

‫‪  SLR‬סגור ‪ ‬המשך‬
‫הפריטים בתוך סגור מתחלקים לשני תת‪-‬קבוצות‪:‬‬
‫• פריטי גרעין (‪  )kernel‬כוללים את‪:‬‬
‫– פריט ההתחלה ‪S’  · S‬‬
‫– כל הפריטים בהם הנקודה איננה בצד שמאל לגמרי‬
‫• פריטי חוץ (‪  )nonkernel‬כוללים את כל הפריטים בהם הנקודה בצד שמאל‬
‫לגמרי‪ ,‬מלבד פריט ההתחלה‬
‫מאחר וכאשר מוסיפים פריט חוץ ‪ B  · ‬לקבוצה‬
‫מוסיפים בעצם את כל פריטי החוץ הנוצרים מכללי ‪,B‬‬
‫אין למעשה צורך לשמור בקבוצה את כל הפריטים עצמם‪,‬‬
‫אלא רק את רשימת הנונטרמינלים‬
‫שמכללי הגזירה שלהם נוצרים הפריטים המעניינים אותנו‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪91‬‬


Slide 92

‫‪  SLR‬פעולת ‪goto‬‬
‫‪  I‬קבוצת הפריטים‬
‫‪  X‬סמל דקדוק‬
‫) ‪  goto ( I , X‬הסגור של קבוצת כל הפריטים מהצורה ] ‪[ A  α X · β‬‬
‫וזאת עבור כל הפריטים מהצורה ] ‪ [ A  α · X β‬השייכים ל‪I-‬‬

‫דוגמה‬

‫} ] ‪I = { [ E’  E · ] , [ E’  E · + T‬‬

‫) ‪ goto ( I , +‬מכיל את‪:‬‬

‫איתן אביאור‬

‫‪E+·T‬‬
‫‪·TF‬‬
‫‪·F‬‬
‫)‪·(E‬‬
‫‪· id‬‬
‫תורת הקומפילציה‬

‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬

‫‪E‬‬
‫‪T‬‬
‫‪T‬‬
‫‪F‬‬
‫‪F‬‬
‫‪92‬‬


Slide 93

‫ בנית קבוצות פריטים‬ SLR
void items ( G )
{
C = { closure ( { [ S’  · S ] } ) } ;
done = 1;
do
foreach set I  C
foreach X  T  N
if
( goto ( I , X ) !=  )
C += goto ( I, X );
while ( !done ) ;
}

93

/* ‫* אוסף של קבוצות פריטים‬/

/* ‫* סמל דקדוק‬/
/* ‫ עשוי להשתנות‬done */

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 94

‫דוגמה לבנית קבוצות פריטים‬
‫הפריטים‬
I4
(·E)
·E+T
·T
·TF
·F
·(E)
 · id

I0
E’  · E
E ·E+T
E ·T
T ·TF
T ·F
F ·(E)
F  · id

F
E
E
T
T
F
F

I1
E’  E ·
E E·+T

F  id ·

E T·
T T·F

I2

TF·

I3

94

E
T
T
F
F

‫הדקדוק‬
E’  E
E E+T |T
T TF |F
F  ( E ) | id

I5

 E + · T I6
·TF
·F
·(E)
 · id

T T·F
F ·(E)
F  · id

I7

I8
F (E·)
E E·+T

‫תורת הקומפילציה‬

E  E + T · I9
T T·F
T  T  F · I10
F (E·)

I11

‫איתן אביאור‬


Slide 95

‫המשך‬
‫הדוגמה‬

‫‪to I7‬‬

‫‪‬‬

‫‪I9‬‬

‫‪to I3‬‬
‫‪to I4‬‬

‫‪T‬‬
‫‪F‬‬
‫(‬
‫‪id‬‬

‫‪I6‬‬

‫‪+‬‬

‫‪I1‬‬

‫‪E‬‬

‫‪I0‬‬

‫‪to I5‬‬

‫•‬

‫הפריטים מייצגים את המצבים‬
‫של ‪ NFA‬המכיר את הרישות‬
‫בנות‪-‬הקיימא של הדקדוק‬
‫– קשת מעבר מפריט ‪A  α · X β‬‬
‫לפריט ‪ A  α X · β‬מסומנת ע"י ‪X‬‬
‫– קשת המעבר מפריט ‪A  α · B β‬‬
‫לפריט ‪ B  · ‬מסומנת ע"י ‪‬‬

‫•‬

‫קבוצות הפריטים מייצגות את מצבי‬
‫ה‪ DFA-‬הנוצר מה‪NFA-‬‬

‫‪I10‬‬
‫‪to I4‬‬

‫‪F‬‬
‫(‬

‫‪‬‬

‫‪I7‬‬

‫‪T‬‬
‫‪I2‬‬

‫‪id‬‬

‫‪F‬‬

‫‪to I5‬‬

‫‪I3‬‬
‫(‬

‫(‬
‫‪I11‬‬
‫‪to I6‬‬

‫)‬
‫‪+‬‬
‫‪to I4‬‬

‫‪I8‬‬

‫‪E‬‬

‫‪I4‬‬
‫‪id‬‬

‫‪T‬‬
‫‪F‬‬

‫‪id‬‬

‫‪to I5‬‬
‫‪I3‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪95‬‬


Slide 96

‫‪  SLR‬פריטים תקפים‬
‫פריט תקף (‪  )valid‬פריט ‪ A  β1 · β2‬תקף עבור רישא בת‪-‬קיימא‬
‫‪‬‬
‫‪‬‬
‫‪  β1 β 2 w‬‬
‫‪S’ rm‬‬
‫‪Aw rm‬‬
‫‪ αβ1‬אם קיימת גזירה‬
‫• פריט עשוי להיות תקף להרבה רישות‬
‫• אם ‪ A  β1 · β2‬תקף עבור רישא ‪ αβ1‬הנמצאת על המחסנית אזי‪:‬‬
‫– אם ‪ β2 ≠ ‬הפריט מציע שלא ראינו עדיין את כל המטפל‪,‬‬
‫ועלינו לבצע פעולת הזזה‬
‫– אם ‪ β2 = ‬הפריט מציע שראינו מטפל שלם במחסנית וניתן‬
‫לבצע פעולת רדוקציה‬
‫• פריטים שונים עלולים להציע רדוקציות שונות ולייצר קונפליקטים‬
‫אם משתמשים בשיטה זו לדקדוק חסר הקשר כלשהו‬
‫• חלק מהקונפליקטים ניתן לפתור ע"י הסתכלות בסמל הקלט הבא‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪96‬‬


Slide 97

‫‪  SLR‬פריטים תקפים ‪ ‬המשך‬
‫משפט‬
‫אוסף הפריטים התקפים עבור רישא בת‪-‬קיימא ‪‬‬

‫הוא בדיוק קבוצת הפריטים אליהם ניתן להגיע‬
‫מהמצב התחלתי לאורך מסלול המסומן ע"י ‪‬‬
‫באוטומט ‪ DFA‬הנוצר מהבניה הקאנונית של קבוצות פריטים‬
‫עם מעברים המוגדרים ע"י פעולת ה‪.goto-‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪97‬‬


Slide 98

‫דוגמה‬
‫• הדקדוק ופעולת ה‪ goto-‬על פי הדוגמה דלעיל‬
‫• המחרוזת ‪ E + T ‬היא רישא בת‪-‬קיימא‬
‫• האוטומט הנ"ל נמצא במצב ‪ I7‬אחרי שהוא קורא ‪E + T ‬‬
‫• מצב ‪ I7‬כולל את הפריטים‪:‬‬
‫‪T T·F‬‬
‫)‪F  ·(E‬‬
‫‪F  · id‬‬
‫הפריטים מתאימים כל אחד לגזירות הבאות‪:‬‬
‫‪F  · id‬‬
‫‪E’  E‬‬
‫‪E+T‬‬
‫‪E+T F‬‬
‫‪ E + T  id‬‬

‫איתן אביאור‬

‫)‪F  ·(E‬‬
‫‪E’  E‬‬
‫‪E+T‬‬
‫‪E+T F‬‬
‫)‪E+T(E‬‬
‫תורת הקומפילציה‬

‫‪T T·F‬‬
‫‪E’  E‬‬
‫‪E+T‬‬
‫‪E+TF‬‬

‫‪98‬‬


Slide 99

‫בנית טבלת פריסה ‪SLR‬‬
‫א‪ .‬מרחיבים את הדקדוק ע"י כלל ‪S’  S‬‬
‫ב‪ .‬מייצרים את האוסף הקאנוני של קבוצות פריטים ‪ C‬לדקדוק המורחב‬
‫ג‪ .‬מחשבים את )‪ Follow(A‬לכל נונטרמינל‬
‫המשך ‪....‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪99‬‬


Slide 100

‫המשך בנית טבלת פריסה ‪SLR‬‬
‫ד‪ .‬בונים את טבלת ‪ action‬באופן הבא‪:‬‬
‫‪ C = { I0, I1, . . . In } .1‬היא אוסף קבוצות הפריטים )‪LR(0‬‬
‫‪ .2‬מצב ‪ i‬נוצר מקבוצה ‪ ― Ii‬הפעולות למצב ‪ i‬נקבעות כדלקמן‪:‬‬
‫‪ .a‬אם ‪ [ A  α · a β ]  Ii‬וכן ‪goto(Ii , a) = Ij‬‬
‫אזי ”‪ a( action[ i , a ] = “shift j‬חייב להיות טרמינל)‬
‫‪ .b‬אם ‪[ A  α ·]  Ii‬‬
‫אזי ”‪action[ i, a ] = “reduce A  α‬‬
‫לכל ‪ a‬ב‪ A( Follow(A)-‬הוא כל נונטרמינל מלבד ’‪)S‬‬
‫‪ .c‬אם ‪[ S’  S · ]  Ii‬‬
‫אזי ”‪action[ i, $ ] = “accept‬‬
‫אם נוצרו קונפליקטים הדקדוק איננו ) ‪SLR ( 1‬‬
‫המשך ‪....‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪100‬‬


Slide 101

‫המשך בנית טבלת פריסה ‪SLR‬‬
‫ה‪ .‬בונים את טבלת ‪ goto‬באופן הבא‪:‬‬
‫אם ‪goto(Ii, A) = Ij‬‬

‫אזי‬

‫‪goto [ i, A ] = j‬‬

‫ו‪ .‬כל הכניסות שלא הוגדרו בטבלאות ‪ action‬ו‪ goto-‬מסומנות ע"י ‪error‬‬
‫ז‪ .‬מצב ההתחלה של הפורס הוא זה שנבנה מתוך קבוצת הפריטים‬
‫המכילה את הפריט ] ‪[ S’  · S‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪101‬‬


Slide 102

‫הגדרות‬
‫טבלת )‪ SLR(1‬עבור דקדוק ‪  G‬טבלאות ‪ action‬ו‪ goto-‬שנבנו כנ"ל‬
‫פורס )‪  SLR(1‬פורס המשתמש בטבלאות )‪SLR(1‬‬
‫דקדוק )‪  SLR(1‬דקדוק שניתן לבנות עבורו טבלאות )‪SLR(1‬‬
‫בדרך כלל משמיטים את ה‪ (1)-‬ואומרים ‪SLR‬‬
‫מפני שלרוב מדובר בהסתכלות קדימה רק על סמל קלט אחד בלבד‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪102‬‬


Slide 103

‫חסרונות ‪SLR‬‬
‫•‬
‫•‬

‫•‬
‫•‬
‫•‬

‫ניתן להראות דוגמה של דקדוק חד‪-‬משמעי שעבורו שיטת ‪SLR‬‬
‫מייצרת קונפליקטים‬
‫קונפליקטים אלה נובעים מכך ששיטה זו אינה "זוכרת" מספיק‬
‫הקשר שמאלי ע"מ להחליט באיזה פעולה לנקוט‬
‫שיטות ‪ LR‬קאנוני ו‪ LALR-‬מתאימות למגוון רחב יותר של דקדוקים‬
‫מאשר ‪SLR‬‬
‫ישנם דקדוקים שאינם ‪ LR‬כלל ולכן גם שיטות אלה נכשלות בהם‬
‫למרבית שפות התכנות מתאימה שיטת הביניים ‪LALR‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪103‬‬


Slide 104

SLR ‫דוגמה לבנית טבלת‬
‫הדקדוק וקבוצות הפריטים שהוגדרו קודם‬

I1 ‫הקבוצה‬
E’  E ·
: action [1, $] = “accept”
E  E · + T : action [1, +] = “shift 6”

I0 ‫הקבוצה‬
E’  · E
//
E  ·E+T
//
E  ·T
//
T  ·TF
//
T  ·F
//
F  · ( E ) : action [0, ( ] = “shift 4”
F  · id
: action [0, id] = “shift 5”
104

‫תורת הקומפילציה‬

I2 ‫הקבוצה‬

E T·
T T·F
Follow( E ) = { $ , + , ) }
‫ולכן‬
action [2, $] =
action [2, +] =
action [2, ] = “shift
7”
‫איתן אביאור‬


Slide 105

‫דוגמה ‪ 2‬לבנית טבלת ‪SLR‬‬
‫דקדוק‬
‫‪L=R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪id‬‬
‫‪L‬‬

‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬

‫‪S‬‬
‫‪S‬‬
‫‪L‬‬
‫‪L‬‬
‫‪R‬‬

‫זהו דקדוק המפריד‬
‫בין ‪( r-value‬ערכים) ובין ‪( l-value‬מקומות אחסון)‬
‫לצורך הגדרת פעולת ההצבה‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪105‬‬


Slide 106

2 ‫המשך דוגמה‬
‫הדקדוק‬

‫ הקנוני של הדקדוק‬LR(0) ‫אוסף הפריטים‬
I0
S’  · S
S ·L=R
S ·R
L ·R
L  · id
R ·L

L
R
L
L

S’  S ·

L  id ·

I1

S  L · = R I2
R L·
SR·
106

I3

S
R
L
F

·R
·L
·R
 · id

I4

I5

 L = · R I6
·L
·R
 · id
‫תורת הקומפילציה‬

S
S
L
L
R







L=R
R
R
id
L

L R·

I7

R L·

I8

S  L = R · I9
T T·F
‫איתן אביאור‬


Slide 107

‫המשך דוגמה ‪2‬‬
‫• נתבונן בקבוצה ‪I2‬‬
‫•‬
‫•‬

‫•‬

‫•‬

‫‪I2‬‬

‫‪S L·=R‬‬
‫·‪R L‬‬

‫הפריט הראשון גורם לכניסה ] = ‪ action[ 2,‬להיות ”‪"shift 6‬‬
‫מאחר וקבוצת ) ‪ Follow( R‬מכילה את הטרמינל =‬
‫) ‪( S  L=R  R=R‬‬
‫הפריט השני גורם לכניסה ] = ‪ action[ 2,‬להיות ”‪“reduce R  L‬‬
‫הדקדוק הוא חד‪-‬משמעי אבל טבלת הפריסה רב‪-‬משמעית ‪‬‬
‫מכילה קונפליקט‬
‫הטבלה איננה זוכרת את ההקשר שבו התגלה הסמל ‪ L‬ולא יודעת‬
‫האם מותר לעשות לו רדוקציה לסמל ‪R‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪107‬‬


Slide 108

‫המשך דוגמה ‪2‬‬
‫• מצב ‪ 2‬מייצג את הרישא ‪L‬‬
‫• מאחר ואין שום נגזרת המתחילה ברישא‬
‫במצב ‪ 2‬כאשר רואים בקלט את הסימן =‬
‫אסור לבצע את הרדוקציה מ‪ L-‬ל‪( R-‬אסור להשתמש בכלל ‪)R  L‬‬
‫‪R=...‬‬

‫• לכן במצב ‪ 2‬עם סימן קלט =‬
‫יש לבצע פעולת הזזה ע"פ ההצעה של הפריט הראשון‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪108‬‬


Slide 109

‫החולשה של שיטת ‪SLR‬‬
‫באופן כללי בשיטת ‪ SLR‬מצב ‪ i‬עם סמל קלט ‪ a‬מציע את‬
‫הרדוקציה ‪ A  ‬כאשר‪:‬‬
‫– קבוצת הפריטים ‪ Ii‬מכילה את הפריט ] · ‪[ A  ‬‬
‫– סמל הקלט ‪ a‬שייך ל‪Follow(A)-‬‬
‫אולם‪,‬‬
‫ייתכן כי מצב ‪ i‬מופיע במחסנית שבה קיימת רישא בת‪-‬קיימא ‪β‬‬
‫ואילו ‪ β‬איננו מופיעה לפני ‪ a‬בשום נגזרת ימנית‪,‬‬
‫ועל כן הרדוקציה ‪ A  ‬איננה תקיפה כשהקלט הבא הוא ‪a‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪109‬‬


Slide 110

‫‪ LR‬קאנוני‬
‫הרעיון המרכזי הוא לפצל את המצבים (קבוצת הפריטים) ע"פ סימן הקלט הבא‪,‬‬
‫וכך לאפשר פתרון הקונפליקטים הנוצרים בשל קוצר הראות של שיטת ‪SLR‬‬
‫פריט )‪[ A  α · β , a ]  LR(1‬‬
‫זוג המורכב מ‪:‬‬
‫– כלל גזירה שבצידו הימני נעוצה במקום מסוים נקודה‬
‫– מטרמינל (או סימן סוף הקלט ‪)$‬‬
‫• הציון )‪ (1‬מסמן שמדובר בהסתכלות קדימה על סמל ‪ 1‬בקלט‬
‫‪ ‬כאשר ] ‪ [ A  α · β , a‬וכן ‪ β ≠ ‬אין חשיבות ל‪a-‬‬
‫‪ ‬כאשר ] ‪ [ A  α · , a‬ניתן לבצע רדוקציה בעזרת ‪A  ‬‬
‫רק אם סמל הקלט הבא הוא ‪a‬‬
‫‪ ‬כלומר ניתן לבצע רדוקציה ‪ A  ‬רק אם סמל הקלט הבא הוא ‪a‬‬
‫וקיים פריט ] ‪ [A  α · , a‬בתוך המצב שבראש המחסנית‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪110‬‬


Slide 111

‫‪ LR‬קאנוני ‪ ‬המשך‬
‫‪ ‬קבוצת כל הסמלים ‪ a‬העומדים בתנאי זה הינה תת‪-‬קבוצה‬
‫(ולעיתים תת‪-‬קבוצה ממש) של )‪Follow(A‬‬
‫הגדרה פורמלית‬
‫פריט )‪ [ A  α · β , a ] LR(1‬הוא תקף (‪ )valid‬לרישא‬
‫בת‪-‬קיימא ‪ ‬אם ישנה נגזרת ‪ Aw  βw‬‬
‫‪S rm‬‬
‫‪‬‬
‫‪rm‬‬
‫כאשר‬
‫‪ =   .1‬‬
‫‪ .2‬או ש‪ a-‬הינו הסמל הראשון של ‪w‬‬
‫או ש‪a = $  w =  -‬‬
‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪111‬‬


Slide 112

‫דוגמה‬
‫‪S  BB‬‬
‫דקדוק‬
‫‪BaB|b‬‬
‫מאחר וקיים ‪ aaBab  aaaBab‬‬
‫‪S rm‬‬
‫‪‬‬
‫‪rm‬‬
‫על כן הפריט ] ‪ [ B  a · B , a‬תקף עבור הרישא ‪ = aaa‬‬
‫(‪ β = B , = a ,w = ab ,A = B , = aa‬בהגדרה דלעיל)‬
‫‪‬‬

‫‪ BaaB‬‬
‫‪ BaB rm‬‬
‫‪S rm‬‬
‫כמו כן קיים‬
‫ועל כן הפריט ] ‪ [ B  a · B , $‬תקף עבור הרישא ‪Baa‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪112‬‬


Slide 113

‫ניתוח מחדש של סגור‬
‫•‬
‫•‬

‫•‬
‫•‬
‫•‬
‫•‬
‫•‬

‫נניח כי קיים פריט ] ‪ [A  α · B β , a‬בקבוצת הפריטים של‬
‫רישא בת‪-‬קיימא ‪‬‬
‫על כן קיימת גזירה ‪ Aax  Bβax‬‬
‫‪S rm‬‬
‫‪‬‬
‫‪rm‬‬
‫כאשר ‪ = ‬‬
‫נניח כי מתוך ‪ βax‬נגזרת מחרוזת הטרמינלים ‪by‬‬
‫לכן‪ ,‬לכל כלל גזירה מהצורה ‪( B  ‬עבור ‪ ‬כלשהו)‬
‫‪‬‬
‫‪ by‬‬
‫‪‬‬
‫‪S rm‬‬
‫‪Bby rm‬‬
‫קיימת הגזירה‬
‫ומכאן ש‪ [ B  ·  , b ] -‬תקף עבור ‪‬‬
‫‪ b‬יכול להיווצר מתוך ‪ ,β‬או אם ‪ β‬נגזרת ל‪ -‬אזי ‪b = a‬‬
‫באופן כללי ‪ b‬יכול להיות טרמינל כלשהו מתוך )‪First(βax‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪113‬‬


Slide 114

‫ סגור‬ LR(1) ‫בנית פריטי‬
set closure ( I )
{
done = 1;
do
foreach item [ A  α · B β , a ] in I
foreach production “B  ” in G
foreach terminal b in First (βa)
I += [ B  ·  , b ] ;
/* => done = 0 */
while ( ! done ) ;
return I;
}
114

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 115

goto  LR(1) ‫בנית פריטי‬
set goto (I, X)
{
set J;
foreach item [ A  α · X β , a ] in I
J += [ A  α X · β , a ] ;
return closure ( J ) ;
}

115

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 116

LR(1) ‫בנית פריטי‬
void items ( G )
{
C = { closure ( { [ S’  · S , $ ] } ) };
done = 1;
do
foreach set I in C
foreach grammar symbol X
if ( goto ( I, X ) !=  )
C += goto (I, X);
/* => done = 0 */
while ( !done) ;
}
116

‫תורת הקומפילציה‬

‫איתן אביאור‬


Slide 117

‫בנית טבלת פריסה ‪ LR‬קנונית‬
‫א‪ .‬הרחב את הדקדוק ע"י הכלל ‪S’  S‬‬
‫ב‪ .‬בנה את ‪ C‬קבוצת כל קבוצות הפריטים )‪ LR(1‬ע"פ האלג' דלעיל‬
‫ג‪ .‬בנה טבלת ‪ action‬כדלקמן‪:‬‬
‫‪C = { I0, I1, . . . In } .1‬‬
‫‪ .2‬מצב ‪ i‬של הפורס מיוצר מתוך ‪ ,Ii‬והפעולות של מצב זה‬
‫נקבעות כדלקמן‪:‬‬
‫‪ .a‬אם ‪goto(Ii, a) = Ij  [ A  α · a β , b ]  Ii‬‬
‫אזי ”‪ a( action[ i, a ] = “shift j‬חייב להיות טרמינל)‬
‫‪ .b‬אם ‪A ≠ S’  [ A  α · , a ]  Ii‬‬
‫אזי ”‪action[ i, a ] = “reduce A  ‬‬
‫‪ .c‬אם ‪ [ S  S · , $ ]  Ii‬אזי ‪action[ i , $ ] = accept‬‬
‫הקומפילציה)‪ LR(1‬והאלגוריתם נכשל‬
‫הדקדוק איננו‬
‫איתן אביאוראם נוצר קונפליקט‬
‫תורת‬

‫‪117‬‬


Slide 118

‫המשך בנית הטבלה‬
‫ד‪ .‬בנה טבלת ‪ goto‬כדלקמן‪:‬‬
‫אם ‪ goto ( Ii, A ) = Ij‬אזי ‪goto[ i , A ] = j‬‬
‫ה‪ .‬כל הכניסות הריקות בטבלת ‪ action‬ובטבלת ‪ goto‬מסומנות ב‪error-‬‬
‫ו‪ .‬המצב ההתחלתי של הפורס הוא זה שנבנה מתוך הקבוצה המכילה‬
‫את הפריט ] ‪[ S’  · S , $‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪118‬‬


Slide 119

‫טבלת פריסה )‪ LR(1‬קאנונית‬
‫• הטבלה הנוצרת ע"י אלגוריתם זה נקראת טבלת פריסה )‪LR(1‬‬
‫קאנונית‬
‫• פורס ‪ LR‬המשתמש בטבלה זאת נקרא פורס )‪ LR(1‬קאנוני‬
‫• אם הטבלה איננה מכילה קונפליקטים הדקדוק נקרא דקדוק )‪LR(1‬‬

‫• לעיתים משמיטים את ה‪ (1)-‬ואומרים דקדוק ‪LR‬‬
‫אבחנה‪:‬‬
‫כל דקדוק )‪ SLR(1‬הוא דקדוק )‪ LR(1‬אבל בהחלט לא להפך‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪119‬‬


Slide 120

‫תום פרק ‪4‬‬

‫איתן אביאור‬

‫תורת הקומפילציה‬

‫‪120‬‬