SWIG includes its own enhanced version of the C preprocessor. The preprocessor
supports the standard preprocessor directives and macro expansion rules.
However, a number of modifications and enhancements have been made. This
chapter describes some of these modifications.

7.1 File inclusion

To include another file into a SWIG interface, use the %include directive
like this:

%include "pointer.i"

Unlike, #include, %include includes each file once (and will not
reload the file on subsequent %include declarations). Therefore, it
is not necessary to use include-guards in SWIG interfaces.

By default, the #include is ignored unless you run SWIG with the
-includeall option. The reason for ignoring traditional includes
is that you often don't want SWIG to try and wrap everything included
in standard header system headers and auxiliary files.

7.2 File imports

SWIG provides another file inclusion directive with the %import directive.
For example:

%import "foo.i"

The purpose of %import is to collect certain information from another
SWIG interface file or a header file without actually generating any wrapper code.
Such information generally includes type declarations (e.g., typedef) as well as
C++ classes that might be used as base-classes for class declarations in the interface.
The use of %import is also important when SWIG is used to generate
extensions as a collection of related modules. This is an advanced topic and is described
in later in the Working with Modules chapter.

The -importall directive tells SWIG to follow all #include statements
as imports. This might be useful if you want to extract type definitions from system
header files without generating any wrappers.

7.3 Conditional Compilation

SWIG fully supports the use of #if, #ifdef,
#ifndef, #else, #endif to conditionally
include parts of an interface. The following symbols are predefined
by SWIG when it is parsing the interface:

SWIG Always defined when SWIG is processing a file
SWIGIMPORTED Defined when SWIG is importing a file with %import
SWIG_VERSION Hexadecimal (binary-coded decimal) number containing SWIG version,
such as 0x010311 (corresponding to SWIG-1.3.11).
SWIGALLEGROCL Defined when using Allegro CL
SWIGCFFI Defined when using CFFI
SWIGCHICKEN Defined when using CHICKEN
SWIGCLISP Defined when using CLISP
SWIGCSHARP Defined when using C#
SWIGGUILE Defined when using Guile
SWIGJAVA Defined when using Java
SWIGLUA Defined when using Lua
SWIGMODULA3 Defined when using Modula-3
SWIGMZSCHEME Defined when using Mzscheme
SWIGOCAML Defined when using Ocaml
SWIGOCTAVE Defined when using Octave
SWIGPERL Defined when using Perl
SWIGPHP Defined when using PHP
SWIGPIKE Defined when using Pike
SWIGPYTHON Defined when using Python
SWIGR Defined when using R
SWIGRUBY Defined when using Ruby
SWIGSEXP Defined when using S-expressions
SWIGTCL Defined when using Tcl
SWIGXML Defined when using XML

In addition, SWIG defines the following set of standard C/C++ macros:

__LINE__ Current line number
__FILE__ Current file name
__STDC__ Defined to indicate ANSI C
__cplusplus Defined when -c++ option used

Interface files can look at these symbols as necessary to change the
way in which an interface is generated or to mix SWIG directives with
C code. These symbols are also defined within the C code generated by
SWIG (except for the symbol `SWIG' which is only defined
within the SWIG compiler).

7.4 Macro Expansion

Traditional preprocessor macros can be used in SWIG interfaces. Be aware that the #define statement
is also used to try and detect constants. Therefore, if you have something like this in your file,

#ifndef _FOO_H 1
#define _FOO_H 1
...
#endif

you may get some extra constants such as _FOO_H showing up in the scripting interface.

The primary purpose of %define is to define large macros of code. Unlike normal C preprocessor
macros, it is not necessary to terminate each line with a continuation character (\)--the macro definition
extends to the first occurrence of %enddef. Furthermore, when such macros are expanded,
they are reparsed through the C preprocessor. Thus, SWIG macros can contain all other preprocessor
directives except for nested %define statements.

The SWIG macro capability is a very quick and easy way to generate large amounts of code. In fact,
many of SWIG's advanced features and libraries are built using this mechanism (such as C++ template
support).

7.6 C99 and GNU Extensions

SWIG-1.3.12 and newer releases support variadic preprocessor macros. For example:

#define DEBUGF(fmt,...) fprintf(stderr,fmt,__VA_ARGS__)

When used, any extra arguments to ... are placed into the
special variable __VA_ARGS__. This also works with special SWIG
macros defined using %define.

SWIG allows a variable number of arguments to be empty. However, this often results
in an extra comma (,) and syntax error in the resulting expansion. For example:

DEBUGF("hello"); --> fprintf(stderr,"hello",);

To get rid of the extra comma, use ## like this:

#define DEBUGF(fmt,...) fprintf(stderr,fmt, ##__VA_ARGS__)

SWIG also supports GNU-style variadic macros. For example:

#define DEBUGF(fmt, args...) fprintf(stdout,fmt,args)

Comment: It's not entirely clear how variadic macros might be useful to
interface building. However, they are used internally to implement a number of
SWIG directives and are provided to make SWIG more compatible with C99 code.

7.7 Preprocessing and delimiters

The preprocessor handles { }, " " and %{ %} delimiters differently.

7.7.1 Preprocessing and %{ ... %} & " ... " delimiters

The SWIG preprocessor does not process any text enclosed in a code block %{ ... %}. Therefore,
if you write code like this,

%{
#ifdef NEED_BLAH
int blah() {
...
}
#endif
%}

the contents of the %{ ... %} block are copied without
modification to the output (including all preprocessor directives).

7.7.2 Preprocessing and { ... } delimiters

SWIG always runs the preprocessor on text appearing inside { ... }. However,
sometimes it is desirable to make a preprocessor directive pass through to the output
file. For example:

SWIG will strip the extra % and leave the preprocessor directive in the code.

7.8 Preprocessor and Typemaps

Typemaps support a special attribute called noblock where the { ... } delimiters can be used,
but the delimiters are not actually generated into the code.
The effect is then similar to using "" or %{ %} delimiters but the code is run through the preprocessor. For example:

7.9 Viewing preprocessor output

Like many compilers, SWIG supports a -E command line option to display the output from the preprocessor.
When the -E switch is used, SWIG will not generate any wrappers.
Instead the results after the preprocessor has run are displayed.
This might be useful as an aid to debugging and viewing the results of macro expansions.

7.10 The #error and #warning directives

SWIG supports the commonly used #warning and #error preprocessor directives.
The #warning directive will cause SWIG to issue a warning then continue processing.
The #error directive will cause SWIG to exit with a fatal error.
Example usage:

#error "This is a fatal error message"
#warning "This is a warning message"

The #error behaviour can be made to work like #warning if the -cpperraswarn
commandline option is used. Alternatively, the #pragma directive can be used to the same effect, for example: