תרגול 11: Backpatching

1. תרגול 11: Backpatching • שלבים בפתרון Backpatch • דוגמא: SWITCH • שאלה ממבחן

2. שלבים בפתרון • פריסת קוד: • ציור סכמאטי של הקוד שיווצר. • סכימת תרגום: • כתיבת הכללים הסמנטיים.

3. Switch: example Switch (x) { case 5: … break; case 7: … break; … case 12: …break; }

4. Case List Case List Case List Case List תרגום פקודת switch S → switch( E ){ CL } CL → C CL | C C → casenum: S ;break; Case Case Case Case

5. S → switch( E ){ CL } CL → C CL | C C → casenum: S ;break; שלב I: פריסת קוד • ציור סכימטי של הקוד שיווצר: • מיקום יחסי של הקוד הנפלט (קבוע). • פקודותgoto שנרצה לתפור. • הקוד המאחה.

6. שלב II: סכימת תרגום • רשימת התכונות שנצטרך ומשמעותן. • הרחבת הדקדוק (באמצעות מרקרים). • כתיבת הכללים הסמנטיים.

7. תכונות סמנטיות למשתני הדקדוק הנחה: כל נקודות היציאה מהקוד המתאים למשתנה הן בפקודת goto ___. nextlist היא רשימה המכילה את כלל הכתובות של נקודות היציאה הללו. • S:nextlist . • E: place . • C: value, quad, nextlist. • CL:value_list (stack), quad_list (stack), nextlist .

8. מרקרים שימושיים M → ε { M.quad = nextquad(); } N → ε { N.nextlist = makelist (nextquad()); emit (“goto ___”); }

9. S → switch( E N){ CL } CL → C CL | C C → casenum:M S ;break; פריסת הקוד: C → casenum:M S ;break; { C.quad = M.quad; C.value = num.value; C.nextlist = S.nextlist; }

10. S → switch( E N){ CL } CL → C CL | C C → casenum:M S ;break; CL → C { CL.quad_list = newstack(); CL.quad_list.push(C.quad); CL.value_list = newstack(); CL.value_list.push(C.value); CL.nextlist = C.nextlist; } תזכורת: מכיל את התווית הראשונה של Sn

11. S → switch( E N){ CL } CL → C CL | C C → casenum:M S ;break; CL → C CL1 { CL.quad_list = CL1.quad_list; CL.quad_list.push(C.quad); CL.value_list = CL1.value_list; CL.value_list.push(C.value); CL.nextlist=merge(CL1.nextlist,C.nextlist); }

12. S → switch( E N){ CL } CL → C CL | C C → casenum:M S ;break; S → switch( E N){ CL } { backpatch(N.nextlist, nextquad()); while (!CL.value_list.empty()) { value = CL.value_list.pop(); quad = CL.quad_list.pop(); emit(“if” || E.place || ”=“ || value || ”goto” || quad); } S.nextlist= merge ( CL.nextlist, makelist(nextquad() ); emit (“goto ___”); }

13. שאלה ממבחן

14. Lisp style loops 1) S  loop COND_LIST do S1 • 2) COND_LIST  COND_LIST1 COND • 3) COND_LIST  COND • 4) COND  while B • 5) COND  until B הלולאה מכילה מספר משתנה של תנאים, וממשיכה להתבצע כל עוד כולם מתקיימים. הלולאה תתבצע כל עודהתנאי הבוליאני B מתקיים הלולאה תתבצע עד אשר התנאי הבוליאני B יתקיים

15. דוגמא:

16. פתרון - נניח, לרגע, דקדוק מצומצם 1) S  loop COND_LIST do S1 • 2) COND_LIST  COND_LIST1 COND • 3) COND_LIST  COND • COND  while B הלולאה תתבצע כל עודהתנאי הבוליאני B מתקיים

17. פריסת קוד S B1 (While) falselist truelist B2 (While) truelist nextlist Bn (While) truelist S1 nextlist

18. S: nextlist • B: truelist, falselist COND: truelist, falselist, quad (היכן התנאי מתחיל) תכונות COND_LIST: truelist, falselist, start_quad(היכן התנאיהראשון)

19. סכימת תרגום COND  whileM B { COND.quad = M.quad; COND.truelist = B.truelist; COND.falselist = B.falselist; }

20. סכימת תרגום COND_LIST  COND { COND_LIST.start_quad = COND.quad; COND_LIST.truelist = COND.truelist; COND_LIST.falselist = COND.falselist; }

21. COND_LIST  COND_LIST1 COND { COND_LIST.start_quad = COND_LIST1.start_quad; backpatch (COND_LIST1.truelist, COND.quad); COND_LIST.truelist = COND.truelist; COND_LIST.falselist = merge (COND_LIST1.falselist, COND.falselist); }

22. S  loop COND_LIST doM S1 { backpatch (COND_LIST.truelist, M.quad); backpatch (S1.nextlist, COND_LIST.start_quad); S.nextlist = COND_LIST.falselist; }

23. נניח כעת דקדוק לא מצומצם 1) S  loop COND_LIST do S1 • 2) COND_LIST  COND_LIST1 COND • 3) COND_LIST  COND • 4) COND  while B • 5) COND  until B הלולאה תתבצע כל עודהתנאי הבוליאני B מתקיים הלולאה תתבצע עד אשר התנאי הבוליאני B יתקיים

24. פריסת קוד truelist B1 (While) falselist סכימת תרגום B2 (Until) truelist falselist COND  untilM B { COND.quad = M.quad; COND.truelist = B.falselist; COND.falselist = B.truelist; } nextlist falselist B3 (While)