1. No category

‫השוואה בין שפות תכנות‬
‫)ועוד מטה‪-‬תכנות(‬
‫בספר‪ :‬פרק ‪4‬‬
‫‪1‬‬
‫השוואה בין שפות תכנות‬
‫הגדרה‪ :‬פונקציה ‪ f‬ניתנת לחישוב )חשיבה ‪ (computable‬בשפת תכנות ‪L‬‬
‫אם קיימת תכנית ‪ p‬ב‪ L-‬כך ש ‪.〚p〛L = f‬‬
‫הגדרה‪ :‬שפת תכנות ‪ L1‬חזקה לפחות כמו שפת תכנות ‪ L2‬אם כל פונקציה‬
‫הניתנת לחישוב ב‪ L2-‬ניתנת לחישוב גם ב‪.L1-‬‬
‫סימון‪L1 f L2 :‬‬
‫=< ניתן לחשוב על הסימן ‪ f‬כמציין הכלה בין קבוצות!‬
‫טענה‪ :‬אם ‪ L1,L2,L3‬מקיימות ‪ L2 f L1‬ו‪ L3 f L2-‬אזי ‪.L3 f L1‬‬
‫הגדרה‪ :‬השפות ‪ L1‬ו‪ L2-‬שקולות אם ‪ L1 f L2‬וגם ‪.L2 f L1‬‬
‫סימון‪.L1≡ L2 :‬‬
‫‪2‬‬
‫• את הטענה‪ L1 f L2 :‬ניתן להביע באופן ששם דגש על תוכניות )יותר‬
‫מאשר פונקציות(‪.‬‬
‫• התוכלו להשלים את הניסוח?‬
‫______________________ ‪∀p∈L2-prog ∃q∈L1-prog :‬‬
‫• יש מקרים שהניסוח המקורי נוח יותר לשימוש‪ ,‬ויש מקרים שהנ"ל עדיף‪.‬‬
‫בדרך כלל‪:‬‬
‫– הניסוח עם תוכניות עדיף להוכחות קונסטרוקטיביות שהיחס מתקיים‪.‬‬
‫– הניסוח עם פונקציות עדיף להוכחות שליליות )שהיחס אינו מתקיים(‪.‬‬
‫‪3‬‬
‫דוגמה ‪1‬‬
‫תהי ‪ L1‬שפה שיש בה תוכנית אחת בלבד ‪ p1‬והסמנטיקה שלה היא‬
‫‪∀d∈D : 〚p1〛L1 d = d‬‬
‫ותהי ‪ L2‬שפה שיש בה תוכנית אחת בלבד ‪ p2‬השקולה לתוכנית ה‪-‬‬
‫‪ WHILE‬הבאה‪:‬‬
‫‪read X ; Y := tl X ; write Y‬‬
‫טענה‪ :‬אף אחד מהיחסים ‪ L1pL2, L1fL2‬אינו מתקיים‪.‬‬
‫ הוכחה‪:‬‬
‫‪4‬‬
‫דוגמה ‪2‬‬
‫• תהי ‪ NOLOOP‬שפה שזהה ל‪ WHILE-‬בתחביר‬
‫ובסמנטיקה למעט זה שאין פקודת לולאה‪.‬‬
‫• טענה ‪WHILE f NOLOOP :1‬‬
‫– טריוויאלי!‬
‫• תרגיל‪ :‬האם ‪? WHILE p NOLOOP‬‬
‫‪5‬‬
‫קומפילציה ויחסי‪-‬כוחות‬
‫• נניח שקיים קומפיילר מ‪ S-‬ל‪) T-‬לא חשוב איך ממומש!(‪.‬‬
‫אזי ‪. S p T‬‬
‫• הערות‪:‬‬
‫– לא תמיד יתקיים ‪.S ≡ T‬‬
‫– המשפט ההפוך‪ :‬אם ‪ S p T‬אז קיים קומפיילר מ‪ S-‬ל‪ - T-‬אינו נכון‪.‬‬
‫ נכון או לא נכון?‬
‫אם הקומפיילר ממומש בשפה ‪ I‬אז בהכרח ‪S p I‬‬
‫• מה אם ידוע שיש מפרש ל‪ S-‬הממומש ב‪? I-‬‬
‫‪6‬‬
‫• תהי ‪ L1‬שפה שיש בה תוכנית אחת בלבד ‪ p1‬והסמנטיקה שלה היא‬
‫‪∀d∈D : 〚p1〛L1 d = d‬‬
‫• ותהי ‪ L2‬שפה שיש בה תוכנית אחת בלבד ‪ p2‬השקולה לתוכנית ה‪-‬‬
‫‪ WHILE‬הבאה‪:‬‬
‫‪read X ; Y := tl X ; write Y‬‬
‫• טענה ‪ :1‬אף אחד מהיחסים ‪ L1fL2, L2fL1‬אינו מתקיים‪.‬‬
‫• טענה ‪ :2‬התוכנית ‪ p2‬מהווה מפרש לשפת המקור ‪.L1‬‬
‫• הוכחה‪:‬‬
‫‪∀p∈L1-prog ∀d∈D : 〚p2〛L2 (p.d) = d =〚p〛L1 d‬‬
‫• מסקנה‪ :‬יש מפרש ל‪ S-‬הממומש ב‪ - I-‬לא מוכיח ‪. S p I‬‬
‫• אבל זהו מצב פתולוגי‪ .‬לדוגמה עבור ‪ WHILE‬ושפות שקולות לה‬
‫היחס ה"צפוי" מתקיים‪.‬‬
‫‪7‬‬
‫משפט‪:‬‬
‫אם קיים מפרש לשפה ‪ M‬בשפה ‪ ,WHILE‬אזי ‪. M p WHILE‬‬
‫הוכחה‪ :‬לפי ההנחה קיים מפרש ‪ .int‬הוא מקיים‪:‬‬
‫‪∀p∈M-prog ∀d∈D : 〚int〛WHILE (p.d) = 〚p〛M d‬‬
‫תהי ‪ p‬תוכנית כלשהי ב‪ M-‬ותהי‪:‬‬
‫)‪q =〚spec〛(int . p‬‬
‫נזכיר את התכונה של ‪:spec‬‬
‫)‪〚〚spec〛(p.s) 〛L d =〚p〛L (s.d‬‬
‫מכאן‬
‫_________________ = ‪〚q〛d = 〚〚spec〛(int.p) 〛d‬‬
‫מסקנה‪ :‬לכל תוכנית ב‪ M-‬יש תוכנית שקולה ב‪ .WHILE-‬מש"ל‬
‫‪8‬‬
‫משפט‪:‬‬
‫תהי ‪ L‬שפה שקולה ל‪.WHILE-‬‬
‫אם קיים מפרש לשפה ‪ M‬בשפה ‪ L‬אז ‪.MpL‬‬
‫הוכחה‪:‬‬
‫נניח כי קיים מפרש ‪ intL‬ל‪ M-‬כתוב ב‪ .L-‬מהנתון ‪L ≡ WHILE‬‬
‫נובע‪ ,‬כי קיימת תוכנית ‪ WHILE‬השקולה ל‪ ,intL-‬נאמר ‪.int‬‬
‫אזי ‪ int‬היא מפרש ל‪ M-‬ב‪ .WHILE-‬לפי הטענה הקודמת‪ ,‬נובע‬
‫‪ . M p WHILE‬אבל ‪ , L ≡ WHILE‬לכן ‪. M p L‬‬
‫• זוהי מסקנה מהמשפט הקודם‪ .‬מסקנה אחרת בשקופית הבאה‬
‫‪9‬‬
‫הטלות פוּטמוּרה‬
‫• שלוש דרכים מעניינות להשתמש ב‪...spec-‬‬
‫• משפט )הטלת פוטמורה ‪ :(I‬תהי ‪ L‬שפה שקיים עבורה‬
‫מצמצם‪ .‬אם ישנו מפרש לשפה ‪ M‬ב‪ L -‬אזי ‪.M p L‬‬
‫• הוכחה‪ :‬כבר ראינו )כאשר ‪ L‬הייתה ‪.(WHILE‬‬
‫תקציר‪ :‬לכל ‪ p∈M-prog‬ניתן ליצור תוכנית שקולה ב‪L-‬‬
‫)‪q = 〚spec〛(int . p‬‬
‫• זוהי "קומפילציה ללא קומפיילר"‬
‫‪10‬‬
‫משפט )הטלת פוטומורה ‪ :(II‬תהי ‪ L‬שפה שקיים עבורה‬
‫מצמצם )המיושם ב‪ .(L-‬אם ישנו מפרש לשפה ‪ M‬ב‪ L -‬אזי‬
‫ישנו קומפיילר מ‪ M-‬ל‪.L-‬‬
‫הוכחה‪ :‬נייצר את התוכנית הבאה ‪.comp‬‬
‫)‪comp =〚spec〛L (spec . int‬‬
‫)‪(!self-application‬‬
‫נוכיח שקיבלנו קומפיילר‪ :‬לכל ‪,p∈M-prog‬‬
‫= ‪〚 comp〛L p = 〚〚spec〛(spec .int) 〛p‬‬
‫)‪〚spec〛(int . p‬‬
‫זוהי תוכנית ב‪ L-‬השקולה ל‪) p-‬הטלה ‪ (I‬ולכן ‪ comp‬מקיים‬
‫את הנדרש מקומפיילר!‬
‫‪11‬‬
‫הטלת פוטומורה ‪:III‬‬
‫נייצר את התוכנית הבאה ‪.gen‬‬
‫)‪gen =〚spec〛L (spec . spec‬‬
‫יהי ‪ int‬מפרש לשפה כלשהי ‪ ,S‬הכתוב ב‪.L-‬‬
‫ מה הסמנטיקה של התוכנית הנוצרת מהפעלת ‪ gen‬על ‪?int‬‬
‫‪12‬‬
‫אלגוריתמי קומפילציה‬
‫בספר‪ :‬פרק ‪5 - 4‬‬
‫‪13‬‬
‫חשוב לזכור‬
‫•‬
‫•‬
‫•‬
‫•‬
‫‪14‬‬
‫אלגוריתם קומפילציה מטפל בתוכנית ברמה תחבירית‬
‫– אינו אמור לבצע )אם כי השיקולים בתכנון‬
‫האלגוריתם הם כמובן סמנטיים(‪.‬‬
‫הקומפיילר מקבל תוכנית בתחביר קונקרטי ומחזיר‬
‫תוכנית יעד בתחביר קונקרטי‪.‬‬
‫אולם ברמת האלגוריתם חשוב יותר להתייחס לתחביר‬
‫המופשט‪.‬‬
‫אנו נשתמש להצגת האלגוריתם בתחביר הלא‪-‬פורמלי‪.‬‬
‫דוגמה ‪ :1‬שפת ‪DOWHILE‬‬
‫השפה ‪ DOWHILE‬היא הרחבה של ‪ ,WHILE‬בעלת‬
‫מבנה זהה למעט תוספת אחת – פקודת לולאה שבה‬
‫התנאי נבדק אחרי ביצוע גוף הלולאה ולא קודם לכן‪.‬‬
‫פקודה חדשה‬
‫‪15‬‬
‫‪C, D ∈ Command ::= X := E‬‬
‫‪|C;D‬‬
‫‪| while E do C‬‬
‫‪| if E then C else D‬‬
‫‪| do C while E‬‬
‫קומפילציה של ‪ DOWHILE‬ל‪WHILE-‬‬
‫‪ .1‬רעיון הקומפילציה‪ :‬איך נתגבר על ההבדל בין השפות?‬
‫‪ .2‬בניית טבלת המרה המאפשרת לטפל בכל תוכנית מקור‬
‫באופן אוטומטי‪.‬‬
‫‪16‬‬
‫טבלת המרה = אלגוריתם קומפילציה‬
‫הקלט‬
Program:
read x; C; write y
‫הפלט‬
read x; C; write y
‫המרה של‬
Commands:
X:=E
C;D
while E do C
if E then C else D
do C while E
X:=E
C;D
while E do C
if E then C else D
C ; while E do C
17
‫סיכום תיאורטי‬
‫• הקומפילציה מוכיחה כי ‪DOWHILE p WHILE‬‬
‫• כיוון הפוך‪ – DOWHILE f WHILE :‬טריוויאלי‬
‫• לכן ‪DOWHILE ≡ WHILE‬‬
‫‪18‬‬
WHILE1OP ‫ שפת‬:2 ‫דוגמה‬
E, F ∈ Expression ::= X
|d
| hd X
| tl X
| cons X Y
C, D ∈ Command ::= X := E
| C;D
| while X do C
| if X then C else D
Program ::= read X ; C; write Y
X, Y ∈ Variable
d∈D
19
‫קומפילציה של ‪ WHILE‬ל‪WHILE1OP-‬‬
‫‪ .1‬רעיון הקומפילציה‪ :‬איך נתגבר על ההבדל בין השפות?‬
‫דוגמה‪:‬‬
‫)‪Y := cons (hd X) (tl X‬‬
‫‪ .2‬בניית טבלת המרה המאפשרת לטפל בכל תוכנית מקור‬
‫באופן אוטומטי‪.‬‬
‫‪20‬‬
Program:
read X; C; write Y
read X; C; write Y
Commands:
C;D
C;D
Y := X
Y := X
Y := d
Y := d
Y := hd E
Y := tl E
Z := E ; Y := hd Z Z’s are fresh variables
Z := E ; Y := tl Z
Y := cons E1 E2
Z1 := E1 ; Z2 := E2 ; Y := cons Z1 Z2
if E then C else D
Z := E ; if Z then C else D
while E do C
Z := E ; while Z do { C ; Z := E }
21
‫דיון ביעילות של קומפילציה‬
‫•‬
‫שתי שאלות עשויות לעניין אותנו‪:‬‬
‫‪ .1‬מה יעילות הקומפיילר?‬
‫‪ .2‬מה יעילותה של תוכנית היעד?‬
‫•‬
‫•‬
‫•‬
‫‪22‬‬
‫ניתוח שאלה מס' ‪ – 1‬כמו כל אלגוריתם‪.‬‬
‫ניתוח שאלה מס' ‪ – 2‬ע"י השוואת קוד היעד לקוד המקור‪.‬‬
‫אם תוכנית המקור היא ‪ p‬ותוכנית היעד ‪ ,q‬רוצים לחסום‬
‫את )‪ timeq(d‬ע"י )‪.timep(d‬‬
‫תרגיל‪ :‬ניתוח היעילות של הקומפילציה שראינו )ונתחיל‬
‫בשאלה היותר חשובה(‪.‬‬
‫שפת ‪GOTO‬‬
‫•‬
‫•‬
‫•‬
‫•‬
‫‪23‬‬
‫שפת ‪ WHILE‬היא דוגמה לשפה מבנית‪.‬‬
‫השפה הבאה ‪ GOTO‬היא שפה לא מבנית‪.‬‬
‫בשתיהן טיפוס נתונים אחד ‪D -‬‬
‫בשפה לא מבנית‪ ,‬תוכנית היא רשימת הוראות‬
‫‪ .instructions‬כל הוראה מבצעת פעולה פשוטה‬
‫אחת‪ .‬הביצוע ממשיך מהוראה להוראה הבאה אחריה‬
‫או מדלג עפ"י הוראת "הסתעפות" ‪.branch‬‬
GOTO ‫תחביר שפת‬
Program ::= read X ; I1; I2; … Im; write Y
I ∈ Instruction ::=
|
|
|
|
|
X := d
X := Y
X := hd Y
X := tl Y
X := cons Y Z
if X then L1 else L2
X, Y, Z ∈ Variable
d ∈D
L1, L2 ∈ {1,…,m+1}
24
‫תוכנית לדוגמה‬
read X
1: if X then 2 else 6
2: Z := hd X
3: Y := cons Z Y
4: X := tl X
‫ממתיק תחבירי‬
5: goto 1
write Y
25
‫הערות‬
‫‪ .1‬שימו לב שהתחביר אינו כולל את אותן מחלקות כמו‬
‫ב‪ – WHILE-‬אל תערבבו בין השפות!‬
‫‪ .2‬לחישובי זמן ריצה – כל הוראה = צעד אחד )יחידת‬
‫זמן(‪.‬‬
‫ זמן הריצה של התוכנית שהוצגה על קלט ‪ d‬הוא ____‬
‫‪26‬‬
‫תחביר קונקרטי‬
read Vi ; I1 I2 ... Im ; write Vj =
( i ( I1 I2 ... Im ) j )
Vi := d
=
(setq i d)
Vi := Vk
=
(setv i k)
Vi := hd Vk
=
(sethd i k)
Vi := tl Vk
=
(settl i k)
Vi := cons Vk Vl
=
(setcons i k l)
if Vi then L1 else L2
=
(if i L1 L2)
27
‫קומפילציה מ‪ WHILE-‬ל‪GOTO-‬‬
‫• ‪ WHILE‬היא שפה מבנית – יש בה פקודות מקננות‬
‫וביטויים מקננים‪ .‬את כל אלה צריך "לפרק" בתרגום‬
‫ל‪.GOTO-‬‬
‫• התרגום ל‪ WHILE1OP-‬כבר פירק את הביטויים‬
‫המורכבים‪ .‬לכן נציג קומפילציה מ‪WHILE1OP-‬‬
‫ל‪.GOTO-‬‬
‫‪28‬‬
‫קלט‬
‫פלט‬
WHILE1OP ‫יחידה תחבירית בשפת‬
‫הוראה או קבוצת הוראות‬
Program:
read X; C; write Y
read X; C; write Y
Commands:
C;D
C;D
X := Y
X := Y
X := d
X := d
X := hd Y
X := hd Y
X := tl Y
X := tl Y
X := cons Y Z
X := cons Y Z
29
if X then C else D
i:
if X then i+1 else i+2+|C|
i+1:
C
i+1+|C|: goto i+2+|C|+|D|
i+2+|C|: D
while X do C
i:
if X then i+1 else i+2+|C|
i+1:
C
i+1+|C|: goto i
‫ההוראות ממוספרות ע"י הקומפיילר‬
30
‫קשרים בין ‪ WHILE‬ל‪GOTO-‬‬
‫משפט‪WHILE p GOTO :‬‬
‫הוכחה‪ :‬הראינו כעת כי _________________‬
‫ומוקדם יותר הראינו כי _____________‬
‫ולכן ‪.WHILE p GOTO‬‬
‫• האם ‪ - WHILE f GOTO‬האם ניתן לחקות‬
‫”‪) “goto‬דילוגים בין הוראות( בשפה מבנית טהורה‬
‫)כמו ‪?(WHILE‬‬
‫‪31‬‬
WHILE-‫ ל‬GOTO-‫קומפילציה מ‬
reverse ‫• נדגים את הרעיון על התוכנית‬
read X
PC := 1 ;
while PC do
case PC of
1 =>
2 =>
3 =>
4 =>
5 =>
6 =>
write Y
if X then PC := 2 else PC := 6 ;
Z := hd X ;
PC := 3 ;
Y := cons Z Y ; PC := 4 ;
X := tl X ;
PC := 5 ;
if X then PC := 1 else PC := 1 ;
PC := 0
32
‫אלגוריתם הקומפילציה = כללי המרה‬
GOTO :‫קלט‬
read X
C1;
C2;
1:
2:
.....
n: Cn;
n+1: writeY
WHILE :‫פלט‬
read X
PC := 1;
while PC do
case PC of
1 => PC:=2; C1;
2 => PC:=3; C2;
....
n => PC:=n+1; Cn;
n+1=> PC:=0
write Y
(‫)התרגום זהה למקור‬
X := SE
X := SE
if X then l else l’
if X then PC:=l else PC:=l’
33
‫ שפת‬:‫דוגמה מתקדמת לקומפילציה‬
WHILE1VAR
E, F ∈ Expression ::= X
|d
| hd X
| tl X
| cons X Y
C, D ∈ Command ::= X := E
| C;D
| while X do C
| if X then C else D
Program ::= read X ; C; write Y
X, Y ∈ Variable
d∈D
34
‫דוגמה מתקדמת לקומפילציה‪ :‬שפת‬
‫‪WHILE1VAR‬‬
‫השפה ‪ WHILE1VAR‬מוגדרת בדיוק כמו ‪ ,WHILE‬אבל‬
‫מותר להשתמש במשתנה אחד בלבד‪.‬‬
‫דוגמה‪ :‬התוכנית הבאה אינה חוקית בשפה זו‬
‫‪read X‬‬
‫‪Y := cons X X‬‬
‫‪write Y‬‬
‫‪35‬‬
‫‪ .1‬רעיון הקומפילציה‪ :‬איך נתגבר על ההבדל בין השפות?‬
‫אם בתוכנית המקור ‪ p‬מספר משתנים ‪... ,X2 ,X1‬‬
‫המשתנה )היחיד( של תוכנית היעד ‪) q‬נקרא לו ‪(A‬‬
‫יכיל את ערכי כל המשתנים של ‪ ,p‬כרשימה‪.‬‬
‫‪ .2‬בניית טבלת המרה המאפשרת לטפל בכל תוכנית מקור‬
‫באופן אוטומטי‪.‬‬
‫‪36‬‬
Program:
read X; C; write Y
read A;
A := list T1 … Tn
C;
A := hd tl j–1 A
write A
TTi i==AA
Tj
Tj==nil
nil (j(j≠≠i)i)
Commands:
C;D
C;D
if E then C else D
if E then C else D
while E do C
while E do C
Xi := E
A := list T1 … Tn
Ti = E
Tj = Xj (j ≠ i)
37
Expressions:
Xi
d
cons E1 E2
hd E
tl E
hd tl i–1 A
d
cons E1 E2
hd E
tl E
38