DIPP is a Pascal Preprocessor to manipulate Pascal source code files. DIPP is a tiny console application suitable for batch processing. It returns an exit code <> 0 on error. DIPP reads, processes and writes one file at a time, performing minimal syntax check as it goes. Output files can then be passed on to Pascal compilers.

DIPP can

• remove comments.
• process compiler directives and switches.
• remove compiler conditionals by wild card masks.
• remove compiler directives by wild card masks.
• insert, read, or skip include files by wild card masks.
• extract units' interface sections.

DIPP is useful to

• insert multiple (nested) include files into a single source file.
• simplify debugging by removing unnecessary conditionals.
• prepare your Pascal source code to be shared with 3rd parties.
• target Pascal sources at specific compiler versions for distribution.
• remove conditionals unsupported by some (old) compilers.
• provide 3rd parties with the interface section of precompiled units.

To run DIPP, open a console window, type DIPP and press Enter. Called without options, DIPP displays its help screen:

C:\DIPP>DIPP

The Delphi Inspiration Pascal Preprocessor Version 1.2
Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration
http://www.yunqa.de/delphi/

Syntax: DIPP.exe [options] <INFILE> <OUTFILE>

 -$[<+|-><sym>[;<sym>]]  Remove directives / keep/remove by wildcards
 -ai[<file>[;<file>]]    Add / insert include files [specific files]
 -C[1]                   Remove comments [but keep 1st comment]
 -c                      Process Conditionals
 -d<sym>[;<sym>]         Define conditionals
 -h[<+|-><sym>[;<sym>]]  Remove conditionals / keep/remove by wildcards
 -i<path>[;<path>]       Include directories
 -n                      Interface only (up to implementation identifier)
 -o                      Overwrite existing file
 -p<Pascal compiler>     Imitate Pascal compiler conditional defines:
                           Delphi:     D, D32, D1-7
                           Kylix:      K, K1-3
                           C++Builder: C, C32, C1, C3-6
 -ri[<FILE>[;<FILE>]]    Read Include files [specific files]
 -si[<FILE>[;<FILE>]]    Skip Include files [specific files]
 -t[i]                   Time stamp outfile to infile [or latest include]

Preprocessing Pascal files with DIPP requires you to enter both an input file and an output file. DIPP reads from the input file and writes the processed Pascal source code to the output file:

C:\DIPP>DIPP infile.pas outfile.pas

The Delphi Inspiration Pascal Preprocessor Version 1.2
Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration
http://www.yunqa.de/delphi/
In:  infile.pas
Out: outfile.pas
  Processed 6523 lines in 10 ms.

Without options, DIPP doesn't really process infile.pas except for some minor formatting like removing multiple line breaks. To turn on real preprocessing, you need to specify one or more of the following options:

Removing compiler directives can be used to adjust Pascal sources to older compilers which do not support all directives of the latest Pascal versions. Directives do not include conditionals and switches.

Multiple directives can be separated by semicolon ';':

Directive names can also contain wildcards '*' and '?'. Wildcards allow to remove groups of directives with start or end with particular characters.

Enables processing of conditional compiler directives. With conditionals enabled, DIPP skips over code enclosed by undefined conditionals, inserts include files depending on defined conditionals. In other words: DIPP treats your sources like a Pascal compiler would do.

Conditional directives include:

• {$DEFINE … }
• {$UNDEF … }
• {$IFDEF … }
• {$IFNDEF … }
• {$ELSE … }
• {$IFOPT … }

Do not confuse -c (lower case) with the -C (upper case) option, which removes comments.

Do not confuse -C (upper case) with the -c (lower case) option, which enables processing conditionals. |

Defines conditional symbols, just like the DCC32 command line compiler. Separate multiple defines with a semicolon ';'.

Removing compiler directives from Pascal sources can be used to clean them up for easier debugging or to create sources for specific Pascal compilers. Conditionals do not include directives and switches.

To remove conditionals, you must instruct DIPP to process conditionals in the first place.

Multiple directives can be separated by semicolon ';':

Directive names can also contain wildcards '*' and '?'. Wildcards allow to remove groups of conditionals with start or end with particular characters.

The -I option lets you specify a list of directories in which DIPP searches for include files. Separate multiple defines with a semicolon ';'. DIPP starts searching for include files at the current directory, then at the first directory specified, then the 2nd, and so on.

-n Outputs the interface part of a Pascal unit only. The implementation part will not be included.

Causes DIPP to imitate a particular Pascal compiler by setting and selected conditional compiler symbols.

-ai is one of the options to specify handling of include files. -ai causes DIPP to insert all include files into the output file. If enabled, DIPP also processes conditionals for all inserted include files.

You can fine-tune the -ai option by appending one or multiple file names, separated by semicolon ';', which instructs DIPP to insert only those include files specified. Include file names may contain wildcards.

If DIPP can not find an include file and open it for reading, it will terminated with an error. To solve the problem, set the include directories.

-ri causes DIPP to read the contents of include files. If enabled, DIPP processes conditionals for all include files which DIPP reads. However, simply reading will not insert the include files' contents into the output file.

You can fine-tune the -ri option by appending one or multiple file names, separated by semicolon ';', which instructs DIPP to read only those include files specified. Include file names may contain wildcards.

If DIPP can not find an include file and open it for reading, it will terminated with an error. To solve the problem, set the include directories.

-si causes DIPP to skip all include files.

You can fine-tune the -si option by appending one or multiple file names, separated by semicolon ';', which instructs DIPP to skip only those include files specified. Include file names may contain wildcards.

Skipping an include file does not require DIPP to be able to locate it and open it for reading.

File The -t option instructs DIPP to set the time stamp of the output file to that of the input file.

With the additional option -ti, DIPP calculates the new timestamp from the input file as well as all include files inserted and read.

The following example file contains comments, conditional defines, compiler directives and an implementation section. Let's see how we can use DIPP to modify it.

{ Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration }
 
{ This is a test unit for DIPP. }
unit Test;
 
{$HPPEMIT '#include "common.h"'}
{$IMAGEBASE $00400000}
 
interface
 
{$IFDEF MSWINDOWS}
const
  OS = 'MS Windows' ;
{$ENDIF}
 
{$IFDEF LINUX}
const
  OS = 'Linux' ;
{$ENDIF}
 
implementation
 
{$IFDEF Debug}
initialization
 
WriteLn( '!!! Debug Mode !!!' );
 
{$ENDIF}
 
end.

Removing all comments, the file looks like:

C:\DIPP>DIPP -C test.pas out.pas

unit Test;
 
{$HPPEMIT '#include "common.h"'}
{$IMAGEBASE $00400000}
 
interface
 
<SNIP>

Removing all but the 1st comment, the file looks like:

 C:\DIPP>DIPP -C1 test.pas out.pas

{ Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration }
 
unit Test;
 
{$HPPEMIT '#include "common.h"'}
{$IMAGEBASE $00400000}
 
interface
 
<SNIP>

This will remove all comments but the 1st, and also remove the {$HPPEMIT … } compiler directive.

 C:\DIPP>DIPP -C1 -$-HPPEMIT test.pas out.pas

{ Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration }
 
unit Test;
 
{$IMAGEBASE $00400000}
 
interface
 
<SNIP>

Next we want to remove all comments (-C) and all compiler directives (-$). We also want to remove all conditionals (-h), so we also enable processing of conditionals (-c). Let's see what's left, if no conditional symbols are defined:

C:\DIPP>DIPP -C -$ -h -c test.pas out.pas

unit Test;
 
interface
 
implementation
 
end.

Why is the file almost empty? DIPP does, by default, not know about the Pascal compiler. Imitating Delphi 6 (-pD6) defines the MSWINDOWS conditional symbol and DIPP outputs the following:

C:\DIPP>DIPP -C -$ -h -c -pD6 test.pas out.pas

unit Test;
 
interface
 
const
  OS = 'MS Windows' ;
 
implementation
 
end.

Now imagine creating a Debug build by defining the Debug conditional symbol at the command prompt with -DDebug:

C:\DIPP>DIPP -C -$ -h -c -pD6 -DDebug test.pas out.pas

unit Test;
 
interface
 
const
  OS = 'MS Windows' ;
 
implementation
 
initialization
 
WriteLn( '!!! Debug Mode !!!' );
 
end.

Last but not least, we will create an interface file (-n) for Kylix (-pK) with all comments after the 1st and all conditionals removed. We will, however, not remove the compiler directives:

C:\DIPP>DIPP -C1 -h -c -n -pK test.pas out.pas

{ Copyright (c) 2003-2007 Ralf Junker, The Delphi Inpiration }
 
unit Test;
 
{$HPPEMIT '#include "common.h"'}
{$IMAGEBASE $00400000}
 
interface
 
const
  OS = 'Linux' ;
 
implementation