Turbo Pascal

Free Pascalwas originally designed to resemble Turbo Pascal as closely as possible. There are, of course, restrictions. Some of these are due to the fact that Turbo Pascal was developed for 16-bit architectures whereas Free Pascalis a 32-bit/64-bit compiler. Other restrictions result from the fact that Free Pascalworks on more than one operating system.

In general we can say that if you keep your program code close to ANSI Pascal, you will have no problems porting from Turbo Pascal, or even Delphi, to Free Pascal. To a large extent, the constructs defined by Turbo Pascal are supported. This is even more so if you use the -Mtp or -MObjfpc switches.

In the following sections we will list the Turbo Pascal and Delphi constructs which are not supported in Free Pascal, and we will list in what ways Free Pascalextends Turbo Pascal.

Things that will not work

Here we give a list of things which are defined/allowed in Turbo Pascal, but which are not supported by Free Pascal. Where possible, we indicate the reason.

1. Duplicate case labels are permitted in Turbo Pascal, but not in Free Pascal. This is actually a bug in Turbo Pascal, and so support for it will not be implemented in Free Pascal.

2. In Turbo Pascal, parameter lists of previously defined functions and procedures did not have to match exactly. In Free Pascal, they must. The reason for this is the function overloading mechanism of Free Pascal. However, the option overcomes this restriction.

3. The Turbo Pascal variables MEM, MEMW, MEML and PORT for memory and port access are not available in the system unit. This is due to the operating system. Under DOS, both the system and the extender unit (GO32) implement the mem constuct. Under Linux, the ports unit implements such a construct for the Ports variable.

4. Turbo Pascal allows you to create procedure and variable names using words that are not permitted in that role in Free Pascal. This is because there are certain words that are reserved in Free Pascal (and Delphi) that are not reserved in Turbo Pascal, such as: PROTECTED, PUBLIC, PUBLISHED, TRY, FINALLY, EXCEPT, RAISE. Using the -Mtp switch will solve this problem if you want to compile Turbo Pascal code that uses these words (chapter Alphabetical list of reserved words for a list of all reserved words).

5. The Turbo Pascal reserved words FAR, NEAR are ignored. This is because their purpose was limited to a 16-bit environment where calls were either far or near. This distinction does not exists in 32/64 bit environments.

6. The Turbo Pascal INTERRUPT directive will work only on the Free PascalDOStarget. Other operating systems do not allow handling of interrupts by user programs.

7. By default the Free Pascalcompiler uses AT&T assembler syntax. This is mainly because Free Pascaluses GNUas. However, other assembler forms are available. For more information, see the Programmer’s Guide.

8. Turbo Pascal’s Turbo Vision is available in Free Pascalunder the name of FreeVision, which should be almost 100% compatible with Turbo Vision.

9. Turbo Pascal’s ’overlay’ unit is not available. This unit had it’s purpose in a 16-bit MS-DOS environment, but in modern environments this is no longer relevant.

10. The command line parameters of the compiler are different.

11. Compiler switches and directives are mostly the same, but some extra exist.

12. Units are not binary compatible. That means that you cannot use a .tpu unit file, produced by Turbo Pascal, in a Free Pascalproject.

13. The Free PascalTextRec structure (for internal description of files) is not binary compatible with TP or Delphi.

14. Sets are by default 4 bytes in Free Pascal; this means that some typecasts which were possible in Turbo Pascal are no longer possible in Free Pascal. However, there is a switch to set the set size, see Programmer’s Guidefor more information.

15. A file is opened for output only (using fmOutput) when it is opened with Rewrite. In order to be able to read from it, it should be reset with Reset.

16. Turbo Pascal destructors allowed parameters. This is not permitted in Free Pascal: by default, in Free Pascal, Destructors cannot have parameters. This restriction can be removed by using the -So switch.

17. Turbo Pascal permits more than one destructor for an object. In Free Pascal, there can be only one destructor. This restriction can also be removed by using the -So switch.

18. The order in which expressions are evaluated is not necessarily the same. In the following expression:

    a := g(2) + f(3);

    it is not guaranteed that g(2) will be evaluated before f(3).

19. In Free Pascal, you need to use the address @ operator when assigning procedural variables.

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. Free Pascalfunctions can also return complex types, such as records and arrays.

2. In Free Pascal, you can use the function return value in the function itself, as a variable. For 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. If a recursive call is actually what is desired, you must append () after the function name:

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

3. In Free Pascal, there is partial support of Delphi constructs. (See the Programmer’s Guidefor more information on this).

4. The Free Pascalexit 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;

5. Free Pascalsupports 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 command line option disables overloading. When you use it, the above will compile, as in Turbo Pascal.

6. Operator overloading. Free Pascalallows operator overloading, e.g. you can define the ’+’ operator for matrices.

7. On FAT16 and FAT32 systems, long file names are supported.

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 Pascalis 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.

A note on long file names under DOS

Under Windows95 and higher, long filenames are supported. Compiling for the Windowstarget ensures that long filenames are supported in all functions that do file or disk access in any way.

Moreover, Free Pascalsupports the use of long filenames in the system unit and the Dos unit also for go32v2 executables. The system unit contains the boolean variable LFNsupport. If it is set to True then all system unit functions and Dos unit functions will use long file names if they are available. This should be so on Windows95 and 98, but not on WindowsNT or Windows2000. The system unit will check this by calling DOSfunction 71A0h and checking whether long filenames are supported on the C: drive.

It is possible to disable the long filename support by setting the LFNSupport variable to False; but in general it is recommended to compile programs that need long filenames as native Windowsapplications.