Compilando projetos Delphi por linha de comando

Escrito em 06 de julho de 2007 em IDE por Jeferson Oliveira

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 -M = Make modified units
-CC = Console target -N<path> = DCU output directory
-CG = GUI target -O<paths> = Object directories
-D<syms> = Define conditionals -P = look for 8.3 file names also
-E<path> = EXE output directory -Q = Quiet compile
-F<offset> = Find error -R<paths> = Resource directories
-GD = Detailed map file -U<paths> = Unit directories
-GP = Map file with publics -V = Debug information in EXE
-GS = Map file with segments -VR = Generate remote debug (RSM)
-H = Output hint messages -W = Output warning messages
-I<paths> = Include directories -Z = Output 'never build' DCPs
-J = Generate .obj file -$<dir> = Compiler directive
-JP = Generate C++ .obj file --help = Show this help screen
-K<addr> = Set image base addr --version = Show name and version
Compiler switches: -$<letter><state> (defaults are shown below)
A8 Aligned record fields P+ Open string params
B- Full boolean Evaluation Q- Integer overflow checking
C+ Evaluate assertions at runtime R- Range checking
D+ Debug information T- Typed @ operator
G+ Use imported data references U- Pentium(tm)-safe divide
H+ Use long strings by default V+ Strict var-strings
I+ I/O checking W- Generate stack frames
J- Writeable structured consts X+ Extended syntax
L+ Local debug symbols Y+ Symbol reference info
M- Runtime type info Z1 Minimum size of enum types
O+ Optimization

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.

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

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 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, e as gratuitas Rake e MSBuild, sendo essa última a
ferramenta padrão de build do Delphi2007.