next up previous contents index search.gif
Next: 7.3 Assembler statements Up: 7. Statements Previous: 7.1 Simple statements

Subsections


7.2 Structured statements

Structured statements can be broken into smaller simple statements, which should be executed repeatedly, conditionally or sequentially:

Structured statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{structured\ ...
...ement}\\
\synt{exception\ statement}\\
\synt{with\ statement}
\)\end{syntdiag}
Conditional statements come in 2 flavours :

Conditional statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{conditional\ statement}
\(
\synt{if\ statement}\\
\synt{case\ statement}
\)\end{syntdiag}
Repetitive statements come in 3 flavours:

Repetitive statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{repetitive\ ...
...atament}\\
\synt{repeat\ statement}\\
\synt{while\ statement}
\)\end{syntdiag}
The following sections deal with each of these statements.

7.2.1 Compound statements

Compound statements are a group of statements, separated by semicolons, that are surrounded by the keywords Begin and End. The Last statement doesn't need to be followed by a semicolon, although it is allowed. A compound statement is a way of grouping statements together, executing the statements sequentially. They are treated as one statement in cases where Pascal syntax expects 1 statement, such as in if ... then statements.

Compound statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{compound\ st...
...ent}
\lit*{begin}
\<[b] \synt{statement} \\ \lit* ; \>
\lit*{end}\end{syntdiag}

7.2.2 The Case statement

Free Pascal supports the case statement. Its syntax diagram is

Case statement

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{case\ statem...
...playmath} \begin{displaymath}\lit* ; \end{displaymath}
\lit*{end}\end{syntdiag}

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{case}
\<[b]...
...onstant} \end{displaymath} \\
\lit* ,
\>
\lit* :
\synt{statement}\end{syntdiag}

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{else\ part} \lit* {else} \synt{statement}\end{syntdiag}
The constants appearing in the various case parts must be known at compile-time, and can be of the following types : enumeration types, Ordinal types (except boolean), and chars. The expression must be also of this type, or an compiler error will occur. All case constants must have the same type. The compiler will evaluate the expression. If one of the case constants values matches the value of the expression, the statement that containing this constant is executed. After that, the program continues after the final end. If none of the case constants match the expression value, the statement after the else keyword is executed. This can be an empty statement. If no else part is present, and no case constant matches the expression value, program flow continues after the final end. The case statements can be compound statements (i.e. a begin..End block). Remark: Contrary to Turbo Pascal, duplicate case labels are not allowed in Free Pascal, so the following code will generate an error when compiling:

Var i : integer;
...
Case i of
 3 : DoSomething;
 1..5 : DoSomethingElse;
end;
The compiler will generate a Duplicate case label error when compiling this, because the 3 also appears (implicitly) in the range 1..5. This is similar to Delhpi syntax. The following are valid case statements: 'b' : WriteLn ('B pressed');

Case C of
 'a' : WriteLn ('A pressed');
 'c' : WriteLn ('C pressed');
else
  WriteLn ('unknown letter pressed : ',C);
end;
Or 'b' : WriteLn ('B pressed');

Case C of
 'a','e','i','o','u' : WriteLn ('vowel pressed');
 'y' : WriteLn ('This one depends on the language');
else
  WriteLn ('Consonant pressed');
end;

Case Number of
 1..10   : WriteLn ('Small number');
 11..100 : WriteLn ('Normal, medium number');
else
 WriteLn ('HUGE number');
end;

7.2.3 The If..then..else statement

The If .. then .. else.. protottype syntax is

If then statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{if\ statemen...
...\begin{displaymath}
\lit*{else} \synt{statement}
\end{displaymath}\end{syntdiag}
The expression between the if and then keywords must have a boolean return type. If the expression evaluates to True then the statement followingthen is executed. If the expression evaluates to False, then the statement following else is executed, if it is present. Be aware of the fact that the boolean expression will be short-cut evaluated. (Meaning that the evaluation will be stopped at the point where the outcome is known with certainty) Also, before the else keyword, no semicolon (;) is allowed, but all statements can be compound statements. In nested If.. then .. else constructs, some ambiguity may araise as to which else statement paits with which if statement. The rule is that the else keyword matches the first if keyword not already matched by an else keyword. For example:

If exp1 Then
  If exp2 then
    Stat1
else
  stat2;
Despite it's appreance, the statement is syntactically equivalent to

If exp1 Then
   begin
   If exp2 then
      Stat1
   else
      stat2
   end;
and not to

{ NOT EQUIVALENT }
If exp1 Then
   begin
   If exp2 then
      Stat1
   end
else
   stat2
If it is this latter construct you want, you must explicitly put the begin and end keywords. When in doubt, add them, they don't hurt. The following is a valid statement:

If Today in [Monday..Friday] then
  WriteLn ('Must work harder')
else
  WriteLn ('Take a day off.');

7.2.4 The For..to/downto..do statement

Free Pascal supports the For loop construction. A for loop is used in case one wants to calculated something a fixed number of times. The prototype syntax is as follows:

For statement

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{for\ stateme...
...\
\lit*{downto}
\)\synt{final\ value}
\lit*{do}
\synt{statement}\end{syntdiag}

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{control\ variable} \synt{variable\ identifier}\end{syntdiag}

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{initial\ value} \synt{expression}\end{syntdiag}

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{final\ value} \synt{expression}\end{syntdiag}
Statement can be a compound statement. When this statement is encountered, the control variable is initialized with the initial value, and is compared with the final value. What happens next depends on whether to or downto is used:
  1. In the case To is used, if the initial value larger than the final value then Statement will never be executed.
  2. In the case DownTo is used, if the initial value larger than the final value then Statement will never be executed.
After this check, the statement after Do is executed. After the execution of the statement, the control variable is increased or decreased with 1, depending on whether To or Downto is used. The control variable must be an ordinal type, no other types can be used as counters in a loop. Remark: Contrary to ANSI pascal specifications, Free Pascal first initializes the counter variable, and only then calculates the upper bound. The following are valid loops:

For Day := Monday to Friday do Work;
For I := 100 downto 1 do
  WriteLn ('Counting down : ',i);
For I := 1 to 7*dwarfs do KissDwarf(i);

7.2.5 The Repeat..until statement

The repeat statement is used to execute a statement until a certain condition is reached. The statement will be executed at least once. The prototype syntax of the Repeat..until statement is

Repeat statement

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{repeat\ stat...
...<[b] \synt{statement} \\ \lit* ; \>
\lit*{until}
\synt{expression}\end{syntdiag}

This will execute the statements between repeat and until up to the moment when Expression evaluates to True. Since the expression is evaluated after the execution of the statements, they are executed at least once. Be aware of the fact that the boolean expression Expression will be short-cut evaluated. (Meaning that the evaluation will be stopped at the point where the outcome is known with certainty) The following are valid repeat statements


repeat
  WriteLn ('I =',i);
  I := I+2;
until I>100;
repeat
 X := X/2
until x<10e-3

7.2.6 The While..do statement

A while statement is used to execute a statement as long as a certain condition holds. This may imply that the statement is never executed. The prototype syntax of the While..do statement is

While statements

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{while\ statement}
\lit*{while} \synt{expression} \lit*{do} \synt{statement}\end{syntdiag}
This will execute Statement as long as Expression evaluates to True. Since Expression is evaluated before the execution of Statement, it is possible that Statement isn't executed at all. Statement can be a compound statement. Be aware of the fact that the boolean expression Expression will be short-cut evaluated. (Meaning that the evaluation will be stopped at the point where the outcome is known with certainty) The following are valid while statements:

I := I+2;
while i<=100 do
  begin
  WriteLn ('I =',i);
  I := I+2;
  end;
X := X/2;
while x>=10e-3 do
  X := X/2;
They correspond to the example loops for the repeat statements.


7.2.7 The With statement

The with statement serves to access the elements of a record7.1or object or class, without having to specify the name of the each time. The syntax for a with statement is

With statement

\begin{syntdiag}\setlength {\sdmidskip}{.5em}\sffamily\sloppy \synt{with\ statem...
...synt{variable\ reference} \\ \lit* , \>
\lit*{do}
\synt{statement}\end{syntdiag}
The variable reference must be a variable of a record, object or class type. In the with statement, any variable reference, or method reference is checked to see if it is a field or method of the record or object or class. If so, then that field is accessed, or that method is called. Given the declaration:

Type Passenger = Record
       Name : String[30];
       Flight : String[10];
       end;
Var TheCustomer : Passenger;
The following statements are completely equivalent:

TheCustomer.Name := 'Michael';
TheCustomer.Flight := 'PS901';
and

With TheCustomer do
  begin
  Name := 'Michael';
  Flight := 'PS901';
  end;
The statement

With A,B,C,D do Statement;
is equivalent to

With A do
 With B do
  With C do
   With D do Statement;
This also is a clear example of the fact that the variables are tried last to first, i.e., when the compiler encounters a variable reference, it will first check if it is a field or method of the last variable. If not, then it will check the last-but-one, and so on. The following example shows this;

Program testw;
Type AR = record
      X,Y : Longint;
     end;

Var S,T : Ar;
begin
  S.X := 1;S.Y := 1;
  T.X := 2;T.Y := 2;
  With S,T do
    WriteLn (X,' ',Y);
end.
The output of this program is

2 2
Showing thus that the X,Y in the WriteLn statement match the T record variable.

7.2.8 Exception Statements

As of version 0.99.7, Free Pascal supports exceptions. Exceptions provide a convenient way to program error and error-recovery mechanisms, and are closely related to classes. Exception support is explained in chapter Exceptions

root
1999-06-10