BASIC TUTORIAL ON VISUAL BASIC

Tutorial: Programming in Visual Basic 6.0
This tutorial contains a beginner’s guide to Visual Basic 6.0, introducing the programming
environment, defining key terms and introducing exercises to demonstrate the five
control structures (sequence, selection: binary and multiway, iteration: pre and post
test).
Syllabus outcome
H5.3 A student selects and applies appropriate software to facilitate the design and
development of software solutions
Students learn to implement a fully tested and documented software solution in a
methodical manner. (SDD syllabus, p.51)
The following headings may help you navigate:

Activity 1: Welcome screen and menu editor

Activity 2: Event handlers and scroll bars

Naming conventions

Data types, variables and functions

Activity 3: Messages and input boxes

Activity 4: Create a calculator and avoid division by zero

Sequence

Binary Selection

Activity 5: Measurement converter

Multiway selection

Activity 6: Multiway selection

Activity 7: Control arrays

Iterations

Activity 8: Pre-test loops

Activity 9: Post-test loops

Activity 10: Random number generator

Activity 11: Using a counter in a pre-test loop

Activity 12: Nested FOR loops and arrays
Organising your first project
The first step is to create a project template within VB, to organise and store your work.
This will consist of a menu structure with headings that will let you access the many
exercises and examples you complete.
Activity 1
·  Open VisualBasic 6.0
·  Use the file menu to open a new project with a blank form.
·  Use the properties window to set
– Main.frm as the form name.
– My programs as the caption.
– BackColor to White.
– BorderStyle to Fixed Single.
– WindowState to Maximised.
·  Find the Menu icon and click on it to select it. Enter the following menu headings:
Quit
Introduction with indented subheadings of
Example1
Example2
Click OK after each menu caption and name are typed.
·  Click on Quit menu heading and enter the following code. This procedure is used to
exit from running the project display and return to the design screens.
Private Sub Quit_Click()
Unload me
End
End Sub
·  Use the <F5> function key to run the application to verify that the Menu structure is
correct and that the Quit procedure is free from error.
·  Use the File menu to save your work as Main.frm and (your intitials)Project1.vbp
·  Use the file menu to open a new blank form (or the properties window)
·  Set the following form properties:
form name as Welcome
caption to Example1
BackColor to White
BorderStyle to Fixed Single
WindowState to Maximised
·  Click on the Example 1 main menu heading and enter the following code:
Private Sub Example1_Click()
Welcome.Show
End Sub
·  Save your work and run <F5> to ensure that it is free of errors.
·  Add two labels, an image and a command button to create a welcome screen. To do
this
Select label icon from the toolbox. Click towards the centre-top of your form and
position and resize your label as required.
With the label selected, use the properties window to
Change the caption to WELCOME TO VISUAL BASIC
Choose a bright back colour
Set the font (Arial, underline, alignment centred, size 24 point, forecolour blue)
Repeat to add the Enjoy label.
Use the image icon on your toolbox to add the image to your form. Use the
properties window of the image to select a picture.
Use the command Button icon to add the button. Change its caption to RETURN.
Then double-click the button and add the following line of code after the
Command1_Click() procedure.
– Unload Welcome
·  Use the file menu to save your work and use <F5> to run the application.
·  DON’T FORGET TO SAVE (AND BACK UP TO FLOPPY) ALL YOUR WORK.
Event handlers and scroll bars
Some definitions to learn
·  An object is a thing — anything that appears on the screen. An object has a set of
properties. Each property of the object has a value.
e.g. Label.Caption = “Welcome to Visual Basic” where
Label is an object
Caption is a property of label
“Welcome to Visual Basic” is a value of the Caption property.
·  Events are things that happen on the screen. Event handlers transfer data to
procedures that complete the task. The results of these procedures are returned
back to other screen objects, e.g. onChange onClick
·  A procedure is a group of statements designed to perform a specific task. A
procedure attached to an object, such as a button, is a command used to make
something happen, e.g.
Public Sub Command2_Click()
Text1.Text = “This is a procedure.”
End Sub
Add new form to menu
As each new example and exercise solution is to be added to your project you will need
to:
·  add a new form
·  set the form properties using the properties window
·  click on the main menu icon with the main form displayed to show the menu
designer
·  add a new menu heading
·  click on the menu heading to show the procedure code
·  to the procedure code, add the statement
FormXX.Show
where FormXX is the new form name.
Activity 2
1. Open a new form and change its name to ColourChanger. Place the following objects
on this form.
 A heading label2 (Caption = Colour Changer)
 3 horizontal scroll bars (Set the max value property of all three to 255)
 3 other labels (2red, 3Green, 4Blue)
 a command button to quit the form (Caption = Return)
 another small label5 under the button with its visible property set to false.
2. Double click each scroll bar and add the following code to its _onChange() event. Use
cut and paste to make the task easier.
Label1.BackColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value)
Label5.BackColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value)
Label1.ForeColor = RGB(255 - HScroll1.Value, 255 - HScroll2.Value, 255 -
HScroll3.Value)
Label5.ForeColor = RGB(255 - HScroll1.Value, 255 - HScroll2.Value, 255 -
HScroll3.Value)
Label5.Visible = True
Label5.Caption = “WOW!”
Label2.BackColor = RGB(HScroll1.Value, 0, 0)
Label3.BackColor = RGB(0, HScroll2.Value, 0)
Label4.BackColor = RGB)0, 0, HScroll3.Value)
3. Double click the return button and add the following code to its _onClick() event
Unload Me
4. Use the Project Explorer window to return to your main form and double click
example 2 in your menu to add the appropriate code.
5. Use <F5> function key to test your project. Save and backup.
Naming conventions
Up till now, we have often accepted default names, Text1, Label1, etc. In a big project,
this is not good practice as it makes the code harder to read or maintain. Naming
conventions use a prefix of three lowerCase letters to identify the type of control,
followed by a meaningful name. eg. lblTitle
Prefix Abbreviations for Control names
Prefix Control Prefix Control
cbo combo box chk check box
cmd command button dir directory list box
drv drive list box fil file list box
fil file list box fra frame
frm form grd grid
hsb horizontal scrollbar img image
lbl label lin line
lst list box mnu menu
ole OLE client opt option button
pic picture box shp shape
tmr timer txt text box
vsb vertical scrollbar
Data types in VB
A variable is a named location that holds data. A variable can only hold one datatype.
A program can have as many variables as you need but before you can use a variable it
must be declared.
You use a DIM statement to declare variables (where DIM stands for dimension). Here is
the format of the DIM statement:
Dim VarName As Datatype
e.g. Dim curCost As Currency, Dim strSurname As String
Datatype Description and Range Prefix
Boolean One of two values only. e.g. True or False e.g. blnIsOverTime bln
Byte Positive numeric values without decimals from 0-256 e.g.
bytAge
byt
Currency Data that holds dollar amounts from
-$922,337,203,685,477.5808 to +-
$922,337,203,685,477.5807 e.g. curHourlyPay
cur
Date Date and time values from Jan 1, 100 to Dec 31, 9999 e.g.
dteFirstLesson
dte
Double Numeric values from –1.79769313486232E+308 to
+1.79769313486232E+308. Often called double-precision.
e.g. dblMicroMeasurement
dbl
Integer Numeric values with no decimal point or fraction from –
32,768 to 32,767 e.g. intCount
int
Long Integer values beyond the range of Integer datatype from lng
–2,147,483,648 to 2,147,483,647 e.g. lngStarDistance
Object A special datatype that holds and references objects such as
controls or forms. e.g. objSoundClip
obj
Single Numeric values that range from –3,402823E+38 to
3,402823E+38. Often called single-precision.
sngYearSalesFigures
sng
String Data that consists of 0 to 65,400 characters of alphanumeric
data including special characters such as @, ^, ½ e.g.
strFirstName
str
Variant Data of any datatype used for control and other values for
which the datatype is unknown. e.g. vntControlValue
vnt or
var
A function is a segment of code that accepts zero, one or more arguments and returns a
single result. Visual Basic includes many built-in functions (intrinsic functions). Some
perform basic mathematical tasks. Others manipulate string data such as converting text
to upperCase or lowerCase letters.
An argument is a value you pass to a function so the function has data to work with.
Function names have parentheses at the end to hold the function arguments. Even if a
function has no arguments, the parenthesis are required.
Two intrinsic functions include message boxes and input boxes.
Activity 3: Message and input boxes
Message and input boxes are intrinsic functions in Visual Basic 6.0 which allow the end
user to interact with the program.
Follow the instructions Add new form to menu at the end of Activity 1 to create a new
form with a menu heading on the main form. Call this “Message and Input Boxes”
·  Make the Form.Caption = “Message and Input Boxes”
·  Put a label on the top of the form “Computer Conversation”. Underneath have a
command button with the caption “Talk to me!” Name the command button cmdTalk.
·  Double click the command button to add the following code sequence.
Private Sub cmdTalk_Click()
Dim strQuestion As String
Dim intAnswer As Integer
‘First you must declare your variables’
‘Then use the input and message box functions’
strQuestion = InputBox(“Type in your name!”, “Ebeneezer”)
intAnswer = MsgBox(“Hello there” & strQuestion, vbOKCancel, “Chat”)
End Sub
·  Add a return button, called cmdBack as you did in the ColourChanger, using the code
Private Sub cmdBack_Click()
Form1.Show
End Sub
·  Run your program using <F5>. Don’t forget to save your work.
Here are some handy literals (values that don’t change). You don’t have to learn them
as the help prompt supplies a drop down list as you start to type.
Buttons in Message Boxes
Named Literal Value Description
vbOKOnly 0 Displays the OK button
vbOKCancel 1 Displays the OK button and Cancel buttons
vbAbortRetryIgnore 2 Displays the Abort, Retry and Ignore buttons.
vbYesNoCancel 3 Displays the Yes, No and Cancel buttons.
vbYesNo 4 Displays the Yes and No buttons.
vbRetryCancel 5 Displays the Retry and Cancel buttons.
Icons in Message Boxes
Named literal Value Description
vbCritical 16 Displays Critical Message icon
vbQuestion 32 Displays Warning Query icon.
vbExclamation 48 Displays Warning Message icon.
vbInformation 64 Displays Information message icon.
vbSystemModal 4096 Displays a System Modal dialog box. The user must
acknowledge this box before doing anything else.
Remarks are added in code to explain the purpose of a section of code or to add
information for code maintenance. If Rem or ‘ is placed in front of the remark, that line
of code is ignored completely.
Activity 4
Create a calculator that can add, subtract, multiply and divide two numbers given by the
user.
[A possible solution might use two input boxes (txtOne and txtTwo) and a label to display
the answer (lblAnswer).
Declare variables:
dblNo1 As Double
dblNo2 As Double
dblAnswer As Double
intError As Integer
Use Val function to change string from input box to a number, then an assignment
statement to put that value into the variable.
dblNo1 = Val (txtOne.text)
Repeat for second number.
Use a Format function to ensure answer is rounded off to two decimal places.
lblAnswer.Caption = Format (dblAnswer, “#,##0.00”)
If you are very clever, this might be an option for the user.
Ensure that it is not possible to divide by zero, either by entering nothing or by entering
zero. Use the MsgBox() function to indicate the problem to the user.
If Val (txtTwo.Text) = 0 Then
IntError = MsgBox (“You cannot divide by 0!”, VbOkCancel, “Whoops!)
Else …
End If
Add a clear command button with the following code to allow the user to do another
calculation.
txtOne.Text = “”
txtTwo.Text = “”
lblAnswer.Caption = “”
txtOne.SetFocus
The SetFocus method returns the cursor to the first input box.
Set properties to pretty it up.
Check that it works. Use integers, very big numbers, very small numbers, negative
numbers, zeros, etc. Is your label big enough for all values? If you set the label’s
autosize property to true it will stretch to fit.
Add a remark (put ‘ at the beginning of the line) at the top of your code which includes
your name and the date.
Connect to a Binary Selection menu heading on the main form.
Sequence algorithms
The programs in Activities 1 — 3 were all constructed from sequence algorithm
constructs. Each line of code followed another with only one possible pathway for each
event. So, for each sub procedure, the algorithm would consist of input, output and a
series of process steps, e.g.
Private Sub cmdClear_Click() `user input
txtOne.Text = “”
txtTwo.Text = “”
lblAnswer.Caption = “”
txtOne.SetFocus
`sequence of processes initializing variables
End Sub `output
Binary selection
The next group of programs you will write uses the second algorithm construct —
selection. Selection allows multiple pathways for any event and allows for choices to be
made. Selection constructs can be Binary (two way) or Multiway (multiple choices)
Binary selection uses the If – End If or the If – Else – End If statements. Here
is the syntax in Visual Basic.
If comparison test Then
One or more Visual Basic statements
End If
OR
If comparison test Then
One or more Visual Basic statements
Else
One or more Visual Basic Statements
End If
(You have used binary selection in your calculator to prevent a user dividing by zero.)
Activity 5
·  Add a new menu heading Selections with two subheadings, Binary Selection and
Multiway Selection.
·  Write a program to convert inches to centimetres OR centimetres to inches (using the
conversion 1 inch = 2.54 centimetres).
·  Use option buttons (from the toolbox) for the user to indicate whether the conversion
is inches to centimetres or centimetres to inches.
·  Use IF statements to determine which formula to use based on which option button is
selected. Option buttons are mutually exclusive, i.e. only one can be selected at a
time.
·  Connect to menu heading Binary Selection.
·  Run the application to ensure that it is working correctly.
·  Use your calculator to verify the results. Try it out with some test data including
very large numbers, very small numbers, zero, negative numbers, 0.000000987654.
Multiway selection
In Activity 5 we looked at an example of binary selection. If the selection involves more
than two alternatives, you can use nested If statements but this becomes complicated
and leads to hard-to-read code. It is better to use Case statements. Here is the syntax
for multiple selection through Case statements.
Select Case Expression
Case value
[One or more VB statements]
Case value
[One or more VB statements]
Case value
[One or more VB statements]
Case Else
[One or more VB statements]
End Select
For example:
Select Case intAge
Is your measurement in Inches
or Centimetres 
Enter the measurement
The measurement in centimetres is 2.54 cms.
1 Convert it!
Case Is < 6
lblTitle.Caption = “Preschool”
Case 6 To 11
lblTitle.Caption = “Primary School”
Case 12 To 18
lblTitle.Caption = “Secondary School”
Case Else
lblTitle.Caption = “Adult”
End Select
Activity 6
1. The post office has the following charges for parcels based upon different weights.
Weight (gram) Cost
0 – 50 $1.40
51 – 100 $2.70
101 – 250 $4.00
251 – 500 $7.50
Parcels which are heavier than 500 gms are calculated by weight*0.02
Design a project that allows a user to enter the weight in a text box and calculate the
postage. Use Case statements in your code. Link this as CaseWeights under the
Multiway menu heading in your main form.
2. Use a set of check boxes to allow a user to choose the noise level by the comments,
then output the probable decibel level based on information in the following table.
Decibel level Comfort level
140+ Extremely painful
90 – 139 Deafening
60 – 89 Disturbing
30 – 59 Distracting
0 – 29 Relaxing
Again use Case statements and link this to the main form menu under the name
NoiseLevels again connected to the Multiway menu heading.
Activity 7
A control array is a set of multiple controls of the same type with the same name (often
created by using the Copy and Paste command). You may have encountered this already
in adding radio buttons or check boxes to your form. Individual controls within the array
are distinguished by having different Index property values. So, if you created a control
array of option buttons called optChoice, the Click event procedure might look like this:
Private Sub optChoice_Click (Index As Integer)
Select Case optChoice (Index)
Case Index = 0 Label1.Caption = "Monday"
Case Index = 1 Label1.Caption = "Tuesday"
Case Index = 2 Label1.Caption = "Wednesday"
Case Index = 3 Label1.Caption = "Thursday"
Case Index = 4 Label1.Caption = "Friday"
Case Index = 5 Label1.Caption = "Saturday"
Case Else Label1.Caption = "Sunday"
End Select
End Sub
The code above would change the label caption as each different option button was
selected. Try this out, then add code to change the label background colour (to
something appropriate) for each different day. Link to the menu Multiway Selection
heading in the main form menu under the heading Colour My Days.
Before we continue with the last structures — iterations — check that the menu
headings on Main are all correct and linked (by code) to the correct forms. Check the list
below and change any that need to be changed.
Menu
Quit
Introduction (Sequences)
Example 1 (– Welcome to VB)
Example 2 (– Colour changer)
from Activity 1
from Activity 2
Message and Input boxes
Sequence (– Computer Conversation) from Activity 3
Selection
Binary (- The calculator)
Binary (- Measurement Converter)
Multiway (- Parcel weights)
Multiway (- Noise levels)
Multiway (-Colour my days)
from Activity 4
from Activity 5
from Activity 6
from Activity 6
from Activity 7
Iteration
Iterations
Iterations or loops are structures that allow a statement or group of statements to be
carried out repeatedly while some condition remains true (or for a counted number of
times). Each iteration MUST contain a way of stopping the looping. There are 2
basic iteration structures:
·  Pre-test iterations: in these loops, the condition to be met occurs at the beginning
of the loop and the code will not run at all if the condition
is never met.
·  Post-test iterations: in these loops, the condition to be met is at the end of the loop
so that the code always runs at least once.
Activity 8
Create a new form and link to iteration — pre-test (- Count the beeps) on the Main menu.
Add a text box and a command button. Put a label above the text box asking the user to
input a number between 1 and 10. When the user clicks the command button, check the
textbox for a valid number and issue an error message if the number isn’t inside the
expected range. If the number is valid, use Do While …… Loop to issue that
number of beeps. Name your form frmBeeper.
Private Sub Command1_Click()
Dim intNumber As Integer
Dim pause As Integer
intNumber = Val(Text1.Text)
If (intNumber > 0) And (intNumber < 11) Then
‘Declare variables
‘Input user number
‘Validate number
Do While intNumber > 0
Beep
For pause = 0 To 2500
frmBeeper.Refresh
Next pause
‘Slow down the beeps
intNumber = intNumber - 1 ‘Count down
Loop
Else
Text1.Text = ""
Text1.SetFocus
End If
End Sub
Write an IPO Chart for this program.
Then write the pseudocode algorithm for this program.
Activity 9
In this tutorial, we look at writing code containing the 5 basic control structures.
·  sequence
·  binary selection
·  multiway selection
·  pre-test iteration
·  post-test iteration
The IPO chart and pseudocode algorithm for finding the average of some numbers
entered from the keyboard, using a post-test loop, might look like this:
I number, counter
P add number to sum
add 1 to counter
average = sum/counter
O average
BEGIN Main Program
counter = 0
sum = 0
REPEAT
get number
sum = sum + number
counter = counter + 1
UNTIL counter = 10
average = sum / counter
display average
END MAINPROGRAM
Write this algorithm as a flowchart.
Open a new form and create a link to the program from the menu form (Main) under
Iterations … Post-test Loops … Averages. Write an application to display the average of
10 numbers entered by the user using a post-test loop with the syntax Do …..Loop
Until to ask for each number. Remember to use the Val () function to convert strings
to numbers. Each number might be asked for with an input box using the syntax:
strNumber = InputBox(“Enter the next number.”, “Enter your numbers.”)
intNumber = Val(strNumber)
Don’t forget to declare all your variables with Dim statements.
e.g. Dim strNumber As String
Initialise your variables to 0 at the beginning of the procedure.
intNumber = 0
intCounter = 0
Can you be sure that the counter will never cause division by zero and crash your
program? Explain your answer.
Activity 10
Use a new function Rnd() to generate a random number. Write an application on a
new form to generate a random number between 1 and 6 to simulate the rolling of a
dice. Your form will need a large picture box with the Autosize property set to true and a
command button with the following code behind it.
Private Sub Command1_Click()
Dim x As Integer
x = 0
Picture1 Print
Randomize
‘ Ensures the start of each sequence of random numbers is also randomised
Do
x = Int(Rnd * 6 + 1)
Picture1 Print x;
Loop Until x <> 6
End Sub
Run your program clicking the command button several times (until the picture box is
full). Create a link to the program from the menu form (Main) under Iterations … Post
test Loops … Roll the dice.
To produce a random integer x where 0 <= x < N, use the following syntax
x = Int(Rnd * N)
The following statement produces random integers in the range from 51 to 150.
x = Int (Rnd*100 + 51)
The Randomize statement ensures that the start of each sequence of random numbers is
also random.
You will notice that Visual Basic has two different syntax statements for post-test
iterations:
·  Do ……. Loop Until (comparison test)
·  Do ……. Loop While (comparison test)
Both are post-test loops where the comparison test appears at the bottom of the loop
meaning that the code in the loop must execute at least once. These are both equivalent
to the pseudocode syntax
REPEAT ……. UNTIL
Write the algorithm for this application in pseudocode that explains what every line in the
program does.
Activity 11
Create a program to generate the first 20 Fibonacci numbers. This time use a counter to
control the number of iterations. Add a Picture Box to print your results to. Make sure
the PictureBox.Font Transparent = False, AutoRedraw = True and that the BackColor is
different from the ForeColor. Use the following code to help you.
Dim FibNumber As Integer, FibNext As Integer, Counter As Integer
‘Initialise
FibNumber = 0
FibNext = 1
Picture1 Print "Ist 20 Fibonacci Numbers"
Do While Counter < 20
Picture1 Print FibNumber & ", ";
‘trailing semicolon stops the Print method going to the next line.
Picture1 Print FibNext & ", "
FibNumber = FibNumber + FibNext
FibNext = FibNext + FibNumber
Counter = Counter + 2
If Counter = 10 Then
Picture1 Print
‘This creates a new line
End If
Loop
Write an IPO chart and the algorithm in pseudocode and as a flowchart.
Activity 12
Write a program that uses nested For loops to fill a 2 dimensional array and then to print
out the times tables from 1 – 12 into a picture control using the syntax:
picDisplay Print (variable, [variable] ...]
with a new line for each new times table on the display.
You will definitely need to plot this one out on paper first, writing your algorithms and
checking them. To declare your variable, you need the statement:
Dim arrTables[12,12] As Integer

BASIC INTRODUCTION TO PASCAL

Lesson 1. INTRODUCTION
The First Few steps in Pascal Programming
Programming Basics
In a program, you must always obey the rules of the language, in our case, the Pascal
language. A natural language has its own grammar rules, spelling and sentence
construction. The Pascal programming language is a high level language that has its own
syntax rules and grammar rules. As you go along with the lessons, you must note what you
can do and what you cannot do in writing a Pascal program. A very simple program is
shown below:
Program Lesson1_Program1;
Begin
Write('Hello World. Prepare to learn PASCAL!!');
Readln;
End.
The program is written only to display the message : 'Hello World. Prepare to learn
PASCAL!!' - an introductory message that is displayed to you whenever you are going to
learn a new programming language. This is simply shown on the screen. So, to display any
message on the screen, you should use 'write' (or 'writeln'). The 'readln' statement, here is
used as to 'stop' the program and wait until the user presses enter. If the 'readln' statement is
missing in this program, then the message is displayed on the screen without giving any
chance for the user to read it and obviously halts! Try running this program with and
without the 'readln' statement and notice the difference. I suggest you see it!! Now, look at
this:
Program Lesson1_Program2;begin
Write('Hello World. Prepare to learn
PASCAL!!');Readln;End.
This program also runs perfectly as the previous one. The only difference is: neatness and
friendliness.
This first program is, what is commonly referred to in programming, as 'indented'.
Indentation is a must in writing programs as it aids in the way the code is written ie. neater.
Indentation also helps with debugging and code presentation. You will note how I indent
programs.
A program in Pascal always starts by the reserved word 'Program' following the title of the
program. There are various restrictions on how to write this statement. Below is a simple
example of a small program. (Remember: you can copy and paste the program in a text file,
save the text file as filename.pas and open it with Turbo Pascal. The .pas extension is
required.)
In the following program, the computer must prompt the user to enter a number, then the
latter is added to the second number input by the user.
Program Lesson1_Program3;
Var
Num1, Num2, Sum : Integer;
Begin {no semicolon}
Write('Input number 1:');
Readln(Num1);
Writeln('Input number 2:');
Readln(Num2);
Sum := Num1 + Num2; {addition}
Writeln(Sum);
Readln;
End.
Now we must take a look at the program. A program in Pascal starts with the reserved word
'Program' (although it is not explicitly required) and ends with 'End', following a full stop
(this is required though). A full-stop is never used within the program, except when dealing
with records (later topics) and at the end of the program as seen in the example above.
The 'Var' statement, is used to introduce any suitable variables which will be used later in
the program. These variables are non-constant terms so that they are used in the program
for storing values. The terms 'Num1', 'Num2' and 'Sum' in the program are the variables
which store any numbers, except those which are real (in fact, during the execution of the
program, a runtime error may occur if a decimal number is input). As you can see in the
example above, these variables are assigned to as integers. The term 'integer' means any
whole number, i.e. a number which is not a decimal number but a positive or negative
number. The integer type ranges from -32768 to 32767. So values which are not within the
specified range cannot be stored by an integer type. There are other types which are wider
in range, but for now the integer type is enough to hold up our values. The variables
'Num1', 'Num2' and 'Sum' are terms which are not reserved words, but can be used as
variables in the program to store data in them. They could be changed more than once.
Moreover, I could have used 'number1', 'number2' and 'totalsum' (note that there must be no
spaces within the variables), instead of 'Num1', 'Num2' and 'Sum', respectively. As you can
see, it is much better to shorten the variables than writing long words, such as
'variable_number1'.
After declaring all the variables which are required to be used later in the program, the
main program always starts with the reserved word 'Begin'. Without this word, the
compiler will display a diagnostic (error message). In the program above, both of the two
types of 'write' are used. These are 'write' and 'writeln'. Both has the same function, except
that the 'write' function, does not proceed to the following line when writing a statement. If
you run this program, you will notice the difference between them. When using these two
terms, any message that will be typed in between the brackets and the inverted commas '('
')', is displayed on the screen. However, if a variable is used instead of a message,
without using the inverted commas, the CPU will display the stored variable in the
memory, on the screen. In line 9, the CPU will not display 'Sum' on the screen, but the
stored number in the memory. Another important thing which must be noticed is the semicolon
(;). The semicolon is used after each statement in the program, except those that you
will learn later. However, in the example above, there isn't a semicolon after a 'begin'
statement. This is because the flow of the program has just started and must not be stopped
by a ';'.
This lesson will cover:
• String Variables
• Constants and the Assignment Statement
String Variables
Soon, you should learn how to input text by the user using 'string variables'. The following
program is written showing an example of a string variable, prompting the user to input his
name, whatsoever:
Program Lesson2_Program1;
Var name, surname: String;
Begin
Write('Enter your name:');
readln(name);
Write('Enter your surname:');
readln(surname);
writeln;{new line}
writeln;{new line}
Writeln('Your full name is: ',name,' ',surname);
Readln;
End.
If we take a look at this program, we notice a new variable type : 'String'. Both the name
and surname variables are of type string. When the program is run and prompts the user to
input his name, the name which is keyed in by the user goes directly to its place in the
memory called 'name'. Same occurs to surname. *I'd like to remind you that the variables
'name' and 'surname' are not reserved words, but are used by the programmer as his
variables. I could have used 'n' instead of 'name' and similarly 'sname' instead of
'surname'. The two 'idle' writeln's in lines 9 and 10 are used to move on for a new line. In
this case, 2 lines are cleared. The next message displays the full name of the user using the
above format. If a string variable is required to be displayed on screen, it should be put in
between inverted commas and commas if it is concatenated with another message;
example:
It could be in the form of: (please note where you must or you must not put the inverted
commas following the commas)
*Writeln('Your name is: ',name);
or:
Writeln('Your name is:',name,'. Your surname is ',surname,'.');
*Note that you can even make it this way:
Writeln('Your name is: ',name,'');
BUT you should put the inverted commas properly (underlined) to close the message.
Constants and the Assignment Statement
Apart from variables, there are also items in the program which are referred to as
'constants'. Unlike variables, constants keep their value or string unchanged for the whole
program. Here I have made a program, not so much different from the previous one:
Program Lesson2_Program2;
Var
surname: String;
Const {the reserved word 'const'
is used to initialize constants}
name = 'Victor';
Begin
Write('Enter your surname:');
readln(surname);
writeln;
writeln;
Writeln('Your full name is: ',name,' ',surname);
Readln;
End.
In the above program, the constant 'name' is assigned to as 'Victor' and is of type string.
However, in other cases, you might have used integer constants (whole numbers), i.e.:
Const
age = 15;
The constant 'age' is a value that could be used whever it is required in a program.
Example:
age2 := 15;
age2 := age + 15;
The above example shows an addition of the value of the variable 'age' with the value 15.
The value of the constant 'age' remains 15, but the value of the variable 'age2' becomes 30.
The assignment statement is not only used for additions, but is also used to assign a
variable: text if it is a string variable or a numeric value if it is an integer variable.
Try examine this yourself:
name := 'victor';
age := 15; {also: "age:='15';" BUT in this case, 'age' is an integer variable}
writeln('Name:',name,'. Age:',age,'.');
I conclude lesson 2 with another simple program for you to read and think about:
Program lesson2_Program3;
Var PD, Dname, Cmodel : String;
TotalKM, CostPD, TCostPD, Distance : Real;
{real is a decimal (described later)}
begin
TCostPD := 0;
{note that this is called an 'initialisation'.
It is important to initialise variables to 0
so that it is 'refreshed' from the previous
'rubbish' value in the memory.}
Writeln('This program prompts you to '+
+'input the cost per litre of');
Writeln('the petrol/diesel you spend '+
+'in and the average distance you travel');
Writeln('with your car every week. Then '+
+'the computer calculates the total cost');
Writeln('you spend in fuel every week.');
Readln;
Write('Diesel or Petrol?: ');
Readln(PD);
Write('Name Of Driver: ');
Readln(Dname);
Write('Car Model: ');
Readln(Cmodel);
Write('Cost of Diesel/Petrol: (£) ');
Readln(CostPD);
Writeln('Average distance you travel '+
+'with your car every week: (kilometres) ');
Readln(Distance);
Writeln;
The messages in between the braces ({ }) are called comments or in-line documentation. I
guess you consider the comments to be 'extra'. Very long programs which include
thousands of lines, have already been felt in need of describing certain functions or even
complicated functions. In my experiences, I have already met many problems, when
refusing to write a program for a long time, and then resuming again writing it! I've made a
long time trying to understand what I have done. You must keep it into your mind that
comments within the braces are not read or compiled by the compiler/interpreter.
The 'readln' statement is another reserved word for input purposes, which enables the user
to input a number or text only i.e.: using the keyboard. But in our case the 'readln'
statement is used to input numbers only (letters are accepted but will cause a run-time error
because it is not the input we want) and store them in the variables 'Num1' and 'Num2'.
This is because both variables are assigned to as integers, and integer variables do not store
strings. A run-time error is detected by the OS (Operating System; ex. Windows or
Linux) if something goes wrong with the input. Later in the course, you will also learn how
to control input and output exceptions - unexpected runtime errors. One last thing on errors
is this: there are 2 major error types which are - Runtime Errors and Compilation Errors.
Runtime errors are those which occur unexpectedly during the execution of the program,
whereas a Compilation error is one which is detected during the compilation process. Note
that a decimal number is also considered as a wrong input; a decimal number must not be
input, since it is a real number (more on this later).
Writeln;
Writeln('Name of Driver:',Dname);
Writeln('Car Model:',Cmodel);
Writeln('Diesel/Petrol:',PD);
Writeln('Average distance covered '+
+'every week: ',Distance:1:2,'Km');
Writeln('Cost of ',PD,' per liter:
£',CostPD:1:2,'/litre');
Writeln;
Writeln;
TCostPD := Distance * CostPD;
Writeln('Total cost of ',PD,' per week:'+
+'£',TCostPD:1:2); {note this,}
TCostPD := 0;
Writeln('Total cost of ',PD,' per week:'+
+'£',(Distance * CostPD):1:2); {this}
Writeln('Total cost of ',PD,' per week:'+
+'£',Distance * CostPD); {and this - without
':1:2'}
readln;
End.
After the prompts and inputs by the user, follows the addition. i.e.
Sum := Num1 + Num2;
The result of the above statement is the addition of the values stored in variables 'Num1'
and 'Num2'. The important thing that you should know is that one cannot make the same
statement as follows:
Num1 + Num2 := Sum;
This is another syntax error. It is the fact that transfer of information is from left to right
and not from right to left. So, mind not to make this error. The ':=' is called the assignment
statement, and should be discussed later on.
Lesson 2 - Variables, Constants and the Assignment Statement
Lesson 3 - Special Reserved Words of the CRT Unit: ClrScr(), GotoXy(), etc...
This lesson will cover :
• Use of the reserved words
• Description of the reserved words
Examples :
1. Clrscr;
2. GotoXy(_,_);
3. Textbackground();
4. Textcolor();
5. Readkey;
6. Delay();
7. Halt; / Halt()
Use of the Reserved Words
Before I teach you the if statements and for loops, I would like to give you an idea of some
pascal functions which are quite useful. This would require your program to include the
library 'crt.tpu'. To include a library in the program, one should use the reserved word
'uses', because it is used to call a library of functions and procedures. Here is the program
of lesson 2 (program 3) which is better handled and more user-friendly:
Program lesson3_Program1;
Uses Crt; {We will make use of the crt library}
Var PD, Dname, Cmodel : String;
CostPD, TCostPD, Distance : Real;
{real is a decimal (described later)}
Begin
textbackground(brown); {background colour}
ClrScr; {Clear screen with a brown colour.
Try run the program without this!!!}
TextColor(lightgreen); {text colour}
TCostPD := 0;
Writeln('This program prompts you to '+
+'input the cost per litre of');
Writeln('the petrol/diesel you spend in and '+
+'the average distance you travel');
Writeln('with your car every week. Then, '+
+'the computer calculates the total cost');
Writeln('you spend in fuel every week.');
Readkey; {program move on as soon as a key is pressed}
ClrScr;{short for clear screen}
GotoXy(28,3);
{^move to a position on the screen:
x (horizontal), y (vertical)}
Write('Diesel or Petrol? Type p or d: ');
PD := Readkey;
{^as soon as a key is pressed,
it is stored in the variable 'PD'}
GotoXy(30,4);
Write('Name Of Driver: ');
Readln(Dname);
GotoXy(30,5);
Write('Car Model: ');
Readln(Cmodel);
GotoXy(29,6);
Write('Cost of Diesel/Petrol: (£) ');
Readln(CostPD);
GotoXy(8,7);
Writeln('Average distance you travel with '+
+'your car every week: (kilometres) ');
Readln(Distance);
ClrScr;
GotoXy(28,3);
Writeln('Name of Driver:',Dname);
GotoXy(31,4); Delay(500);
Writeln('Car Model:',Cmodel);
GotoXy(32,5); Delay(500);
Writeln('Diesel/Petrol:',PD);
GotoXy(8,6); Delay(500);
Writeln('Average distance covered '+
+'every week: ',Distance:1:2,'Km');
GotoXy(25,7); Delay(500);
Writeln('Cost of ',PD,' per litre:
£',CostPD:1:2,'/litre');
Writeln; Delay(500);
Writeln;
TCostPD := Distance * CostPD;
GotoXy(21,10);
Writeln('Total cost of ',PD,' per week:£',TCostPD:1:2);
TCostPD := 0;
GotoXy(21,12);
Writeln('Total cost of ',PD,' per week:'+
+'£',(Distance * CostPD):1:2);
GotoXy(18,14);
Writeln('Total cost of ',PD,' per week:£',Distance *
CostPD);
readln;
End.
(if you want to see the difference of the 2 programs then you should run them) What is the
difference between this program and the program which is program 3 in lesson 2?
The 'Crt' (short for cathode-ray tube) library has a wide range of functions and procedures
that you will use so frequently. Some of them are listed in the table below. There are many
similar libraries, such as 'Strings' (you will be learning something on this later) and 'Dos'.
Description of the following Reserved Words
Below is a table of the new words:
Reserved Word
Crt:
Yes/No
Description
Clrscr Yes Clears screen
Gotoxy(int,int) Yes
Takes the cursor to
the pre-defined
position
Textbackground(word/int) Yes Background colour
Textcolor(word/int) Yes Colour of text
Readkey Yes
Reads a key; Could
be assigned to a
variable
Delay(int) Yes
Waits for the
included
time(milliseconds)
Halt(parameter) No Program terminates
key (variable type) :
int - integer (-32768 to 32767), word - 0 to 65535.
Example of each
• Clrscr: (clear screen)
writeln('When you press enter, the screen would be cleared!');
readln;
clrscr;
• Gotoxy(int,int): (Go to position x and y);
gotoxy(10,10);
Writeln('The position is 10 pixels from the left of the screen, and ten pixels');
Writeln('from the top of the screen.');
readln;
• Textbackground(word/int): (Background colour);
Textbackground(red); {word - red}
Writeln('Note the difference');
Textbackground(5); {integer - 5}
ClrScr;
Writeln('Note the difference'); Readln;
• Textcolor(word/int): (Text colour);
Textcolor(red); {word - red}
Writeln('Text colour');
Textcolor(5); {integer - 5}
Writeln('Text colour'); Readln;
• Readkey: (Reads a key-press);
Example 1:
Writeln('Press ANY key!!!');
Readkey;
Example 2:
Writeln('Press ANY key');
Keypress := readkey; {keypress is a DECLARED string variable(can be an integer
variable)}
Writeln(Keypress);
• Delay(int): (Waits for some time);
Writeln('1');
Delay(1000);{1000 milliseconds}
Writeln('2');
Delay(1000);
Writeln('3');
Readln;
• Halt(int): (Program terminates with an exit code);
writeln('Press enter and the program terminates!);
Readln;
Halt(0);
Note that instructions following 'halt' are not executed since the program terminates when
halt is encountered.
Lesson 4 - Program Control
This lesson will cover:
• The If Statement
1. If..Then..Else
2. Nested If Statements
• The Repeat-Until Loop
• The For Loop
1. Nested For loops
• While-Do Loop
Now, it is time to learn the most important rules of programming: the if statements -
decision making, for loops and the repeat-until loop. Almost, these 3 general
programming constructs are common in every programming language and you have to
make sure that when you have finished reading this lesson, make sure that you have
practiced them enough before continuing with learning pascal because they are of outmost
importance. If you fall in doubt about these programming constructs, then try to use the
forums, describing your problem.
The If Statement
The 'if statement' executes a the proceeding statement(s) conditionally. This means that if
an action comes to be true, then the statement(s) proceeding the if statement are executed,
else these statements are skipped. It works like this:
If this happens(action), then do this(reaction, if action is true).
OR:
If this happens(action), then do this(reaction, if action is true), else do this(reaction, if
action is false).
In Pascal, the 'if statement' should be written as follows:
If conditional expression then code ... ;{if one action}
OR:
If conditional expression then Begin instructions ... End; {if more than one action is
required}
Note that you should not use an assignment statement in the 'if' construct, otherwise the
compiler will raise a syntax error. I.e.:
Wrong:
If x := 20 then x := x + 1; {the underlined character must be excluded}
Correct:
If x = 20 then x := x + 1; {only an equal sign is used for comparison}
A program is shown below as an example of how the 'if statement' works:
Program lesson4_Program1;
Uses Crt;
Label 1; {this is used with a goto statement}
Var Sel: String;
N1,N2, Total : Real;
YN : Char; {this is a character variable type,
which holds single characters ONLY}
Begin
1:Clrscr;
Total := 0; {always initialise integer/real variables}
GotoXy(4,3);
Writeln('1.Addition');
GotoXy(4,4);
Writeln('2.Subtraction');
GotoXy(4,5);
Writeln('3.Exit');
GotoXy(6,8);
Write('Select: ');
Sel := Readkey;
If Sel = '1' {action} then
Begin {more than one statement}
ClrScr;
Write('Input No.1:');
Readln(N1);
Write('Input No.2:');
Readln(N2);
Total := N1 + N2;
Writeln('Addition: ',N1:2:3,' + ',N2:2:3,' =
',Total:2:3);
Write('Press any key to continue...');
Readkey;
Goto 1;{this leads back to the beginning of the
program,
otherwise the program terminates}
End; {Closing the if statement(begin)}
If Sel = '2' then
{note that the assignment statement
is not used within an if statement}
Begin
ClrScr;
Write('Input No.1:');
Readln(N1);
Write('Input No.2:');
Readln(N2);
Total := N1 - N2;
Write('Subtraction: ');
Write(N1:2:3,' - ',N2:2:3,' = ',Total:2:3);
Write('Press any key to continue...');
Readkey;
Goto 1;
End; {Closing the if statement}
If Sel = '3' then
Begin
ClrScr;
Write('Are you sure?(Y/N)');
YN := Readkey;
If YN = 'y' then Halt; {1 action, so no need of
Begin..End}
If YN = 'n' then Goto 1; {the goto statement is not
recommended for excessive
use}
End;
End.
In the above program, the 'goto' statement is used. So far, it has been a real damage to
programs and it has produced unwanted confusions. I strongly suggest you not to use it
repeatedly.
-> If..Then..Else
In a normal if statement, the 'reaction' cannot be performed if the
condition is not true. But in an if..then..else statement, there is at least
one set of statements to be performed. Let's take a look at the example
below:
writeln('Who has discovered the land of America?');
Readln(ans);
If (ans = 'Christopher Colombus') then
score := score + 1 {if this is false,}
ELSE
writeln('sorry, you''ve got it wrong!'); {then this is true}
Note that if the 'else' term is included with an if statement, then there
should be no semi-colon before the 'else' term; just as seen in the
above example.
-> Nested If statements
The previous program have already shown an example of nested if
statements. I.e.:
If Sel = '3' then
Begin
ClrScr;
Write('Are you sure?(Y/N)');
YN := Readkey;
If YN = 'y' then HALT; {Nested if statement}
If YN = 'n' then Goto 1;{Another Nested if statement}
End;
A nested if statement, is in the form:
If (this happens) then {if 1}
If (this happens) then {if 2}
(do this) etc...
Else (do this) {if 2}
Else (do this) etc... {if 1}
A nested if statement is an if statement within another if statement, as
shown above.
The Repeat-Until Loop
This loop is used to repeat the execution of a set of instructions for at
least one time. It is repeated until the conditional expression is obeyed.
The following example, shows the model of the 'repeat-until' loop:
Repeat
..(code)
..(code)
..(code)
Until conditional statement;
Here's an example:
Uses Crt;
Var YN : String;
Begin
Writeln('Y(YES) or N(NO)?');
Repeat {repeat the code for at least one time}
YN := Readkey ;
If YN = 'y' then Halt; {Halt - exit}
If YN = 'n' then Writeln('Why not? Exiting...');
Delay(1800); { wait a second plus 800 milliseconds }
Until (YN = 'y') OR (YN = 'n');
End.
See? It's very simple! In the above program, there is a Boolean
expression in the 10th line (or). This will be described later on.
The For Loop
The for loop is a sort of repeat-until loop. The for loop, repeats a set of
instructions for a number of times. The for loop is in the form:
- If used for only one action:
for {variable}* := {original value} to/downto {final value} do
{code...(for one action)}
- If used for more than one action:
for {variable}* := {original value} to/downto {final value} do Begin
{code...}
{code...}
End;
*Generally, this variable is called the 'loop counter'.
Now, an example of the for loop is shown below, but firstly, you should
have an idea of the usefulness of the for loop. Consider the following
example:
Without for loop:
Program lesson4_Program2a;
Uses Crt;
Begin
Writeln('for loop'); {somewhat boring writing all
this!!!}
Writeln('for loop');
Writeln('for loop');
Writeln('for loop');
Writeln('for loop');
Writeln('for loop');
Writeln('for loop');
Readln;
End.
With for loop:
Program lesson4_Program2b;
Uses Crt;
Var Counter : Integer; {loop counter declared as integer}
Begin
For Counter := 1 to 7 do {it's easy and fast!}
writeln('for loop');
Readln;
End.
Note that the two programs above perform the same function, but which
programming style is more useful?
Suppose we have to make a program which designs a small box with
some of the characters of the ASCII, obviously the characters which are
most likely to make up a simple box.
Without the for loop:
Program Program3a_lesson4;
Uses Crt;
Begin
Gotoxy(25,5);Writeln('+');
Gotoxy(25,6);Writeln('I');
GotoXy(25,7);Writeln('I');
GotoXy(25,8);Writeln('I');
GotoXy(25,9);Writeln('I');
GotoXy(25,10);Writeln('I');
GotoXy(25,11);Writeln('+');
GotoXy(26,11);Writeln('-');
GotoXy(27,11);Writeln('-');
GotoXy(28,11);Writeln('-');
GotoXy(29,11);Writeln('-');
GotoXy(30,11);Writeln('-');
GotoXy(31,11);Writeln('-');
GotoXy(32,5);Writeln('+');
Gotoxy(32,6);writeln('I');
GotoXy(32,7);Writeln('I');
GotoXy(32,8);Writeln('I');
GotoXy(32,9);Writeln('I');
GotoXy(32,10);Writeln('I');
GotoXy(32,5);Writeln('+');
GotoXy(26,5);Writeln('-');
GotoXy(27,5);Writeln('-');
GotoXy(28,5);Writeln('-');
GotoXy(29,5);Writeln('-');
GotoXy(30,5);Writeln('-');
GotoXy(31,5);Writeln('-'); {oh my God!!! Phew!}
Readln; { wait for user to read }
End.
With for loop:
Program Program3b_lesson4;
Uses Crt;
Var Counter : Integer; {loop counter}
Begin
For Counter := 1 to 5 do
Begin
gotoxy(25, 5 + Counter);
Writeln('I');
End;
For Counter := 5 Downto 1 do
Begin {an example of 'downto' instead of
'to', note the 'gotoxy(_,_)'}
gotoxy(32, 11 - Counter);
Writeln('I');
End;
For Counter := 1 to 6 do
Begin
gotoxy(25 + Counter, 11);
Writeln('-');
End;
For Counter := 6 Downto 1 do
Begin
gotoxy(32 - Counter, 5);
Writeln('-');
End;
{--------------The Corners(+)---------------}
Gotoxy(25,5);
Writeln('+');
GotoXy(25,11);
Writeln('+');
GotoXy(32,5);
Writeln('+');
GotoXy(32,11);
Writeln('+');
GotoXy(45,7);
Writeln('Just as simple as the for loop!!!');
Readln;
End.
Again, the two programs above perform the same function.
-> Nested for loops
A nested for loop is similar to that of the nested if statements. A nested
for loop is in the form:
for {loop counter} := {original value} to {final value} do {Begin-if
required}
{code if any..begin should be included (i.e more than one action)}
for {loop counter} := {original value} to {final value} do {Begin-if
required}
{code..if more than one action, include begin in the second for
loop}
{End; - if begin is included in the second for loop)}
{code if any..begin should be included in the first for loop}
{End; - if begin is included in the first for loop)}
The nested for loop is rarely used and it may cause problems.
While-Do Loop
This type of loop is executed while the condition is true. It is different
from the 'Repeat-Until' loop since the loop might not be executed for at
least one time. The code works like this:
While <condition is true> do the following:
instruction 1;
instruction 2;
instruction 3;
etc...
End; {If while-do loop starts with a begin statement}
Example Program on the While-Do loop:
Program Lesson4_Program4;
Uses Crt;
Var Ch : Char;
Begin
Writeln('Press ''q'' to exit...');
Ch := Readkey;
While Ch <> 'q' do
Begin
Writeln('I told you press ''q'' to exit!!');
Ch := Readkey;
End;
End.
Lesson 5 - The CASE-OF Statement
*You should have an idea of the 'if statement' before you proceed with this lesson.
The Simple Case Statement
So far, you have learned how to use an 'if statement'. But in some cases the 'case statement'
is preferred to the if statement because it reduces some unnecessary code but the same
meaning is retained. The case statement is very similar to the if statement, except in that the
it does not accept literal conditional expressions (i.e.: strings) but surprisingly enough, it
allows single character conditional expressions. Here is how it works:
Case {variable of type: integer or character ONLY} of
{input statement- within inverted commas if of type char} : {code..}
{input statement- within inverted commas if of type char} : {code..}
...
End; {End Case}
Now you should note the difference and the intelligent use of the case statement over the if
statement.
The Program is written using the if statement:
Program Program1a_Lesson5;
Uses Crt;
Label Return; {used respectively with the
goto statement; beware of it}
Var SEL : Integer;
YN : Char;
Begin
Return: Clrscr;
Writeln('[1].PLAY GAME');
WRITELN('[2].LOAD GAME');
WRITELN('[3].MULTIPLAYER');
WRITELN('[4].EXIT GAME');
Writeln('note: Do note press anything except');
Writeln('numbers; otherwise an error occurs!');
Readln(SEL);
If SEL = 1 then
Begin
Writeln('Are you able to create a game');
Writeln('of yourself using pascal??');
Delay(2000);
Goto Return;
End;
If SEL = 2 then
Begin
Writeln('Ahhh... no saved games');
Delay(2000);
Goto Return;
End;
If SEL = 3 then
Begin
Writeln('networking or 2 players?');
Delay(2000);
Goto Return;
End;
If SEL = 4 then
Begin
Writeln('Exit?');
YN := Readkey;
If YN = 'y' then
Begin
Writeln('Nooooooooooooo...');
Delay(1000);
Halt; {EXIT PROGRAM}
End;
If YN = 'n' then
Goto Return;
End;
End.
Now, the next program is written using the case statement and the
output
is almost the same.
Program Program1b_Lesson5;
Uses Crt;
Label Return; {use of the goto statement
is not recommended..avoid it}
Var SEL : Integer;
YN : Char;
Begin
Return:Clrscr;
Writeln('[1].PLAY GAME');
WRITELN('[2].LOAD GAME');
WRITELN('[3].MULTIPLAYER');
WRITELN('[4].EXIT GAME');
Writeln('note: Do note press anything except');
Writeln('numbers; otherwise an error occurs!');
Readln(SEL);
Case SEL of
1 : Begin
Writeln('Are you able to create');
Writeln('a game of yourself using pascal??');
Delay(2000);
Goto Return;
End;
2 : Begin
Writeln('Ahhh... no saved games');
Delay(2000);
Goto Return;
End;
3 : Begin
Writeln('networking or 2 players?');
Delay(2000);
Goto Return;
End;
4 : Begin
Writeln('Exit?');
YN := Readkey;
Case YN of {a sort of a nested case statement}
'y' : Begin
Writeln('Nooooooooooooo...');
Delay(2000);
Halt;
End;
'n' : Begin
Writeln(‘You have decided not to Exit’);
Delay(3000);
Goto Return;
End;{End Case2}
End;{Close Conditional Expression 4}
End; {End Case1}
End.
The Case-Else Statement
Again this is similar to the if..then..else statement. Study the program
below to learn how to use the 'else' term following the 'case statement':
Program Program2_Lesson5;
Uses Crt;
Label Return; { avoid it }
Var YN : Char;
Begin
Return:ClrScr;
Writeln('Exiting?');
YN := Readkey;
Case YN of
'y' : Halt;
'n' : Begin
Writeln('What are you going to do here,
anyway?');
Delay(2000);
Halt;
End;
Else
Begin
Writeln('Either press ''y'' for yes');
Writeln('or ''n'' for no.. please try again..');
Delay(3500);
ClrScr;
Goto Return;
End;
End; {CASE}
End. {PROGRAM}
Lesson 6 - Logical Operators and Boolean Expressions
This lesson will cover:
• What are logical operators?
• The Logical Operators
1. AND
2. OR
3. NOT
• Example of each logical operator:
1. AND
2. OR
3. NOT
• The Boolean Expressions
What are the Logical Operators
The logical operators are expressions which return a false or true result over a conditional
expression. They are also used in assignments (an example of this would be shown later).
Such operators consist of simple logical operators, such as 'Not' or 'And'. They should be
used between two conditional expressions ; for example:
If (x = 0) AND (a = 2) then...
The Logical Operators
There are three types of logical operators, each of which are concerned with conditional
expressions. These are:
AND
OR
NOT
All of these logical operators have a different effect on the conditional expressions. Let's
see what each of the logical operator does two (or more) conditional expressions...
And
If *1(Str1 = 'a') AND *2(Str2 = 'b') then writeln('Yes, you got it right.');
Expression
1
Expression
2
AND
(result)
true true true
false true false
true false false
false false false
If expression 1 and expression 2 are both true(i.e. the user inputs 'a' and 'b' into variables
'Str1' and 'Str2' respectively), the message will be displayed. Above is a table showing the
possible combinations.
So, from the above table, one can conclude that for a logical operation such as AND, to
give out a true result, both conditional expressions should be true.
OR
If *1(Str1 = 'a') OR *2(Str2 = 'b') then writeln('Yes, you got it right.');
Expression 1 Expression 2 OR (result)
true true true
false true true
true false true
false false false
Either expression 1 or expression 2 should be true to display the message. If for example
expression 1 is true and any other conditional expressions are false, the result is true!
Above is a table(the truth table) showing the possible combinations.
So, from the above table, one can conclude that for a logical operation such as OR, to give
out a true result, only one of the conditional expressions should be true.
NOT
Not is almost different from the two logical gates. It only accepts one input and is wellknown
as the 'inverter'. If for example the result of two conditional expressions is true, the
'not' operator would invert the result to false! So, the of the logical operator, 'not', is to
output the inverse of the input. The simple truth table for the not operator is:
Input Output
true false
false true
Example of the AND Operator
Program Lesson6_Program1;
Uses Crt;
Var n1, n2 : string;
Begin
Writeln('Enter two numbers: (''0'' & ''0'' to exit)');
Repeat
Write('No.1: ');
Readln(n1);
Write('No.2: ');
Readln(n2);
If (n1 = '0') AND (n2 = '0') then Halt(0);
Until (n1 = '0') AND (n2 = '0');
End.
Example of the OR Operator
Program Lesson6_Program2;
Uses Crt;
Var n1, n2 : String;
Begin
Writeln('Enter two numbers: (''1'' & ''2'' to exit)');
Repeat
Write('No.1: ');
Readln(n1);
Write('No.2: ');
Readln(n2);
If (n1 = '1') OR (n2 = '2') then Halt;
Until (n1 = '1') OR (n2 = '2');
End.
Example of the NOT Operator
Program Lesson6_Program3;
Uses Crt;
Var n1 : String;
Begin
Writeln('Enter two numbers: (any number except 0 to
exit)');
Repeat
Write('No.1: ');
Readln(n1);
If not(n1 = '0') then Halt;
Until not(n1 = '0');
End.
The Boolean Expressions
The boolean expressions are the terms 'true' and 'false'. These are simply similar to 1's (for
true) and 0's(for false). They describe an expression whether it is false or true. The variable
types over boolean expressions is the 'boolean' type. Example:
Var bool : Boolean;
Example Program:
Program Lesson6_Program4;
Uses crt;
Label return;
Var quit : Boolean;
a : String;
Begin
Return:clrscr;
Repeat
Write('Type ''exit'' to quit:');
Readln(a);
If a = 'exit' then quit := True else quit := False;
If quit = True then Halt;
Goto return;
Until quit = True;
End.
Lesson 7 - Procedures and Functions
From now on, lessons are becoming somewhat more than basic. The most important thing
is that you understand clearly the material especially the examples shown which are very
important and you should keep on practicing more often.
Procedures
Procedures are just like small programs. Sometimes they are called sub--programs. They
help the programmer to avoid repetitions. A procedure start off with a begin and ends up
with an end;. It can also have its own variables, which cannot be used with the mainprogram.
To have an exact definition of a procedure, you should compare a program which
includes a repeated section with another program avoiding the repeated sections by using a
procedure, which is called several times:
Program Lesson7_Program1a;
Uses Crt;
Var Counter : Integer;
Begin
textcolor(green);
GotoXy(10,5);
For Counter := 1 to 10 do
Begin {Step [1]}
write(chr(196)); {Step [2]}
End; {Step [3]}
GotoXy(10,6);
For Counter := 1 to 10 do
Begin {Step [1]}
write(chr(196)); {Step [2]}
End; {Step [3]}
GotoXy(10,7);
For Counter := 1 to 10 do
Begin {Step [1]}
write(chr(196)); {Step [2]}
End; {Step [3]}
GotoXy(10,10);
For Counter := 1 to 10 do
Begin {Step [1]}
write(chr(196)); {Step [2]}
End; {Step [3]}
Readkey;
End.
Now have a look at the next program which uses a procedure:
Program Lesson7_Program1;
Uses Crt;
Procedure DrawLine;
{This procedure helps me to
avoid the repetition of steps [1]..[3]}
Var Counter : Integer;
Begin
textcolor(green);
For Counter := 1 to 10 do
Begin {Step [1]}
write(chr(196)); {Step [2]}
End; {Step [3]}
End;
Begin
GotoXy(10,5);
DrawLine;
GotoXy(10,6);
DrawLine;
GotoXy(10,7);
DrawLine;
GotoXy(10,10);
DrawLine;
Readkey;
End.
There are some differences between these two programs which are very
important to note. These are :
• Size of the program
It is very important for a program to be small in size. The first program,
say, its size is 1900 bytes, but the second one holds about 1350 bytes!
• Neatness
Adopting a neat style of writing for a program helps the programmer
(and other future debuggers) to cater with future bugs. I think that the
first program is cumbersome, whilst the other is not! What do you
think??!
• Repetitions
Repetitions in a program can cause a hard time for a programmer. So
procedures are an essential way to avoid repitions in a program. They
also enlarge the size of a program!
• Debugging Efficiency
When you are required to debug the program, bugs could be much more
easier to find out as the program is sliced into smaller chunks. You may
run the program and notice a mistake at a certain point and which is
located in a particular procedure/function. It would be much more
difficult to find a mistake in a program if it would be one whole piece of
code. Do slice your program into smaller chunks, and this needs design
of the whole problem in hand prior to coding. Coding (or writing up your
program) is just one section of the whole software developement
process. The whole Software Developement Process is an important
part of nowadays scientific computing.
Using Procedures with Parameters
Returning back to program Lesson7_Program1b, the gotoxy statement
before the DrawLine; could be "kicked off" so that we can avoid the
repetition of the gotoxy! We cannot build up another procedure for the
gotoxy, but it should be done by adding parameters with the
procedure. The new program is as follows:
Program Lesson7_Program2;
Uses Crt;
Procedure DrawLine(X : Integer; Y : Integer);
{the decleration of the variables in brackets are called
parameters or arguments}
Var Counter : Integer;
{normally this is called a local variable}
Begin
GotoXy(X,Y); {here I use the parameters}
textcolor(green);
For Counter := 1 to 10 do
Begin
write(chr(196));
End;
End;
Begin
DrawLine(10,5);
DrawLine(10,6);
DrawLine(10,7);
DrawLine(10,10);
Readkey;
End.
Now, this program includes a procedure which uses parameters. Every
time it is called, the parameters can be variable, so that the position of
the line could be changed. This time, we have also eliminated the
gotoxy statement before every DrawLine statement. The numbers in the
brackets of the DrawLine are the parameters which state the position of
the line. They also serve as a gotoxy statement.
When you apply parameters to a procedure, variables should be
declared on there own, and must be separated by a semi-colon ";". They
are put in between the brackets, following the procedure name. The
variables (known as the parameters) should be used by the
procedure/sub-program only.
I made another program, which prompts the user to enter his/her
favourite text colour and background colour, which would be used to
write text (in his/her favourite colours) further in the program.
Program Lesson7_Program3;
Uses Crt;
Var
UName, USurn, UCoun, UMail : String[50];
{These var's are global because
they are used by more than one procedure}
TxtB, TxtC, i : Integer;
InfoCor : Boolean;
Procedure EnterUserInfo(TxtCol : SmallInt; TxtBck :
SmallInt);
Begin
textcolor(TxtCol);
textbackground(TxtBck);
ClrScr;
Write('Your Name: ');
Readln(UName);
Write('Your Surname : ');
Readln(USurn);
Write('Country : ');
Readln(UCoun);
Write('E-Mail Address: ');
Readln(UMail);
Write(' Thank you for entering your personal
information!!');
Readkey;
End;
Procedure ConfirmationField(TxtCol : SmallInt;
TxtBck : SmallInt);
Var
YN : Char; { a local variable }
Begin
textcolor(TxtCol);
textbackground(TxtBck);
ClrScr;
Writeln('Your Name: ',UName);
Writeln('Your Surname : ',USurn);
Writeln('Country : ',UCoun);
Writeln('E-Mail Address: ',UMail);
Writeln;
Writeln;
Writeln('This is a confirmation field. Please verify
that');
Writeln('your information is correct!');
Writeln;
Write('Is your personal information all correct? [Y/N]
');
Repeat
YN := Readkey;
Case YN Of
'N' : InfoCor := False;
'Y' : InfoCor := True;
End;
Until (YN = 'N') or (YN = 'Y');
End;
Begin { main program }
InfoCor := True;
ClrScr;
TextBackground(cyan);
TextColor(green);
Write('A list of colours is being displayed...');
For i := 1 to 16 do
Begin
Case i Of
16 : Begin
TextBackGround(white);
End;
End;
textcolor(i);
Writeln(i,': This is Colour No.',i);
End;
TextBackGround(black);
TextColor(white);
Write('Please, put into your mind your favourite colour.
');
Write('When you are ready press any key...');
Readkey;
ClrScr;
Write('Enter your favourite text colour: (only numbers)
');
Readln(TxtC);
Write('Enter your favourite background colour : __');
Readln(TxtB);
Writeln;
Writeln;
Write('Now, you must enter your personal information. ');
Write('Hit any key to continue...');
ClrScr;
EnterUserInfo(TxtC,TxtB);
ConfirmationField(TxtC,TxtB);
If InfoCor = False then
Repeat
Writeln;
Writeln('You verified that your information is, '+
+'for some reason, incorrect.');
Writeln('You are now going to re-enter your '+
+'correct information. Hit any key..');
Readkey;
EnterUserInfo(TxtC,TxtB);
ClrScr;
ConfirmationField(TxtC,TxtB);
Until InfoCor = True;
End.
The Variable Parameter
Parameters of procedures may be varaible. In this case, data may flow
through the variable in both ways. What I am trying to say is that you
can pass data and get data through the procedure using a variable
parameter. Here is a declereation of a variable parameter:
Procedure <PROCEDURE_NAME(Var Variable_Name : Type);>
Here is an example of how to use a varaible parameter and what's its
purpose:
Program VAR_PARAM_EXAMPLE;
Procedure Square(Index : Integer; Var Result : Integer);
Begin
Result := Index * Index;
End;
Var
Res : Integer;
Begin
Writeln('The square of 5 is: ');
Square(5, Res);
Writeln(Res);
End.
Functions
The second type of sub-program is called a function. The only difference
from the procedure is that the function return a value at the end. Note
that a procedure cannot return a value. A function start and end in a
similar way to that of a procedure. If more than one value is required to
be returned by a module, you should make use of the variable
parameter. A function can have parameters too. If you change the subprogram
from procedure to a function, of the previous program, there
will be no difference in the output of the program. Just make sure which
one is best when you can to implement a module. For example, if you
don't need to return any values, a procedure is more best. However if a
value should be returned after the module is executed, function should
be used instead.
Example of a program using a function is seen below:
Program Lesson7_Program4;
Uses Crt;
Var SizeA, sizeB : Real;
YN : Char;
unitS : String[2];
Function PythagorasFunc(A:Real; B:Real) : Real;
{The pythagoras theorem}
Begin
PythagorasFunc := SQRT(A*A + B*B);
{Output: Assign the procedure name to the value.
If you forget to assign the function to the value,
you will get a trash value from the memory}
End;
Begin
Repeat
Writeln;
Write('Enter the size of side A : ');
Readln(sizeA);
Write('Enter the size of side B : ');
Readln(sizeB);
Repeat
Write('metres or centimetres? Enter : [m or cm] ');
Readln(unitS);
Until (unitS = 'm') or (unitS = 'cm');
Writeln(PythagorasFunc(sizeA,sizeB),' ',unitS);
Writeln;
Write('Repeat? ');
YN := Readkey;
Until (YN in ['N','n']);
End.
Program code is updated (24th August 2005)
Details: the function returns a real instead an integer; if..then..halt removed;
repeat..until condition is also changed
Program Errors corrected thanks to Harold Smith
Lesson 10 - Arrays
This lesson will cover:
• What are Arrays?
• Introducing User-Defined Data Types
• 2 Dimensional and multi-Dimensional Arrays
What are Arrays?
An Array is a powerful data structure that stores variable data having
the same data type. It is just like a small fixed number of boxes linked
together one after the other storing things that are related to each
other. An array is said to be a static data structure because, once
declared, its original size that is specified by the programmer will remain
the same throughout the whole program and cannot be changed.
Up until now, we have used single variables only as a tool to store data.
Now we will be using the array data structure and here is how it is
declared:
Var
myArray : Array[1..20] of Integer;
<arrayName> : Array[n..m] of <Data Type>;
An array data structure defines the size of the array and the data type
that it will use for storing data. In the above example, the array stores
up to 20 integers however I may have used 30 integers or more. This
size depends on your program requirements.
Arrays are used just like ordinary variables. They are used to store
typed data just like the ordinary variables. You will now learn how to
assign data to arrays and read data from arrays.
In the example above, I have declared 20 integers and I should be able
to access each and one of them and here is how I do it.
To assign values to a particular integer of an array, we do it like this:
myArray[5] := 10;
myArray[1] := 25;
<arrayName>[index] := <relevant data>
You just take the array in subject, specify the index of the variable of
the array and assign it a value relevant to the data type of the array
itself.
Reading a value from an array is done as follows:
Var
myVar : Integer;
myArray : Array[1..5] of Integer;
Begin
myArray[2] := 25;
myVar := myArray[2];
End.
Just like ordinary variables, arrays should be initialised, otherwise scrap
data will remain stored in them. If we want to intialise 2 whole 20-sized
integer and boolean arrays to 0 and false respectively, we do it like this:
Var
i : Integer;
myIntArray : Array[1..20] of Integer;
myBoolArray : Array[1..20] of Boolean;
Begin
For i := 1 to 20 do
Begin
myIntArray[i] := 0;
myBoolArray[i] := false;
End;
End.
Introducing User-Defined Data Types
Now that we have used various built-in data types, we have arrived at a
point were we want to use our defined data types. Built-in data types
are the ones we used lately, such as Integer, Boolean and String.
Now we will learn how to specify our own customised data types and
this is just how it is done:
Type
<myDataType> = <particularDataType>;
The "Type" keyword is a reserved Pascal word used to define our own
data types. So you start defining your own data types by using this
keyword. After defining your own data types, you may start using them
just like the other built-in data types as follows:
Var
<myVar> : <myDataType>;
Now lets define a new simple data type and note how it will be used in
the program below:
Type
nameType = String[50];
ageType = 0..150; { age range: from 0 to 150 }
Var
name : nameType;
age : ageType;
Begin
Write('Enter your name: ');
Readln(name);
Write('Enter your age: ');
Readln(age);
Writeln;
Writeln('Your name:', name);
Writeln('Your age :', age);
Readln;
End.
In the above example we defined a String[50] and a 0..150 data type.
The nameType only stores strings up to 50 characters long and the
ageType stores numbers only from 0 to 150.
We can define more complex user-defined data types. Here is an
example of more complex user-defined data types:
Type
i = 1..5;
myArrayDataType = Array[1..5] of Byte;
byteFile = File of Byte; { binary file }
Var
myArrayVar : myArrayDataType;
myFile : byteFile;
Begin
Writeln('Please enter 5 number from (0..255): ');
For i := 1 to 5 do
Readln(myArrayVar[i]);
Writeln('You have entered the following numbers: ');
For i := 1 to 5 do
Writeln('Number ',i,': ',myArrayVar[i]);
Writeln('Now writing them to file...');
{store the numbers in a file}
Assign(myFile, 'example.dat');
ReWrite(byteFile);
Write(myFile, myArrayVar[i]);
Close(myFile);
Writeln('Done, you may exit..');
Readln;
End.
In the above example I showed you how to incorporate arrays as userdefined
data types. Note that you may use user-defined data types
more than once.
2 Dimensional and Multi-Dimensional Arrays
2 Dimensional arrays and multi-dimensional are arrays which store
variables in a second or nth dimension having n*m storage locations.
Mutli dimensional arrays including the 2 dimensional array, are declared
by using multiple square brackets placed near each other or using
commas with one sqaure brackets as an alternative. Here is how multidimensional
are declared:
my2DArray : Array[i..j][k..l] of <DataType>;
myMultiDimArray : Array[m..n][o..p][q..r][s..t]... of
<DataType>;
Let us have the 2 dimensional array defined first. Think of a grid where
each box is located by using horizontal and vertical coordinates just in
the example below:
1 2 3 4 5
2
3 3,4
4
5 5,3
An example of a 5 by 5 2D array illustrated on a grid
Let us declare an array having 3 by 5 dimensions, assign a value to a
particular variable in the array and illustrate this on a grid just like the
one above:
Var
my2DArray : Array[1..3][1..5] of Byte;
Begin
my2DArray[2][4] := 10;
End.
Having the vertical axis as the 1st dimension and the horizontal one as
the 2nd dimension, the above example is illustrated as follows:
1 2 3 4 5
2 10
3
Multi-dimensional arrays are rare and are not important. The single and
2D dimensional arrays are the 2 most frequent dimensions.
The following example is a bit more complex example than the previous
examples and it also uses a 2 dimensional array to illustrate their use.
Uses Crt;
Type
myRange = 1..5;
arrayIntType = Array[myRange] of Integer;
myFileType = File of arrayIntType;
Var
i : myRange;
myFile : myFileType;
{ the next array is 2 dimensional }
arrayInt : Array[1..2] of arrayIntType;
Begin
Clrscr;
Randomize;
For i := 1 to 5 do
Begin
arrayInt[1][i] := Random(1000);
Writeln('rand num: ',arrayInt[1][i]);
End;
Assign(myFile, 'test.dat');
ReWrite(myFile);
Write(myFile, arrayInt[1]);
Close(myFile);
ReSet(myFile);
Read(myFile, arrayInt[2]);
Close(myFile);
For i := 1 to 5 do
Writeln(i,': ', arrayInt[2][i]);
Readln;
End.
This concludes the arrays lesson. In the next lesson we will learn about
Record data structures, their uses and we will also learn how to use
binary files used record data structures.
Lesson 11 - Record Data Structure
This lesson will cover:
• What are Records?
• The With Keyword
• Passing Records as Arguments
• Arrays of Records
• Binary Files and Records
What are Records?
A record is a special type of data structure that, unlike arrays, collects
different data types that define a particular structure such a book,
product, person and many others. The programmer defines the data
structure under the Type user definition.
Let us take the case of defining a book using a record data structure.
The main entities of a book are its title, author, unique ISBN number
and its price. This is how it is defined in Pascal and in most other
programming languages:
Type
Str25 = String[25];
TBookRec = Record
Title, Author,
ISBN : Str25;
Price : Real;
End;
Var
myBookRec : TBookRec;
That's it! Note that I could have used this structure as a variable by
declaring it under Var. When type-defining it, you can declare as many
TBookRec variables as you wish.The entities of the record (title,
author...) are called fields and these will be accessed through the
instance of myBookRec variable. As you might have noticed, the
declaration of typical record data structure starts with the keyword
Record and always ends with the end keyword.
Now, you will see how we access the fields of the record by assigning
them values and retrieve them back later in the following small
program.
Type
Str25 = String[25];
TBookRec = Record
Title, Author,
ISBN : Str25;
Price : Real;
End;
Var
myBookRec : TBookRec;
Begin
myBookRec.Title := 'Some Book';
myBookRec.Author := 'Victor John Saliba';
myBookRec.ISBN := '0-12-345678-9';
myBookRec.Price := 25.5;
Writeln('Here are the book details:');
Writeln;
Writeln('Title: ', myBookRec.Title);
Writeln('Author: ', myBookRec.Author);
Writeln('ISBN: ', myBookRec.ISBN);
Writeln('Price: ', myBookRec.Price);
Readln;
End.
The With Keyword
The with keyword is a quick way in accessing fields of a record.
Although it helps with quick field evaluation, it is rarely used since it has
a lack of readability and increases ambiguity when coming to distinguish
between a variable having the same name as one of the field names of a
record within a with statement. Taking a snippet from the previous
example, this is how the code above transforms when incorprating the
with keyword.
With myBookRec do
Begin
Title := 'Some Book';
Author := 'Victor John Saliba';
ISBN := '0-12-345678-9';
Price := 25.5;
End;
Passing Records as Arguments
It may become very useful when records are required to be passed
through arguments and this will be demonstrated shortly. I will use the
same data structure, pass it by reference as a parameter and return the
value back through the parameter also.
Type
Str25 = String[25];
TBookRec = Record
Title, Author,
ISBN : Str25;
Price : Real;
End;
Procedure EnterNewBook(var newBook : TBookRec);
Begin
Writeln('Please enter the book details: ');
Write('Book Name: ');
Readln(newBook.Title);
Write('Author: ');
Readln(newBook.Author);
Write('ISBN: ');
Readln(newBook.ISBN);
Write('Price: ');
Readln(newBook.Price);
End;
Procedure DisplayBookDetails(myBookRec : TBookRec);
Begin
Writeln('Here are the book details:');
Writeln;
Writeln('Title: ', myBookRec.Title);
Writeln('Author: ', myBookRec.Author);
Writeln('ISBN: ', myBookRec.ISBN);
Writeln('Price: ', myBookRec.Price);
End;
Var
bookRec : TBookRec;
Begin
EnterNewBook(bookRec);
Writeln('Thanks for entering the book details');
DisplayBookDetails(bookRec);
Readln;
End.
Arrays of Records
Records may be stored in arrays and this will become very useful and it
is not that difficult to manage. We will use an array of records to store a
number of different books and by using this example, it will be
immensely indicative to learn how to use them.
In the following example I will use the procedures above to store 10
different books from input and then output only one chosen record to
display it back to screen in order to demonstrate how to access a record
from an array.
Type
Str25 = String[25];
TBookRec = Record
Title, Author,
ISBN : Str25;
Price : Real;
End;
Procedure EnterNewBook(var newBook : TBookRec);
Begin
Writeln('Please enter the book details: ');
Write('Book Name: ');
Readln(newBook.Title);
Write('Author: ');
Readln(newBook.Author);
Write('ISBN: ');
Readln(newBook.ISBN);
Write('Price: ');
Readln(newBook.Price);
End;
Var
bookRecArray : Array[1..10] of TBookRec;
i : 1..10;
Begin
For i := 1 to 10 do
EnterNewBook(bookRecArray[i]);
Writeln('Thanks for entering the book details');
Write('Now choose a record to display from 1 to 10: ');
Readln(i);
Writeln('Here are the book details of record #',i,':');
Writeln;
Writeln('Title: ', bookRecArray[i].Title);
Writeln('Author: ', bookRecArray[i].Author);
Writeln('ISBN: ', bookRecArray[i].ISBN);
Writeln('Price: ', bookRecArray[i].Price);
Readln;
End.
Note that you can also use arrays within records and this time the
square brackets go on with the field name instead of the record. Also
you can embed records within records. More dots will be required to
access deeper records.
Binary Files and Records
Records can also be stored into files and this could be done by using
binary files. I will demonstrate storing records into files by continuing
from the previous example. Using binary files could be very handy, fast
and more reliable over text files. You can't afford storing hundreths of
files by using text files since it becomes confusing and even slower for
the computer to process and read/write from/to the file.
In the following example I will use a file of the book record I have
created and then store as many books as I want in the file using the
binary file system. Watch carefully how I will create the file of record
and how I will perform the file I/O for the binary file system. Also, I will
make use of special built in functions that help me position the file
pointer to the record I want.
Note that with binary files, only Read and Write are allowed to
read/write fro/to a file.
Type
Str25 = String[25];
TBookRec = Record
Title, Author,
ISBN : Str25;
Price : Real;
End;
Procedure EnterNewBook(var newBook : TBookRec);
Begin
Writeln('Please enter the book details: ');
Write('Book Name: ');
Readln(newBook.Title);
Write('Author: ');
Readln(newBook.Author);
Write('ISBN: ');
Readln(newBook.ISBN);
Write('Price: ');
Readln(newBook.Price);
End;
Var
bookRecArray : Array[1..10] of TBookRec;
tempBookRec : TBookRec;
bookRecFile : File of TBookRec;
i : 1..10;
Begin
Assign(bookRecFile, 'bookrec.dat');
ReWrite(bookRecFile);
For i := 1 to 10 do
Begin
EnterNewBook(bookRecArray[i]);
{ bookRecArray[i] now contains the book details }
Write(bookRecFile, bookRecArray[i]);
End;
Close(bookRecFile);
Writeln('Thanks for entering the book details.');
Writeln('They are saved in a file!');
Write('Now choose a record to display from 1 to 10: ');
Readln(i);
ReSet(bookRecFile);
Seek(bookRecFile, i-1);
Read(bookRecFile, tempBookRec);
Close(bookRecFile);
Writeln('Here are the book details of record #',i,':');
Writeln;
Writeln('Title: ', tempBookRec.Title);
Writeln('Author: ', tempBookRec.Author);
Writeln('ISBN: ', tempBookRec.ISBN);
Writeln('Price: ', tempBookRec.Price);
Readln;
End.
The example program above demonstrated the use of the seek
function. It's role is to place the file pointer to the desired position. The
first component of the file is marked as 0. So you have to keep in mind
that if you have a counter starting from 1, you have to decrement it by
1 to obtain the actual record you want.
The seek function is very important and has an important role in binary
file system. Here are some uses of the function and how it can be used
effectively to obtain a particular position of the file.
Special Uses of the Seek Function
Seek the first record of the file
Seek(myFile, 0);
Seek the last record of the file
Seek(myFile, FileSize(myFile)-1);
Seek one position beyond the last record
Seek(myFile, FileSize(myFile));
Seek to the next position of the file from the
current
Seek(myFile, FilePos(myFile)+1);
When trying to access from a file position that is beyonf the file limits,
a runtime error is automatically raised. Try to avoid this type of error.
This may be caused because you might have looped through the file and
kept on looping beyond its limits. Note that Seek(myFile, -1) is a typical
runtime error becuase -1 position does not exist. 0 is the least and the
first record in the file. Note that FilePos is also very useful and it
returns the current positon of the file. Please note that FileSize returns
the number of components in the specified file and not the size in
Bytes. If the file is empty, 0 is the returned value. On the other hand, if
the file contains 5 records (ie. 0 to 4), 5 is returned.
The structure of a binary file is just like blocks being stored contiguosly
in a line. Think of boxes being placed one adjacent the other and each
one of them has data. There is a space between this boxes that indicates
the file positon and we can easily depict this fact below.
0
B
o
o
k
R
e
c
0
1
B
o
o
k
R
e
c
1
2
B
o
o
k
R
e
c
2
3
B
o
o
k
R
e
c
3
4
B
o
o
k
R
e
c
4
^
The first row is the actual file showing the indexes of each record block and the second row
shows the file pointer ie. the file position. The current file position shown in the illustration
above is relevant to Seek(myFile, 1). Now you have been assured that the number 1 record
of a file is not the first record of the file. After the last record, there is an EOF marker that
indicates the end of the file and it is not legal to go beyond this point except for only one
position to allow appending ie. Seek(myFile, FileSize(myFile)).
This concludes another lesson from the pascal programming tutorial. See you in the next
lesson!
Lesson 12 - Strings
This lesson will cover:
• Introduction to Strings
• Some Useful String Functions
o Pos
o Copy
o Delete
o Insert
o Concat
o UpCase
o Str
o Val
Introduction to Strings
Maybe you already know what is a string variable from previous
program examples that you have tried, but you don't know what
operations and what functions one can apply to them and how can they
be manipulated in order to obtain another form of string whatsoever.
In this lesson we will cover some important functions that the Pascal
programming language has for us in order to cater for string operations
far more easier to use than you think.
Let's jump into the strings staff straight away. In order to understand
strings, one has to keep in mind that a string is made up of an array of
characters. The string data type is an in-built data type that is an array
of 256 characters (Type String = Packed Array[0..255] of Char).
When stored in memory, the processor should know where the string
starts and where it finishes. In order to know where the string finishes,
in Pascal, the 0th element of a string is defined as the length of the
string. So, if you try to access character 0 of a string, the number of
characters stored in that array is returned, thus letting the processor to
know where the string finishes.
The following example shows some simple string operations.
Var
myString : String;
Begin
myString := 'Hey! How are you?';
Writeln('The length of the string is
',byte(myString[0]));
Write(myString[byte(myString[0])]);
Write(' is the last character.');
End.
Note that in the previous program I have used an automatic data-type
conversion, normally referred to as data type-casting. When typecasting
from one data type to another, all that is happening is simply a
conversion from one data type to another based on the data type in
subject and the wrapping data type to which the old data type is being
converted. In our case, the array variable myString has a special 0th
element storing the number of characters in that array in string format.
This value is an ascii value, so trying to display it without converting it
into a number, the alternative ascii character is displayed. So you have
to change the character value to an ordinary number by wrapping the
variable by another data type, in our case a byte data type (why use
integer? - its all waste of memory and memory consumption).
Note that myString[myString[0]] without having data-type casting
around myString[0] will lead to a compiler error because myString[0] is
a character and not an integer.
Note that to retrieve the length of a string (ie. the number of characters
in a string) there is no need to use the method I showed to you because
its too complicated and unfriendly. Instead, there is the simpler
function, length() which will return the number of characters of the
string in subject. Eg. numOfChars := length(myString);
Some Useful String Functions
There are some basic Pascal functions that has to do with string
operations and so there is no need to write them yourself, and they are
of course quite useful. I will explain all the string functions by describing
what they do and a simple example of each.
Function Pos(SubString : String; S : String) : Byte;
Description
This function will search for the string SubString within the string S. If the sub-string
is not found, then the function would return 0. If on the other hand the sub-string is
found, then the index integer value of the first character of the main string that matches
the character of the sub-string is returned.
Var
S : String;
Begin
S := 'Hey there! How are you?';
Write('The word "How" is found at char index ');
Writeln(Pos('How',S));
If Pos('Why',S) <= 0 then
Writeln('"Why" is not found.');
End.
Function Copy(S : String; Index : Integer; Count : Integer ) :
String;
Description
This function will copy some characters from string S starting from character index
Index and copies as much as Count. The copied string is then returned.
Var
S : String;
Begin
S := 'Hey there! How are you?';
Copy(S, 5, 6); { 'there!' }
Write(S);
End.
Procedure Delete(var S : String; Index : Integer; Count :
Integer );
Description
Deletes a specified number of characters from the string S. The starting position of
deletion is from character index Index. The number of characters that will be deleted is
specified through Count. The new string is passed back through the variable parameter
S.
Var
S : String;
Begin
S := 'Hey Max! How are you?';
Delete(S, 4, 4); { 'Hey! How are you?' }
Write(S);
End.
Procedure Insert(Source : String; var S : String; Index :
Integer);
Description
This function will insert a string of any length into a source string starting from an
index character. The string S will be inserted into string Source starting from the index
character Index. No characters will be deleted from the front except if the resulting
string is longer than 255 characters. In this case, the front characters will be truncated
as to fit a 255-character string.
Var
S : String;
Begin
S := 'Hey! How are you?';
Insert(S, ' Max', 4);
Write(S);
{ 'Hey Max! How are you?' }
End.
Function Concat(s1 [, s2, s3...sn] : String) : String;
Description
Concatenates 2 or more strings depending how long is the argument expression. Try to
make sure not to exceed the limit of 255 characters when concatening strings as it will
result in truncation. This function can also be obtained by using the plus (+) operator
between strings that need to be concatenated.
Var
S1, S2 : String;
Begin
S1 := 'Hey!'
S2 := ' How are you?';
Write(Concat(S1, S2)); { 'Hey! How are you?' }
End.
is the same as
Var
S1, S2 : String;
Begin
S1 := 'Hey!'
S2 := ' How are you?';
Write(S1 + S2); { 'Hey! How are you?' }
End.
Function UpCase(C : Char) : Char;
Description
Converts the character C to uppercase and returned. If the character is already in
uppercase form or the character is not within the range of the lower case alphabet, then
it is left as is.
Var
S : String;
i : Integer;
Begin
S := 'Hey! How are you?';
For i := 1 to length(S) do
S[i] := UpCase(S[i]);
Write(S); { 'HEY! HOW ARE YOU?' }
End.
Procedure Str(Val : Integer / LongInt / Real; var S : String);
Description
Converts an integer or a decimal value to a string. The value parameter Val is
converted into a string and passed through the variable paramter S.
Var
S : String;
i : Real;
Begin
i := -0.563;
Str(i, S);
Write(S);
End.
Procedure Val(S : String; var Val; Code : Integer);
Description
Converts a string to its corresponding numeric value. The string paramater S is
converted into a numeric value and passed back through the variable paramter Val. If
the string to be converted is not a correct numeric value, an error occurs and is returned
via Code. If the conversion is correct then Code is 0.
Var
S : String;
error : Integer;
R : Real;
Begin
S := '-0.563';
Val(S, R, error);
If error > 0 then
Write('Error in conversion.')
Else
Write(R);
End.
Lesson 9 - File Handling
This topic deals on how to:
• Read from a File
• Create and Write to a File
• Append data to an existing File
• Delete Files
• Use the '{$I-},{$I+}' compiler directive
• Create and Remove Sub-Directories
• FileSize() - return the size of the file in bytes
Intro
A file contains data which is saved in the hard disk. You can only view a file from the hard
disk by using an operating system. A can contain text data which is used by word
processors. Many text files are saved in the hard disk with the extensions: *.txt and *.doc.
The file with extension of *.txt, means that it is created by the Microsoft Notepad.
Whenever you use the Microsoft Notepad and save a text file, this saved file is created and
written on to the hard disk. However, some programs have various formats on how to
maintain the text - such as justification, font, font colour. So many files contain more data
other than text data! The program itself uses various techniques to create a file in such a
way that, when it is being read again it can read (using programming skills, etc..) if it is
justified, its font style etc..
The program that is able to read the file of extension *.xxx, is called the viewer of that
file!
Before you go on with files, please make sure that you have enough hard disk space for our
experiments, since I am going to demonstrate to save a file to the hard disk!! :) Only a few
kb, however..
Read from a File (file input)
Reading a file in pascal is very easy. Note that there are no reserved
words in Pascal that are used to to read or write to a file. We used the
'usual words': readln() and writeln(); Here's the technique of how to
read a text file (only):
Program Lesson9_Program1;
Var UserFile : Text;
FileName, TFile : String;
Begin
Writeln('Enter the file name '+
+'(with its full path) of the text file:');
readln(FileName);
{A .txt file will be assigned to a text variable}
Assign(UserFile, FileName, + '.txt');
Reset(UserFile); {'Reset(x)' - means open the file x}
Repeat
Readln(UserFile,TFile);
Writeln(TFile);
Until Eof(UserFile);
Close(UserFile);
Readln;
End.
Program code is updated (13th June 2006)
Details: the Assign()function on line 10 has been changed from Assign(UserFile,
FileName, + '.txt') to Assign(UserFile, FileName + '.txt') because the comma ',' after
'Filename' is a syntax error.
Program Errors corrected thanks to James McNamara
I think that it is worth to take a look at various important lines of the
program. A new variable of type: 'Text' is new to you, and this should
be used whenever you are going to edit a text file! The variable
'FileName' is required to link to the file indicated by the user. The
'assign' statement is used to declare 'FileName' + '.txt' to a text file, so
that the file could be opened, using - 'Reset()'. To read from the first
line to the very last line of the file, you should use the repeat-until loop,
ending the loop with : 'Until Eof(textfile);', which means: 'Until the End
Of File [eof]'.
Create and Write to a File (file output)
The following program is an example of how to create-and-write or
overwrite a file:
Program Lesson9_Program2;
Var FName, Txt : String[10];
UserFile : Text;
Begin
FName := 'Textfile'; Assign(UserFile,'C:\'+FName+'.txt');
{assign a text file}
Rewrite(UserFile); {open the file 'fname' for writing}
Writeln(UserFile,'PASCAL PROGRAMMING');
Writeln(UserFile,'if you did not understand something,');
Writeln(UserFile,'please send me an email to:');
Writeln(UserFile,'victorsaliba@hotmail.com');
Writeln('Write some text to the file:');
Readln(Txt);
Writeln(UserFile,'');
Writeln(UserFile,'The user entered this text:');
Writeln(UserFile,Txt);
Close(UserFile);
End.
In the above program, I am using the 'writeln()' statement so that I
write to the file I have previously assigned to. Note that, since I am
using writeln(), there is no output to the screen, it goes to the file I
initialised.
To check exactly what has just been written to this file, go to C:\, and
see if there is a file named:
Textfile.txt. Open it and see what does it contain!! :-). If you had
problems, or if you did not have a way out, then in the start menu go
to:
start -> find -> files or folders => look in drive C: and enter 'textfile.txt'
in the text box; double click on it.
Append text to an existing File
Writing to an existing file, means, open a file and add extra data, but
not overwrite the file. Some beginner programmers do not actually
understand how to, not overwrite a file with data they would like to
input. This is the common problem:
Var UFile : Text;
Begin
Assign(UFile,'C:\ADDTEXT.TXT');
ReWrite(UFile);
Writeln(UFile,'How many sentences, '+
+'are present in this file?');
Close(UFile);
End.
Copy the program above in a text file editor and save it in the turbo
pascal bin folder as 'example.pas'. Open Turbo Pascal, and run this
program for two times or more. Close Turbo Pascal and find the file
named 'addtext.txt'. Is there more than one sentence?
A new reserved word which works with files, can complete our problem.
The new reserved word is 'append(f)', where f is a variable of type text.
This can be done by simply change the 'Rewrite(UFile)' to
'append(UFile)', and the text file is not overwritten, but appended! The
above program changes to the following:
Var UFile : Text;
Begin
Assign(UFile,'C:\ADDTEXT.TXT');
Append(UFile);
Writeln(UFile,'How many sentences, '+
+'are present in this file?');
Close(UFile);
End.
Run the program two times or more to see the change...
Delete Files
In Pascal, the reserved word used to delete files from the hard this is
the 'Erase(f)' where f is a variable of any data type. This means that 'f'
could be both file and text variable type. Note, that the file you are
about to delete is not taken in the recycle bin, but it is directly kicked off
the hard disk!!
Unlike any other file functions, the erase() function does not open the
file to delete it, so you don't need to apply a 'close(...)' after erase().
Example Program:
Var UFile : Text; { or it could be of 'file' type}
Begin
Assign(UFile,'C:\ADDTEXT.TXT');
Erase (UFile);
End.
The '{$I-},{$I+}' compiler directives
Compiler directives are used to adjust the compiler settings during the
compilation process, so that programmers can control their program in
their preferrable way. Compiler directives are declared using the
symbols '{', '$' and '}'. Note that the braces are used for comments, but
still, '{$something}' is taken to be a directive. Instead of 'something'
the programmer should replace it by a known directive (a letter). Now,
the '{$I}' is used to tell the compiler not to take into consideration I/O
errors including file operations. Say, for example, if a file is trying to be
opened, but it does not exist, the program does not stop from executing
and halts with a runtime error, saying: 'File not found' or whatever
boring error! Make sense? So, if you apply this compiler directive before
you open the file, either for writing or reading, I/O errors will not cause
the program to raise a runtime error forced halt.
Now, I must teach you how to use this compiler directive by letting you
know where to put it and how to cater with the error that might occur. It
must be placed where you are going to open or delete a file. ie.:
{$I-}
action on file...
{$I+} { enable the i/o error check again }
It is important to enable again the i/o error check, after you have
disabled it, so that any unknown future errors would be automatically
encountered. However, if you think that it would be better to disable i/o
error checking for the entire program, you can! Just apply the directive
at the beginning and that's it but it is not recommended since during the
runtime of your program you will not be notfied of IO errors that might
occur!! After you control a file action, you must check whether an error
has occured or not by using the system function 'IOResult', which
returns IO error information. This is a typical traditional exception
handling. You should test for errors using the statement:
If (IOResult <> 0) then ...
The IOResult function should be explicitly used after an IO error check
so that it will automatically clear the error flag of the system otherwise,
the IO error cause a 'mutation' to other IO processes resulting into a
runtime error. You are not required to grasp each word perfectly from
what I said. The most important thing is that you include that statement
if the IO directives are to be used and everything would be fine. Now I
should show you how to use it by an example:
Program Lesson9_Program3;
Uses Crt;
Var t : Text;
s : String;
Begin
Assign(t,'C:\ABC.DEF');
{$I-} { disable i/o error checking }
Reset(t);
{$I+} { enable again i/o error checking - important }
If (IOResult <> 0) then
Begin
Writeln('The file required to be opened is not found!');
Readln;
End Else
Begin
readln(t,s);
Writeln('The first line of the file reads: ',s);
Close(t);
End;
End.
If the required file is found the IOResult returns a 0 value, meaning no
errors; ELSE if not found (IOResult returns a non-0 value) display an
error message!
IMPORTANT: if the file is successfuly found, the file is opened and you
should close it as shown in the program above. However, if it is not
found, the common sense says that it couldn't be opened because it is
not found!?! So, you should not include a 'close(..)' after it is not opened
and this is done conditionally as shown in the example. Study carefully
my program and run it several times with good paths and non-good
ones to see well the difference and how does the compiler directive
works!!
Hopefully, the compiler directive could be applied to different functions,
similarly as in the program above. You can use it with 'rewrite()',
'append()', 'erase()', and also 'FSearch()'. You can try as many
programs as you wish and hopefully practicing the IO directive. I know,
that this directive is somewhat complex and hard to be understood but
undoubtedly useful! I am there waiting for your e-mails, if you think that
your program does not work properly when using this directive.
Create and Remove Sub-Directories
In Pascal, there are functions with which you can either create or
remove a directory from the hard disk. To create a directoy, we use the
function 'createdir(c)' where 'c' is of type PChar. Ohh, that's sound
kinky... What the heck does PChar means? Hehe, PChar is a pointer
variable which holds the address of a dynamic variable of a specified
type. It is sort of a pointer for characters. Before you create the
directory, however, you have to check if the directory exists, else a
runtime error shows up fiddling in front of your monitor!! :-) The
directory is created as follows:
NewDir := FSearch('C:\Pascal Programming',GetEnv(''));
if NewDir = '' then CreateDir('C:\Pascal Programming');
From only two lines of code, we have been able to create a dir. But,
before you go experimenting on your own, you should strictly read the
following documented example: (I will explain in detail the 'FSearch()'
function)
Program Lesson9_Program4;
Uses WinDos, Dos;
{ note the inclusion of the 'windos.tpu' library }
Var NewDir : PathStr;
{ for searching the dir and create a new one,
if it does not exist }
F : Text;
Begin
{ search for the dir }
NewDir := FSearch('C:\Pascal Programming', GetEnv(''));
{ create a new one, if it does not exist }
if NewDir = '' then CreateDir('C:\Pascal Programming');
Assign(F,'C:\Pascal Programming\pprogramming.txt');
{$I+} ReWrite(F); {$I-} { disable and enable back again
i/o error checking }
{ write to text file }
Writeln(F,'http://pascalprogramming.byethost15.com/');
{$I+} Close(F); {$I-}
End.
The variable type, 'PathStr', is new to you, and this is a variable defined
in the 'dos.tpu' library. So, you have to include the 'dos' library at the
beginning of your program. The 'FSearch()' function is implemented also
in the windos library to search in a dir list. So, it was useful in our
program and any other program to search if the dir exists or not. It's
not important to know exactly what does 'GetEnv()' mean, which is
found in the second parameter of FSearch(). The Borland Turbo Pascal
reference says that its function is to return the value of the specified
function. Note that 'FSearch()' is implemented in the 'dos.tpu' library,
while CreateDir()' is implemented in the 'windos.tpu' library.
To remove a directory, it is quite simple. Just add 'remove()' at the end
of your program! :-) Your operating system will automatically erase the
dir if it exists. It doesn't matter if you 'remove' a dir which does not
exist. Hopefully, no runtime errors, will show up! The 'remove(Pch)'
function is also implemented in the windos library, where 'Pch' is a
variable of type PChar, again.
FileSize() - Return the value of a file in bytes
Now, for the fun stuff!! To return the size of a file, simply declare a
variable of 'longint' type, and assign it to the filesize of the file. A file
variable of type byte, should be assigned to the file which you would like
to return its size, using 'assign()'.
Program Lesson9_Program4;
Var f : file of byte; { file var of type byte }
sz : longint; { var for the size }
Begin
Assign(f,'C:\anyfile.txt');
{$I-} Reset(f); {$I+}
f (IOResult <> 0) then
Begin { file found? }
Writeln('File not found.. exiting');
Readln;
End Else
Begin
{ Return the file size in Kilobytes }
sz := round(FileSize(f)/1024);
Writeln('Size of the file in Kilobytes: ',sz,' Kb');
Readln;
Close(f);
End;
End.
Lesson 8 - BGI Graphics
If you feel that Graphics is not important for you than skip to lesson 9 (File Handling). BGI
Graphics is an advanced topic and need not be explicitly covered. It depends on your
preference. Graphics lovers will surely be interested in this topic.
This lesson will cover:
• Introduction to Graphics
• Initialising Graphics
• Graphics Statements
• Advanced Graphics Statements
One might require the file egavga.bgi during this graphics tutorial. Click here if you don't
have this file (or it is corrupt) and place it in the BGI directory in the Turbo Pascal
installation folder.
COPYRIGHT NOTICE: It is assumed that you have bought Turbo Pascal once you have
downloaded this file. This file is owned by its respective owners (Borland Company).
IMPORTANT DISCLAIMER: You will download and use this file at your own risk. We
don't take any responsability for any damage whatsoever.
Introduction to Graphics
Graphics is a method of representing output material in a more complex, user-friendlier
way than the crt. The crt is one of the few turbo pascal units or libraries. Turbo Pascal has a
graphics library with which you can represent output material. Before you can call turbo
pascal's graphics procedures and functions, you have to include the Graph unit in the Uses
section (Eg. Uses Crt, Graph, Overlay, Printers etc...).
Initialising Graphics
Unlike the crt, graphics should be initialised, and it should be initialised at the beginning of
the program or just before you start using graphics procedures and functions. This will help
the compiler to link to the graphics file. Usually, the default graphics routines used by the
Turbo Pascal's compiler is the EGAVGA.BGI. When you initialise the graphics,
automatically your computer will use this file to output graphics material.
The famous piece of code, used to initialise the graphics in Turbo Pascal (NOT Dev-
PASCAL! Mind you! Dev-Pascal does not accept the graph driver and graph mode be
declared as integer values. If you have Dev-Pascal then change all the variable types of the
'gd,gm' to smallint! 'Gd, Gm : Smallint;') is shown below:
Program Lesson8_Program1;
Uses Crt,Graph;
Var GraphicsDriver, GraphicsMode,
ErrCode : Integer;
{two var's are needed for initialisation}
Begin
Writeln('Initialising Graphics, please wait...');
GraphicsDriver := Detect;
InitGraph(GraphicsDriver, GraphicsMode,'');
{IMPORTANT, read the following or
otherwise graphics will not work!! ;)}
(*between the inverted commas,
type in the path of the graphics BGI file
(usually 'C:\TP\BGI'),
OR
change the dir in the file menu (PRESS Alt+F)
and roll down your mouse pointer to the 'change dir'
menu; then either type the path to the BGI file,
or go to C: -> TP -> BGI*)
ErrCode := GraphResult;
If GraphResult <> grOK then { <> means 'not equal to' }
Begin
ClrScr;
Writeln('Graphics error occured: ',
GraphErrorMsg(ErrCode));
Writeln('If a file not found error is displayed
above');
Writeln('then, change the dir from the current');
Writeln('location to C:\ -> TP -> BGI, '+
+'from the file menu!');
Readln;
Halt(1);
End Else
Begin
Randomize;
SetColor(Random(15) + 1); {Set text colour}
{Output text at 20 pixels from the top of the screen,
and 20 other from the left side of the screen.}
OutTextXY(20,20,'Welcome to the new generation
of Pascal Programming:');
OutTextXY(20,30,'Pascal Graphics!!');
OutTextXY(25,70,'You will learn more
graphics procedures and');
OutTextXY(25,80,'functions, later in this lesson :-)');
Readln;
End;
CloseGraph;
End.
The program above uses the statement:
InitGraph(GraphicsDriver,GraphicsMode,'');
You may find it strange what does the two inverted commas (' ') mean,
in the statement shown above. It is the path which redirects the turbo
pascal linker to the graphics BGI file. So, in between the inverted
commas, you have to enter the path to the graphics driver, or otherwise
you will receive an error message. You may leave it blank and let the
compiler himself find the BGI file automatically (in the current
directory), but when I did this, it never worked!! :-) If you did not
change the folder address (C:\TP) after the installation, you may use
this path: 'C:\TP\BGI', like this:
InitGraph(GraphicsDriver,GraphicsMode,'C:\TP\BGI');
After the 'initgraph()' statement, you should inform the user with the
problem concerning a graphics error, if the EGAVGA.BGI file is not
found. Hope it does not happen to you :-) !! Then, if the user is errorfree,
then you can start calling graphics procedures and functions from
the graphics library (graph). In the example program above, I used
only the 'OutTextXY()' statement and the 'SetColor()' statement.
However there are many more functions other than these!
At the end of each graphic statments, you have to close the graphics
section, by using the 'CloseGraph' statement.
USEFUL INFORMATION:
Note that the screen resolution is 640 by 480 pixels (compare this with
that of the CRT! - the CRT has a screen resolution of 80 by 25 'pixels'
only!)
Graphics Statements
Learning graphics, is very simple - all you have to learn is how to
initialise graphics and then use your graphics knowledge to display
whatever you want! Now, the following statements are found in the
graph unit which are used to output graphically. Then I will show you an
example program using the graph unit, to demonstrate how the
statments below work:
Statement
Descri
ption
Example
SetBkColor(colour/
colour code);
This
will set
the
backgr
ound
colour
of the
screen
to the
colour
indicat
ed
within
the
parent
hesis.
SetBkColor(Brown);
or
SetBkColor(6);
SetColor(colour/col
our code);
This
will set
the
text
colour
to the
colour
indicat
ed
within
the
parent
SetColor(Green); or
SetColor(2);
hesis.
OutText('');
This
statem
ent will
output
the
text
indicat
ed
within
the
inverte
d
comma
s.
OutText('BGI
Graphics');
OutTextXY(X,Y,'');
This is
very
similar
to the
one
before
this
statem
ent,
except
in that
it move
the
cursor
positio
n
indicat
ed as
shown
OutTextXY(300,100
,'BGI Graphics');
MoveTo(X,Y);
Takes
the
cursor
positio
n to
that
indicat
ed in
the
bracket
s.
MoveTo(GetMaxX,G
etMaxY);
PutPixel(X,Y,colour Places PutPixel(50,128,Cya
/colour code); a small
pixel at
X
pixels
left and
Y pixels
down.
n); or
PutPixel(50,128,5);
Line(X,Y);
Draws
a line
from
the
positio
n of
the
cursor
to X, Y.
Line(30,111);
LineTo(X1,Y1,X2,Y
2);
Draws
a line
from
X1, Y1
to X2,
Y2.
LineTo(0,0,
GetMaxX,GetMaxY);
Rectangle(X1,Y1,X
2,Y2);
Draws
a
rectang
le from
point
X1, Y1
to
point
X2, Y2.
Rectangle(30,50,25
,45);
Circle(X,Y,Radius);
Draws
a circle
from
point
X, Y
with a
radius
length
of
Radius.
Circle(GetMaxX Div
2, GetMaxY Div 2,
100);
Ellipse(X,Y,P,Q,Hor
R,VerR);
Draws
an
ellipse
with
Ellipse(300,160,
0,360,60,40);
centre
point
X,Y
startin
g from
P
degree
s to Q
degree
s, with
a
horizon
tal
radius
of HorR
and a
vertical
radius
of
VerR.
Arc(X,Y,P,Q,Radius
);
Draws
an arc
startin
g from
X,Y
startin
g with
an
angle
of
Pdegre
es and
ending
with an
angle
of Q
degree
s, with
radius
Radius.
Arc(100,200,0,90,7
0);
PieSlice(X,Y,P,Q,Ra
dius);
Similar
to the
arc();,
except
in that
it is a
PieSlice(90,150,20,
95,100);
pie.
Bar(X1,Y1,X2,Y2);
Draws
a bar
filled
with
the
current
colour,
startin
g from
X1, X2
to Y1,
Y2.
Bar(50,100,150,50
0);
Bar3D(X1,Y1,X2,Y2
,
Depth,ThreeD_Top
);
Similar
to the
one
above,
except
in that
it is
3D.
The
last
parame
ter
indicat
es the
3D top
of the
3D Bar.
Bar3D(120,100,250
, 150,50,TopOn);
Below is a really fantastic graphics program, which uses most of the
graphics statements above. If you could not run the program because of
a graphics error, then send me an e-mail and I will help you how to do
so. But first of all, try the path of the BGI file as shown above. You can
download or copy this program:
Program Lesson8_Program2;
{Author: Victor J. Saliba}
{victorsaliba@hotmail.com}
{Website: http://pascalprogramming.byethost15.com/}
Uses Crt,Graph;
Var Gd, Gm,
Radius, Grow, IncP, IncQ : Integer;
DecrP, DecrQ : Boolean;
Begin
Gd := Detect;
InitGraph(Gd, Gm, '');
{Do not forget to change the dir path}
{Try C:\TP\BGI}
if GraphResult <> grOk then
Halt(1);
Randomize;
SetColor(Random(15)+1);
{In the following loop, 600 circles:
circles with different radii are
drawn. Everytime the loop is repeated,
the radius increases by
one, and thus the circle becomes +1
larger than the previous one.}
For Radius := 1 to 600 do
Begin
Circle(GetMaxX Div 2, GetMaxY Div 2, Radius);
Delay(1);
End;
ClearViewPort;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(230,GetMaxY Div 2,'Prepare for another
one...');
Delay(1000);
ClearViewPort;
Grow := 0;
{The ellipse loop, is similar to the one
above except in that the vertical
radius increases by 1}
For Radius := 1 to 600 do
Begin
Inc(Grow);
Ellipse(GetMaxX Div 2,
GetMaxY Div 2, 0, 360,
GetMaxX Div 2, Radius + Grow);
Delay(1);
End;
ClearViewPort;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(230,GetMaxY Div 2,'Now what?'); Delay(1000);
ClearViewPort;
{Here's another graphics invention of mine! Similar
to the first one, but using two circles positioned
on both edges of the screen,
continously increasing in size}
For Radius := 1 to 600 do
Begin
Circle(GetMaxX Div 2, 0, Radius);
Circle(GetMaxX Div 2, GetMaxY, Radius);
Delay(2);
End;
Delay(1000);
ClearViewPort;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(230,GetMaxY Div 2,'What are you lookin'' at?');
Delay(1000);
ClearViewPort;
Grow := 0;
{Below is a simple rectangle loop,
which inreases its size by 1
(increment x1,y1 and decrement x2,y2)}
For Radius := 1 to 600 do
Begin
Inc(Grow);
Rectangle(((GetMaxX Div 2) - Radius) - Grow,
((GetMaxY Div 2) - Radius)- Grow,
((GetMaxX Div 2) + Radius) + Grow,
((GetMaxY Div 2) + Radius) + Grow);
Delay(2);
End;
ClearDevice;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(230,GetMaxY Div 2,
'Rotor of a helicopter thorn apart..');
Delay(2000);
ClearDevice;
{The demonstration below shows 4 rotating sectors,
moving horizontally,
and 4 other sectors in the opposite direction}
IncP := 0; IncQ := 0;
For Radius := 1 to 320 do
Begin
Inc(IncQ, 1);
Inc(IncP, (IncQ Div 2));
PieSlice(GetMaxX Div 2 + IncP,
GetMaxY Div 2, 0 + IncP, 2 + IncP, 240);
PieSlice(GetMaxX Div 2 + IncP,
GetMaxY Div 2, 180 + IncP, 182 + IncP, 240);
PieSlice(GetMaxX Div 2 + IncP,
GetMaxY Div 2, 88 + IncP, 90 + IncP, 240);
PieSlice(GetMaxX Div 2 + IncP,
GetMaxY Div 2, 268 + IncP, 270 + IncP, 240);
PieSlice(GetMaxX Div 2 - IncP,
GetMaxY Div 2, 45 + IncP, 47 + IncP, 240);
PieSlice(GetMaxX Div 2 - IncP,
GetMaxY Div 2, 135 + IncP, 137 + IncP, 240);
PieSlice(GetMaxX Div 2 - IncP,
GetMaxY Div 2, 225 + IncP, 227 + IncP, 240);
PieSlice(GetMaxX Div 2 - IncP,
GetMaxY Div 2, 315 + IncP, 317 + IncP, 240);
Delay(10);
ClearDevice;
If IncP >= 220 then
Dec(IncQ, 4);
End;
ClearViewPort;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(230,GetMaxY Div 2,'Ah, now it is repaired..');
Delay(2000);
ClearDevice;
{The next demonstration shows a fantastic
rotor-like movement animation}
{Do not be amazed by the coding below - it's very
simple}
{To make such animation, all you
have to do is to make a sector rotating
by simply increasing its degrees and clear the old one}
IncP := 0; IncQ := 0;
For Radius := 1 to 320 do
Begin
Inc(IncQ, 1);
Inc(IncP, (IncQ Div 4));
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 0 + IncP, 2 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 180 + IncP, 182 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 90 + IncP, 92 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 270 + IncP, 272 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 45 + IncP, 47 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 135 + IncP, 137 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 225 + IncP, 227 + IncP, 240);
PieSlice(GetMaxX Div 2,
GetMaxY Div 2, 315 + IncP, 317 + IncP, 240);
Delay(10);
ClearDevice;
End;
SetTextJustify(230, GetMaxY Div 2);
OutTextXY(220,GetMaxY Div 2,'The chop is on its way!');
Delay(1000);
ClearDevice;
Randomize;
IncP := Random(GetMaxX) + 1;
IncQ := 0;
DecrP := False;
DecrQ := False;
For Radius := 1 to MaxInt do
Begin
If not(DecrP) then Inc(IncP,3) Else
If DecrP then Dec(IncP,3);
If not(DecrQ) then Inc(IncQ,3) Else
If DecrQ then Dec(IncQ,3);
SetColor(LightCyan);
{Now FillCircle! - same radii (20)}
FillEllipse(IncP,IncQ, 20, 20);
Circle(IncP, IncQ, 40);
PieSlice(IncP, IncQ, 0 + (IncP * 80),
6 + (IncP * 80), 100);
PieSlice(IncP, IncQ, 180 + (IncP * 80),
186 + (IncP * 80), 100);
PieSlice(IncP, IncQ, 90 + (IncP * 80),
96 + (IncP * 80), 100);
PieSlice(IncP, IncQ, 270 + (IncP * 80),
276 + (IncP * 80), 100);
If IncP > GetmaxX then DecrP := True Else
If IncP < 0 then DecrP := False;
If IncQ > GetmaxY then DecrQ := True Else
If IncQ < 0 then DecrQ := False;
Delay(10);
ClearDevice; {Try to remove this :-)}
If KeyPressed then Break;
End;
ReadKey;
SetTextStyle(SansSerifFont,HorizDir,1);
SetUserCharSize(2,1,5,1);
OutTextXy(12,20,'Was it fun? Ehh???');
SetUserCharSize(1,1,2,1);
SetColor(LightCyan);
OutTextXY(35,190,'Now you can try to do it yourself.');
OutTextXY(20,240,'If you have any comments then send');
OutTextXY(180,300,'me an e-mail to');
OutTextXY(120,400,'victorsaliba@hotmail.com');
Readln;
CloseGraph;
End.
Have you successfully ran the program above? How's it? There are many
different animations! I used some statements which you are'nt still
familiar with. But, sooner or later, you will get to know how to use them
and know their function.
Advanced Graphics Statments
There are many other graphics procedures and functions, which do not
draw graphic objects, but manipulate the format of the graphic objects
you draw. For example, if I want to fill a circle with a colour, it's like
this:
Circle(GetMaxX Div 2, GetMaxY Div 2, 60);
FillEllipse(GetMaxX Div 2, GetMaxY Div 2, 60, 60); {Note the radii}
The command 'FillEllipse' will fill the circle with the current colour. Take
a look at the table below:
Statement
Descr
iptio
n
Example
SetFillStyle(Pa
ttern, Colour);
Chang
es the
style
of the
filling
of an
object
. It
can
only
be
used
with
bar/b
ar3d
and
pieslic
e. It
has
13
differe
nt fill
styles
.
SetFillStyle(XHatchFill
,LightCyan);
OR
SetFillStyle(10,3);
SetUserCharSi
ze(MultX,
DivX, MultY,
DivY);
Displa
y the
text
in a
larger
or
small
er
size.
SetUserCharSize(5,1,
3,1);
SetTextStyle(
Font,
Direction,
Size);
Displa
y text
using
the
font
style,
orient
ation
and
size
indica
ted as
shown
.
SetTextStyle(TriplexF
ont, HorizDir,2);
ClearViewPort
;
Clears
the
active
scree
n
page.
ClearViewPort;
GetDriverNam
e
Get
the
driver
name
being
curre
ntly
used.
OutText('Using
driver:' +
GetDriverName);
It is useful to try to run the program below yourself so as to understand
the meaning of several reserved words included in certain functions,
such as:
SetTextStyle(SansSerifFont,VertDir,2);
OR
Bar3D(40,50,60,100,50,TopOn);
Program Lesson8_Program3;
Uses Graph;
Var Gd, Gm: Integer;
Begin
Gd := Detect;
InitGraph(Gd, Gm, ' ');
if GraphResult <> grOk then Halt(1);
SetTextStyle(TriplexFont, HorizDir, 1);
SetUserCharSize(2,1,10,1);
SetTextJustify(CenterText, CenterText);
OutTextXY(GetMaxX Div 2,200,'Is it big enough?');
readln;
ClearViewPort;
SetTextStyle(SmallFont, VertDir, 5);
SetTextJustify(LeftText,CenterText);
OutTextXY(200,250,'VertDir (vertical) Direction.
Do you understand now??');
Readln;
ClearViewPort;
Bar3d(150,80,450,330,50,TopOn);
SetTextStyle(SansSerifFont, HorizDir, 2);
SetColor(LightRed);
OutTextXY(130,410,'BAR3D(150,80,350,330,50,TopOn);');
Readln;
ClearViewPort;
Bar3d(150,80,450,330,50,TopOff);
SetColor(LightGreen);
OutTextXY(130,410,'BAR3D(150,80,450,330,50,TopOff);');
Readln;
ClearViewPort;
OutTextXY(130,380,'SetFillStyle(BkSlashFill,7);');
SetFillStyle(BkSlashFill,7);
Bar3d(150,80,450,330,50,TopOn);
OutTextXY(130,410,'BAR3D(150,80,450,330,50,TopOn);');
Readln;
ClearViewPort;
OutTextXY(130,380,'SetFillStyle(XHatchFill,6);');
SetFillStyle(XHatchFill,6);
Bar3d(150,80,450,330,50,TopOn);
OutTextXY(130,410,'BAR3D(150,80,450,330,50,TopOn);');
Readln;
CloseGraph;
End.
This is just the beginning of the graphics adventure. If you would like to
be a guru in graphics, just keep on practicing and produce only
graphical programs.