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