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 $$\left(\text{identifier}, \text{definition}\right)$$, to be more specific, variables are declared like $$\left(\text{identifier}, \text{data type}\right)$$ and constant declarations are $$\left(\text{identifier}, \text{literal}\right)$$ tuples. A tuple is an ordered collection. You may not reverse or rearrange its items without the tuple rendering to be different.

Structure
"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."

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: and  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 IDE supports some auto-completion mechanism. The FPC, for example, has a limit of 127 characters: "Identifiers consist of between and   significant characters (letters, digits and the underscore character), of which the first must be a letter ( ‑  or  ‑ ), or an underscore."

Note, allowing, too, is an ISO 10206 (“Extended Pascal”) extension, but – unlike the FPC – it imposes the restriction that an identifier may neither begin or end an identifier, nor may two underscores appear one another.

Variable section
Variables are declared in a dedicated section, the -section. When the compiler processes the -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. An  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,   or.

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  there are also:
 * A character, like a Latin letter or Western Arabic digit, but also spaces and other characters.
 * A character, like a Latin letter or Western Arabic digit, but also spaces and other characters.


 * A subset of ℚ, that is – due to computer’s binary nature – the set of rational numbers. Examples are  (2−6) or   (216 + 213 + 2−1).
 * A subset of ℚ, that is – due to computer’s binary nature – the set of rational numbers. Examples are  (2−6) or   (216 + 213 + 2−1).


 * A Boolean value, that is  or.
 * A Boolean value, that is  or.

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  and the program header also lists. 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,  is assumed, thus   is equivalent to , 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. If you do not enter a literal that is compatible to the type of the supplied argument, something like this happens: 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 -sections as necessary, but they may not be empty. There is also a shorthand syntax for declaring many variables of the same type: This will declare three independent variables, all of the  data type. Nonetheless, different types have to appear in different declarations:

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:
 * This is the maximum  value an   variable could assume. There is no minimum integer constant, but it is guaranteed that a   variable can at least store the value.
 * This is the maximum  value an   variable could assume. There is no minimum integer constant, but it is guaranteed that a   variable can at least store the value.


 * Likewise, this is the maximum  value a   variable could assume, where maximum refers to the ordinal value using the built-in   function.
 * Likewise, this is the maximum  value a   variable could assume, where maximum refers to the ordinal value using the built-in   function.


 * ,  and
 * Are defined by the “Extended Pascal” standard.


 * and
 * 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
References: