Compilando projetos Delphi

por linha de comando

Neste artigo será demonstrada a utilização do compilador do Delphi por linha de comando

Jeferson Oliveira
TechTips.com.br
 Compilando projetos Delphi por linha de comando

Introdução

Neste artigo será demonstrada a utilização do compilador do Delphi por linha de comando:
como acioná-lo manualmente, como automatizar a compilação de um projeto, e as
diferentes possibilidades de configurações permitidas.

Para os exemplos apresentados aqui será utilizado o Delphi 7, mas as mesmas

configurações poderão ser utilizadas sem muitas alterações em qualquer versão do Delphi.

O problema

A compilação de um projeto precisa ser um processo rápido e eficiente. O tempo gasto para
abrir o IDE do Delphi, aguardar que ele esteja completamente carregado, abrir o projeto
que precisa ser liberado, para só então dar início à compilação, será sempre maior do que o
tempo realmente necessário pelo compilador para a geração do arquivo final.

A solução

Para simplificar essa tarefa, tornando-a mais ágil e confiável, temos a possibilidade de
acionar o compilador por linha de comando. Esse processo, se corretamente configurado,
produzirá o mesmo resultado que seria obtido ao compilar o projeto pelo IDE do Delphi.

O compilador

O compilador do Delphi é o arquivo dcc32.exe que fica localizado em $(DELPHI)\Bin. Para

listar os parâmetros do compilador, basta digitar dcc32 no prompt de comando do Windows.

Nota: Se houver mais de uma versão do Delphi instalada no

computador, digitar apenas dcc32 acionará a primeira versão do
compilador encontrada na variável de ambiente “PATH” do
Windows. Nesses casos, para acionar uma versão específica do
compilador, indique o caminho completo do arquivo dcc32.exe.

Abaixo um exemplo das informações exibidas no prompt de comando ao executar o

dcc32.exe sem informar qualquer parâmetro:

C:\>dcc32
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation

Syntax: dcc32 [options] filename [options]

-A<unit>=<alias> = Set unit alias -LU<package> = Use package

-B = Build all units
-CC = Console target
-CG = GUI target
-D<syms> = Define conditionals
-E<path> = EXE output directory
-F<offset> = Find error
-GD = Detailed map file
-GP = Map file with publics
-GS = Map file with segments
-H = Output hint messages
-I<paths> = Include directories
-J = Generate .obj file
-JP = Generate C++ .obj file
-K<addr> = Set image base addr
-M = Make modified units
-N<path> = DCU output directory
-O<paths> = Object directories
-P = look for 8.3 file names also
-Q = Quiet compile
-R<paths> = Resource directories
-U<paths> = Unit directories
-V = Debug information in EXE
-VR = Generate remote debug (RSM)
-W = Output warning messages
-Z = Output 'never build' DCPs
-$<dir> = Compiler directive
--help = Show this help screen
--version = Show name and version

-2-
 Compilando projetos Delphi por linha de comando

Compiler switches: -$<letter><state> (defaults are shown below)

A8 Aligned record fields
B- Full boolean Evaluation
C+ Evaluate assertions at runtime R- Range checking
D+ Debug information
G+ Use imported data references
H+ Use long strings by default
I+ I/O checking
J- Writeable structured consts
L+ Local debug symbols
M- Runtime type info
O+ Optimization
P+ Open string params
Q- Integer overflow checking
T- Typed @ operator
U- Pentium(tm)-safe divide
V+ Strict var-strings
W- Generate stack frames
X+ Extended syntax
Y+ Symbol reference info
Z1 Minimum size of enum types

Todos os parâmetros do compilador devem ser precedidos por hífen (-) ou por barra (/).

Entre os diversos parâmetros existentes, os mais relevantes para nosso exemplo são:

B: Indica que deverão ser compiladas todas as units do projeto. É equivalente à opção
“Build” disponível no menu “Projects” do Delphi;

H: Habilita (-H+) ou desabilita (-H-) a exibição de hints.

Q: será realizada uma compilação silenciosa, não emitindo informações sobre todos os
arquivos processados pelo compilador. Hints, warnings e erros serão exibidos normalmente.

R: Lista de diretórios nos quais o compilador irá buscar por arquivos de recursos (.RC,
.RES) utilizados no projeto;

U: Lista de diretórios nos quais o compilador irá procurar arquivos .PAS ou .DCU utilizados
no projeto;

W: Habilita (-W+) ou desabilita (-W-) a exibição de mensagens do compilador. Para

habilitar ou desabilitar um alerta específico, basta citar os alertas após o parâmetro,
precedidos de + ou -. Exemplo: -W-UNIT_PLATFORM +UNIT_DEPRECATED

Nota: Nos parâmetros que indicam diretórios, caso mais de um

diretório seja listado, eles deverão estar separados por ponto e
vírgula (;).

Nosso projeto de exemplo

Vamos criar um novo projeto, que não fará nada além de produzir algumas situações que
nos permitirão tirar proveito dos recursos do compilador. No Delphi 7 acesse
File/New/Aplication. Adicione ao form um TFileListBox e um TButton. No evento OnClick do
botão, defina o código abaixo:

procedure TfrmPrincipal.btnFazNadaClick(Sender: TObject);

var
i: Integer;
s: string;
begin
s := 'alo mamae';
ShowMessage(s);
end;

Salve a unit como Principal.pas, salve o projeto como Compila.dpr e defina a propriedade
Name do form como frmPrincipal.

-3-
 Compilando projetos Delphi por linha de comando

Compilação manual

Vamos então começar o uso do compilador. Inicie o prompt de comando do Windows e

digite o caminho do compilador seguido do caminho completo do arquivo DPR. Por exemplo:

C:\>dcc32 T:\ProjetoExemplo\Compila.dpr

Ao executar esse comando será retornado um erro, indicando que o arquivo Principal.dcu
não foi encontrado. Esse erro ocorre porque nenhum Principal.pas nem Principal.dcu foram
encontrados nos diretórios conhecidos pelo dcc32. Uma forma simples de evitar esse
problema é sempre iniciar a compilação a partir do diretório do projeto. Para isso basta
alterar o diretório corrente antes de executar o compilador. Como exemplificado abaixo:

C:\>T:
T:\>cd ProjetoExemplo
T:\ProjetoExemplo>dcc32 Compila.dpr

Se tudo correu bem, nesse ponto a compilação foi executada sem erros, e o arquivo
Compila.exe foi gerado corretamente. Porém, algumas mensagens foram exibidas pelo
compilador:

Principal.pas(7) Warning: Unit 'FileCtrl' is specific to a platform

Principal.pas(29) Hint: Variable 'i' is declared but never used in
TfrmPrincipal.btnFazNadaClick'

Os hints foram exibidos porque nas propriedades do projeto a opção “Show hints” está
marcada, o que seria equivalente a passar o parâmetro /H+. Os hints são importantes, pois
indicam situações que podem ser melhoradas no nosso código. Afinal, se a variável “s” não
é utilizada em nenhum ponto do código, para quê declará-la? É possível desabilitar a
exibição de hints passando o parâmetro /H-, mas a melhor forma mesmo de evitar essas
mensagens é fazendo os ajustes necessários no seu código. No nosso caso vamos então
remover a declaração da variável i, que é desnecessária.

Mas, para quem desenvolve somente aplicações para Windows, qual a relevância do alerta
que indica que a unit FileCtrl é específica dessa plataforma? Nenhuma. Nesse caso, para
deixarmos o log enxuto, contendo apenas as mensagens realmente necessárias, podemos
desabilitar esse warning listando-o no parâmetro W. Como o arquivo Principal.dcu já se
encontra no diretório e nenhuma alteração foi realizada em Principal.pas ele não precisará
ser compilado novamente. Para forçar a compilação de todos os arquivos do projeto vamos
inserir também o parâmetro B, que indica ao compilador que deve ser realizada uma
compilação de todos os arquivos. O compilador exibe informações sobre cada arquivo sendo
compilado. Se desejar omitir essas informações acrescente o parâmetro Q. Ficamos então
com o seguinte comando:

T:\ProjetoExemplo>dcc32 -B Compila.dpr -Q -W-UNIT_PLATFORM

Nesse ponto a compilação deve ser executada sem qualquer dica ou alerta, ficando a saída
parecida com o exemplo abaixo:

Borland Delphi Version 15.0

Copyright (c) 1983,2002 Borland Software Corporation
52 lines, 0.20 seconds, 358352 bytes code, 7749 bytes data.

Automatizando a compilação

Já conseguimos compilar nosso projeto invocando manualmente o compilador pelo prompt

de comando. Mas, como o processo de compilação precisa ser repetido inúmeras vezes, a
qualquer tempo, não seria conveniente a cada compilação digitarmos os comandos no

-4-
 Compilando projetos Delphi por linha de comando

prompt. Para automatizar esse processo, podemos criar um arquivo de script com os
comandos necessários. Crie um novo arquivo .CMD e insira nele os comandos. Segue o
conteúdo do meu arquivo Compila.cmd:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=ProjetoExemplo
set DIR_DELPHI=c:\Progra~1\Borland\Delphi7\Bin
set COMP_MSGS=-UNIT_PLATFORM

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\dcc32.exe -B %PRJ% -Q -W%COMP_MSGS%

Algumas variáveis foram criadas no arquivo para simplificar a manutenção dos comandos de
compilação. Embora a definição dessas variáveis não seja indispensável para esse processo,
seu uso é recomendável.

Agora temos uma forma automatizada de compilar nosso projeto, bastando para tanto
executar o arquivo Compila.cmd, seja pelo prompt de comando, ou mesmo pelo Windows
Explorer.

Definindo os diretórios de componentes

Se utilizássemos em nosso projeto componentes de terceiros, os diretórios onde se

encontram seus arquivos de recursos e units precisariam ser informados para o compilador.
Para isso são disponibilizados os parâmetros R e U.

Se, por exemplo, utilizássemos um TJvFileListBox, que é um componente da JVCL, bastaria

indicar os diretórios da JVCL em nosso arquivo. Como no exemplo abaixo:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=ProjetoExemplo
set DIR_DELPHI=c:\Progra~1\Borland\Delphi7\Bin
set COMP_MSGS=-UNIT_PLATFORM
set SEARCH_PATH=D:\Delphi\jcl\lib\d7;D:\Delphi\jvcl\lib\d7
set RES_PATH=D:\Delphi\jvcl\resources

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\dcc32.exe -U%SEARCH_PATH% -R%RES_PATH% -B %PRJ% -Q -W%COMP_MSGS%

Configurações por projeto

Em alguns projetos é comum utilizarmos vários componentes de terceiros, habilitarmos ou

desabilitarmos mensagens do compilador, entre tantas outras configurações que podem ser
alteradas com freqüência. Embora o nosso arquivo de script permita configurar todas essas
opções atualizá-lo à cada mudança das configurações do projeto não será uma tarefa tão
cômoda. Uma maneira mais simples de realizar essas configurações é através das opções
do projeto (menu Project/Options). As configurações alteradas pelas opções do projeto
serão salvas nos arquivos Compila.cfg e Compila.res, que serão automaticamente lidos pelo
dcc32.exe.

-5-
 Compilando projetos Delphi por linha de comando

Nota: ao utilizar configurações personalizadas por projeto, não

se esqueça de adicionar os arquivos .CFG .RES ao controle de
versão.

Vamos tirar proveito da facilidade das configurações visuais e organizar um pouco nosso
projeto. Crie os diretórios bin e dcu dentro do diretório do projeto. Nesses diretórios serão
colocados respectivamente o arquivo de saída do nosso projeto (.EXE, .DLL, etc.) e os
arquivos .DCU. Para indicar ao compilador como usar esses diretórios acesse as opções do
projeto. Na aba “Directories/Conditionals” preencha os campos “Output directory” e “Unit
output directory”.

No campo “Search path” indique os diretórios dos componentes utilizados no projeto.

-6-
 Compilando projetos Delphi por linha de comando

Caso no projeto sejam utilizadas diretivas de compilação, bastaria indicá-las no campo

“Conditional defines”.

Na aba “Compiler messages” certifique-se que as opções “Show hints” e “Show warnings”
estejam selecionadas. Uma lista de warnings é exibida nessa aba, permitindo desabilitar
aquelas que não são relevantes para o projeto.

Após concluir essas configurações não será mais necessário indicar no nosso arquivo de
script os diretórios de recuros e de units, nem mesmo indicar os alertas que deverão ser
desabilitados, o que reduzirá o conteúdo do arquivo:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=ProjetoExemplo
set DIR_DELPHI=c:\Progra~1\Borland\Delphi7\Bin

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\dcc32.exe -B %PRJ% -Q

Configurações por máquina

Com a utilização do arquivo de configurações do projeto ganhamos a possibilidade de

realizar uma edição visual das configurações da compilação.

Normalmente um build completo só é realizado na máquina de liberação de versão, o que

fica a cargo do administrador do projeto, mas é possível que um projeto possua vários
desenvolvedores, trabalhando cada um em sua máquina, ou mesmo trabalhando
remotamente, em ambientes diferentes, e seja necessário ou desejado que todos possam
utilizar as mesmas configurações de compilação nos diversos ambientes. Nesses casos,
utilizar um único arquivo de configuração por projeto exigirá que em todas as máquinas os
componentes estejam instalados nos mesmos diretórios, ou ao menos estejam em uma
estrutura de diretórios que possa ser referenciada por caminhos relativos. O que pode ser

-7-
 Compilando projetos Delphi por linha de comando

um problema se no projeto trabalharem desenvolvedores free-lancers. Uma forma de

contornar esse problema é referenciando os componentes por diretórios virtuais, criados
pelo comando subst no prompt de comando do Windows. Mas, ainda assim, seria necessário
que os mesmos diretórios virtuais fossem criados em todos os computadores. Outra
maneira é utilizar configurações gerais por máquina.

Sempre que o compilador é acionado ele busca por configurações no arquivo dcc32.cfg que
se encontra no mesmo diretório que o arquivo dcc32.exe, depois procura pelo arquivo
dcc32.cfg no diretório do projeto e, finalmente, pelo arquivo NomeDoProjeto.cfg, no nosso
caso Compila.cfg, no diretório do projeto. Todas as configurações são consideradas, o que
significa que podemos fazer uso de mais de um arquivo ao mesmo tempo. Para o problema
citado acima, onde cada máquina pode possuir configurações diferentes, os parâmetros
referentes a diretórios componentes poderiam ser definidos em $(Delphi)\Bin\dcc32.cfg,
pois podem variar por máquina, e as demais configurações que são gerais, como exibição
de alertas, diretivas de compilação, e diretórios para geração de dcus e binários, poderiam
ser mantidas no arquivo de configuração do projeto.

O dcc32.cfg pode também ser utilizado para definir configurações e diretórios que se
apliquem a todos os projetos utilizados em um determinado ambiente. Fazendo uma
analogia com o IDE do Delphi, os diretórios definidos no dcc32.cfg seriam equivalentes
aqueles definidos no library path (Tools/Environment options/Library/Library path) tendo,
portanto, visibilidade global, válida para todos os projetos; já os diretórios definidos em
NomeDoProjeto.cfg são aqueles visíveis pelo Search path
(Project/Options/Directories/Conditionals/Search path) e são específicas do projeto em
questão.

O arquivo dcc32.cfg deve ser editado manualmente. Para facilitar pode-se copiar o conteúdo
do arquivo de configurações do projeto, mas a cada alteração em diretórios ele precisará
ser atualizado novamente.

Recursos não disponíveis

Um recurso do qual você pode sentir falta ao utilizar o compilador por linha de comando é o
incremento automático do número da versão do arquivo. Ainda que essa opção tenha sido
selecionada nas configurações do projeto, ela não terá efeito, pois não se trata de uma
funcionalidade do compilador, mas sim do IDE do Delphi. Uma saída para continuar
incrementando a versão do arquivo, seria desenvolver um utilitário com essa
funcionalidade, e invocá-lo no arquivo de script, mas isso é assunto para outro artigo.

Considerações finais

Como vimos, a compilação de projetos por linha de comando é um recurso simples de ser
utilizado que pode nos auxiliar muito na padronização do processo de compilação e
liberação de versões, tornando essa tarefa mais ágil e confiável.

Caso precise de uma automação completa do processo de liberação de versão, vale a pena
conhecer algumas das ferramentas interessantes disponíveis atualmente para essa
finalidade, entre as quais tem destaque a comercial FinalBuilder (http://www.finalbuilder.com/), e
as gratuitas Rake (http://rake.rubyforge.org/) e MSBuild, sendo essa última a ferramenta padrão
de build do Delphi2007.

Espero com esse artigo ter contribuído de alguma forma para a melhoria do seu processo de
compilação.

Fonte.: http://www.techtips.com.br/programacao/delphi/ide/compilando-projetos-delphi-por-linha-de-comando/

-8-