PageRenderTime 20ms CodeModel.GetById 13ms app.highlight 3ms RepoModel.GetById 1ms app.codeStats 0ms

/trunk/Lib/constraints.i

#
Swig | 224 lines | 180 code | 35 blank | 9 comment | 0 complexity | d8ac7106c0efc9b55bf9d9c87ee4f261 MD5 | raw file
  1/* -----------------------------------------------------------------------------
  2 * constraints.i
  3 *
  4 * SWIG constraints library.
  5 *
  6 * SWIG library file containing typemaps for implementing various kinds of 
  7 * constraints.  Depends upon the SWIG exception library for generating
  8 * errors in a language-independent manner.
  9 * ----------------------------------------------------------------------------- */
 10
 11#ifdef AUTODOC
 12%text %{
 13%include <constraints.i>
 14
 15This library provides support for applying constraints to function
 16arguments.  Using a constraint, you can restrict arguments to be
 17positive numbers, non-NULL pointers, and so on.   The following
 18constraints are available :
 19
 20      Number  POSITIVE        - Positive number (not zero)
 21      Number  NEGATIVE        - Negative number (not zero)
 22      Number  NONZERO         - Nonzero number
 23      Number  NONNEGATIVE     - Positive number (including zero)
 24      Number  NONPOSITIVE     - Negative number (including zero)
 25      Pointer NONNULL         - Non-NULL pointer
 26      Pointer ALIGN8          - 8-byte aligned pointer
 27      Pointer ALIGN4          - 4-byte aligned pointer
 28      Pointer ALIGN2          - 2-byte aligned pointer
 29
 30To use the constraints, you need to "apply" them to specific
 31function arguments in your code.  This is done using the %apply
 32directive.   For example :
 33
 34  %apply Number NONNEGATIVE { double nonneg };
 35  double sqrt(double nonneg);         // Name of argument must match
 36  
 37  %apply Pointer NONNULL { void *ptr };
 38  void *malloc(int POSITIVE);       // May return a NULL pointer
 39  void free(void *ptr);             // May not accept a NULL pointer
 40
 41Any function argument of the type you specify with the %apply directive
 42will be checked with the appropriate constraint.   Multiple types may
 43be specified as follows :
 44
 45  %apply Pointer NONNULL { void *, Vector *, List *, double *};
 46
 47In this case, all of the types listed would be checked for non-NULL 
 48pointers.
 49
 50The common datatypes of int, short, long, unsigned int, unsigned long,
 51unsigned short, unsigned char, signed char, float, and double can be
 52checked without using the %apply directive by simply using the 
 53constraint name as the parameter name. For example :
 54
 55  double sqrt(double NONNEGATIVE);
 56  double log(double POSITIVE);
 57
 58If you have used typedef to change type-names, you can also do this :
 59
 60  %apply double { Real };       // Make everything defined for doubles
 61                                // work for Reals.
 62  Real sqrt(Real NONNEGATIVE);
 63  Real log(Real POSITIVE);
 64
 65%}
 66#endif
 67
 68%include <exception.i>
 69
 70#ifdef SWIGCSHARP
 71// Required attribute for C# exception handling
 72#define SWIGCSHARPCANTHROW , canthrow=1
 73#else
 74#define SWIGCSHARPCANTHROW
 75#endif
 76
 77
 78// Positive numbers
 79
 80%typemap(check SWIGCSHARPCANTHROW) 
 81                int               POSITIVE,
 82                short             POSITIVE,
 83                long              POSITIVE,
 84                unsigned int      POSITIVE,
 85                unsigned short    POSITIVE,
 86                unsigned long     POSITIVE,
 87                signed char       POSITIVE,
 88                unsigned char     POSITIVE,
 89                float             POSITIVE,
 90                double            POSITIVE,
 91                Number            POSITIVE
 92{
 93  if ($1 <= 0) {
 94    SWIG_exception(SWIG_ValueError,"Expected a positive value.");
 95  }
 96}
 97
 98// Negative numbers
 99
100%typemap(check SWIGCSHARPCANTHROW) 
101                int               NEGATIVE,
102                short             NEGATIVE,
103                long              NEGATIVE,
104                unsigned int      NEGATIVE,
105                unsigned short    NEGATIVE,
106                unsigned long     NEGATIVE,
107                signed char       NEGATIVE,
108                unsigned char     NEGATIVE,
109                float             NEGATIVE,
110                double            NEGATIVE,
111                Number            NEGATIVE
112{
113  if ($1 >= 0) {
114    SWIG_exception(SWIG_ValueError,"Expected a negative value.");
115  }
116}
117
118// Nonzero numbers
119
120%typemap(check SWIGCSHARPCANTHROW) 
121                int               NONZERO,
122                short             NONZERO,
123                long              NONZERO,
124                unsigned int      NONZERO,
125                unsigned short    NONZERO,
126                unsigned long     NONZERO,
127                signed char       NONZERO,
128                unsigned char     NONZERO,
129                float             NONZERO,
130                double            NONZERO,
131                Number            NONZERO
132{
133  if ($1 == 0) {
134    SWIG_exception(SWIG_ValueError,"Expected a nonzero value.");
135  }
136}
137
138// Nonnegative numbers
139
140%typemap(check SWIGCSHARPCANTHROW) 
141                int               NONNEGATIVE,
142                short             NONNEGATIVE,
143                long              NONNEGATIVE,
144                unsigned int      NONNEGATIVE,
145                unsigned short    NONNEGATIVE,
146                unsigned long     NONNEGATIVE,
147                signed char       NONNEGATIVE,
148                unsigned char     NONNEGATIVE,
149                float             NONNEGATIVE,
150                double            NONNEGATIVE,
151                Number            NONNEGATIVE
152{
153  if ($1 < 0) {
154    SWIG_exception(SWIG_ValueError,"Expected a non-negative value.");
155  }
156}
157
158// Nonpositive numbers
159
160%typemap(check SWIGCSHARPCANTHROW) 
161                int               NONPOSITIVE,
162                short             NONPOSITIVE,
163                long              NONPOSITIVE,
164                unsigned int      NONPOSITIVE,
165                unsigned short    NONPOSITIVE,
166                unsigned long     NONPOSITIVE,
167                signed char       NONPOSITIVE,
168                unsigned char     NONPOSITIVE,
169                float             NONPOSITIVE,
170                double            NONPOSITIVE,
171                Number            NONPOSITIVE
172{
173  if ($1 > 0) {
174    SWIG_exception(SWIG_ValueError,"Expected a non-positive value.");
175  }
176}
177                
178// Non-NULL pointer
179
180%typemap(check SWIGCSHARPCANTHROW) 
181                void *            NONNULL,
182                Pointer           NONNULL
183{
184  if (!$1) {
185    SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
186  }
187}
188
189// Aligned pointers
190
191%typemap(check SWIGCSHARPCANTHROW) 
192                void *            ALIGN8,
193                Pointer           ALIGN8
194{
195   unsigned long long tmp;
196   tmp = (unsigned long long) $1;
197   if (tmp & 7) {
198     SWIG_exception(SWIG_ValueError,"Pointer must be 8-byte aligned.");
199   }
200}
201
202%typemap(check SWIGCSHARPCANTHROW) 
203                void *            ALIGN4,
204                Pointer           ALIGN4
205{
206   unsigned long long tmp;
207   tmp = (unsigned long long) $1;
208   if (tmp & 3) {
209     SWIG_exception(SWIG_ValueError,"Pointer must be 4-byte aligned.");
210   }
211}
212
213%typemap(check SWIGCSHARPCANTHROW) 
214                void *            ALIGN2,
215                Pointer           ALIGN2
216{
217   unsigned long long tmp;
218   tmp = (unsigned long long) $1;
219   if (tmp & 1) {
220     SWIG_exception(SWIG_ValueError,"Pointer must be 2-byte aligned.");
221   }
222}
223
224