[next] [prev] [prev-tail] [tail] [up]

### 7.2 Things which are extra

Here we give a list of things which are possible in Free Pascal, but which didn’t exist in Turbo Pascal or Delphi.

1. There are more reserved words. (see appendix B for a list of all reserved words.)
2. Functions can also return complex types, such as records and arrays.
3. You can handle function results in the function itself, as a variable. Example

             function a : longint;

             begin
                a:=12;
                while a>4 do
                  begin
                     {...}
                  end;
             end;

   The example above would work with TP, but the compiler would assume that the a>4 is a recursive call. To do a recursive call in this you must append () behind the function name:

             function a : longint;

             begin
                a:=12;
                { this is the recursive call }
                if a()>4 then
                  begin
                     {...}
                  end;
             end;

4. There is partial support of Delphi constructs. (see the Programmers guide for more information on this).
5. The exit call accepts a return value for functions.

             function a : longint;

             begin
                a:=12;
                if a>4 then
                  begin
                     exit(a*67); {function result upon exit is a*67 }
                  end;
             end;

6. Free Pascal supports function overloading. That is, you can define many functions with the same name, but with different arguments. For example:

             procedure DoSomething (a : longint);
             begin
             {...}
             end;

             procedure DoSomething (a : real);
             begin
             {...}
             end;

   You can then call procedure DoSomething with an argument of type Longint or Real.
   This feature has the consequence that a previously declared function must always be defined with the header completely the same:

             procedure x (v : longint); forward;

             {...}

             procedure x;{ This will overload the previously declared x}
             begin
             {...}
             end;

   This construction will generate a compiler error, because the compiler didn’t find a definition of procedure x (v : longint);. Instead you should define your procedure x as:

             procedure x (v : longint);
             { This correctly defines the previously declared x}
             begin
             {...}
             end;

   (The -So, (see page 5.1) switch disables overloading. When you use it, the above will compile, as in Turbo Pascal.
7. Operator overloading. Free Pascal allows to overload operators, i.e. you can define e.g. the ’+’ operator for matrices.
8. On FAT16 and FAT32 systems, long file names are supported.

[next] [prev] [prev-tail] [front] [up]