SWIG Users Manual
1 Preface
Introduction
SWIG Versions
SWIG License
SWIG resources
Prerequisites
Organization of this manual
How to avoid reading the manual
Backwards compatibility
Release notes
Credits
Bug reports
Installation
Windows installation
Unix installation
Macintosh OS X installation
Testing
Examples
2 Introduction
What is SWIG?
Why use SWIG?
A SWIG example
SWIG interface file
The swig command
Building a Perl5 module
Building a Python module
Shortcuts
Supported C/C++ language features
Non-intrusive interface building
Incorporating SWIG into a build system
Hands off code generation
SWIG and freedom
3 Getting started on Windows
Installation on Windows
Windows Executable
SWIG Windows Examples
Instructions for using the Examples with Visual Studio
C#
Java
Perl
Python
TCL
R
Ruby
Instructions for using the Examples with other compilers
SWIG on Cygwin and MinGW
Building swig.exe on Windows
Building swig.exe using MinGW and MSYS
Building swig.exe using Cygwin
Building swig.exe alternatives
Running the examples on Windows using Cygwin
Microsoft extensions and other Windows quirks
4 Scripting Languages
The two language view of the world
How does a scripting language talk to C?
Wrapper functions
Variable linking
Constants
Structures and classes
Proxy classes
Building scripting language extensions
Shared libraries and dynamic loading
Linking with shared libraries
Static linking
5 SWIG Basics
Running SWIG
Input format
SWIG Output
Comments
C Preprocessor
SWIG Directives
Parser Limitations
Wrapping Simple C Declarations
Basic Type Handling
Global Variables
Constants
A brief word about const
A cautionary tale of char *
Pointers and complex objects
Simple pointers
Run time pointer type checking
Derived types, structs, and classes
Undefined datatypes
Typedef
Other Practicalities
Passing structures by value
Return by value
Linking to structure variables
Linking to char *
Arrays
Creating read-only variables
Renaming and ignoring declarations
Simple renaming of specific identifiers
Advanced renaming support
Limiting global renaming rules
Ignoring everything then wrapping a few selected symbols
Default/optional arguments
Pointers to functions and callbacks
Structures and unions
Typedef and structures
Character strings and structures
Array members
Structure data members
C constructors and destructors
Adding member functions to C structures
Nested structures
Other things to note about structure wrapping
Code Insertion
The output of SWIG
Code insertion blocks
Inlined code blocks
Initialization blocks
An Interface Building Strategy
Preparing a C program for SWIG
The SWIG interface file
Why use separate interface files?
Getting the right header files
What to do with main()
6 SWIG and C++
Comments on C++ Wrapping
Approach
Supported C++ features
Command line options and compilation
Proxy classes
Construction of proxy classes
Resource management in proxies
Language specific details
Simple C++ wrapping
Constructors and destructors
Default constructors, copy constructors and implicit destructors
When constructor wrappers aren't created
Copy constructors
Member functions
Static members
Member data
Protection
Enums and constants
Friends
References and pointers
Pass and return by value
Inheritance
A brief discussion of multiple inheritance, pointers, and type checking
Default arguments
Overloaded functions and methods
Dispatch function generation
Ambiguity in overloading
Renaming and ambiguity resolution
Comments on overloading
Overloaded operators
Class extension
Templates
The %template directive
Function templates
Default template arguments
Template base classes
Template specialization
Member templates
Scoping and templates
More on templates
Namespaces
The nspace feature for namespaces
Renaming templated types in namespaces
Exception specifications
Exception handling with %catches
Pointers to Members
Smart pointers and operator->()
C++ reference counted objects - ref/unref feature
Using declarations and inheritance
Nested classes
A brief rant about const-correctness
Callbacks to the target language
Introduction to director classes
Using directors and target language callbacks
Where to go for more information
7 SWIG and C++11
Introduction
Core language changes
Rvalue reference and move semantics
Generalized constant expressions
Extern template
Initializer lists
Uniform initialization
Type inference
Range-based for-loop
Lambda functions and expressions
Alternate function syntax
Object construction improvement
Explicit overrides and final
Null pointer constant
Strongly typed enumerations
Double angle brackets
Explicit conversion operators
Type alias and alias templates
Unrestricted unions
Variadic templates
New string literals
User-defined literals
Thread-local storage
Explicitly defaulted functions and deleted functions
Type long long int
Static assertions
Allow sizeof to work on members of classes without an explicit object
Exception specifications and noexcept
Control and query object alignment
Attributes
Methods with ref-qualifiers
Standard library changes
Threading facilities
Tuple types
Hash tables
Regular expressions
General-purpose smart pointers
Extensible random number facility
Wrapper reference
Polymorphic wrappers for function objects
Type traits for metaprogramming
Uniform method for computing return type of function objects
8 SWIG and C++17
Introduction
Core language changes
Nested namespace definitions
Standard library changes
9 Preprocessing
File inclusion
File imports
Conditional Compilation
Macro Expansion
SWIG Macros
C99 and GNU Extensions
Preprocessing and delimiters
Preprocessing and %{ ... %} & " ... " delimiters
Preprocessing and { ... } delimiters
Preprocessor and Typemaps
Viewing preprocessor output
The #error and #warning directives
10 SWIG library
The %include directive and library search path
C arrays and pointers
cpointer.i
carrays.i
cmalloc.i
cdata.i
C string handling
Default string handling
Passing binary data
Using %newobject to release memory
cstring.i
STL/C++ library
std::string
std::vector
STL exceptions
shared_ptr smart pointer
shared_ptr basics
shared_ptr and inheritance
shared_ptr and method overloading
shared_ptr and templates
shared_ptr and directors
auto_ptr smart pointer
Utility Libraries
exception.i
11 Argument Handling
The typemaps.i library
Introduction
Input parameters
Output parameters
Input/Output parameters
Using different names
Applying constraints to input values
Simple constraint example
Constraint methods
Applying constraints to new datatypes
12 Typemaps
Introduction
Type conversion
Typemaps
Pattern matching
Reusing typemaps
What can be done with typemaps?
What can't be done with typemaps?
Similarities to Aspect Oriented Programming
The rest of this chapter
Typemap specifications
Defining a typemap
Typemap scope
Copying a typemap
Deleting a typemap
Placement of typemaps
Pattern matching rules
Basic matching rules
Typedef reductions matching
Default typemap matching rules
Multi-arguments typemaps
Matching rules compared to C++ templates
Debugging typemap pattern matching
Code generation rules
Scope
Declaring new local variables
Special variables
Special variable macros
$descriptor(type)
$typemap(method, typepattern)
Special variables and typemap attributes
Special variables combined with special variable macros
Common typemap methods
"in" typemap
"typecheck" typemap
"out" typemap
"arginit" typemap
"default" typemap
"check" typemap
"argout" typemap
"freearg" typemap
"newfree" typemap
"ret" typemap
"memberin" typemap
"varin" typemap
"varout" typemap
"throws" typemap
Some typemap examples
Typemaps for arrays
Implementing constraints with typemaps
Typemaps for multiple target languages
Optimal code generation when returning by value
Multi-argument typemaps
Typemap warnings
Typemap fragments
Fragment type specialization
Fragments and automatic typemap specialization
The run-time type checker
Implementation
Usage
Typemaps and overloading
SWIG_TYPECHECK_POINTER precedence level and the typecheck typemap
More about %apply and %clear
Passing data between typemaps
C++ "this" pointer
Where to go for more information?
13 Customization Features
Exception handling with %exception
Handling exceptions in C code
Exception handling with longjmp()
Handling C++ exceptions
Exception handlers for variables
Defining different exception handlers
Special variables for %exception
Using The SWIG exception library
Object ownership and %newobject
Features and the %feature directive
Feature attributes
Feature flags
Clearing features
Features and default arguments
Feature example
14 Contracts
The %contract directive
%contract and classes
Constant aggregation and %aggregate_check
Notes
15 Variable Length Arguments
Introduction
The Problem
Default varargs support
Argument replacement using %varargs
Varargs and typemaps
Varargs wrapping with libffi
Wrapping of va_list
C++ Issues
Discussion
16 SWIG and Doxygen Translation
Doxygen translation overview
Preparations
Enabling Doxygen translation
Doxygen-specific %feature directives
doxygen:notranslate
doxygen:alias:<command-name>
doxygen:ignore:<command-name>
doxygen:nolinktranslate
doxygen:nostripparams
Additional command line options
Doxygen to Javadoc
Basic example
Javadoc tags
Unsupported tags
Further details
Doxygen to Pydoc
Basic example
Pydoc translator
Unsupported tags
Further details
Developer information
Doxygen translator design
Debugging the Doxygen parser and translator
Tests
Extending to other languages
17 Warning Messages
Introduction
Warning message suppression
Enabling extra warnings
Issuing a warning message
Symbolic symbols
Commentary
Warnings as errors
Message output format
Warning number reference
Deprecated features (100-199)
Preprocessor (200-299)
C/C++ Parser (300-399)
Types and typemaps (400-499)
Code generation (500-559)
Doxygen comments (560-599)
Language module specific (700-899)
User defined (900-999)
History
18 Working with Modules
Modules Introduction
Basics
The SWIG runtime code
External access to the runtime
A word of caution about static libraries
References
Reducing the wrapper file size
19 Using SWIG with ccache - ccache-swig(1) manpage
NAME
SYNOPSIS
DESCRIPTION
OPTIONS SUMMARY
OPTIONS
INSTALLATION
EXTRA OPTIONS
ENVIRONMENT VARIABLES
CACHE SIZE MANAGEMENT
CACHE COMPRESSION
HOW IT WORKS
USING CCACHE WITH DISTCC
SHARING A CACHE
HISTORY
DIFFERENCES FROM COMPILERCACHE
CREDITS
AUTHOR
20 SWIG and Allegro Common Lisp
Basics
Running SWIG
Command Line Options
Inserting user code into generated files
Wrapping Overview
Function Wrapping
Foreign Wrappers
FFI Wrappers
Non-overloaded Defuns
Overloaded Defuns
What about constant and variable access?
Object Wrapping
Wrapping Details
Namespaces
Constants
Variables
Enumerations
Arrays
Classes and Structs and Unions (oh my!)
CLOS wrapping of
CLOS Inheritance
Member fields and functions
Why not directly access C++ classes using foreign types?
Templates
Generating wrapper code for templates
Implicit Template instantiation
Typedef, Templates, and Synonym Types
Choosing a primary type
Function overloading/Parameter defaulting
Operator wrapping and Operator overloading
Varargs
C++ Exceptions
Pass by value, pass by reference
Typemaps
Code Generation in the C++ Wrapper
IN Typemap
OUT Typemap
CTYPE Typemap
Code generation in Lisp wrappers
LIN Typemap
LOUT Typemap
FFITYPE Typemap
LISPTYPE Typemap
LISPCLASS Typemap
Modifying SWIG behavior using typemaps
Identifier Converter functions
Creating symbols in the lisp environment
Existing identifier-converter functions
identifier-convert-null
identifier-convert-lispify
Default identifier to symbol conversions
Defining your own identifier-converter
Instructing SWIG to use a particular identifier-converter
21 SWIG and Android
Overview
Android examples
Examples introduction
Simple C example
C++ class example
Other examples
C++ STL
22 SWIG and C#
Introduction
SWIG 2 Compatibility
Additional command line options
Differences to the Java module
Void pointers
C# Arrays
The SWIG C arrays library
Managed arrays using P/Invoke default array marshalling
Managed arrays using pinning
C# Exceptions
C# exception example using "check" typemap
C# exception example using %exception
C# exception example using exception specifications
Custom C# ApplicationException example
C# Directors
Directors example
Directors implementation
Director caveats
Multiple modules
C# Typemap examples
Memory management when returning references to member variables
Memory management for objects passed to the C++ layer
Date marshalling using the csin typemap and associated attributes
A date example demonstrating marshalling of C# properties
Date example demonstrating the 'pre' and 'post' typemap attributes for directors
Turning proxy classes into partial classes
Turning proxy classes into sealed classes
Extending proxy classes with additional C# code
Underlying type for enums
23 SWIG and Chicken
Preliminaries
Running SWIG in C mode
Running SWIG in C++ mode
Code Generation
Naming Conventions
Modules
Constants and Variables
Functions
Exceptions
TinyCLOS
Linkage
Static binary or shared library linked at compile time
Building chicken extension libraries
Linking multiple SWIG modules with TinyCLOS
Typemaps
Pointers
Garbage collection
Unsupported features and known problems
TinyCLOS problems with Chicken version <= 1.92
24 SWIG and D
Introduction
Command line invocation
Typemaps
C# <-> D name comparison
ctype, imtype, dtype
in, out, directorin, directorout
din, dout, ddirectorin, ddirectorout
typecheck typemaps
Code injection typemaps
Special variable macros
D and %feature
Pragmas
D Exceptions
D Directors
Other features
Extended namespace support (nspace)
Native pointer support
Operator overloading
Running the test-suite
D Typemap examples
Work in progress and planned features
25 SWIG and Go
Overview
Examples
Running SWIG with Go
Go-specific Commandline Options
Generated Wrapper Files
A tour of basic C/C++ wrapping
Go Package Name
Go Names
Go Constants
Go Enumerations
Go Classes
Go Class Memory Management
Go Class Inheritance
Go Templates
Go Director Classes
Example C++ code
Enable director feature
Constructor and destructor
Override virtual methods
Call base methods
Subclass via embedding
Memory management with runtime.SetFinalizer
Complete FooBarGo example class
Default Go primitive type mappings
Output arguments
Adding additional go code
Go typemaps
26 SWIG and Guile
Supported Guile Versions
Meaning of "Module"
Old GH Guile API
Linkage
Simple Linkage
Passive Linkage
Native Guile Module Linkage
Old Auto-Loading Guile Module Linkage
Hobbit4D Linkage
Underscore Folding
Typemaps
Representation of pointers as smobs
Smobs
Garbage Collection
Native Guile pointers
Exception Handling
Procedure documentation
Procedures with setters
GOOPS Proxy Classes
Naming Issues
Linking
27 SWIG and Java
Overview
Preliminaries
Running SWIG
Additional Commandline Options
Getting the right header files
Compiling a dynamic module
Using your module
Dynamic linking problems
Compilation problems and compiling with C++
Building on Windows
Running SWIG from Visual Studio
Using NMAKE
A tour of basic C/C++ wrapping
Modules, packages and generated Java classes
Functions
Global variables
Constants
Enumerations
Anonymous enums
Typesafe enums
Proper Java enums
Type unsafe enums
Simple enums
Pointers
Structures
C++ classes
C++ inheritance
Pointers, references, arrays and pass by value
Null pointers
C++ overloaded functions
C++ default arguments
C++ namespaces
C++ templates
C++ Smart Pointers
The shared_ptr Smart Pointer
Generic Smart Pointers
Further details on the generated Java classes
The intermediary JNI class
The intermediary JNI class pragmas
The Java module class
The Java module class pragmas
Java proxy classes
Memory management
Inheritance
Proxy classes and garbage collection
The premature garbage collection prevention parameter for proxy class marshalling
Single threaded applications and thread safety
Type wrapper classes
Enum classes
Typesafe enum classes
Proper Java enum classes
Type unsafe enum classes
Interfaces
Cross language polymorphism using directors
Enabling directors
Director classes
Overhead and code bloat
Simple directors example
Director threading issues
Director performance tuning
Java exceptions from directors
Customizing director exceptions
Accessing protected members
Common customization features
C/C++ helper functions
Class extension with %extend
Class extension with %proxycode
Exception handling with %exception and %javaexception
Method access with %javamethodmodifiers
Tips and techniques
Input and output parameters using primitive pointers and references
Simple pointers
Wrapping C arrays with Java arrays
Unbounded C Arrays
Binary data vs Strings
Overriding new and delete to allocate from Java heap
Java typemaps
Default primitive type mappings
Default typemaps for non-primitive types
Sixty four bit JVMs
What is a typemap?
Typemaps for mapping C/C++ types to Java types
Java typemap attributes
Java special variables
Typemaps for both C and C++ compilation
Java code typemaps
Director specific typemaps
Typemap Examples
Simpler Java enums for enums without initializers
Handling C++ exception specifications as Java exceptions
NaN Exception - exception handling for a particular type
Converting Java String arrays to char **
Expanding a Java object to multiple arguments
Using typemaps to return arguments
Adding Java downcasts to polymorphic return types
Adding an equals method to the Java classes
Void pointers and a common Java base class
Struct pointer to pointer
Memory management when returning references to member variables
Memory management for objects passed to the C++ layer
Date marshalling using the javain typemap and associated attributes
Living with Java Directors
Odds and ends
JavaDoc comments
Functional interface without proxy classes
Using your own JNI functions
Performance concerns and hints
Debugging
Java Examples
28 SWIG and Javascript
Overview
Preliminaries
Running SWIG
Running Tests and Examples
Known Issues
Integration
Creating node.js Extensions
Troubleshooting
Embedded Webkit
Mac OS X
GTK
Creating Applications with node-webkit
Examples
Simple
Class
Implementation
Source Code
Code Templates
Emitter
Emitter states
Handling Exceptions in JavascriptCore
29 SWIG and Common Lisp
Allegro Common Lisp
Common Foreign Function Interface(CFFI)
Additional Commandline Options
Generating CFFI bindings
Generating CFFI bindings for C++ code
Inserting user code into generated files
CLISP
Additional Commandline Options
Details on CLISP bindings
UFFI
30 SWIG and Lua
Preliminaries
Running SWIG
Additional command line options
Compiling and Linking and Interpreter
Compiling a dynamic module
Using your module
A tour of basic C/C++ wrapping
Modules
Functions
Global variables
Constants and enums
Constants/enums and classes/structures
Pointers
Structures
C++ classes
C++ inheritance
Pointers, references, values, and arrays
C++ overloaded functions
C++ operators
Class extension with %extend
Using %newobject to release memory
C++ templates
C++ Smart Pointers
C++ Exceptions
Namespaces
Compatibility Note
Names
Inheritance
Typemaps
What is a typemap?
Using typemaps
Typemaps and arrays
Typemaps and pointer-pointer functions
Writing typemaps
Typemaps you can write
SWIG's Lua-C API
Customization of your Bindings
Writing your own custom wrappers
Adding additional Lua code
Details on the Lua binding
Binding global data into the module.
Userdata and Metatables
Memory management
31 SWIG and Modula-3
Overview
Motivation
Conception
Interfaces to C libraries
Interfaces to C++ libraries
Preliminaries
Compilers
Additional Commandline Options
Modula-3 typemaps
Inputs and outputs
Subranges, Enumerations, Sets
Objects
Imports
Exceptions
Example
More hints to the generator
Features
Pragmas
Remarks
32 SWIG and MzScheme/Racket
Creating native structures
Simple example
External documentation
33 SWIG and Ocaml
Preliminaries
Running SWIG
Compiling the code
The camlp4 module
Using your module
Compilation problems and compiling with C++
The low-level Ocaml/C interface
The generated module
Enums
Enum typing in Ocaml
Arrays
Simple types of bounded arrays
Complex and unbounded arrays
Using an object
Example typemap for a function taking float * and int
C++ Classes
STL vector and string Example
C++ Class Example
Compiling the example
Sample Session
Director Classes
Director Introduction
Overriding Methods in Ocaml
Director Usage Example
Creating director objects
Typemaps for directors, directorin, directorout, directorargout
typemap
directorout typemap
directorargout typemap
Exceptions
34 SWIG and Octave
Preliminaries
Running SWIG
Command-line options
Compiling a dynamic module
Using your module
A tour of basic C/C++ wrapping
Modules
Functions
Global variables
Constants and enums
Pointers
Structures and C++ classes
C++ inheritance
C++ overloaded functions
C++ operators
Class extension with %extend
C++ templates
C++ Smart Pointers
The shared_ptr Smart Pointer
Generic Smart Pointers
Directors (calling Octave from C++ code)
Threads
Memory management
STL support
Matrix typemaps
35 SWIG and Perl5
Overview
Preliminaries
Getting the right header files
Compiling a dynamic module
Building a dynamic module with MakeMaker
Building a static version of Perl
Using the module
Compilation problems and compiling with C++
Compiling for 64-bit platforms
Building Perl Extensions under Windows
Running SWIG from Developer Studio
Using other compilers
The low-level interface
Functions
Global variables
Constants
Pointers
Structures
C++ classes
C++ classes and type-checking
C++ overloaded functions
Operators
Modules and packages
Input and output parameters
Exception handling
Remapping datatypes with typemaps
A simple typemap example
Perl5 typemaps
Typemap variables
Useful functions
Typemap Examples
Converting a Perl5 array to a char **
Return values
Returning values from arguments
Accessing array structure members
Turning Perl references into C pointers
Pointer handling
Proxy classes
Preliminaries
Structure and class wrappers
Object Ownership
Nested Objects
Proxy Functions
Inheritance
Modifying the proxy methods
Adding additional Perl code
Cross language polymorphism
Enabling directors
Director classes
Ownership and object destruction
Exception unrolling
Overhead and code bloat
Typemaps
36 SWIG and PHP
Generating PHP Extensions
Building a loadable extension
Using PHP Extensions
Basic PHP interface
Constants
Global Variables
Functions
Overloading
Pointers and References
Structures and C++ classes
Using -noproxy
Constructors and Destructors
Static Member Variables
Static Member Functions
Specifying Implemented Interfaces
PHP Pragmas, Startup and Shutdown code
Cross language polymorphism
Enabling directors
Director classes
Ownership and object destruction
Exception unrolling
Overhead and code bloat
Typemaps
Miscellaneous
37 SWIG and Pike
Preliminaries
Running SWIG
Getting the right header files
Using your module
Basic C/C++ Mapping
Modules
Functions
Global variables
Constants and enumerated types
Constructors and Destructors
Static Members
38 SWIG and Python
Overview
Preliminaries
Running SWIG
Using distutils
Hand compiling a dynamic module
Static linking
Using your module
Compilation of C++ extensions
Compiling for 64-bit platforms
Building Python Extensions under Windows
A tour of basic C/C++ wrapping
Modules
Functions
Global variables
Constants and enums
Pointers
Structures
C++ classes
C++ inheritance
Pointers, references, values, and arrays
C++ overloaded functions
C++ operators
C++ namespaces
C++ templates
C++ Smart Pointers
The shared_ptr Smart Pointer
Generic Smart Pointers
C++ reference counted objects
Further details on the Python class interface
Proxy classes
Built-in Types
Limitations
Operator overloads and slots -- use them!
Memory management
Cross language polymorphism
Enabling directors
Director classes
Ownership and object destruction
Exception unrolling
Overhead and code bloat
Typemaps
Miscellaneous
Common customization features
C/C++ helper functions
Adding additional Python code
Class extension with %extend
Exception handling with %exception
Optimization options
-fastproxy
Tips and techniques
Input and output parameters
Simple pointers
Unbounded C Arrays
String handling
Default arguments
Typemaps
What is a typemap?
Python typemaps
Typemap variables
Useful Python Functions
Typemap Examples
Converting Python list to a char **
Expanding a Python object into multiple arguments
Using typemaps to return arguments
Mapping Python tuples into small arrays
Mapping sequences to C arrays
Pointer handling
Docstring Features
Module docstring
%feature("autodoc")
%feature("autodoc", "0")
%feature("autodoc", "1")
%feature("autodoc", "2")
%feature("autodoc", "3")
%feature("autodoc", "docstring")
%feature("docstring")
Python Packages
Setting the Python package
Absolute and relative imports
Enforcing absolute import semantics
Importing from __init__.py
Implicit Namespace Packages
Searching for the wrapper module
Both modules in the same package
Split modules
Both modules are global
Statically linked C modules
Python 3 Support
Function annotation
Buffer interface
Abstract base classes
Byte string output conversion
Python 2 Unicode
Support for Multithreaded Applications
UI for Enabling Multithreading Support
Multithread Performance
39 SWIG and R
Bugs
Using R and SWIG
Precompiling large R files
General policy
Language conventions
C++ classes
Enumerations
40 SWIG and Ruby
Preliminaries
Running SWIG
Getting the right header files
Compiling a dynamic module
Using your module
Static linking
Compilation of C++ extensions
Building Ruby Extensions under Windows 95/NT
Running SWIG from Developer Studio
The Ruby-to-C/C++ Mapping
Modules
Functions
Variable Linking
Constants
Pointers
Structures
C++ classes
C++ Inheritance
C++ Overloaded Functions
C++ Operators
C++ namespaces
C++ templates
C++ Standard Template Library (STL)
C++ STL Functors
C++ STL Iterators
C++ Smart Pointers
The shared_ptr Smart Pointer
Generic Smart Pointers
Cross-Language Polymorphism
Exception Unrolling
Naming
Defining Aliases
Predicate Methods
Bang Methods
Getters and Setters
Input and output parameters
Exception handling
Using the %exception directive
Handling Ruby Blocks
Raising exceptions
Exception classes
Typemaps
What is a typemap?
Typemap scope
Copying a typemap
Deleting a typemap
Placement of typemaps
Ruby typemaps
"in" typemap
"typecheck" typemap
"out" typemap
"arginit" typemap
"default" typemap
"check" typemap
"argout" typemap
"freearg" typemap
"newfree" typemap
"memberin" typemap
"varin" typemap
"varout" typemap
"throws" typemap
directorin typemap
directorout typemap
directorargout typemap
ret typemap
globalin typemap
Typemap variables
Useful Functions
C Datatypes to Ruby Objects
Ruby Objects to C Datatypes
Macros for VALUE
Exceptions
Iterators
Typemap Examples
Converting a Ruby array to a char **
Collecting arguments in a hash
Pointer handling
Ruby Datatype Wrapping
Example: STL Vector to Ruby Array
Docstring Features
Module docstring
%feature("autodoc")
%feature("autodoc", "0")
%feature("autodoc", "1")
%feature("autodoc", "2")
%feature("autodoc", "3")
%feature("autodoc", "docstring")
%feature("docstring")
Advanced Topics
Operator overloading
Creating Multi-Module Packages
Specifying Mixin Modules
Memory Management
Mark and Sweep Garbage Collector
Object Ownership
Object Tracking
Mark Functions
Free Functions
Embedded Ruby and the C++ Stack
41 SWIG and Scilab
Preliminaries
Running SWIG
Generating the module
Building the module
Loading the module
Using the module
Scilab command line options
A basic tour of C/C++ wrapping
Overview
Identifiers
Functions
Argument passing
Multiple output arguments
Global variables
Constants and enumerations
Constants
Enumerations
Pointers
Utility functions
Null pointers:
Structures
C++ classes
C++ inheritance
C++ overloading
Pointers, references, values, and arrays
C++ templates
C++ operators
C++ namespaces
C++ exceptions
C++ STL
Type mappings and libraries
Default primitive type mappings
Arrays
Pointer-to-pointers
Matrices
STL
Module initialization
Building modes
No-builder mode
Builder mode
Generated scripts
Builder script
Loader script
Other resources
42 SWIG and Tcl
Preliminaries
Getting the right header files
Compiling a dynamic module
Static linking
Using your module
Compilation of C++ extensions
Compiling for 64-bit platforms
Setting a package prefix
Using namespaces
Building Tcl/Tk Extensions under Windows 95/NT
Running SWIG from Developer Studio
Using NMAKE
A tour of basic C/C++ wrapping
Modules
Functions
Global variables
Constants and enums
Pointers
Structures
C++ classes
C++ inheritance
Pointers, references, values, and arrays
C++ overloaded functions
C++ operators
C++ namespaces
C++ templates
C++ Smart Pointers
Further details on the Tcl class interface
Proxy classes
Memory management
Input and output parameters
Exception handling
Typemaps
What is a typemap?
Tcl typemaps
Typemap variables
Converting a Tcl list to a char **
Returning values in arguments
Useful functions
Standard typemaps
Pointer handling
Turning a SWIG module into a Tcl Package.
Building new kinds of Tcl interfaces (in Tcl)
Proxy classes
Tcl/Tk Stubs
43 Extending SWIG to support new languages
Introduction
Prerequisites
The Big Picture
Execution Model
Preprocessing
Parsing
Parse Trees
Attribute namespaces
Symbol Tables
The %feature directive
Code Generation
SWIG and XML
Primitive Data Structures
Strings
Hashes
Lists
Common operations
Iterating over Lists and Hashes
I/O
Navigating and manipulating parse trees
Working with attributes
Type system
String encoding of types
Type construction
Type tests
Typedef and inheritance
Lvalues
Output functions
Parameters
Writing a Language Module
Execution model
Starting out
Command line options
Configuration and preprocessing
Entry point to code generation
Module I/O and wrapper skeleton
Low-level code generators
Configuration files
Runtime support
Standard library files
User examples
Test driven development and the test-suite
Running the test-suite
Documentation
Prerequisites for adding a new language module to the SWIG distribution
Coding style guidelines
Debugging Options
Guide to parse tree nodes
Further Development Information