Program Structure
The basic structure of a Pascal program is:
PROGRAM ProgramName (FileList);
CONST
(* Constant declarations *)
TYPE
(* Type declarations *)
VAR
(* Variable declarations *)
(* Subprogram definitions *)
BEGIN
(* Executable statements *)
END.
Program Structure
The elements of a program must be in the
correct order, though some may be
omitted if not needed.
Here's a program that does nothing, but
has all the required elements:
program DoNothing;
begin
end.
Comments are portions of the code which
do not compile or execute. Pascal
comments start with a (* and end with a
*).
Identifiers
Identifiers are names that allow us to
reference stored values, such as variables and
constants. Also, every program and unit must
be named by an identifier.
Rules for identifiers:
Must begin with a letter from the English alphabet.
Can be followed by alphanumeric characters
(alphabetic characters and numerals) and possibly
the underscore (_).
May not contain certain special characters, many of
which have special meanings in Pascal.
~!@#$%^&*()+`-={}[]:";'<>?,./|
Identifiers
Several identifiers are reserved in Pascal
as syntactical elements. We are not
allowed to use these for our identifiers.
These include but are not limited to:
and array begin case const div do downto
else end file for forward function goto if in
label mod nil not of or packed procedure
program record repeat set then to type until
var while with
Constants
Constants are referenced by identifiers,
and can be assigned one value at the
beginning of the program. The value
stored in a constant cannot be changed.
Constants are defined in the constant
section of the program:
const
Identifier1 = value;
Identifier2 = value;
Identifier3 = value;
Constants
For example, let's define some
constants of various data types: strings,
characters, integers, reals, and
Booleans.
const
Name = 'Tao Yue';
FirstLetter = 'a';
Year = 1997;
pi = 3.1415926535897932;
UsingNCSAMosaic = TRUE;
Constants
Constants are useful for defining a value
which is used throughout our program
but may change in the future.
Typed constants force a constant to be of
a particular data type. For example,
const
a : real = 12;
would yield an identifier which contains a real
value 12.0 instead of the integer value 12.
Variables and Data Types
Variables are similar to constants, but their values can
be changed as the program runs. Variables must first be
declared in Pascal before they can be used:
var
IdentifierList1 : DataType1;
IdentifierList2 : DataType2;
IdentifierList3 : DataType3;
IdentifierList is a series of identifiers, separated by
commas (,). All identifiers in the list are declared as
being of the same data type.
The basic data types in Pascal include:
integer
real
char
Boolean
Variables and Data Types
The integer data type can contain integers from
-32768 to 32767.
The real data type has a range from 3.4x10 -38 to
3.4x1038, in addition to the same range on the
negative side. In Pascal, we can express real
values in our code in either fixed-point notation or
in scientific notation, with the character e
separating the mantissa from the exponent. Thus,
452.13 is the same as 4.5213e 2
The char data type holds characters. Be sure to
enclose them in single quotes, like so: 'a' 'B' '+'.
The Boolean data type can have only two values:
TRUE and FALSE
Variables and Data Types
An example of declaring several
variables is:
var
age, year, grade: integer;
circumference: real;
LetterGrade: char;
DidYouFail: Boolean;
Assignment and Operation
s
Once we have declared a variable, we can
store values in it. This is called assignment.
To assign a value to a variable, follow this
syntax:
The expression can either be a single value:
variable_name := expression;
some_real := 385.385837;
or it can be an arithmetic sequence:
some_real := 37573.5 * 37593 + 385.8/367.1;
Assignment and Operation
s
The arithmetic operators in Pascal are:
Operator
Operation
Operands
Result
Addition or unary positive
real or integer
real or integer
Subtraction or unary negative
real or integer
real or integer
Multiplication
real or integer
real or integer
Real division
real or integer
real
div
Integer division
integer
integer
mod
Modulus (remainder division)
integer
integer
When mixing integers and reals, the result will always be a real.
Each variable can only be assigned a value that is of the same data
Assignment and Operation
s
Typecasting: changing one data type to
another.
Variable declaration section:
var
some_int : integer;
some_real : real;
When the following block of statements
executes,
some_int := 375;
some_real := some_int;
some_real will have a value of 375.0.
Standard Functions
Pascal has several standard
mathematical functions.
For example:
value := sin (3.1415926535897932);
The sin function operates on
angular measure stated in radians.
Standard Functions
Functions are called by using the function
name followed by the argument(s) in
parentheses. Standard Pascal functions:
Function
Description
Argument type
Return type
abs
absolute value
real or integer
same as argument
arctan
arctan in radians
real or integer
real
cos
cosine of a radian measure
real or integer
real
exp
e to the given power
real or integer
real
ln
natural logarithm
real or integer
real
round
round to nearest integer
real
integer
sin
sin of a radian measure
real or integer
real
sqr
square (power 2)
real or integer
same as argument
sqrt
square root (power 1/2)
real or integer
real
trunc
truncate (round down)
real or integer
integer
Punctuation and
Indentation
Since Pascal ignores end-of-lines and spaces,
punctuation is needed to tell the compiler when
a statement ends.
We must have a semicolon (;) following:
the program heading
each constant definition
each variable declaration
each type definition
almost all statements
The last statement in a BEGIN-END block, the
one immediately preceding the END, does not
require a semicolon. However, it's harmless to
add one.
Punctuation and
Indentation
Indenting is not required. However, it is of great use for the
programmer, since it helps to make the program clearer.
If we wanted to, we could have a program look like this:
program Stupid; const a=5; b=385.3; var alpha,beta:real; begin
alpha := a + b; beta:= b/a end.
But it's much better for it to look like this:
program NotAsStupid;
const
a = 5;
b = 385.3;
var
alpha,
beta : real;
begin (* main *)
alpha := a + b;
beta := b / a
end. (* main *)
Input
Input is what comes into the program. It can be
from the keyboard, the mouse, a file on disk, a
scanner, a joystick, etc.
The basic format for reading in data is:
read (Variable_List);
readln (Variable_List);
Variable_List is a series of variable identifiers
separated by commas.
read treats input as a stream of characters, with
lines separated by a special end-of-line character
readln will skip to the next line after reading a
value, by automatically moving past the next
end-of-line character.
Output
For writing data to the screen:
write (Argument_List);
writeln (Argument_List);
writeln skips to the next line when done.
We can use strings in the argument list,
either constants or literal values. If we
want to display an apostrophe within a
string, use two consecutive apostrophes.
Formatting output
For each identifier or literal value on the
argument list, use:
Value : field_width
The output is right-justified in a field of
the specified integer width. If the width
is not long enough for the data, the
width specification will be ignored and
the data will be displayed in its entirety
(except for real values).
Formatting output
Suppose we had:
The output
write ('Hi':10, 5:4, 5673:2);
_ _ _ _ _ _ _ _Hi_ _ _55673
For real values, we can use the
aforementioned syntax to display
scientific notation in a specified field
width, or we can convert to fixed
decimal-point notation with:
Value : field_width : decimal_field_width
