View source for Pascal Programming/Routines

You do not have permission to edit this page, for the following reason:
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis.
The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
Start of block: 05:35, 21 February 2024
Expiry of block: 05:35, 21 February 2029
Your current IP address is 3.19.69.117. The blocked range is 3.19.0.0/16.
Please include all above details in any queries you make.
If you believe you were blocked by mistake, you can find additional information and instructions in the Stewards Block Wizard.
You can view and copy the source of this page.
In the opening chapter [[Pascal Programming/Beginning#Routines|routines were already mentioned]].
Routines are, as it was described before, reusable pieces of code that can be used over and over again.
Examples of routines are <syntaxhighlight lang="pascal" inline>read</syntaxhighlight>&#8239;/&#8239;<syntaxhighlight lang="pascal" inline>readLn</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>write</syntaxhighlight>&#8239;/&#8239;<syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight>.
You can invoke, ''call'', these routines as many times as you want.
In this chapter you will learn
* how to define your ''own'' routines,
* the difference between a definition and declaration, and
* the difference between functions and procedures.
<!-- Kinds of parameters, especially var parameters, will be explained in the chapter Pointers -->

== Different routines for different occasions ==
Routines come in two flavors.
In Pascal, routines can either replace statements, or they replace a (sub‑)expression.
A routine that can be used where statements are allowed is called a <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight>.
A routine that is called as part of an expression is a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight>.

=== Functions ===
A <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> is a routine that returns a value.
Pascal defines, among others, a function <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight>.
The function <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> takes one <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>-expression as a parameter and returns <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>, depending on the parity of the supplied parameter (in layman terms that means whether it is divisible by&nbsp;2).
Let’s see the function <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> in action:
<syntaxhighlight lang="pascal" highlight="8" style="page-break-inside: avoid;">
program functionDemo(input, output);
var
	x: integer;
begin
	write('Enter an integer: ');
	readLn(x);
	
	if odd(x) then
	begin
		writeLn('Now this is an odd number.');
	end
	else
	begin
		writeLn('Boring!');
	end;
end.
</syntaxhighlight>
<syntaxhighlight lang="pascal" inline>Odd(x)</syntaxhighlight> is pronounced {{nowrap|“odd of x”}}.
First, the expression in parentheses is evaluated.
Here it is simply <syntaxhighlight lang="pascal" inline>x</syntaxhighlight>, the variable’s value to be precise, but a more complex expression is allowed too, as long as it eventually evaluates to an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>-expression.
The ''value'' of this expression, the ''actual parameter'', is then handed to a (in this case invisible) block of code that processes the input, performs some calculations on it, and ''returns'' <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> according to the calculation’s findings.
The function’s returned value is ultimately filled in in place of the function call.
You can, in your mind, read <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>&#8239;/&#8239;<syntaxhighlight lang="pascal" inline>true</syntaxhighlight> in place of <syntaxhighlight lang="pascal" inline>odd(x)</syntaxhighlight>, although this is dynamic depending on the given input.

{{caution
| heading =
| You are only allowed to call functions where you can put an expression. The following program is wrong:
<syntaxhighlight lang="pascal" highlight="3" style="page-break-inside: avoid">
program lostFunction;
begin
	odd(42);
end.
</syntaxhighlight>
Calling a function results in an expression, in this particular case (the value) <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>. But <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> is not a statement. You can only put ''statements'' between <syntaxhighlight lang="pascal" inline>begin</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>end</syntaxhighlight>, no expressions.<ref group="fn">Some dialects of Pascal are not so strict about that: The {{abbr|FPC|FreePascal Compiler}} has the option {{nowrap|<syntaxhighlight lang="pascal" inline>{$extendedSyntax on}</syntaxhighlight>}} which will allow the program above to compile anyway.</ref>
}}

=== Procedures ===
Procedures on the other hand cannot be used as part of an expression.
You can only call procedures where statements are allowed.

{{caution
| heading =
| A routine can either be a function or a procedure. In some programming languages the routine used to retrieve data from the console can be used like a function, but this is not the case in Pascal. The following <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> will not compile:
<syntaxhighlight lang="pascal" highlight="3" style="page-break-inside: avoid">
program strayProcedure(input, output);
begin
	if readLn(input) = '' then
	begin
		writeLn('Error: No input supplied.');
	end;
end.
</syntaxhighlight>
<syntaxhighlight lang="pascal" inline>ReadLn</syntaxhighlight> refers to a <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight> thus it does not return anything, yet at this specific position a value has to be inserted so the <syntaxhighlight lang="pascal" inline>if</syntaxhighlight>‑branch language construct and the equal comparison make sense.
}}

=== Effects ===
A <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight> may use functions, and the other way around.
Do not understand a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> as a mere substitute for an expression.
In the following section we will learn why.

=== Rationale ===
The dichotomy of routines, distinguishing between a <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight> and a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight>, is meant to gently push the programmer to write “clean” programs.
Doing so, a routine does not conceal whether it is just a replacement for a sequence of statements or shorthand for a complex, difficult to write out expression.
This kind of notation works without introducing nasty pseudo types like, for example, <syntaxhighlight lang="c" inline>void</syntaxhighlight> in the C&nbsp;programming language where every routine is a function, but the “invalid” data type <syntaxhighlight lang="c" inline>void</syntaxhighlight> will allow you to make it (in part) behave like a <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight>.

== Definition ==
Defining routines follows a pattern you are already familiar with since your very first <syntaxhighlight lang="pascal" inline>program</syntaxhighlight>.
A <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> is, in some regards, like a ''special'' routine:
You can run it as many times as you want through {{abbr|OS|operating system}}-defined means.
A <syntaxhighlight lang="pascal" inline>program</syntaxhighlight>’s definition looks almost just like a routine’s.

A routine is defined by,
# a header, and
# a block
in that order.
The routine header shows a couple differences depending on whether it is a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight>.
We will first take a look at blocks, since these are the same for both types of routines.

=== Block ===
A ''block'' is the synthesis of a productive part (statements) and (optional) declarations and definitions.
In Standard Pascal (as laid out by the {{abbr|ISO|international organization for standardization}} standard&nbsp;7185) a block has a fixed order:<ref group="fn">The <syntaxhighlight lang="pascal" inline>label</syntaxhighlight>-section has intentionally been omitted.</ref>
# constant definitions (the <syntaxhighlight lang="pascal" inline>const</syntaxhighlight>-section)
# type definitions (the <syntaxhighlight lang="pascal" inline>type</syntaxhighlight>-section)
# variable declarations (the <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section)
# routine declarations and definitions
# sequence ({{nowrap|<syntaxhighlight lang="pascal" inline>begin … end</syntaxhighlight>}}, possibly empty)
All items but the last one, the productive part, are optional.

{{XNote|Sections (<syntaxhighlight lang="pascal" inline>const</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>type</syntaxhighlight>, or <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section) may not be empty. Once you specify a section heading, you have to define/declare at least one symbol in the just started section.}}

In {{abbr|EP|Extended Pascal}}, the fixed order restriction has been lifted.
There, sections and routine declarations and definitions may occur as many times as needed and do not necessarily have to adhere to a particular order.
The consequences are detailed in the [[Pascal Programming/Scopes|chapter “Scopes”]].
For the remainder of this book we will refer to {{abbr|EP|Extended Pascal}}’s definition of ''block'', because all major compilers support this.
Nevertheless, the order defined by Standard Pascal is a good guideline:
It makes sense to define types, before there is a section that may use those types (i.&#8239;e. <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section).

=== Header ===
A routine header consists of
# the word <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight>,
# an identifier identifying this routine,
# possibly a parameter list, and,
# lastly, in the case of functions, the data type of an expression a call to this function results in, the ''result data type''.

The parameter list for routines also defines the data type of every single parameter.
Thus, the header of the function <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> could look like this:
<syntaxhighlight lang="pascal">
function odd(x: integer): Boolean;
</syntaxhighlight>
Take notice of the colon (<syntaxhighlight lang="pascal" inline>:</syntaxhighlight>) after the parameter list separating the function’s result data type.
You can view functions as sort of special variable declaration which also separates an identifier with a colon, except in the case of a function the “variable’s” value is computed dynamically.

''Formal parameters'', i.&#8239;e. parameters in the context of a routine header, are separated by a semicolon.
Consider the following procedure header:
<syntaxhighlight lang="pascal">
procedure printAligned(x: integer; tabstop: integer);
</syntaxhighlight>
Note that every routine header is terminated with a semicolon.

=== Body ===
While the routine header tells the processor (usually a compiler), “Hey, there’s a routine with the following properties: […]”, it is not enough.
You have to “flesh out”, give the routine a ''body''.
This is done in the subsequent block.

Inside the block all parameters can be read as if they were variables.

=== Function result ===
In the sequence of the block defining a function there is automatically a variable of the function’s name.
You have to assign a value exactly one time, so the function, mathematically speaking, becomes defined.
Confer this example:
<syntaxhighlight lang="pascal" highlight="5">
function getRandomNumber(): integer;
begin
	// chosen by fair dice roll,
	// guaranteed to be random
	getRandomNumber := 4;
end;
</syntaxhighlight>
Note that the block did not contain a <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section declaring the variable <syntaxhighlight lang="pascal" inline>getRandomNumber</syntaxhighlight>, but it is already implicitly declared by the function’s header:
Both the name and the data type are part of the function header.

== Declaration ==
A routine declaration happens most of the time implicitly.
Declaring a routine, or in general any identifier, refers to the process of giving the processor (i.&#8239;e. usually a compiler) information in order to correctly interpret your program source code.
This information is not directly encoded in your executable program, but it is implicitly there.
Examples are:
* A variable declaration tells the processor to install proper provisions in order to reserve some memory space. This chunk of memory will be interpreted according to its associated data type. However, neither the variable’s name, nor the data type are in any way stored in your program. Only the processor knows about this information as it is reading your source code file.
* A routine header constitutes a routine declaration (which is usually directly followed by its definition<ref group="fn">The Extended Pascal standard allows so-called “forward declarations” [remote directive]. A forward declaration of a routine is just the declaration, no definition.</ref>). Here again, the information given in a routine header are not stored directly in the executable file, but they ensure the processor (the compiler) will correctly transform your source code.
* Likewise, <syntaxhighlight lang="pascal" inline>type</syntaxhighlight> declarations merely serve the purpose of clean and abstract programming, but those declarations do not end up in the executable program file.<ref group="fn">Some compilers support the generation of non-standardized “run-time type information” (RTTI). By enabling {{abbr|RTTI|run-time type information}}, <syntaxhighlight lang="pascal" inline>type</syntaxhighlight> declarations ''do'' produce data that ''is'' stored in your program.</ref>
Declarations make an identifier known to denote a certain object (“object” mathematically speaking).
Definitions on the other hand will, hence their name, define what this object exactly is.
Whether it is a value of a constant, the value of a variable, or the steps taken in a routine (the statement sequence), data defined through definitions will result in specific code in your executable file, which may vary according to the information given in related declarations;
writing a variable possessing the data type <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> is fundamentally different than writing a value of the type <syntaxhighlight lang="pascal" inline>real</syntaxhighlight>.
The code for properly storing, calculating and retrieving <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>real</syntaxhighlight> values differs, but the computer is not aware of that.
It just performs the given instructions, the circumstance that a certain set of instructions resemble operations on Pascal’s data type <syntaxhighlight lang="pascal" inline>real</syntaxhighlight> for instance is, so to speak, a “coincidence”.

== Calling routines ==
=== Routing ===
Routines are selected based on their signature.
A routine signature consists of
# the routine’s name,
# the data type’s of all arguments, and
# (implicitly) their correct order.
Thus the signature of the function <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> reads <syntaxhighlight lang="pascal" inline>odd(integer)</syntaxhighlight>.
The function named <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> accepts one <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> value as the ''first'' (and only) argument.

{{XNote|In some other programming languages the data type of the returned value also belongs to a routine’s signature. Remember differing definitions of the term ''signature'' should you ever switch between programming languages.}}

=== Overloading ===
Pascal allows you to declare and define routines of the same name, but differing formal parameters.
This is usually called ''overloading''.
When calling a routine there must be exactly one routine of that name that accepts parameters with their corresponding data types.

== Pre-defined routines ==

{| class="wikitable" style="margin: auto; page-break-inside: avoid;
|+ Pascal’s pre-defined functions (excerpt)
! signature
! description
! returned value’s type
|-
| <syntaxhighlight lang="pascal" inline>abs(integer)</syntaxhighlight>
| absolute value of argument
| <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>odd(integer)</syntaxhighlight>
| parity (is given value divisible by two)
| <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>sqr(integer)</syntaxhighlight>
| the value squared
| <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>
|}

== Persistent variables ==
Some compilers, such as the {{abbr|FPC|Free Pascal Compiler}}, allow you to use constants as if they were variables, but different lifetime.
In the following example the “constant” <syntaxhighlight lang="pascal" inline>numberOfInvocations</syntaxhighlight> exists for the entire duration of program execution, but is only accessible in the scope it was declared in.
<syntaxhighlight lang="pascal" highlight="8,9">program persistentVariableDemo(output);
{$ifDef FPC}
	// allow assignments to _typed_ “constants”
	{$writeableConst on}
{$endIf}

procedure foo;
const
	numberOfInvocations: integer = 0;
begin
	numberOfInvocations := numberOfInvocations + 1;
	writeLn(numberOfInvocations);
end;

begin
	foo;
	foo;
	foo;
end.</syntaxhighlight>
The program will print <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>2</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>3</syntaxhighlight> for every call.
Lines&nbsp;2,&nbsp;4, and&nbsp;5 contain specially crafted comments that instruct the compiler to support persistent variables.
These comments are non-standard, yet some are explained in the appendix, [[Pascal Programming/Preprocessor|chapter “Preprocessor Functionality”]].

Note, the concept of typed “constants” is not standardized.
Some [[Pascal Programming/Object oriented|object-oriented programming]] extensions will give nicer tools to implement such behavior as demonstrated above.
We primarily explained the concept of persistent variables to you, so you can read and understand source code by other people.

== Benefit ==
Routines can be used as many times as you want.
They are no tools of mere “text substitution”:
The definition of a routine is ''not'' “copied” to the place where it is called, the call site.
The size of the executable program file remains about the same.

Utilizing routines can also be and usually is beneficial to the development progress of a program.
By splitting up a programming project into smaller ''understandable'' problems you can focus on solving isolated issues as part of the big task.
This approach is known as ''divide and conquer''.
We now ask you to slowly shift toward thinking ''more'' about your programming tasks ''before'' you start typing anything.
You may need to spend more time on thinking about, for example, how to structure a routine’s parameter list.
What information, what parameters, does this routine require?
Where and how can a recurring pattern be generalized through a routine definition?
Identifying such questions needs time and expertise, so do not be discouraged if you are not seeing everything the task’s sample answers show.
You will learn through your mistakes.

Keep in mind, though, routines are no panacea.
There are situations, very specific situations, where you do not want to use routines.
Recognizing those, however, is out this book’s scope.
For the sake of this textbook, and in 99% of all your programming projects you want to use routines if possible.
Modern compilers can even recognize some situations where a routine was “unnecessary”, yet the only gain is that your source code becomes more structured and thus readable, albeit at the expense of being more abstract and therefore complex.<ref group="fn">One such compiler optimization is called [[Wikipedia: Inline expansion|inlining]]. This will effectively copy a routine definition to the call site. [[Wikipedia: Pure function#Compiler optimizations|Pure functions]] even stand to benefit by being defined as isolated functions, provided the compiler does support appropriate optimizations.</ref>

== Tasks ==
{{question-answer
| question = Write a (now infamous) program that writes the word “Mississippi” in large (spanning at least three lines) capital letters. It should become apparent that writing four routines, <syntaxhighlight lang="pascal" inline>printM</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>printI</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>printS</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>printP</syntaxhighlight>, will significantly speed up development.
| answer = An acceptable answer could look like this <syntaxhighlight lang="pascal" style="page-break-inside: avoid;">program mississippi(output);

const
	width = 8;

procedure printI;
begin
	writeLn( '#   ':width);
	writeLn( '#   ':width);
	writeLn( '#   ':width);
	writeLn( '#   ':width);
	writeLn( '#   ':width);
	writeLn;
end;

procedure printM;
begin
	writeLn('#    #':width);
	writeLn('##  ##':width);
	writeLn('# ## #':width);
	writeLn('#    #':width);
	writeLn('#    #':width);
	writeLn;
end;

procedure printP;
begin
	writeLn( '###  ':width);
	writeLn( '#  # ':width);
	writeLn( '###  ':width);
	writeLn( '#    ':width);
	writeLn( '#    ':width);
	writeLn;
end;

procedure printS;
begin
	writeLn('  ###  ':width);
	writeLn(' #   # ':width);
	writeLn('  ##   ':width);
	writeLn('#   #  ':width);
	writeLn(' ###   ':width);
	writeLn;
end;

begin
	printM;
	printI;
	printS;
	printS;
	printI;
	printS;
	printS;
	printI;
	printP;
	printP;
	printI;
end.</syntaxhighlight>
}}
{{newpage}}
<hr class="noprint"/>
<small>Notes:</small>
{{smallrefs|group="fn"}}


{{auto navigation|Enumerations|Expressions and Branches}}
Templates used on this page:
Template:Abbr (edit)
Template:Auto navigation (view source) (semi-protected)
Template:BOOKCATEGORY (view source) (protected)
Template:BookCat (view source) (protected)
Template:BookCat/core (view source) (protected)
Template:BookCat/default (view source) (protected)
Template:Caution (edit)
Template:Dynamic navigation (view source) (semi-protected)
Template:Evalx (view source) (protected)
Template:Mbox (view source) (protected)
Template:NAIVEBOOKNAME (view source) (protected)
Template:Newpage (edit)
Template:Nowrap (view source) (semi-protected)
Template:Nowrap/styles.css (edit)
Template:Page-break (view source) (semi-protected)
Template:Page-break/end (edit)
Template:Print version change (edit)
Template:Question-answer (edit)
Template:Smallrefs (edit)
Template:XNote (edit)
Module:Arguments (edit)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:String (view source) (protected)
Module:TScope (view source) (protected)
Module:Wikilisp (view source) (protected)
Module:Yesno (view source) (protected)
Return to Pascal Programming/Routines.
Retrieved from "https://en.wikibooks.org/wiki/Pascal_Programming/Routines"