← Back to branch summary

~ubuntu-branches/ubuntu/maverick/swig1.3/maverick

« back to all changes in this revision

Viewing changes to Lib/php4/typemaps.i

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-12-05 01:16:04 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051205011604-ygx904it6413k3go
Tags: 1.3.27-1ubuntu1
Resynchronise with Debian again, for the new subversion packages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/php4/typemaps.i
11
11
// ever need to write a typemap.
12
12
//
13
13
 
14
 
%typemap(in) double *INPUT(double temp)
15
 
{
16
 
        temp = (double) Z_DVAL_PP($input);
17
 
        $1 = &temp;
18
 
}
19
 
 
20
 
%typemap(in) float  *INPUT(float temp)
21
 
{
22
 
        temp = (float) Z_DVAL_PP($input);
23
 
        $1 = &temp;
24
 
}
25
 
 
26
 
%typemap(in) int        *INPUT(int temp)
27
 
{
28
 
        temp = (int) Z_LVAL_PP($input);
29
 
        $1 = &temp;
30
 
}
31
 
 
32
 
%typemap(in) short      *INPUT(short temp)
33
 
{
34
 
        temp = (short) Z_LVAL_PP($input);
35
 
        $1 = &temp;
36
 
}
37
 
 
38
 
%typemap(in) long       *INPUT(long temp)
39
 
{
40
 
        temp = (long) Z_LVAL_PP($input);
41
 
        $1 = &temp;
42
 
}
43
 
 
44
 
%typemap(in) unsigned int       *INPUT(unsigned int temp)
45
 
{
46
 
        temp = (unsigned int) Z_LVAL_PP($input);
47
 
        $1 = &temp;
48
 
}
49
 
 
50
 
%typemap(in) unsigned short *INPUT(unsigned short temp)
51
 
{
52
 
        temp = (unsigned short) Z_LVAL_PP($input);
53
 
        $1 = &temp;
54
 
}
55
 
 
56
 
%typemap(in) unsigned long *INPUT(unsigned long temp)
57
 
{
58
 
        temp = (unsigned long) Z_LVAL_PP($input);
59
 
        $1 = &temp;
60
 
}
61
 
 
62
 
%typemap(in) unsigned char *INPUT(unsigned char temp)
63
 
{
64
 
        temp = (unsigned char) Z_LVAL_PP($input);
65
 
        $1 = &temp;
66
 
}
67
 
 
68
 
%typemap(in,numinputs=0)        int     *OUTPUT(int temp),
69
 
                        short   *OUTPUT(short temp),
70
 
                        long    *OUTPUT(long temp),
71
 
                        unsigned int    *OUTPUT(unsigned int temp),
72
 
                        unsigned short  *OUTPUT(unsigned short temp),
73
 
                        unsigned long   *OUTPUT(unsigned long temp),
74
 
                        unsigned char   *OUTPUT(unsigned char temp),
75
 
                        float           *OUTPUT(float temp),
76
 
                        double          *OUTPUT(double temp)
77
 
{
78
 
  $1 = &temp;
79
 
}
80
 
 
81
 
%typemap(argout)        int     *OUTPUT,
82
 
                        short   *OUTPUT,
83
 
                        long    *OUTPUT,
84
 
                        unsigned int    *OUTPUT,
85
 
                        unsigned short  *OUTPUT,
86
 
                        unsigned long   *OUTPUT,
87
 
                        unsigned char   *OUTPUT
88
 
{
89
 
 
90
 
  ZVAL_LONG($result,*($input));
91
 
}
92
 
 
93
 
%typemap(argout)        float   *OUTPUT,
94
 
                        double  *OUTPUT
95
 
{
96
 
  ZVAL_DOUBLE($result,*($input));
97
 
}
 
14
//
 
15
// Define macros to define the following typemaps:
 
16
//
 
17
// TYPE *INPUT.   Argument is passed in as native variable by value.
 
18
// TYPE *OUTPUT.  Argument is returned as an array from the function call.
 
19
// TYPE *INOUT.   Argument is passed in by value, and out as part of returned list
 
20
// TYPE *REFERENCE.  Argument is passed in as native variable with value
 
21
//                   semantics.  Variable value is changed with result.
 
22
//                   Use like this:
 
23
//                   int foo(int *REFERENCE);
 
24
//
 
25
//                   $a = 0;
 
26
//                   $rc = foo($a);
 
27
//
 
28
//                   Even though $a looks like it's passed by value,
 
29
//                   it's value can be changed by foo().
 
30
//
 
31
%define double_typemap(TYPE)
 
32
%typemap(in) TYPE *INPUT(TYPE temp)
 
33
{
 
34
  convert_to_double_ex($input);
 
35
  temp = (TYPE) Z_DVAL_PP($input);
 
36
  $1 = &temp;
 
37
}
 
38
%typemap(argout) TYPE *INPUT "";
 
39
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp)
 
40
{
 
41
  $1 = &temp;
 
42
}
 
43
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
 
44
{
 
45
  zval *o;
 
46
  MAKE_STD_ZVAL(o);
 
47
  ZVAL_DOUBLE(o,temp$argnum);
 
48
  t_output_helper( &$result, o );
 
49
}
 
50
%typemap(in) TYPE *REFERENCE (TYPE dvalue)
 
51
{
 
52
  convert_to_double_ex($input);
 
53
  dvalue = (TYPE) (*$input)->value.dval;
 
54
  $1 = &dvalue;
 
55
}
 
56
%typemap(argout) TYPE *REFERENCE
 
57
{
 
58
  $1->value.dval = (double)(lvalue$argnum);
 
59
  $1->type = IS_DOUBLE;
 
60
}
 
61
%enddef
 
62
 
 
63
%define int_typemap(TYPE)
 
64
%typemap(in) TYPE *INPUT(TYPE temp)
 
65
{
 
66
  convert_to_long_ex($input);
 
67
  temp = (TYPE) Z_LVAL_PP($input);
 
68
  $1 = &temp;
 
69
}
 
70
%typemap(argout) TYPE *INPUT "";
 
71
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp)
 
72
{
 
73
  $1 = &temp;
 
74
}
 
75
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
 
76
{
 
77
  zval *o;
 
78
  MAKE_STD_ZVAL(o);
 
79
  ZVAL_LONG(o,temp$argnum);
 
80
  t_output_helper( &$result, o );
 
81
}
 
82
%typemap(in) TYPE *REFERENCE (TYPE lvalue)
 
83
{
 
84
  convert_to_long_ex($input);
 
85
  lvalue = (TYPE) (*$input)->value.lval;
 
86
  $1 = &lvalue;
 
87
}
 
88
%typemap(argout) TYPE   *REFERENCE
 
89
{
 
90
 
 
91
  (*$arg)->value.lval = (long)(lvalue$argnum);
 
92
  (*$arg)->type = IS_LONG;
 
93
}
 
94
%enddef
 
95
 
 
96
double_typemap(float);
 
97
double_typemap(double);
 
98
 
 
99
int_typemap(int);
 
100
int_typemap(short);
 
101
int_typemap(long);
 
102
int_typemap(unsigned int);
 
103
int_typemap(unsigned short);
 
104
int_typemap(unsigned long);
 
105
int_typemap(unsigned char);
 
106
 
 
107
%typemap(in) float *INOUT = float *INPUT;
 
108
%typemap(in) double *INOUT = double *INPUT;
98
109
 
99
110
%typemap(in) int *INOUT = int *INPUT;
100
111
%typemap(in) short *INOUT = short *INPUT;
103
114
%typemap(in) unsigned short *INOUT = unsigned short *INPUT;
104
115
%typemap(in) unsigned long *INOUT = unsigned long *INPUT;
105
116
%typemap(in) unsigned char *INOUT = unsigned char *INPUT;
106
 
%typemap(in) float *INOUT = float *INPUT;
107
 
%typemap(in) double *INOUT = double *INPUT;
 
117
 
 
118
%typemap(argout) float *INOUT = float *OUTPUT;
 
119
%typemap(argout) double *INOUT= double *OUTPUT;
108
120
 
109
121
%typemap(argout) int *INOUT = int *OUTPUT;
110
122
%typemap(argout) short *INOUT = short *OUTPUT;
112
124
%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
113
125
%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
114
126
%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
115
 
%typemap(argout) float *INOUT = float *OUTPUT;
116
 
%typemap(argout) double *INOUT= double *OUTPUT;
117
 
 
118
 
// REFERENCE
119
 
// Accept Php references as pointers
120
 
 
121
 
%typemap(in) double *REFERENCE (double dvalue)
122
 
{
123
 
  if(!ParameterPassedByReference(ht, argvi))
124
 
  {
125
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
126
 
        RETURN_NULL();
127
 
  }
128
 
 
129
 
  dvalue = (double) (*$input)->value.dval;
130
 
  $1 = &dvalue;
131
 
}
132
 
 
133
 
%typemap(in) float *REFERENCE (float dvalue)
134
 
{
135
 
  if(!ParameterPassedByReference(ht, argvi))
136
 
  {
137
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
138
 
        RETURN_NULL();
139
 
  }
140
 
 
141
 
  dvalue = (float) (*$input)->value.dval;
142
 
  $1 = &dvalue;
143
 
}
144
 
 
145
 
%typemap(in) int *REFERENCE (int dvalue)
146
 
{
147
 
  if(!ParameterPassedByReference(ht, argvi))
148
 
  {
149
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
150
 
        RETURN_NULL();
151
 
  }
152
 
 
153
 
  dvalue = (int) (*$input)->value.lval;
154
 
  $1 = &dvalue;
155
 
}
156
 
 
157
 
%typemap(in) short *REFERENCE (short dvalue)
158
 
{
159
 
  if(!ParameterPassedByReference(ht, argvi))
160
 
  {
161
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
162
 
        RETURN_NULL();
163
 
  }
164
 
 
165
 
  dvalue = (short) (*$input)->value.lval;
166
 
  $1 = &dvalue;
167
 
}
168
 
 
169
 
%typemap(in) long *REFERENCE (long dvalue)
170
 
{
171
 
  if(!ParameterPassedByReference(ht, argvi))
172
 
  {
173
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
174
 
        RETURN_NULL();
175
 
  }
176
 
 
177
 
  dvalue = (long) (*$input)->value.lval;
178
 
  $1 = &dvalue;
179
 
}
180
 
 
181
 
%typemap(in) unsigned int *REFERENCE (unsigned int dvalue)
182
 
{
183
 
  if(!ParameterPassedByReference(ht, argvi))
184
 
  {
185
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
186
 
        RETURN_NULL();
187
 
  }
188
 
 
189
 
  dvalue = (unsigned int) (*$input)->value.lval;
190
 
  $1 = &dvalue;
191
 
}
192
 
 
193
 
%typemap(in) unsigned short *REFERENCE (unsigned short dvalue)
194
 
{
195
 
  if(!ParameterPassedByReference(ht, argvi))
196
 
  {
197
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
198
 
        RETURN_NULL();
199
 
  }
200
 
 
201
 
  dvalue = (unsigned short) $input->value.lval;
202
 
  $1 = &dvalue;
203
 
}
204
 
 
205
 
%typemap(in) unsigned long *REFERENCE (unsigned long dvalue)
206
 
{
207
 
  if(!ParameterPassedByReference(ht, argvi))
208
 
  {
209
 
        zend_error(E_WARNING, "Parameter wasn't passed by reference");
210
 
        RETURN_NULL();
211
 
  }
212
 
 
213
 
  dvalue = (unsigned long) $input->value.lval;
214
 
  $1 = &dvalue;
215
 
}
216
 
 
217
 
%typemap(argout) double *REFERENCE,
218
 
                      float  *REFERENCE
219
 
{
220
 
  $1->value.dval = (double)(*$arg);
221
 
  $1->type = IS_DOUBLE;
222
 
}
223
 
 
224
 
%typemap(argout) int    *REFERENCE,
225
 
                      short     *REFERENCE,
226
 
                      long      *REFERENCE,
227
 
                      unsigned int *REFERENCE,
228
 
                      unsigned short *REFERENCE,
229
 
                      unsigned long *REFERENCE
230
 
{
231
 
 
232
 
  (*$arg)->value.lval = (long)(*$input);
233
 
  (*$arg)->type = IS_LONG;
 
127
 
 
128
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
 
129
{
 
130
  convert_to_string_ex($input);
 
131
  char *val = Z_LVAL_PP($input);
 
132
  strncpy(temp,val,$1_dim0);
 
133
  $1 = temp;
 
134
}
 
135
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
 
136
{
 
137
  $1 = temp;
 
138
}
 
139
%typemap(argout) char OUTPUT[ANY]
 
140
{
 
141
  zval *o;
 
142
  MAKE_STD_ZVAL(o);
 
143
  ZVAL_STRINGL(o,temp$argnum,$1_dim0);
 
144
  t_output_helper( &$result, o );
 
145
}
 
146
 
 
147
%typemap(in,numinputs=0) void **OUTPUT (int force),
 
148
                         void *&OUTPUT (int force)
 
149
{
 
150
  /* If they pass NULL by reference, make it into a void*
 
151
     This bit should go in arginit if arginit support init-ing scripting args */
 
152
  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
 
153
    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
 
154
    if ((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input)) {
 
155
#ifdef __cplusplus
 
156
      ptr=new $*1_ltype;
 
157
#else
 
158
      ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
 
159
#endif
 
160
      $1=&ptr;
 
161
      /* have to passback arg$arg too */
 
162
      force=1;
 
163
    } else {  /* wasn't a pre/ref/thing, OR anything like an int thing */
 
164
      force=0;
 
165
      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
 
166
    }
 
167
  } else force=0;
 
168
}
 
169
 
 
170
%typemap(argout) void **OUTPUT,
 
171
                 void *&OUTPUT
 
172
{
 
173
  if (force$argnum) {  /* pass back arg$argnum through params ($arg) if we can */
 
174
    if(! PZVAL_IS_REF(*$arg)) {
 
175
      SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
 
176
    } else {
 
177
      SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
 
178
    }
 
179
  }
234
180
}