Turbo Pascal compatibility mode

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

#### 7.2.3 Turbo Pascal compatibility mode

When you compile a program with the -Mtp switch, the compiler will attempt to mimic the Turbo Pascal compiler in the following ways:

- Assigning a procedural variable doesn’t require an @ operator. One of the differences between Turbo Pascal and Free Pascal is that the latter requires you to specify an address operator when assigning a value to a procedural variable. In Turbo Pascal compatibility mode, this is not required.
- Procedure overloading is disabled. If procedure overloading is disabled, the function header doesn’t need to repeat the function header.
- Forward defined procedures don’t need the full parameter list when they are defined. Due to the procedure overloading feature of Free Pascal, you must always specify the parameter list of a function when you define it, even when it was declared earlier with Forward. In Turbo Pascal compatibility mode, there is no function overloading; hence you can omit the parameter list:
  Procedure a (L : Longint); Forward;
  ...
  Procedure a ; { No need to repeat the (L : Longint) }
  begin
  ...
  end;

- Recursive function calls are handled differently. Consider the following example:
  Function expr : Longint;
  begin
  ...
  Expr:=L:
  Writeln (Expr);
  ...
  end;

  In Turbo Pascal compatibility mode, the function will be called recursively when the writeln statement is processed. In Free Pascal, the function result will be printed. In order to call the function recursively under Free Pascal, you need to implement it as follows :

  Function expr : Longint;
  begin
  ...
  Expr:=L:
  Writeln (Expr());
  ...
  end;

- You cannot assign procedural variables to untyped pointers; so the following is invalid:
  a: Procedure;
  b: Pointer;
  begin
  b := a; // Error will be generated.

- The @ operator is typed when applied on procedures.
- You cannot nest comments.

Remark The MemAvail and MaxAvail functions are no longer available in Free Pascal as of version 2.0. The reason for this incompatibility follows:

On modern operating systems, 1 the idea of ”Available Free Memory” is not valid for an application. The reasons are:

1.
  One processor cycle after an application asked the OS how much memory is free, another application may have allocated everything.
2.
  It is not clear what ”free memory” means: does it include swap memory, does it include disk cache memory (the disk cache can grow and shrink on modern OS’es), does it include memory allocated to other applications but which can be swapped out, etc.

Therefore, programs using MemAvail and MaxAvail functions should be rewritten so they no longer use these functions, because it does not make sense any more on modern OS’es. There are 3 possibilities:

1.
  Use exceptions to catch out-of-memory errors.
2.
  Set the global variable ”ReturnNilIfGrowHeapFails” to True and check after each allocation whether the pointer is different from Nil.
3.
  Don’t care and declare a dummy function called MaxAvail which always returns High(LongInt) (or some other constant).

1 The DOS extender GO32V2 falls under this definition of ”modern” because it can use paged memory and run in multitasked environments.

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