פסקל (שפת תכנות)

פסקל (באנגלית: Pascal) היא שפת תכנות עילית, שפותחה בשנת 1970 על ידי ניקלאוס וירת, וקרויה על שמו של המתמטיקאי והפילוסוף בן המאה ה-17 בלז פסקל.

השפה תוכננה במטרה להקל על לימוד שפות תכנות ומדעי המחשב, ושימשה לפיתוח תוכנה ואף כשפה הסטנדרטית לתיאור אלגוריתמים עד אמצע שנות התשעים. תכנון השפה הושפע בעיקר משפת ALGOL, כמו שפות רבות אחרות. השפה מאפשרת תכנות מבני, תוך שימוש בשגרות, פונקציות ויצירת מבני נתונים מורכבים.

בגרסתה המקורית היו בשפה כשלים תכנוניים רבים, אך לא מעטים מהם שופרו עם הזמן בתקינה, ואחרים שופצו על ידי מפתחי המהדרים. פסקל השפיעה רבות על עולם התוכנה ועל שפות שהופיעו אחריה, כגון עדה, Java, Visual Basic ועוד.

 היסטוריה 
ממוזער|שמאל|השפה פותחה בשנת 1970 על ידי ניקלאוס וירת, וקרויה על שמו של המתמטיקאי והפילוסוף בן המאה ה-17 בלז פסקל.

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

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

בשל תפיסותיה ובהירות קוד המקור שלה, היא שימשה שפה לימודית באוניברסיטאות פרק זמן לא מבוטל. משרד החינוך הישראלי השתמש בשפת פסקל לבחינות הבגרות וללימוד בכיתות, במקביל לשפת C, עד שנת 2006. ההתאמה שלה ללמידה סייעה לה להפוך לשפה משפיעה, בשל העובדה שבוגרי תיכונים רבים בשנות השבעים, השמונים והתשעים של המאה ה-20 היו בעלי ידע בשפה זו.

בפועל השפה הייתה חזקה יותר מהשפה המתוקננת, הואיל והחברות שפיתחו סביבות פיתוח לשפה זו הרחיבו אותה ויצרו שפה גמישה וחזקה יותר, אך יכולות אלה גרמו לתלות במהדר הספציפי עבורו הן נכתבו. בין החברות שפיתחו מהדרים לשפה זו הייתה מיקרוסופט (עם Microsoft Pascal), אך הפופולרית שבהן הייתה חברת בורלנד שפיתחה בסביבת DOS סביבת פיתוח ומהדר בשם טורבו פסקל. בגרסה 5.5 היא הורחבה לתכנות מונחה עצמים ובגרסתה השביעית הוציאה גם סביבת פיתוח לחלונות 16 ביט בשם BPW. גרסה זו לא זכתה לפופולריות ועם עליית התפוצה של מערכת ההפעלה חלונות, טורבו פסקל ירד ממעמדו, ולמעשה הוחלף בסביבת הפיתוח הוויזואלית דלפי, שמשתמשת בפסקל כשפת הקוד הפנימית שלה. קיימות מספר סביבת פיתוח חופשיות לפסקל, אחת מהידועות בהן היא סביבה רב פלטפורמית של הקוד הפתוח בשם FreePascal.

 מבנה התוכנית 

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

 שם התוכנית: המילה השמורה Program ולאחריה שם התוכנית.
 ספריות חיצוניות: המילה השמורה Uses ולאחריה רשימת הספריות החיצוניות שהתוכנית עושה בהם שימוש. לדוגמה: גרפיקה, קריאות למערכת ההפעלה וכולי.
 תוויות קפיצה: באמצעות המילה השמורה Label.
 קבועים גלובליים: באמצעות המילה השמורה Const.
 טיפוסי נתונים באמצעות המילה השמורה Type.
 משתנים גלובליים באמצעות המילה השמורה Var.
 פונקציות ושגרות (פרוצדורות) גלובליות באמצעות המילות השמורות Function ו- Procedure. (בשפות התכנות של היום אין הבחנה בין פונקציה לפרוצדורה, ההבדל ביניהן בפסקל הוא שפונקציה מחזירה ערך בעוד פרוצדורה לא מחזירה ערך)
 גוף התוכנית המתחיל במילה השמורה Begin ומסתיים במילה השמורה End ולאחר מכן נקודה (".").

השפה אינה מבחינה בין אותיות קטנות וגדולות. לדוגמה, הפקודות: write, Write ו- wrITE הן זהות לחלוטין מבחינת השפה.

 התוכנית "שלום עולם" 

Program Hello_World;
Begin
 Writeln ('Hello World!');
End.

קוד זה יגרום להצגת "!Hello World" על המסך ולירידת הסמן לשורה הבאה.

 פקודות בסיסיות 
כל בלוק בשפה מתחיל במילה השמורה Begin ויסתיים במילה השמורה End ולאחריה נקודה. הפקודות בשפה מופרדות ביניהן בעזרת נקודה פסיק (כמו שפות רבות אחרות שהושפעו משפת Algol). בשל ההגדרה של הפקודות ב"מופרדות בנקודה פסיק" ולא "מסתיימות בנקודה פסיק", הוספה של נקודה פסיק לאחר הפקודה האחרונה תגרום לשגיאת הידור; מאפיין זה גרר ביקורת רבה. בסופה של התוכנית יש להוסיף תו נקודה במקום נקודה ופסיק. מחרוזת תוקף בגרש (') יחיד בלבד ולא בגרשיים (") כפי שמקובל בשפות תכנות אחרות. הערה תוקף בתווים (* בתחילתה והתווים *) בסופה.

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

Const
 Example1 : Boolean = False;
 Example2 : Array [3 .. 5] of Char = ('F', 'o', 'o');

 משתנה 
מערכת הטיפוסים של השפה היא בעלת טיפוסיות סטטית ובטוחה יחסית, כך שלא ניתן להמיר בין טיפוסי נתונים מובחנים. מאפיין זה סייע להקל על לימוד השפה, אך גרר ביקורת בשל הקושי הרב לבצע פעולות שבשפות אחרות (כגון שפת C) הן קלות לביצוע.
בפסקל ישנם כמה טיפוסי משתנים:
 מספרים שלמים בגדלים שונים:
כל המספרים: ShortInt, Integer, LongInt. החל מגרסה 7 של טורבו פסקל נוסף Int64 (עבור כל מספר שלם, שערכו המוחלט אינו גדול מהחסם: 2 בחזקת 63, אם המספר שלילי; בעוד שאם המספר חיובי יש להפחית אחד מהחסם).
טווח המספרים החיוביים בלבד: Byte, Word.
 מספר ממשיים בגדלים שונים: Comp ,Extended ,Double ,Single ,Real.
 משתנה מסוג תו היכול להכיל תו ASCII יחיד: Char.
 מחרוזת: String. המחרוזת יכולה להכיל רצף של תווים אלפא־נומריים באורך משתנה עד 255 תווים. עם זאת, ניתן להקטין ולהגביל את אורכה באופן הבא:

Type StringNine = String [9];

החל מגרסה 7 של טורבו פסקל נוספה מחרוזת NullTerminated שגודלה 65,535 תווים.
 בוליאני: Boolean - משתנה היכול להכיל שני ערכים בלבד - "True" ו־"False" (בשונה מהמקובל בשפות אחרות כגון שפת C לא ניתן להגדיר למשתנה בוליאני ערכים באמצעות 0 ו־1).

ההכרזה על משתנה תתבצע באמצעות המילה השמורה Var לפני גוף התוכנית. ניתן לבצע הכרזה והשמת ערך בפקודה אחת, אך יש מהדרים שאינם תומכים באפשרות זו:

Var i : Integer = 0;

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

Var myArray : Array [0..261] of Char;

ניתן להגדיר טווח של איברי מערך לא רק באמצעות מספרים אלא אף באמצעות תווים. בדוגמה הבאה ייווצר מערך שגודלו יהיה בדיוק מספר האותיות שבא'-ב' הלועזי.

Var aLetters: Array ['A'..'Z'] of Char;

באמצעות התו פסיק ניתן ליצור מערכים רבי ממדים בסוגריים המרובעים שבהם אנו מגדירים את מספר האיברים. בדוגמה הבאה ניתן לראות מערך תלת־ממדי המייצג למעשה קובייה.

Var myArray : Array [0..10, 0..10, 0..10] of Char;

לפני השימוש במערך יש לאפס את המערך כדי לנקות אותו ממידע אקראי. כדי לגשת למידע במערך יש להשתמש בסוגריים מרובעים לאחר שם המערך, בהם אינדקס המיוצג על ידי מספר, אות או משתנה.

 משתנה מורכב - רשומה 
משתנה מסוג "רשומה" הוא משתנה שמוגדר על ידי המתכנת וכולל צירוף של מספר טיפוסי משתנים ביחד. הוא יכול להכיל בתוכו משתנים רגילים, מערכים ומצביעים. שימושים נפוצים הם במבנה ערכים טבלאי וברשימות מקושרות. הגדרת רשומה נעשית באמצעות המילים השמורות Record ו־End, בתוך קטע הקוד של Var. לדוגמה:

Var
 tW32FindData = Record
 iFileAttributes : LongInt;
 iCreationTime : Array [0..1] of LongInt;
 cFileName : Array [0..261] of Char;
 End;

ניתן ליצור מבנה של רשומה דינמית, שבה תתבצע הגדרה דינמית של המשתנים בזמן ריצה, כאשר המשתנים שברשומה ישתנו בהתאם לערכי שדה או שדות אחרים. הדבר נעשה באמצעות פקודת Case, בדומה לפקודת Case רגילה, יוכרזו משתנים שונים בכל תנאי, וכך מבנה השדות ישתנה מרשומה לרשומה, לפי הערכים שבפועל קיימים בהם.

ניתן להשתמש במילה With על מנת לקצר את הגישה במשתנה רשומה ולוותר על הקידומת של שם משתנה הרשומה, כך לאחר פקודת With אפשר לגשת ישירות למשתני הרשומה.

 קבוצות 
ניתן ליצור בפסקל אוסף של פריטים מכל סוג שהוא בתוך משתנה יחיד מסוג Set. מספר הפריטים המרבי הוא 256. ניתן לבצע פעולות שונות על קבוצות, כמו למשל בדיקה האם קבוצה מכילה או מוכלת בקבוצה אחרת, איחוד, חיסור וחיתוך בין הקבוצות. דוגמה להגדרת קבוצה:

Var
 TheSet : SET OF BaseType
 TheSet := [Element1, Element2, ... ElementN];

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

Procedure PrintManyTimes (t : integer; s : string);
 Var
 i : Integer;
 Begin
 For i := 1 To t Do
 Writeln (s);
 End;

שגרה זו מקבלת מספר (t) ומחרוזת (s). השגרה מדפיסה t פעמים את המחרוזת s.

 פונקציה 
פונקציה מוגדרת באמצעות כותרת שבה המילה השמורה Function, שם הפונקציה, שמות וסוג הפרמטרים שהיא מקבלת, וסוג תוכן שהיא מחזירה. בדומה לשגרה, לאחר מכן ניתן להגדיר קבועים ומשתנים מקומיים. גוף השגרה תחום באמצעות המילים Begin ו־End. עם זאת במהלך התוכנית יש לבצע השמת ערך לשמה של הפונקציה, פעולה שתגרום לפונקציה להחזיר ערך. לדוגמה:

Function Get_NumberCard (Num : Integer) : Integer;
 Var
 St1 : String;
 Number, Code : Integer;
 Begin
 St1 := Card_GetIdent(C, Num);
 St1 := Str_Get(St1, 2, '-');
 Val(St1, Number, Code);
 Get_NumberCard := Number;
 End;

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

 כתיבה וקריאה 
בפסקל, קלט ופלט אינטראקטיבי (למשתמש וממנו) מבוצע באמצעות השגרות Read ו־Write. קיימות גם השגרות ReadLn ו־WriteLn, המבצעות ירידת שורה לאחר ביצוע פעולת הכתיבה או הקריאה.

 Read: קליטה של ערך. זוהי פקודה המורה למשתמש להזין ערך. הערך שיתקבל יושם לתוך המשתנה הנמצא בסוגריים.

 Write: הדפסה של ערך ומידע. את המידע המודפס יש להכניס לסוגריים, כאשר המידע מופרד באמצעות פסיק ותחום בגרש יחיד. לדוגמה, אם בקוד הבא המשתנה iNum הוא המספר 8, אזי יודפס: "The Value of iNum is 8".

Write('The value of iNum is ', iNum);

 השמה 
השמה נעשית באמצעות נקודתיים וסימן שווה ("=:"). כך לדוגמה, X := A + 5 הוא חיבור המשתנה A והמספר 5 והשמת התוצאה במשתנה X.

 מבני בקרה 
 תנאי If...Then...Else 
מבנה If...Then...Else מאפשר לבצע פקודות באופן בררני באמצעות התניה ולבצע הסתעפות של התוכנה לכיוונים שונים. אם התנאי לא התקבל ניתן לבצע פקודה חלופית באמצעות Else. ניתן לכתוב תנאי If מקוננים.

If Variable > Value Then
 Statement1
Else
 Statement2;

אין למקם את סימן הנקודה פסיק לאחר המילה Then או לפני ה-Else. ניתן להשתמש ב-Begin ו-End לשם ביצוע מספר פקודות מותנות (פקודה מורכבת).

 תנאי Case...End 
תנאי Case...End מאפשר ליצור תנאי מרובה על ערכים מטיפוס נתונים סדור מסוג מספרי או Char. היא יכולה לפעול על טווחי ערכים ואף טווחי משנה. בטורבו פסקל נוספה פקודת Else שאינה קיימת בשפה התקנית.

Case Variable of
 Value1: Statment1;
 Value2: Statment2
 Else Statment3;
End;

 לולאות 
 לולאת For...Do 
לולאת...For היא פקודה מחזורית המורה לבצע קטע קוד מספר פעמים קבוע מראש. בתחילת הפעלתה יש לקבוע את מספר הפעמים שהיא תתבצע. לדוגמה: For i := 1 To 7 Do. במקרה זה i הוא המשתנה המונה, והמניה תתבצע מ־1 עד ל־7. כברירת מחדל, פסקל תחזור רק על הפקודה שמיד לאחר הוראת הלולאה, בדומה לתנאי If. כדי לכלול מספר פקודות יש להשתמש במילים Begin ו־End.

For i := 1 to 10 Do
 Statement1;

 לולאת While...Do 
לולאה זו היא פקודה המבצעת את קטע קוד כל עוד תנאי כלשהו מתקיים. היא נחשבת לגמישה יותר מכיוון שהיא יכולה לבחון תנאים שבזמן כתיבת התוכנית אינם ברורים כגון גודל של קובץ.

While Variable > Value Do
 Statement1;

 לולאת Repeat...Until 
לולאה זו אף היא מתקיימת על פי תנאי. היא דומה ללולאת While...Do וההבדל העיקרי הוא שהתנאי מוערך רק לאחר ביצוע הקוד, ולכן תמיד יתבצע הקוד לפחות פעם אחת. הבדל נוסף הוא שלולאת While ממשיכה לרוץ כל עוד התנאי המוערך מתקיים (כלומר מקבל ערך "TRUE") ואילו לולאת Repeat ממשיכה לרוץ כל עוד התנאי המוערך לא מתקיים (כלומר מקבל ערך "False").

Repeat
 Statement1;
Until Variable > Value;

 אופרטרים 
 אופרטורים אריתמטיים: חיבור (+), חיסור (-), כפל (*) וחילוק (/) פועלים באופן המקובל. אופרטור Div מחזיר את החלק השלם לאחר חילוק. אופרטור Mod מחזיר את השארית לאחר חילוק.
 אופרטורים בוליאניים: או (Or), וגם (And), לא (Not), שווה ל- (=), שונה מ- (<>), גדול מ- (<), קטן מ- (>), גדול או שווה ל- (=<) וקטן או שווה ל- (=>).
 אופרטורי קבוצות: מכיל את (=<), מוכל ב- (=>), שייך אל (in).

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

לדוגמה, כדי להגדיר מבנה ששמו MyRecord ובו שלושה משתנים, כאשר המשתנה RecPtr מצביע אליו, והוא גם משולב כאחד מאיבריו (ליישום של רשימה מקושרת), נכתוב את הקוד הבא:

Type
 String20 = String[20];
 RecPtr = ^MyRecord;
 MyRecord = Record
 Name: String20;
 Age: integer;
 Next: RecPtr
 End;

כדי להכריז על משתנה pb, מצביע מסוג MyRecord, יש לכתוב את הקוד הבא:

Var
 pb: RecPtr

יצירה של רשומה חדשה וביצוע השמה של שם, גיל ומצביע, כך שהמצביע יצביע לכלום, יש לכתוב את הפקודות הבאות:

New(pb);
pb^.Name := 'Eli Gold';
pb^.Age := 18;
pb^.Next := Nil;

 עבודה עם קבצים 

 מילים שמורות 
לפי תקן ISO הבסיסי בפסקל קיימות 35 מילים שמורות, לצורך שימושים מיוחדים של השפה כגון מזהים, אופרטורים, קבועים ופקודות תכנותיות. לא ניתן לכנות משתנים בשמות אלה. בתקן המורחב נוספו עוד 13 מילים נוספות.

 מילים שמורות לפי מסמך 7185
and | array | begin | case | const | div |do | downto | else | end | file | for | function | goto | if | in | label | mod | nil | not | of | or | packed | procedure | program | record | repeat | set | then
| to | type | until | var | while | with.

 תוספת של מילים שמורות לפי מסמך 10206
and then | bindable | export | import | module | only | or else | otherwise | pow | protected | qualifed | restricted | value |

 בטורבו פסקל נוספו עוד מילים שמורות, בהן: Unit ו-Uses להגדרת שימוש ביחידות חיצוניות, XOR, InLine ו-Object ו-assign לייבוא, ייצוא וטיפול בקבצים שאינם pascal units

 הרחבות לפסקל 
על פי תקן 10206 הוספו לפסקל שיפורים רבים והעיקריים שבהם: מודולים מוכללים שניתן יהיה להדר כרכיבי תוכנה נפרדים שמקבילים ל-Unit של טורבו פסקל. סכמה לקביעת טיפוסי משתנים דומים, שיוכלו להיות מוגדרים באופן סטטי או דינמי, כך למשל אפשר להגדיר מערך דינמי כפרמטר של פונקציה. מחרוזת מטיפוס גודל קבוע. משתנה שניתן לכריכה, גישה ישירה לקבצים, מספרים מרוכבים, אתחול ערכים ברשומה באמצעות בנאי, פרמטרים מוגנים משינוי, פונקציות לטיפול בחתימת זמן ואופרטור להעלאה בחזקה.

 רשימת מהדרים לפסקל 

 ראו גם 
 דלפי
 טורבו פסקל
 Lazarus

 לקריאה נוספת 
 סקוט ד. פלמר, תכנות בבורלנד פסקל, בהוצאת באג

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

 FreePascal, סביבת פיתוח חופשית
 GnuPascal, סביבת פיתוח מבית פרויקט גנו
 DevPascal, סביבת פיתוח לפיתוח בסביבת חלונות
 מאמר שמשווה בין תקן פסקל מורחב לבין טורבו פסקל



 הערות שוליים 

קטגוריה:שפות תכנות
קטגוריה:בלז פסקל
קטגוריה:תוכנות שהושקו ב-1970
קטגוריה:אפונימים