מודולה

מודולה
Modula
	האפיון של מודולה מאת ניקלאוס וירת בהוצאת המכון הטכנולוגי של ציריך
טיפוסיות	חזקה, סטטית
השפיעה על	מודולה־2

מוֹדוּלה (באנגלית: Modula) היא שפת תכנות מערכות מובנת ופרוצדורלית עם טיפוסיות חזקה וסטטית שפותחה על ידי ניקלאוס וירת בין השנים 1973–1976 במכון הטכנולוגי של ציריך.^[1] מודולה הורחבה במקור מפסקל, וממנה נולד הפיתוח של מודולה־2.^[2] מודולה היא שפת תכנות ניסיונית והפיתוח שלה הופסק לטובת הפיתוח של מודולה־2.^[1]^[3]^[4]^[5]

היסטוריה

בשנת 1973 וירת התחיל את הפיתוח של מודולה.^[1] המימוש הראשון שלה הושלם על מחשב PDP-11.^[1]^{[א 1]}^{[א 2]}

בשנת 1976 וירת פרסם את האפיון של השפה במכון הטכנולוגי של ציריך.^[6]

בשנת 1977 וירת התחיל את הפיתוח של מודולה־2 כהמשך לפיתוח של מודולה, וכתחליף לפסקל.^[4]

דוגמאות

מחלק מרבי משותף

PROCEDURE GCD(n, m: INTEGER): INTEGER;
    VAR a, b: INTEGER;
BEGIN
    WHILE a <> b DO
        IF a < b THEN
            b := b - a
        ELSE
            a := a - b
        END
    END;
    GCD := a
END GCD

עיצוב

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

מודול כיחידת קוד מקור שעוברת הידור נפרד משאר הקוד.^{[א 1]}^{[א 3]}
ריבוי וניהול תהליכים בו זמניים על ידי אותות בתוך הקוד.^{[א 4]}^{[א 3]}

טיפוסי נתונים

מודולה הכירה רק בארבע טיפוסי נתונים בסיסיים: מספר שלם, ערך בוליאני (אמת או שקר), תו, ומערך סיביות.^{[א 5]}^{[א 6]} לא אופיין מספר ממשי ולא אופיין טיפוס נפרד למחרוזות בשפה, אך היה ניתן ליצור מחרוזת באמצעות מערך תווים.^{[א 7]} אין גישה למצביעים בשפה.^{[א 3]}

ריבוי תהליכים

כשפת תכנות מערכות, מודולה הציעה דרך ליישם ריבוי תהליכים בצורה נוחה.^{[א 4]} להכרזת תהליכים בשפה היה תחביר דומה לתחביר של שגרות, אם כי היה ניתן להגדיר תהליכים אך ורק ברמת הקובץ ולא באופן מקונן בתוך רכיבים אחרים.^{[א 8]} בשונה משגרות, תהליכים לא היו עוצרים את שאר התוכנה בזמן ריצה, אלא רצים באופן מקביל.^{[א 8]} היה ניתן להריץ תהליכים אך ורק מגוף השגרה הראשית, ולא בשום מקום אחר בקוד.^{[א 9]}^{[א 3]} בנוסף, מודולים ששיתפו נתונים בין התהליכים הוגדרו בעזרת המילה INTERFACE.^{[א 10]} מודולים מסוג זה יצרו תור לכל משתנה בתוכם כדי למנוע מצב שבו שני תהליכים או יותר היו ניגשים לקרוא או לכתוב באותו משתנה באותו הזמן.^{[א 10]} וירת המליץ נגד השימוש במשתנים כדי לסנכרן בין תהליכים, במקום זאת הוא עיצב בשפה אותות מיוחדים לניהול תהליכים מכל מקום בקוד.^{[א 11]}^{[א 3]} לאותות היה תחביר דומה לזה של קריאת שגרה.^{[א 11]} היו שני סוגי אותות: לעצירת תהליכים, ולהמשך תהליכים.^{[א 11]}

תחביר

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

אסימוני השפה

אסימונים במודולה^{[א 12]}
סיווג			הגדרה	דוגמה
מזהה	שם משתנה		רצף של תווי אותיות אלף־בת לטיניות וסיפרות עשרוניות, כשהתו הראשון מוכרח להיות אות.	`i8MyPi`
ערך	מספר שלם	עשרוני	רצף סיפרות עשרוניות.	`2016`
	מספר שלם	אוקטלי	רצף סיפרות עשרוניות בטווח 0–7 ותו `B` עוקב.	`7B`
	תו		תו בודד בין זוג תווי `'`.	`'C'`
תחביר	פעולה		כל הופעה של תו המייצג פעולה (ראה פעולות).	`+`
	מילה שמורה		כל רצף תווים שיוצר מילה מרשימת המילים השמורות.	`IF`
	הערה		כל רצף שנפתח ב־`(` ונסגר ב־`)`.	`(* Comment *)`

מילים שמורות

למודולה היו 35 מילים שמורות.^{[א 12]}

AND				DIV				INTERFACE		PROCEDURE		USE				
ARRAY			DO				LOOP			PROCESS			VALUE			
BEGIN			ELSE			MOD				RECORD			VAR				
CASE			ELSIF			MODULE			REPEAT			WHEN			
CONST			END				NOT				THEN			WHILE			
DEFINE			EXIT			OF				TYPE			WITH			
DEVICE			IF				OR				UNTIL			XOR

פעולות

סימני פעולות במודולה^{[א 12]}^{[א 13]}
סיווג		אופרנדים	פעולה	סימן
בינארי	הקצאה (קלט)	קליטת ערך למשתנה		`:=`	$=$
	יוחסה	מספרים	שווה ל־	`=`	$=$
			לא שווה ל־	`<>`	$\neq$
			גדול מ־	`>`	$>$
			קטן מ־	`<`	$<$
			גדול או שווה ל־	`>=`	$\geq$
			קטן או שווה ל־	`<=`	$\leq$
	לוגיקה	אמת או שקר	וגם	`AND`	$\land$
	לוגיקה	אמת או שקר	או	`OR`	$\lor$
	חשבון	מספרים	חיבור	`+`	$+$
			חיסור	`-`	$-$
			כפל	*``**	$\times$
			חילוק שלמים ללא שארית^[א]	`/`	$\div$
אונארי	לוגיקה	אמת או שקר	לא	`NOT`	$\neg$
אונארי	חשבון	מספר	סימן שלילי	`-`	$-$

^ במודולה לא היו מספרים ממשיים, לכן פעולת החילוק החזירה מספר שלם ללא שארית.

פקודות וביטויים

בדומה לשפות תכנות אחרות, פקודות במודולה אפשרו תכנות אימפרטיבי בכך שהן הורו בקרת זרימה והקצאת ביטויים לתוך משתנים,^{[א 14]} בעוד שהביטויים עצמם היו רצפים של פעולות ואופרנדים שעוברים חישוב לפי סדר פעולות מתמטי, או סדר פעולות שהמתכנת היה מגדיר בעזרת סוגריים עגולים.^{[א 13]} מודולה הכירה בתשע סוגי פקודות:^{[א 14]}

הקצאה (קליטת ערך למשתנה) :=^{[א 15]}
קריאת שגרה^{[א 16]}
כניסה לתוך היקף השדות ברשומה באמצעות הפקודה WITH^{[א 17]}
שש פקודות לבקרת זרימה:
1. תנאי IF^{[א 18]}
2. ניתוב מקרים CASE^{[א 19]}
3. יציאה ידנית מלולאת LOOP באמצעות הפקודה EXIT^{[א 20]}
4. שלוש סוגי לולאות:
  1. לולאה אין סופית LOOP^{[א 20]}
  2. לולאת WHILE^{[א 21]}
  3. לולאת REPEAT^{[א 22]}

קבועים

מודולה אפשרה למתכנת להכריז ערכים קבועים. ערכים אלה אינם משתנים במהלך התוכנית. קבועים הוגדרו בשפה באמצעות מזהה והסימן = ולאחריו הערך (הערך יכול להיות גם מבנה נתונים ולא רק ערך בסיסי).^{[א 7]}

ON = 1
OFF = 0

משתנים

הכרזה של משתנה נעשתה בעזרת הסימן : כשמשמאל שם המשתנה, ומימין טיפוס המשתנה.^{[א 23]}

i, j, k: INTEGER
p, q: BOOLEAN

בקרת זרימה

מהיותה שפת תכנות מבנית, חלק מסוגי הפקודות היו יכולות להכיל בתוכן תת-פקודות. לדוגמה, תנאי IF היה יכול להיות מוכל בתוך תנאי IF אחר, שגם הוא היה יכול להיות מוכל בתוך לולאת WHILE, וכך בעצם הייתה נוצרת בקרת זרימה. במודולה, הסימן נקודה ופסיק ; הפריד בין פקודות והגדיר את סדר הביצוע בתוכנית.^{[א 24]}

לולאות

מודולה הציעה שלוש סוגי לולאות: WHILE, REPEAT, ו־LOOP.^{[א 14]} כמו בשפות אחרות, הלולאות WHILE ו־REPEAT היו תלויות בתנאי כלשהו.^[^{דרוש מקור]} לעומת זאת, בלולאת LOOP נדרשה יציאה ידנית באמצעות הפקודה EXIT בתוכה.^{[א 20]}

LOOP
    i := i + 1 WHEN i = n DO EXIT
END

בלולאת WHILE, כל עוד התנאי מתקיים, הלולאה תמשיך לחזור על עצמה. דוגמה ללולאת WHILE:^{[א 21]}

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

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

REPEAT
    i := i + 1
UNTIL i = n

תנאים

הפקודה IF אפשרה בקרת זרימה לפי תנאים. אם התנאי הראשון נכשל, ניתן לשרשר מספר תנאים נוספים אחריו בעזרת ELSIF, ומצב ברירת מחדל באמצעות ELSE.^{[א 18]} תחביר של תנאי מלא היה נראה כך:

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

ניתוב מקרים

הפקודה CASE הייתה מחשבת ביטוי כלשהו ואז מבצעת קטע פקודות בהתאם לתוצאה. הקטעים סומנו בעזרת ערך קבוע או ערך מפורש.^{[א 19]}

CASE N OF
    0: BEGIN (* N equals 0 *) END
    1: BEGIN (* N equals 1 *) END
    2: BEGIN (* N equals 2 *) END
END

היקף שדות רשומה

הפקודה WITH מקבלת רשומה והופכת את השדות שלה לזמינים בתוך ההיקף שלה בלי הצורך להקליד בכל פעם את הכתובת המלאה של השדה עם השם של הרשומה.^{[א 17]}

WITH Account DO
    Balance := 0
END

מבני נתונים

מודולה הכירה בשני מבני נתונים יסודיים: מערך ורשומה.^{[א 6]}

מערך

מערך הוגדר בשפה בעזרת המילה השמורה ARRAY, לאחריו טווח האינדקסים, ולאחר מכן טיפוסיות המערך.^{[א 25]} לדוגמה, מחרוזת באורך 80 תווים הוגדר כך:

Line = ARRAY 0:79 OF CHAR

בנוסף, מערך רב ממדים הוגדר באמצעות רשימה של טווחים.^{[א 25]} לדוגמה, עמוד באורך 256 שורות שבכל אחת מהן יש 80 תווים הוגדר כך:

Buffer = ARRAY 0:255, 0:79 OF CHAR

גישה לתוך מערך הייתה מתבצעת בעזרת זוג סוגריים מרובעים [] ובינם האינדקסים מסודרים ברשימה לכל ממד.^{[א 23]}

B: Buffer
B[0, 0] := 'C'

רשומה

רשומה הוגדרה בשפה בעזרת המילה השמורה RECORD ואז רשימת השדות והטיפוסיות שלהם (הסימן נקודה ופסיק ; הפריד בין השדות).^{[א 26]} לדוגמה:

Account = RECORD
    FirstName: ARRAY 0:255 OF CHAR;
    LastName: ARRAY 0:255 OF CHAR;
    Balance: INTEGER;
    Alive: BOOLEAN
END

גישה לתוך שדות ברשומה הייתה מתבצעת באמצעות נקודה ..^{[א 23]}

A: Account
A.Alive := TRUE

שגרות

מהיותה שפת תכנות פרוצדורלית, פירקנים במודולה היו עשויים להגדיר תת-תוכניות ולייצא אותם כפקודות עם שמות ייחודיים ופרמטרים. פקודות כאלה נקראות שגרות והן היו מוגדרות בעזרת המילה השמורה PROCEDURE.^{[א 27]} שגרה היא בגדר פונקציה אם היא מחזירה ערך כלשהו, אחרת היא בגדר ציווי.^{[א 27]} פונקציה תחזיר את הערך שהוקצה למזהה שלה.^{[א 27]} הגדרת קבועים ומשתנים מקומיים התאפשרה לפני המילה BEGIN.^{[א 27]} המילה CONST הגדירה את הקבועים, בעוד המילה VAR הגדירה את המשתנים.^{[א 27]} דוגמה לפונקציה ריבועית פשוטה של מספרים שלמים $f(n)=n^{2}$ כך ש־ $f:\mathbb {Z} \rightarrow \mathbb {N}$ :

PROCEDURE f(n: INTEGER): INTEGER;
BEGIN
    f := n * n;
END f

קריאה לשגרה נעשתה בעזרת רשימת ערכים מתאימים לפרמטרים בתוך סוגריים עגולים () מיד אחרי שם השגרה.^{[א 16]}

k := Factorial(4)

טיפוס נמנים

טיפוסי נמנים (enumerated type) הוגדרו בשפה בעזרת זוג סוגריים עגולים () ובתוכם רשימת מזהים מופרדים עם פסיק ,.^{[א 28]}

weekdays = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)

מודולים

תוכניות במודולה היו בנויות מרכיבים שעברו הידור נפרד זה אחר זה לפי קשר התלות בינם, רכיבים אלו כונו "מודולים" או בעברית "פירקנים."^{[א 29]} מבנה המודול הוא גם השלד הבסיסי של כל קובץ קוד מקור בשפה.^{[א 29]} הקטע הבא מתאר את מבנה המודול במודולה.^{[א 29]} בסוף מודול תמיד מופיעה נקודה.^{[א 29]}

MODULE MyModule
    DEFINE f, g;    (* List of exported identifiers *)
    USE;            (* List of imported identifiers *)
    CONST;          (* List of constants *)
    VAR;            (* List of variables *)
    (* Some procedures: *)
    PROCEDURE f(x: INTEGER): INTEGER BEGIN END f;
    PROCEDURE g(x: INTEGER): INTEGER BEGIN END g;
BEGIN
    (* Statements *)
END MyModule.

ראו גם

פסקל - שפת התכנות שממנה הורחבה מודולה.^[1]
מודולה־2 - שפת התכנות שירשה את הפיתוח של מודולה.^[1]

לקריאה נוספת

Niklaus Wirth, Modula: A Language for Modular Multiprogramming, ETH Zurich, 1976

קישורים חיצוניים

מדיה וקבצים בנושא מודולה בוויקישיתוף
דגימות קוד של מודולה ב־RosettaCode (באנגלית)

הערות שוליים

אפיון השפה

^ ^1.0 ^1.1 ^1.2 ^1.3 ^1.4 ^1.5 ^1.6 ^1.7 Modula, Introduction, pp. 3–5
^ Modula, PDP-11 Specific Facilities, pp. 29–32
^ ^3.0 ^3.1 ^3.2 ^3.3 ^3.4 Modula, Overview, pp. 5–9
^ ^4.0 ^4.1 Modula, Facilities for Multiprogramming, pp. 25–29
^ Modula, Basic Types, p. 13
^ ^6.0 ^6.1 Modula, Type Declarations, pp. 12–14
^ ^7.0 ^7.1 Modula, Constant Declarations, p. 12
^ ^8.0 ^8.1 Modula, Processes, pp. 25–26
^ Modula, Process Control Statement, p. 26
^ ^10.0 ^10.1 Modula, Interface Modules, pp. 25–26
^ ^11.0 ^11.1 ^11.2 Modula, Signals, pp. 26–28
^ ^12.0 ^12.1 ^12.2 Modula, Vocabulary and Representation, pp. 10–12
^ ^13.0 ^13.1 Modula, Expressions, pp. 15–16
^ ^14.0 ^14.1 ^14.2 Modula, Statements, p. 16
^ Modula, Assignments, p. 16
^ ^16.0 ^16.1 Modula, Procedure Calls, p. 17
^ ^17.0 ^17.1 Modula, With Statements, p. 19
^ ^18.0 ^18.1 Modula, If Statements, p. 17
^ ^19.0 ^19.1 Modula, Case Statements, p. 18
^ ^20.0 ^20.1 ^20.2 Modula, Loop Statements, pp. 18–19
^ ^21.0 ^21.1 Modula, While Statements, p. 18
^ ^22.0 ^22.1 Modula, Repeat Statements, p. 18
^ ^23.0 ^23.1 ^23.2 Modula, Variables, pp. 14–15
^ Modula, Statement Sequence, p. 17
^ ^25.0 ^25.1 Modula, Array Structures, p. 13
^ Modula, Record Structures, p. 14
^ ^27.0 ^27.1 ^27.2 ^27.3 ^27.4 Modula, Procedures, pp. 19–22
^ Modula, Enumerations, p. 13
^ ^29.0 ^29.1 ^29.2 ^29.3 Modula, Modules, pp. 22–25

מקורות נוספים

^ ^1.0 ^1.1 ^1.2 ^1.3 ^1.4 ^1.5 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
^ Modula Two, wiki.c2.com
^ ^4.0 ^4.1 Niklaus Wirth, Preface, Programming in Modula-2, 4th Edition, Berlin, Heidelberg: Springer, 1988, Texts and Monographs in Computer Science, עמ' 3-5, מסת"ב 978-3-642-83565-0. (באנגלית)
^ Niklaus Wirth, Introduction, Report on the Programming Language Modula-2, 4th Edition, Berlin, Heidelberg: Springer-Verlag, 1988, עמ' 133–134, מסת"ב 978-3-642-83567-4. (באנגלית)
^ Niklaus Wirth, Modula: A Language for Modular Multiprogramming, ETH Zurich, 1976

הערך באדיבות ויקיפדיה העברית, קרדיט,
רשימת התורמים
רישיון cc-by-sa 3.0

34874739מודולה

[20] במודולה לא היו מספרים ממשיים, לכן פעולת החילוק החזירה מספר שלם ללא שארית.

[:0-6] 1.0 ^1.1 ^1.2 ^1.3 ^1.4 ^1.5 ^1.6 ^1.7 Modula, Introduction, pp. 3–5

[7] Modula, PDP-11 Specific Facilities, pp. 29–32

[:15-9] 3.0 ^3.1 ^3.2 ^3.3 ^3.4 Modula, Overview, pp. 5–9

[:16-10] 4.0 ^4.1 Modula, Facilities for Multiprogramming, pp. 25–29

[11] Modula, Basic Types, p. 13

[:3-12] 6.0 ^6.1 Modula, Type Declarations, pp. 12–14

[:1-13] 7.0 ^7.1 Modula, Constant Declarations, p. 12

[:17-14] 8.0 ^8.1 Modula, Processes, pp. 25–26

[15] Modula, Process Control Statement, p. 26

[:18-16] 10.0 ^10.1 Modula, Interface Modules, pp. 25–26

[:19-17] 11.0 ^11.1 ^11.2 Modula, Signals, pp. 26–28

[:1report-18] 12.0 ^12.1 ^12.2 Modula, Vocabulary and Representation, pp. 10–12

[:5-19] 13.0 ^13.1 Modula, Expressions, pp. 15–16

[:6-21] 14.0 ^14.1 ^14.2 Modula, Statements, p. 16

[22] Modula, Assignments, p. 16

[:7-23] 16.0 ^16.1 Modula, Procedure Calls, p. 17

[:8-24] 17.0 ^17.1 Modula, With Statements, p. 19

[:9-25] 18.0 ^18.1 Modula, If Statements, p. 17

[:10-26] 19.0 ^19.1 Modula, Case Statements, p. 18

[:11-27] 20.0 ^20.1 ^20.2 Modula, Loop Statements, pp. 18–19

[:12-28] 21.0 ^21.1 Modula, While Statements, p. 18

[:13-29] 22.0 ^22.1 Modula, Repeat Statements, p. 18

[:4-30] 23.0 ^23.1 ^23.2 Modula, Variables, pp. 14–15

[31] Modula, Statement Sequence, p. 17

[:2-32] 25.0 ^25.1 Modula, Array Structures, p. 13

[33] Modula, Record Structures, p. 14

[:14-34] 27.0 ^27.1 ^27.2 ^27.3 ^27.4 Modula, Procedures, pp. 19–22

[35] Modula, Enumerations, p. 13

[:20-36] 29.0 ^29.1 ^29.2 ^29.3 Modula, Modules, pp. 22–25

[:1-1] 1.0 ^1.1 ^1.2 ^1.3 ^1.4 ^1.5 Summary of projects by N. Wirth, 1962 - 1999, people.inf.ethz.ch

[2] Niklaus Wirth, The programming language Pascal, Acta Informatica 1, 1971, עמ' 35–63 doi: 10.1007/BF00264291

[3] Modula Two, wiki.c2.com

[:0-4] 4.0 ^4.1 Niklaus Wirth, Preface, Programming in Modula-2, 4th Edition, Berlin, Heidelberg: Springer, 1988, Texts and Monographs in Computer Science, עמ' 3-5, מסת"ב 978-3-642-83565-0. (באנגלית)

[5] Niklaus Wirth, Introduction, Report on the Programming Language Modula-2, 4th Edition, Berlin, Heidelberg: Springer-Verlag, 1988, עמ' 133–134, מסת"ב 978-3-642-83567-4. (באנגלית)

[8] Niklaus Wirth, Modula: A Language for Modular Multiprogramming, ETH Zurich, 1976

[1]

[2]

[3]

[4]

[5]

[א 1]

[א 2]

[6]

[א 3]

[א 4]

[א 5]

[א 6]

[א 7]

[א 8]

[א 9]

[א 10]

[א 11]

[א 12]

[א 13]

[א]

[א 14]

[א 15]

[א 16]

[א 17]

[א 18]

[א 19]

[א 20]

[א 21]

[א 22]

[א 23]

[א 24]

[א 25]

[א 26]

[א 27]

[א 28]

[א 29]

מודולה

תוכן עניינים

היסטוריה

דוגמאות

מחלק מרבי משותף

עיצוב

טיפוסי נתונים

ריבוי תהליכים

תחביר

אסימוני השפה

מילים שמורות

פעולות

פקודות וביטויים

קבועים

משתנים

בקרת זרימה

לולאות

תנאים

ניתוב מקרים

היקף שדות רשומה

מבני נתונים

מערך

רשומה

שגרות

טיפוס נמנים

מודולים

ראו גם

לקריאה נוספת

קישורים חיצוניים

הערות שוליים

אפיון השפה

מקורות נוספים

תפריט ניווט

מודולה

היסטוריה

דוגמאות

מחלק מרבי משותף

עיצוב

טיפוסי נתונים

ריבוי תהליכים

תחביר

אסימוני השפה

מילים שמורות

פעולות

פקודות וביטויים

קבועים

משתנים

בקרת זרימה

לולאות

תנאים

ניתוב מקרים

היקף שדות רשומה

מבני נתונים

מערך

רשומה

שגרות

טיפוס נמנים

מודולים

ראו גם

לקריאה נוספת

קישורים חיצוניים

הערות שוליים

אפיון השפה

מקורות נוספים

תפריט ניווט

חיפוש