/* DEBUG : Language specific headers go here */

/* DEBUG : Pointer conversion function here */

/* DEBUG : Language specific code here */

#define   SWIG_init     swig_init

#define   SWIG_name    "swig"


extern int  t_eint; 
extern short  t_eshort; 
extern long  t_elong; 
extern unsigned int  t_euint; 
extern unsigned short  t_eushort; 
extern unsigned long  t_eulong; 
extern signed int  t_esint; 
extern signed short  t_esshort; 
extern signed long  t_eslong; 
extern unsigned  t_eu; 
extern signed  t_es; 
extern signed char  t_eschar; 
extern unsigned char  t_euchar; 
extern char  t_echar; 
extern float  t_efloat; 
extern double  t_edouble; 
extern bool  t_ebool; 
extern int  ea; 
extern int * eb; 
extern int ** ec; 
extern int *** ed; 


enum months {JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};
#define test_value 4

typedef struct Vector {
	double x,y,z;
} Vector;	

Vector v1;

int const_foo(int a, int b) {
	return a + b;
};

typedef int (*PFOO)(int, int);



WRAPPER : char *getenv(char *);

WRAPPER : void hello();

WRAPPER : int sum_int(int ,int );

WRAPPER : short sum_short(short ,short );

WRAPPER : long sum_long(long ,long );

WRAPPER : unsigned int sum_uint(unsigned int ,unsigned int );

WRAPPER : unsigned short sum_ushort(unsigned short ,unsigned short );

WRAPPER : unsigned long sum_ulong(unsigned long ,unsigned long );

WRAPPER : unsigned char sum_uchar(unsigned char ,unsigned char );

WRAPPER : signed int sum_sint(signed int ,signed int );

WRAPPER : signed short sum_sshort(signed short ,signed short );

WRAPPER : signed long sum_slong(signed long ,signed long );

WRAPPER : signed char sum_schar(signed char ,signed char );

WRAPPER : float sum_float(float ,float );

WRAPPER : double sum_double(double ,double );

WRAPPER : void prints(char *);

WRAPPER : void printc(char );

WRAPPER : int *sum_pint(int *,int *);

WRAPPER : short *sum_pshort(short *,short *);

WRAPPER : long *sum_plong(long *,long *);

WRAPPER : unsigned int *sum_puint(unsigned int *,unsigned int *);

WRAPPER : unsigned short *sum_pushort(unsigned short *,unsigned short *);

WRAPPER : unsigned long *sum_pulong(unsigned long *,unsigned long *);

WRAPPER : unsigned char *sum_puchar(unsigned char *,unsigned char *);

WRAPPER : signed int *sum_psint(signed int *,signed int *);

WRAPPER : signed short *sum_psshort(signed short *,signed short *);

WRAPPER : signed long *sum_pslong(signed long *,signed long *);

WRAPPER : signed char *sum_pschar(signed char *,signed char *);

WRAPPER : float *sum_pfloat(float *,float *);

WRAPPER : double *sum_pdouble(double *,double *);

WRAPPER : void *incr_ptr(void *,int );

WRAPPER : Vector *new_Vector(double ,double ,double );

WRAPPER : void print_Vector(Vector *);

WRAPPER : Vector addv(Vector ,Vector );

WRAPPER : int *new_int(int );

WRAPPER : short *new_short(short );

WRAPPER : long *new_long(long );

WRAPPER : unsigned int *new_uint(unsigned int );

WRAPPER : unsigned short *new_ushort(unsigned short );

WRAPPER : unsigned long *new_ulong(unsigned long );

WRAPPER : unsigned char *new_uchar(unsigned char );

WRAPPER : signed int *new_sint(signed int );

WRAPPER : signed short *new_sshort(signed short );

WRAPPER : signed long *new_slong(signed long );

WRAPPER : signed char *new_schar(signed char );

WRAPPER : float *new_float(float );

WRAPPER : double *new_double(double );

WRAPPER : void *malloc(int );

WRAPPER : struct Foo func(struct Foo );

WRAPPER : class Bar func1(class Bar *);

WRAPPER : union Grok func2(union Grok *);

WRAPPER : enum Enum func3(enum Enum2 );

WRAPPER : int  t_int; 
WRAPPER : short  t_short; 
WRAPPER : long  t_long; 
WRAPPER : unsigned int  t_uint; 
WRAPPER : unsigned short  t_ushort; 
WRAPPER : unsigned long  t_ulong; 
WRAPPER : signed int  t_sint; 
WRAPPER : signed short  t_sshort; 
WRAPPER : signed long  t_slong; 
WRAPPER : unsigned  t_u; 
WRAPPER : signed  t_s; 
WRAPPER : signed char  t_schar; 
WRAPPER : unsigned char  t_uchar; 
WRAPPER : char  t_char; 
WRAPPER : float  t_float; 
WRAPPER : double  t_double; 
WRAPPER : bool  t_bool; 
WRAPPER : int * t_aint; 
WRAPPER : double * t_adouble; 
WRAPPER : float *** t_pfloat; 
WRAPPER : struct Matrix1  t_struct; 
WRAPPER : class Matrix2  t_class; 
WRAPPER : union Matrix3  t_union; 
WRAPPER : Matrix4  t_user; 
WRAPPER : struct Matrix4 * t_pstruct; 
WRAPPER : class Matrix5 * t_pclass; 
WRAPPER : union Matrix6 * t_punion; 
WRAPPER : Matrix7 * t_puser; 
WRAPPER : int  a; 
WRAPPER : int * b; 
WRAPPER : int ** c; 
WRAPPER : int *** d; 
WRAPPER : int  t_eint; 
WRAPPER : short  t_eshort; 
WRAPPER : long  t_elong; 
WRAPPER : unsigned int  t_euint; 
WRAPPER : unsigned short  t_eushort; 
WRAPPER : unsigned long  t_eulong; 
WRAPPER : signed int  t_esint; 
WRAPPER : signed short  t_esshort; 
WRAPPER : signed long  t_eslong; 
WRAPPER : unsigned  t_eu; 
WRAPPER : signed  t_es; 
WRAPPER : signed char  t_eschar; 
WRAPPER : unsigned char  t_euchar; 
WRAPPER : char  t_echar; 
WRAPPER : float  t_efloat; 
WRAPPER : double  t_edouble; 
WRAPPER : bool  t_ebool; 
WRAPPER : int  ea; 
WRAPPER : int * eb; 
WRAPPER : int ** ec; 
WRAPPER : int *** ed; 
WRAPPER : char  aa[32]; 
WRAPPER : int  ai[100]; 
WRAPPER : Vector  av[200]; 
C++ CLASS DECLARATION : class Func
WRAPPER : double Func::div(double ,double );

C++ CLASS DECLARATION : class Func4
C++ CLASS DECLARATION : class Func2
C++ CLASS DECLARATION : class Data
C++ CLASS DECLARATION : class Shape
C++ CLASS DECLARATION : class TwoD
C++ CLASS DECLARATION : class ThreeD
C++ CLASS DECLARATION : class Circle
C++ CLASS DECLARATION : class Square
C++ CLASS DECLARATION : class Sphere
C++ CLASS DECLARATION : class Cube
C++ CLASS DECLARATION : class ENUM
C++ CLASS DECLARATION : class ENUM1
C++ CLASS DECLARATION : class ROnlyBase
C++ CLASS DECLARATION : class ROnly
C++ CLASS DECLARATION : class Foo
WRAPPER : int  my_variable; 
WRAPPER : double sum(double ,double );

C++ CLASS DECLARATION : class Foo2
C++ CLASS DECLARATION : class Class
WRAPPER : Class *retClass();

C++ CLASS DECLARATION : class Foo3
C++ CLASS DECLARATION : class Foo4
C++ CLASS DECLARATION : class Bar
WRAPPER : void OldName(double );

WRAPPER : void SameName(int );

WRAPPER : int foo10(double );

WRAPPER : int old_name(double );

C++ CLASS DECLARATION : class C
C++ CLASS START : class Func  ========================================

        CONSTRUCTOR   : Func *Func(double );
        DESTRUCTOR    : ~Func();
        MEMBER FUNC   : double add(double );

        MEMBER FUNC   : double abs();

        STATIC FUNC   : double mul(double ,double );
        MEMBER FUNC   : double sub(double &);

        MEMBER FUNC   : double &new_double(double );

C++ CLASS END ===================================================

C++ CLASS START : class Func2  ========================================

        MEMBER FUNC   : int add_int(int ,int );

        MEMBER FUNC   : short add_short(short ,short );

        MEMBER FUNC   : long add_long(long ,long );

        MEMBER FUNC   : unsigned int add_uint(unsigned int ,unsigned int );

        MEMBER FUNC   : unsigned short add_ushort(unsigned short ,unsigned short );

        MEMBER FUNC   : unsigned long add_ulong(unsigned long ,unsigned long );

        MEMBER FUNC   : unsigned char add_uchar(unsigned char ,unsigned char );

        MEMBER FUNC   : signed char add_char(signed char ,signed char );

        MEMBER FUNC   : float add_float(float ,float );

        MEMBER FUNC   : double add_double(double ,double );

        MEMBER FUNC   : void hello();

        MEMBER FUNC   : int *nothing_pint(int *,int *);

        MEMBER FUNC   : short *nothing_pshort(short *,short *);

        MEMBER FUNC   : long *nothing_plong(long *,long *);

        MEMBER FUNC   : unsigned int *nothing_puint(unsigned int *,unsigned int *);

        MEMBER FUNC   : unsigned short *nothing_pushort(unsigned short *,unsigned short *);

        MEMBER FUNC   : unsigned long *nothing_pulong(unsigned long *,unsigned long *);

        MEMBER FUNC   : unsigned char *nothing_puchar(unsigned char *,unsigned char *);

        MEMBER FUNC   : signed char *nothing_pschar(signed char *,signed char *);

        MEMBER FUNC   : float *nothing_pfloat(float *,float *);

        MEMBER FUNC   : double *nothing_pdouble(double *,double *);

        MEMBER FUNC   : void print(char *);

        MEMBER FUNC   : int &ref_int(int &);

        MEMBER FUNC   : short &ref_short(short &);

        MEMBER FUNC   : long &ref_long(long &);

        MEMBER FUNC   : unsigned int &ref_uint(unsigned int &);

        MEMBER FUNC   : unsigned short &ref_ushort(unsigned short &);

        MEMBER FUNC   : unsigned long &ref_ulong(unsigned long &);

        MEMBER FUNC   : unsigned char &ref_uchar(unsigned char &);

        MEMBER FUNC   : signed char &ref_schar(signed char &);

        MEMBER FUNC   : float &ref_float(float &);

        MEMBER FUNC   : double &ref_double(double &);

        MEMBER FUNC   : char &ref_char(char &);

C++ CLASS END ===================================================

C++ CLASS START : class Data  ========================================

        ATTRIBUTE     : int  d_int; 
        ATTRIBUTE     : short  d_short; 
        ATTRIBUTE     : long  d_long; 
        ATTRIBUTE     : unsigned int  d_uint; 
        ATTRIBUTE     : unsigned short  d_ushort; 
        ATTRIBUTE     : unsigned long  d_ulong; 
        ATTRIBUTE     : unsigned char  d_uchar; 
        ATTRIBUTE     : signed char  d_schar; 
        ATTRIBUTE     : float  d_float; 
        ATTRIBUTE     : double  d_double; 
        ATTRIBUTE     : char * d_string; 
        ATTRIBUTE     : char  d_char; 
        ATTRIBUTE     : int * p_int; 
        ATTRIBUTE     : short * p_short; 
        ATTRIBUTE     : long * p_long; 
        ATTRIBUTE     : unsigned int * p_uint; 
        ATTRIBUTE     : unsigned short * p_ushort; 
        ATTRIBUTE     : unsigned long * p_ulong; 
        ATTRIBUTE     : unsigned char * p_uchar; 
        ATTRIBUTE     : signed char * p_schar; 
        ATTRIBUTE     : float * p_float; 
        ATTRIBUTE     : double * p_double; 
        C++ STATIC VAR: int  s_int; 
        C++ STATIC VAR: short  s_short; 
        C++ STATIC VAR: long  s_long; 
        C++ STATIC VAR: float  s_float; 
        C++ STATIC VAR: double  s_double; 
        C++ STATIC VAR: char * s_string; 
        ATTRIBUTE     : Vector  vec; 
        ATTRIBUTE     : Vector & rvec; 
C++ CLASS END ===================================================

C++ CLASS START : class Shape  ========================================

        DESTRUCTOR    : ~Shape();
        CONSTRUCTOR   : Shape *Shape();
        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        MEMBER FUNC   : void print();

        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class TwoD  ========================================

inheriting from baseclass : Shape
static void *SwigTwoDToShape(void *ptr) {
    TwoD *src;
    Shape *dest;
    src = (TwoD *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        DESTRUCTOR    : ~TwoD();
        MEMBER FUNC   : void set_center(double ,double );

        MEMBER FUNC   : double area();

        MEMBER FUNC   : double perimeter();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class ThreeD  ========================================

inheriting from baseclass : Shape
static void *SwigThreeDToShape(void *ptr) {
    ThreeD *src;
    Shape *dest;
    src = (ThreeD *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        DESTRUCTOR    : ~ThreeD();
        MEMBER FUNC   : void set_center(double ,double ,double );

        MEMBER FUNC   : double volume();

        MEMBER FUNC   : double surface();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class Circle  ========================================

inheriting from baseclass : TwoD
static void *SwigCircleToTwoD(void *ptr) {
    Circle *src;
    TwoD *dest;
    src = (Circle *) ptr;
    dest = (TwoD *) src;
    return (void *) dest;
}

static void *SwigCircleToShape(void *ptr) {
    Circle *src;
    Shape *dest;
    src = (Circle *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        CONSTRUCTOR   : Circle *Circle(double );
        MEMBER FUNC   : double area();

        MEMBER FUNC   : double perimeter();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void set_center(double ,double );

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class Square  ========================================

inheriting from baseclass : TwoD
static void *SwigSquareToTwoD(void *ptr) {
    Square *src;
    TwoD *dest;
    src = (Square *) ptr;
    dest = (TwoD *) src;
    return (void *) dest;
}

static void *SwigSquareToShape(void *ptr) {
    Square *src;
    Shape *dest;
    src = (Square *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        CONSTRUCTOR   : Square *Square(double );
        MEMBER FUNC   : double area();

        MEMBER FUNC   : double perimeter();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void set_center(double ,double );

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class Sphere  ========================================

inheriting from baseclass : ThreeD
static void *SwigSphereToThreeD(void *ptr) {
    Sphere *src;
    ThreeD *dest;
    src = (Sphere *) ptr;
    dest = (ThreeD *) src;
    return (void *) dest;
}

static void *SwigSphereToShape(void *ptr) {
    Sphere *src;
    Shape *dest;
    src = (Sphere *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        CONSTRUCTOR   : Sphere *Sphere(double );
        MEMBER FUNC   : double volume();

        MEMBER FUNC   : double surface();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void set_center(double ,double ,double );

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class Cube  ========================================

inheriting from baseclass : ThreeD
static void *SwigCubeToThreeD(void *ptr) {
    Cube *src;
    ThreeD *dest;
    src = (Cube *) ptr;
    dest = (ThreeD *) src;
    return (void *) dest;
}

static void *SwigCubeToShape(void *ptr) {
    Cube *src;
    Shape *dest;
    src = (Cube *) ptr;
    dest = (Shape *) src;
    return (void *) dest;
}

        CONSTRUCTOR   : Cube *Cube(double );
        MEMBER FUNC   : double volume();

        MEMBER FUNC   : double surface();

        MEMBER FUNC   : void print();

        MEMBER FUNC   : void set_center(double ,double ,double );

        MEMBER FUNC   : void print_center();

        MEMBER FUNC   : void ref();

        MEMBER FUNC   : void deref();

        MEMBER FUNC   : int get_ref();

        ATTRIBUTE     : int  color; 
        ATTRIBUTE     : char * name; 
C++ CLASS END ===================================================

C++ CLASS START : class ENUM  ========================================

        C++ CONST     : (int ) ALE = [None]
        C++ CONST     : (int ) LAGER = [None]
        C++ CONST     : (int ) STOUT = [None]
        C++ CONST     : (int ) PILSNER = [None]
        MEMBER FUNC   : void foo(ENUM::Enum1 );

        MEMBER FUNC   : ENUM::Real bar(ENUM::Real );

C++ CLASS END ===================================================

C++ CLASS START : class ENUM1  ========================================

inheriting from baseclass : ENUM
static void *SwigENUM1ToENUM(void *ptr) {
    ENUM1 *src;
    ENUM *dest;
    src = (ENUM1 *) ptr;
    dest = (ENUM *) src;
    return (void *) dest;
}

        MEMBER FUNC   : void foo2(ENUM::Enum1 );

        MEMBER FUNC   : ENUM::Real bar2(ENUM::Real );

        C++ CONST     : (int ) ALE = [None]
        C++ CONST     : (int ) LAGER = [None]
        C++ CONST     : (int ) STOUT = [None]
        C++ CONST     : (int ) PILSNER = [None]
        MEMBER FUNC   : void foo(ENUM::Enum1 );

        MEMBER FUNC   : ENUM::Real bar(ENUM::Real );

C++ CLASS END ===================================================

C++ CLASS START : class ROnlyBase  ========================================

        ATTRIBUTE     : int  x; 
        ATTRIBUTE     : int  y; 
C++ CLASS END ===================================================

C++ CLASS START : class ROnly  ========================================

inheriting from baseclass : ROnlyBase
static void *SwigROnlyToROnlyBase(void *ptr) {
    ROnly *src;
    ROnlyBase *dest;
    src = (ROnly *) ptr;
    dest = (ROnlyBase *) src;
    return (void *) dest;
}

        ATTRIBUTE     : int  x; 
        ATTRIBUTE     : int  y; 
C++ CLASS END ===================================================

C++ CLASS START : class Foo  ========================================

        C++ CONST     : (int ) JAN = [None]
        C++ CONST     : (int ) FEB = [None]
        C++ CONST     : (int ) MAR = [None]
        C++ CONST     : (int ) APR = [None]
        C++ CONST     : (int ) MAY = [None]
        C++ CONST     : (int ) JUN = [None]
        C++ CONST     : (int ) JUL = [None]
        C++ CONST     : (int ) AUG = [None]
        C++ CONST     : (int ) SEP = [None]
        C++ CONST     : (int ) OCT = [None]
        C++ CONST     : (int ) NOV = [None]
        C++ CONST     : (int ) DEC = [None]
        C++ CONST     : (int ) PEAR = [None]
        C++ CONST     : (int ) APPLE = [None]
        C++ CONST     : (int ) BANANA = [None]
        C++ CONST     : (int ) PEACH = [None]
        C++ CONST     : (int ) VAL1 = [None]
        C++ CONST     : (int ) VAL2 = [None]
        C++ CONST     : (int ) VAL3 = [None]
        C++ CONST     : (double ) MAX = 50
C++ CLASS END ===================================================

C++ CLASS START : class Foo2  ========================================

        ATTRIBUTE     : double  var; 
        C++ STATIC VAR: double  static_var; 
        MEMBER FUNC   : int sum(int ,int );

        STATIC FUNC   : int mul(int ,int );
        C++ CONST     : (int ) lager = [None]
        C++ CONST     : (int ) ale = [None]
        C++ CONST     : (int ) stout = [None]
        C++ CONST     : (int ) pilsner = [None]
        MEMBER FUNC   : int foo(double ,double );

        MEMBER FUNC   : void foo(char *);

        STATIC FUNC   : int bar(double );
        STATIC FUNC   : void bar(char *);
        STATIC FUNC   : int bar(int );
C++ CLASS END ===================================================

C++ CLASS START : class Class  ========================================

        ATTRIBUTE     : int  member_data; 
        MEMBER FUNC   : double member_func();

        MEMBER FUNC   : void pointer(Class *);

        MEMBER FUNC   : Class *retptr();

C++ CLASS END ===================================================

C++ CLASS START : class Foo3  ========================================

inheriting from baseclass : Foo2
static void *SwigFoo3ToFoo2(void *ptr) {
    Foo3 *src;
    Foo2 *dest;
    src = (Foo3 *) ptr;
    dest = (Foo2 *) src;
    return (void *) dest;
}

        ATTRIBUTE     : double  var; 
        C++ STATIC VAR: double  static_var; 
        MEMBER FUNC   : int sum(int ,int );

        STATIC FUNC   : int mul(int ,int );
        C++ CONST     : (int ) lager = [None]
        C++ CONST     : (int ) ale = [None]
        C++ CONST     : (int ) stout = [None]
        C++ CONST     : (int ) pilsner = [None]
        MEMBER FUNC   : int foo(double ,double );

        MEMBER FUNC   : void foo(char *);

        STATIC FUNC   : int bar(double );
        STATIC FUNC   : void bar(char *);
C++ CLASS END ===================================================

C++ CLASS START : class Foo4  ========================================

inheriting from baseclass : Foo3
static void *SwigFoo4ToFoo3(void *ptr) {
    Foo4 *src;
    Foo3 *dest;
    src = (Foo4 *) ptr;
    dest = (Foo3 *) src;
    return (void *) dest;
}

static void *SwigFoo4ToFoo2(void *ptr) {
    Foo4 *src;
    Foo2 *dest;
    src = (Foo4 *) ptr;
    dest = (Foo2 *) src;
    return (void *) dest;
}

        ATTRIBUTE     : double  var; 
        C++ STATIC VAR: double  static_var; 
        MEMBER FUNC   : int sum(int ,int );

        STATIC FUNC   : int mul(int ,int );
        C++ CONST     : (int ) lager = [None]
        C++ CONST     : (int ) ale = [None]
        C++ CONST     : (int ) stout = [None]
        C++ CONST     : (int ) pilsner = [None]
        MEMBER FUNC   : int foo(double ,double );

        MEMBER FUNC   : void foo(char *);

        STATIC FUNC   : int bar(double );
        STATIC FUNC   : void bar(char *);
C++ CLASS END ===================================================

C++ CLASS START : class Bar  ========================================

inheriting from baseclass : Class
static void *SwigBarToClass(void *ptr) {
    Bar *src;
    Class *dest;
    src = (Bar *) ptr;
    dest = (Class *) src;
    return (void *) dest;
}

        ATTRIBUTE     : int  member_data; 
        MEMBER FUNC   : double member_func();

        MEMBER FUNC   : void pointer(Class *);

        MEMBER FUNC   : Class *retptr();

C++ CLASS END ===================================================

C++ CLASS START : class C  ========================================

        MEMBER FUNC   : int old_name(int );

C++ CLASS END ===================================================

SWIG POINTER-MAPPING TABLE


/* MODULE INITIALIZATION */

void swig_init() {
     ADD COMMAND    : getenv --> char *getenv(char *);
     ADD COMMAND    : hello --> void hello();
     ADD COMMAND    : sum_int --> int sum_int(int ,int );
     ADD COMMAND    : sum_short --> short sum_short(short ,short );
     ADD COMMAND    : sum_long --> long sum_long(long ,long );
     ADD COMMAND    : sum_uint --> unsigned int sum_uint(unsigned int ,unsigned int );
     ADD COMMAND    : sum_ushort --> unsigned short sum_ushort(unsigned short ,unsigned short );
     ADD COMMAND    : sum_ulong --> unsigned long sum_ulong(unsigned long ,unsigned long );
     ADD COMMAND    : sum_uchar --> unsigned char sum_uchar(unsigned char ,unsigned char );
     ADD COMMAND    : sum_sint --> signed int sum_sint(signed int ,signed int );
     ADD COMMAND    : sum_sshort --> signed short sum_sshort(signed short ,signed short );
     ADD COMMAND    : sum_slong --> signed long sum_slong(signed long ,signed long );
     ADD COMMAND    : sum_schar --> signed char sum_schar(signed char ,signed char );
     ADD COMMAND    : sum_float --> float sum_float(float ,float );
     ADD COMMAND    : sum_double --> double sum_double(double ,double );
     ADD COMMAND    : prints --> void prints(char *);
     ADD COMMAND    : printc --> void printc(char );
     ADD COMMAND    : sum_pint --> int *sum_pint(int *,int *);
     ADD COMMAND    : sum_pshort --> short *sum_pshort(short *,short *);
     ADD COMMAND    : sum_plong --> long *sum_plong(long *,long *);
     ADD COMMAND    : sum_puint --> unsigned int *sum_puint(unsigned int *,unsigned int *);
     ADD COMMAND    : sum_pushort --> unsigned short *sum_pushort(unsigned short *,unsigned short *);
     ADD COMMAND    : sum_pulong --> unsigned long *sum_pulong(unsigned long *,unsigned long *);
     ADD COMMAND    : sum_puchar --> unsigned char *sum_puchar(unsigned char *,unsigned char *);
     ADD COMMAND    : sum_psint --> signed int *sum_psint(signed int *,signed int *);
     ADD COMMAND    : sum_psshort --> signed short *sum_psshort(signed short *,signed short *);
     ADD COMMAND    : sum_pslong --> signed long *sum_pslong(signed long *,signed long *);
     ADD COMMAND    : sum_pschar --> signed char *sum_pschar(signed char *,signed char *);
     ADD COMMAND    : sum_pfloat --> float *sum_pfloat(float *,float *);
     ADD COMMAND    : sum_pdouble --> double *sum_pdouble(double *,double *);
     ADD COMMAND    : incr_ptr --> void *incr_ptr(void *,int );
     ADD COMMAND    : new_Vector --> Vector *new_Vector(double ,double ,double );
     ADD COMMAND    : print_Vector --> void print_Vector(Vector *);
     ADD COMMAND    : addv --> Vector addv(Vector ,Vector );
     ADD COMMAND    : new_int --> int *new_int(int );
     ADD COMMAND    : new_short --> short *new_short(short );
     ADD COMMAND    : new_long --> long *new_long(long );
     ADD COMMAND    : new_uint --> unsigned int *new_uint(unsigned int );
     ADD COMMAND    : new_ushort --> unsigned short *new_ushort(unsigned short );
     ADD COMMAND    : new_ulong --> unsigned long *new_ulong(unsigned long );
     ADD COMMAND    : new_uchar --> unsigned char *new_uchar(unsigned char );
     ADD COMMAND    : new_sint --> signed int *new_sint(signed int );
     ADD COMMAND    : new_sshort --> signed short *new_sshort(signed short );
     ADD COMMAND    : new_slong --> signed long *new_slong(signed long );
     ADD COMMAND    : new_schar --> signed char *new_schar(signed char );
     ADD COMMAND    : new_float --> float *new_float(float );
     ADD COMMAND    : new_double --> double *new_double(double );
     ADD COMMAND    : malloc --> void *malloc(int );
     ADD COMMAND    : func --> struct Foo func(struct Foo );
     ADD COMMAND    : func1 --> class Bar func1(class Bar *);
     ADD COMMAND    : func2 --> union Grok func2(union Grok *);
     ADD COMMAND    : func3 --> enum Enum func3(enum Enum2 );
     ADD VARIABLE   : t_int --> int  t_int; 
     ADD VARIABLE   : t_short --> short  t_short; 
     ADD VARIABLE   : t_long --> long  t_long; 
     ADD VARIABLE   : t_uint --> unsigned int  t_uint; 
     ADD VARIABLE   : t_ushort --> unsigned short  t_ushort; 
     ADD VARIABLE   : t_ulong --> unsigned long  t_ulong; 
     ADD VARIABLE   : t_sint --> signed int  t_sint; 
     ADD VARIABLE   : t_sshort --> signed short  t_sshort; 
     ADD VARIABLE   : t_slong --> signed long  t_slong; 
     ADD VARIABLE   : t_u --> unsigned  t_u; 
     ADD VARIABLE   : t_s --> signed  t_s; 
     ADD VARIABLE   : t_schar --> signed char  t_schar; 
     ADD VARIABLE   : t_uchar --> unsigned char  t_uchar; 
     ADD VARIABLE   : t_char --> char  t_char; 
     ADD VARIABLE   : t_float --> float  t_float; 
     ADD VARIABLE   : t_double --> double  t_double; 
     ADD VARIABLE   : t_bool --> bool  t_bool; 
     ADD VARIABLE   : t_aint --> int * t_aint; 
     ADD VARIABLE   : t_adouble --> double * t_adouble; 
     ADD VARIABLE   : t_pfloat --> float *** t_pfloat; 
     ADD VARIABLE   : t_struct --> struct Matrix1  t_struct; 
     ADD VARIABLE   : t_class --> class Matrix2  t_class; 
     ADD VARIABLE   : t_union --> union Matrix3  t_union; 
     ADD VARIABLE   : t_user --> Matrix4  t_user; 
     ADD VARIABLE   : t_pstruct --> struct Matrix4 * t_pstruct; 
     ADD VARIABLE   : t_pclass --> class Matrix5 * t_pclass; 
     ADD VARIABLE   : t_punion --> union Matrix6 * t_punion; 
     ADD VARIABLE   : t_puser --> Matrix7 * t_puser; 
     ADD VARIABLE   : a --> int  a; 
     ADD VARIABLE   : b --> int * b; 
     ADD VARIABLE   : c --> int ** c; 
     ADD VARIABLE   : d --> int *** d; 
     ADD VARIABLE   : t_eint --> int  t_eint; 
     ADD VARIABLE   : t_eshort --> short  t_eshort; 
     ADD VARIABLE   : t_elong --> long  t_elong; 
     ADD VARIABLE   : t_euint --> unsigned int  t_euint; 
     ADD VARIABLE   : t_eushort --> unsigned short  t_eushort; 
     ADD VARIABLE   : t_eulong --> unsigned long  t_eulong; 
     ADD VARIABLE   : t_esint --> signed int  t_esint; 
     ADD VARIABLE   : t_esshort --> signed short  t_esshort; 
     ADD VARIABLE   : t_eslong --> signed long  t_eslong; 
     ADD VARIABLE   : t_eu --> unsigned  t_eu; 
     ADD VARIABLE   : t_es --> signed  t_es; 
     ADD VARIABLE   : t_eschar --> signed char  t_eschar; 
     ADD VARIABLE   : t_euchar --> unsigned char  t_euchar; 
     ADD VARIABLE   : t_echar --> char  t_echar; 
     ADD VARIABLE   : t_efloat --> float  t_efloat; 
     ADD VARIABLE   : t_edouble --> double  t_edouble; 
     ADD VARIABLE   : t_ebool --> bool  t_ebool; 
     ADD VARIABLE   : ea --> int  ea; 
     ADD VARIABLE   : eb --> int * eb; 
     ADD VARIABLE   : ec --> int ** ec; 
     ADD VARIABLE   : ed --> int *** ed; 
     ADD VARIABLE   : aa --> char  aa[32]; 
     ADD VARIABLE   : ai --> int  ai[100]; 
     ADD VARIABLE   : av --> Vector  av[200]; 
     ADD CONSTANT   : (int ) ICON1 = 42
     ADD CONSTANT   : (int ) ICON2 = -13
     ADD CONSTANT   : (double ) FCON1 = 3.14159
     ADD CONSTANT   : (double ) FCON2 = 2.134e3
     ADD CONSTANT   : (double ) FCON3 = 2e3
     ADD CONSTANT   : (double ) FCON4 = 2e+3
     ADD CONSTANT   : (double ) FCON5 = 2e-3
     ADD CONSTANT   : (double ) FCON6 = -3e-7
     ADD CONSTANT   : (char *) CCON1 = a
     ADD CONSTANT   : (char *) SCON1 = hello world
     ADD CONSTANT   : (char *) CCON2 = \n
     ADD CONSTANT   : (char *) CCON3 = \123
     ADD CONSTANT   : (char *) CCON4 = \x13
     ADD CONSTANT   : (double ) FCON65 = .53
     ADD CONSTANT   : (int ) SIZE_INT = sizeof(int)
     ADD CONSTANT   : (int ) IEXPR = 2+3
     ADD CONSTANT   : (int ) IEXPR2 = 2*3
     ADD CONSTANT   : (int ) IEXPR3 = 3-2
     ADD CONSTANT   : (int ) IEXPR4 = 3/2
     ADD CONSTANT   : (int ) IEXPR5 = (2+3)
     ADD CONSTANT   : (int ) IEXPR6 = (2+3*((2+3)))/4
     ADD CONSTANT   : (double ) FEXPR = 3.14159*2.3
     ADD CONSTANT   : (double ) FEXPR2 = (3.14159)/(2.134e3)
     ADD CONSTANT   : (double ) FEXPR3 = (2.1+3.5*7.4)*2.1
     ADD CONSTANT   : (double ) FEXPR4 = 3.14+2
     ADD CONSTANT   : (double ) FEXPR5 = 8.89+(2+3)
     ADD CONSTANT   : (int ) BCON1 = 0x3f&0x8
     ADD CONSTANT   : (int ) BCON2 = 0x3f|0x822
     ADD CONSTANT   : (int ) BCON3 = 0x3f^0x822
     ADD CONSTANT   : (int ) BCON4 = ~0x3f
     ADD CONSTANT   : (int ) BCON5 = 0x3f<<4
     ADD CONSTANT   : (int ) BCON6 = 0x3f>>4
     ADD CONSTANT   : (int ) BCON7 = (1<<8)|(1<<7)|(1<<6)
     ADD CONSTANT   : (int ) BCON8 = ((1<<8)|(1<<7)|(1<<6))&(0x3f>>4)
     ADD CONSTANT   : (int ) JAN = JAN
     ADD CONSTANT   : (int ) FEB = FEB
     ADD CONSTANT   : (int ) MAR = MAR
     ADD CONSTANT   : (int ) APR = APR
     ADD CONSTANT   : (int ) MAY = MAY
     ADD CONSTANT   : (int ) JUN = JUN
     ADD CONSTANT   : (int ) JUL = JUL
     ADD CONSTANT   : (int ) AUG = AUG
     ADD CONSTANT   : (int ) SEP = SEP
     ADD CONSTANT   : (int ) OCT = OCT
     ADD CONSTANT   : (int ) NOV = NOV
     ADD CONSTANT   : (int ) DEC = DEC
     ADD CONSTANT   : (int ) READ = READ
     ADD CONSTANT   : (int ) WRITE = WRITE
     ADD CONSTANT   : (int ) USER = USER
     ADD CONSTANT   : (int ) SUPER = SUPER
     ADD CONSTANT   : (int ) ECON1 = ECON1
     ADD CONSTANT   : (int ) ECON2 = ECON2
     ADD CONSTANT   : (int ) ECON3 = ECON3
     ADD CONSTANT   : (int ) cpp_int = 6
     ADD CONSTANT   : (double ) cpp_double = 3.14159
     ADD CONSTANT   : (int ) test_value = test_value
     ADD CONSTANT   : (char *) cpp_char = Hello world
     ADD CONSTANT   : (unsigned int ) UINT = 2400000000U
     ADD CONSTANT   : (long ) LONG = 2100000000L
     ADD CONSTANT   : (unsigned long ) ULONG = 4000000000UL
     ADD CONSTANT   : (unsigned long ) ULONG2 = 4100000000LU
     ADD CONSTANT   : (double ) FCON7 = 4f
     ADD CONSTANT   : (double ) FCON8 = 4.76F
     ADD CONSTANT   : (double ) FCON9 = 5e-34F
     ADD CONSTANT   : (double ) FCON10 = 7.88234E+3L
     ADD CONSTANT   : (unsigned int ) UINT2 = 2400U+2300U-14U
     ADD CONSTANT   : (PFOO ) FOO_CALLBACK = const_foo
     ADD CONSTANT   : (Vector *) vecaddr = &v1
     ADD CONSTANT   : (int ) CAST1 = (int)4
     ADD CONSTANT   : (double ) CAST2 = (double)4
     ADD CONSTANT   : (float ) CAST3 = ((float)3.14159)
     ADD CONSTANT   : (double ) CAST4 = (Real)2.71828
     ADD CONSTANT   : (double ) CAST5 = (FooBar)2.66
     ADD CONSTANT   : (int ) CAST6 = (3+(short)2)
     ADD CONSTANT   : (int ) CAST7 = (13+(int)3.82930)
     ADD CONSTANT   : (int ) CAST8 = (FooBar)7.8
     ADD CONSTANT   : (int ) ECAST1 = ECAST1
     ADD CONSTANT   : (short ) ECAST2 = ECAST2
     ADD CONSTANT   : (char ) ECAST3 = ECAST3
     ADD CONSTANT   : (long ) ECAST4 = ECAST4
     ADD CONSTANT   : (int ) ECAST8 = ECAST8
     ADD CONSTANT   : (int ) COMMENT1 = 1
     ADD CONSTANT   : (char *) COMMENT2 = foo
     ADD COMMAND    : Func_div --> double Func::div(double ,double );
     ADD CONSTANT   : (int ) PEAR = PEAR
     ADD CONSTANT   : (int ) APPLE = APPLE
     ADD CONSTANT   : (double ) PI = 3.141592654
     ADD CONSTANT   : (int ) N = 1000
     ADD CONSTANT   : (char *) VERSION = 1.0
     ADD VARIABLE   : new_variable --> int  my_variable; 
     ADD COMMAND    : add --> double sum(double ,double );
     ADD COMMAND    : retClass --> Class *retClass();
     ADD COMMAND    : NewName --> void OldName(double );
     ADD COMMAND    : SameName --> void SameName(int );
     ADD COMMAND    : foo10 --> int foo10(double );
     ADD COMMAND    : new_name --> int old_name(double );

     // C++ CLASS START : class Func
     ADD CONSTRUCT  : Func --> Func *Func(double );
     ADD DESTRUCT  : Func --> ~Func();
     ADD MEMBER FUN : add --> double add(double );
     ADD MEMBER FUN : abs --> double abs();
     ADD STATIC FUNC: mul --> double mul(double ,double );
     ADD MEMBER FUN : sub --> double sub(double &);
     ADD MEMBER FUN : new_double --> double &new_double(double );
     // C++ CLASS END 


     // C++ CLASS START : class Func2
     ADD MEMBER FUN : add_int --> int add_int(int ,int );
     ADD MEMBER FUN : add_short --> short add_short(short ,short );
     ADD MEMBER FUN : add_long --> long add_long(long ,long );
     ADD MEMBER FUN : add_uint --> unsigned int add_uint(unsigned int ,unsigned int );
     ADD MEMBER FUN : add_ushort --> unsigned short add_ushort(unsigned short ,unsigned short );
     ADD MEMBER FUN : add_ulong --> unsigned long add_ulong(unsigned long ,unsigned long );
     ADD MEMBER FUN : add_uchar --> unsigned char add_uchar(unsigned char ,unsigned char );
     ADD MEMBER FUN : add_char --> signed char add_char(signed char ,signed char );
     ADD MEMBER FUN : add_float --> float add_float(float ,float );
     ADD MEMBER FUN : add_double --> double add_double(double ,double );
     ADD MEMBER FUN : hello --> void hello();
     ADD MEMBER FUN : nothing_pint --> int *nothing_pint(int *,int *);
     ADD MEMBER FUN : nothing_pshort --> short *nothing_pshort(short *,short *);
     ADD MEMBER FUN : nothing_plong --> long *nothing_plong(long *,long *);
     ADD MEMBER FUN : nothing_puint --> unsigned int *nothing_puint(unsigned int *,unsigned int *);
     ADD MEMBER FUN : nothing_pushort --> unsigned short *nothing_pushort(unsigned short *,unsigned short *);
     ADD MEMBER FUN : nothing_pulong --> unsigned long *nothing_pulong(unsigned long *,unsigned long *);
     ADD MEMBER FUN : nothing_puchar --> unsigned char *nothing_puchar(unsigned char *,unsigned char *);
     ADD MEMBER FUN : nothing_pschar --> signed char *nothing_pschar(signed char *,signed char *);
     ADD MEMBER FUN : nothing_pfloat --> float *nothing_pfloat(float *,float *);
     ADD MEMBER FUN : nothing_pdouble --> double *nothing_pdouble(double *,double *);
     ADD MEMBER FUN : print --> void print(char *);
     ADD MEMBER FUN : ref_int --> int &ref_int(int &);
     ADD MEMBER FUN : ref_short --> short &ref_short(short &);
     ADD MEMBER FUN : ref_long --> long &ref_long(long &);
     ADD MEMBER FUN : ref_uint --> unsigned int &ref_uint(unsigned int &);
     ADD MEMBER FUN : ref_ushort --> unsigned short &ref_ushort(unsigned short &);
     ADD MEMBER FUN : ref_ulong --> unsigned long &ref_ulong(unsigned long &);
     ADD MEMBER FUN : ref_uchar --> unsigned char &ref_uchar(unsigned char &);
     ADD MEMBER FUN : ref_schar --> signed char &ref_schar(signed char &);
     ADD MEMBER FUN : ref_float --> float &ref_float(float &);
     ADD MEMBER FUN : ref_double --> double &ref_double(double &);
     ADD MEMBER FUN : ref_char --> char &ref_char(char &);
     // C++ CLASS END 


     // C++ CLASS START : class Data
     ADD MEMBER     : d_int --> int  d_int; 
     ADD MEMBER     : d_short --> short  d_short; 
     ADD MEMBER     : d_long --> long  d_long; 
     ADD MEMBER     : d_uint --> unsigned int  d_uint; 
     ADD MEMBER     : d_ushort --> unsigned short  d_ushort; 
     ADD MEMBER     : d_ulong --> unsigned long  d_ulong; 
     ADD MEMBER     : d_uchar --> unsigned char  d_uchar; 
     ADD MEMBER     : d_schar --> signed char  d_schar; 
     ADD MEMBER     : d_float --> float  d_float; 
     ADD MEMBER     : d_double --> double  d_double; 
     ADD MEMBER     : d_string --> char * d_string; 
     ADD MEMBER     : d_char --> char  d_char; 
     ADD MEMBER     : p_int --> int * p_int; 
     ADD MEMBER     : p_short --> short * p_short; 
     ADD MEMBER     : p_long --> long * p_long; 
     ADD MEMBER     : p_uint --> unsigned int * p_uint; 
     ADD MEMBER     : p_ushort --> unsigned short * p_ushort; 
     ADD MEMBER     : p_ulong --> unsigned long * p_ulong; 
     ADD MEMBER     : p_uchar --> unsigned char * p_uchar; 
     ADD MEMBER     : p_schar --> signed char * p_schar; 
     ADD MEMBER     : p_float --> float * p_float; 
     ADD MEMBER     : p_double --> double * p_double; 
     ADD STATIC VAR : s_int --> int  s_int; 
     ADD STATIC VAR : s_short --> short  s_short; 
     ADD STATIC VAR : s_long --> long  s_long; 
     ADD STATIC VAR : s_float --> float  s_float; 
     ADD STATIC VAR : s_double --> double  s_double; 
     ADD STATIC VAR : s_string --> char * s_string; 
     ADD MEMBER     : vec --> Vector  vec; 
     ADD MEMBER     : rvec --> Vector & rvec; 
     // C++ CLASS END 


     // C++ CLASS START : class Shape
     ADD DESTRUCT  : Shape --> ~Shape();
     ADD CONSTRUCT  : Shape --> Shape *Shape();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class TwoD
     ADD DESTRUCT  : TwoD --> ~TwoD();
     ADD MEMBER FUN : set_center --> void set_center(double ,double );
     ADD MEMBER FUN : area --> double area();
     ADD MEMBER FUN : perimeter --> double perimeter();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class ThreeD
     ADD DESTRUCT  : ThreeD --> ~ThreeD();
     ADD MEMBER FUN : set_center --> void set_center(double ,double ,double );
     ADD MEMBER FUN : volume --> double volume();
     ADD MEMBER FUN : surface --> double surface();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class Circle
     ADD CONSTRUCT  : Circle --> Circle *Circle(double );
     ADD MEMBER FUN : area --> double area();
     ADD MEMBER FUN : perimeter --> double perimeter();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : set_center --> void set_center(double ,double );
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class Square
     ADD CONSTRUCT  : Square --> Square *Square(double );
     ADD MEMBER FUN : area --> double area();
     ADD MEMBER FUN : perimeter --> double perimeter();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : set_center --> void set_center(double ,double );
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class Sphere
     ADD CONSTRUCT  : Sphere --> Sphere *Sphere(double );
     ADD MEMBER FUN : volume --> double volume();
     ADD MEMBER FUN : surface --> double surface();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : set_center --> void set_center(double ,double ,double );
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class Cube
     ADD CONSTRUCT  : Cube --> Cube *Cube(double );
     ADD MEMBER FUN : volume --> double volume();
     ADD MEMBER FUN : surface --> double surface();
     ADD MEMBER FUN : print --> void print();
     ADD MEMBER FUN : set_center --> void set_center(double ,double ,double );
     ADD MEMBER FUN : print_center --> void print_center();
     ADD MEMBER FUN : ref --> void ref();
     ADD MEMBER FUN : deref --> void deref();
     ADD MEMBER FUN : get_ref --> int get_ref();
     ADD MEMBER     : color --> int  color; 
     ADD MEMBER     : name --> char * name; 
     // C++ CLASS END 


     // C++ CLASS START : class ENUM
     ADD C++ CONST  : ALE --> (int ) = [None]
     ADD C++ CONST  : LAGER --> (int ) = [None]
     ADD C++ CONST  : STOUT --> (int ) = [None]
     ADD C++ CONST  : PILSNER --> (int ) = [None]
     ADD MEMBER FUN : foo --> void foo(ENUM::Enum1 );
     ADD MEMBER FUN : bar --> ENUM::Real bar(ENUM::Real );
     // C++ CLASS END 


     // C++ CLASS START : class ENUM1
     ADD MEMBER FUN : foo2 --> void foo2(ENUM::Enum1 );
     ADD MEMBER FUN : bar2 --> ENUM::Real bar2(ENUM::Real );
     ADD C++ CONST  : ALE --> (int ) = [None]
     ADD C++ CONST  : LAGER --> (int ) = [None]
     ADD C++ CONST  : STOUT --> (int ) = [None]
     ADD C++ CONST  : PILSNER --> (int ) = [None]
     ADD MEMBER FUN : foo --> void foo(ENUM::Enum1 );
     ADD MEMBER FUN : bar --> ENUM::Real bar(ENUM::Real );
     // C++ CLASS END 


     // C++ CLASS START : class ROnlyBase
     ADD MEMBER     : x --> int  x; 
     ADD MEMBER     : y --> int  y; 
     // C++ CLASS END 


     // C++ CLASS START : class ROnly
     ADD MEMBER     : x --> int  x; 
     ADD MEMBER     : y --> int  y; 
     // C++ CLASS END 


     // C++ CLASS START : class Foo
     ADD C++ CONST  : JAN --> (int ) = [None]
     ADD C++ CONST  : FEB --> (int ) = [None]
     ADD C++ CONST  : MAR --> (int ) = [None]
     ADD C++ CONST  : APR --> (int ) = [None]
     ADD C++ CONST  : MAY --> (int ) = [None]
     ADD C++ CONST  : JUN --> (int ) = [None]
     ADD C++ CONST  : JUL --> (int ) = [None]
     ADD C++ CONST  : AUG --> (int ) = [None]
     ADD C++ CONST  : SEP --> (int ) = [None]
     ADD C++ CONST  : OCT --> (int ) = [None]
     ADD C++ CONST  : NOV --> (int ) = [None]
     ADD C++ CONST  : DEC --> (int ) = [None]
     ADD C++ CONST  : PEAR --> (int ) = [None]
     ADD C++ CONST  : APPLE --> (int ) = [None]
     ADD C++ CONST  : BANANA --> (int ) = [None]
     ADD C++ CONST  : PEACH --> (int ) = [None]
     ADD C++ CONST  : VAL1 --> (int ) = [None]
     ADD C++ CONST  : VAL2 --> (int ) = [None]
     ADD C++ CONST  : VAL3 --> (int ) = [None]
     ADD C++ CONST  : MAX --> (double ) = 50
     // C++ CLASS END 


     // C++ CLASS START : class Foo2
     ADD MEMBER     : new_var --> double  var; 
     ADD STATIC VAR : new_static_var --> double  static_var; 
     ADD MEMBER FUN : add --> int sum(int ,int );
     ADD STATIC FUNC: product --> int mul(int ,int );
     ADD C++ CONST  : LAGER --> (int ) = [None]
     ADD C++ CONST  : ALE --> (int ) = [None]
     ADD C++ CONST  : STOUT --> (int ) = [None]
     ADD C++ CONST  : PILSNER --> (int ) = [None]
     ADD MEMBER FUN : foo --> int foo(double ,double );
     ADD MEMBER FUN : foochar --> void foo(char *);
     ADD STATIC FUNC: bar --> int bar(double );
     ADD STATIC FUNC: barchar --> void bar(char *);
     ADD STATIC FUNC: bar --> int bar(int );
     // C++ CLASS END 


     // C++ CLASS START : class Class
     ADD MEMBER     : member_data --> int  member_data; 
     ADD MEMBER FUN : member_func --> double member_func();
     ADD MEMBER FUN : pointer --> void pointer(Class *);
     ADD MEMBER FUN : retptr --> Class *retptr();
     // C++ CLASS END 


     // C++ CLASS START : class Foo3
     ADD MEMBER     : new_var --> double  var; 
     ADD STATIC VAR : new_static_var --> double  static_var; 
     ADD MEMBER FUN : add --> int sum(int ,int );
     ADD STATIC FUNC: product --> int mul(int ,int );
     ADD C++ CONST  : LAGER --> (int ) = [None]
     ADD C++ CONST  : ALE --> (int ) = [None]
     ADD C++ CONST  : STOUT --> (int ) = [None]
     ADD C++ CONST  : PILSNER --> (int ) = [None]
     ADD MEMBER FUN : foo --> int foo(double ,double );
     ADD MEMBER FUN : foochar --> void foo(char *);
     ADD STATIC FUNC: bar --> int bar(double );
     ADD STATIC FUNC: barchar --> void bar(char *);
     // C++ CLASS END 


     // C++ CLASS START : class Foo4
     ADD MEMBER     : new_var --> double  var; 
     ADD STATIC VAR : new_static_var --> double  static_var; 
     ADD MEMBER FUN : add --> int sum(int ,int );
     ADD STATIC FUNC: product --> int mul(int ,int );
     ADD C++ CONST  : LAGER --> (int ) = [None]
     ADD C++ CONST  : ALE --> (int ) = [None]
     ADD C++ CONST  : STOUT --> (int ) = [None]
     ADD C++ CONST  : PILSNER --> (int ) = [None]
     ADD MEMBER FUN : foo --> int foo(double ,double );
     ADD MEMBER FUN : foochar --> void foo(char *);
     ADD STATIC FUNC: bar --> int bar(double );
     ADD STATIC FUNC: barchar --> void bar(char *);
     // C++ CLASS END 


     // C++ CLASS START : class Bar
     ADD MEMBER     : member_data --> int  member_data; 
     ADD MEMBER FUN : member_func --> double member_func();
     ADD MEMBER FUN : pointer --> void pointer(Class *);
     ADD MEMBER FUN : retptr --> Class *retptr();
     // C++ CLASS END 


     // C++ CLASS START : class C
     ADD MEMBER FUN : new_name --> int old_name(int );
     // C++ CLASS END 

}  /* END INIT */
/*
 * These are the pointer type-equivalency mappings. 
 * (Used by the SWIG pointer type-checker).
 */
	 SWIG_RegisterMapping("_ROnly","_class_ROnly",0);
	 SWIG_RegisterMapping("_signed_long","_long",0);
	 SWIG_RegisterMapping("_double","_FooBar",0);
	 SWIG_RegisterMapping("_double","_Real",0);
	 SWIG_RegisterMapping("_class_ROnlyBase","_class_ROnly",SwigROnlyToROnlyBase);
	 SWIG_RegisterMapping("_class_ROnlyBase","_ROnly",SwigROnlyToROnlyBase);
	 SWIG_RegisterMapping("_class_ROnlyBase","_ROnlyBase",0);
	 SWIG_RegisterMapping("_class_C","_C",0);
	 SWIG_RegisterMapping("_class_Foo","_Foo",0);
	 SWIG_RegisterMapping("_Real","_FooBar",0);
	 SWIG_RegisterMapping("_Real","_double",0);
	 SWIG_RegisterMapping("_Cube","_class_Cube",0);
	 SWIG_RegisterMapping("_long","_unsigned_long",0);
	 SWIG_RegisterMapping("_long","_signed_long",0);
	 SWIG_RegisterMapping("_class_Shape","_class_Cube",SwigCubeToShape);
	 SWIG_RegisterMapping("_class_Shape","_Cube",SwigCubeToShape);
	 SWIG_RegisterMapping("_class_Shape","_class_Sphere",SwigSphereToShape);
	 SWIG_RegisterMapping("_class_Shape","_Sphere",SwigSphereToShape);
	 SWIG_RegisterMapping("_class_Shape","_class_Square",SwigSquareToShape);
	 SWIG_RegisterMapping("_class_Shape","_Square",SwigSquareToShape);
	 SWIG_RegisterMapping("_class_Shape","_class_Circle",SwigCircleToShape);
	 SWIG_RegisterMapping("_class_Shape","_Circle",SwigCircleToShape);
	 SWIG_RegisterMapping("_class_Shape","_class_ThreeD",SwigThreeDToShape);
	 SWIG_RegisterMapping("_class_Shape","_ThreeD",SwigThreeDToShape);
	 SWIG_RegisterMapping("_class_Shape","_class_TwoD",SwigTwoDToShape);
	 SWIG_RegisterMapping("_class_Shape","_TwoD",SwigTwoDToShape);
	 SWIG_RegisterMapping("_class_Shape","_Shape",0);
	 SWIG_RegisterMapping("_ENUM1","_class_ENUM1",0);
	 SWIG_RegisterMapping("_Bar","_class_Bar",0);
	 SWIG_RegisterMapping("_class_Data","_Data",0);
	 SWIG_RegisterMapping("_class_Foo2","_class_Foo4",SwigFoo4ToFoo2);
	 SWIG_RegisterMapping("_class_Foo2","_Foo4",SwigFoo4ToFoo2);
	 SWIG_RegisterMapping("_class_Foo2","_class_Foo3",SwigFoo3ToFoo2);
	 SWIG_RegisterMapping("_class_Foo2","_Foo3",SwigFoo3ToFoo2);
	 SWIG_RegisterMapping("_class_Foo2","_Foo2",0);
	 SWIG_RegisterMapping("_class_Foo3","_class_Foo4",SwigFoo4ToFoo3);
	 SWIG_RegisterMapping("_class_Foo3","_Foo4",SwigFoo4ToFoo3);
	 SWIG_RegisterMapping("_class_Foo3","_Foo3",0);
	 SWIG_RegisterMapping("_Class","_class_Bar",SwigBarToClass);
	 SWIG_RegisterMapping("_Class","_Bar",SwigBarToClass);
	 SWIG_RegisterMapping("_Class","_class_Class",0);
	 SWIG_RegisterMapping("_class_Foo4","_Foo4",0);
	 SWIG_RegisterMapping("_TwoD","_class_Square",SwigSquareToTwoD);
	 SWIG_RegisterMapping("_TwoD","_Square",SwigSquareToTwoD);
	 SWIG_RegisterMapping("_TwoD","_class_Circle",SwigCircleToTwoD);
	 SWIG_RegisterMapping("_TwoD","_Circle",SwigCircleToTwoD);
	 SWIG_RegisterMapping("_TwoD","_class_TwoD",0);
	 SWIG_RegisterMapping("_class_Bar","_Bar",0);
	 SWIG_RegisterMapping("_Func","_class_Func",0);
	 SWIG_RegisterMapping("_class_Cube","_Cube",0);
	 SWIG_RegisterMapping("_unsigned_long","_long",0);
	 SWIG_RegisterMapping("_Sphere","_class_Sphere",0);
	 SWIG_RegisterMapping("_FooBar","_double",0);
	 SWIG_RegisterMapping("_FooBar","_Real",0);
	 SWIG_RegisterMapping("_class_Func2","_Func2",0);
	 SWIG_RegisterMapping("_Square","_class_Square",0);
	 SWIG_RegisterMapping("_signed_int","_int",0);
	 SWIG_RegisterMapping("_unsigned_short","_short",0);
	 SWIG_RegisterMapping("_Shape","_class_Cube",SwigCubeToShape);
	 SWIG_RegisterMapping("_Shape","_Cube",SwigCubeToShape);
	 SWIG_RegisterMapping("_Shape","_class_Sphere",SwigSphereToShape);
	 SWIG_RegisterMapping("_Shape","_Sphere",SwigSphereToShape);
	 SWIG_RegisterMapping("_Shape","_class_Square",SwigSquareToShape);
	 SWIG_RegisterMapping("_Shape","_Square",SwigSquareToShape);
	 SWIG_RegisterMapping("_Shape","_class_Circle",SwigCircleToShape);
	 SWIG_RegisterMapping("_Shape","_Circle",SwigCircleToShape);
	 SWIG_RegisterMapping("_Shape","_class_ThreeD",SwigThreeDToShape);
	 SWIG_RegisterMapping("_Shape","_ThreeD",SwigThreeDToShape);
	 SWIG_RegisterMapping("_Shape","_class_TwoD",SwigTwoDToShape);
	 SWIG_RegisterMapping("_Shape","_TwoD",SwigTwoDToShape);
	 SWIG_RegisterMapping("_Shape","_class_Shape",0);
	 SWIG_RegisterMapping("_class_ROnly","_ROnly",0);
	 SWIG_RegisterMapping("_ThreeD","_class_Cube",SwigCubeToThreeD);
	 SWIG_RegisterMapping("_ThreeD","_Cube",SwigCubeToThreeD);
	 SWIG_RegisterMapping("_ThreeD","_class_Sphere",SwigSphereToThreeD);
	 SWIG_RegisterMapping("_ThreeD","_Sphere",SwigSphereToThreeD);
	 SWIG_RegisterMapping("_ThreeD","_class_ThreeD",0);
	 SWIG_RegisterMapping("_Circle","_class_Circle",0);
	 SWIG_RegisterMapping("_class_Sphere","_Sphere",0);
	 SWIG_RegisterMapping("_class_TwoD","_class_Square",SwigSquareToTwoD);
	 SWIG_RegisterMapping("_class_TwoD","_Square",SwigSquareToTwoD);
	 SWIG_RegisterMapping("_class_TwoD","_class_Circle",SwigCircleToTwoD);
	 SWIG_RegisterMapping("_class_TwoD","_Circle",SwigCircleToTwoD);
	 SWIG_RegisterMapping("_class_TwoD","_TwoD",0);
	 SWIG_RegisterMapping("_signed_short","_short",0);
	 SWIG_RegisterMapping("_class_Square","_Square",0);
	 SWIG_RegisterMapping("_ENUM","_class_ENUM1",SwigENUM1ToENUM);
	 SWIG_RegisterMapping("_ENUM","_ENUM1",SwigENUM1ToENUM);
	 SWIG_RegisterMapping("_ENUM","_class_ENUM",0);
	 SWIG_RegisterMapping("_unsigned_int","_int",0);
	 SWIG_RegisterMapping("_class_Func","_Func",0);
	 SWIG_RegisterMapping("_short","_unsigned_short",0);
	 SWIG_RegisterMapping("_short","_signed_short",0);
	 SWIG_RegisterMapping("_class_ThreeD","_class_Cube",SwigCubeToThreeD);
	 SWIG_RegisterMapping("_class_ThreeD","_Cube",SwigCubeToThreeD);
	 SWIG_RegisterMapping("_class_ThreeD","_class_Sphere",SwigSphereToThreeD);
	 SWIG_RegisterMapping("_class_ThreeD","_Sphere",SwigSphereToThreeD);
	 SWIG_RegisterMapping("_class_ThreeD","_ThreeD",0);
	 SWIG_RegisterMapping("_class_Circle","_Circle",0);
	 SWIG_RegisterMapping("_class_ENUM1","_ENUM1",0);
	 SWIG_RegisterMapping("_int","_unsigned_int",0);
	 SWIG_RegisterMapping("_int","_signed_int",0);
	 SWIG_RegisterMapping("_C","_class_C",0);
	 SWIG_RegisterMapping("_class_Class","_class_Bar",SwigBarToClass);
	 SWIG_RegisterMapping("_class_Class","_Bar",SwigBarToClass);
	 SWIG_RegisterMapping("_class_Class","_Class",0);
	 SWIG_RegisterMapping("_ROnlyBase","_class_ROnly",SwigROnlyToROnlyBase);
	 SWIG_RegisterMapping("_ROnlyBase","_ROnly",SwigROnlyToROnlyBase);
	 SWIG_RegisterMapping("_ROnlyBase","_class_ROnlyBase",0);
	 SWIG_RegisterMapping("_Func2","_class_Func2",0);
	 SWIG_RegisterMapping("_class_ENUM","_class_ENUM1",SwigENUM1ToENUM);
	 SWIG_RegisterMapping("_class_ENUM","_ENUM1",SwigENUM1ToENUM);
	 SWIG_RegisterMapping("_class_ENUM","_ENUM",0);
	 SWIG_RegisterMapping("_Foo","_class_Foo",0);
	 SWIG_RegisterMapping("_Data","_class_Data",0);
	 SWIG_RegisterMapping("_Foo2","_class_Foo4",SwigFoo4ToFoo2);
	 SWIG_RegisterMapping("_Foo2","_Foo4",SwigFoo4ToFoo2);
	 SWIG_RegisterMapping("_Foo2","_class_Foo3",SwigFoo3ToFoo2);
	 SWIG_RegisterMapping("_Foo2","_Foo3",SwigFoo3ToFoo2);
	 SWIG_RegisterMapping("_Foo2","_class_Foo2",0);
	 SWIG_RegisterMapping("_Foo3","_class_Foo4",SwigFoo4ToFoo3);
	 SWIG_RegisterMapping("_Foo3","_Foo4",SwigFoo4ToFoo3);
	 SWIG_RegisterMapping("_Foo3","_class_Foo3",0);
	 SWIG_RegisterMapping("_Foo4","_class_Foo4",0);
