פרק 7 סביבת הריצה

1. פרק 7 סביבת הריצה תורת הקומפילציה

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

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

4. שגרות (Routines) שגרה (routine) – קטע קוד שיש לו תפקיד מסוים, ואשר • ניתן להעביר לו פרמטרים (אופציונלית) • ניתן לקבל ממנו ערך מסוים (אופציונלית) שמות בשפות שונות • שגרה (routine) • תת-שגרה (subroutine) • נוהל (procedure) • פונקציה (function) לעניינו  כולם שקולים תורת הקומפילציה

5. מונחים הקשורים לשגרות • כותרת (header) שם השגרה, שמות הפרמטרים, טיפוסי הפרמטרים והערך המוחזר. • גוף (body) פסוק (מורכב בד"כ) המכיל את הקוד לביצוע • הגדרה (definition) כותרת שלאחריה גוף • הצהרה (declaration) כותרת ללא גוף • קריאה (call) המקום בתוכנית בו מופיע שם השגרה ע"מ שתופעל שם • קוראת (caller) השגרה (או התוכנית הראשית) בה מופיעה הקריאה לשגרה מסוימת • נקראת (callee) השגרה המסוימת שנקראה תורת הקומפילציה

6. מונחים הקשורים לשגרות  2 • פרמטרים פורמלים (formal parameters) השמות בהם מוזכרים הפרמטרים בהגדרת השגרה • פרמטרים אקטואליים, ארגומנטים (actual parameters, arguments) הערכים הספציפים שניתנו לפרמטרים בקריאה מסוימת תורת הקומפילציה

7. דוגמה לשגרות (נהלים ופונקציות) ב-Pascal program sort(input, output); var a : array [0..10] of integer; procedure readarray; var i : integer; begin for i := 1to9do read ( a [ i ] ) end; function partition(y, z : integer) : integer; var i, j, x, v: integer; begin ... end; procedure quicksort(m, n: integer); var i : integer; begin if ( n > m ) then begin i := partition(m, n); quicksort (m,i-1); quicksort (i+1,n) end end; begin a[0] := -9999; a[10] := 9999; readarray; quicksort(1,9) end. תורת הקומפילציה

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

9. עוד מונחים • הפעלה (activation) קריאה מסוימת לשגרה בזמן הרצת התוכנית • זמן חיים (lifetime) משך הזמן בחיי התוכנית מרגע ששגרה הופעלה בהפעלה מסויימת, ועד שהיא הסתיימה אבחנה על סמך הנחות היסוד  שני זמני חיים של שגרות: זרים זה לזה או אחד מהם מכיל ממש את השני מסקנה ניתן לצייר עץ של זרימת הבקרה בין השגרותבריצה מסוימת של תוכנית תורת הקומפילציה

10. רקורסיה (Recursion) • שגרה לא רקורסיבית (non-recursive routine) שגרה שעבורה זמני חיים של כל שתי הפעלות שלה זרים זה לזה • שגרה רקורסיבית (recursive routine) שגרה שעבורה זמן חיים של הפעלה אחת שלה עשויי להיות מוכל בתוך זמן חיים של הפעלה אחרת • רקורסיה עצמית (self-recursion) השגרה מפעילה את עצמה • רקורסיה הדדית (mutual-recursion) שגרה א' מפעילה שגרה ב' ושגרה ב' שבה ומפעילה את שגרה א' תורת הקומפילציה

11. עץ הפעלה(Activation Tree) עץ הפעלה הינו עץ אשר בו: • כל צומת מציין הפעלה של שגרה (שם וארגומנטים) • השורש הוא שגרה התחילית (או התוכנית הראשית) • צומת א' הינו ההורה של צומת ב' אם ורק אם הפעלת ב' נעשתה מתוך הפעלת א' • צומת א' מופיע משמאל לצומת ב' אם ורק אם זמן החיים של א' קדם לזמן החיים של ב' תורת הקומפילציה

12. s r q (1, 9) p (1, 9) q (1, 3) q (5,9) p (1, 3) q (1,0) q (2,3) p (5,9) q (5,5) q (7,9) p (2,3) q (2,1) q (3,3) p (7,9) q (7,7) q (9,9) עץ הפעלה – דוגמה תורת הקומפילציה

13. s r q ( 1, 9 ) p ( 1, 9 ) q ( 1, 3 ) p ( 1, 3 ) q ( 1, 0 ) q ( 2, 3 ) מחסנית הבקרה(Control Stack) • ביצוע תוכנית הינו מעבר לעומק (DFT) על עץ ההפעלה • ניתן לשמור במחסנית את המסלול מהשורש עד המקום הנוכחי בעץ • מחסנית זו נקראת: מחסנית הבקרה (control stack) דוגמה המצב הנוכחי בעץ מחסנית הבקרה תורת הקומפילציה

14. הכרזה (Declaration) • הכרזה (declaration) משפט בשפה המכריז על קיומו של עצם (משתנה, קבוע, שגרה) • שם העצם (name) • טיפוס (type) • מחלקת זיכרון (static, auto, register) • מאפיינים (const, volatile) • לשגרות  טיפוסי הפרמטרים • הכרזה מפורשת (explicit declaration) משפט ההכרזה המופיע בתוכנית • הכרזה סתומה (implicit declaration) כאשר האזכור הראשון של עצם בתוכנית מהווה את הכרזתו בברירת מחדללדוגמה  ב-Fortran עצמים ששמם מתחיל ב-I..N הם INTEGER ובשאר האותיות הם REAL (אלא אם כן היתה הכרזה מפורשת אחרת) תורת הקומפילציה

15. תחום הכרזה(Scope of Declaration) • תחום הכרזה (scope of definition) האזור בתוכנית בו עצם מוכר על סמך הכרזה מסוימת • חוקי תחום (scope rules) חוקי המשמעות של שפת התכנות הקובעים את תחומי ההכרזות השונות • שם מקומי (local) שם שתחום הכרזתו מוכל בשגרה (או הגוש) אותו בוחנים • שם לא-מקומי (non-local) שם שתחום הכרזתו חורג מהשגרה (או הגוש) אותו בוחנים תורת הקומפילציה

16. environment state name storage value קשירת שמות(Binding of Names) • סביבה (environment) הפונקציה הממפה שם (של עצם) לאזור בזיכרון בו ממומש העצם • מצב (state) הפונקציה הממפה אזור בזיכרון לערך המוחזק בו • קשירה (binding) הפעולה המתבצעת ע"י הסביבה כאשר הסביבה קושרת את השם X למקום בזיכרון s נאמר ש-X קשור ל-s (X is bound to s) • שם עשוי להיות קשור למספר עצמים שונים בזיכרון בעת ובעונה אחת תורת הקומפילציה

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

18. ארגון הזיכרון כתובות נמוכות קוד = הוראות נתונים סטטים ערמה heap מחסנית stack כתובות גבוהות זיכרון חופשי תורת הקומפילציה

19. רשומת הפעלה(Activation Record) רשומת הפעלה (activation record) או מסגרת (frame) שטח (בד"כ רצוף) המכיל את כל המידע הנחוץ להפעלה של השגרה: • השדות המסומנים ב- יכולים להיות כולם או חלקם באוגרים • האוגרים (שערכם הקודם נשמר בשדה המצב) יכולים לשמש כ"הרחבה" של רשומת ההפעלה תורת הקומפילציה

20. אסטרטגיות להקצאת זיכרון • הקצאה סטטית • הקצאה במחסנית • הקצאה בערימה תורת הקומפילציה

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

22. הקוד של CNSUME קוד הקוד של PRDUCE CHARACTER50 BUF INTEGER NEXT CHARACTER C רשומת ההפעלה של CNSUME נתונים סטטיים CHARACTER80 BUFFER INTEGER NEXT רשומת ההפעלה של PRDUCE הקצאה סטטית  דוגמה PROGRAM CNSUME CHARACTER  50 BUF INTEGER NEXT CHARACTER C, PRDUCE DATA NEXT /1/, BUF /’ ‘/ 6 C = PRDUCE( ) BUF ( NEXT : NEXT ) = C NEXT = NEXT + 1 IF ( C .NE. ‘ ‘ ) GOTO 6 WRITE ( , ‘(A)’ ) BUF END CHARACTER FUNCTION PRDUCE( ) CHARACTER  80 BUFFER INTEGER NEXT SAVE BUFFER, NEXT DATA NEXT /81/ IF ( NEXT .GT. 80 ) THEN READ (, ‘(A)’ ) BUFFER NEXT = 1 END IF PRODUCE = BUFFER ( NEXT : NEXT ) NEXT = NEXT + 1 END תורת הקומפילציה

23. הקצאה במחסנית לכל הפעלה של שגרה, נבנית רשומה במחסנית, ובסיום השגרה הרשומה מתבטלת • הרשומה הפעילה נמצאת בראש המחסנית • בנוסף לאוגר ה-sp אפשר שיהיה אוגר נוסף אוגר המסגרת המצביע אל מקום קבוע בתוך רשומת ההפעלה • VAX: Frame Pointer, Argument Pointer • 8086: Base Pointer • מעבדים אחרים: אוגר כללי כלשהו המוקצה לצורך כך קישורית הבקרה היא ערכו הקודם של אוגר זה  כלומר נוצרת רשימה מקושרת של רשימות הפעלה • הגישה לעצמים שבתוך רשומת ההפעלה תיעשה בשיטת מיעון בסיס + העתק (base-displacement), מפני שכל עצם נמצא במרחק ידוע מראש בתוך רשומת ההפעלה (בהנחה שגודל מערכים ידוע בזמן התרגום) תורת הקומפילציה

24. s a : array s a : array s a : array s a : array s מסגרת עבור s s r הופעלה r r i : integer s המסגרת של r נשלפה וזאת של q (1,9) נדחפה r q (1,9) q ( 1, 9 ) i: integer s הבקרה זה עתה חזרה אל q (1,3) r q (1,9) q ( 1, 9 ) i: integer p (1,9) q (1,3) q ( 1, 3 ) i: integer p (1,3) q (1,0) הקצאה במחסנית  דוגמה מיקום בעץ ההפעלה רשומות הפעלה על המחסנית הערות תורת הקומפילציה

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

26. סדר קריאה וחזרה(Calling end Return Sequence) • סדר הפעולות המוסכם המתבצע בקריאה לשגרה ע"י הקוראת והנקראת נקרא סדר קריאה (calling sequence) • סדר הפעולות המוסכם המתבצע בחזרה משגרה ע"י הקוראת והנקראת נקרא סדר חזרה (return sequence) מוסכמות אלה תלויות ב: • שפת המקור • מכונת המטרה • מערכת ההפעלה • טעם אישי של בונה המהדר תורת הקומפילציה

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

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

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

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

31. מערכים בגודל משתנה ישנן שפות בהן ניתן לכתוב: int func ( int n, char a[n] ) { char b[n]; ... } • כלומר גודלו של מערך מקומי נקבע ע"פ ערך פרמטר שהשגרה מקבלת • קיומם של מערכים בגודל שאינו ידוע מראש בזמן התרגום בתוך אזור המשתנים המקומיים ישבש את חישובי ההעתק של העצמים השונים ברשומת ההפעלה, ולא ניתן יהיה לקבוע אותם חד-משמעית בזמן התרגום • יהיה צורך בחישובים "מיותרים" בזמן ריצה תורת הקומפילציה

32. מערך B מערך A משתנים מקומיים וזמניים קישורית בקרה מצב קודם ערכים מוחזרים וארגומנטים מצביע ל-A מצביע ל-B מצביע מסגרת רשומת הפעלה עם מערכיםבגודל משתנה • המערך יימצא מעבר לחלק הקבוע של רשומת ההפעלה • בחלק הקבוע יהיה מצביע אל המערך תורת הקומפילציה

33. מחוונים מתנדנדים(Dangling References) שחרור אוטומטי של זיכרון עלול לגרום לשגיאות אם לא מביאים את קיומו בחשבון: main() { int p; p = dangle( ); } int dangle( ) { int i = 23; return &i; } תיקון אפשרי:המשתנה i צריך להיות סטטי static int i = 23; תיקון נוסף: המשתנה i יוקצה באופן דינמיreturn new int(23); תורת הקומפילציה

34. הקצאה בערימה אפשר להקצות את רשומת ההפעלה מתוך הערימה כאשר: • הערכים של עצמים מקומיים חייבים להישמר גם לאחר סיום ההפעלה של השגרה • זמן החיים של ההפעלה של השגרה הנקראת חורג מזמן החיים של השגרה הקוראת • בלתי אפשרי במודל שהנחנו מקודם • אפשרי כאשר השגרה הנקראת מופעלת כתהליך (process) או משימה (task) או תהליכון (thread) במקביל לשגרה הקוראת תורת הקומפילציה

35. s קישורית בקרה s r קישורית בקרה r q (1,9) q( 1, 9) קישורית בקרה הקצאה בערימה  דוגמה מיקום בעץ ההפעלה רשומות הפעלה על המחסנית הערות רשומת ההפעלה של השגרה r נשמרת תורת הקומפילציה

36. ניהול הערימה • מאחר וסדר השחרורים בערימה אינו תמונת ראי של סדר ההקצאות נוצרים אזורים מבודדים של זיכרון חופשי • מצב זה נקרא שיבוב (fragmentation) • מאחר וההקצאות הדרושות הינן של שטחים רציפים, השיבוב עשוי לגרום לבזבוז וחוסר מדומה של מקום • ישנן אסטרטגיות שונות להקצאה במטרה להקטין את תוחלת המקום המבוזבז • ישנן מערכות ושפות (lisp, java) שבהן המערכת התומכת מבצעת איסוף זבל (garbage collection) אוטומטי • במערכות אלה אובייקט חי עשוי לשנות את מקומו בזיכרון, ויש צורך לשנות את ערכי המצביעים אליו used used free used free used free תורת הקומפילציה

37. גישה לשמות לא-מקומיים חוקי הגישה של השפה קובעים כיצד ניגשים לשמות לא-מקומיים • חוק תחום לקסיקאלי (lexical scope) או תחום סטטי (static scope) • מקובל יותר ― למשל בשפת C, Pascal, Ada, Perl • חוק תחום דינמי (dynamic scope) • פחות מקובל ― למשל Lisp, APL, Snobol, Perl תורת הקומפילציה

38. גוש (Block) גוש (block)פסוק מורכב היכול להכיל הצהרות של שמות מקומייםגוש נתחם ע"י סימנים של השפה • C { } • Pascalbegin end חפיפה בין גושים אפשרית אך ורק אם גוש אחד מכיל בשלמותו את גוש השני תורת הקומפילציה

39. חוקי תחום של גושים • התחום של הצהרה המופיעה בגוש B כוללת את B • אם השם x איננו מוגדר בגוש B, אזי הופעה של x ב-B תהיה בתחום של הצהרה על x בבלוק 'B הכולל את B כך ש: א. ישנה הצהרה על x בגוש 'B ב. 'B הינו הגוש הקטן ביותר המכיל ההצהרה על x מבין כל הגושים הכוללים את B תורת הקומפילציה

40. B2 B0 B1 B3 גושים  דוגמה main( ) { int a = 0 ; int b = 0 ; { int b = 1 ; { int a = 2 ; printf (“%d %d\n”, a, b); } { int b = 3 ; printf (“%d %d\n”, a, b); } printf (“%d %d\n”, a, b); } printf (“%d %d\n”, a, b); } תורת הקומפילציה

41. a0 b0 b1 a2,b3 הקצאת הזיכרון לגושים שתי שיטות אפשריות: • נתייחס לגוש כאל שגרה חסרת פרמטרים • נקצה זיכרון בכניסה לגוש • נשמור זיכרון ביציאה מהגוש • יתרון  חיסכון במקום • חסרון  עלות בזמן (הקצאה ושחרור)  במיוחד כשהגוש נמצא בתוך לולאה • נקצה את כל הזיכרון הנחוץ לכלל הגושים של שגרה עם הכניסה לשגרה • גושים שאינם מכילים זה את זה  הזיכרון שלהם יכול להיות חופף • יתרון  חיסכון בזמן הקצאה/שחרור • חסרון  בזבוז מקום (למשל בהקצאת זיכרון גדול לגוש שאיננו מופעל) תורת הקומפילציה

42. תחום לקסיקאליללא קינון שגרות בשפת C אין אפשרות להגדיר שגרות מקוננות, ועל כן חוקי התחום פשוטים יותר (1) int a[11]; (2) readarray( ) { … a … } (3) int partition(int y,int z) { … a … } (4) quicksort(int m,int n) { … } (5) main( ) { … a … } • שמות מקומיים נמצאים ברשומת ההפעלה בראש המחסנית • שמות לא-מקומיים (גלובליים) נמצאים בזיכרון סטטי, בכתובת קבועה תורת הקומפילציה

43. תחום לקסיקאלי עם קינון שגרות בשפת Pascal ניתן לקנן הגדרת שגרות program sort(input, output); var a : array [0..10] of integer; x : integer; procedure readarray; var i : integer; begin . . . a . . . end { readarray } ; procedure exchange(i, j : integer); begin x := a[i]; a[i] := a[j]; a[j] := x end { exchange }; procedure quicksort(m, n: integer); var k, v : integer; function partition(y, z: integer):integer; var i, j :integer; begin . . . a . . . . . . v . . . . . . exchange(i, j); . . . end { partition } ; begin . . . end { quicksort }; begin . . . end { sort } . תורת הקומפילציה

44. תחום לקסיקאליעם קינון שגרות  המשך תורת הקומפילציה

45. עומק קינון (Nesting Depth) • עומק הקינון של התוכנית הראשית הוא 1 • עומק הקינון של השגרה p, המוגדרת בתוך שגרה q, הינו אחד יותר מעומק הקינון של q sort 1 readarray 2 exchange 2 quicksort 2 partition 3 תורת הקומפילציה

46. s a, x s a, x s a, x s a, x p(1,3) accesslink i, j q(1,9) access link k, v q(1,9) access link k, v q(1,3) access link k, v e(1,3) accesslink q(1,9) accesslink k, v q(1,3) accesslink k, v p(1,3) access link i, j q(1,9) accesslink k, v q(1,3) accesslink k, v קישורית גישה (Access Link) • מצביע מרשומת ההפעלה של שגרה בעומק קינון n לרשומת ההפעלה של שגרה בעומק קינון n-1 • מאחר והשגרה בקינון n-1 עשויה להופיע מספר פעמים במחסנית (רקורסיה), יש לקשר לרשומה של ההפעלה האחרונה תורת הקומפילציה

47. איתור בעזרת קישוריות גישה הנחות • בזמן התרגום ידוע עומק הקינון של כל שגרה • בזמן התרגום ידוע באיזה גוש/שגרה נמצאת ההצהרה של כל שם שתחום ההגדרה שלו כולל את הגוש/שגרה אליה מתייחסים כרגע המשימה בשגרה p יש לאתר את הזיכרון של לא-מקומי a עומק הקינון np (של p) ו-na (של a) ידועים בזמן תרגום תורת הקומפילציה

48. איתור בעזרת קישוריות גישה  2 השיטה • לך np – na צעדים בעקבות קישוריות הגישה, ומצא את הרשומה בה הוקצה הזיכרון ל-a • השתמש בהסט (הקבוע) של a ברשומה ע"מ לאתר את a אבחנה כל שם (לא-מקומי) יש לייצג ע"י זוג מספרים (np – na, offset) • הפרש עומקי הקינון בין השגרה המשתמשת והשגרה המצהירה • הסט בין העוגן (קישורית הגישה) של הרשומה ובין מיקומו של הזיכרון המקושר לאותו שם תורת הקומפילציה

49. בניית קישוריות גישה שגרה p בעומק קינון np מפעילה את שגרה q בעומק קינון nq • np < nq • ע"פ חוקי התחום q מוגדרת ישירות בתוך p, ועל כן np +1 = nq • הקישורית של q תצביע ישירות לקישורית של p • np nq • ע"פ חוקי התחום, השגרות בעומקים 1,2… nq-1 זהות עבור pו-q • הקישורית של q תצביע לקישורית של השגרה בעומק nq-1 שאותה ניתן לאתר ע"י np-nq+1 צעדים מהקישורית של p • np-nq+1 הוא מספר הידוע בזמן התרגום תורת הקומפילציה

50. שגרות כפרמטרים שגרה קוראתמפעילה שגרה נקראתומעבירה כפרמטר שגרה מועברת דוגמה program param(input, output); procedure b(function h(n:integer): integer); begin writeln(h(2)) end { b }; procedure c; var : integer; function f(n : integer) : integer; begin f :=  + n end { f }; begin  := 0; b(f) end { c }; begin c end. cקוראת bנקראת f מועברת תורת הקומפילציה