--- /dev/null
+//
+// SWIG pointer conversion and utility library
+//
+// Dave Beazley
+// April 19, 1997
+//
+// Perl5 specific implementation. This file is included
+// by the file ../pointer.i
+
+%{
+
+#ifdef WIN32
+#undef isspace
+#define isspace(c) (c == ' ')
+#endif
+
+/*------------------------------------------------------------------
+ ptrcast(value,type)
+
+ Constructs a new pointer value. Value may either be a string
+ or an integer. Type is a string corresponding to either the
+ C datatype or mangled datatype.
+
+ ptrcast(0,"Vector *")
+ or
+ ptrcast(0,"Vector_p")
+ ------------------------------------------------------------------ */
+#ifdef PERL_OBJECT
+static SV *_ptrcast(CPerlObj *pPerl, SV *_PTRVALUE, char *type) {
+#define ptrcast(a,b) _ptrcast(pPerl,a,b)
+#else
+static SV *_ptrcast(SV *_PTRVALUE, char *type) {
+#define ptrcast(a,b) _ptrcast(a,b)
+#endif
+ char *r,*s;
+ void *ptr;
+ SV *obj;
+ char *typestr,*c;
+
+ /* Produce a "mangled" version of the type string. */
+
+ typestr = (char *) malloc(strlen(type)+20);
+
+ /* Go through and munge the typestring */
+
+ r = typestr;
+ c = type;
+ while (*c) {
+ if (!isspace(*c)) {
+ if ((*c == '*') || (*c == '&')) {
+ strcpy(r,"Ptr");
+ r+=3;
+ } else *(r++) = *c;
+ }
+ c++;
+ }
+ *(r++) = 0;
+
+ /* Check to see if the input value is an integer */
+ if (SvIOK(_PTRVALUE)) {
+ ptr = (void *) SvIV(_PTRVALUE);
+ /* Received a numerical value. Make a pointer out of it */
+ obj = sv_newmortal();
+ sv_setref_pv(obj,typestr,ptr);
+ } else if (sv_isobject(_PTRVALUE)) {
+ /* Have a real pointer value now. Try to strip out the pointer value */
+ /* Now extract the pointer value */
+ if (!SWIG_GetPtr(_PTRVALUE,&ptr,0)) {
+ obj = sv_newmortal();
+ sv_setref_pv(obj,typestr,ptr);
+ }
+ } else {
+ croak("ptrcast(). Not a reference.");
+ }
+ free(typestr);
+ return obj;
+}
+
+
+
+/*------------------------------------------------------------------
+ ptrvalue(ptr,type = 0)
+
+ Attempts to dereference a pointer value. If type is given, it
+ will try to use that type. Otherwise, this function will attempt
+ to "guess" the proper datatype by checking against all of the
+ builtin C datatypes.
+ ------------------------------------------------------------------ */
+
+#ifdef PERL_OBJECT
+static SV *_ptrvalue(CPerlObj *pPerl,SV *_PTRVALUE, int index, char *type) {
+#define ptrvalue(a,b,c) _ptrvalue(pPerl,a,b,c)
+#else
+static SV *_ptrvalue(SV *_PTRVALUE, int index, char *type) {
+#define ptrvalue(a,b,c) _ptrvalue(a,b,c)
+#endif
+
+ void *ptr;
+ SV *obj = 0;
+
+
+ if (SWIG_GetPtr(_PTRVALUE,&ptr,0)) {
+ croak("Type error it ptrvalue. Argument is not a valid pointer value.");
+ } else {
+ /* If no datatype was passed, try a few common datatypes first */
+ if (!type) {
+
+ /* No datatype was passed. Type to figure out if it's a common one */
+
+ if (!SWIG_GetPtr(_PTRVALUE,&ptr,"intPtr")) {
+ type = "int";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"doublePtr")) {
+ type = "double";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"shortPtr")) {
+ type = "short";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"longPtr")) {
+ type = "long";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"floatPtr")) {
+ type = "float";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"charPtr")) {
+ type = "char";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"charPtrPtr")) {
+ type = "char *";
+ } else {
+ type = "unknown";
+ }
+ }
+
+ if (!ptr) {
+ croak("Unable to dereference NULL pointer.");
+ return 0;
+ }
+
+ /* Now we have a datatype. Try to figure out what to do about it */
+ if (strcmp(type,"int") == 0) {
+ obj = sv_newmortal();
+ sv_setiv(obj,(IV) *(((int *) ptr) + index));
+ } else if (strcmp(type,"double") == 0) {
+ obj = sv_newmortal();
+ sv_setnv(obj,(double) *(((double *) ptr)+index));
+ } else if (strcmp(type,"short") == 0) {
+ obj = sv_newmortal();
+ sv_setiv(obj,(IV) *(((short *) ptr) + index));
+ } else if (strcmp(type,"long") == 0) {
+ obj = sv_newmortal();
+ sv_setiv(obj,(IV) *(((long *) ptr) + index));
+ } else if (strcmp(type,"float") == 0) {
+ obj = sv_newmortal();
+ sv_setnv(obj,(double) *(((float *) ptr)+index));
+ } else if (strcmp(type,"char") == 0) {
+ obj = sv_newmortal();
+ sv_setpv(obj,((char *) ptr)+index);
+ } else if (strcmp(type,"char *") == 0) {
+ char *c = *(((char **) ptr)+index);
+ obj = sv_newmortal();
+ if (c)
+ sv_setpv(obj,c);
+ else
+ sv_setpv(obj,"NULL");
+ } else {
+ croak("Unable to dereference unsupported datatype.");
+ obj = 0;
+ }
+ }
+ return obj;
+}
+
+/*------------------------------------------------------------------
+ ptrcreate(type,value = 0,numelements = 1)
+
+ Attempts to create a new object of given type. Type must be
+ a basic C datatype. Will not create complex objects.
+ ------------------------------------------------------------------ */
+#ifdef PERL_OBJECT
+static SV *_ptrcreate(CPerlObj *pPerl, char *type, SV *value, int numelements) {
+#define ptrcreate(a,b,c) _ptrcreate(pPerl,a,b,c)
+#else
+static SV *_ptrcreate(char *type, SV *value, int numelements) {
+#define ptrcreate(a,b,c) _ptrcreate(a,b,c)
+#endif
+
+ void *ptr;
+ SV *obj;
+ int sz;
+ char *cast;
+ char temp[40];
+
+ /* Check the type string against a variety of possibilities */
+
+ if (strcmp(type,"int") == 0) {
+ sz = sizeof(int)*numelements;
+ cast = "intPtr";
+ } else if (strcmp(type,"short") == 0) {
+ sz = sizeof(short)*numelements;
+ cast = "shortPtr";
+ } else if (strcmp(type,"long") == 0) {
+ sz = sizeof(long)*numelements;
+ cast = "longPtr";
+ } else if (strcmp(type,"double") == 0) {
+ sz = sizeof(double)*numelements;
+ cast = "doublePtr";
+ } else if (strcmp(type,"float") == 0) {
+ sz = sizeof(float)*numelements;
+ cast = "floatPtr";
+ } else if (strcmp(type,"char") == 0) {
+ sz = sizeof(char)*numelements;
+ cast = "charPtr";
+ } else if (strcmp(type,"char *") == 0) {
+ sz = sizeof(char *)*(numelements+1);
+ cast = "charPtrPtr";
+ } else if (strcmp(type,"void") == 0) {
+ sz = numelements;
+ cast = "voidPtr";
+ } else {
+ croak("Unable to create unknown datatype.");
+ return 0;
+ }
+
+ /* Create the new object */
+
+ ptr = (void *) malloc(sz);
+ if (!ptr) {
+ croak("Out of memory in ptrcreate.");
+ return 0;
+ }
+
+ /* Now try to set its default value */
+
+ if (value) {
+ if (strcmp(type,"int") == 0) {
+ int *ip,i,ivalue;
+ ivalue = (int) SvIV(value);
+ ip = (int *) ptr;
+ for (i = 0; i < numelements; i++)
+ ip[i] = ivalue;
+ } else if (strcmp(type,"short") == 0) {
+ short *ip,ivalue;
+ int i;
+ ivalue = (short) SvIV(value);
+ ip = (short *) ptr;
+ for (i = 0; i < numelements; i++)
+ ip[i] = ivalue;
+ } else if (strcmp(type,"long") == 0) {
+ long *ip,ivalue;
+ int i;
+ ivalue = (long) SvIV(value);
+ ip = (long *) ptr;
+ for (i = 0; i < numelements; i++)
+ ip[i] = ivalue;
+ } else if (strcmp(type,"double") == 0) {
+ double *ip,ivalue;
+ int i;
+ ivalue = (double) SvNV(value);
+ ip = (double *) ptr;
+ for (i = 0; i < numelements; i++)
+ ip[i] = ivalue;
+ } else if (strcmp(type,"float") == 0) {
+ float *ip,ivalue;
+ int i;
+ ivalue = (float) SvNV(value);
+ ip = (float *) ptr;
+ for (i = 0; i < numelements; i++)
+ ip[i] = ivalue;
+ } else if (strcmp(type,"char") == 0) {
+ char *ip,*ivalue;
+ ivalue = (char *) SvPV(value,PL_na);
+ ip = (char *) ptr;
+ strncpy(ip,ivalue,numelements-1);
+ } else if (strcmp(type,"char *") == 0) {
+ char **ip, *ivalue;
+ int i;
+ ivalue = (char *) SvPV(value,PL_na);
+ ip = (char **) ptr;
+ for (i = 0; i < numelements; i++) {
+ if (ivalue) {
+ ip[i] = (char *) malloc(strlen(ivalue)+1);
+ strcpy(ip[i],ivalue);
+ } else {
+ ip[i] = 0;
+ }
+ }
+ ip[numelements] = 0;
+ }
+ }
+ /* Create the pointer value */
+
+ SWIG_MakePtr(temp,ptr,cast);
+ obj = sv_newmortal();
+ sv_setref_pv(obj,cast,ptr);
+ return obj;
+}
+
+/*------------------------------------------------------------------
+ ptrset(ptr,value,index = 0,type = 0)
+
+ Attempts to set the value of a pointer variable. If type is
+ given, we will use that type. Otherwise, we'll guess the datatype.
+ ------------------------------------------------------------------ */
+
+#ifdef PERL_OBJECT
+static void _ptrset(CPerlObj *pPerl,SV *_PTRVALUE, SV *value, int index, char *type) {
+#define ptrset(a,b,c,d) _ptrset(pPerl,a,b,c,d)
+#else
+static void _ptrset(SV *_PTRVALUE, SV *value, int index, char *type) {
+#define ptrset(a,b,c,d) _ptrset(a,b,c,d)
+#endif
+ void *ptr;
+ SV *obj;
+
+ if (SWIG_GetPtr(_PTRVALUE,&ptr,0)) {
+ croak("Type error in ptrset. Argument is not a valid pointer value.");
+ return;
+ }
+
+ /* If no datatype was passed, try a few common datatypes first */
+
+ if (!type) {
+
+ /* No datatype was passed. Type to figure out if it's a common one */
+
+ if (!SWIG_GetPtr(_PTRVALUE,&ptr,"intPtr")) {
+ type = "int";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"doublePtr")) {
+ type = "double";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"shortPtr")) {
+ type = "short";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"longPtr")) {
+ type = "long";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"floatPtr")) {
+ type = "float";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"charPtr")) {
+ type = "char";
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"charPtrPtr")) {
+ type = "char *";
+ } else {
+ type = "unknown";
+ }
+ }
+
+ if (!ptr) {
+ croak("Unable to set NULL pointer.");
+ return;
+ }
+
+ /* Now we have a datatype. Try to figure out what to do about it */
+ if (strcmp(type,"int") == 0) {
+ *(((int *) ptr)+index) = (int) SvIV(value);
+ } else if (strcmp(type,"double") == 0) {
+ *(((double *) ptr)+index) = (double) SvNV(value);
+ } else if (strcmp(type,"short") == 0) {
+ *(((short *) ptr)+index) = (short) SvIV(value);
+ } else if (strcmp(type,"long") == 0) {
+ *(((long *) ptr)+index) = (long) SvIV(value);
+ } else if (strcmp(type,"float") == 0) {
+ *(((float *) ptr)+index) = (float) SvNV(value);
+ } else if (strcmp(type,"char") == 0) {
+ char *c = SvPV(value,PL_na);
+ strcpy(((char *) ptr)+index, c);
+ } else if (strcmp(type,"char *") == 0) {
+ char *c = SvPV(value,PL_na);
+ char **ca = (char **) ptr;
+ if (ca[index]) free(ca[index]);
+ if (strcmp(c,"NULL") == 0) {
+ ca[index] = 0;
+ } else {
+ ca[index] = (char *) malloc(strlen(c)+1);
+ strcpy(ca[index],c);
+ }
+ } else {
+ croak("Unable to set unsupported datatype.");
+ return;
+ }
+}
+
+/*------------------------------------------------------------------
+ ptradd(ptr,offset)
+
+ Adds a value to an existing pointer value. Will do a type-dependent
+ add for basic datatypes. For other datatypes, will do a byte-add.
+ ------------------------------------------------------------------ */
+
+#ifdef PERL_OBJECT
+static SV *_ptradd(CPerlObj *pPerl, SV *_PTRVALUE, int offset) {
+#define ptradd(a,b) _ptradd(pPerl,a,b)
+#else
+static SV *_ptradd(SV *_PTRVALUE, int offset) {
+#define ptradd(a,b) _ptradd(a,b)
+#endif
+
+ void *ptr,*junk;
+ SV *obj;
+ char *type;
+
+ /* Try to handle a few common datatypes first */
+
+ if (!SWIG_GetPtr(_PTRVALUE,&ptr,"intPtr")) {
+ ptr = (void *) (((int *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"doublePtr")) {
+ ptr = (void *) (((double *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"shortPtr")) {
+ ptr = (void *) (((short *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"longPtr")) {
+ ptr = (void *) (((long *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"floatPtr")) {
+ ptr = (void *) (((float *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,"charPtr")) {
+ ptr = (void *) (((char *) ptr) + offset);
+ } else if (!SWIG_GetPtr(_PTRVALUE,&ptr,0)) {
+ ptr = (void *) (((char *) ptr) + offset);
+ } else {
+ croak("Type error in ptradd. Argument is not a valid pointer value.");
+ return 0;
+ }
+ type = SWIG_GetPtr(_PTRVALUE,&junk,"INVALID POINTER");
+ obj = sv_newmortal();
+ sv_setref_pv(obj,type,ptr);
+ return obj;
+}
+
+/*------------------------------------------------------------------
+ ptrmap(type1,type2)
+
+ Allows a mapping between type1 and type2. (Like a typedef)
+ ------------------------------------------------------------------ */
+
+#ifdef PERL_OBJECT
+static void _ptrmap(CPerlObj *pPerl,char *type1, char *type2) {
+#define ptrmap(a,b) _ptrmap(pPerl,a,b)
+#else
+static void _ptrmap(char *type1, char *type2) {
+#define ptrmap(a,b) _ptrmap(a,b)
+#endif
+ char *typestr1,*typestr2,*c,*r;
+ /* Produce a "mangled" version of the type string. */
+
+ typestr1 = (char *) malloc(strlen(type1)+20);
+
+
+ /* Go through and munge the typestring */
+
+ r = typestr1;
+ *(r++) = '_';
+ c = type1;
+
+ while (*c) {
+ if (!isspace(*c)) {
+ if ((*c == '*') || (*c == '&')) {
+ strcpy(r,"Ptr");
+ r+=3;
+ }
+ else *(r++) = *c;
+ }
+ c++;
+ }
+ *(r++) = 0;
+
+ typestr2 = (char *) malloc(strlen(type2)+20);
+
+ /* Go through and munge the typestring */
+
+ r = typestr2;
+ *(r++) = '_';
+ c = type2;
+ while (*c) {
+ if (!isspace(*c)) {
+ if ((*c == '*') || (*c == '&')) {
+ strcpy(r,"Ptr");
+ r+=3;
+ }
+ else *(r++) = *c;
+ }
+ c++;
+ }
+ *(r++) = 0;
+ SWIG_RegisterMapping(typestr1,typestr2,0);
+ SWIG_RegisterMapping(typestr2,typestr1,0);
+}
+
+/*------------------------------------------------------------------
+ ptrfree(ptr)
+
+ Destroys a pointer value
+ ------------------------------------------------------------------ */
+#ifdef PERL_OBJECT
+void _ptrfree(CPerlObj *pPerl, SV *_PTRVALUE) {
+#define ptrfree(a) _ptrfree(pPerl, a)
+#else
+void _ptrfree(SV *_PTRVALUE) {
+#define ptrfree(a) _ptrfree(a)
+#endif
+
+ void *ptr, *junk;
+
+ if (SWIG_GetPtr(_PTRVALUE,&ptr,0)) {
+ croak("Type error in ptrfree. Argument is not a valid pointer value.");
+ return;
+ }
+
+ /* Check to see if this pointer is a char ** */
+ if (!SWIG_GetPtr(_PTRVALUE,&junk,"charPtrPtr")) {
+ char **c = (char **) ptr;
+ if (c) {
+ int i = 0;
+ while (c[i]) {
+ free(c[i]);
+ i++;
+ }
+ }
+ }
+ if (ptr)
+ free((char *) ptr);
+}
+
+%}
+
+%typemap(perl5,in) SV *ptr, SV *value {
+ $target = $source;
+}
+
+
+%typemap(perl5,out) SV *ptrcast,
+ SV *ptrvalue,
+ SV *ptrcreate,
+ SV *ptradd
+{
+ $target = $source;
+ argvi++;
+}
+
+%typemap(perl5,ret) int ptrset {
+ if ($source == -1) return NULL;
+}
+
+SV *ptrcast(SV *ptr, char *type);
+// Casts a pointer ptr to a new datatype given by the string type.
+// type may be either the SWIG generated representation of a datatype
+// or the C representation. For example :
+//
+// ptrcast($ptr,"doublePtr"); # Perl5 representation
+// ptrcast($ptr,"double *"); # C representation
+//
+// A new pointer value is returned. ptr may also be an integer
+// value in which case the value will be used to set the pointer
+// value. For example :
+//
+// $a = ptrcast(0,"VectorPtr");
+//
+// Will create a NULL pointer of type "VectorPtr"
+//
+// The casting operation is sensitive to formatting. As a result,
+// "double *" is different than "double*". As a result of thumb,
+// there should always be exactly one space between the C datatype
+// and any pointer specifiers (*).
+
+SV *ptrvalue(SV *ptr, int index = 0, char *type = 0);
+// Returns the value that a pointer is pointing to (ie. dereferencing).
+// The type is automatically inferred by the pointer type--thus, an
+// integer pointer will return an integer, a double will return a double,
+// and so on. The index and type fields are optional parameters. When
+// an index is specified, this function returns the value of ptr[index].
+// This allows array access. When a type is specified, it overrides
+// the given pointer type. Examples :
+//
+// ptrvalue($a) # Returns the value *a
+// ptrvalue($a,10) # Returns the value a[10]
+// ptrvalue($a,10,"double") # Returns a[10] assuming a is a double *
+
+
+void ptrset(SV *ptr, SV *value, int index = 0, char *type = 0);
+// Sets the value pointed to by a pointer. The type is automatically
+// inferred from the pointer type so this function will work for
+// integers, floats, doubles, etc... The index and type fields are
+// optional. When an index is given, it provides array access. When
+// type is specified, it overrides the given pointer type. Examples :
+//
+// ptrset($a,3) # Sets the value *a = 3
+// ptrset($a,3,10) # Sets a[10] = 3
+// ptrset($a,3,10,"int") # Sets a[10] = 3 assuming a is a int *
+
+
+SV *ptrcreate(char *type, SV *value = 0, int nitems = 1);
+// Creates a new object and returns a pointer to it. This function
+// can be used to create various kinds of objects for use in C functions.
+// type specifies the basic C datatype to create and value is an
+// optional parameter that can be used to set the initial value of the
+// object. nitems is an optional parameter that can be used to create
+// an array. This function results in a memory allocation using
+// malloc(). Examples :
+//
+// $a = ptrcreate("double") # Create a new double, return pointer
+// $a = ptrcreate("int",7) # Create an integer, set value to 7
+// $a = ptrcreate("int",0,1000) # Create an integer array with initial
+// # values all set to zero
+//
+// This function only recognizes a few common C datatypes as listed below :
+//
+// int, short, long, float, double, char, char *, void
+//
+// All other datatypes will result in an error. However, other
+// datatypes can be created by using the ptrcast function. For
+// example:
+//
+// $a = ptrcast(ptrcreate("int",0,100),"unsigned int *")
+
+
+void ptrfree(SV *ptr);
+// Destroys the memory pointed to by ptr. This function calls free()
+// and should only be used with objects created by ptrcreate(). Since
+// this function calls free, it may work with other objects, but this
+// is generally discouraged unless you absolutely know what you're
+// doing.
+
+SV *ptradd(SV *ptr, int offset);
+// Adds a value to the current pointer value. For the C datatypes of
+// int, short, long, float, double, and char, the offset value is the
+// number of objects and works in exactly the same manner as in C. For
+// example, the following code steps through the elements of an array
+//
+// $a = ptrcreate("double",0,100); # Create an array double a[100]
+// $b = $a;
+// for ($i = 0; $i < 100; $i++) {
+// ptrset($b,0.0025*$i); # set *b = 0.0025*i
+// $b = ptradd($b,1); # b++ (go to next double)
+// }
+//
+// In this case, adding one to b goes to the next double.
+//
+// For all other datatypes (including all complex datatypes), the
+// offset corresponds to bytes. This function does not perform any
+// bounds checking and negative offsets are perfectly legal.
+
+void ptrmap(char *type1, char *type2);
+// This is a rarely used function that performs essentially the same
+// operation as a C typedef. To manage datatypes at run-time, SWIG
+// modules manage an internal symbol table of type mappings. This
+// table keeps track of which types are equivalent to each other. The
+// ptrmap() function provides a mechanism for scripts to add symbols
+// to this table. For example :
+//
+// ptrmap("doublePtr","RealPtr");
+//
+// would make the types "doublePtr" and "RealPtr" equivalent to each
+// other. Pointers of either type could now be used interchangably.
+//
+// Normally this function is not needed, but it can be used to
+// circumvent SWIG's normal type-checking behavior or to work around
+// weird type-handling problems.
+
+
+
projects / wxWidgets.git / blobdiff