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

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

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

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

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

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

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

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

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

10. 10 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 S → switch ( E N ) { CL } CL → C CL | C C → case num : M S ; break ;

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

12. S → switch ( E N ) { CL } CL → C CL | C C → case num : 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. שאלה ממבחן 13

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

15. דוגמא : 15

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

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

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

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

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

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

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

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

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