SWIG 1.1英文版用户手册概述与版权信息

需积分: 9 67 浏览量更新于2024-07-20 收藏 699KB PDF 举报

SWIG (Simplified Wrapper and Interface Generator) 是一个开源工具，用于在不同的编程语言之间创建高效的接口。这个1.1版本的用户手册，由David M. Beazley编写，发布于1997年6月，隶属于美国犹他大学计算机科学系。该手册的主要目标是提供对如何使用SWIG进行C/C++库与Python、Perl、Tcl等脚本语言之间的无缝集成的全面指导。重要知识点包括： 1. **简介**：SWIG是一款编译器驱动的工具，它通过解析C/C++源代码注解（称为"interface files"），自动生成绑定代码，使得非C/C++程序员能够方便地调用这些库的功能。它简化了通常需要大量手动编码的工作，如数据类型转换和函数调用的细节处理。 2. **版权与许可证**：SWIG 1.1 版本受到University of Utah和University of California Regents的共同版权保护。用户可以在保留原有版权声明的情况下分发此文档，但未经作者书面许可，任何形式的未经授权复制都是被禁止的。软件本身遵循的是一种许可协议，允许用户在保留版权信息的前提下自由使用、修改、分发和再授权。 3. **使用许可**：根据许可证，用户可以不受限制地使用SWIG及其文档，只要在所有副本中保留原始版权通知，并确保包含此通知。这意味着SWIG是一个开放源码项目，鼓励社区参与并促进技术交流。 4. **核心功能**：SWIG的核心作用是通过C++接口定义（Interface Definition Language, IDL）文件，自动将C/C++库的功能转换为其他语言的可用API。这包括类型映射、参数传递方式的调整以及异常处理等复杂细节。 5. **应用场景**：SWIG广泛应用于跨平台开发，例如将C++库暴露给Python开发者，让他们能利用丰富的Python库和工具来操作C++代码。这对于快速原型设计、科学计算和数据分析等领域非常有用。 6. **手册结构**：手册详细介绍了如何设置SWIG环境、编写接口文件、配置选项、生成代码和调试过程，同时提供了示例和最佳实践，帮助用户充分利用SWIG的优势。 SWIG用户手册1.1版是一份重要的资源，它向读者展示了如何通过SWIG有效地将C/C++库转化为其他动态语言的模块，促进了不同语言间的协作与互操作性。理解并掌握其工作原理和使用方法，对于从事多语言编程或库开发的开发者来说是不可或缺的。

SWIG Users Guide Introduction 16

Version 1.1, June 24, 1997

Building libraries and modules

In addition to generating wrapper code, SWIG provides extensive support for handling multiple

ﬁles and building interface libraries. For example, our example.i ﬁle, could be used in another

interface as follows :

%module foo

%include example.i // Get definitions from example.i

... Now more declarations ...

In a large system, an interface might be built from a variety of pieces like this :

%module package

%include network.i

%include file.i

%include graphics.i

%include objects.i

%include simulation.i

SWIG comes with a library of existing functions known as the SWIG library. The library contains

a mix of language independent and language dependent functionality. For example, the ﬁle

‘array.i’ provides access to C arrays while the ﬁle ‘wish.i’ includes specialized code for

rebuilding the Tcl wish interpreter. Using the library, you can use existing modules to build up

your own personalized environment for building interfaces. If changes are made to any of the

components, they will appear automatically the next time SWIG is run.

C syntax, but not a C compiler

SWIG uses ANSI C syntax, but is not a full ANSI C compiler. By using C syntax, I hope to make

SWIG easy to use with most C programs, easy to learn, and easy to remember. Other tools tend

to use a precise interface deﬁnition language, but I personally ﬁnd this approach to be painful.

When I want to build an interface to a collection of several hundred C functions, I don’t necessar-

ily want to write a special interface deﬁnition for each one. Nor do I want to have to go dig up

the manual because I can’t remember the syntax.

On the other hand, using C syntax can be ambiguous. For example, if you have the following

declaration

int foo(double *a);

We don’t really know if a is an array of some ﬁxed size, a dynamically allocated block of mem-

ory, a single value, or an output value of the function. For the most part, SWIG takes a literal

approach (a is obviously a double *) and leaves it up to the user to use the function in a correct

manner. Fortunately, there are several ways to help SWIG out using additional directives and

“helper” functions. Thus, the input to SWIG is often a mix of C declarations, special directives

and hints. Like Perl programming, there is almost always more than one way to do almost any-

thing.

SWIG does not currently parse every conceivable type of C declaration that it might encounter in

a C/C++ ﬁle. Many things may be difﬁcult or impossible to integrate with a scripting language

SWIG Users Guide Introduction 17

Version 1.1, June 24, 1997

(C++ templates for example). Thus, SWIG may not recognize advanced C/C++ constructs. I

make no apologies for this--SWIG was designed to access C, but was never intended to magi-

cally turn scripting languages into some sort of bizarre C++ interpreter. Of course, SWIG’s

parser is always being improved so currently unsupported features may be supported in later

releases.

Non-intrusive interface building

When used as I intended, SWIG requires minimal modiﬁcation to existing C code. This makes

SWIG extremely easy to use with existing packages, but also promotes software reuse and mod-

ularity. By making the C code independent of the high level interface, you can change the inter-

face and reuse the code in other applications. In a similar spirit, I don’t believe that there is any

one “best” scripting language--use whichever one you like (they’re all pretty good). There’s no

real reason why a particular application couldn’t support multiple scripting language interfaces

to serve different needs (or to have no scripting language interface at all).

Hands off code generation

SWIG is designed to produce working code that needs no hand-modiﬁcation (in fact, if you look

at the output, you probably won’t want to modify it). Ideally, SWIG should be invoked automat-

ically inside a Makeﬁle just as one would call the C compiler. You should think of your scripting

language interface being deﬁned entirely by the input to SWIG, not the resulting output ﬁle.

While this approach may limit ﬂexibility for hard-core hackers, it allows others to forget about

the low-level implementation details. This is my goal.

Event driven C programming

By adding a scripting language interface to a program, SWIG encourages an event-driven style

of programming (although it may not be immediately obvious). An event driven program basi-

cally consists of a large-collection of functions (called callback functions), and an inﬁnite loop

that just sits and waits for the user to do something. When the user does something like type a

command, hit a key, or move the mouse the program will call a function to perform an opera-

tion--this is an event. Of course, unless you’ve been living in cave for the last 20 years, you’ve

used this kind of approach when running any sort of graphical user interface.

While you may not be using SWIG to develop a GUI, the underlying concept is the same. The

scripting language acts as an event-loop waiting for you to issue commands. Unlike a traditional

C application (that may use command line options), there is no longer a ﬁxed sequence of opera-

tions. Functions may be issued in any order and at any time. Of course, this ﬂexibility is exactly

what we want!

However, there are a number of things to keep in mind when developing an application with

SWIG :

• Functions may be called at any time and in any order. It is always a good idea for func-

tions to check their arguments and internal state to see if it’s legal to proceed (Not doing

so usually results in mysterious crashes later on).

• Code should be structured as a collection of independent modules, not a huge mess of

SWIG Users Guide Introduction 18

Version 1.1, June 24, 1997

interrelated functions and variables (ie. spaghetti code).

• Global variables should be used with care.

• Careful attention to the naming of variables and functions may be required to avoid

namespace conﬂicts when combining packages.

While it may be hard (or impossible) to address all these problems in a legacy code, I believe that

using SWIG encourages all of the above qualities when developing new applications. This

results in code that is more reliable, more modular, and easier to integrate into larger packages.

By providing a non-intrusive, easy to use tool, it is possible to develop highly reliable event-

driven code from the start--not as a hack to be added later. As a ﬁnal sales pitch, in the initial

application for which SWIG was developed, code reliability and ﬂexibility has increased sub-

stantially while code size has decreased by more than 25%. I believe this is a good thing.

Automatic documentation generation

SWIG makes it very easy to build large interactive C programs, but it can sometimes be hard to

remember what C functions are available and how they are called in the scripting language inter-

face. To address this problem, SWIG automatically generates a documentation ﬁle in a number of

different formats. C comments can be used to provide additional descriptions of each function,

and documentation can be grouped into a hierarchy of sections and subsections. The documenta-

tion ﬁle is intended to provide a reasonable description of the scripting language interface. While

it’s no competition for a full-blown C code documentation generator, the documentation system

can do a reasonable job of documenting an interface.

Summary

At this point, you know about 95% of everything you need to know to start using SWIG. First,

functions and variables are speciﬁed using ANSI C, C++, or Objective-C syntax. These may

appear in a separate interface ﬁle or you can use a C source ﬁle (if it is sufﬁciently clean). SWIG

requires no modiﬁcations to existing C code so it’s easy to get started. To build a module, use the

swig command with an appropriate target language option. This generates a C file that you

need to compile with the rest of your code and you're ready to go.

I don’t consider there to be a “right” or “wrong” way to use SWIG, although I personally use

separate interface ﬁles for a variety of reasons :

• It helps keep me organized.

• It’s usually not necessary to wrap every single C function in a program.

• SWIG provides a number of directives that I tend to use alot.

• Having a special interface ﬁle makes it clear where the scripting language interface is

deﬁned. If you decide to change something in the interface, it’s easy to track down if you

have special ﬁle.

Of course, your mileage may vary.

SWIG for Windows and Macintosh

SWIG has been primarily developed and designed to work with Unix-based applications. How-

SWIG Users Guide Introduction 19

Version 1.1, June 24, 1997

ever, most of the scripting languages supported by SWIG are available on a variety of other plat-

forms including Windows 95/NT and Macintosh. SWIG generated code is mostly compatible

with these versions (and SWIG itself can now run on these platforms).

SWIG on Windows 95/NT

The Windows 95/NT port of SWIG (provided by Kevin Butler), is a straightforward translation

of the Unix version. At this time it is only known to work with Microsoft Visual C++ 4.x, but

there is nothing to prevent its use with other compilers (at least not that I’m aware of). SWIG

should be invoked from the MS-DOS prompt in exactly the same manner as in Unix. SWIG can

also be used in NMAKE build ﬁles and added to Visual C++ projects under the custom build set-

ting. As of this writing, SWIG is known to work with Windows versions of Tcl/Tk, Python, and

Perl (including the ActiveWare Perl for Win32 port). SWIG makes extensive use of long ﬁlena-

mes, so it is unlikely that the SWIG compiler will operate correctly under Windows 3.1 or DOS

(the wrapper code generated by SWIG may compile however).

SWIG on the Power Macintosh

A Macintosh port of SWIG is also available, but is highly experimental at this time. It only works

on PowerPC based Macintosh systems running System 7 or later. Modules can be compiled with

the Metrowerks Code Warrior compiler, but support for other compilers is unknown. Due to the

lack of command line options on the Mac, SWIG has been packaged in a Tcl/Tk interface that

allows various settings and command line options to be speciﬁed with a graphical user interface.

Underneath the hood, SWIG is identical to the Unix/Windows version. It recognizes the same

set of options and generates identical code. Any SWIG command line option listed in this man-

ual can be given to the Mac version under “Advanced Options” shown in the ﬁgure. At this writ-

ing, SWIG is only known to support Mac versions of Tcl/Tk. Work on Macintosh versions of

Python and Perl is underway.

Cross platform woes

While SWIG and various freely available scripting languages are supported on different plat-

剩余317页未读，继续阅读

CDMA

粉丝: 3
资源: 23

SWIG 1.1英文版用户手册概述与版权信息

swigwin-4.0.2.zip

swigwin-4.0.1.zip

SWIG4.0开发手册

swig.exe 在哪里

win10 swig下载

swig c++ 转java

Linux下的Swig

windows swig 配置环境变量

swig c++ 生成c#

手动安装 swig.exe

最新资源