1/* ------------------------------------------------------------
2 * Primitive Types
3 * ------------------------------------------------------------ */
4
5/* bool */
6
7%fragment(SWIG_From_frag(bool),"header") {
8SWIGINTERNINLINE SV *
9SWIG_From_dec(bool)(bool value)
10{
11  SV *obj = sv_newmortal();
12  if (value) {
13    sv_setsv(obj, &PL_sv_yes);
14  } else {
15    sv_setsv(obj, &PL_sv_no);
16  }
17  return obj;
18}
19}
20
21%fragment(SWIG_AsVal_frag(bool),"header",
22	  fragment="SWIG_CanCastAsInteger") {
23SWIGINTERN int
24SWIG_AsVal_dec(bool)(SV *obj, bool* val)
25{
26  if (obj == &PL_sv_yes) {
27    if (val) *val = true;
28    return SWIG_OK;
29  } else if (obj == &PL_sv_no) {
30    if (val) *val = false;
31    return SWIG_OK;
32  } else {
33    if (val) *val = SvTRUE(obj) ? true: false;
34    return SWIG_AddCast(SWIG_OK);
35  }
36  return SWIG_TypeError;
37}
38}
39
40
41/* long */
42
43%fragment(SWIG_From_frag(long),"header") {
44SWIGINTERNINLINE SV *
45SWIG_From_dec(long)(long value)
46{
47  SV *obj = sv_newmortal();
48  sv_setiv(obj, (IV) value);
49  return obj;
50}
51}
52
53%fragment(SWIG_AsVal_frag(long),"header",
54	  fragment="SWIG_CanCastAsInteger") {
55SWIGINTERN int
56SWIG_AsVal_dec(long)(SV *obj, long* val)
57{
58  if (SvIOK(obj)) {
59    if (val) *val = SvIV(obj);
60    return SWIG_OK;
61  } else {
62    int dispatch = 0;
63    const char *nptr = SvPV_nolen(obj);
64    if (nptr) {
65      char *endptr;
66      long v;
67      errno = 0;
68      v = strtol(nptr, &endptr,0);
69      if (errno == ERANGE) {
70	errno = 0;
71	return SWIG_OverflowError;
72      } else {
73	if (*endptr == '\0') {
74	  if (val) *val = v;
75	  return SWIG_Str2NumCast(SWIG_OK);
76	}
77      }
78    }
79    if (!dispatch) {
80      double d;
81      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
82      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
83	if (val) *val = (long)(d);
84	return res;
85      }
86    }
87  }
88  return SWIG_TypeError;
89}
90}
91
92/* unsigned long */
93
94%fragment(SWIG_From_frag(unsigned long),"header",
95	  fragment=SWIG_AsVal_frag(double)) {
96SWIGINTERNINLINE SV *
97SWIG_From_dec(unsigned long)(unsigned long value)
98{
99  SV *obj = sv_newmortal();
100  sv_setuv(obj, (UV) value);
101  return obj;
102}
103}
104
105%fragment(SWIG_AsVal_frag(unsigned long),"header",
106	  fragment="SWIG_CanCastAsInteger") {
107SWIGINTERN int
108SWIG_AsVal_dec(unsigned long)(SV *obj, unsigned long *val)
109{
110  if (SvUOK(obj)) {
111    if (val) *val = SvUV(obj);
112    return SWIG_OK;
113  } else  if (SvIOK(obj)) {
114    long v = SvIV(obj);
115    if (v >= 0) {
116      if (val) *val = v;
117      return SWIG_OK;
118    } else {
119      return SWIG_OverflowError;
120    }
121  } else {
122    int dispatch = 0;
123    const char *nptr = SvPV_nolen(obj);
124    if (nptr) {
125      char *endptr;
126      unsigned long v;
127      errno = 0;
128      v = strtoul(nptr, &endptr,0);
129      if (errno == ERANGE) {
130	errno = 0;
131	return SWIG_OverflowError;
132      } else {
133	if (*endptr == '\0') {
134	  if (val) *val = v;
135	  return SWIG_Str2NumCast(SWIG_OK);
136	}
137      }
138    }
139    if (!dispatch) {
140      double d;
141      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
142      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
143	if (val) *val = (unsigned long)(d);
144	return res;
145      }
146    }
147  }
148  return SWIG_TypeError;
149}
150}
151
152/* long long */
153
154%fragment(SWIG_From_frag(long long),"header",
155	  fragment=SWIG_From_frag(long),
156	  fragment="<limits.h>",
157	  fragment="<stdio.h>") {
158SWIGINTERNINLINE SV *
159SWIG_From_dec(long long)(long long value)
160{
161  if (((long long) LONG_MIN <= value) && (value <= (long long) LONG_MAX)) {
162    return SWIG_From(long)(%numeric_cast(value,long));
163  } else {
164    char temp[256];
165    SV *obj = sv_newmortal();
166    sprintf(temp, "%lld", value);
167    sv_setpv(obj, temp);
168    return obj;
169  }
170}
171}
172
173%fragment(SWIG_AsVal_frag(long long),"header",
174	  fragment="<limits.h>",
175	  fragment="<stdlib.h>",
176	  fragment="SWIG_CanCastAsInteger") {
177
178SWIGINTERN int
179SWIG_AsVal_dec(long long)(SV *obj, long long *val)
180{
181  if (SvIOK(obj)) {
182    if (val) *val = SvIV(obj);
183    return SWIG_OK;
184  } else {
185    int dispatch = 0;
186    const char *nptr = SvPV_nolen(obj);
187    if (nptr) {
188      char *endptr;
189      long long v;
190      errno = 0;
191      v = strtoll(nptr, &endptr,0);
192      if (errno == ERANGE) {
193	errno = 0;
194	return SWIG_OverflowError;
195      } else {
196	if (*endptr == '\0') {
197	  if (val) *val = v;
198	  return SWIG_Str2NumCast(SWIG_OK);
199	}
200      }
201    }
202    if (!dispatch) {
203      const double mant_max = 1LL << DBL_MANT_DIG;
204      const double mant_min = -mant_max;
205      double d;
206      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
207      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
208	if (val) *val = (long long)(d);
209	return res;
210      }
211    }
212  }
213  return SWIG_TypeError;
214}
215}
216
217/* unsigned long long */
218
219%fragment(SWIG_From_frag(unsigned long long),"header",
220	  fragment=SWIG_From_frag(long long),
221	  fragment="<limits.h>",
222	  fragment="<stdio.h>") {
223SWIGINTERNINLINE SV *
224SWIG_From_dec(unsigned long long)(unsigned long long value)
225{
226  if (value < (unsigned long long) LONG_MAX) {
227    return SWIG_From(long long)(%numeric_cast(value, long long));
228  } else {
229    char temp[256];
230    SV *obj = sv_newmortal();
231    sprintf(temp, "%llu", value);
232    sv_setpv(obj, temp);
233    return obj;
234  }
235}
236}
237
238%fragment(SWIG_AsVal_frag(unsigned long long),"header",
239	  fragment="<limits.h>",
240	  fragment="<stdlib.h>",
241	  fragment="SWIG_CanCastAsInteger") {
242SWIGINTERN int
243SWIG_AsVal_dec(unsigned long long)(SV *obj, unsigned long long *val)
244{
245  if (SvUOK(obj)) {
246    if (val) *val = SvUV(obj);
247    return SWIG_OK;
248  } else  if (SvIOK(obj)) {
249    long v = SvIV(obj);
250    if (v >= 0) {
251      if (val) *val = v;
252      return SWIG_OK;
253    } else {
254      return SWIG_OverflowError;
255    }
256  } else {
257    int dispatch = 0;
258    const char *nptr = SvPV_nolen(obj);
259    if (nptr) {
260      char *endptr;
261      unsigned long long v;
262      errno = 0;
263      v = strtoull(nptr, &endptr,0);
264      if (errno == ERANGE) {
265	errno = 0;
266	return SWIG_OverflowError;
267      } else {
268	if (*endptr == '\0') {
269	  if (val) *val = v;
270	  return SWIG_Str2NumCast(SWIG_OK);
271	}
272      }
273    }
274    if (!dispatch) {
275      const double mant_max = 1LL << DBL_MANT_DIG;
276      double d;
277      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
278      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
279	if (val) *val = (unsigned long long)(d);
280	return res;
281      }
282    }
283  }
284  return SWIG_TypeError;
285}
286}
287
288/* double */
289
290%fragment(SWIG_From_frag(double),"header") {
291SWIGINTERNINLINE SV *
292SWIG_From_dec(double)(double value)
293{
294  SV *obj = sv_newmortal();
295  sv_setnv(obj, value);
296  return obj;
297}
298}
299
300%fragment(SWIG_AsVal_frag(double),"header") {
301SWIGINTERN int
302SWIG_AsVal_dec(double)(SV *obj, double *val)
303{
304  if (SvNIOK(obj)) {
305    if (val) *val = SvNV(obj);
306    return SWIG_OK;
307  } else if (SvIOK(obj)) {
308    if (val) *val = (double) SvIV(obj);
309    return SWIG_AddCast(SWIG_OK);
310  } else {
311    const char *nptr = SvPV_nolen(obj);
312    if (nptr) {
313      char *endptr;
314      double v = strtod(nptr, &endptr);
315      if (errno == ERANGE) {
316	errno = 0;
317	return SWIG_OverflowError;
318      } else {
319	if (*endptr == '\0') {
320	  if (val) *val = v;
321	  return SWIG_Str2NumCast(SWIG_OK);
322	}
323      }
324    }
325  }
326  return SWIG_TypeError;
327}
328}
329