מודולה-2

שפת תכנות
(הופנה מהדף Modula-2)

מוֹדוּלה־2אנגלית: Modula-2) היא שפת תכנות מובנת ופרוצדורלית שפותחה על ידי ניקלאוס וירת בין השנים 1977–1988 במכון הטכנולוגי של ציריך.[1] מודולה־2 הורחבה במקור מפסקל,[וירת 1] והיא ירשה את הפיתוח של מודולה,[א][וירת 2] שהופסק לטובת הפיתוח של מודולה־2 כדי לתת מענה מקיף לכל החסרונות של פסקל.[1][2][מדריך 1][סקירה 1]

מוֹדוּלה־2
Modula-2
פרדיגמות תכנות אימפרטיבי, מודולריות, תכנות מובנה, concurrent computing עריכת הנתון בוויקינתונים
תאריך השקה 1978 עריכת הנתון בוויקינתונים
מתכנן ניקלאוס וירת
מפתח ניקלאוס וירת
טיפוסיות חזקה, סטטית
מימושים ETH, GNU, ADW
ניבים PIM2, PIM3, PIM4, ISO
הושפעה על ידי מֶסה,[מדריך 1] פסקל,[מדריך 1] מודולה[מדריך 1]
השפיעה על מודולה־3, עדה, לואה
לעריכה בוויקינתונים שמשמש מקור לחלק מהמידע בתבנית OOjs UI icon info big.svg

היסטוריהעריכה

בשנת 1976 וירת ביקר במעבדת פארק, היכן שתפס את ההשראה לפיתוח של מודולה־2 משפת התכנות מֶסַה.[מדריך 1][1]

 
בשנת 1980 DISER Lilith היה המחשב הראשון שהושק עם מערכת הפעלה שפותחה במודולה־2.[1]

בשנת 1977 וירת התחיל את הפיתוח של מודולה־2 כהמשך לפיתוח של מודולה, וכתחליף לפסקל.[מדריך 1] וירת תכנן את מודולה־2 שתהיה שפת תכנות מערכות ושפת תכנות כללית במחשבי DISER Lilith.[1][מדריך 1] תחביר השפה היה דומה יותר לזה של מודולה מאשר לפסקל, לכן וירת החליט לקרוא לה מודולה־2.[מדריך 1]

בשנת 1978 פורסמה המהדורה הראשונה של הדו"ח של אפיון השפה.[וירת 3]

בשנת 1979 נוצר היישום השימושי הראשון של השפה עבור מחשבי ה־PDP-11 בשימוש פנימי של המכון הטכנולוגי של ציריך.[מדריך 1]

בשנת 1980 פורסמה המהדורה השנייה של הדו"ח של האפיון השפה.[וירת 4][מדריך 1]

בשנת 1981 מהדר השפה שוחרר בפעם הראשונה לציבור הרחב.[מדריך 1] מיד לאחר מכן השפה צברה פופולריות ונוצר עניין ציבורי בפרסום מדריך רשמי עבור השפה.[מדריך 1]

בשנת 1982 פורסמה המהדורה הראשונה של מדריך השפה מאת ניקלאוס וירת על ידי הוצאת שפרינגר.[וירת 5]

בשנת 1983 פורסמה המהדורה השנייה של השפה (PIM2).[וירת 6]

בין השנים 1983–1985 וירת החליט לפתח מהדר משלו עבור השפה. המהדר של וירת היה מהיר ויעיל בהרבה מהמהדרים שהוצעו עד כה לשפה.[1][וירת 7]

בשנת 1985 פורסמה המהדורה השלישית של השפה (PIM3).[וירת 8]

בשנת 1988 פורסמה המהדורה הרביעית של השפה (PIM4).[וירת 9]

בשנת 1989 וירת פרסם מאמר בו התייחס לתכנות מונחה עצמים במודולה־2, למרות שבמקור לא עוצבה לכך. במאמר וירת הציע פתרון לחיקוי הורשה במודולה־2 באמצעות היכולת של השפה להתעלם מאכיפת טיפוסיות בתכנות מערכות.[וירת 10]

בשנת 1996 ארגון התקינה הבין־לאומי (ISO) פרסם תקן מקיף לשפת התכנות מודולה־2. מכיוון שהיו בו שינויים מזעריים אך מחייבים בשפה, הוא נחשב לניב נוסף של השפה.[3]

בשנת 2010 שוחררה הגרסה הראשונה של המימוש החופשי GNU Modula-2 עבור המהדר GCC לציבור הרחב מטעם מיזם גנו.[4]

בשנת 2011 שוחררה הגרסה הראשונה של המהדר החינמי ADW Modula-2 לציבור הרחב אחרי שירש את הפיתוח של המהדר Stony Brook Modula-2.[5]

דוגמאותעריכה

שלום, עולם!עריכה

MODULE HelloWorld
    IMPORT InOut;
BEGIN
    InOut.WriteString("Hello, world!");
    InOut.WriteLn;
END HelloWorld.

מחלק משותף מרביעריכה

הדוגמה הבאה מוצאת את המחלק המשותף המריבי בין המונה x למכנה y בשבר פשוט שהמשתמש קולט לתוכם, ואז מדפיסה אותו במסוף.[מדריך 2]

MODULE GCD
    FROM InOut IMPORT ReadInt, WriteString, WriteLn, WriteInt;
    VAR x, y: INTEGER;
BEGIN
    WriteString("x = "); ReadInt(x); WriteLn;
    WriteString("y = "); ReadInt(y); WriteLn;
    WHILE x # y DO
        IF x > y THEN
            x := x - y
        ELSE
            y := y - x
        END
    END;
    WriteString("GCD = ");
    WriteInt(x, 6);
    WriteLn;
END GCD.

עיצובעריכה

וירת עיצב את מודולה־2 כדי לתת מענה מקיף לכל החסרונות של פסקל, והכתיר אותה להיות היורשת.[מדריך 1][סקירה 1] מודולה־2 היא שפת תכנות מערכות, ולמרות זאת, הפירקניות שלה מאפשרת לתוכניות לעבור הידור מוצלח בלי שינויים נוספים עבור ארכיטקטורות מחשבים שונות, מכיוון שיישום השפה (המהדר והפירקנים שלו) דואג לספק פירקנים מערכתיים עם ממשק זהה ויישום מותאם לכל ארכיטקטורה שהוא מכיר בה. פירקנים מערכתיים אלה עוברים הידור נפרד ובלתי־תלוי בשאר התוכנית של המשתמש. אחריות זו מוטלת על יישום השפה.[סקירה 1] חידושיה המרכזיים של מודולה־2 על פני פסקל הם:

  1. פִּירְקָן[לשון 1] (או מוֹדוּל[ב]) כיחידת קוד מקור שעוברת הידור נפרד משאר הקוד.[מדריך 1][סקירה 1]
  2. תחביר חינוכי ואחיד שמעודד את למידת השפה תוך כדי הקריאה.[מדריך 1][סקירה 1]
  3. שִׁגְרַת הֶמְשֵׁךְ (אנ')[לשון 2] (או קוֹ־רוּטִינַה[ג]) כמנגנון ליישום וניהול תהליכים בו־זמניים (אנ').[לשון 3][מדריך 1][סקירה 1]
  4. גישה למבני נתונים ללא אכיפת טיפוסיות בתכנות מערכות.[ד][מדריך 1]

היקף משתניםעריכה

כמו שפות אימפרטיביות אחרות, גם מודולה־2 משתמשת בהיקף לקסיקלי. כלומר, שמות משתנים חייבים להיות מוכרזים לפני השימוש בהם באותו ההיקף.[מדריך 2][סקירה 2] בנוסף, על מנת להשתמש במשתנה בביטוי, חייבים להקצות לו ערך כלשהו.[מדריך 3]

טיפוסי נתוניםעריכה

מודולה־2 מכירה בשישה טיפוסי נתונים בסיסיים:[ה] מספר שלם, מספר טבעי, מספר ממשי, בוליאני (אנ') (אמת או שקר), תו, ומערך ביטים (אנ').[מדריך 4] לא ניתן לשנות טיפוס של משתנה לאחר הכרזתו, וניסיון להקצות ערך שאינו הולם את טיפוסיות המשתנה יגרום לשגיאת הידור עוד לפני הריצה של התוכנית.[מדריך 4] אי לכך, מודולה־2 היא שפת תכנות עם טיפוסיות חזקה וסטטית. בנוסף, טיפוס הנתונים של המשתנה מגדיר את הפעולות האפשריות עליו.[מדריך 4] מודולה־2 מאפשרת למתכנת להגדיר הרכבות של טיפוסי נתונים מתקדמים יותר בעזרת ששת הטיפוסים הבסיסיים.[מדריך 4] לא רק משתנים נושאים עימם טיפוסיות, אלא גם קבועים, פונקציות, ותוצאות של פעולות.[מדריך 4] בנוסף, מודולה־2 לא מבצעת המרת טיפוסים בלי הוראה מפורשת. לדוגמה, פעולת חשבון בין מספר טבעי ומספר ממשי תדרוש המרה מפורשת של אחד מהם לטיפוס של האחר בעזרת FLOAT(n) או TRUNC(x).[מדריך 4]

טיפוסי הנתונים הבסיסיים של מודולה־2[מדריך 4][סקירה 3][6][וירת 11]
סיווג שם פעולות בתים טווח ערכים מותר
מספר שלם INTEGER חיבור +, חיסור -, כפל *, חילוק שלמים DIV,[ו] ושארית MOD.[ז] 2  
LONGINT 4  
מספר טבעי[ח] CARDINAL 2  
LONGCARD 4  
מספר ממשי REAL ארבע פעולות חשבון: +, -, *, /. 4  [ט]
LONGREAL 8  [י]
בוליאני BOOLEAN שלילה NOT (או ~), וגם AND (או &), ואו OR. 1 TRUE או FALSE
תו CHAR להמיר תו למספר סידורי ORD("c"), להמיר מספר סידורי לתו CHR(n). 1 במקור תו ASCII.
2 מהדרים חדשים מציעים Unicode.
מערך ביטים BITSET איחוד +, הפרש -, חיתוך *, והפרש סימטרי /. 2 מערך ערכי CARDINAL מ־0 עד 15.

פִּירְקָנוּתעריכה

אחד מחידושיה המרכזיים של מודולה־2 הוא פיצול התוכנית לפירקנים כיחידות קוד מקור שעוברות הידור נפרד.[מדריך 5][סקירה 4] במודולה־2, פירקן מוגדר בשני רבדים: הכרזת הממשק, ויישום הפירקן.[סקירה 4] בדומה לשפת C, הכרזת הממשק של הפירקן נמצאת בקובץ נפרד שמכריז על השגרות הזמינות באותו פירקן, על סוגי המשתנים שהן קולטות ופולטות. הכרזת הפירקן היא שימושית בעיקר למהדר, ואין צורך לספק אותה למשתמש התוכנית. לעומת זאת, יישום הפירקן עובר הידור לשפת מכונה כי הוא מכיל בו קוד אימפרטיבי שמתאר את אופן הפעולה והביצוע של השגרות והתכנית.[סקירה 4]

תחבירעריכה

התחביר של מודולה־2 מורכב מפקודות אימפרטיביות. פקודות מופרדות בעזרת נקודה ופסיק ;, ולעיתים קרובות הן גם מכילות ביטויים שעוברים חישוב. פקודות וביטויים מורכבים מאסימונים שנוצרים מרצף תווי ASCII. המהדר מבצע בדיקת דקדוק תחבירי, ניתוח סמנטי, וניתוח לקסיקלי, ואז מתרגם פקודות לשפת סף. אסימונים מוכרים מייצגים בין היתר מילים שמורות, ערכים, מחרוזות, הערות, מזהים (שמות של משתנים, קבועים, שגרות, ופירקנים), פעולות, ופיסוק.[סקירה 5][סקירה 6][מדריך 6]

אסימוני השפהעריכה

אסימונים במודולה־2[מדריך 6][סקירה 6]
סיווג הגדרה דוגמה
מזהה שם משתנה רצף של תווי אותיות אלף־בת לטיניות וסיפרות עשרוניות, כשהתו הראשון מוכרח להיות אות. i8MyPi
ערך מספר שלם עשרוני רצף סיפרות עשרוניות. 2016
אוקטלי רצף סיפרות עשרוניות בטווח 0–7 ותו B עוקב. 7B
הקסדצימלי רצף סיפרות עשרוניות ואותיות מ־A עד F ותו H עוקב. FFFFFFH[י"א]
מספר ממשי שבר עשרוני רצף סיפרות עשרוניות עם נקודה עשרונית. 1.25
כתיב מדעי רצף סיפרות עשרוניות עם נקודה עשרונית, התו E, סימן + או - ורצף ספרות עשרוניות נוסף. 4.0E-10
מחרוזת רצף תווים שנפתח ונסגר בתו ", או שנפתח ונסגר בתו '. "Hello, World!"

'Hello, World!'

תחביר פעולה כל הופעה של תו המייצג פעולה (ראה פעולות). +
מילה שמורה כל רצף תווים שיוצר מילה מרשימת המילים השמורות. IF
הערה כל רצף שנפתח ב־(* ונסגר ב־*). (* comment *)

מילים שמורותעריכה

למודולה־2 קיימות ארבעים מילים שמורות.[מדריך 6][סקירה 6]

AND                     ELSIF                   LOOP                    REPEAT
ARRAY                   END                     MOD                     RETURN
BEGIN                   EXIT                    MODULE                  SET
BY                      EXPORT                  NOT                     THEN
CASE                    FOR                     OF                      TO
CONST                   FROM                    FOR                     TYPE
DEFINITION              IF                      POINTER                 UNTIL
DIV                     IMPLEMENTATION          PROCEDURE               VAR
DEFINITION              IMPORT                  QUALIFIED               WHILE
ELSE                    DEFINITION              RECORD                  WITH

פקודות וביטוייםעריכה

בדומה לשפות תכנות רבות, פקודות במודולה־2 מאפשרות תכנות אימפרטיבי בכך שהן מורות בקרת זרימה והקצאת ביטויים לתוך משתנים, בעוד שהביטויים עצמם הם רצפים של פעולות ואופרנדים שעוברים חישוב לפי סדר פעולות מתמטי, או סדר פעולות שהמתכנת מגדיר בעזרת סוגריים עגולים.[מדריך 3] מודולה־2 מכירה באחד־עשרה סוגי פקודות:[מדריך 3]

  1. הקצאה (קליטת ערך למשתנה) :=
  2. קריאת שגרה
  3. שינוי היקף משתנים WITH
  4. שמונה פקודות לבקרת זרימה:
    1. תנאי IF
    2. מִקְרֶה[לשון 4] CASE
    3. חזרה RETURN
    4. יציאה ידנית מלולאה EXIT
    5. וארבעה סוגי לולאות:
      1. לולאה אין־סופית LOOP
      2. לולאת WHILE
      3. לולאת REPEAT
      4. לולאת FOR

קבועיםעריכה

מודולה־2 מאפשרת למתכנת להכריז ערכים קבועים. ערכים אלה אינם משתנים במהלך התוכנית, וערכם נקבע על ידי המהדר לפני הריצה של התוכנית. הכרזה של קבוע נעשית בעזרת הסימן =, והמילה CONST מאפשרת הכרזה של כמה קבועים ברצף כמו בדוגמה למטה.[מדריך 7][סקירה 7]

CONST PI = 3.14159;
    E = 2.71828;
    N = 16;
    M = N - 1;

משתניםעריכה

הכרזה של משתנה נעשית בעזרת הסימן : כשמשמאל שם המשתנה, ומימין טיפוס המשתנה. בדומה לקבועים, ניתן להכריז מספר משתנים ברצף בעזרת המילה VAR.[מדריך 7]

VAR i, j, k: INTEGER;
    x, y, z: REAL;
    c: CHAR;

בקרת זרימהעריכה

מהיותה שפת תכנות מבנית, חלק מסוגי הפקודות יכולות להכיל בתוכן תת־פקודות. לדוגמה, תנאי IF יכול להיות מוכל בתוך תנאי IF אחר, שגם הוא יכול להיות מוכל בתוך לולאת WHILE, וכך בעצם נוצרת בקרת זרימה.[מדריך 3] במודולה־2, הסימן נקודה ופסיק ; הוא מפריד בין פקודות ומגדיר את סדר הביצוע בתוכנית.[מדריך 3]

לולאותעריכה

מודולה־2 מציעה ארבעה סוגי לולאות: LOOP, WHILE, REPEAT, ו־FOR.[מדריך 8] כמו בשפות אחרות, הלולאות WHILE, REPEAT, ו־FOR הן תלויות בתנאי כלשהו.[מדריך 8] לעומת זאת, הלולאה LOOP היא אין־סופית ומתקיימת ללא תנאים. לכן, היא דורשת יציאה ידנית באמצעות הפקודה EXIT בתוכה.[סקירה 8][מדריך 8] ובכל אופן, הפקודה EXIT יודעת לעצור לולאה מכל סוג.[סקירה 9] דוגמה ללולאת LOOP:[מדריך 8][סקירה 8]

LOOP
    IF i < n THEN
        i := i + 1
    ELSE
        EXIT
    END
END

בלולאה WHILE, כל עוד התנאי מתקיים, הלולאה תמשיך לחזור על עצמה. דוגמה ללולאת WHILE:[מדריך 8][סקירה 10]

WHILE i < n DO
    i := i + 1
END

בלולאת REPEAT, הבדיקה נעשית בסוף המחזור, והמחזור הראשון מתקיים ללא תנאי. התנאי לעצירה צריך להתקיים על מנת שהלולאה תיעצר. דוגמה ללולאת REPEAT:[מדריך 8][סקירה 11]

REPEAT
    i := i + 1
UNTIL i = n

בלולאת FOR ישנה הכרזה של משתנה ייעודי. ברירת המחדל, הלולאה מקדמת את המשתנה שלה ב־1 כל מחזור, אבל אפשר להגדיר את קצב ההתקדמות או להפוך אותה להתקדמות שלילית בעזרת BY בפקודת FOR:[מדריך 9][סקירה 12]

FOR i := 0 TO -n BY -1 DO
    (* Statements *)
END
תנאיםעריכה

במודולה־2, הפקודה IF מאפשרת בקרת זרימה לפי תנאים. אם התנאי הראשון נכשל, ניתן לשרשר מספר תנאים נוספים אחריו בעזרת ELSIF, ומצב ברירת מחדל באמצעות ELSE.[סקירה 13][מדריך 8] חשוב לציין שבשרשרת תנאים הבדיקה היא לפי סדר הופעתם. לכן, ברגע שתנאי אחד מתקיים, כל השאר אחריו מדולגים.[מדריך 8] תחביר של תנאי מלא יראה כך:

IF n = 0 THEN
    (* n equals 0 *)
ELSIF n = 1 THEN
    (* n equals 1 *)
ELSIF n > 1 THEN
    (* n is greater than 1 *)
ELSE
    (* n is lesser than 0 *)
END

מבני נתוניםעריכה

מודולה־2 מציעה שמונה סוגים בסיסיים של טיפוסי נתונים:

  1. טיפוס ערך (לדוגמה, משתנה המחזיק בו ערך של מספר ממשי)[סקירה 3][6]
  2. טיפוס נמנים (אנ')[לשון 5][י"ב][מדריך 10][סקירה 14]
  3. טווח משנה[י"ג][סקירה 15]
  4. מערך[מדריך 9][סקירה 16]
  5. רשומה[לשון 6][י"ד][סקירה 17]
  6. קבוצה (דומה למושג קבוצה במתמטיקה)[סקירה 18]
  7. מצביע[סקירה 19]
  8. טיפוס פונקציה (אנ') (טיפוס נתונים שיודע להחזיק בו כתובת של פונקציה או שגרה באופן דומה לתכנות פונקציונלי)[סקירה 20][7]

בעזרת הטיפוסים הבסיסיים בשפה ניתן להרכיב טיפוסי נתונים חדשים עבור מבני נתונים מורכבים יותר כגון מערך דו־ממדי. לאחר הכרזת הטיפוסים החדשים ניתן להמשיך להרכיב בעזרתם טיפוסים מורכבים אף יותר.[סקירה 21]

מערכיםעריכה

באופן דומה להכרזת משתנים, הכרזת מערכים תיעשה בעזרת המילה ARRAY, טווח האיברים מוגדר בעזרת שתי נקודות .. בין סוגריים מרובעים, וטיפוסיות האיברים תבוא בסוף הפקודה אחרי המילה OF.[מדריך 9][סקירה 16] גישה למערכים נעשית בעזרת סוגריים מרובעים A[i], ובמערכים רב־ממדיים מפרידים בין הממדים בעזרת פסיק ,: A[i, j].[מדריך 9][סקירה 16] שלא כמו בשפות אחרות, הקצאה בין משתנים שמחזיקים מערכים היא בפועל מעתיקה את המערך בינם ולא רק את המצביע.[ט"ו][מדריך 9]

VAR A: ARRAY [0 .. N-1] OF INTEGER;

במודולה־2 אפשר להכריז על מערכים רב־ממדיים לאיברים מאותו טיפוס בעזרת שני תחבירים:[מדריך 9]

VAR A: ARRAY [1 .. N], [1 .. M] OF INTEGER;
VAR A: ARRAY [1 .. N] OF
       ARRAY [1 .. M] OF INTEGER;

טיפוסי נמניםעריכה

במודולה־2 ניתן להגדיר טיפוס נמנים (אנ')[לשון 5][ט"ז] בעזרת רשימת מזהים בסוגריים עגולים.[מדריך 10][סקירה 14] בדומה לטיפוס התו (CHAR), ניתן לבקש את המספר הסידורי של כל איבר במניה בעזרת הפונקציה ORD(item).[מדריך 10] בנוסף, הטיפוס הבוליאני (BOOLEAN) במודולה־2 הוא מקרה פרטי של טיפוס נמנים מהצורה: BOOLEAN = (FALSE, TRUE).[מדריך 10] השימוש בטיפוסי נמנים הוא כשאר הטיפוסים בשפה. כלומר, משתנה מאותו טיפוס נמנים יכול להכיל בו אחד מהפריטים במנייה.[מדריך 10]

TYPE messageType = (error, warning, info);
     messagePriority = (prompt, monitor, log);
     messageBell = (beep, visual, sound);

טווח משנהעריכה

במודולה־2 ניתן להגדיר טיפוס נתונים חדש שמגביל את טווח הערכים המותר בטיפוס ערכי בלתי־רציף (כלומר, טיפוס מספרי שאינו מספר ממשי) או טיפוס נמנים קיים. לדוגמה, טווח משנה אופייני של ימי עסקים וסוף שובע בישראל בתוך ימי השבוע יוגדר כך:[סקירה 15]

(* Describing working days and weekend days in Israel via enum subranges. *)
TYPE Days = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday);
     WorkingDays = Days [Sunday .. Thursday];
     WeekendDays = Days [Friday .. Saturday];

רשומותעריכה

רשומה היא טיפוס הנתונים הגמיש ביותר בשפה, והיא מאפשרת למתכנת להגדיר טיפוס נתונים חדש המורכב מכמה טיפוסי נתונים שונים בתוך הרשומה בעזרת ”שדות.“ שדות גם יכולים להכיל בהם רשומות באופן מקונן.[סקירה 17] בעזרת רשומות ניתן לתאר בשפה טיפוסי נתונים מגוונים הן לשימוש רב־תכליתי ומופשט כגון עץ בינארי, והן לשימוש מסוים כגון פרטי לקוחות. לדוגמה, רשומה פשוטה המתארת ייצוג צבע תוגדר בעזרת רשומה המורכבת משלושה שדות, שכל אחד מהם מכיל ערך מטיפוס טווח משנה של מספר שלם:

(* Record type describing an RGB color. *)
TYPE Color = RECORD
    R: INTEGER [0..255];
    G: INTEGER [0..255];
    B: INTEGER [0..255];
END

בנוסף, במודולה־2 ניתן להגדיר זמינות של שדות על פי הערכים שנמצאים בשאר השדות.[סקירה 17] לדוגמה, לכל אדם קיים תאריך לידה, אך רק לאדם שנפטר קיים תאריך פטירה:

TYPE Date = RECORD
    Day: INTEGER [1..31];
    Month: INTEGER [1..12];
    Year: INTEGER;
END;
Person = RECORD
    Born: Date;
    CASE IsAlive: BOOLEAN OF
        FALSE: Died: Date;
    END;
END;

שגרותעריכה

מהיותה שפת תכנות פרוצדורלית, פירקנים במודולה־2 עשויים להגדיר תת־תוכניות ולייצא אותם כפקודות עם שמות ייחודיים ופרמטרים. פקודות כאלה נקראות שִגְרוֹת והן מוגדרות בעזרת המילה PROCEDURE.[מדריך 11][סקירה 22][8] שגרה היא בגדר ”פונקציה“ אם היא מחזירה ערך כלשהו,[י"ז] אחרת היא בגדר ”ציווי.“[י"ח][סקירה 22][8] פונקציות מחזירת ערך בעזרת הפקודה RETURN.[סקירה 9] לכן, ביטויים מתייחסים אליהן כאל ערכים שטרם חושבו.[סקירה 22][8] שגרות יודעות להכריז על משתנים מקומיים בקטע הפנימי שנמצא בין ה־PROCEDURE וה־BEGIN.[סקירה 22][8] דוגמה לפונקציה ריבועית פשוטה   כך ש־  (כלומר, פונקציה שמקבלת ומחזירה מספרים ממשיים):

PROCEDURE f(x: REAL): REAL;
BEGIN
    RETURN x * x;
END f

במודולה־2, הפעלת פונקציות מחייבת שימוש בסוגריים עגולים אפילו בהיעדר פרמטרים. לדוגמה, IsWindowMinimized(). לעומת זאת, אין צורך בכתיב עם סוגריים עגולים בציווים שלא מקבלים פרמטרים. לדוגמה, MinimizeWindow.[סקירה 22][8] בנוסף, שגרות יודעות לקבל שני סוגים של פרמטרים: ”פרמטר ערך,“[י"ט] ו”פרמטר משתנה.“[כ] פרמטר מסוג ”משתנה“ מוכרז בעזרת המילה VAR לפניו, והוא בפועל מצביע למשתנה שנמצא מחוץ להיקף השגרה. לפיכך, פרמטר כזה גורם ל”תופעות לוואי“ במשתנה המקורי שנשלח אל השגרה.[סקירה 22][8] דוגמה לשגרת ציווי שמבצעת העלאה בריבוע בעזרת פרמטר מסוג ”משתנה“:

PROCEDURE Square(VAR x: REAL);
BEGIN
    x := x * x;
END Square

במודולה־2 קיימות 19 שגרות בסיסיות שהן זמינות בכל חלקי הקוד. מתוכן 12 הן פונקציות ו־7 הן ציווים.[סקירה 22]

שגרות ופונקציות סטנדרטיות במודולה־2[סקירה 22]
סיווג קריאה משמעות מקבלת מחזירה
פונקציה ABS(x) ערך מוחלט מספר (בדרך כלל ממשי או שלם)
CAP(ch) אות רישית תו
CHR(n) המרת מספר סידורי לתו מספר טבעי תו
FLOAT(n) המרת מספר שלם למספר ממשי מספר שלם מספר ממשי
HIGH(a) האינדקס האחרון במערך מערך מספר טבעי
MAX(T) הערך המרבי מהטיפוס T T
MIN(T) הערך המזערי מהטיפוס T
ORD(ch) המרת תו למספר סידורי תו מספר טבעי
SIZE(T) אורך בזיכרון (במספר הבתים) הדרוש לערך מהטיפוס T T
TRUNC(x) המרת מספר ממשי למספר שלם מספר ממשי מספר שלם
VAL(T, n) החזרת הפריט ה־n מהטיפוס T (בדרך כלל טיפוס נמנים); זהה ל־CHR(n) אם T הוא CHAR T, מספר טבעי T
ציווי DEC(x) הקטנה ב־1; בשפות תכנות רבות קיימת הפעולה -- במקום מספר, תו, או טיפוס נמנים
DEC(x, n) הקטנה ב־n; בשפות תכנות רבות קיימת הפעולה -= במקום
EXCL(s, i) הוצאת הפריט i מהקבוצה s
HALT יציאה מהתוכנית (סיום ריצה)
INC(x) הגדלה ב־1; בשפות תכנות רבות קיימת הפעולה ++ במקום מספר, תו, או טיפוס נמנים
INC(x, n) הגדלה ב־n; בשפות תכנות רבות קיימת הפעולה += במקום
INCL(s, i) הכללת הפריט i בקבוצה s

פעולותעריכה

בשונה מכתיב מתמטי, במודולה־2 שני סימוני פעולות[כ"א] לא יכולים לבוא זה מיד אחר זה באופן רציף, ובמקרה כזה חובה להשתמש בסוגריים כדי לבודד את סדר הפעולות. לדוגמה, x * -1 נחשב ביטוי לא חוקי במודולה־2. במקום זאת, יש לכתוב x * (-1).[מדריך 3] בנוסף, לא ניתן לרמוז על פעולת כפל בין משתנים וערכים. לדוגמה, 2n ( ) נחשב ביטוי לא חוקי. במקום זאת, חובה לכתוב את הביטוי במלואו. כלומר, 2 * n.[מדריך 3]

סימני פעולות במודולה־2[מדריך 12][9]
סיווג אופרנדים פעולה סימן
בינארי הקצאה (קלט) קליטת ערך למשתנה :=  
יוחסה (פלט) מספרים שווה ל־ =
לא שווה ל־ #או <>  
גדול מ־ >  
קטן מ־ <  
גדול או שווה ל־ >=  
קטן או שווה ל־ <=  
קבוצות מוכל ב־  
מכיל את >=  
ערך וקבוצה שייך ל־ IN  
לוגיקה (פלט) אמת או שקר וגם & או AND  
או OR  
חשבון (פלט) מספרים חיבור +  
חיסור -  
כפל *  
חילוק /  
חשבון קבוצות (פלט) קבוצות איחוד +  
חיתוך *  
הפרש -  
הפרש סימטרי /  
אונארי לוגיקה (פלט) אמת או שקר לא ~ או NOT  
חשבון (פלט) מספר סימן שלילי -  

פירקניםעריכה

תוכניות במודולה־2 בנויות מרכיבים שעוברים הידור נפרד זה אחר זה לפי קשר התלות בינם. כל רכיב כזה נכתב בקובץ נפרד, ובמונחי השפה הוא מכונה ”מודול“ או בעברית ”פירקן.“ לפיכך, מבנה הפירקן הוא גם השלד הבסיסי של כל קובץ קוד מקור בשפה. הקטע הבא מתאר את מבנה הפירקן במודולה־2.[מדריך 2] בסוף פירקן תמיד מופיעה נקודה.

MODULE MyModule
    (* Import Lists *)
    (* Declarations *)
BEGIN
    (* Statements *)
END MyModule.

מהדריםעריכה

במשך השנים מאז הופעתה בשנת 1983 פותחו עשרות מהדרים ומימושים שונים לשפה. נכון לשנת 2021, קיימים שני מימושים מרכזיים שזמינים לציבור הרחב ונמצאים תחת פיתוח ותחזוקה מתמדת: המימוש של מיזם גנו והמימוש של ADW. כמו כן, גם מעצב השפה, ניקלאוס וירת, פיתח מימוש משלו עבור השפה בין השנים 1983–1985.[1][וירת 7]

GNU Modula-2עריכה

GNU Modula-2 הוא מימוש חופשי ומקיף עבור מודולה־2 עם המהדר GCC מטעם מיזם גנו.[10][11] הגרסה הראשונה של המימוש שוחררה לציבור בשנת 2010.[4] המהדר מצטיין במיוחד בממשק בין מודולה־2 לשפת C.[10] בנוסף, המימוש חוצה פלטפורמות ותומך גם בארכיטקטורות מחשבים פחות מוכרות כמו ARM ו־AVR לתכנות משובצות.[10]

ADW Modula-2עריכה

ADW Modula-2 הוא מהדר חינמי עבור מודולה־2.[5] הגרסה הראשונה של המהדר שחוררה בשנת 2011 אחרי שירש את הפיתוח של מימוש קודם, Stony Brook Modula-2.[5] המהדר תומך אך ורק בחלונות (32 או 64 סיביות).[5] כמו כן, באתר הבית של ADW Modula-2 ניתן למצוא מדריך מקיף לשפה, דוגמאות והסברים לשימוש במהדר.[12] נכון לשנת 2021 הוא נמצא תחת פיתוח פעיל, ויוצאת לו גרסה חדשה כאחת לשנתיים.[5]

ראו גםעריכה

לקריאה נוספתעריכה

קישורים חיצונייםעריכה

ביאוריםעריכה

  1. ^ מודולה הראשונה הייתה שפת תכנות נסיונית, והיא מעולם לא פותחה מעבר לשלבי הניסוי שלה אחרי שנת 1975.
  2. ^ באנגלית: ”module“
  3. ^ באנגלית: ”coroutine“
  4. ^ זה שימוש בעיקר לפיתוח מערכת ההפעלה של DISER Lilith.
  5. ^ אותם המדריך מכנה כ־”standard types“
  6. ^ חילוק מסוג זה לא מחזיר שבר עשרוני, אלא את מספר הפעמים המרבי שהמכנה יכול להיכנס בתוך המונה בלי שארית.
  7. ^ זאת השארית שנאבדת בחילוק שלמים.
  8. ^ מספרים טבעיים כולל אפס.
  9. ^ בפועל ערך עם נקודה צפה ודיוק עשרוני משתנה. לטיפוס שתי הצגות, בנקודה עשרונית ובכתיב מדעי (ראה ”רצפים“ בפרק ”תחביר“).
  10. ^ מהדרים שונים מציעים טווח שונה. הטווח הזה לקוח מ־ADW Modula-2.
  11. ^ צבע לבן בתצוגה הקסדצימלית.
  12. ^ באנגלית: ”enumeration type“
  13. ^ באנגלית: ”subrange“; ניתן לתרגם גם כ”תת־טווח“
  14. ^ באנגלית: ”record“
  15. ^ מתכנת מתחיל היה עושה זאת בעזרת לולאה, ומעתיק איבר־איבר, אך במודולה־2 מספיק להקצות את כל המערך למשתנה חדש, והוא למעשה יוצר מערך נפרד עם אותם איברים.
  16. ^ באנגלית: ”enumeration type“
  17. ^ באנגלית: ”function procedure“
  18. ^ באנגלית: ”proper procedure“
  19. ^ באנגלית: ”value parameter“
  20. ^ באנגלית: ”variable parameter“
  21. ^ באנגלית: ”operator“

הערות שולייםעריכה

ניקלאוס וירתעריכה

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

סקירת השפהעריכה

סקירת השפה פורסמה באופן חופשי לקהל הרחב בגרסת PDF מתוך מדריך השפה שהערך בנוי עליו. הסקירה כוללת בה אפיון מלא של השפה.[מדריך 13] גרסת ה־PDF שפרסמה הוצאת שפרינגר כוללת בה גם את ארבעת הנספחים האחרונים בספר: הגדרת תחביר השפה בסימון EBNF (אנ'),[מדריך 12] תיאור ספריית הליבה של מודולה־2,[מדריך 14] טבלת תוי ASCII,[מדריך 15] ותרשימי זרימה לתחביר השפה.[מדריך 16]

Niklaus Wirth, Report on the Programming Language Modula-2, Berlin, Heidelberg: Springer-Verlag, 4th Edition, 1988, עמ' 133–184, ISBN 978-3-642-83567-4

  1. ^ 1 2 3 4 5 6 “Introduction.” pp. 133–134.
  2. ^ “Declarations and Scope Rules.” pp. 135–136.
  3. ^ 1 2 “Basic Types.” p. 137.
  4. ^ 1 2 3 “Introduction.” pp. 133–134.
  5. ^ “Syntax.” p. 134.
  6. ^ 1 2 3 “Vocabulary and Representation.” pp. 134–135.
  7. ^ “Constant Declarations.” p. 136.
  8. ^ 1 2 “Loop Statements.” p. 147.
  9. ^ 1 2 “Return and Exit Statements.” pp. 147–148.
  10. ^ “While Statements.” pp. 145–146.
  11. ^ “Repeat Statements.” p. 146.
  12. ^ “For Statements.” pp. 146–147.
  13. ^ “If Statements.” p. 145.
  14. ^ 1 2 “Enumerations.” p. 137.
  15. ^ 1 2 “Subrange Types.” pp. 137–138.
  16. ^ 1 2 3 “Array Types.” p. 138.
  17. ^ 1 2 3 “Record Types.” pp. 138–139.
  18. ^ “Set Types.” p. 139.
  19. ^ “Pointer Types.” p. 140.
  20. ^ “Procedure Types.” p. 140.
  21. ^ “Type Declarations.” pp. 136–140.
  22. ^ 1 2 3 4 5 6 7 8 “Procedure Declarations.” pp. 148–150.

מדריך השפהעריכה

מדריך השפה יצא לאור בארבע מהדורות בין השנים 1982–1988. המהדורות שיקפו על שינויים בשפה. ערך זה בנוי על המהדורה הרביעית.[וירת 9]

Niklaus Wirth, Programming in Modula-2, Berlin, Heidelberg: Springer-Verlag, 4th Edition, 1988, ISBN 978-3-642-83567-4. (באנגלית)

  1. ^ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 “Preface.” pp. 3–5.
  2. ^ 1 2 3 “A First Example.” pp. 11–13.
  3. ^ 1 2 3 4 5 6 7 “Statements and Expressions.” pp. 19–21.
  4. ^ 1 2 3 4 5 6 7 “Elementary Data Types.” pp. 28–35.
  5. ^ “Preface.” pp. 3–5.
  6. ^ 1 2 3 “Representation of Modula Programs.” pp. 16–18.
  7. ^ 1 2 “Constant and Variable Declarations.” p. 36.
  8. ^ 1 2 3 4 5 6 7 8 “Control Structures.” pp. 22–27.
  9. ^ 1 2 3 4 5 6 “The Data Structure Array.” pp. 37–46.
  10. ^ 1 2 3 4 5 “Enumeration Types.” p. 64.
  11. ^ “Procedures.” pp. 47–48.
  12. ^ 1 2 “Appendix 1. The Syntax of Modula-2.” pp. 157–160.
  13. ^ “Report on the Programming Language Modula-2.” pp. 133–156.
  14. ^ “Appendix 2. Standard Utility Modules.” pp. 161–169.
  15. ^ “Appendix 3. The ASCII Character Set.” p. 170.
  16. ^ “Appendix 4. Syntax Diagrams.” pp. 171–180.

פרסומיםעריכה

  1. ^ Niklaus Wirth, The programming language Pascal, Acta Informatica 1, 1971, עמ' 35–63 doi: 10.1007/BF00264291
  2. ^ Niklaus Wirth, Modula: A language for modular multiprogramming, Software: Practice and Experience 7, 1977, עמ' 1–35 doi: 10.1002/spe.4380070102
  3. ^ Niklaus Wirth, MODULA-2, ETH, Institut für Informatik 27, ETH Zürich, 1978 doi: 10.3929/ethz-a-000153014
  4. ^ Niklaus Wirth, MODULA-2, ETH, Institut für Informatik 36, ETH Zürich, 1980 doi: 10.3929/ethz-a-000189918
  5. ^ Niklaus Wirth, Programming in Modula-2, Berlin, Heidelberg: Springer-Verlag, 1st Edition, 1982, ISBN 978-3-642-96717-7. (באנגלית)
  6. ^ Niklaus Wirth, Programming in Modula-2, Berlin, Heidelberg: Springer-Verlag, 2nd Edition, 1983, ISBN 978-3-642-96757-3. (באנגלית)
  7. ^ 1 2 Niklaus Wirth, Jürg Gutknecht, A fast and compact compiler for Modula-2, ETH, Institut für Informatik 64, ETH Zürich, 1985 doi: 10.3929/ethz-a-006650101
  8. ^ Niklaus Wirth, Programming in Modula-2, Berlin, Heidelberg: Springer-Verlag, 3rd Edition, 1985, ISBN 978-3-642-96880-8. (באנגלית)
  9. ^ 1 2 Niklaus Wirth, Programming in Modula-2, Berlin, Heidelberg: Springer-Verlag, 4th Edition, 1988, ISBN 978-3-642-83567-4. (באנגלית)
  10. ^ Niklaus Wirth, Modula-2 and object-oriented programming, ETH, Institut für Informatik 117, ETH Zürich, 1989 doi: 10.3929/ethz-a-000523424
  11. ^ Niklaus Wirth, et al., MacMETH User Manual, Zurich: ETH Zurich, 1992. (באנגלית)

האקדמיה ללשון העבריתעריכה

ערך זה נשען על מונחי האקדמיה ללשון העברית במדעי המחשב וטכנולוגיית המידע.

  1. ^ פִּרְקָן, האקדמיה ללשון העברית
  2. ^ שִׁגְרַת הֶמְשֵׁךְ, האקדמיה ללשון העברית
  3. ^ בּוֹ־זְמַנִּי, האקדמיה ללשון העברית
  4. ^ מִשְׁפַּט ”מִקְרֶה“, האקדמיה ללשון העברית
  5. ^ 1 2 טִיפּוּס נִמְנִים, האקדמיה ללשון העברית
  6. ^ רְשׁוּמָה, האקדמיה ללשון העברית

מקורות אחריםעריכה

  1. ^ 1 2 3 4 5 6 7 8 Summary of projects by N. Wirth, 1962 - 1999, people.inf.ethz.ch
  2. ^ Modula Two, wiki.c2.com
  3. ^ ISO/IEC 10514-1:1996, ISO (באנגלית)
  4. ^ 1 2 News, GNU Modula-2
  5. ^ 1 2 3 4 5 ADW Modula-2, ADW Modula-2
  6. ^ 1 2 Modula-2 Basic Data Types, ADW Modula-2
  7. ^ Procedure Types, ADW Modula-2
  8. ^ 1 2 3 4 5 6 Procedure Declarations, Modula-2 Reference (באנגלית)
  9. ^ Modula-2 Reference: Expressions: Operators, ADW Modula-2
  10. ^ 1 2 3 Features, GNU Modula-2
  11. ^ License, GNU Modula-2
  12. ^ Home, ADW Modula-2