X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/eb6a4098a0f2e9ae55e72ad960b3dfc134d177c9..d14a1e28567de23c586bc80017073d0c39f8d18f:/wxPython/wxSWIG/swig_lib/perl5/ptrlang.i?ds=inline

diff --git a/wxPython/wxSWIG/swig_lib/perl5/ptrlang.i b/wxPython/wxSWIG/swig_lib/perl5/ptrlang.i
deleted file mode 100644
index a1bc88e8db..0000000000
--- a/wxPython/wxSWIG/swig_lib/perl5/ptrlang.i
+++ /dev/null
@@ -1,650 +0,0 @@
-//
-// 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.
-
-
-