Swig

Swig (Simplified Wrapper and Interface Generator) es una herramienta que se utiliza para integrar sistemas de scripts a programas C/C++. Los sistemas de scripts soportados son varios a ser:

. Perl
. Python
. Tcl
. Guile
. MzScheme
. Ruby
. Java

En las últimas versiones se agregó soporte a:

. PHP
. Objective Caml
. Pike
. C#
. Chicken
. Allegro CL
. Modula 3

Swig puede ser descargado desde http://www.swig.org y puede ser utilizado libremente. La herramienta es básicamente un precompilador, de uso muy similar a ToLua, sólo que en este caso no existe una librería con la cual enlazar.
En función del sistema de scripts que se desee integrar se soportan diversas funcionalidades de C++. En este caso, nuestro interés pasa por integrar Python utilizando Swig y por suerte la integración que hace Swig con este sistema está muy trabajada y fue incorporada en las primeras versiones de la utilidad.
Se soportará de C++ las siguientes funcionalidades:

. Todos los tipos de datos del C++
. Referencias
. Punteros a miembros
. Clases
. Herencia y herencia múltiple
. Sobrecarga de funciones y métodos
. Sobrecarga de operadores
. Miembros estáticos
. Espacios de nombre
. Templates

Con esto queremos decir, que las funcionalidades mencionadas de C++ serán de algún modo mapeadas en Python para poder ser explotadas.

Pero veamos un ejemplo en acción. Mencionamos que su uso era similar a ToLua, aquí también deberemos crear un archivo cabecera de declaración de una clase simplificado, en este caso se su terminación será “.i”. Este archivo será tomado por el precompilador el cual dejará como salida un archivo tipo C++ que deberá ser compilado con nuestro proyecto.

También, para acceder a ciertas funcionalidades, podemos requerir la generación de clases especiales en Python llamadas shadow classes, estas clases son la contra parte de las clases C++ a la cuales queremos acceder. De este modo podremos hacer referencia a ellas desde Python como si fuesen nativas y se podrán manejar objetos C++ como si fuesen de Python (con la contra de introducir una indirección extra).

Una vez creado el archivo del tipo .i deberemos utilizar la herramienta swig para generar el archivo c++ del siguiente modo:

swig -c++ -python -shadow -o clasefoo.cxx clasefoo.i

El modificador -c++ indica que el código a generar es C++, el -python indica que el lenguaje objetivo es Python, luego especificamos que genere shadow classes con -shadow y finalmente especificamos el archivo de salida con -o.

También podremos configurar el entorno Visual Studio .NET para que la herramienta sea invocada automáticamente cuando estamos construyendo el proyecto.
Para esto deberemos realizar los siguientes pasos:

1. Incluir el archivo i en nuestro proyecto.

2. Mover el archivo en el panel “Solution Explorer” desde “Solutions Items” a “Source Files”:

3. Acceder a las propiedades del archivo clasefoo.i y en la sección “Custom Build Setup” agregar en:

CommandLine: swig -c++ -python -shadow -o $(InputName).cxx $(InputName).i
$(InputName) es una variable que representa el nombre del archivo.

Description: Precompilando con Swig
Aquí podremos especificar la descripción que deseemos (este mensaje aparecerá en la ventana “Output” cuando el entorno de desarrollo esté trabajando en la construcción del proyecto).

Outputs: $(ProjectDir)/$(InputName).cxx
Indicamos cual será el nombre y ubicación del archivo de salida.

4. Precompilado por primera vez el archivo pkg, agregamos su salida al proyecto (el archivo del tipo cxx) para que sea compilado convenientemente.

Ahora, vamos a utilizar la misma clase que utilizamos en el ejemplo de ToLua:

Archivo: ClaseFoo.h

| class ClaseFoo
| {
| public:
| ClaseFoo();
| ~ClaseFoo();
|
| int m_valor;
|
| void SetValor(int iVal);
| int GetValor();
| };


El archivo de interfaz va a ser bastante similar al de ToLua, veamos:


| %module clasefoo
| %{
| #include "ClaseFoo.h"
| %}
|
| class ClaseFoo
| {
| public:
| ClaseFoo();
| ~ClaseFoo();
| static int m_svalor;
| int m_valor;
| void SetValor(int iVal);
| int GetValor();
| };


Podemos apreciar que también introducimos un #include para que sea pasado directamente y sin interpretación al archivo generado.

Cuando swig entre en acción generará un archivo similar al que se muestra a continuación:


| /* ----------------------------------------------------------------------------
| * This file was automatically generated by SWIG (http://www.swig.org).
| * Version 1.3.23
| *
| * This file is not intended to be easily readable and contains a number of
| * coding conventions designed to improve portability and efficiency. Do not make
| * changes to this file unless you know what you are doing--modify the SWIG
| * interface file instead.
| * ----------------------------------------------------------------------------- */
|
| #define SWIGPYTHON
|
| #ifdef __cplusplus
| template<class T> class SwigValueWrapper
| {
| T *tt;
| public:
| SwigValueWrapper() : tt(0) { }
| SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
| SwigValueWrapper(const T& t) : tt(new T(t)) { }
| ~SwigValueWrapper() { delete tt; }
| SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
| operator T&() const { return *tt; }
| T *operator&() { return tt; }
| private:
| SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
| };
| #endif
|
| #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
| # if defined(__SUNPRO_CC)
| # define SWIG_TEMPLATE_DISAMBIGUATOR template
| # else
| # define SWIG_TEMPLATE_DISAMBIGUATOR
| # endif
| #endif
|
| #include <Python.h>
|
| /***********************************************************************
| * common.swg
| *
| * This file contains generic SWIG runtime support for pointer
| * type checking as well as a few commonly used macros to control
| * external linkage.
| *
| * Author : David Beazley (beazley@cs.uchicago.edu)
| *
| * Copyright (c) 1999-2000, The University of Chicago
| *
| * This file may be freely redistributed without license or fee provided
| * this copyright message remains intact.
| ************************************************************************/
|
| #include <string.h>
| // ...


Del archivo generado, sólo mostramos una sección ya que el archivo real poseía 1450 líneas de código (!).

Conclusión

Luego de haber decidido utilizar un sistema de scripts como Python, Lua o el que fuese podremos hacer uso de algunas de las opciones que mencionamos en este artículo (o soluciones similares para otros lenguajes). Sin embargo, siempre existe quien opine que es mejor hacer todo el trabajo a mano y que el código compilado en nuestro proyecto sea exclusivamente generado por nosotros y no por un sistema genérico no optimizado para uso en juegos; al menos esta fue la opinión que escuché alguna vez de un respetado colega de la industria. Es cuestión de probar, al fin y al cabo todo el código generado por estos precompiladores pueden ser analizados por nosotros las veces que sean necesarias.

Pages: 1 2

Comentarios (1)