View source for Pascal Programming/Strings

The data type <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> is used to store a finite sequence of <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values.
It is a special case of an [[../Arrays|<syntaxhighlight lang="pascal" inline>array</syntaxhighlight>]], but unlike an {{nowrap|<syntaxhighlight lang="pascal" inline>array[…] of char</syntaxhighlight>}} the data type <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> has some advantages facilitating its effective usage.

The data type <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> as presented here is an ''Extended'' Pascal extension, as defined in the {{abbr|ISO|international organization for standardization}} standard 10206.
Due to its high relevance in practice, this topic has been put into the Standard Pascal part of this Wikibook, right after the chapter on [[../Arrays|arrays]].
{{XWarning|Many compilers have a different conception of what constitutes a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>. Consult ''their'' manual for their idiosyncratic differences. Rest assured, the {{abbr|GPC|GNU Pascal compiler}} supports <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> as explained here.}}

== Properties ==
=== Capacity ===
==== Definition ====
The declaration of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> data type always entails a ''maximum capacity'':
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="3">
program stringDemo(output);
type
	address = string(60);
var
	houseAndStreet: address;
begin
	houseAndStreet := '742 Evergreen Trc.';
	writeLn('Send complaints to:');
	writeLn(houseAndStreet);
end.
</syntaxhighlight>
After the word <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> follows a ''positive'' integer number surrounded by parenthesis.
This is not a function call.<ref group="fn">In fact this is a discrimination of, what {{abbr|EP|extended Pascal}} calls “schema”. [[../Schemas|Schemata]] will be explained in detail in the Extensions Part of this Wikibook.</ref>

==== Implications ====
Variables of the data type <syntaxhighlight lang="pascal" inline>address</syntaxhighlight> as defined above will only be able to store ''up to'' <syntaxhighlight lang="pascal" inline>60</syntaxhighlight> independent <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values.
Of course it is possible to store less, or even <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>, but once this limit is set it cannot be expanded.

==== Inquiry ====
<syntaxhighlight lang="pascal" inline>String</syntaxhighlight> variables “know” about their own maximum capacity:
If you use <syntaxhighlight lang="pascal" inline>writeLn(houseAndStreet.capacity)</syntaxhighlight>, this will print <syntaxhighlight lang="text" inline>60</syntaxhighlight>.
Every <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variable automatically has a “field” called <syntaxhighlight lang="pascal" inline>capacity</syntaxhighlight>.
This field is accessed by writing the respective <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variable’s name and the word <syntaxhighlight lang="pascal" inline>capacity</syntaxhighlight> joined by a dot (<syntaxhighlight lang="pascal" inline>.</syntaxhighlight>).
This field is read-only:
You cannot assign values to it.
It can only appear in expressions.

=== Length ===
All <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variables have a current ''length''.
This is the total number of legit <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values every <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variable currently contains.
To query this number, the {{abbr|EP|extended Pascal}} standard defines a new function called <syntaxhighlight lang="pascal" inline>length</syntaxhighlight>:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="8">
program lengthDemo(output);
type
	domain = string(42);
var
	alphabet: domain;
begin
	alphabet := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
	writeLn(length(alphabet));
end.
</syntaxhighlight>
The <syntaxhighlight lang="pascal" inline>length</syntaxhighlight> function returns a non-negative <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> value denoting the supplied string’s length.
It also accepts <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values.<ref group="fn">This functionality is useful if you are handling ''constants'' you or someone might change at some point. Per definition the literal value {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}} is a <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> value, whereas <syntaxhighlight lang="pascal" inline>''</syntaxhighlight> (“null-string”) or <syntaxhighlight lang="pascal" inline>'42'</syntaxhighlight> are string literals. In order to write generic code, <syntaxhighlight lang="pascal" inline>length</syntaxhighlight> accepts all kinds of values that ''could'' denote a finite sequence of <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values.</ref>
A <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> value has by definition a length of&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>.

It is guaranteed that the <syntaxhighlight lang="pascal" inline>length</syntaxhighlight> of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variable will always be less than or equal to its corresponding <syntaxhighlight lang="pascal" inline>capacity</syntaxhighlight>.

=== Compatibility ===
You can copy entire string values using the <syntaxhighlight lang="pascal" inline>:=</syntaxhighlight> operator provided the variable on the {{abbr|LHS|left-hand side}} has the same or a greater [[#Capacity|capacity]] than the {{abbr|RHS|right-hand side}} string expression.
This is different than a regular <syntaxhighlight lang="pascal" inline>array</syntaxhighlight>’s behavior, which would require dimensions and size to match ''exactly''.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="12">
program stringAssignmentDemo;
type
	zipcode = string(5);
	stateCode = string(2);
var
	zip: zipcode;
	state: stateCode;
begin
	zip := '12345';
	state := 'QQ';
	
	zip := state; // ✔
	// zip.capacity > state.capacity
	// ↯ state := zip; ✘
end.
</syntaxhighlight>
As long as no clipping occurs, i.&#8239;e. the omission of values because of a too short capacity, the assignment is fine.

=== Index ===
It is worth noting that otherwise strings are internally regarded as arrays.<ref group="fn">In fact the definition essentially is {{nowrap|<syntaxhighlight lang="pascal" inline>packed array[1..capacity] of char</syntaxhighlight>}}.</ref>
Like a [[../Arrays#Character array|character array]] you can access (and alter) every array element ''independently'' by specifying a valid index surrounded by brackets.
''However'', there is a big difference with respect to validity of an index.
At any time, you are only allowed to specify indices that are within the range <syntaxhighlight lang="pascal" inline>1..length</syntaxhighlight>.
This range may be ''empty'', specifically if <syntaxhighlight lang="pascal" inline>length</syntaxhighlight> is currently&nbsp;<syntaxhighlight lang="pascal" inline>0</syntaxhighlight>.
{{caution
| heading =
| It is ''not'' possible to change the current length by manipulating individual <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> components:
<syntaxhighlight lang="pascal" highlight="9" style="page-break-inside: avoid;">
program stringAccessDemo;
type
	bar = string(8);
var
	foo: bar;
begin
	foo := 'AA';   { ✔  length ≔ 2 }
	foo[2] := 'B'; { ✔             }
	foo[3] := 'C'; { ↯: 3 > length }
end.
</syntaxhighlight>}}

== Standard routines ==
In addition to the [[#Length|<syntaxhighlight lang="pascal" inline>length</syntaxhighlight> function]], {{abbr|EP|extended Pascal}} also defines a few other standard functions operating on strings.

=== Manipulation ===
The following functions return strings.

==== Substring ====
In order to obtain just a part of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> (or <syntaxhighlight lang="pascal" inline>char</syntaxhighlight>) expression, the function {{nowrap|<syntaxhighlight lang="pascal" inline>subStr(stringOrCharacter, firstCharacter, count)</syntaxhighlight>}} returns a sub-string of <syntaxhighlight lang="pascal" inline>stringOrCharacter</syntaxhighlight> having the non-negative length <syntaxhighlight lang="pascal" inline>count</syntaxhighlight>, starting at the positive index <syntaxhighlight lang="pascal" inline>firstCharacter</syntaxhighlight>.
It is important that {{nowrap|<syntaxhighlight lang="pascal" inline>firstCharacter + count - 1</syntaxhighlight>}} is a valid character index in <syntaxhighlight lang="pascal" inline>stringOrCharacter</syntaxhighlight>, otherwise the function causes an error.<ref group="fn">This means, in the case of ''empty'' strings, ''only'' the following function call ''could'' be legal {{nowrap|<syntaxhighlight lang="pascal" inline>subStr('', 1, 0)</syntaxhighlight>}}. It goes without saying that such a function call is very useless.</ref>
{{Code:Output
| Let’s have a look at it in action:
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="3">program substringDemo(output);
begin
	writeLn(subStr('GCUACGGAGCUUCGGAGUUAG', 7, 3));
	{ char index:   1  4  7  … }
end.</syntaxhighlight>
| <syntaxhighlight lang="text">GAG</syntaxhighlight>
| Pay particular attention to the <syntaxhighlight lang="pascal" inline>firstCharacter</syntaxhighlight> index. Here we wanted to extract the ''third'' codon. However, <syntaxhighlight lang="pascal" inline>firstCharacter</syntaxhighlight> is not simply {{nowrap|<syntaxhighlight lang="pascal" inline>2 * 3</syntaxhighlight>}} but {{nowrap|<syntaxhighlight lang="pascal" inline>2 * 3 + 1</syntaxhighlight>}}. Indexing characters in a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> variable start at&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>. Note, a ''sophisticated'' implementation for encoding codons would ''not'' make use of <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>, but define a custom [[../Enumerations|enumeration data type]].
}}

For ''<syntaxhighlight lang="pascal" inline>string</syntaxhighlight>''-variables, the <syntaxhighlight lang="pascal" inline>subStr</syntaxhighlight> function is the same as specifying <syntaxhighlight lang="pascal" inline>myString[firstCharacter..firstCharacter+count]</syntaxhighlight>.<ref group="fn">The string variable may not be <syntaxhighlight lang="pascal" inline>bindable</syntaxhighlight> when using this notation.</ref>
Evidently, if the <syntaxhighlight lang="pascal" inline>firstCharacter</syntaxhighlight> value is some ''complicated'' expression, the <syntaxhighlight lang="pascal" inline>subStr</syntaxhighlight> function should be preferred to prevent any programming mistakes.
{{Code:Output
| However this syntax of a range index can be used not just as values in expressions, but also to ''overwrite'' parts of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>.
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="6">program substringOverwriteDemo(output);
var
	m: string(35);
begin
	m := 'supercalifragilisticexpialidocious ';
	m[21..35] := '-yadi-yada-yada';
	writeLn(m);
end.</syntaxhighlight>
| <syntaxhighlight lang="text">supercalifragilistic-yadi-yada-yada</syntaxhighlight>
| Note that the first assignment contains a trailing blank. [[#Index|As emphasized above]], you cannot use this syntax to alter the length of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>.
}}

Furthermore, the third parameter to <syntaxhighlight lang="pascal" inline>subStr</syntaxhighlight> can be omitted:
This will simply return ''the rest'' of the given ''<syntaxhighlight lang="pascal" inline>string</syntaxhighlight>'' starting at the position indicated by the second parameter.<ref group="fn">Omitting the third parameter in the case of empty strings or characters is not allowed. {{nowrap|<syntaxhighlight lang="pascal" inline>subStr('', 1)</syntaxhighlight>}} is illegal, because there is no “character&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>” in an empty string. Also, {{nowrap|<syntaxhighlight lang="pascal" inline>subStr('Z', 1)</syntaxhighlight>}} is not allowed, because <syntaxhighlight lang="pascal" inline>'Z'</syntaxhighlight> is a <syntaxhighlight lang="pascal" inline>char</syntaxhighlight>-expression and as such always has a length of&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>, rendering any need for a “give me the rest of/''subsequent'' characters of” function obsolete.</ref>

==== Remove trailing spaces ====
The <syntaxhighlight lang="pascal" inline>trim(source)</syntaxhighlight> function returns a copy of <syntaxhighlight lang="pascal" inline>source</syntaxhighlight> without any ''trailing'' space characters, i.&#8239;e. {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}.
In {{abbr|LTR|left-to-right}} scripts any blanks to the right are considered insignificant, yet in computing they take up (memory) space.
It is advisable to prune strings before writing them, for example, to a disk or other long-term storage media, or transmission via networks.
Concededly memory requirements were a more relevant issue prior to the 21<sup>st</sup> century.

=== First occurrence of substring ===
The function {{nowrap|<syntaxhighlight lang="pascal" inline>index(source, pattern)</syntaxhighlight>}} finds the first occurrence of <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight> in <syntaxhighlight lang="pascal" inline>source</syntaxhighlight> and returns the starting index.
All characters from <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight> match the characters in <syntaxhighlight lang="pascal" inline>source</syntaxhighlight> ''at'' the returned offset:
{| class="wikitable" style="text-align: center; margin: auto;"
| &nbsp; || 1 || 2 || 3 || ✘
| colspan="4" | &nbsp;
|-
! <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| colspan="4" | &nbsp;
|-
| colspan="2" | &nbsp;
| 1 || 2 || 3 || ✘
| colspan="2" | &nbsp;
|-
! <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight>
| &nbsp;
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| colspan="3" | &nbsp;
|-
| colspan="3" | &nbsp;
| 1 || 2 || 3 || ✔ || &nbsp;
|-
! <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight>
| colspan="2" | 
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
| colspan="2" | &nbsp;
|-
! <syntaxhighlight lang="pascal" inline>source</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>Z</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>
| '''<syntaxhighlight lang="pascal" inline>X</syntaxhighlight>'''
| '''<syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>'''
| '''<syntaxhighlight lang="pascal" inline>X</syntaxhighlight>'''
| <syntaxhighlight lang="pascal" inline>Y</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>X</syntaxhighlight>
|-
|
| 1 || 2 || '''3''' || 4 || 5 || 6 || 7
|-
|+ <syntaxhighlight lang="pascal" inline>index('ZYXYXYX', 'XYX')</syntaxhighlight> returns <syntaxhighlight lang="pascal" inline>3</syntaxhighlight>
|}
Note, to obtain the second or any subsequent occurrence, you need to use a proper [[#Substring|substring]] of the <syntaxhighlight lang="pascal" inline>source</syntaxhighlight>.

Because the “empty string” is, mathematically speaking, present ''everywhere'', {{nowrap|<syntaxhighlight lang="pascal" inline>index(characterOrString, '')</syntaxhighlight>}} always returns <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>.
Conversely, because any non-empty string cannot occur in an empty string, {{nowrap|<syntaxhighlight lang="pascal" inline>index('', nonEmptyStringOrCharacter)</syntaxhighlight>}} always returns&nbsp;<syntaxhighlight lang="pascal" inline>0</syntaxhighlight>, in the context of strings an otherwise invalid index.
The value ''zero'' is returned if <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight> does not occur in <syntaxhighlight lang="pascal" inline>source</syntaxhighlight>.
This will always be the case if <syntaxhighlight lang="pascal" inline>pattern</syntaxhighlight> is ''longer'' than <syntaxhighlight lang="pascal" inline>source</syntaxhighlight>.

=== Operators ===
The {{abbr|EP|extended Pascal}} standard introduced an additional operator for strings of any length, including single characters.
The <syntaxhighlight lang="pascal" inline>+</syntaxhighlight> operator ''concatenates'' two strings or characters, or any combination thereof.
Unlike the arithmetic <syntaxhighlight lang="pascal" inline>+</syntaxhighlight>, ''this'' operator is ''non''-commutative, that means the ''order'' of the operands matters.
{| class="wikitable" style="text-align: center; margin: auto;"
! expression !! result
|-
| {{nowrap|<syntaxhighlight lang="pascal" inline>'Foo' + 'bar'</syntaxhighlight>}}
| <syntaxhighlight lang="pascal" inline>'Foobar'</syntaxhighlight>
|-
| {{nowrap|<syntaxhighlight lang="pascal" inline>'' + ''</syntaxhighlight>}}
| <syntaxhighlight lang="pascal" inline>''</syntaxhighlight>
|-
| {{nowrap|<syntaxhighlight lang="pascal" inline>'9' + chr(ord('0') + 9) + ' Luftballons'</syntaxhighlight>}}
| {{nowrap|<syntaxhighlight lang="pascal" inline>'99 Luftballons'</syntaxhighlight>}}
|-
|+ concatenation samples
|}
Concatenation is useful if you intend to save the data somewhere.
Supplying concatenated strings to routines such as <syntaxhighlight lang="pascal" inline>write</syntaxhighlight>/<syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight>, however, may possibly be disadvantageous:
The concatenation, especially of long strings, first requires to allocate enough memory to accommodate for the entire resulting string.
Then, all the operands are ''copied'' to their respective location.
This takes time.
Hence, in the case of <syntaxhighlight lang="pascal" inline>write</syntaxhighlight>/<syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight> it is advisable (for very long strings) to use their capability of accepting an ''infinite'' number of (comma-separated) parameters.
{{hidden|Procedural equivalent|Note, the common {{abbr|LOC|line of code}}
<syntaxhighlight lang="pascal">
stringVariable := 'xyz' + someStringOrCharacter + …;
</syntaxhighlight>
is equivalent to
<syntaxhighlight lang="pascal">
writeStr(stringVariable, 'xyz', someStringOrCharacter, …);
</syntaxhighlight>
The latter is particularly useful if you also want to pad the result or need some conversion.
Writing <syntaxhighlight lang="pascal" inline>foo:20</syntaxhighlight> (minimum width of <syntaxhighlight lang="pascal" inline>20</syntaxhighlight> characters possibly padded with spaces {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}} to the left) is only acceptable using <syntaxhighlight lang="pascal" inline>write</syntaxhighlight>/<syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight>/<syntaxhighlight lang="pascal" inline>writeStr</syntaxhighlight>. <syntaxhighlight lang="pascal" inline>WriteStr</syntaxhighlight> is an {{abbr|EP|extended Pascal}} extension.}}
The {{abbr|GPC|GNU Pascal compiler}}, the {{abbr|FPC|Free Pascal compiler}} and Delphi are also shipped with a function <syntaxhighlight lang="pascal" inline>concat</syntaxhighlight> performing the very same task.
Read the respective compiler’s documentation ''before'' using it, because there are some differences, or just stick to the ''standardized'' <syntaxhighlight lang="pascal" inline>+</syntaxhighlight>&nbsp;operator.

=== Sophisticated comparison ===
All functions presented in this subsection return a <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> value.

==== Order ====
Since every character in a string has an ordinal value, we can think of a method to sort them.
There are ''two'' flavors of comparing strings:
* One uses the [[../Expressions and Branches#Comparisons|relational operators]] already introduced, such as <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>></syntaxhighlight> or <syntaxhighlight lang="pascal" inline><=</syntaxhighlight>.
* The other one is to use dedicated functions like {{abbr|<syntaxhighlight lang="pascal" inline>LT</syntaxhighlight>|less than}}, or {{abbr|<syntaxhighlight lang="pascal" inline>GT</syntaxhighlight>|greater than}}.
The difference lies in their treatment of strings that ''vary'' in length.
While the former will bring both strings to the same length by ''[[../Arrays#Character array|padding]]'' them with space characters ({{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}), the latter simply ''clips'' them to the shortest length, but taking into account which one was longer (if necessary).
{| class="wikitable" style="text-align: center; margin: auto;"
! function name                                              !! meaning                  !! operator
|-
| <syntaxhighlight lang="pascal" inline>EQ</syntaxhighlight> || equal                    || <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>NE</syntaxhighlight> || not equal                || <syntaxhighlight lang="pascal" inline><></syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>LT</syntaxhighlight> || less than                || <syntaxhighlight lang="pascal" inline><</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>LE</syntaxhighlight> || less than or equal to    || <syntaxhighlight lang="pascal" inline><=</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>GT</syntaxhighlight> || greater than             || <syntaxhighlight lang="pascal" inline>></syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>GE</syntaxhighlight> || greater than or equal to || <syntaxhighlight lang="pascal" inline>>=</syntaxhighlight>
|-
|+ string comparison functions and operators
|}
All these functions and operators are binary, that means they expect and accept only exactly two parameters or operands respectively.
They ''can'' produce ''different'' results if supplied with the ''same'' input, as you will see in the next two sub-subsections.

==== Equality ====
Let’s start with equality.
* Two strings (of any length) are considered equal by the <syntaxhighlight lang="pascal" inline>EQ</syntaxhighlight> function if both operands are of the same length ''and'' the value, i.&#8239;e. the character sequence that actually make up the strings, are the same.
* An <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>‑comparison, on the other hand, augments any “missing” characters in the shorter string by using the padding character ''space'' ({{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}).<ref group="fn">If you are a {{abbr|GPC|GNU Pascal compiler}} user, you will need to ensure you are in a fully-{{abbr|EP|extended Pascal}}-compliant mode for example by specifying <syntaxhighlight lang="text" inline>‑‑extended‑pascal</syntaxhighlight> on the command line. Otherwise, no padding occurs. The Standard (''unextended'') Pascal, as per {{abbr|ISO|international organization for standardization}} standard 7185, does not define any padding algorithm.</ref>
{{Code:Output
| Let’s see this in action:
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program equalDemo(output);
const
	emptyString = '';
	blankString = ' ';
begin
	writeLn(emptyString = blankString);
	writeLn(EQ(emptyString, blankString));
end.
</syntaxhighlight>
| <syntaxhighlight lang="text">  True
 False</syntaxhighlight>
| As you can see <syntaxhighlight lang="pascal" inline>emptyString</syntaxhighlight> got padded to match the length of <syntaxhighlight lang="pascal" inline>blankString</syntaxhighlight>, before the actual character-by-character <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>‑expression took place.
}}
To put ''this'' relationship in other words, ''Pascal'' terms you already know:
<syntaxhighlight lang="pascal" style="text-align: center;">
(foo = bar)  =  EQ(trim(foo), trim(bar))
</syntaxhighlight>
The ''actual'' implementation is usually different, because [[#Remove trailing spaces|<syntaxhighlight lang="pascal" inline>trim</syntaxhighlight>]] ''can'' be, especially for long strings, quite resource-consuming (time, as well as memory).

As a consequence, an <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>‑comparison is usually used if trailing spaces are insignificant, but ''are'' still ''there'' for technical reasons (e.&#8239;g. because you are using an {{nowrap|<syntaxhighlight lang="pascal" inline>array[1..8] of char</syntaxhighlight>}}).
Only <syntaxhighlight lang="pascal" inline>EQ</syntaxhighlight> ensures both strings are lexicographically the same.
Note that the <syntaxhighlight lang="pascal" inline>capacity</syntaxhighlight> of either string is irrelevant.
The function <syntaxhighlight lang="pascal" inline>NE</syntaxhighlight>, short for ''not equal'', behaves accordingly.

==== Less than ====
A string is determined to be “less than” another one by ''sequentially'' reading both strings ''simultaneously from left to right'' and ''comparing'' corresponding characters.
If ''all'' characters match, the strings are said to be ''equal'' to each other.
However, if we encounter a differing character pair, processing is ''aborted'' and the relation of the current characters determines the ''overall'' string’s relation.
{| class="wikitable" style="text-align: center; margin: auto;"
! first operand
| <syntaxhighlight lang="pascal" inline>'A'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'B'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'C'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'D'</syntaxhighlight>
|-
! second operand
| <syntaxhighlight lang="pascal" inline>'A'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'B'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'E'</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>'A'</syntaxhighlight>
|-
! determined relation
| <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>
| '''<syntaxhighlight lang="pascal" inline><</syntaxhighlight>'''
| {{abbr|⨯|don’t care, irrelevant}}
|-
|+ {{nowrap|<syntaxhighlight lang="pascal" inline>'ABCD' < 'ABEA'</syntaxhighlight>}} evaluates to <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|}
If both strings are of ''equal length'', the {{abbr|<syntaxhighlight lang="pascal" inline>LT</syntaxhighlight>|less than}} function and the <syntaxhighlight lang="pascal" inline><</syntaxhighlight>‑operator behave the same.
<syntaxhighlight lang="pascal" inline>LT</syntaxhighlight> actually even builds on top of&nbsp;<syntaxhighlight lang="pascal" inline><</syntaxhighlight>.
Things get interesting if the supplied strings ''differ'' in length.
# The <syntaxhighlight lang="pascal" inline>LT</syntaxhighlight> function first cuts both strings to the same (shorter) length. ([[#Substring|substring]])
# Then a regular comparison is performed as demonstrated above. If the ''shortened'' versions, common length versions turn out to be ''equal'', the (originally) ''longer'' string is said to be ''greater than'' the other one.
{{Code:Output
| The <syntaxhighlight lang="pascal" inline><</syntaxhighlight>‑comparison, on the other, compares all remaining “missing” characters to {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}, the space character. This can lead to differing results:
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="15,18,21">
program lessThanDemo(output);
var
	hogwash, malarky: string(8);
begin
	{ ensure ' ' is not chr(0) or maxChar }
	if not (' ' in [chr(1)..pred(maxChar)]) then
	begin
		writeLn('Character set presumptions not met.');
		halt; { EP procedure immediately terminating the program }
	end;
	
	hogwash := '123';
	
	malarky := hogwash + chr(0);
	writeLn(hogwash < malarky, LT(hogwash, malarky));
	
	malarky := hogwash + '4';
	writeLn(hogwash < malarky, LT(hogwash, malarky));
	
	malarky := hogwash + maxChar;
	writeLn(hogwash < malarky, LT(hogwash, malarky));
end.
</syntaxhighlight>
| <syntaxhighlight lang="text"> False  True
  True  True
  True  True</syntaxhighlight>
| When doing a primitive <syntaxhighlight lang="pascal" inline><</syntaxhighlight>‑comparison, the “missing” fourth character in <syntaxhighlight lang="pascal" inline>hogwash</syntaxhighlight> is presumed to be {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}. The fourth character in <syntaxhighlight lang="pascal" inline>malarky</syntaxhighlight> is compared against {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}.
}}
The situation above has been provoked artificially for demonstration purposes, but this can still become an issue if you are frequently using characters that are “smaller” than the regular space character, like for instance if you are programming on an 1980s 8‑bit Atari computer using [[w:ATASCII|{{abbr|ATASCII|Atari standard code for information interchange}}]].
The {{abbr|<syntaxhighlight lang="pascal" inline>LE</syntaxhighlight>|less than or equal to}}, {{abbr|<syntaxhighlight lang="pascal" inline>GT</syntaxhighlight>|greater than}}, and {{abbr|<syntaxhighlight lang="pascal" inline>GE</syntaxhighlight>|greater than or equal to}} functions act accordingly.

== Details on <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> literals ==
=== Inclusion of delimiter ===
In Pascal <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> literals start with and are terminated by the same character.
Usually this is a straight (typewriter’s) apostrophe (<syntaxhighlight lang="pascal" inline>'</syntaxhighlight>).
Troubles arise if you want to actually include that character in a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> literal, because the character you want to include into your string is already understood as the ''terminating'' delimiter.
Conventionally, two straight typewriter’s apostrophes back-to-back are regarded as an ''apostrophe image''.
In the produced computer program, they are replaced by a ''single'' apostrophe.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="7">
program apostropheDemo(output);
var
	c: char;
begin
	for c := '0' to '9' do
	begin
		writeLn('ord(''', c, ''') = ', ord(c));
	end;
end.
</syntaxhighlight>
Each double-apostrophe is replaced by a single apostrophe.
The string still needs ''delimiting'' apostrophes, so you ''might'' end up with ''three'' consecutive apostrophes like in the example above, or even ''four'' consecutive apostrophes (<syntaxhighlight lang="pascal" inline>''''</syntaxhighlight>) if you want a <syntaxhighlight lang="pascal" inline>char</syntaxhighlight>-value consisting of a ''single'' apostrophe.

=== Non-permissible characters ===
A <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> is a ''linear'' sequence of characters, i.&#8239;e. along a ''single'' dimension.
{{caution
| heading =
| As such the only ''illegal'' “character” in strings is the one marking line breaks (new lines). The string literal in the following piece of code is unacceptable, because it spans across ''multiple'' (source code) lines.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
welcomeMessage := 'Hello!

All your base are belong to us.';
</syntaxhighlight>
However, this only concerns string ''literals'' (string values written in your ''source'' code).
}}
You are nevertheless allowed to use the {{abbr|OS|operating system}}-specific code indicating {{abbr|EOL|end of line}}s, yet the only ''cross-platform'' (i.&#8239;e. guaranteed to work regardless of the used {{abbr|OS|operating system}}) procedure is <syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight>.
Although ''not'' standardized, many compilers provide ''a'' constant representing the environment’s character/string necessary to produce line breaks.
In {{abbr|FPC|Free Pascal compiler}} it is called <syntaxhighlight lang="pascal" inline>lineEnding</syntaxhighlight>.
Delphi has <syntaxhighlight lang="pascal" inline>sLineBreak</syntaxhighlight>, which is also understood by the {{abbr|FPC|Free Pascal compiler}} for compatibility reasons.
The {{abbr|GPC|GNU Pascal compiler}}’s standard module <syntaxhighlight lang="pascal" inline>GPC</syntaxhighlight> supplies the constant <syntaxhighlight lang="pascal" inline>lineBreak</syntaxhighlight>.
You will first need to <syntaxhighlight lang="pascal" inline>import</syntaxhighlight> this module before you can use that identifier.

== Remainder operator ==
{{Wikibook|Programming Fundamentals/Integer Division and Modulus}}
The final Standard Pascal arithmetic operator you are introduced to, after learning to [[../Arrays#Division|divide]], is the ''remainder operator'' <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> (short for ''modulo'').
Every <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> division (<syntaxhighlight lang="pascal" inline>div</syntaxhighlight>) may yield a remainder.
This operator evaluates to this value.
{| class="wikitable" style="text-align: right; margin: auto;"
! <syntaxhighlight lang="pascal" inline>i</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>-3</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>-2</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>-1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>2</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>3</syntaxhighlight>
|-
! {{nowrap|<syntaxhighlight lang="pascal" inline>i mod 2</syntaxhighlight>}}
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
|-
! {{nowrap|<syntaxhighlight lang="pascal" inline>i mod 3</syntaxhighlight>}}
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>2</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>2</syntaxhighlight>
| <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>
|-
|+ <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> operation sample values
|}
Similar to all other division operations, the <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> operator does not accept a ''zero'' value as the second operand.
Moreover, the second operand to <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> ''must'' be ''positive''.
There are many definitions, among computer scientists and mathematicians, as regards to the result if the divisor was negative.
Pascal avoids any confusion by simply declaring negative divisors as illegal.

The <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> operator is frequently used to ensure a certain value remains in a specific range starting at zero (<syntaxhighlight lang="pascal" inline>0..n</syntaxhighlight>).
Furthermore, you will find modulo in [[Subject:Number theory|number theory]].
For example, the definition of ''prime'' numbers says “not divisible by any other number”.
This expression can be translated into Pascal like that:
{| class="wikitable" style="text-align: center; margin: auto;"
! expression
| <math>x</math> is divisible by <math>d</math>
|-
! mathematical notation
| <math>d \mid x</math>
|-
! Pascal expression
| {{nowrap|<syntaxhighlight lang="pascal" inline>x mod d = 0</syntaxhighlight>}}
|-
|+ mathematical relation of <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight>
|}
{{XNote|<syntaxhighlight lang="pascal" inline>odd(x)</syntaxhighlight> is shorthand for {{nowrap|<syntaxhighlight lang="pascal" inline>x mod 2 <> 0</syntaxhighlight>}}.<ref group="fn">The actual implementation of <syntaxhighlight lang="pascal" inline>odd</syntaxhighlight> may be different. On many processor architectures it is usually something to the effect of the x86 instruction {{nowrap|<syntaxhighlight lang="asm" inline>and x, 1</syntaxhighlight>}}.</ref>}}

== Tasks ==
{{question-answer
| question = How do you access a single character from an {{nowrap|<syntaxhighlight lang="pascal" inline>array[n..m] of string(c)</syntaxhighlight>}}?
| answer   = Since a <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> is basically a special case of an <syntaxhighlight lang="pascal" inline>array</syntaxhighlight> (namely one consisting of <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> values), you can access a single character from it just like usual: {{nowrap|<syntaxhighlight lang="pascal" inline>v[i, p]</syntaxhighlight>}} where <syntaxhighlight lang="pascal" inline>i</syntaxhighlight> is a valid index in the range <syntaxhighlight lang="pascal" inline>n..m</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>p</syntaxhighlight> refers to the character index within <syntaxhighlight lang="pascal" inline>1..length(v[i])</syntaxhighlight>.
}}
{{-}}
{{question-answer
| question = Write a Boolean function that returns <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> if, and only if a given <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> contains non-blank characters (i.&#8239;e. other characters than {{nowrap|<syntaxhighlight lang="pascal" inline>' '</syntaxhighlight>}}).
| answer   = The following is a quite neat implementation.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="10-13">
program spaceTest(input, output);
type
	info = string(20);

{**
	\brief determines whether a string contains non-space characters
	\param s the string to inspect
	\return true if there are any characters other than ' '
*}
function containsNonBlanks(s: info): Boolean;
begin
	containsNonBlanks := length(trim(s)) > 0;
end;

// … remaining code for testing purposes only …</syntaxhighlight>
Note, that this function (correctly) returns <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> if supplied with an empty string (<syntaxhighlight lang="pascal" inline>''</syntaxhighlight>). Alternatively you could have written:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="12">
	containsNonBlanks := '' <> s;
</syntaxhighlight>
This requires some Pascal afficionado (someone like you) though, because in ''other'' programming languages this kind of expression would only check for ''empty'' strings. Also, it requires a <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> data type to work properly. Remember, in these exercises there is no “best” solution.
}}
{{-}}
{{question-answer
| question = Write a <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> that reads a <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> and transposes every letter in it by 13 positions with respect to the original character’s place in the English alphabet, and then outputs the modified version. This algorithm is known as “[[Cryptography/Caesar cipher|Caesar cipher]]”. For simplicity assume all input is lower-case.
| answer   = This implementation makes use of multiple things you saw in this unit:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program rotate13(input, output);
const
	// we will only operate ("rotate") on these characters
	alphabet = 'abcdefghijklmnopqrstuvwxyz';
	offset = 13;
type
	integerNonNegative = 0..maxInt;
	sentence = string(80);
var
	secret: sentence;
	i, p: integerNonNegative;
begin
	readLn(secret);
	
	for i := 1 to length(secret) do
	begin
		// is current character in alphabet?
		p := index(alphabet, secret[i]);
		// if so, rotate
		if p > 0 then
		begin
			// The `+ 1` in the end ensures that p
			// in the following expression `alphabet[p]`
			// is indeed always a valid index (i.e. not zero).
			p := (p - 1 + offset) mod length(alphabet) + 1;
			
			secret[i] := alphabet[p];
		end;
	end;
	
	writeLn(secret);
end.
</syntaxhighlight>An implementation using a translation table ({{nowrap|<syntaxhighlight lang="pascal" inline>array[chr(0)..maxChar] of char</syntaxhighlight>}}) would have been acceptable, too, but care must be taken in properly populating it.
Note, it is not guaranteed that expressions such as {{nowrap|<syntaxhighlight lang="pascal" inline>succ('A', 13)</syntaxhighlight>}} will yield the expected result. The range <syntaxhighlight lang="pascal" inline>'A'..'Z'</syntaxhighlight> is not necessarily contiguous, so you should not make any assumptions about it. If your solution makes use of that, you must ''document'' it (e.&#8239;g. “This program only runs properly on computers using the [[Programming Fundamentals/ASCII Character Set|ASCII character set]].”).
}}
{{-}}
{{question-answer
| question = Write a Boolean function that determines whether a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> is a [[wikt:Appendix:English palindromes#Phrases|palindrome]], that means it can be read forward ''and'' backwards producing the same meaning/sound provided word gaps (spaces) are adjusted accordingly. For simplicity assume all characters are lower-case and there are no punctuation characters (other than whitespace).
| answer   = The following is ''an'' acceptable implementation:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="11-57">
program palindromes(input, output);

type
	sentence = string(80);

{
	\brief determines whether a lower-case sentence is a palindrome
	\param original the sentence to inspect
	\return true iff \param original can be read forward and backward
}
function isPalindrome(original: sentence): Boolean;
var
	readIndex, writeIndex: integer;
	derivative: sentence;
	check: Boolean;
begin
	check := true;
	
	// “sentences” that have a length of one, or even zero characters
	// are always palindromes
	if length(original) > 1 then
	begin
		// ensure `derivative` has the same length as `original`
		derivative := original;
		// the contents are irrelevant, alternatively [in EP] you could’ve used
		//writeStr(derivative, '':length(original));
		// which would’ve saved us the “fill the rest with blanks” step below
		
		writeIndex := 1;
		// strip blanks
		for readIndex := 1 to length(original) do
		begin
			// only copy significant characters
			if not (original[readIndex] in [' ']) then
			begin
				derivative[writeIndex] := original[readIndex];
				writeIndex := writeIndex + 1;
			end;
		end;
		
		// fill the rest with blanks
		for writeIndex := writeIndex to length(derivative) do
		begin
			derivative[writeIndex] := ' ';
		end;
		// remove trailing blanks and thus shorten length
		derivative := trim(derivative);
		
		for readIndex := 1 to length(derivative) div 2 do
		begin
			check := check and (derivative[readIndex] =
				derivative[length(derivative) - readIndex + 1]);
		end;
	end;
	
	isPalindrome := check;
end;

var
	mystery: sentence;
begin
	writeLn('Enter a sentence that is possibly a palindrome (no caps):');
	readLn(mystery);
	writeLn('The sentence you have entered is a palindrome: ',
		isPalindrome(mystery));
end.
</syntaxhighlight>
Ensure that you have understood that you can only set a string’s length by making a direct “complete” assignment (confer [[#Index|§&nbsp;Index]]). Notice how this implementation uses an altered, ''filtered'' copy of the <syntaxhighlight lang="pascal" inline>original</syntaxhighlight> <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>. For demonstration purposes the example shows {{nowrap|<syntaxhighlight lang="pascal" inline>if not (original[readIndex] in [' ']) then</syntaxhighlight>}}. In fact an ''explicit'' set list would have been more adequate, i.&#8239;e. {{nowrap|<syntaxhighlight lang="pascal" inline>if original[readIndex] in ['a', 'b', 'c', …, 'z']) then</syntaxhighlight>}}. Do not worry if you simply wrote something to the effect of {{nowrap|<syntaxhighlight lang="pascal" inline>if original[readIndex] <> ' ' then</syntaxhighlight>}}, this is just as fine given the task’s requirements.
}}
{{-}}
{{question-answer
| question = Without trying it out, what is the result of {{nowrap|<syntaxhighlight lang="pascal" inline>LT('', '')</syntaxhighlight>}}?
| answer   = Now you are allowed to try it out.
}}
{{-}}
{{question-answer
| question = Write a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> that determines whether a year in the Gregorian calendar is a [[Primary Mathematics/Time expressions#What years are leap years ?|leap year]]. Every fourth year is a leap year, but every hundredth year is not, unless it is the fourth century in a row.
| answer   = This task is a prime example for the [[#Remainder operator|<syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> operator]] you just saw:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
{
	\brief determines whether a year is a leap year in Gregorian calendar
	\param x the year to inspect
	\return true, if and only if \param x meets leap year conditions
}
function leapYear(x: integer): Boolean;
begin
	leapYear := (x mod 4 = 0) and (x mod 100 <> 0) or (x mod 400 = 0);
end;
</syntaxhighlight>
Note there is an already pre-made <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> <syntaxhighlight lang="pascal" inline>isLeapYear</syntaxhighlight> in Delphi’s and the {{abbr|FPC|FreePascal Compiler}}’s <syntaxhighlight lang="delphi" inline>sysUtils</syntaxhighlight> <syntaxhighlight lang="delphi" inline>unit</syntaxhighlight> or in {{abbr|GPC|GNU Pascal Compiler}}’s <syntaxhighlight lang="pascal" inline>GPC</syntaxhighlight> <syntaxhighlight lang="pascal" inline>module</syntaxhighlight>. Whenever possible reuse code already available.
}}
{{-}}
{{question-answer
| question = After writing <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> returning the leap year property of a year, write a binary <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> returning the number of days in a given month and year.
| answer   = This is a typical case for a [[../Enumerations#Selections|<syntaxhighlight lang="pascal" inline>case</syntaxhighlight>-statement]]. Recall that there must be ''exactly'' one assignment to the result variable:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
type
	{ a valid day number in Gregorian calendar month }
	day = 1..31;
	{ a valid month number in Gregorian calendar year }
	month = 1..12;

{
	\brief determines the number of days in a given Gregorian year
	\param m the month whose day number count is requested
	\param y the year (relevant for leap years)
	\return the number of days in a given month and year
}
function daysInMonth(m: month; y: integer): day;
begin
	case m of
		1, 3, 5, 7, 8, 10, 12:
		begin
			daysInMonth := 31;
		end;
		4, 6, 9, 11:
		begin
			daysInMonth := 30;
		end;
		2:
		begin
			daysInMonth := 28 + ord(leapYear(y));
		end;
	end;
end;
</syntaxhighlight>
Note, Delphi’s and the {{abbr|FPC|FreePascal Compiler}}’s compatible <syntaxhighlight lang="delphi" inline>dateUtils unit</syntaxhighlight> provide a <syntaxhighlight lang="delphi" inline>function</syntaxhighlight> called <syntaxhighlight lang="delphi" inline>daysInAMonth</syntaxhighlight>. You are strongly encouraged to reuse ''it'' instead of your own code.
}}
More exercises can be found in:
* [[Programming Fundamentals/Practice: Strings and Files#String Activities|Programming Fundamentals, Chapter “Practice: Strings and Files”, §&nbsp;“String Activities”]]
{{newpage}}
<hr class="noprint"/>
<div style="font-size:smaller;">
Notes:
<references group="fn" />
</div>

{{auto navigation|Records|Arrays}}