מודולה-2

מוֹדוּלה־2 (באנגלית: Modula-2) היא שפת תכנות מערכות מובנת ופרוצדורלית עם טיפוסיות חזקה וסטטית שפותחה על ידי ניקלאוס וירת בין השנים 1977–1988 במכון הטכנולוגי של ציריך. מודולה־2 הורחבה במקור מפסקל, והיא ירשה את הפיתוח של מודולה. מודולה־2 באה לתת מענה מקיף לכל החסרונות של פסקל. בשנת 1976 וירת ביקר במעבדת פארק, היכן שתפס את ההשראה לפיתוח של מודולה־2 משפת התכנות מֶסַה. בשנת 1977 וירת התחיל את הפיתוח של מודולה־2 כהמשך לפיתוח של מודולה, וכתחליף לפסקל. מודולה הראשונה הייתה שפת תכנות נסיונית, והיא מעולם לא פותחה מעבר לשלבי הניסוי שלה אחרי שנת 1975. וירת תכנן את מודולה־2 שתהיה שפת תכנות מערכות ושפת תכנות כללית במחשבי DISER Lilith. תחביר השפה היה דומה יותר לזה של מודולה מאשר לפסקל, לכן וירת החליט לקרוא לה מודולה־2. בשנת 1978 פורסמה המהדורה הראשונה של הדו"ח של אפיון השפה. בשנת 1979 נוצר היישום השימושי הראשון של השפה עבור מחשבי ה־PDP-11 בשימוש פנימי של המכון הטכנולוגי של ציריך. בשנת 1980 פורסמה המהדורה השנייה של הדו"ח של האפיון השפה. בשנת 1981 מהדר השפה שוחרר בפעם הראשונה לציבור הרחב. מיד לאחר מכן השפה צברה פופולריות ונוצר עניין ציבורי בפרסום מדריך רשמי עבור השפה. בשנת 1982 פורסמה הגרסה הראשונה של מדריך השפה מאת ניקלאוס וירת על ידי הוצאת שפרינגר. בשנת 1983 פורסמה הגרסה השנייה של השפה (PIM2). בין השנים 1983–1985 וירת החליט לפתח מהדר משלו עבור השפה. המהדר של וירת היה מהיר ויעיל בהרבה מהמהדרים שהוצעו עד כה לשפה. בשנת 1985 פורסמה הגרסה השלישית של השפה (PIM3). בשנת 1988 פורסמה הגרסה הרביעית של השפה (PIM4). בשנת 1989 וירת פרסם מאמר בו התייחס לתכנות מונחה עצמים במודולה־2, למרות שבמקור לא עוצבה לכך. במאמר וירת הציע פתרון לחיקוי הורשה במודולה־2 באמצעות היכולת של השפה להתעלם מאכיפת טיפוסיות בתכנות מערכות. בשנת 1996 ארגון התקינה הבין־לאומי (ISO) פרסם תקן מקיף לשפת התכנות מודולה־2. מכיוון שהיו בו שינויים מזעריים אך מחייבים בשפה, הוא נחשב לניב נוסף של השפה. בשנת 2010 שוחררה הגרסה הראשונה של המימוש החופשי GNU Modula-2 עבור המהדר GCC לציבור הרחב מטעם מיזם גנו. בשנת 2011 שוחררה הגרסה הראשונה של המהדר החינמי ADW Modula-2 לציבור הרחב אחרי שירש את הפיתוח של המהדר Stony Brook Modula-2. מדריך השפה יצא לאור בארבע מהדורות בין השנים 1982–1988. המהדורות שיקפו על שינויים בשפה. סקירת השפה פורסמה באופן חופשי לקהל הרחב בגרסת PDF מתוך מדריך השפה. הסקירה כוללת בה אפיון מלא של השפה. גרסת ה־PDF שפרסמה הוצאת שפרינגר כוללת בה גם את ארבעת הנספחים האחרונים בספר: הגדרת תחביר השפה בסימון EBNF (אנ'), תיאור ספריית הליבה של מודולה־2, טבלת תוי ASCII, ותרשימי זרימה לתחביר השפה. MODULE HelloWorld IMPORT InOut; BEGIN InOut.WriteString("Hello, world!"); InOut.WriteLn; END HelloWorld. הדוגמה הבאה מוצאת את המחלק המשותף המריבי בין המונה a למכנה b בשבר פשוט שהמשתמש קולט לתוכם, ואז מדפיסה אותו במסוף. MODULE GCD FROM InOut IMPORT ReadInt, WriteString, WriteLn, WriteInt; VAR a, b: INTEGER; BEGIN WriteString("a = "); ReadInt(a); WriteLn; WriteString("b = "); ReadInt(b); WriteLn; WHILE a # b DO IF a > b THEN a := a - b ELSE b := b - a END END; WriteString("GCD = "); WriteInt(a, 6); WriteLn; END GCD. וירת עיצב את מודולה־2 כדי לתת מענה מקיף לכל החסרונות של פסקל, והכתיר אותה להיות היורשת. מודולה־2 היא שפת תכנות מערכות, ולמרות זאת, המודלריות שלה מאפשרת לתוכניות לעבור הידור מוצלח בלי שינויים נוספים עבור ארכיטקטורות מחשבים שונות, מכיוון שיישום השפה (המהדר והמודולים שלו) דואג לספק מודולים מערכתיים עם ממשק זהה ויישום מותאם לכל ארכיטקטורה שהוא מכיר בה. מודולים מערכתיים אלה עוברים הידור נפרד ובלתי־תלוי בשאר התוכנית של המשתמש. אחריות זו מוטלת על יישום השפה. חידושיה המרכזיים של מודולה־2 על פני פסקל הם: פִּירְקָן (או מוֹדוּל) כיחידת קוד מקור שעוברת הידור נפרד משאר הקוד. תחביר חינוכי ואחיד שמעודד את למידת השפה תוך כדי הקריאה. שִׁגְרַת הֶמְשֵׁךְ (אנ') (או קוֹ־רוּטִינַה) כמנגנון ליישום וניהול תהליכים בו־זמניים (אנ'). גישה למבני נתונים ללא אכיפת טיפוסיות בתכנות מערכות. זה שימוש בעיקר לפיתוח מערכת ההפעלה של DISER Lilith. כמו שפות אימפרטיביות אחרות, גם מודולה־2 משתמשת בתחום הכרזה לקסיקלי. כלומר, שמות משתנים חייבים להיות מוכרזים לפני השימוש בהם באותו התחום. בנוסף, על מנת להשתמש במשתנה בביטוי, חייבים להקצות לו ערך כלשהו. מודולה־2 מכירה בשישה טיפוסי נתונים בסיסיים: מספר שלם, מספר טבעי, מספר ממשי, בוליאני (אנ') (אמת או שקר), תו, ומערך ביטים (אנ'). לא ניתן לשנות טיפוס של משתנה לאחר הכרזתו, וניסיון להקצות ערך שאינו הולם את טיפוסיות המשתנה יגרום לשגיאת הידור עוד לפני הריצה של התוכנית. אי לכך, מודולה־2 היא שפת תכנות עם טיפוסיות חזקה וסטטית. בנוסף, טיפוס הנתונים של המשתנה מגדיר את הפעולות האפשריות עליו. מודולה־2 מאפשרת למתכנת להגדיר הרכבות של טיפוסי נתונים מתקדמים יותר בעזרת ששת הטיפוסים הבסיסיים. לא רק משתנים נושאים עימם טיפוסיות, אלא גם קבועים, פונקציות, ותוצאות של פעולות. בנוסף, מודולה־2 לא מבצעת המרת טיפוסים בלי הוראה מפורשת. לדוגמה, פעולת חשבון בין מספר טבעי ומספר ממשי תדרוש המרה מפורשת של אחד מהם לטיפוס של האחר בעזרת FLOAT(n) או TRUNC(x). חילוק מסוג זה לא מחזיר שבר עשרוני, אלא את מספר הפעמים המרבי שהמכנה יכול להיכנס בתוך המונה בלי שארית. זאת השארית שנאבדת בחילוק שלמים. מספרים טבעיים כולל אפס. בפועל ערך עם נקודה צפה ודיוק עשרוני משתנה. לטיפוס שתי הצגות, בנקודה עשרונית ובכתיב מדעי (ראה ”רצפים“ בפרק ”תחביר“). מהדרים שונים מציעים טווח שונה. הטווח הזה לקוח מ־ADW Modula-2. אחד מחידושיה המרכזיים של מודולה־2 הוא פיצול התוכנית למודולים כיחידות קוד מקור שעוברות הידור נפרד. במודולה־2, מודול מוגדר בשני רבדים: הכרזת הממשק, ויישום המודול. בדומה לשפת C, הכרזת הממשק של המודול נמצאת בקובץ נפרד שמכריז על השגרות הזמינות באותו מודול, על סוגי המשתנים שהן קולטות ופולטות. הכרזת המודול היא שימושית בעיקר למהדר, ואין צורך לספק אותה למשתמש התוכנית. לעומת זאת, יישום המודול עובר הידור לשפת מכונה כי הוא מכיל בו קוד אימפרטיבי שמתאר את אופן הפעולה והביצוע של השגרות והתכנית. התחביר של מודולה־2 מורכב מפקודות אימפרטיביות. פקודות מופרדות בעזרת נקודה ופסיק ;, ולעיתים קרובות הן גם מכילות ביטויים שעוברים חישוב. פקודות וביטויים מורכבים מאסימונים שנוצרים מרצף תווי ASCII. המהדר מבצע בדיקת דקדוק תחבירי, ניתוח סמנטי, וניתוח לקסיקלי, ואז מתרגם פקודות לשפת סף. אסימונים מוכרים מייצגים בין היתר מילים שמורות, ערכים, מחרוזות, הערות, מזהים (שמות של משתנים, קבועים, שגרות, ומודולים), פעולות, ופיסוק. צבע לבן בתצוגה הקסדצימלית. למודולה־2 קיימות ארבעים מילים שמורות. 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 מאפשרות תכנות אימפרטיבי בכך שהן מורות בקרת זרימה והקצאת ביטויים לתוך משתנים, בעוד שהביטויים עצמם הם רצפים של פעולות ואופרנדים שעוברים חישוב לפי סדר פעולות מתמטי, או סדר פעולות שהמתכנת מגדיר בעזרת סוגריים עגולים. מודולה־2 מכירה באחד־עשרה סוגי פקודות: הקצאה (קליטת ערך למשתנה) := קריאת שגרה שינוי תחום משתנים WITH שמונה פקודות לבקרת זרימה: תנאי IF מִקְרֶה CASE חזרה RETURN יציאה ידנית מלולאה EXIT וארבעה סוגי לולאות: לולאה אין־סופית LOOP לולאת WHILE לולאת REPEAT לולאת FOR מודולה־2 מאפשרת למתכנת להכריז ערכים קבועים. ערכים אלה אינם משתנים במהלך התוכנית, וערכם נקבע על ידי המהדר לפני הריצה של התוכנית. הכרזה של קבוע נעשית בעזרת הסימן =, והמילה CONST מאפשרת הכרזה של כמה קבועים ברצף כמו בדוגמה למטה. CONST PI = 3.14159; E = 2.71828; N = 16; M = N - 1; הכרזה של משתנה נעשית בעזרת הסימן : כשמשמאל שם המשתנה, ומימין טיפוס המשתנה. בדומה לקבועים, ניתן להכריז מספר משתנים ברצף בעזרת המילה VAR. VAR i, j, k: INTEGER; x, y, z: REAL; c: CHAR; מהיותה שפת תכנות מבנית, חלק מסוגי הפקודות יכולות להכיל בתוכן תת־פקודות. לדוגמה, תנאי IF יכול להיות מוכל בתוך תנאי IF אחר, שגם הוא יכול להיות מוכל בתוך לולאת WHILE, וכך בעצם נוצרת בקרת זרימה. במודולה־2, הסימן נקודה ופסיק ; הוא מפריד בין פקודות ומגדיר את סדר הביצוע בתוכנית. מודולה־2 מציעה ארבעה סוגי לולאות: LOOP, WHILE, REPEAT, ו־FOR. כמו בשפות אחרות, הלולאות WHILE, REPEAT, ו־FOR הן תלויות בתנאי כלשהו. לעומת זאת, הלולאה LOOP היא אין־סופית ומתקיימת ללא תנאים. לכן, היא דורשת יציאה ידנית באמצעות הפקודה EXIT בתוכה. ובכל אופן, הפקודה EXIT יודעת לעצור לולאה מכל סוג. דוגמה ללולאת LOOP: LOOP IF i < n THEN i := i + 1 ELSE EXIT END END בלולאת WHILE, כל עוד התנאי מתקיים, הלולאה תמשיך לחזור על עצמה. דוגמה ללולאת WHILE: WHILE i < n DO i := i + 1 END בלולאת REPEAT, הבדיקה נעשית בסוף המחזור, והמחזור הראשון מתקיים ללא תנאי. התנאי לעצירה צריך להתקיים על מנת שהלולאה תיעצר. דוגמה ללולאת REPEAT: REPEAT i := i + 1 UNTIL i = n בלולאת FOR ישנה הכרזה של משתנה ייעודי. ברירת המחדל, הלולאה מקדמת את המשתנה שלה ב־1 כל מחזור, אבל אפשר להגדיר את קצב ההתקדמות או להפוך אותה להתקדמות שלילית בעזרת BY בפקודת FOR: FOR i := 0 TO -n BY -1 DO (* Statements *) END במודולה־2, הפקודה IF מאפשרת בקרת זרימה לפי תנאים. אם התנאי הראשון נכשל, ניתן לשרשר מספר תנאים נוספים אחריו בעזרת ELSIF, ומצב ברירת מחדל באמצעות ELSE. חשוב לציין שבשרשרת תנאים הבדיקה היא לפי סדר הופעתם. לכן, ברגע שתנאי אחד מתקיים, כל השאר אחריו מדולגים. תחביר של תנאי מלא יראה כך: 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 מציעה שמונה סוגים בסיסיים של טיפוסי נתונים: טיפוס ערך (לדוגמה, משתנה המחזיק בו ערך של מספר ממשי) טיפוס נמנים (אנ') טווח משנה מערך רשומה קבוצה (דומה למושג קבוצה במתמטיקה) מצביע טיפוס פונקציה (אנ') (טיפוס נתונים שיודע להחזיק בו כתובת של פונקציה או שגרה באופן דומה לתכנות פונקציונלי) בעזרת הטיפוסים הבסיסיים בשפה ניתן להרכיב טיפוסי נתונים חדשים עבור מבני נתונים מורכבים יותר כגון מערך דו־ממדי. לאחר הכרזת הטיפוסים החדשים ניתן להמשיך להרכיב בעזרתם טיפוסים מורכבים אף יותר. באופן דומה להכרזת משתנים, הכרזת מערכים תיעשה בעזרת המילה ARRAY, טווח האיברים מוגדר בעזרת שתי נקודות .. בין סוגריים מרובעים, וטיפוסיות האיברים תבוא בסוף הפקודה אחרי המילה OF. גישה למערכים נעשית בעזרת סוגריים מרובעים A[i], ובמערכים רב־ממדיים מפרידים בין הממדים בעזרת פסיק ,: A[i, j]. שלא כמו בשפות אחרות, הקצאה בין משתנים שמחזיקים מערכים היא בפועל מעתיקה את המערך בינם ולא רק את המצביע. מתכנת מתחיל היה עושה זאת בעזרת לולאה, ומעתיק איבר־איבר, אך במודולה־2 מספיק להקצות את כל המערך למשתנה חדש, והוא למעשה יוצר מערך נפרד עם אותם איברים. VAR A: ARRAY [0 .. N-1] OF INTEGER; במודולה־2 אפשר להכריז על מערכים רב־ממדיים לאיברים מאותו טיפוס בעזרת שני תחבירים: VAR A: ARRAY [1 .. N], [1 .. M] OF INTEGER; VAR A: ARRAY [1 .. N] OF ARRAY [1 .. M] OF INTEGER; במודולה־2 ניתן להגדיר טיפוס נמנים (אנ') בעזרת רשימת מזהים בסוגריים עגולים. בדומה לטיפוס התו (CHAR), ניתן לבקש את המספר הסידורי של כל איבר במניה בעזרת הפונקציה ORD(item). בנוסף, הטיפוס הבוליאני (BOOLEAN) במודולה־2 הוא מקרה פרטי של טיפוס נמנים מהצורה: 1=BOOLEAN = (FALSE, TRUE). השימוש בטיפוסי נמנים הוא כשאר הטיפוסים בשפה. כלומר, משתנה מאותו טיפוס נמנים יכול להכיל בו אחד מהפריטים במנייה. TYPE messageType = (error, warning, info); messagePriority = (prompt, monitor, log); messageBell = (beep, visual, sound); במודולה־2 ניתן להגדיר טיפוס נתונים חדש שמגביל את טווח הערכים המותר בטיפוס ערכי בלתי־רציף (כלומר, טיפוס מספרי שאינו מספר ממשי) או טיפוס נמנים קיים. לדוגמה, טווח משנה אופייני של ימי עסקים וסוף שובע בישראל בתוך ימי השבוע יוגדר כך: (* 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]; רשומה היא טיפוס הנתונים הגמיש ביותר בשפה, והיא מאפשרת למתכנת להגדיר טיפוס נתונים חדש המורכב מכמה טיפוסי נתונים שונים בתוך הרשומה בעזרת ”שדות.“ שדות גם יכולים להכיל בהם רשומות באופן מקונן. בעזרת רשומות ניתן לתאר בשפה טיפוסי נתונים מגוונים הן לשימוש רב־תכליתי ומופשט כגון עץ בינארי, והן לשימוש מסוים כגון פרטי לקוחות. לדוגמה, רשומה פשוטה המתארת ייצוג צבע תוגדר בעזרת רשומה המורכבת משלושה שדות, שכל אחד מהם מכיל ערך מטיפוס טווח משנה של מספר שלם: (* Record type describing an RGB color. *) TYPE Color = RECORD R: INTEGER [0..255]; G: INTEGER [0..255]; B: INTEGER [0..255]; END בנוסף, במודולה־2 ניתן להגדיר זמינות של שדות על פי הערכים שנמצאים בשאר השדות. לדוגמה, לכל אדם קיים תאריך לידה, אך רק לאדם שנפטר קיים תאריך פטירה: 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. שגרה היא בגדר ”פונקציה“ אם היא מחזירה ערך כלשהו, אחרת היא בגדר ”ציווי.“ פונקציות מחזירת ערך בעזרת הפקודה RETURN. לכן, ביטויים מתייחסים אליהן כאל ערכים שטרם חושבו. שגרות יודעות להכריז על משתנים מקומיים בקטע הפנימי שנמצא בין ה־PROCEDURE וה־BEGIN. דוגמה לפונקציה ריבועית פשוטה f ( x ) = x 2 {\displaystyle f(x)=x^{2}} כך ש־ f : R → R {\displaystyle f:\mathbb {R} \rightarrow \mathbb {R} } (כלומר, פונקציה שמקבלת ומחזירה מספרים ממשיים): PROCEDURE f(x: REAL): REAL; BEGIN RETURN x * x; END f במודולה־2, הפעלת פונקציות מחייבת שימוש בסוגריים עגולים אפילו בהיעדר פרמטרים. לדוגמה,IsWindowMinimized(). לעומת זאת, אין צורך בכתיב עם סוגריים עגולים בציווים שלא מקבלים פרמטרים. לדוגמה, MinimizeWindow. בנוסף, שגרות יודעות לקבל שני סוגים של פרמטרים: ”פרמטר ערך,“ ו”פרמטר משתנה.“ פרמטר מסוג ”משתנה“ מוכרז בעזרת המילה VAR לפניו, והוא בפועל מצביע למשתנה שנמצא מחוץ לתחום השגרה. לפיכך, פרמטר כזה גורם ל”תופעות לוואי“ במשתנה המקורי שנשלח אל השגרה. דוגמה לשגרת ציווי שמבצעת העלאה בריבוע בעזרת פרמטר מסוג ”משתנה“: PROCEDURE Square(VAR x: REAL); BEGIN x := x * x; END Square במודולה־2 קיימות 19 שגרות בסיסיות שהן זמינות בכל חלקי הקוד. מתוכן 12 הן פונקציות ו־7 הן ציווים. בשונה מכתיב מתמטי, במודולה־2 שני סימוני פעולות לא יכולים לבוא זה מיד אחר זה באופן רציף, ובמקרה כזה חובה להשתמש בסוגריים כדי לבודד את סדר הפעולות. לדוגמה, x * -1 נחשב ביטוי לא חוקי במודולה־2. במקום זאת, יש לכתוב x * (-1). בנוסף, לא ניתן לרמוז על פעולת כפל בין משתנים וערכים. לדוגמה, 2n ( 2 n {\displaystyle 2n} ) נחשב ביטוי לא חוקי. במקום זאת, חובה לכתוב את הביטוי במלואו. כלומר, 2 * n. תוכניות במודולה־2 בנויות מרכיבים שעוברים הידור נפרד זה אחר זה לפי קשר התלות בינם. כל רכיב כזה נכתב בקובץ נפרד, ובמונחי השפה הוא מכונה ”מודול.“ לפיכך, מבנה המודול הוא גם השלד הבסיסי של כל קובץ קוד מקור בשפה. הקטע הבא מתאר את מבנה המודול במודולה־2. בסוף מודול תמיד מופיעה נקודה. MODULE MyModule (* Import Lists *) (* Declarations *) BEGIN (* Statements *) END MyModule. במשך השנים מאז הופעתה בשנת 1983 פותחו עשרות מהדרים ומימושים שונים לשפה. נכון לשנת 2021, קיימים שני מימושים מרכזיים שזמינים לציבור הרחב ונמצאים תחת פיתוח ותחזוקה מתמדת: המימוש של מיזם גנו והמימוש של ADW. כמו כן, גם מעצב השפה, ניקלאוס וירת, פיתח מימוש משלו עבור השפה בין השנים 1983–1985. GNU Modula-2 הוא מימוש חופשי ומקיף עבור מודולה־2 עם המהדר GCC מטעם מיזם גנו. הגרסה הראשונה של המימוש שוחררה לציבור בשנת 2010. המהדר מצטיין במיוחד בממשק בין מודולה־2 לשפת C. בנוסף, המימוש חוצה פלטפורמות ותומך גם בארכיטקטורות מחשבים פחות מוכרות כמו ARM ו־AVR לתכנות משובצות. ADW Modula-2 הוא מהדר חינמי עבור מודולה־2. הגרסה הראשונה של המהדר שחוררה בשנת 2011 אחרי שירש את הפיתוח של מימוש קודם, Stony Brook Modula-2. המהדר תומך אך ורק בחלונות (32 או 64 סיביות). כמו כן, באתר הבית של ADW Modula-2 ניתן למצוא מדריך מקיף לשפה, דוגמאות והסברים לשימוש במהדר. נכון לשנת 2021 הוא נמצא תחת פיתוח פעיל, ויוצאת לו גרסה חדשה כאחת לשנתיים. פסקל - שפת התכנות שממנה הורחבה מודולה־2. עדה - שפת תכנות עילית ממשפחת פסקל שפותחה במיוחד עבור צבא ארצות הברית; גם היא הושפעה מאחותה, מודולה־2.[דרוש מקור] לואה - שפת תכנות דינמית עכשוויות וידידותית, למרות שאינה ממשפחת פסקל, היא תפסה השראה רבה ממודולה־2. Niklaus Wirth, Programming in Modula-2, 4th Edition, Berlin, Heidelberg: Springer-Verlag, 1988, ISBN 978-3-642-83567-4. (באנגלית) Niklaus Wirth, Report on the Programming Language Modula-2, 4th Edition, Berlin, Heidelberg: Springer-Verlag, 1988, עמ' 133–184, ISBN 978-3-642-83567-4. (באנגלית) מדיה וקבצים בנושא מודולה-2 בוויקישיתוף אתר האינטרנט הרשמי של ETH Modula-2 (באנגלית) אתר האינטרנט הרשמי של GNU Modula-2 (באנגלית) אתר האינטרנט הרשמי של ADW Modula-2 (באנגלית) דגימות קוד של מודולה־2 ב־RosettaCode (באנגלית) Programming in Modula-2, Preface, pp. 3–5 Programming in Modula-2, Report on the Programming Language Modula-2, pp. 133–156 Programming in Modula-2, The Syntax of Modula-2, pp. 157–160 Programming in Modula-2, Appendix 2: Standard Utility Modules, pp. 161–169 Programming in Modula-2, Appendix 3: The ASCII Character Set, p. 170 Programming in Modula-2, Appendix 4: Syntax Diagrams, pp. 171–180 Programming in Modula-2, A First Example, pp. 11–13 Programming in Modula-2, Statements and Expressions, pp. 19–21 Programming in Modula-2, Elementary Data Types, pp. 28–35 Programming in Modula-2, Representation of Modula Programs, pp. 16–18 Programming in Modula-2, Constant and Variable Declarations, p. 36 Programming in Modula-2, Control Structures, pp. 22–27 Programming in Modula-2, The Data Structure Array, pp. 37–46 Programming in Modula-2, Enumeration Types, p. 64 Programming in Modula-2, Procedures, pp. 47–48 Report, Introduction, pp. 133–134 Report, Declarations and Scope Rules, pp. 135–136 Report, Basic Types, pp. 137 Report, Syntax, p. 134 Report, Vocabulary and Representation, pp. 134–135 Report, Constant Declarations, p. 136 Report, Loop Statements, p. 147 Report, Return and Exit Statements, pp. 147–148 Report, While Statements, pp. 145–146 Report, Repeat Statements, p. 146 Report, For Statements, pp. 146–147 Report, If Statements, p. 145 Report, Enumerations, p. 137 Report, Subrange Types, pp. 137–138 Report, Array Types, p. 138 Report, Record Types, pp. 138–139 Report, Set Types, p. 139 Report, Pointer Types, p. 140 Report, Procedure Types, p. 140 Report, Type Declarations, pp. 136–140 Report, Procedure Declarations, pp. 148–150 Summary of projects by N. Wirth, 1962 - 1999, people.inf.ethz.ch Niklaus Wirth, The programming language Pascal, Acta Informatica 1, 1971, עמ' 35–63 doi: 10.1007/BF00264291 Niklaus Wirth, Modula: A language for modular multiprogramming, Software: Practice and Experience 7, 1977, עמ' 1–35 doi: 10.1002/spe.4380070102 Modula Two, wiki.c2.com Niklaus Wirth, MODULA-2, ETH, Institut für Informatik 27, ETH Zürich, 1978 doi: 10.3929/ethz-a-000153014 Niklaus Wirth, MODULA-2, ETH, Institut für Informatik 36, ETH Zürich, 1980 doi: 10.3929/ethz-a-000189918 Niklaus Wirth, Programming in Modula-2, 1st Edition, Berlin, Heidelberg: Springer-Verlag, 1982, ISBN 978-3-642-96717-7. (באנגלית) Niklaus Wirth, Programming in Modula-2, 2nd Edition, Berlin, Heidelberg: Springer-Verlag, 1983, ISBN 978-3-642-96757-3. (באנגלית) 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 Niklaus Wirth, Programming in Modula-2, 3rd Edition, Berlin, Heidelberg: Springer-Verlag, 1985, ISBN 978-3-642-96880-8. (באנגלית) Niklaus Wirth, Programming in Modula-2, 4th Edition, Berlin, Heidelberg: Springer-Verlag, 1988, ISBN 978-3-642-83567-4. (באנגלית) Niklaus Wirth, Modula-2 and object-oriented programming, ETH, Institut für Informatik 117, ETH Zürich, 1989 doi: 10.3929/ethz-a-000523424 ISO/IEC 10514-1:1996, ISO (באנגלית) News, GNU Modula-2 ADW Modula-2, ADW Modula-2 פִּרְקָן, באתר האקדמיה ללשון העברית שִׁגְרַת הֶמְשֵׁךְ, באתר האקדמיה ללשון העברית בּוֹ־זְמַנִּי, באתר האקדמיה ללשון העברית Modula-2 Basic Data Types, ADW Modula-2 Niklaus Wirth, et al., MacMETH User Manual, Zurich: ETH Zurich, 1992. (באנגלית) מִשְׁפַּט ”מִקְרֶה“, באתר האקדמיה ללשון העברית טִיפּוּס נִמְנִים, באתר האקדמיה ללשון העברית רְשׁוּמָה, באתר האקדמיה ללשון העברית Procedure Types, ADW Modula-2 Procedure Declarations, Modula-2 Reference (באנגלית) Modula-2 Reference: Expressions: Operators, ADW Modula-2 Features, GNU Modula-2 License, GNU Modula-2 Home, ADW Modula-2 Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes, The evolution of Lua, Proceedings of the third ACM SIGPLAN conference on History of programming languages, HOPL III, Association for Computing Machinery, 2007-06-09, עמ' 2–1–2–26 doi: 10.1145/1238844.1238846