The Structure of a Pascal Program

EVERY PASCAL PROGRAM MUST FOLLOW A BASİC STRUCTURE. WHİLE THİS STRUCTURE İS VERY SİMİLAR TO KAREL
PROGRAMMİNG, THERE ARE SEVERAL DİFFERENCES. BELOW İS THE BASİC STRUCTURE THAT EVERY PASCAL PROGRAM MUST
FOLLOW.
PROGRAM ProgramName;

VAR
VariableName : VariableType;
VariableName : VariableType;
...

PROCEDURE ProcedureName;
variables here if necessary
BEGIN
Some Code;
END;

FUNCTION FunctionName(variableList): VariableType;

variables here if necessary
BEGIN
Some Code if necessary;
FunctionName := some expression
More Code if necessary;
END;

... more functions and procedures if necessary ...

BEGIN
the main program block. It should be small and all
work should be delegated to the procedures and
functions.
It often consists of a WHILE loop that calls in
turn procedures and functions in the appropriate
order.
END.
NOTE: THE FUNCTİONS AND PROCEDURES CAN APPEAR İN ANY ORDER. THE ONLY REQUİREMENT İS THAT İF ONE PROCEDURE
OR FUNCTİON USES ANOTHER ONE, THAT LATTER ONE MUST HAVE BEEN DEFİNED ALREADY.

Variable Types
THERE ARE FİVE BASİC VARİABLE TYPES İN PASCAL: INTEGER, REAL, CHAR, BOOLEAN, AND STRING. THEY
ARE DEFİNED AS FOLLOWS :
I A POSİTİVE OR NEGATİVE İNTEGER BETWEEN A SMALLEST (NEGATİVE) AND A LARGEST NUMBER. IN
NT GENERAL THE SMALLEST AND LARGEST NUMBER POSSİBLE DEPENDS ON THE MACHİNE; FOR IBM PC
EG AND TURBO PASCAL THEY ARE:
ER SMALLEST INTEGER: -32766

LARGEST INTEGER: 32767

RE CAN CONTAİN A REAL NUMBER İN SCİENTİFİC OR DECİMAL NOTATİON. THERE İS A LİMİT ON THE SİZE AND
AL ACCURACY OF THE REAL NUMBER THAT WİLL BE COVERED LATER. VALİD REAL NUMBERS ARE, FOR
EXAMPLE:
DECİMAL NOTATİON: 1.234 OR -34.5507
SCİENTİFİC NOTATİON: 5.0E-3 OR -7.443E3
CH ANY KEY ON THE KEYBOARD İS CONSİDERED A VALİD CHARACTER. CHARACTERS ARE USUALLY
AR ENCLOSED İN SİNGLE QUOTES. FOR EXAMPLE: '1' İS A CHARACTER, WHİLE 1 İS AN İNTEGER.
BO
OL
WE WİLL DEAL WİTH BOOLEAN VARİABLES LATER
EA
N
ST A STRİNG İS A COLLECTİON OF UP TO 255 CHARACTERS ENCLOSED İN SİNGLE QUOTES. FOR EXAMPLE:
RIN
'BERT' İS A STRİNG OF 4 CHARACTERS. MORE DETAİLS ABOUT STRİNGS WİLL FOLLOW LATER.
G

Assigning Values to Variables

VARİABLES ARE SİMPLY A NAME FOR A BLOCK OF MEMORY CELLS İN MAİN MEMORY. IF A VALUE İS ASSİGNED TO A VARİABLE,
THAT VALUE MUST BE OF THE SAME TYPE AS THE VARİABLE, AND WİLL BE STORED İN THE MEMORY ADDRESS DESİGNATED BY
THE VARİABLE NAME. THE ASSİGNMENT STATEMENT İS THE SEMİCOLON-EQUAL :=.
VARİABLES MUST BE DECLARED AT THE BEGİNNİNG OF THE PROGRAM, A PROCEDURE, OR A FUNCTİON
VARİABLES MUST BE İNİTİALİZED BEFORE THEY CAN BE USED.
VARİABLES CAN BE REUSED AS OFTEN AS NECESSARY. THEİR OLD VALUE İS SİMPLY OVERWRİTTEN BY A NEW
ASSİGNMENT.
EXAMPLE:
PROGRAM Test;
VAR
x : REAL; { variable name is x, type is real
i : INTEGER: { variable name is i, type is integer
c : CHAR; { variable name is c, type is character
s : STRING; { variable name is s, type is string
BEGIN
x := -34.55; { valid real number assigned to variable x }
x := -3.9E-3; { valid real number assigned to variable x }
WRITELN(x); { x contains the value -3.9E-3 }
i := 10; { valid integer number assigned to variable i }
i := i * i; { valid (!) - i will be 100 now }
i := 9933; { valid integer number assigned to variable i }
i := -99999; { invalid integer - too small }
i := 999.44; { invalid assignment - types do not match }
c := '1'; { valid character assigned to variable c }
c := 1; { invalid assignment - types do not match }
c := 'Bert'; { invalid assignment - types do not match }
c := 'd'; { valid character assigned to variable c }
WRITELN(c); { c contains the value 'd' }
d := 'c'; { unknown variable - the variable d is not declared }
WRITELN(s); { invalid reference - s has undefined value }
END.

Formatted Input and Output

Reading Information
To read information from the keyboard, you can the command READLN, as in the following example:
PROGRAM Test;
VAR
x : REAL; { x is declared to be real }
i : INTEGER; { i is declared to be an integer }
c : CHAR; { c is declared to be a character }
BEGIN
READLN(x); { user can type a real number, followed by
the return key. The value will be stored
in the variable x. If the user input is
not a real (or integer) number, a
runtime error (invalid assignment) will
occur. }
READLN(i); { user can type a integer, followed by
the return key. The value will be stored
 in the variable i. If the user input is
not an integer, a runtime error (invalid
assignment) will occur. }
READLN(c); { user can type any character, followed by
the return key. The value will be stored in
the variable c and will be a character. If
a user enters 1, c will be the character '1'
not the integer 1. }
READLN; { user can type a single return. }
END.
The exact workings of the READLN command will be discussed later.

Writing Information
To write information on the screen, you can use the WRITE or WRITELN command. You can write the
content of variables or simple text. There are several variations:
WRİTİNG TEXT WRITE( WRİTES ANY TEXT ENCLOSED İN SİMPLE QUOTES ON THE SCREEN
'ANY
TEXT');
WRİTİNG WRITE( I İS AN İNTEGER VARİABLE
İNTEGERS I);
UNFORMATTED
WRİTİNG WRITE( I İS AN İNTEGER AND NUM İNDİCATES THE TOTAL POSİTİONS TO BE USED. IF THE
İNTEGERS
I:NUM); VALUE CONTAİNED İN THE VARİABLE I NEEDS MORE DİGİTS, NUM İS İGNORED.
FORMATTED
WRİTİNG REALS WRITEL X İS A REAL VARİABLE. WİLL ALWAYS WRİTE THE REAL NUMBER İN SCİENTİFİC
UNFORMATTED N(X); NOTATİON AND İS ALMOST NEVER WHAT YOU WANT.
WRİTİNG REALS WRITEL X İS A REAL VARİABLE, NUM1 İS THE TOTAL AMOUNT OF DİGİTS TO USE
FORMATTED N(X:NUM (İNCLUDİNG SİGN AND PERİOD) AND NUM2 İS THE NUMBER OF DİGİTS AFTER THE
1:NUM2) PERİOD.
;
NOTE: THE SAME RULES APPLY FOR THE COMMAND WRITELN BUT THİS COMMAND ALSO POSİTİONS THE CURSOR TO THE
FİRST POSİTİON OF THE NEXT LİNE.
YOU CAN COMBİNE WRİTTİNG TEXT AND MORE THAN ONE VARİABLE BY SEPERATİNG THE İNDİVİDUAL COMPONENTS BY A COMMA.
HERE İS AN EXAMPLE:
PROGRAM Test;
VAR
x : REAL;
i : INTEGER;
j : INTEGER;
BEGIN
x := 12.449;
i := 10;
j := -300;
WRITE('This is some text');
WRITELN('Unformatted integer ',i);
WRITELN('Unformatted integer computation ',i*i);
WRITELN('formatted integer',i:4);
WRITELN('formatted integer',j:4);
WRITELN('Unformatted real ',x);
WRITE('Formatted real');
WRITE(x:8:2);
WRITELN('all in one line');
END.
WHİCH WİLL PRODUCE THE FOLLOWİNG OUTPUT:
This is some textUnformatted integer 10
Unformatted integer computation 100
formatted integer 10
formatted integer-300
Unformatted real 1.24490000000E+01
Formatted real 12.45all in one line

Functions
FUNCTİONS PROVİDE A FLEXİBLE METHOD TO APPLY ONE FORMULA MANY TİMES TO POSSİBLY DİFFERENT VALUES. THEY ARE
COMPARABLE TO PROCEDURES BUT
FUNCTİONS ARE OF ALWAYS OF A CERTAİN TYPE

FUNCTİONS USUALLY HAVE ONE OR MORE İNPUT VARİABLE(S)

THE FUNCTİON NAME MUST APPEAR AT LEAST ONCE İNSİDE THE DEFİNİTİON

THE GENERAL FORM OF THE FUNCTİON STATEMENT LOOKS LİKE THİS:

FUNCTION FunctionName(VariableName: VariableType): VariableType;
BEGIN
some code, if necessary;
FunctionName := some computation;
more code if necessary;
END;
NOTE THAT EVERY FUNCTİON MUST CONTAİN THE FUNCTİON NAME AT LEAST TWİCE: ONCE İN THE DEFİNİTİON OF THE FUNCTİON,
AND ONCE TO ASSİGN THE RESULT OF A COMPUTATİON TO THE FUNCTİON. FUNCTİONS CAN BE USED SİMİLAR TO VARİABLES.
YOU CAN ASSİGN THE RESULT OF A FUNCTİON TO A NEW VARİABLE, YOU CAN PRİNT THE RESULT OF A FUNCTİON USİNG WRITE
OR WRITELN, OR YOU CAN USE THE RESULT OF A FUNCTİON İN ANOTHER COMPUTATİON OR TEST. HERE İS AN EXAMPLE:
PROGRAM Test;
VAR
radius: REAL;

FUNCTION CircleArea(r : REAL): REAL;

BEGIN
CircleArea := 3.1415 * r * r;
END;

BEGIN
WRITE('Area of circle with radius 2.0: ');
WRITELN(CircleArea(2.0):6:1);
WRITE('Area of circle with radius 5.0: ');
WRITELN(CircleArea(5.0):6:1);
WRITE('Enter your own radius: ');
READLN(radius);
WRITE('Area of circle with radius ', radius:3:1,': ');
WRITELN(CircleArea(radius)); { ugly - formatting missing for real }
radius := 5.0;
radius := CircleArea(radius);
WRITELN(radius); { can you guess the output ? }
END.

An extended example: Unit Conversion

BELOW İS A BASİC PASCAL PROGRAM. PLEASE LOOK VERY CAREFULLY AT İT; İT CAN BE USED AS A PROTOTYPE FOR MANY
OTHER PROGRAMS THAT YOU WİLL HAVE TO WRİTE.
PROGRAM THE BEGİNNİNG OF THE PROGRAM. NOTE THAT THE NAME OF THE PROGRAMMER AND THE
A_Basic_Pro DATE WHEN THE PROGRAM WAS FİNİSHED ARE PART OF THE COMMENTS. ALSO, A BRİEF
gram; DESCRİPTİON OF THE PROGRAM İS GİVEN.
{**********
***********
***********
********}
{*
Programmer:
Bert G.
Wachsmuth
*}
{* Date:
Sept. 28,
1995
*}
{*
*}
{* This
program
converts
degree
Celcius *}
{* to and
from degree
Fahrenheit.
The *}
{* user can
choose the
conversion
from *}
{* a menu.
*}
{**********
***********
***********
********}
VAR
UserChoi
ce : CHAR;
{ menu
choice }
UserInpu THE LİST OF VARİABLES. THERE ARE TWO REAL VARİABLES, ONE FOR THE USER'S İNPUT
t : REAL; NUMBER AND ONE FOR THE CONVERTED NUMBER. EVEN İF MORE CONVERSİON FORMULAS
{ number to ARE ADDED LATER, ONLY TWO VARİABLES ARE NEEDED.
convert}
Answer
: REAL;
{ converted
answer }
{********** THE MENU THAT THE USER WİLL SEE. NOTE THE BLANK LİNE PRODUCED BY THE
*********** WRITELN AT THE TOP AND BOTTOM, AS WELL AS THE SPACİNG İN FRONT TO MOVE THE
*********** TEXT TO THE MİDDLE OF THE SCREEN.
********}
PROCEDURE
ShowTheMenu
;
{ This
procedure
shows the
available
}
{ options
to the user
of the
program.
}
BEGIN
WRITEL
N;
WRITEL
N(' A
Basic
Program');
WRITEL
N('
-----------
----');
WRITEL
N(' a)
Celcius to
Fahrenheit'
);
WRITEL
N(' b)
Fahrenheit
to
Celcius');
WRITEL
N;
WRITEL
N(' x) To
exit the
program');
WRITEL
N;
END;
{********** THİS PROCEDURE ASKS THE USER FOR THEİR CHOİCE AND STORES THE RESULT İN THE
*********** VARİABLE USERCHOİCE. NOTE THAT BY USİNG WRITE İNSTEAD OF WRITELN THE
*********** USER'S İNPUT WİLL APPEAR İN THE SAME LİNE AS THE PROMPT. ALSO, THE EMPTY SPACE
********} AFTER THE PROMPT WİLL ALİGN THİS LETTER WİTH THE NEXT USER İNPUT.
PROCEDURE
GetUserChoi
ce;
{ This
procedure
asks the
user for
their }
{ choice
and stores
the result
in }
{
UserMenuCho
ice. }
BEGIN
WRITE('
Enter your
choice:
');
READLN(
UserChoice)
;
END;
{**********
***********
***********
********}
PROCEDURE
GetNumberTo
Convert;
{ Asks the
user for
the number THİS PROCEDURE ASKS FOR THE NUMBER TO CONVERT. AGAİN, USİNG WRITE İNSTEAD
to be } OF WRITELN WİLL MAKE THE USER'S NUMBER APPEAR İN THE SAME LİNE AS THE
{ converted PROMPT. THE NUMBER WİLL BE STORED İN THE VARİABLE USERINPUT
}
BEGIN
WRITE('E
nter number
to convert:
');
READLN(U
serInput);
END;
{**********
***********
***********
********}
PROCEDURE
Wait;
{ Holds
execution
until user
presses
A READLN WİTHOUT A VARİABLE WİLL WAİT UNTİL THE USER HİTS THE RETURN KEY.
}
{ RETURN THE KEYSTROKE İS NOT STORED İN ANY VARİABLE.
}
BEGIN
WRITE('
Press
RETURN to
continue
...');
READLN;
END;
{********** THİS FUNCTİONS CONVERTS İTS İNPUT X TO DEGREE FAHRENHEİT. THE RESULT OF THE
*********** COMPUTATİON CAN BE USED BY ANY OTHER PROCEDURE OR FUNCTİON, OR BY THE MAİN
*********** PROGRAM.
********}
FUNCTION
ToFahrenhei
t(x: REAL):
REAL;
{ Function
to convert
degrees
Celcius
to }
{ degree
Fahrenheit.
}
BEGIN
ToFahr
enheit :=
9/5 * x +
32;
END;
{**********
***********
***********
********}
FUNCTION
ToCelcius(x
: REAL):
REAL;
{ Function
to convert THİS FUNCTİONS CONVERTS İTS İNPUT X TO DEGREE CELCİUS. THE RESULT OF THE
degrees COMPUTATİON CAN BE USED BY ANY OTHER PROCEDURE OR FUNCTİON, OR BY THE MAİN
Fahrenheit PROGRAM.
}
{ to degree
Celcius.
}
BEGIN
ToCelc
ius := 5/9
* (x - 32);
END;
{********** THİS PROCEDURE SELECTS THE APPROPRİATE CONVERSİON FUNCTİON DEPENDİNG ON THE
*********** CONTENT OF THE VARİABLE USERCHOİCE. IN ANY CASE, THE RESULT OF THE CONVERSİON
*********** İS STORED İN THE VARİABLE ANSWER
********}
PROCEDURE
DoTheConver
sion;
{ This
procedure
converts
the number
}
{ contained
in
UserInput
to the
degree }
{ according
to the
user's menu
choice. }
BEGIN
IF
(UserChoice
= 'a') THEN
ans
wer :=
ToFahrenhei
t(UserInput
);
IF
(UserChoice
= 'b') THEN
ans
wer :=
ToCelcius(U
serInput);
END;
{********** THİS PROCEDURE DİSPLAYS THE ANSWER. IT İS PROBABLY THE SMARTEST PROCEDURE OF
*********** THE WHOLE PROGRAM. CAN YOU SEE EXACTLY WHAT İT DOES, AND WHY İT İS
*********** CONSİDERED A SMART PROCEDURE ?
********}
PROCEDURE
DisplayTheA
nswer;
{ This
procedure
displays
the answer
in }
{ a nice
numerical
format. It
switches
}
{ the title
of the
table
displaying
the }
{ answer
depending
on the
user's menu
}
{ choice.
}
BEGIN
WRITEL
N;
WRITEL
N('
Degree');
IF
(UserChoice
= 'a') THEN
WRI
TELN('Celci
us |
Fahrenheit'
);
IF
(UserChoice
= 'b') THEN
WRI
TELN('Fahre
nHeit |
Celcius');
WRITEL
N('--------
-----------
-----');
WRITE(
UserInput:8
:2);
WRITE(
' | ');
WRITE(
Answer:8:2)
;
WRITEL
N;
WRITEL
N;
END;
{**********
***********
***********
********}
BEGIN
UserChoi
ce := 'q';
WHILE
(UserChoice
<> 'x') DO
BEGIN
Sh
owTheMenu;
Ge
tUserChoice
; THE MAİN EXECUTİON BLOCK, OR MAİN PROGRAM. IT CONSİSTS OF A SİMPLE LOOP THAT
IF EXECUTES UNLESS THE VARİABLE USERCHOİCE CONTAİNS THE CHARACTER X. HOWEVER,
(UserChoice
THE USER İS ASKED FOR THE FİRST TİME İNSİDE THE LOOP, THUS THE VARİABLE
= 'a') OR
USERCHOİCE MUST BE İNİTİALİZED BY HAND BEFORE THE LOOP CAN START. IF A USER
ENTERS X THEN MANY PROCEDURES ARE NOT NEEDED AND ARE THEREFORE BLOCKED
(UserChoice
= 'b') THEN IF STATEMENT. NOTE THAT THE IF STATEMENT USES THE LOGİCAL
İNSİDE THE
OPERATOROR. WHY DİD WE NOT USE THE APPEARENTLY EASİER FORM IF
BEGIN (USERCHOİCE <> 'X') THEN ?

GetNumberTo
Convert;

DoTheConver
sion;

DisplayTheA
nswer;

Wait;

END;
END;
END.
(bgw)