פרק 6 בדיקת טיפוסים

פרק 6 בדיקת טיפוסים תורת הקומפילציה

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

סוגי בדיקות בדיקות סטטיות (static checks)בדיקות הנערכות ע"י המהדר בזמן התרגום בדיקות דינמיות (dynamic checks)בדיקות הנערכות ע"י התוכנית עצמה תוך כדי ריצה תורת הקומפילציה

בדיקות סטטיות(Static Checks) • בדיקות טיפוסים (type checks) התאמת טיפוסי ביטויים ע"פ חוקי השפה • בדיקות הזרימה (flow-of-control checks)בדיקת מבני בקרת הזרימהלמשל break שלא נמצא בתוך הלולאה • בדיקות יחידוּת (uniqueness checks)בדיקה שעצם לא מוגדר יותר מפעם אחת בניגוד לחוקי השפה • בדיקות הקשורות לשמות (name related checks)וידוא ששם שמופיע פעמיים זהה בשני המופעיםלמשל בשפת עדה  שם הלולאה בתחילתה ובסופה זהה להלן נתמקד בבדיקות טיפוסים תורת הקומפילציה

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

דרישות להתאמת טיפוסים מתוך הגדרת פסקל (Pascal report) “If both operands of the arithmetic operators of addition, subtraction and multiplication are of type integer, then the result is of type integer.” מתוך הגדרת C (C reference manual) “The result of the unary & operator is a pointer to the object referred to by the operand. If the type of the operand is ‘…’, the type of the result is ‘pointer to …’ .” מסקנה: ע"מ שנוכל להשוות טיפוסים של ביטויים שונים עלינו להגדיר "ביטויי טיפוסים" תורת הקומפילציה

ביטוי טיפוסים(Type Expressions) • טיפוסים בסיסיים כגון:boolean, char, integer, real, voidוכן טיפוס שגיאה מיוחד:type-err • שם שניתן לעיל לטיפוס כלשהו • בנאי טיפוסים (type constructor):א. מערך (array) אם I הינה קבוצת אינדקסים ו-T הינה טיפוס אזי array(I, T) הינו טיפוס "מערך I של T"ב. מכפלה (product)אם T1 ו-T2 הינם טיפוסים אזי T1  T2 הינו טיפוס מכפלה (לאופרטור  אסוציאטיביות שמאלית) תורת הקומפילציה

ביטוי טיפוסים  2 ג. רשומה (record) ההבדל בין רשומה למכפלה היא שלשדות של רשומה ישנם שמות למשל: type row = record address: integer; lexeme: array [1..15] of char end; var table: array [1..101] of row; ואז הטיפוס row הינו: record ((address  integer)  (lexeme  array(1..15, char))) תורת הקומפילציה

ביטוים טיפוסיים  3 ד. מצביע (pointer) אם T הינו טיפוס אזי T הינו טיפוס "מצביע ל-T" ה. פונקציה (function) אם T1 הינו טיפוס הערך שהפונקציה מקבלת ו-T2 הינו טיפוס הערך שהיא מחזירה אזי T1  T2 הינו טיפוס "פונקציה המקבלת T1 ומחזירה T2“ (לאופרטור  אסוציאטיביות ימנית, ועדיפות נמוכה מאשר ) הערה: כאשר פונקציה מקבלת מספר פרמטרים נשתמש באופרטור המכפלה ע"מ להגדיר את טיפוס הערך שהיא מקבלת תורת הקומפילציה

הצגת ביטויי טיפוסים דוגמה:פונקציה המקבלת שני char ומחזירה מצביע ל-integer char char  pointer( integer ) ניתן לייצג את הטיפוס בתור גרף בשני אופנים:    pointer  pointer char char integer char integer עץ DAG תורת הקומפילציה

מערכת טיפוסים(Type System) אוסף חוקים הקובעים עד כמה יש לבדוק התאמת טיפוסים למשל: • האם להשוות אינדקסים של מערך המועבר כפרמטר? • האם להשוות את טיפוסי הפרמטרים של פונקציה המועברת כפרמטר? • האם לבדוק התאמה של טיפוסי עצמים המועברים ע"י כתובת ? יכולים להיות כל מיני חוקי בדיקה ובודק טיפוסים מיישם מערכת טיפוסים מסוימת יישומים שונים עשויים להוביל לתוצאות שונות תורת הקומפילציה

עוד הגדרות מערכת בטוחה (sound)מערכת טיפוסים שבה ניתן לוודא את כל ההתאמות הנחוצות ע"פ חוקי השפה בבדיקות סטטיות בלבד שפה strongly typed כאשר המהדר יכול להבטיח שתוכנית שהוא מקבל לא תיכשל בעת הביצוע בשל שגיאות טיפוס כלומר – שפה שעבורה ניתן לבנות מערכת טיפוסים בטוחה. באופן מעשי ישנן בדיקות שניתן לבצע רק בזמן ריצה למשל – בדיקה לוידוא אי-חריגה מגבולות מערך תורת הקומפילציה

בודק טיפוסים פשוט דקדוק P D;E D  D;Did:T T  char integer array[num]ofT T E  literal numid EmodE E[E] E תוכנית לדוגמה key : integer; key mod 1999 תורת הקומפילציה

בודק טיפוסים פשוט  2 סכמת התרגום לפסוקי הגדרה P D;E D  D;D D  id:T { addtype (id.entry, T.type) } T  char { T.type :=char} T  integer { T.type :=integer} T  T1{ T.type := pointer(T1.type) } T  array[num]ofT1 { T.type := array(1..num.val, T1.type) } תורת הקומפילציה

בודק טיפוסים פשוט  3 סכמת תרגום לביטויים E  literal { E.type :=char} E  num { E.type :=integer} E  id{E.type :=lookup (id.entry) } E  E1modE2{E.type := ( E1.type = integer && E2.type = integer ? integer : type_err)} E  E1[E2]{E.type := ( E2.type = integer && E1.type = array(s,t) ? t : type_err) } E  E1{E.type := ( E1.type = pointer( t) ?t : type_err) } תורת הקומפילציה

הרחבת השפה • הוספת טיפוסים נוספים כגון boolean, real • הוספת אופרטורים נוספים: • אריתמטיים+  / • השוואה< <= = <> > >= • בוליאניםand not or • מעבר מביטויים לפסוקים תורת הקומפילציה

בדיקת טיפוסים פשוטה לפסוקים הסכמה לפסוקים S  id:=E { S.type :=( id.type = E.type ? void : type_err ) } S  ifEthenS1 { S.type :=( E.type = boolean? S1.type : type_err ) } S  whileEdoS1 { S.type :=( E.type = boolean? S1.type : type_err ) } S  S1;S2{ S.type := ( S1.type = void && S2.type = void ? void : type_err ) } תורת הקומפילציה

בדיקת טיפוסים פשוטה לפונקציות סכמה להגדרת טיפוסי פונקציות T  T1->T2{ T.type := T1.type T2.type } סכמה להגדרת קריאה לפונקציות E  E1(E2){ E.type := ( E2.type = S && E1.type = S t? t: type_err) } תורת הקומפילציה

שקילות טיפוסים(Type Equivalence) לצורך בדיקת נכונות התוכנית יש להשוות ביטויי טיפוסים, למשל בפסוק x := y צריך לבדוק שהטיפוס של x ושל y זהים (או שקולים) קיימים שני סוגי שקילות • שקילות מבנה (structural equivalence) • שקילות שם (name equivalence) תורת הקומפילציה

שקילות מבנה שני טיפוסים יהיו שקולים אם הם בעלי אותו מבנה דוגמה typedef cell link ; link next ; link last ; cell p ; cell q, r ; כל חמשת המשתנים r ,q ,p ,last ,next הם מטיפוס מאותו מבנה ועל כך הם שקולי מבנה בשפת C משמעות הדבר שהם טיפוסים זהים תורת הקומפילציה

אלגוריתם לבדיקת שקילות מבנה booleansequiv(types, typet){ if( sandtare the same basic type) returntrue ; elseif(s=array(s1,s2)&&t=array(t1,t2) ) return sequiv(s1,t1)&&sequiv(s2, t2) ; elseif ( s = s1 s2&&t =t1 t2 ) returnsequiv(s1,t1)&&sequiv(s2, t2) ; elseif ( s = pointer(s1)&&t = pointer(t1) ) returnsequiv(s1,t1) ; elseif ( s = s1 s2&&t = t1t2 ) returnsequiv(s1,t1)&&sequiv(s2, t2) ; else return false ; } תורת הקומפילציה

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

שיטה להתאמת מספריםלביטויי טיפוס ע"פ השיטה של מהדר C שכתב D. M. Ritchie הטיפוסים היסודים boolean ,char ,integer ,real הבנאים מצביע ל-tpointer ( t ) פונקציה שמקבלת פרמטרים כלשהם ומחזירה tfreturns ( t ) מערך של גודל כלשהו שאיבריו מטיפוס tarray ( t ) תורת הקומפילציה

שיטה להתאמת מספריםלביטויי טיפוס  המשך נתאים את הקודים הבאים boolean 0000pointer 01 char 0001array 10 integer 0010freturns 11 real 0011 רשומה(struct)מקבלת קוד של טיפוס בסיסי חדש דוגמאות 000000 0001char 0000110001 freturns(char) 0001110001 pointer(freturns(char)) 1001110001 array(pointer(freturns(char))) תורת הקומפילציה

שקילות שמות • בפסקל זהות מבנה איננה מספיקה, ויש צורך בזהות שמות. • על כן, next ו-last הם מאותו טיפוס, וכן q ו-r • אולםnext ו-p הם מטיפוס שונה • יתר על כן, p ו-q הם מטיפוס שונה כאילו ההגדרה היתה: type link =  cell; var next : link; last : link; p :  cell; q, r :  cell; type link =  cell; np =  cell; nqr =  cell; var next : link; last : link; p : np; q : nqr; r : nqr; תורת הקומפילציה

next last p q r link pointer pointer pointer cell ייצוג הטיפוסיםלשקילות שמות • נייצג את הטיפוסים ע"י גרף • כל פעם שטיפוס בסיסי חדש נראה  נייצר צומת עלה • כל פעם שבנאי טיפוסים נראה  נייצר צומת חדש המקושר לעץ • כל פעם שמוגדר שם חדש  נייצר צומת עלה עם מצביע מיוחד לביטוי המגדיר אותו • שני טיפוסים יהיו זהים אם"ם הם מיוצגים ע"י אותו צומת בגרף דוגמה תורת הקומפילציה

cell = record    next pointer info integer מעגליות בייצוג טיפוסים נתבונן בקטע הבא: type link =  cell; cell = record info : integer; next : link end; הטיפוס cell הינו רשומה המכילה שדה שהינו מצביע ל-cellמעגליות cell = record    next pointer info integer ייצוג רקורסיבי ייצוג מעגלי cell תורת הקומפילציה

פתרון המעגליות • בשפת C שקילות טיפוסים נעשית ע"פ שקילות מבנה,למעט כאשר מדובר במבנים struct, union (או class ב-C++) • מבנים אלה יהיו שקולים ע"פ שם • ב-C חייבים כל השמות להיות מוגדרים לפני שמשתמשים בהם,למעט תגים של מבנים בהם מותר להשתמש רק לצורך מצביעים • המעגליות ב-C אפשרית אם כן, רק במצביעים למבנים שבהם כאמור מוגדרת שקילות שם תורת הקומפילציה

המרת טיפוסים(Type Conversions) • שפה יכולה לספק שיטות שונות להמרת טיפוסים • ב-C++ 4 סוגים • לעיתים יש צורך בהמרה אוטומטית ע"י המהדר הנקראת המרה בכפיה (coercions) • כאשר האופרנדים של פעולה אינם תואמים • כאשר ערך מטיפוס אחד מוצב למשתנה מטיפוס אחר תורת הקומפילציה

המרה בכפיה של טיפוסים סכמות להמרה בכפיה E num E.type := integer E num . num E.type := real E id E.type := lookup( id.entry ) E E1opE2 E.type := (E1.type = integer && E2.type = integer) ? integer : (E1.type = integer && E2.type = real ) ? real : (E1.type = real && E2.type = integer) ? real : (E1.type = real&& E2.type = real ) ? real : type_err תורת הקומפילציה

תום פרק 6 תורת הקומפילציה

פרק 6 בדיקת טיפוסים

פרק 6 בדיקת טיפוסים

Presentation Transcript