Free Pascal

*Free Pascal Compiler*
Free Pascal
	; Free Pascal sendo operado pela linha de comando
Desenvolvedor	Vários
Plataforma	Multiplataforma
Lançamento	1993
Versão estável	3.2.0 (Junho de 2020)
Sistema operacional	Multiplataforma
Gênero(s)	Compilador
Licença	GNU GPL
Estado do desenvolvimento	Ativo
Página oficial	www.freepascal.org

Free Pascal (também conhecido pela sigla FPC) é um compilador 32 bits/64 bits para a linguagem Pascal (dialetos: Borland Pascal, Delphi Object Pascal e algumas extensões do Mac-Pascal), escrito em Pascal e distribuído sob a licença GPL. Ele possui alto grau de compatibilidade com o antigo Turbo Pascal, bem como com versões recentes do Delphi (até a versão 7) e roda em várias arquiteturas (x86, x86-64, PowerPC, SPARC, ARM) e sistemas operacionais (Linux, FreeBSD, Mac OS X/Darwin, Mac OS Classic, DOS, Win32, OS/2, Netware (libc e classic) e MorphOS). Sua RTL (RunTime Library - biblioteca de tempo de execução) é extensa, disponibilizando uma grande quantidade de funções, rotinas e classes prontas para o programador. O projeto atualmente é liderado por Florian Klaëmpfl, mas conta com vários desenvolvedores, espalhados principalmente pela Europa.

Características do Free Pascal

Linguagem limpa e com sintaxe clara;
Não é necessário o uso de makefiles, embora seja suportado através da ferramenta fpcmake;
Compilador rápido;
Cada unit tem seus próprios identificadores, o que ajuda a evitar a poluição do namespace;
Possui uma IDE escrita usando a biblioteca FreeVision, que é um clone gratuito da famosa biblioteca TurboVision, distribuída com os compiladores Turbo Pascal e Turbo C++ da Borland;
Excelente integração com assembly, pois é possível misturar código assembly com código Pascal nos programas;
Suporte a cross-compiling, onde é possível escrever o código Pascal numa plataforma e compilar para outra, usando os utilitários da série binutils apropriados;
Suporte ao paradigma de orientação a objetos;
Smartlinking, onde somente o código realmente utilizado de cada unit incluída é ligado (estaticamente) ao executável;
Compatibilidade: o Free Pascal tem alto grau de compatibilidade com códigos já existentes, legados da época do Turbo Pascal, bem como com códigos recentes, das versões 6 e 7 do Borland Delphi.

História

O Free Pascal começou em meados da década de 1990, quando a Borland descontinuou os compiladores Turbo Pascal e Borland Pascal, deixando para trás uma grande comunidade de programadores. O Turbo Pascal e o Borland Pascal eram o topo de linha de compiladores da Borland e ainda custavam bem menos que os concorrentes (o Turbo Pascal era vendido por US$49,99). Nessa época vários projetos foram iniciados para produzir um compilador Pascal que amparasse essa comunidade. Um deles foi o FPK-Pascal, que depois se tornaria o Free Pascal e se mostrou exatamente o que a comunidade queria: um compilador Pascal de 32bits moderno, robusto, estável e confiável. Com isso, o Free Pascal começou a ganhar mais e mais adeptos e os gurus da programação em Pascal começaram a escrever seus programas com ele.

Com o advento do Delphi, o sucessor da linha de compiladores Pascal da Borland, que era o carro-chefe da Borland no desenvolvimento de aplicações comerciais para Windows 32bits, o Free Pascal acabou passando de um substituto para o Turbo Pascal a um compilador compativel com Delphi porém de código-fonte aberto, licenciado sob a GPL. A partir daí, o FPC ganhou uma comunidade ainda maior, com os servidores de download chegando a marca de aproximadamente 512GB/mês.

Inicialmente, o FPC foi escrito pelo estudante Florian Paul Klaempfl e daí vem a sigla FPK-Pascal, que em 1997 se tornou Free Pascal. Nos primeiros estágios, o FPC era escrito em Pascal com o compilador Turbo Pascal, que é de 16bits, mas já produzia código 32bits para o estender go32v1, oriundo do DJGPP. Dois anos depois, o compilador já era capaz de compilar a si próprio, no processo conhecido como bootstraping, e que é utilizado até hoje para compilar o FPC.

O projeto foi publicado na internet na mesma época em que usava o go32v1 para produzir código 32 bit e outros desenvolvedores começaram a trabalhar nele. Um deles, Michael van Canneyt, foi o responsável por portar o FPC para Linux, conseguindo uma versão 100% funcional 5 anos antes da Borland lançar o Kylix. Enquanto isso, a versão para DOS apresentava muitos progressos e foi migrada para o go32v2, um estender mais moderno do DJGPP. Nessa época, a compatibilidade com o Turbo Pascal foi abandonada em favor de um novo modo de compatibilidade com o Delphi para as próximas versões, onde também foi incluído suporte para compilar binários nativos Win32 que usa o formato PE (Portable Executable) da Microsoft.

Atualmente, a versão estável é a 2.0.4 lançada em 28 de agosto de 2006. Essa versão é, basicamente, uma versão de correções para a versão 2.0.0, lançada em maio de 2005. Trata-se de um compilador moderno e de código-fonte aberto, com uma ampla, multi-plataforma e bem documentada RTL (o FPC vem com mais de 1.800 páginas de documentação), compatível com Delphi (7 até o momento) e que, de fato, não fica devendo em nada nem para linguagem C nem para os outros compiladores Pascal.

Nessa versão, o FPC faz inlining corretamente, gera código melhor e ainda pode usar várias convenções de chamada, o que abre as portas para a programação visual em ambientes Windows. Existe um gerenciador melhor para o heap e tanto o compilador como a RTL tem suporte a multithreading e a internacionalização ajuda a traduzir sua aplicação para outras linguagens, sendo que o suporte a WideStrings (UNICODE) permite o uso dos conjuntos de caracteres mais incomuns. Além disso, a compatibilidade com o Delphi também foi melhorada, com o uso de alguns hacks para emular certas funcionalidades. O FPC também possui algumas extensões próprias, como parsing de constantes de 64 bits, interfaces e arrays dinâmicos.

Design

O FPC passou por duas grandes mudancas em seu design: quando da migração para a versão 1.0. x e para a versão 2.0. x. Na versao 1.0. x o FPC ganhou um gerador de código melhor, um novo alocador de registradores e um novo parser. Nessa versão, o scanner converte o código em tokens que depois passam pelo processo de parsing. Depois o compilador faz o primeiro passo para avaliar expressões constantes e coletar informações para o gerador de código. O segundo passo consiste em gerar o código de fato e passá-lo por um otimizador dependente de CPU. Nessa versão o FPC é dito ser um compilador de dois passos.

A versão 2.0. x tem uma arquitetura nova, de três passos: avaliação de constantes, coleta de informações e otimizações de alto nível e geração de código que é separada em front-end e back-end. Todos os passos são construídos em cima de uma arquitetura de classes e componentes reutilizáveis. Dessa forma, fica mais simples adicionar suporte a novos processadores, por exemplo. Basta sobrescrever os métodos necessários do gerador de código, o que facilita também a reescrita do compilador para outros sistemas operacionais. A arquitetura de classes também permite cada gerador de código poder aproveitar as vantagens de cada processador sem reescrever muito código, pois qualquer parte do gerador pode ser sobrescrita. Por exemplo, a linha x86 tem modos de endereçamento poderosos que podem ser utilizados para melhorar o desempenho para os índices dos arrays. Assim, basta sobrescrever a parte do gerador que gera os índices dos arrays para tirar vantagem desses modos e o desempenho aumenta. Processadores que fazem muito uso dessas vantagens são os da linha x86 e ARM.

figura compilador 2.0. x

Por último, tem-se um novo alocador de registradores. Fazendo a alocação dos registradores depois da geração do código, o compilador pode tomar decisões muito mais inteligentes a respeito da alocação dos registradores da CPU

Quanto as bibliotecas, o grande progresso foi na versão para UNIX onde é possível compartilhar código entre os diferentes sistemas operacionais dessa família.

Versões

O FPC evoluiu muito ao longo dos mais de 10 anos de desenvolvimento (o projeto começou em junho de 1993). Versões anteriores a 0.99.5 são consideradas muito obsoletas pelos desenvolvedores e, apenas após essa versão, foi introduzido um sistema de numeração de versões. Nesse sistema, versões com último número par eram versões de lançamento para os usuários e versões com último número ímpar eram versões de desenvolvimento. A partir das versões 1.0. x, o sistema de numeração de versões mudou para um sistema novo que lembrava o do núcleo Linux. Nesse novo sistema, a versões diferem no segundo número(ex: 1.0. x para 1.1. x) e o terceiro número fica para correções. Com a arquitetura antiga das versões 1.0.x era muito difícil reescrever o compilador para outras plataformas, mesmo assim existe um port dele para microprocessadores 68000, da Motorola (usado em microcomputadores Macintosh antigos e os Amiga).

Geralmente, os programadores usam a versão de lançamento, pois ela é considerada estável. Nessas versões, os problemas são revelados após curto período de tempo e existem maneiras de contorná-los. Pacotes para desenvolvedores são gerados diariamente e refletem o estado atual do compilador. Essas versões de desenvolvimento tem novas características e novos bugs. Para uso corrente, recomenda-se usar as versões de lançamento (preferencialmente a série estável 2.0.x).

Logo, vemos que a versão estável (2.0.x) deriva da série 0.99.x (entre 0.99.12b e 0.99.14). A partir desse ponto, foi criada a série 1.1.x, que deu origem à versão 1.9.x, que, por fim, chegou a estável atual, que é a 2.0.2. Nota-se também que já foi criada a série 2.1.x (a partir da série 2.0.x) mas ela ainda tem uma versão estável.

A versão mais atual é a versão 2.4.4.

Linguagem

A linguagem Pascal foi criada pelo professor Niklaus Wirth, do ETH de Zurique, em 1970, baseando-se no ALGOL. Ela foi criada inicialmente com o intuito de ensinar programação, mas depois revelou-se uma linguagem de propósito geral, que pode ser usada para qualquer tarefa em desenvolvimento de software. A Borland, por sua vez, criou a variante mais conhecida do Pascal, o Turbo Pascal, em 1983, vendendo por correspondência uma solução integrada (editor + compilador + linker) por US$ 49,95, apenas 10% do preço de outros compiladores comerciais. O Turbo Pascal foi desenvolvido até a versão 7.0, sendo substituído no plano de negócios da Borland pelo Delphi.

Apesar do Pascal ser originalmente uma linguagem estruturada, a Borland introduziu no Pascal o paradigma de orientação a objetos a partir do Turbo Pascal 5.5 (que hoje é de livre distribuição).

O FPC suporta a imensa maioria das construções usadas no Delphi e no Turbo Pascal. Ele implementa os dialetos Borland Pascal e Object Pascal (utilizado no Delphi) mais algumas extensões extra do Mac-Pascal e alguns patches para garantir compatibilidade com os dialetos padronizados (ISO/IEC 7185). É notável a grande comunidade de programadores que Pascal possui entre usuários de Macs, tanto que os primeiros Macintosh e o Apple Lisa dependiam muito de Pascal e as APIs em C do MacOS tem que lidar com tipos de dados do Pascal. A linguagem Pascal tem uma sintaxe muito clara e simples, porém poderosa, suportando o uso de ponteiros, enumerações e tipos de dados packed. Pascal foi criticada por muito tempo sob a alegação de que não servia para outro nicho que não fosse o acadêmico. Brian Kernigham, um dos desenvolvedores da linguagem C, em seu artigo "Por que Pascal não é a minha linguagem favorita" aponta vários problemas com a linguagem Pascal, os quais felizmente, hoje em dia, não estão mais presentes nas implementações mais atuais. Apesar disso, Kernigham acabou por acertar prevendo que o Pascal teria problemas por causa da incompatiblidade entre compiladores e padrões, com a Borland de um lado e o padrão ISO do outro. Felizmente, o FPC está vindo para derrubar essas incompatibilidades.

Note-se ainda que o FPC implementa algumas extensões que não existem nem no Delphi, nem no Turbo Pascal. Algumas delas são: retorno tipos de dados complexos como records e arrays, sobrecarga de funções e de operadores. Alem disso, o Free Pascal suporta o uso da linguagem Assembly no código-fonte, permitindo o uso da sintaxe Intel 80x86 ou AT&T, convertendo entre uma e outra se necessário.

Programação orientada a objetos (POO)

Com o Turbo Pascal 5.5, escrito em assembly por Anders Hejlsberg e que, na época, era funcionário da Borland, o Pascal ganhou suporte ao paradigma de orientação a objetos inspirado pelos escritos de Larry Tesler (Object Pascal Report - Apple, 1985) e Bjarne Stroustroup (The C++ Programming Language - Addison-Wesley, 1986). Seu debugger também ganhou modificações para suportar o novo paradigma. O Turbo Pascal se destacava também pela altíssima velocidade de compilação (~34000 linhas/minuto) e pela qualidade do código gerado.

O FPC suporta o paradigma de orientação a objetos muito bem, tendo compatibilidade com a maioria dos códigos modernos feitos em Delphi ou legados do Turbo Pascal que usem POO. Em delphi, os programas são do tipo GUI por padrão sendo necessário o uso da diretiva {$APPTYPE CONSOLE} para criar programas em modo console. O FPC suporta essa diretiva, mas por padrão os programas são para modo console, sendo necessário utilizar uma outra diretiva: {$APPTYPE GUI} para escrever programas com GUI para Windows.

O compilador suporta tanto o estilo antigo do Turbo Pascal de utilizar objetos, pelo uso da palavra reservada object e onde todos os objetos herdam de TObject quanto o estilo novo do Delphi, onde tudo gira em volta da palavra reservada class e onde todas as classes herdam de TClass. TObject e TClass estão definidos na unit System. Para usar extensões orientadas a objetos devem ser usados quando os parâmetros do compilador: -S2 (para modo Object Pascal) ou -Sd (para modo Delphi). Os mesmos efeitos podem ser conseguidos utilizando as diretivas {$MODE OBJFPC} ou {$MODE Delphi} colocadas no código-fonte. Para descrições detalhadas destes e de outros modos de operação do compilador, consulte o Apêndice D do Free Pascal Programmer's Manual (http://www.freepascal.org/docs-html/prog/prog.html).

IDE

Dado o sucesso do Free Pascal e sua grande comunidade de usuários, acabaram por surgir vários projetos para prover uma IDE para o compilador. Um deles é a própria IDE que vem junto com o pacote oficial do compilador. Ela é escrita usando a FreeVision, que é um port para o Free Pascal da famosa biblioteca de widgets modo console da Borland, a Turbo Vision. A IDE oficial, disponível apenas para DOS, Windows e Linux, está muito bem documentada no capítulo 6 do Free Pascal User's Manual (http://www.freepascal.org/docs-html/user/user.html) e tenta se aproximar do visual e das características da IDE do Turbo Pascal; dessa forma os programadores vindos dele se sentem confortáveis para usá-la.

imagem IDE FPC

Outras IDEs para o FPC são:

DevPascal: é o primo desconhecido do famoso Dev-C++, feito pelo mesmo time de desenvolvedores. Apesar de ser uma ótima IDE e suportar o Free Pascal nativamente, ele parece estar descontinuado. Seu código fonte em Delphi bem como o programa compilado estão disponíveis para download no site oficial: http://www.bloodshed.net/devpascal.html.
Lazarus: o Lazarus é um projeto que visa criar um RAD clone do Delphi com o Free Pascal como compilador. Ele procura manter compatibilidade com o Delphi quando possível, mas roda em Linux e Windows e está num estágio bastante avançado em seu desenvolvimento. O lazarus é baseado na sua própria biblioteca de componentes visuais e não-visuais: a LCL (Lazarus Component Library). Ele é licenciado sob a GPL e pode ser copiado em seu site oficial: http://www.lazarus.freepascal.org
MOS (Master Operating System): é uma IDE para DOS contendo um kit completo de widgets para criação de aplicações com excelente aparência. O MOS é um projeto que está descontinuado (até a data da escrita deste artigo), mas as telas mostradas no site oficial são muito boas, ele é compatível com o Free Pascal e seu código-fonte está sob a licença GPL exceto pela biblioteca Graphix de Michael Knapp (http://www.cg.tuwien.ac.at/~knapp/graphix_old/gxframe.html), que, apesar de ser de livre distribuição, não tem o código fonte aberto. O download pode ser feito em: http://jp.planas.free.fr/main.htm
MSEGUI + MSEIDE: MESEIDE é uma ferramenta RAD para a produção de aplicações gráficas para Linux e Windows usando a framework MSEGUI. De certa forma é semelhante ao projeto Lazarus, porém não tem compromisso de compatibilidade com Delphi, sendo portanto uma nova e diferente ferramenta. No dia 27 de janeiro de 2007 foi lançada a versão 1.0 desta ferramenta que pode ser obtida em http://mypage.bluewin.ch/msegui/
WOLGUI: é um kit de ferramentas e uma biblioteca que foi desenvolvida em Free Pascal para gerar interfaces de aplicações usando Object Pascal. Inicialmente, estava planejada para Windows e GTK 1 (nativos). Após a substituição da GTK versão 1 pela versão 2, começou-se a desenvolver a nova versão para GTK 2 dessa biblioteca. Esse "framework" vem com uma ferramenta comparável a uma IDE, embora seja destinada à criação de objetos de janela.

Bibliotecas

O FPC vem com um conjunto muito vasto de bibliotecas e componentes prontos para serem usados pelo programador. Esse conjunto engloba a FCL (Free Component Library), que é um conjunto de classes não-visuais que o programador deve usar para executar tarefas rotineiras no desenvolvimento de software e que tenta se aproximar o máximo possível da VCL do Delphi. A FCL é distribuída junto com o pacote oficial do Free Pascal; seus principais componentes são:

classes: implementa a unit de classes do Delphi com várias outras classes úteis como StringLists, Streams, TPersistent, Twriter
idea: implementa o sistema de criptografia IDE
db: implementa o TDataSet junto com os descendentes conscientes de dados do TDataBase
mysqldb: contém um descendente do TDataSet que acessa o banco de dados MySQL
dom: contém uma implementação do Document Object Model de acordo com as especificações do W3C
xmlcfg, xmlread e xmlwrite: implementam classes para manipular arquivos XML, usando-os como arquivos de configuração, leitura e escrita
zstream: implementa leitura/escrita de streams comprimidos no formato .gz

Além da FCL, o Free Pascal conta ainda com a RTL e com alguns pacotes extra. A RTL (RunTime Library) é o conjunto de componentes que fornece as rotinas para execução básica do programa (como as funções writeln e readln, equivalentes a printf e scanf do C). Ela possui muitas funções e classes prontas para serem usadas e que tem boa compatibilidade com aquelas presentes no Delphi e Turbo Pascal. Por cima destas últimas estão rotinas básicas para acesso ao teclado, ao mouse e a gráficos em modo console de uma maneira multiplataforma. Existem ainda rotinas matemáticas, de sockets, impressora, strings, para acessar o estender go32v2 do DOS e para acessar o conjunto de instruções MMX do processador. A documentação completa de todas as units da RTL está em:

Os pacotes extra, que também vem com o Free Pascal, fornecem um conjunto de classes para dar uma abordagem orientada a objetos para algumas bibliotecas conhecidas. Eles são bastante úteis e funcionam muito bem. Dentre os principais estão:

gdbint: interface para o debugger GDB
ibase: interface para o banco de dados Interbase
inet: rotinas de programação para internet
md5: cálculo de hashes usando o algoritmo MD5
mysql: interface para a API do banco de dados MySQL
paszlib: implementação em Pascal da Zlib
regexpr: rotinas para trabalhar com expressões regulares

Existem ainda pacotes para: GTK, OpenGL, libPNG, SVGALib, tcl e X11. Para encontrar muitas outras bibliotecas e units para o FPC, vá em: http://www.freepascal.org/contrib/db.php3

Exemplo

Para exemplificar o uso do Free Pascal, um programa completo será mostrado aqui. Trata-se de uma ferramenta desenvolvida com o propósito de extrair informações de roms do console Sega Genesis/Mega Drive. Ela ilustra vários aspectos do Free Pascal e não foram feitas quaisquer otimizações ou depuração; o código-fonte está comentado para explicar os comandos usados. É uma ferramenta apenas para uso educacional sem quaisquer garantias quanto ao seu funcionamento. Todas as funções e comandos utilizados estão documentados em http://www.freepascal.org/docs-html/rtl/index.html


// isto é um comentário
// o FPC também aceita comentários no estilo turbo pascal, usando { e }
//
// Sega Genesis ROM tool - feito com o FreePascal 2.0.0
// ultima alteração: 30.07.2005
//
// algoritmo para cálculo do checksum do arquivo .bin e informações
// sobre o formato da rom extraídos de THE COMPLETE DOCUMENTATION ABOUT GENESIS
// ROM FORMAT - versão 1.2 por Felipe Xnak (felipe@ComPorts.com) e
// Volker Oth (dOnut) (volkeroth@aol.com)
// a versão mais atual deste documento pode ser encontrada em
// http://www.classicgaming.com/launchtool
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

program SegaGenRomTool;

//A unit system para Win32 é incluída por padrão

uses Sysutils; //funções extra para manipulação de strings

procedure RomCheck(filename: string);
var
    rom: File of byte;
    rom_size: DWord; // número inteiro de 32bits sem sinal
    i: byte; // número inteiro de 8bits sem sinal
    buffer_48b: array [1..48] of byte;  //buffer de 48 bytes
    buffer_16b: array [1..16] of byte;  //buffer de 16 bytes
    bytes_read: DWord; // número inteiro de 32bits sem sinal
    chksum: Word; // número inteiro de 16bits sem sinal
    j: byte; // número inteiro de 8bits sem sinal
begin
    //atribui o arquivo a rom
    assign(rom, filename);
    //abre o arquivo para leitura
    reset(rom);
    rom_size:=FileSize(rom);
    writeln();
    writeln('Opening ', filename);
    writeln('-> Size: ', rom_size, ' bytes');
    //pula os primeiros 256 bytes
    Seek(rom, 256);
    //le 16 bytes com o nome do console
    blockread(rom, buffer_16b, 16);
    write('-> Console: ');
    for j:=1 to 16 do
      begin
        write(chr(buffer_16b[j])); //escreve na tela cada caracter do buffer
      end;

    writeln();

    //le 16 bytes com a data
    blockread(rom, buffer_16b, 16);
    write('-> Date: ');
    for j:=1 to 16 do
      begin
        write(chr(buffer_16b[j]));
      end;

    writeln();

    //le o nome original da rom

    blockread(rom, buffer_48b, 48);
    write('-> Original rom name: ');
    for j:=1 to 48 do
      begin
        write(chr(buffer_48b[j]));
      end;

    writeln();

    //read 'international' rom name
    blockread(rom, buffer_48b, 48);
    write('-> International rom name: ');
    for j:=1 to 48 do
      begin
        write(chr(buffer_48b[j]));
      end;

    writeln();

    //le informações sobre o tipo de produto
    blockread(rom, i, 1);
    if chr(i) = 'G' then
      begin
        blockread(rom, i, 1);
        if chr(i) = 'M' then
          writeln('-> Product Type: Game');
      end
    else
      if chr(i) = 'A' then
        begin
          blockread(rom, i,1);
          if chr(i) = 'I' then
            writeln('-> Product Type: Educational');
        end
      else
        writeln('-> Product Type: ?');

    //le informações sobre o suporte a I/O da rom
    seek(rom, 400);
    blockread(rom, buffer_16b, 16);
    writeln('-> I/O Support:');

    for j:= 1 to 16 do
      begin
        case chr(buffer_16b[j]) of
          'J': writeln('  ->Joypad');
          '6': writeln('  ->6-button joystick');
          'K': writeln('  ->Keyboard');
          'P': writeln('  ->Printer');
          'B': writeln('  ->Control Ball');
          'F': writeln('  ->Floppy disk drive');
          'L': writeln('  ->Activator');
          '4': writeln('  ->Team Play');
          '0': writeln('  ->Joystick for MS');
          'R': writeln('  ->Serial RS-232C');
          'T': writeln('  ->Tablet');
          'V': writeln('  ->Paddle Controller');
          'C': writeln('  ->CD-ROM');
          'M': writeln('  ->Mega Mouse');
        else
          continue;
        end;
      end;

    //posição para cálculo do checksum
    seek(rom, 512);
    bytes_read:=512;

    chksum := 0;
    while bytes_read < rom_size do
      begin
        //algoritmo de calculo de checksum
        blockread(rom, i,1); //le próximo byte
        chksum := chksum + i*256;
        inc(bytes_read);
        blockread(rom, i,1);
        chksum := chksum + i;
        inc(bytes_read);
      end;
    writeln('-> Calculated checksum: ', hexstr(chksum, 4));
    //volta o ponteiro para o começo da rom
    seek(rom,0);
    //o checksum fica armazenado nos bytes 399 e 400
    seek(rom, 398);
    write('-> Read checksum: ');
    blockread(rom, i,1);
    write(hexstr(i,2));
    blockread(rom, i,1);
    write(hexstr(i,2));
    writeln();
    close(rom);
end;

//retirado do manual da RTL
Function FileExists (Name : String) : boolean;
Var
  F : File;
begin
  {$I-} //desliga geração de código para verificar erros
  Assign (F,Name); //faz o teste
  Reset (F);
  {$I+} //liga geração de código para verificar erros
  FileExists:=(IoResult()=0) and (Name<>''); //usa a função IoResult para verificar
  Close (F);
end;

//início do programa
begin
  writeln('Sega Genesis ROM Tool 1.0');
  if Paramcount = 0 then
    writeln('   Usage: ', ExtractFileName(paramstr(0)), ' romname.bin')
  else
    if paramcount = 1 then
      if FileExists(paramstr(1)) then
        begin
          RomCheck(paramstr(1));
        end
      else
        begin
          writeln('File ', paramstr(1), ' not found!');
        end
    else
      begin
         writeln('Usage: ', ExtractFileName(paramstr(0)), ' romname.bin');
      end;
end. //fim do programa

Ferramentas extra

O FPC conta ainda com um conjunto de ferramentas linha de comando extra para ajudar o programador a desenvolver seu software. São elas:

h2pas: é um pequeno utilitário linha de comando para converter header de C para units Pascal. Os desenvolvedores do Free Pascal o usam para gerar units para bibliotecas importantes como GTK e MySQL.
fpcmake: é a ferramenta que dá suporte ao uso de makefiles para compilar programas no FPC. Os desenvolvedores do FPC a usam para criar todos os makefiles.
ppdep: gerador de dependências para um programa ou unit; gera um arquivo que pode ser usado no make e entende símbolos e interdependência entre units.
delp: apaga arquivos deixados pelo FPC, após compilar um programa.
ppudump: extrai o conteúdo da unit para um formato legível; entende versões antigas, da época do Turbo Pascal.
ppufiles: lista os arquivos objeto que você precisa ligar ao programa quando usando uma certa unit. Mostra todas as bibliotecas e units necessárias.
ppumove: combina várias units em uma; pode ser usado para criar bibliotecas estáticas e dinâmicas.
ptop: é um formatador de código configurável. Ele organiza e imprime o código, como o indent faz com códigos em C.
rstconv: conversor de arquivos .rst (que contêm strings usadas como recursos) criados pelo compilador para formato GNU gettext (outros ainda estão por vir).

TP Lex and Yacc: usados para criar units em Pascal a partir de um vocabulário Lex e uma gramática Yacc; escritos por Albert Graef.

Bibliografia

Dominando Delphi 7 - A biblia (Marco Cantú)
Delphi in a Nutshell (Ray Lischner; O'Reilly)
Algorithms (versão em Pascal) (Sedgewick)
Turbo Pascal 5.5 - Object Oriented Programming Guide (ebook - Borland)
Object Pascal Language Guide (Borland; incluído na documentação do Delphi)
Turbo Pascal 7 - caderno de mão (Werner Fiebel)
Algoritmos e Estruturas de dados (Nikhlaus Wirth)
Projeto de algoritmos com implementações em Pascal e C (Nivio Ziviani).