de turbo pascal para free pascal

Este documento contém algumas informações sobre as diferenças existentes entre o compilador Free Pascal e o compilador Turbo Pascal 7.0 da Borland. A lista a seguir não está completa, mas apresenta alguns detalhes importantes.

  • Assembly

    • O padrão assembly utilizado pelo FPC possui sintaxe diferente do padrão TP7, mas você poderá vir a utilizar o estilo assembly Intel (semelhante ao modo utilizado pelo Turbo Pascal da Borland) usando o comando -Rintel nas opções de linha de comando adicionando os parâmetros {intel de $asmmode} no programa fonte.

    Possui um modelo de memória de 32 bits que requer um recoding completo de seus blocos de assembler.

  • Biblioteca de Run-Time

    • Para usar o PORT array, adicione a unidade Ports junto com a cláusula USES (disponível apenas para Dos/Go32v2 e Linux).

    Você pode ter acesso ao modo real de memória usando MEM[seg:ofs] (como também MemW e MemL) somente sob Go32v2.

    Ofs() retorna longint em vez de word.

    A unidade (unit) OVERLAY não está disponível.

    Turbo Vision não está ainda disponível (problemas com copyright).

    O suporte aos recursos do pacote Turbo Vision será fornecido pelo pacote Free Vision, ainda não disponível, pois o copyright do Turbo Vision ainda não foi liberado pela Borland.

  • Preprocessador/Sintaxe

    • Se você usar o parâmetro -So na linha de comando (ou adicionar a diretiva {$mode TP} em seu programa fonte), o compilador FPC será colocado em modo Turbo Pascal tornado-se compatível. Esta opção quando ativada incapacitará algumas das características avançadas do FPC.

    São permitidos comentários aninhados (em modo TP desabilitado).

  • Sintaxe

    • FAR e NEAR são ignorados.

    Para adquirir o endereço de uma procedure e então associá-lo a uma variável do tipo procedure é necessário utilizar o operador “@” arroba (em modo TP, procedure variável pode ser trabalhada em TP): 

        procedure p;
    begin
      {....}
    end;

    var
      proc : procedure;
    begin
      proc:=@p;
    end;

    INLINE é suportado pelo compilador, porém é usado em modo inline no código pascal e não em modo bytecode.

    Os cabeçalhos declarados de functions/procedures deverão ser reescritos na definição, caso contrário o compilador pensará que eles serão executados em overloaded (não requer o uso do parâmetro -So).

    Possui um conjunto maior de palavras reservadas.

    Algumas extensões Delphi são parcialmente suportadas.

  • Semântica

    • O tamanho máximo de parâmetros que pode ser passado em uma sequência de dados é de 64K para a versão Intel e 32K para a versão Motorola.

    Records são sempre alinhados como word; use 'packed record' ou {$PACKRECORDS 1} para conseguir records compatíveis com TP. Observação: utilize o recurso de package somente em casos onde seu uso é necessário, pois poderá não trabalhar adequadamente com os campos (de um registro) em processadores de não Intel (além do fato de reduzir a velocidade de acesso da estrutura de dados do registro): 

        type 
      r1 = record
             a : byte;
             b : word;
           end;

      r2 = packed record
             a : byte;
             b : word;
           end;

    begin
      writeln(sizeof(r1));  { outputs 4 }
      writeln(sizeof(r2));  { outputs 3 }
    end.

    Atenção: atualmente todos os conjuntos de dados utilizados no FPC são do tipo longint ou do tipo 32 byte de acordo com seu tamanho, no TP o conjunto de dados são do tipo byte ou do tipo word e são classificadas segundo o tamanho. Um trabalho de desenvolvimento atual está declarando o conjunto de dados para os tipos byte/word. Claro que, esta informação torna-se necessária caso você precisa utilizar registros compatíveis com TP, caso contrário poderá ser utilizado sem nenhum problema o conjunto de dados para o padrão FPC.

    Resultados de funções poderão ser tipos complexos como arrays ou records (não em modo TP).

    Possui um conjunto maior de palavras reservadas.

    É possível direcionar o resultado de função em uma função como uma variável (isto não se aplica em modo TP): 

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

    O exemplo anterior trabalha em modo TP, porém o compilador assumiria que a condição a > 4 é uma chamada recursiva. Para fazer uma chamada recursiva em FPC é necessário anexar () logo atrás do nome de função (isto não se aplica em modo TP): 

        function a : longint;
    begin
      a := 12;
      { *** esta e uma chamada recursiva *** }
      while a() > 4 do
        begin
          {...}
        end;
    end;

    O comando exit da procedure também utiliza o resultado da função como seu parâmetro: 

        function a : longint;
    begin
      a:=12;
      if a>4 then
        exit(a*67);
    end;

    Funções como as a seguir sempre deverão sempre ser definidas com o cabeçalho completo (isto não se aplica em modo TP): 

        procedure x(v : longint); forward;

    procedure x; { this overloads the procedure x !!!!}
    begin
      { ... }
    end;

    { write instead: }

    procedure x(v : longint);
      begin
       { ... }
      end;
  • Outros

    • Os parâmetros de linha de comando são diferentes.
    Não são implementadas todas as diretivas de compilação.
    As units não são compatíveis em modo binário.