[OpenSPARC-T2-SAM] / sam-t2 / devtools / v8plus / share / swig / 1.3.26 / php4 / globalvar.i

/* Global variables - add the variable to PHP */

%typemap(varinit) char *,
                  char []
{
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  z_var->type = IS_STRING;
  if($1) {
      z_var->value.str.val = estrdup($1);
      z_var->value.str.len = strlen($1);
  } else {
      z_var->value.str.val = 0;
      z_var->value.str.len = 0;
  }
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}

%typemap(varinit) int,
	          unsigned int,
                  unsigned short,
                  short,
                  unsigned short,
                  long,
                  unsigned long,
                  signed char,
                  unsigned char,
                  enum SWIGTYPE
{
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  z_var->type = IS_LONG;
  z_var->value.lval = $1;
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}

%typemap(varinit) bool
{
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  z_var->type = IS_BOOL;
  z_var->value.lval = ($1)?1:0;
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}

%typemap(varinit) float, double
{
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  z_var->type = IS_DOUBLE;
  z_var->value.dval = $1;
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
  sizeof(zval *), NULL);
}

%typemap(varinit) char
{
  zval *z_var;
  char c[2];
  MAKE_STD_ZVAL(z_var);
  c[0] = $1;
  c[1] = 0;
  z_var->type = IS_STRING;
  z_var->value.str.val = estrdup(c);
  z_var->value.str.len = 2;
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
  sizeof(zval *), NULL);
}

%typemap(varinit) SWIGTYPE *, SWIGTYPE []
{
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
  sizeof(zval *), NULL);
}

%typemap(varinit) SWIGTYPE, SWIGTYPE &
{
  $&1_ltype argp;
  zval *z_var;

  MAKE_STD_ZVAL(z_var);
  SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
  zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
  sizeof(zval *), NULL);
}

%typemap(varinit) char [ANY]
{
 zval *z_var;
 MAKE_STD_ZVAL(z_var);
 z_var->type = IS_STRING;
 if($1) {
	// varinit char [ANY]
	ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
 }
 zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
 sizeof(zval *), NULL);
}

%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char,  enum SWIGTYPE
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
  convert_to_long_ex(z_var);
  if($1 != ($1_ltype)((*z_var)->value.lval)) {
    $1 = Z_LVAL_PP(z_var);
  }
}

%typemap(varin) bool
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
  convert_to_boolean_ex(z_var);
  if($1 != ($1_ltype)((*z_var)->value.lval)) {
    $1 = Z_LVAL_PP(z_var);
  }
}

%typemap(varin) double,float
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  convert_to_double_ex(z_var);
  if($1 != ($1_ltype)((*z_var)->value.dval)) {
    $1 = Z_DVAL_PP(z_var);
  }
}

%typemap(varin) char
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
  convert_to_string_ex(z_var);
  if($1 != *((*z_var)->value.str.val)) {
    $1 = *((*z_var)->value.str.val);
  }
}

%typemap(varin) char *
{
  zval **z_var;
  char *s1;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  convert_to_string_ex(z_var);
  s1 = Z_STRVAL_PP(z_var);
  if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
    if(s1)
      $1 = estrdup(s1);
    else
      $1 = NULL;
  }
}


%typemap(varin) SWIGTYPE []
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1) {
    SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
  }
}

%typemap(varin) char [ANY]
{
 zval **z_var;
 char *s1;

 zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
 s1 = Z_STRVAL_PP(z_var);
 if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
  if(s1)
    strncpy($1, s1, $1_dim0);
 }
}

%typemap(varin) SWIGTYPE
{
  zval **z_var;
  $&1_ltype _temp;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
  }

  $1 = *($&1_ltype)_temp;

}

%typemap(varin) SWIGTYPE *, SWIGTYPE &
{
  zval **z_var;
  $1_ltype _temp;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) { 
    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
  }

  $1 = ($1_ltype)_temp;
}

%typemap(varout) int,
                 unsigned int,
                 unsigned short,
                 short,
                 long,
                 unsigned long,
                 signed char,
                 unsigned char,
                 enum SWIGTYPE
{
  zval **z_var;
  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1 != ($1_ltype)((*z_var)->value.lval)) {
    (*z_var)->value.lval = (long)$1;
  }
}

//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
%typemap(varout) bool
{
  zval **z_var;
  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1 != ($1_ltype)((*z_var)->value.lval)) {
    (*z_var)->value.lval = (long)$1;
  }
}

%typemap(varout) double, float
{
  zval **z_var;
  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1 != ($1_ltype)((*z_var)->value.dval)) {
    (*z_var)->value.dval = (double)$1;
  }
}

%typemap(varout) char
{
  zval **z_var;
  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1 != *((*z_var)->value.str.val)) {
    char c[2];
    efree((*z_var)->value.str.val);
    c[0] = $1;
    c[1] = 0;
    (*z_var)->value.str.val = estrdup(c);
  }
}

%typemap(varout) char *
{
  zval **z_var;
  char *s1;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  s1 = Z_STRVAL_PP(z_var);
  if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) {
    if(s1)
      efree(s1);
    if($1) {
      (*z_var)->value.str.val = estrdup($1);
      (*z_var)->value.str.len = strlen($1) +1;
    } else {
      (*z_var)->value.str.val = 0;
      (*z_var)->value.str.len = 0;
    }
 }
}

%typemap(varout) SWIGTYPE
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
}

%typemap(varout) SWIGTYPE []
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  if($1) 
  	SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
}

%typemap(varout) char [ANY]
{
  zval **z_var;
  char *s1;
deliberate error cos this code looks bogus to me
  zend_hash_find(&EG(symbol_table), "$1" ,strlen("$1")+1, (void**)&z_var);
  s1 = Z_STRVAL_PP(z_var);
  if((s1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {

    if($1) {
      (*z_var)->value.str.val = estrdup($1);
      (*z_var)->value.str.len = strlen($1)+1;
    } else {
      (*z_var)->value.str.val = 0;
      (*z_var)->value.str.len = 0;
    }
  }
}

%typemap(varout) SWIGTYPE *, SWIGTYPE &
{
  zval **z_var;

  zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
  SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
}
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