Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | /* Global variables - add the variable to PHP */ |
2 | ||
3 | %typemap(varinit) char *, | |
4 | char [] | |
5 | { | |
6 | zval *z_var; | |
7 | MAKE_STD_ZVAL(z_var); | |
8 | z_var->type = IS_STRING; | |
9 | if($1) { | |
10 | z_var->value.str.val = estrdup($1); | |
11 | z_var->value.str.len = strlen($1); | |
12 | } else { | |
13 | z_var->value.str.val = 0; | |
14 | z_var->value.str.len = 0; | |
15 | } | |
16 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL); | |
17 | } | |
18 | ||
19 | %typemap(varinit) int, | |
20 | unsigned int, | |
21 | unsigned short, | |
22 | short, | |
23 | unsigned short, | |
24 | long, | |
25 | unsigned long, | |
26 | signed char, | |
27 | unsigned char, | |
28 | enum SWIGTYPE | |
29 | { | |
30 | zval *z_var; | |
31 | MAKE_STD_ZVAL(z_var); | |
32 | z_var->type = IS_LONG; | |
33 | z_var->value.lval = $1; | |
34 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL); | |
35 | } | |
36 | ||
37 | %typemap(varinit) bool | |
38 | { | |
39 | zval *z_var; | |
40 | MAKE_STD_ZVAL(z_var); | |
41 | z_var->type = IS_BOOL; | |
42 | z_var->value.lval = ($1)?1:0; | |
43 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL); | |
44 | } | |
45 | ||
46 | %typemap(varinit) float, double | |
47 | { | |
48 | zval *z_var; | |
49 | MAKE_STD_ZVAL(z_var); | |
50 | z_var->type = IS_DOUBLE; | |
51 | z_var->value.dval = $1; | |
52 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, | |
53 | sizeof(zval *), NULL); | |
54 | } | |
55 | ||
56 | %typemap(varinit) char | |
57 | { | |
58 | zval *z_var; | |
59 | char c[2]; | |
60 | MAKE_STD_ZVAL(z_var); | |
61 | c[0] = $1; | |
62 | c[1] = 0; | |
63 | z_var->type = IS_STRING; | |
64 | z_var->value.str.val = estrdup(c); | |
65 | z_var->value.str.len = 2; | |
66 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, | |
67 | sizeof(zval *), NULL); | |
68 | } | |
69 | ||
70 | %typemap(varinit) SWIGTYPE *, SWIGTYPE [] | |
71 | { | |
72 | zval *z_var; | |
73 | MAKE_STD_ZVAL(z_var); | |
74 | SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0); | |
75 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, | |
76 | sizeof(zval *), NULL); | |
77 | } | |
78 | ||
79 | %typemap(varinit) SWIGTYPE, SWIGTYPE & | |
80 | { | |
81 | $&1_ltype argp; | |
82 | zval *z_var; | |
83 | ||
84 | MAKE_STD_ZVAL(z_var); | |
85 | SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0); | |
86 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var, | |
87 | sizeof(zval *), NULL); | |
88 | } | |
89 | ||
90 | %typemap(varinit) char [ANY] | |
91 | { | |
92 | zval *z_var; | |
93 | MAKE_STD_ZVAL(z_var); | |
94 | z_var->type = IS_STRING; | |
95 | if($1) { | |
96 | // varinit char [ANY] | |
97 | ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1); | |
98 | } | |
99 | zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var, | |
100 | sizeof(zval *), NULL); | |
101 | } | |
102 | ||
103 | %typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE | |
104 | { | |
105 | zval **z_var; | |
106 | ||
107 | zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var); | |
108 | convert_to_long_ex(z_var); | |
109 | if($1 != ($1_ltype)((*z_var)->value.lval)) { | |
110 | $1 = Z_LVAL_PP(z_var); | |
111 | } | |
112 | } | |
113 | ||
114 | %typemap(varin) bool | |
115 | { | |
116 | zval **z_var; | |
117 | ||
118 | zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var); | |
119 | convert_to_boolean_ex(z_var); | |
120 | if($1 != ($1_ltype)((*z_var)->value.lval)) { | |
121 | $1 = Z_LVAL_PP(z_var); | |
122 | } | |
123 | } | |
124 | ||
125 | %typemap(varin) double,float | |
126 | { | |
127 | zval **z_var; | |
128 | ||
129 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
130 | convert_to_double_ex(z_var); | |
131 | if($1 != ($1_ltype)((*z_var)->value.dval)) { | |
132 | $1 = Z_DVAL_PP(z_var); | |
133 | } | |
134 | } | |
135 | ||
136 | %typemap(varin) char | |
137 | { | |
138 | zval **z_var; | |
139 | ||
140 | zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var); | |
141 | convert_to_string_ex(z_var); | |
142 | if($1 != *((*z_var)->value.str.val)) { | |
143 | $1 = *((*z_var)->value.str.val); | |
144 | } | |
145 | } | |
146 | ||
147 | %typemap(varin) char * | |
148 | { | |
149 | zval **z_var; | |
150 | char *s1; | |
151 | ||
152 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
153 | convert_to_string_ex(z_var); | |
154 | s1 = Z_STRVAL_PP(z_var); | |
155 | if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) { | |
156 | if(s1) | |
157 | $1 = estrdup(s1); | |
158 | else | |
159 | $1 = NULL; | |
160 | } | |
161 | } | |
162 | ||
163 | ||
164 | %typemap(varin) SWIGTYPE [] | |
165 | { | |
166 | zval **z_var; | |
167 | ||
168 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
169 | if($1) { | |
170 | SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner); | |
171 | } | |
172 | } | |
173 | ||
174 | %typemap(varin) char [ANY] | |
175 | { | |
176 | zval **z_var; | |
177 | char *s1; | |
178 | ||
179 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
180 | s1 = Z_STRVAL_PP(z_var); | |
181 | if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) { | |
182 | if(s1) | |
183 | strncpy($1, s1, $1_dim0); | |
184 | } | |
185 | } | |
186 | ||
187 | %typemap(varin) SWIGTYPE | |
188 | { | |
189 | zval **z_var; | |
190 | $&1_ltype _temp; | |
191 | ||
192 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
193 | if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) { | |
194 | SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor"); | |
195 | } | |
196 | ||
197 | $1 = *($&1_ltype)_temp; | |
198 | ||
199 | } | |
200 | ||
201 | %typemap(varin) SWIGTYPE *, SWIGTYPE & | |
202 | { | |
203 | zval **z_var; | |
204 | $1_ltype _temp; | |
205 | ||
206 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
207 | if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) { | |
208 | SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor"); | |
209 | } | |
210 | ||
211 | $1 = ($1_ltype)_temp; | |
212 | } | |
213 | ||
214 | %typemap(varout) int, | |
215 | unsigned int, | |
216 | unsigned short, | |
217 | short, | |
218 | long, | |
219 | unsigned long, | |
220 | signed char, | |
221 | unsigned char, | |
222 | enum SWIGTYPE | |
223 | { | |
224 | zval **z_var; | |
225 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
226 | if($1 != ($1_ltype)((*z_var)->value.lval)) { | |
227 | (*z_var)->value.lval = (long)$1; | |
228 | } | |
229 | } | |
230 | ||
231 | //SAMFIX need to cast zval->type, what if zend-hash_find fails? etc? | |
232 | %typemap(varout) bool | |
233 | { | |
234 | zval **z_var; | |
235 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
236 | if($1 != ($1_ltype)((*z_var)->value.lval)) { | |
237 | (*z_var)->value.lval = (long)$1; | |
238 | } | |
239 | } | |
240 | ||
241 | %typemap(varout) double, float | |
242 | { | |
243 | zval **z_var; | |
244 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
245 | if($1 != ($1_ltype)((*z_var)->value.dval)) { | |
246 | (*z_var)->value.dval = (double)$1; | |
247 | } | |
248 | } | |
249 | ||
250 | %typemap(varout) char | |
251 | { | |
252 | zval **z_var; | |
253 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
254 | if($1 != *((*z_var)->value.str.val)) { | |
255 | char c[2]; | |
256 | efree((*z_var)->value.str.val); | |
257 | c[0] = $1; | |
258 | c[1] = 0; | |
259 | (*z_var)->value.str.val = estrdup(c); | |
260 | } | |
261 | } | |
262 | ||
263 | %typemap(varout) char * | |
264 | { | |
265 | zval **z_var; | |
266 | char *s1; | |
267 | ||
268 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
269 | s1 = Z_STRVAL_PP(z_var); | |
270 | if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) { | |
271 | if(s1) | |
272 | efree(s1); | |
273 | if($1) { | |
274 | (*z_var)->value.str.val = estrdup($1); | |
275 | (*z_var)->value.str.len = strlen($1) +1; | |
276 | } else { | |
277 | (*z_var)->value.str.val = 0; | |
278 | (*z_var)->value.str.len = 0; | |
279 | } | |
280 | } | |
281 | } | |
282 | ||
283 | %typemap(varout) SWIGTYPE | |
284 | { | |
285 | zval **z_var; | |
286 | ||
287 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
288 | SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0); | |
289 | } | |
290 | ||
291 | %typemap(varout) SWIGTYPE [] | |
292 | { | |
293 | zval **z_var; | |
294 | ||
295 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
296 | if($1) | |
297 | SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0); | |
298 | } | |
299 | ||
300 | %typemap(varout) char [ANY] | |
301 | { | |
302 | zval **z_var; | |
303 | char *s1; | |
304 | deliberate error cos this code looks bogus to me | |
305 | zend_hash_find(&EG(symbol_table), "$1" ,strlen("$1")+1, (void**)&z_var); | |
306 | s1 = Z_STRVAL_PP(z_var); | |
307 | if((s1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) { | |
308 | ||
309 | if($1) { | |
310 | (*z_var)->value.str.val = estrdup($1); | |
311 | (*z_var)->value.str.len = strlen($1)+1; | |
312 | } else { | |
313 | (*z_var)->value.str.val = 0; | |
314 | (*z_var)->value.str.len = 0; | |
315 | } | |
316 | } | |
317 | } | |
318 | ||
319 | %typemap(varout) SWIGTYPE *, SWIGTYPE & | |
320 | { | |
321 | zval **z_var; | |
322 | ||
323 | zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var); | |
324 | SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0); | |
325 | } | |
326 | ||
327 |