Gecko [ 122.154.134.11 ]

Name	Size	Permission
allegrocl	[ DIR ]	drwxr-xr-x
cffi	[ DIR ]	drwxr-xr-x
chicken	[ DIR ]	drwxr-xr-x
clisp	[ DIR ]	drwxr-xr-x
csharp	[ DIR ]	drwxr-xr-x
gcj	[ DIR ]	drwxr-xr-x
guile	[ DIR ]	drwxr-xr-x
java	[ DIR ]	drwxr-xr-x
lua	[ DIR ]	drwxr-xr-x
modula3	[ DIR ]	drwxr-xr-x
mzscheme	[ DIR ]	drwxr-xr-x
ocaml	[ DIR ]	drwxr-xr-x
octave	[ DIR ]	drwxr-xr-x
perl5	[ DIR ]	drwxr-xr-x
php	[ DIR ]	drwxr-xr-x
pike	[ DIR ]	drwxr-xr-x
python	[ DIR ]	drwxr-xr-x
r	[ DIR ]	drwxr-xr-x
ruby	[ DIR ]	drwxr-xr-x
std	[ DIR ]	drwxr-xr-x
tcl	[ DIR ]	drwxr-xr-x
typemaps	[ DIR ]	drwxr-xr-x
uffi	[ DIR ]	drwxr-xr-x
allkw.swg	684 B	-rw-r--r--
attribute.i	655 B	-rw-r--r--
carrays.i	2.74 KB	-rw-r--r--
cdata.i	2.21 KB	-rw-r--r--
cmalloc.i	2.46 KB	-rw-r--r--
constraints.i	7.04 KB	-rw-r--r--
cpointer.i	3.63 KB	-rw-r--r--
cstring.i	486 B	-rw-r--r--
cwstring.i	427 B	-rw-r--r--
exception.i	7.21 KB	-rw-r--r--
intrusive_ptr.i	3.81 KB	-rw-r--r--
inttypes.i	2.73 KB	-rw-r--r--
math.i	2.2 KB	-rw-r--r--
pointer.i	456 B	-rw-r--r--
runtime.swg	1.21 KB	-rw-r--r--
shared_ptr.i	2.05 KB	-rw-r--r--
std_except.i	2.09 KB	-rw-r--r--
stdint.i	2.47 KB	-rw-r--r--
stl.i	411 B	-rw-r--r--
swig.swg	23.42 KB	-rw-r--r--
swigarch.i	1.7 KB	-rw-r--r--
swigerrors.swg	509 B	-rw-r--r--
swiginit.swg	7.91 KB	-rw-r--r--
swiglabels.swg	3.11 KB	-rw-r--r--
swigrun.i	418 B	-rw-r--r--
swigrun.swg	16.71 KB	-rw-r--r--
swigwarn.swg	11.75 KB	-rw-r--r--
swigwarnings.swg	6.83 KB	-rw-r--r--
wchar.i	471 B	-rw-r--r--
windows.i	4.2 KB	-rw-r--r--

Code Editor : constraints.i

/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * constraints.i
 *
 * SWIG constraints library.
 *
 * SWIG library file containing typemaps for implementing various kinds of 
 * constraints.  Depends upon the SWIG exception library for generating
 * errors in a language-independent manner.
 * ----------------------------------------------------------------------------- */

#ifdef AUTODOC
%text %{
%include <constraints.i>

This library provides support for applying constraints to function
arguments.  Using a constraint, you can restrict arguments to be
positive numbers, non-NULL pointers, and so on.   The following
constraints are available :

Number  POSITIVE        - Positive number (not zero)
      Number  NEGATIVE        - Negative number (not zero)
      Number  NONZERO         - Nonzero number
      Number  NONNEGATIVE     - Positive number (including zero)
      Number  NONPOSITIVE     - Negative number (including zero)
      Pointer NONNULL         - Non-NULL pointer
      Pointer ALIGN8          - 8-byte aligned pointer
      Pointer ALIGN4          - 4-byte aligned pointer
      Pointer ALIGN2          - 2-byte aligned pointer

To use the constraints, you need to "apply" them to specific
function arguments in your code.  This is done using the %apply
directive.   For example :

%apply Number NONNEGATIVE { double nonneg };
  double sqrt(double nonneg);         // Name of argument must match
  
  %apply Pointer NONNULL { void *ptr };
  void *malloc(int POSITIVE);       // May return a NULL pointer
  void free(void *ptr);             // May not accept a NULL pointer

Any function argument of the type you specify with the %apply directive
will be checked with the appropriate constraint.   Multiple types may
be specified as follows :

%apply Pointer NONNULL { void *, Vector *, List *, double *};

In this case, all of the types listed would be checked for non-NULL 
pointers.

The common datatypes of int, short, long, unsigned int, unsigned long,
unsigned short, unsigned char, signed char, float, and double can be
checked without using the %apply directive by simply using the 
constraint name as the parameter name. For example :

double sqrt(double NONNEGATIVE);
  double log(double POSITIVE);

If you have used typedef to change type-names, you can also do this :

%apply double { Real };       // Make everything defined for doubles
                                // work for Reals.
  Real sqrt(Real NONNEGATIVE);
  Real log(Real POSITIVE);

%}
#endif

%include <exception.i>

#ifdef SWIGCSHARP
// Required attribute for C# exception handling
#define SWIGCSHARPCANTHROW , canthrow=1
#else
#define SWIGCSHARPCANTHROW
#endif

// Positive numbers

%typemap(check SWIGCSHARPCANTHROW) 
                int               POSITIVE,
                short             POSITIVE,
                long              POSITIVE,
                unsigned int      POSITIVE,
                unsigned short    POSITIVE,
                unsigned long     POSITIVE,
                signed char       POSITIVE,
                unsigned char     POSITIVE,
                float             POSITIVE,
                double            POSITIVE,
                Number            POSITIVE
{
  if ($1 <= 0) {
    SWIG_exception(SWIG_ValueError,"Expected a positive value.");
  }
}

// Negative numbers

%typemap(check SWIGCSHARPCANTHROW) 
                int               NEGATIVE,
                short             NEGATIVE,
                long              NEGATIVE,
                unsigned int      NEGATIVE,
                unsigned short    NEGATIVE,
                unsigned long     NEGATIVE,
                signed char       NEGATIVE,
                unsigned char     NEGATIVE,
                float             NEGATIVE,
                double            NEGATIVE,
                Number            NEGATIVE
{
  if ($1 >= 0) {
    SWIG_exception(SWIG_ValueError,"Expected a negative value.");
  }
}

// Nonzero numbers

%typemap(check SWIGCSHARPCANTHROW) 
                int               NONZERO,
                short             NONZERO,
                long              NONZERO,
                unsigned int      NONZERO,
                unsigned short    NONZERO,
                unsigned long     NONZERO,
                signed char       NONZERO,
                unsigned char     NONZERO,
                float             NONZERO,
                double            NONZERO,
                Number            NONZERO
{
  if ($1 == 0) {
    SWIG_exception(SWIG_ValueError,"Expected a nonzero value.");
  }
}

// Nonnegative numbers

%typemap(check SWIGCSHARPCANTHROW) 
                int               NONNEGATIVE,
                short             NONNEGATIVE,
                long              NONNEGATIVE,
                unsigned int      NONNEGATIVE,
                unsigned short    NONNEGATIVE,
                unsigned long     NONNEGATIVE,
                signed char       NONNEGATIVE,
                unsigned char     NONNEGATIVE,
                float             NONNEGATIVE,
                double            NONNEGATIVE,
                Number            NONNEGATIVE
{
  if ($1 < 0) {
    SWIG_exception(SWIG_ValueError,"Expected a non-negative value.");
  }
}

// Nonpositive numbers

%typemap(check SWIGCSHARPCANTHROW) 
                int               NONPOSITIVE,
                short             NONPOSITIVE,
                long              NONPOSITIVE,
                unsigned int      NONPOSITIVE,
                unsigned short    NONPOSITIVE,
                unsigned long     NONPOSITIVE,
                signed char       NONPOSITIVE,
                unsigned char     NONPOSITIVE,
                float             NONPOSITIVE,
                double            NONPOSITIVE,
                Number            NONPOSITIVE
{
  if ($1 > 0) {
    SWIG_exception(SWIG_ValueError,"Expected a non-positive value.");
  }
}
                
// Non-NULL pointer

%typemap(check SWIGCSHARPCANTHROW) 
                void *            NONNULL,
                Pointer           NONNULL
{
  if (!$1) {
    SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
  }
}

// Aligned pointers

%typemap(check SWIGCSHARPCANTHROW) 
                void *            ALIGN8,
                Pointer           ALIGN8
{
   unsigned long long tmp;
   tmp = (unsigned long long) $1;
   if (tmp & 7) {
     SWIG_exception(SWIG_ValueError,"Pointer must be 8-byte aligned.");
   }
}

%typemap(check SWIGCSHARPCANTHROW) 
                void *            ALIGN4,
                Pointer           ALIGN4
{
   unsigned long long tmp;
   tmp = (unsigned long long) $1;
   if (tmp & 3) {
     SWIG_exception(SWIG_ValueError,"Pointer must be 4-byte aligned.");
   }
}

%typemap(check SWIGCSHARPCANTHROW) 
                void *            ALIGN2,
                Pointer           ALIGN2
{
   unsigned long long tmp;
   tmp = (unsigned long long) $1;
   if (tmp & 1) {
     SWIG_exception(SWIG_ValueError,"Pointer must be 2-byte aligned.");
   }
}

${this.title}

Code Editor : constraints.i