[edit] Pointers

Pascal supports the use of pointers:

type
 a = ^b;
 b = record
       x: Integer;
       y: Char;
       z: a
     end;
var
 pointer_to_b: a;

Here the variable pointer_to_b is a pointer to the data type b, a record. Pointers can be used before they are declared. This is an exception to the rule that things must be declared before they are used. To create a new record and assign the values 10 and A to the fields a and b in the record, the commands would be;

  new(pointer_to_b);

pointer_to_b^.x := 10;
 pointer_to_b^.y := 'A';
 pointer_to_b^.z := nil;
...

This could also be done using the with statement, as follows

new(pointer_to_b);
 with pointer_to_b^ do
   begin
       x := 10;
       y := 'A';
       z := nil
   end;
...

Note that inside of the scope of the with statement, the compiler knows that a and b refer to the subfields of the record pointer pointer_to_b and not to the record b or the pointer type a.

Linked lists, stacks and queues can be created by including a pointer type field (c) in the record (see also nil and null (computer)).

[edit] Control structures

Pascal is a structured programming language, meaning that the flow of control is structured into standard statements, ideally without 'go to' commands.

while a <> b do writeln('Waiting');

if a > b then
 writeln('Condition met')
else
 writeln('Condition false');

for i := 1 to 10 do writeln('Iteration: ', i:1);

repeat a := a + 1 until a = 10;

[edit] Procedures and functions

Pascal structures programs into procedures and functions.

program mine(output);
 var i : integer;

 procedure print(var j: integer);

   function next(k: integer): integer;
   begin
     next := k + 1
   end;

 begin
   writeln('The total is: ', j);
   j := next(j)
 end;

begin
 i := 1;
 while i <= 10 do print(i)
end.

Procedures and functions can nest to any depth, and the 'program' construct is the logical outermost block.

Each procedure or function can have its own declarations of goto labels, constants, types, variables, and other procedures and functions, which must all be in that order. This ordering requirement was originally intended to allow efficient single-pass compilation. However, in some dialects the strict ordering requirement of declaration sections is not required.