View source for Pascal Programming/Variables and Constants

Like all programming languages, Pascal provides some means to modify memory.
This concept is known as variables.
Variables are named chunks of memory.
You can use them to store data you cannot predict.

Constants, on the other hand, are named pieces of data.
You ''cannot alter'' them during run-time, but they are ''hard-coded'' into the compiled executable program.
Constants do not necessarily occupy any dedicated unique space in memory, but facilitate writing clean and understandable source code.

== Declaration ==
In Pascal, before you are even allowed to use ''any'' variable or constant you have to declare them, like virtually any symbol in Pascal.
A declaration makes a certain symbol ''known'' to the compiler and possibly instructs it to make the necessary provisions for their effective usage, that means – in the context of variables – earmark some piece of memory.

A declaration is always a two-tuple <math>\left(\text{identifier}, \text{definition}\right)</math>, to be more specific, variables are declared like <math>\left(\text{identifier}, \text{data type}\right)</math> and constant declarations are <math>\left(\text{identifier}, \text{literal}\right)</math> tuples.
A tuple is an ''ordered'' collection.
You may not reverse or rearrange its items without the tuple rendering to be ''different''.

{{XNote|After you have declared an identifier to refer to one thing, you may not re-declare the same identifier to refer to another (or same) thing (“shadowing” may apply, but more on that later).}}

== Identifiers ==
=== Structure ===
{{quote|
''Identifiers'' are names denoting constants, types, bounds, variables, procedures, and functions.
They must begin with a letter, which may be followed by any combination and numbers of letters and digits.
The spelling of an identifier is significant over its whole length.
Corresponding upper-case and lower-case letters are considered equivalent.<ref name="pumar_identifiers">{{cite book
| title         = Pascal – user manual and report
| edition       = 4th revised
| first1        = Kathleen
| last1         = Jensen
| first2        = Niklaus
| last2         = Wirth
| doi           = 10.1007/978-1-4612-4450-9 <!-- digital version -->
| isbn          =         978-0-387-97649-5 <!-- printed copy -->
}}</ref>
}}

''Letters'' refers to the modern Latin alphabet, that is all letters you use in writing English words, and ''digits'' are Western Arabic digits.

=== Usage ===
As you infer from the quote’s last sentence, the casing of letters does not matter:
<syntaxhighlight lang="pascal" inline>Foo</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>fOO</syntaxhighlight> are both the ''same'' identifier, just different representations.

Identifiers are used simply by writing them out at a suitable position.

=== Significant characters ===
In the age Pascal was developed in, computer memory was a precious resource.
In order to build a working compiler, however, the notion of ''significant characters'' was introduced.
A significant character of an identifier is a character that contributes to distinguishing two identifiers from one another.

Some programming languages had a limit of 8 (eight) characters.
This led to very cryptic identifiers.
Today, however, the limit of significant characters is primarily governed by usability:
The programmer eventually has to type them out if no {{abbr|IDE|integrated development environment}} supports some auto-completion mechanism.
The {{abbr|FPC|Free Pascal Compiler}}, for example, has a limit of 127 characters:
{{quote|
Identifiers consist of between <syntaxhighlight lang="text" inline>1</syntaxhighlight> and <syntaxhighlight lang="text" inline>127</syntaxhighlight> significant characters (letters, digits and the underscore character), of which the first must be a letter (<syntaxhighlight lang="pascal" inline>a</syntaxhighlight>‑<syntaxhighlight lang="pascal" inline>z</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>A</syntaxhighlight>‑<syntaxhighlight lang="pascal" inline>Z</syntaxhighlight>), or an underscore (<syntaxhighlight lang="pascal" inline>_</syntaxhighlight>).<ref name="fpcref_identifier">{{cite manual
|     author = Michaël Van Canneyt
|      title = Free Pascal Reference guide
|    version = version 3.0.4
|       date = September 2017
|        url = ftp://ftp.freepascal.org/pub/fpc/docs-pdf/ref.pdf
| accessdate = 2019-12-14
|    section = §1.4
|       page = 15
}}</ref>
}}

{{XNote|You are still allowed to write identifiers ''longer'' than 127 characters, however, the compiler only looks at the first 127 characters and discards the remaining characters as irrelevant.}}

Note, allowing <syntaxhighlight lang="pascal" inline>_</syntaxhighlight>, too, is an ISO 10206 (“Extended Pascal”) extension, but – unlike the {{abbr|FPC|Free Pascal Compiler}} – it imposes the restriction that an identifier may neither begin or end an identifier, nor may two underscores appear one another.

== Variables ==
=== Variable section ===
Variables are declared in a dedicated section, the <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section.
<syntaxhighlight lang="pascal" highlight="2,3" style="page-break-inside: avoid;">
program varDemo(input, output);
var
	number: integer;
begin
	write('Enter a number: ');
	readLn(number);
	writeLn('Great choice! ', number, ' is awesome.');
end.
</syntaxhighlight>
When the compiler processes the <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-section it will set as much memory aside as is required by its associated data type.
Here, we instruct the compiler to reserve space for an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>.
An <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> is a data type that is part of the programming language, thus it is guaranteed to be present regardless of the used compiler.
It stores a subset of ℤ, the set of integers, like for example <syntaxhighlight lang="pascal" inline>42</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>1337</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>-1</syntaxhighlight>.

=== Data type ===
''Data type'' refers to the combination of a permissible range of values and permissible operations on this range of values.
Pascal defines some basic data types as part of the language.
Apart from <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> there are also:
; <syntaxhighlight lang="pascal" inline>char</syntaxhighlight>
: A character, like a Latin letter or Western Arabic digit, but also spaces and other characters.
; <syntaxhighlight lang="pascal" inline>real</syntaxhighlight>
: A subset of ℚ, that is – due to computer’s binary nature – the set of rational numbers. Examples are <syntaxhighlight lang="pascal" inline>0.015625</syntaxhighlight> (2<sup>−6</sup>) or <syntaxhighlight lang="pascal" inline>73728.5</syntaxhighlight> (2<sup>16</sup> + 2<sup>13</sup> + 2<sup>−1</sup>).
; <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight>
: A Boolean value, that is <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>.
Each data type defines how data are laid out in memory.
In a high-level language, such as Pascal, it is not of the programmer’s concern how exactly the data are stored, but the processor (i. e. in most cases a compiler) has to define it.

We will revisit all data types later on.

=== Reading from the console ===
As you may have noticed, the example above contains <syntaxhighlight lang="pascal" inline>readLn(number)</syntaxhighlight> and the program header also lists <syntaxhighlight lang="pascal" inline>input</syntaxhighlight>.
<syntaxhighlight lang="pascal" inline>ReadLn</syntaxhighlight> will (try to) read data from the (optionally named) source and store the (interpreted) values into the supplied parameters discarding any line-end characters.
If the source is not specified, like it is the case here, <syntaxhighlight lang="pascal" inline>input</syntaxhighlight> is assumed, thus <syntaxhighlight lang="pascal" inline>readLn(number)</syntaxhighlight> is equivalent to <syntaxhighlight lang="pascal" inline>readLn(input, number)</syntaxhighlight>, but shorter.

When the program is run, it will stop and wait for the user to input a number, that is a literal that can be converted into the argument’s data type.
{{Code:Error
| If you do not enter a literal that is compatible to the type of the supplied argument, something like this happens:
| <syntaxhighlight lang="text">Enter a number: I want cookies!
./a.out: sign or digit expected (error #552 at 402ac3)</syntaxhighlight>
| And then the program aborted. The following <syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight> was not executed. Now obviously <syntaxhighlight lang="text" inline>I want cookies!</syntaxhighlight> is not a literal that can be converted into an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> value (i. e. the data type of <syntaxhighlight lang="pascal" inline>number</syntaxhighlight>). For reference, this error message was generated with the program compiled using the {{abbr|GPC|GNU Pascal compiler}}. Programs compiled with different compilers may emit different error messages.}}
You have to indicate in your program’s accompanying documents – the user manual – how and when the user needs to input data.
Later we will learn how to treat erroneous input, but this is too complex for now.

=== More variables ===
There can be as many <syntaxhighlight lang="pascal" inline>var</syntaxhighlight>-sections as necessary, but they may not be empty.
There is also a shorthand syntax for declaring many variables of the ''same'' type:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
var
	foo, bar, x: integer;
</syntaxhighlight>
This will declare ''three'' independent variables, all of the <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> data type.
Nonetheless, ''different'' types have to appear in different declarations:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
var
	x: integer;
	itIsSunnyInPhiladelphia: Boolean;
</syntaxhighlight>

== Constants ==
=== Constant section ===
<syntaxhighlight lang="pascal" highlight="2,3" style="page-break-inside: avoid;">
program constDemo(output);
const
	answer = 42;
begin
	writeLn('The answer to the Ultimate Question of ',
	        'Life, the Universe, and Everything, is: ',
	        answer);
end.
</syntaxhighlight>

=== Usage ===
As already mentioned in the introduction, a constant may never change its value, but you have to modify the source code.
Consequently, the name of a constant cannot appear on the left-hand side of an assignment.

=== Pre‑defined constants ===
There are some already predefined constants:
; <syntaxhighlight lang="pascal" inline>maxInt</syntaxhighlight>
: This is the maximum <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> value an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> variable could assume. There is no ''minimum integer'' constant, but it is guaranteed that a <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> variable can at least store the value <syntaxhighlight lang="pascal" inline>-maxInt</syntaxhighlight>.
; <syntaxhighlight lang="pascal" inline>maxChar</syntaxhighlight>
: Likewise, this is the maximum <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> value a <syntaxhighlight lang="pascal" inline>char</syntaxhighlight> variable could assume, where ''maximum'' refers to the ordinal value using the built-in <syntaxhighlight lang="pascal" inline>ord</syntaxhighlight> function.
; <syntaxhighlight lang="pascal" inline>maxReal</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>minReal</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>epsReal</syntaxhighlight>
: Are defined by the “Extended Pascal” standard.
; <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
: Refer to Boolean values.

=== Rationale ===
Pascal was designed, so – among other considerations – it could be compiled in one pass, from top to bottom:
The reason being to make compiling fast and simple.
Distinguishing between variables and constants allows the processor to simply substitute any occurrence of a constant identifier to be replaced by its value.
Thus, a constant does not need any special treatment like a variable, yet allows the programmer to reuse reappearing data.

== Tasks ==
{{question-answer
| question = Does the German word <syntaxhighlight lang="pascal" inline>Zähler</syntaxhighlight> (meaning “counter”&#x202F;/&#8239;“enumerator”) constitute a valid identifier?
| answer   = No, because the letter Umlaut-a (&auml;) is not a letter in the English alphabet. Identifiers may only consist of (English alphabet) letters and (Western Arabic) digits. As a word of advice, stick to English words as identifiers even though your native language is a different one.
}}
{{-}}
{{question-answer
| question = Is <syntaxhighlight lang="text" inline>1direction</syntaxhighlight> (<syntaxhighlight lang="text" inline>1D</syntaxhighlight>) a permissible identifier?
| answer   = This is also not a valid identifier. All identifiers have to start with a letter. This restriction allows compiler vendors to assume, once a digit is encountered, that a number literal follows.
}}
{{-}}
{{question-answer
| question = What is the difference between <syntaxhighlight lang="pascal" inline>write</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight>?
| answer   = They are the same except that, as the name already indicates, <syntaxhighlight lang="pascal" inline>writeLn</syntaxhighlight> puts the cursor into the next line after it has printed all its parameters.
}}
{{Newpage}}{{Hide in print|
----
}}

<small>References:</small>
{{smallrefs}}


{{Auto navigation|Input and Output|Beginning}}