Mercurial > mm7

comparison lib/swig/swigwin-2.0.11/Lib/constraints.i @ 1899:b3009adc0e2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Adding swig, gitignore, hgignore
author Nomad
date Mon, 21 Oct 2013 10:42:27 +0200
parents
children
comparison
equal deleted inserted replaced
1867:eb580660bbbb 1899:b3009adc0e2f
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
15 This library provides support for applying constraints to function
16 arguments. Using a constraint, you can restrict arguments to be
17 positive numbers, non-NULL pointers, and so on. The following
18 constraints 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
30 To use the constraints, you need to "apply" them to specific
31 function arguments in your code. This is done using the %apply
32 directive. 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
41 Any function argument of the type you specify with the %apply directive
42 will be checked with the appropriate constraint. Multiple types may
43 be specified as follows :
44
45 %apply Pointer NONNULL { void *, Vector *, List *, double *};
46
47 In this case, all of the types listed would be checked for non-NULL
48 pointers.
49
50 The common datatypes of int, short, long, unsigned int, unsigned long,
51 unsigned short, unsigned char, signed char, float, and double can be
52 checked without using the %apply directive by simply using the
53 constraint name as the parameter name. For example :
54
55 double sqrt(double NONNEGATIVE);
56 double log(double POSITIVE);
57
58 If 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