Pascal Midterm 2 Review
Chapter 7 - Procedures
When to use procedures – if it makes the overall program easier to understand.
Order of Declarations
Constant declarations
Variable declarations
Procedure and/or function declarations
Main part
A Simple Pascal Program with added procedure
PROGRAM SimpleWithProcedure(INPUT, OUTPUT);
CONST
MyCount = 3;
VAR a, b, c : INTEGER;
d : REAL;
PROCEDURE multiply(VAR b:INTEGER; a: INTEGER);
BEGIN
b := a * MyCount;

b=3*3 = 9
END;
BEGIN
a := MyCount;
multiply(b,a); (* calling multiply procedure*)
c := b div 3;

c = 9 div 3 = 3
d := (b + a)/ 5;

d = (3+9)/5 = 12/5=2.4
END.
A Simple Pascal Program with added procedure(formal and actual parameters)
PROGRAM SimpleWithProcedure(INPUT, OUTPUT);
CONST
MyCount = 3;
VAR a, b, c , I , j: INTEGER;
d : REAL;
(*declaring procedure with formal parameters x and y*)
PROCEDURE multiply(VAR x:INTEGER; y: INTEGER);
BEGIN
x := y * MyCount;
END;
BEGIN
a := MyCount;
j := MyCount+5;
multiply(b,a); (* calling multiply procedure with actual parameters a and b*) 
multiply(I,j); (* calling multiply procedure with actual parameters I and j*) 
c := b div 2;
d := (b + a)/ 2;
END.


c := 16 divided by 2:= 8
d := (16+2)/ 9.0
b = 3*3 = 9
I = (3+5) * 4 = 32
A Simple Pascal Program with added procedure(Local Variables )
PROGRAM SimpleWithProcedure(INPUT, OUTPUT);
CONST
MyCount = 3;
VAR a, b, c , I , j: INTEGER;
d : REAL;
(*declaring procedure with formal parameters x and y*)
(*procedure multiply gets the address of the first variable
and a copy of the value of the second variable*)
PROCEDURE multiply(x:INTEGER; VAR y: INTEGER);
(* z is local variable*)
VAR z: INTEGER;
BEGIN
y:=0;
FOR z := 1 TO x DO (* for z = 1 to 3 x is b *)
y := y + z * MyCount;
END;
BEGIN
a := MyCount;
b:=0;
i := MyCount+5;
j:=0;
multiply(a,b); (* calling procedure multiply with actual parameters a and b*)
multiply(I,j); (* calling procedure multiply with actual parameters I and j *)
writeln(‘ value of b= ‘ ,b);
writeln(,value of I = ‘ , I);
END.
Befor calling procedure multiply with a and b
a= 3 b is undefined
calling procedure multiply with a and b
actual parameters a and b are represented in the procedure as x and y so:
x=3 y=0
When for loop is executed
z=1
 y = y+ z * MyCount  y = 0 + 1 * 3 = 3
z=2
 y = y+ z * MyCount  y = 3 + 2 * 3 = 9
z=3
 y = y+ z * MyCount  y = 9 + 3 * 3 = 18
after calling procedure multiply with parameters a and be a is not changed and b = 18
In main program the statement writeln(‘ value of b= ‘ ,b); displays value of b = 18
Befor calling procedure multiply with i and j
i= MyCount + 5  3+5 = 8 j is undefined
calling procedure multiply with i and j
actual parameters i and j are represented in the procedure as x and y so:
x=5 y=0
When for loop is executed
z=1
 y = y+ z * MyCount  y = 0 + 1 * 3 = 3
z=2
 y = y+ z * MyCount  y = 3 + 2 * 3 = 9
z=3
 y = y+ z * MyCount  y = 9 + 3 * 3 = 18
z=4
 y = y+ z * MyCount  y= 18+ 4*3 = 30
z=5
 y = y+ z * MyCount  y = 30 + 5*3 = 45
after calling procedure multiply with parameters a and be a is not changed and b = 18
In main program the statement writeln(‘ value of j= ‘ ,j); displays value of j = 45
Chapter 8 –Nesting
Scope Rules
Begin (*Main part of the program*)
End
Procedure A can only be called in main program.
Procedure B can be called in procedure C and A but not in the main program.
Procedure C can only be called in procedure A
main module - Items Visible: Char1, procedure One and Three
Procedure one- Items Visible: char2, two,
Procedure two – Items visible: char3, char2, char1
Procedure three- Items Visible: char1, One, char4
Functions
Functions – Functions are very similar to procedures. The Difference is that functions are employed when the
result is a single value that is used directly in an expression. For example, ISVALID() is a typical function.
FUNCTION identifier parameter-list : type;
Program Exaple(input, output)
Var area: double;
Max : integer;
FUNCTION CircleArea(radius: DOUBLE): DOUBLE;
VAR area: DOUBLE;
BEGIN
area := PI * radius * radius;
CircleArea:= area;
END;
FUNCTION Highest(v1, v2, v3: INTEGER): INTEGER;
begin
if (v1 > v2) and (v1 > v3) then
begin
result := v1;
end
else if v2 > v3 then
begin
result := v2;
end
else
begin
result := v3;
end;
Highest:=result;
end;
BEGIN (*main program*)
area := CircleArea(10.0);
maxBy2 := Highest(10, 3, 18) * 2;
END.
The function name IS NOT a variable add the assigned parameters.
Do not use a function if more than one value is returned .
Do not use var for parameters.
Do not use if inputting or outputting a value.
Use if only one value is returned
Precision
Real numbers
example
Precision: numbers after
.
5.4321  precision =4
sign digits.digits
-34.67
Sign digits.digits E sign digits 4,321.768  4.321768×103 normalized scientfic notation 4.32176 E 3
In normalized scientific notation
least one but less than ten (1 ≤ |a| < 10).
the exponent b is chosen so that the absolute value of a remains at
Standard decimal notation Normalized scientific notation Scientific E notation
2
2×100
2E 0
300
3×102
3E2
4,321.768
4.321768×103
4.32176 E 3
−53,000
−5.3×104
-5.3 E 4
6,720,000,000
6.72×109
6.72 E 9
0.2
2×10−1
2 E -1
0.000 000 007 51
7.51×10−9
7.51 E -9
Significant digits:
number of digits regardless of the whole value
Formatting real numbers:
Actual number
without formatting
x = 4321.768
4.32176 E 3
with proper formatting variable: space used: precision
x:8:3  4321.768
x:10:4  □□4321.7680
x:8:2  □ 4321.77
Simple Data Types
Data Types – A data type is a formal description of the values that a can be stored in a constant or variable of that
type and the operations that can be applied to these values.




integer
real
char
boolean
Ord, Pred, and Succ Functions
predefined Pascal functions that take a parameter and return a value.
Great example in naming formal and actual parameters differently.
ORD – takes an ordinal value and returns an Integer representing the value’s place in the ordering of the data
Examples: Integer returns integer ord(23)  23
Boolean returns 0 or 1. Ord (true)  1 ord false  0
Character returns the ascii value ord(‘A’)  66
PRED Pred – takes an ordinal value and returns the value’s predecessor (with ascii value decreased by one).
Example: PRED(‘A’)  ‘@’
PRED(‘Z’)  ‘Y’
SUCC – takes an ordinal value and returns the value’s successor( with asscii value increased by one).
Example: SUCC(‘A’)  ‘B’
SUCC (‘Z’)  ‘[‘
ascii value for ‘Z’ is 90 and for ‘[‘ is 91
CHR - Chr is the inverse of the Ord operation. It takes an integer value and returns corresponding character
representation.
Example: CHR(65)  ‘A’
CHR(ord(‘A’) + 3)  CHR (65 + 3)  CHR (68)  ‘D’
type.
Control Structures
CASE Statement -- Example:
program Grades;
var
grade: char;
begin
writeln(‘Enter Grade’);
read(grade);
CASE grade OF
'A' : writeln('Excellent!' );
'B','C': writeln('Well done' );
'D' : writeln('You passed' );
'F' : writeln('Try again' );
Look at the valiable grade
if it is = ‘A’ then writeln(‘Excellent!!’)
if it is = ‘B’ or ‘C’ then writeln(‘Well done’)
if it is = ‘D’ then writeln(‘you passed’)
if it is = ‘F’ then writeln(‘Try again’)
ELSE WRITELN(‘Letter grades should be ‘A’ to ‘F’);
END; Must to use keyword ‘end’ to complete the case statement.
LOOPs
REPEAT Statement :
REPEAT Do it at least one time
statement;
Example
REPEAT
sum := sum + number;
number := number - 1;
UNTIL number = 0;question asked
statement;
if the answer is true stop
UNTIL Boolean expression ask a question if the answer is false go back up to the keyword REPEAT
For loop
Example:
FOR variable:= initial_value TO final_value DO
BEGIN
statement;
END;
FOR i:= 1 TO 10 DO
BEGIN
writeln(i);
END;
Example:
FOR variable:= initial_value DOWN TO final_value DO
Begin
statement;
end;
While loop
WHILE I < 10 DO
BEGIN
WRITELN(I);
I := I +1;
END
FOR i:= 10 DOWN TO 1 DO
Begin
writeln(i);
end;
User-Defined Ordinal Data Types
program StudentMarksSystem;
CONST
NumStudents = 30;
TYPE
Range = 1.. NumStudents;
IntegerArray = array [Range] of Integer;
VAR
Class1Agrads : IntegerArray;
Class1Bgrades : IntegerArray;
Grade, ndx:INTEGER;
PROCEDURE enterGrades(StudentArray : IntegerArray)
BEGIN
FOR ndx := 1 TO NumStudents DO
BEGIN
Read (grade);
StudentArray [ndex] := grade;
END;
END; (*of enter grade procedure *)
BEGIN(*main program*)
enterGrade(MarksForClass1A);
enterGrade(MarksForClass1B);
END.(*end of main program*)
Composite Data types: Files and Arrays
Why Arrays:
Readln(inputData, value1);
Readln(inputData, value1);
Readln(inputData, value1);
.
.
Readln(inputData, value1000);
Writeln(value1000);
Writeln(value999);
Writeln(value998);
.
.
Writeln(value1);
For I :=1 to 1000 do
begin
Readln(inputData, dataAry[i];
Writeln(dataAry[i]);
End;
One-Dimensional Arrays
Defining Arrays:
<arrayName> : ARRAY[n..m] OF <Data Type>;
Example:
intArray : ARRAY[1..20] OF INTEGER;
charArray: ARRAY[1..20] OF CHAR;
Using for loops with arrays
Sum = 0;
FOR i:=1 TO 20 DO
BEGIN
sum:= sum + intArray[i];
END
(*different ways to see the value of an array location or use it *)
charArray[5] = ‘A’
WRITHELN(charArray[10]);
Passing arrays, always by reference
PROGRAM arrayToFunction;
CONST
size = 5;
TYPE
a = ARRAY [1..size] OF INTEGER;
VAR
balance: a;
PROCEDURE calSum( VAR arr: a);
VAR
i , sum: INTEGER;
BEGIn
sum := 0;
FOR i := 1 TO size DO
sum := sum + arr[i];
WRITELN(sum);
END;
BEGIN (* main body of program*)
WRITELN(‘calculating sum of numbers in balance array’);
(* Passing the array to the procedure *)
calSum(balance);
END.
Batch Input/Output
We need to use files to enter massive data and save the massive results.
To use files for reading and writing first we put the name of the files in the program header.
Program something(infile, outfile);
Then we declare then in var section
Var infile, outfile:TEXT
Then we open the files for reading and writing in the beginning of the program
Reset (infile);
for reading
Rewrite(outfile); for writing.
To read from a file:
Read(infile, data);
To write to a file:
Write(outfile, data);