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

**פסקל** (באנגלית: **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` הן זהות לחלוטין מבחינת השפה.

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


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


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

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

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


```pascal
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 תווים. עם זאת, ניתן להקטין ולהגביל את אורכה באופן הבא:


```pascal
Type StringNine = String [9];
```


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

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


```pascal
Var i : Integer = 0;
```


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


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


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


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


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


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


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

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


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


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

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

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


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


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


```pascal
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`. עם זאת במהלך התוכנית יש לבצע השמת ערך לשמה של הפונקציה, פעולה שתגרום לפונקציה להחזיר ערך. לדוגמה:


```pascal
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".


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


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

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


```pascal
If Variable > Value Then
 Statement1
Else
 Statement2;
```


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

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


```pascal
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`.


```pascal
For i := 1 to 10 Do
 Statement1;
```


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


```pascal
While Variable > Value Do
 Statement1;
```


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


```pascal
Repeat
 Statement1;
Until Variable > Value;
```


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

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

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


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


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


```pascal
Var
 pb: RecPtr
```


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


```pascal
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
קטגוריה:אפונימים