1/* -----------------------------------------------------------------------------
2 * See the LICENSE file for information on copyright, usage and redistribution
3 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
4 *
5 * std_pair.i
6 *
7 * SWIG typemaps for std::pair
8 * ----------------------------------------------------------------------------- */
9
10%include <std_common.i>
11%include <exception.i>
12
13
14// ------------------------------------------------------------------------
15// std::pair
16//
17// See std_vector.i for the rationale of typemap application
18// ------------------------------------------------------------------------
19
20%{
21#include <utility>
22%}
23
24// exported class
25
26namespace std {
27
28    template<class T, class U> struct pair {
29        %typemap(in) pair<T,U> (std::pair<T,U>* m) {
30            if (SCHEME_PAIRP($input)) {
31                T* x;
32                U* y;
33                Scheme_Object *first, *second;
34                first = scheme_car($input);
35                second = scheme_cdr($input);
36                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
37                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
38                $1 = std::make_pair(*x,*y);
39            } else {
40                $1 = *(($&1_type)
41                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
42            }
43        }
44        %typemap(in) const pair<T,U>& (std::pair<T,U> temp,
45                                       std::pair<T,U>* m),
46                     const pair<T,U>* (std::pair<T,U> temp,
47                                       std::pair<T,U>* m) {
48            if (SCHEME_PAIRP($input)) {
49                T* x;
50                U* y;
51                Scheme_Object *first, *second;
52                first = scheme_car($input);
53                second = scheme_cdr($input);
54                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
55                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
56                temp = std::make_pair(*x,*y);
57                $1 = &temp;
58            } else {
59                $1 = ($1_ltype)
60                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
61            }
62        }
63        %typemap(out) pair<T,U> {
64            T* x = new T($1.first);
65            U* y = new U($1.second);
66            Scheme_Object* first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
67            Scheme_Object* second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
68            $result = scheme_make_pair(first,second);
69        }
70        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
71            /* native pair? */
72            if (SCHEME_PAIRP($input)) {
73                T* x;
74                U* y;
75                Scheme_Object* first = scheme_car($input);
76                Scheme_Object* second = scheme_cdr($input);
77                if (SWIG_ConvertPtr(first,(void**) &x,
78                                    $descriptor(T *), 0) != -1 &&
79                    SWIG_ConvertPtr(second,(void**) &y,
80                                    $descriptor(U *), 0) != -1) {
81                        $1 = 1;
82                } else {
83                    $1 = 0;
84                }
85            } else {
86                /* wrapped pair? */
87                std::pair<T,U >* p;
88                if (SWIG_ConvertPtr($input,(void **) &p,
89                                    $&1_descriptor, 0) != -1)
90                    $1 = 1;
91                else
92                    $1 = 0;
93            }
94        }
95        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
96                                        const pair<T,U>* {
97            /* native pair? */
98            if (SCHEME_PAIRP($input)) {
99                T* x;
100                U* y;
101                Scheme_Object* first = scheme_car($input);
102                Scheme_Object* second = scheme_cdr($input);
103                if (SWIG_ConvertPtr(first,(void**) &x,
104                                    $descriptor(T *), 0) != -1 &&
105                    SWIG_ConvertPtr(second,(void**) &y,
106                                    $descriptor(U *), 0) != -1) {
107                        $1 = 1;
108                } else {
109                    $1 = 0;
110                }
111            } else {
112                /* wrapped pair? */
113                std::pair<T,U >* p;
114                if (SWIG_ConvertPtr($input,(void **) &p,
115                                    $1_descriptor, 0) != -1)
116                    $1 = 1;
117                else
118                    $1 = 0;
119            }
120        }
121        pair();
122        pair(T first, U second);
123        pair(const pair& p);
124
125        template <class U1, class U2> pair(const pair<U1, U2> &p);
126
127        T first;
128        U second;
129    };
130
131    // specializations for built-ins
132
133    %define specialize_std_pair_on_first(T,CHECK,CONVERT_FROM,CONVERT_TO)
134    template<class U> struct pair<T,U> {
135        %typemap(in) pair<T,U> (std::pair<T,U>* m) {
136            if (SCHEME_PAIRP($input)) {
137                U* y;
138                Scheme_Object *first, *second;
139                first = scheme_car($input);
140                second = scheme_cdr($input);
141                if (!CHECK(first))
142                    SWIG_exception(SWIG_TypeError,
143                                   "pair<" #T "," #U "> expected");
144                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
145                $1 = std::make_pair(CONVERT_FROM(first),*y);
146            } else {
147                $1 = *(($&1_type)
148                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
149            }
150        }
151        %typemap(in) const pair<T,U>& (std::pair<T,U> temp,
152                                       std::pair<T,U>* m),
153                     const pair<T,U>* (std::pair<T,U> temp,
154                                       std::pair<T,U>* m) {
155            if (SCHEME_PAIRP($input)) {
156                U* y;
157                Scheme_Object *first, *second;
158                first = scheme_car($input);
159                second = scheme_cdr($input);
160                if (!CHECK(first))
161                    SWIG_exception(SWIG_TypeError,
162                                   "pair<" #T "," #U "> expected");
163                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
164                temp = std::make_pair(CONVERT_FROM(first),*y);
165                $1 = &temp;
166            } else {
167                $1 = ($1_ltype)
168                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
169            }
170        }
171        %typemap(out) pair<T,U> {
172            U* y = new U($1.second);
173            Scheme_Object* second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
174            $result = scheme_make_pair(CONVERT_TO($1.first),second);
175        }
176        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
177            /* native pair? */
178            if (SCHEME_PAIRP($input)) {
179                U* y;
180                Scheme_Object* first = scheme_car($input);
181                Scheme_Object* second = scheme_cdr($input);
182                if (CHECK(first) &&
183                    SWIG_ConvertPtr(second,(void**) &y,
184                                    $descriptor(U *), 0) != -1) {
185                        $1 = 1;
186                } else {
187                    $1 = 0;
188                }
189            } else {
190                /* wrapped pair? */
191                std::pair<T,U >* p;
192                if (SWIG_ConvertPtr($input,(void **) &p,
193                                    $&1_descriptor, 0) != -1)
194                    $1 = 1;
195                else
196                    $1 = 0;
197            }
198        }
199        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
200                                        const pair<T,U>* {
201            /* native pair? */
202            if (SCHEME_PAIRP($input)) {
203                U* y;
204                Scheme_Object* first = scheme_car($input);
205                Scheme_Object* second = scheme_cdr($input);
206                if (CHECK(first) &&
207                    SWIG_ConvertPtr(second,(void**) &y,
208                                    $descriptor(U *), 0) != -1) {
209                        $1 = 1;
210                } else {
211                    $1 = 0;
212                }
213            } else {
214                /* wrapped pair? */
215                std::pair<T,U >* p;
216                if (SWIG_ConvertPtr($input,(void **) &p,
217                                    $1_descriptor, 0) != -1)
218                    $1 = 1;
219                else
220                    $1 = 0;
221            }
222        }
223        pair();
224        pair(T first, U second);
225        pair(const pair& p);
226
227        template <class U1, class U2> pair(const pair<U1, U2> &p);
228
229        T first;
230        U second;
231    };
232    %enddef
233
234    %define specialize_std_pair_on_second(U,CHECK,CONVERT_FROM,CONVERT_TO)
235    template<class T> struct pair<T,U> {
236        %typemap(in) pair<T,U> (std::pair<T,U>* m) {
237            if (SCHEME_PAIRP($input)) {
238                T* x;
239                Scheme_Object *first, *second;
240                first = scheme_car($input);
241                second = scheme_cdr($input);
242                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
243                if (!CHECK(second))
244                    SWIG_exception(SWIG_TypeError,
245                                   "pair<" #T "," #U "> expected");
246                $1 = std::make_pair(*x,CONVERT_FROM(second));
247            } else {
248                $1 = *(($&1_type)
249                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
250            }
251        }
252        %typemap(in) const pair<T,U>& (std::pair<T,U> temp,
253                                       std::pair<T,U>* m),
254                     const pair<T,U>* (std::pair<T,U> temp,
255                                       std::pair<T,U>* m) {
256            if (SCHEME_PAIRP($input)) {
257                T* x;
258                Scheme_Object *first, *second;
259                first = scheme_car($input);
260                second = scheme_cdr($input);
261                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
262                if (!CHECK(second))
263                    SWIG_exception(SWIG_TypeError,
264                                   "pair<" #T "," #U "> expected");
265                temp = std::make_pair(*x,CONVERT_FROM(second));
266                $1 = &temp;
267            } else {
268                $1 = ($1_ltype)
269                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
270            }
271        }
272        %typemap(out) pair<T,U> {
273            T* x = new T($1.first);
274            Scheme_Object* first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
275            $result = scheme_make_pair(first,CONVERT_TO($1.second));
276        }
277        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
278            /* native pair? */
279            if (SCHEME_PAIRP($input)) {
280                T* x;
281                Scheme_Object* first = scheme_car($input);
282                Scheme_Object* second = scheme_cdr($input);
283                if (SWIG_ConvertPtr(first,(void**) &x,
284                                    $descriptor(T *), 0) != -1 &&
285                    CHECK(second)) {
286                        $1 = 1;
287                } else {
288                    $1 = 0;
289                }
290            } else {
291                /* wrapped pair? */
292                std::pair<T,U >* p;
293                if (SWIG_ConvertPtr($input,(void **) &p,
294                                    $&1_descriptor, 0) != -1)
295                    $1 = 1;
296                else
297                    $1 = 0;
298            }
299        }
300        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
301                                        const pair<T,U>* {
302            /* native pair? */
303            if (SCHEME_PAIRP($input)) {
304                T* x;
305                Scheme_Object* first = scheme_car($input);
306                Scheme_Object* second = scheme_cdr($input);
307                if (SWIG_ConvertPtr(first,(void**) &x,
308                                    $descriptor(T *), 0) != -1 &&
309                    CHECK(second)) {
310                        $1 = 1;
311                } else {
312                    $1 = 0;
313                }
314            } else {
315                /* wrapped pair? */
316                std::pair<T,U >* p;
317                if (SWIG_ConvertPtr($input,(void **) &p,
318                                    $1_descriptor, 0) != -1)
319                    $1 = 1;
320                else
321                    $1 = 0;
322            }
323        }
324        pair();
325        pair(T first, U second);
326        pair(const pair& p);
327
328        template <class U1, class U2> pair(const pair<U1, U2> &p);
329
330        T first;
331        U second;
332    };
333    %enddef
334
335    %define specialize_std_pair_on_both(T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO,
336                                        U,CHECK_U,CONVERT_U_FROM,CONVERT_U_TO)
337    template<> struct pair<T,U> {
338        %typemap(in) pair<T,U> (std::pair<T,U>* m) {
339            if (SCHEME_PAIRP($input)) {
340                Scheme_Object *first, *second;
341                first = scheme_car($input);
342                second = scheme_cdr($input);
343                if (!CHECK_T(first) || !CHECK_U(second))
344                    SWIG_exception(SWIG_TypeError,
345                                   "pair<" #T "," #U "> expected");
346                $1 = make_pair(CONVERT_T_FROM(first),
347                               CONVERT_U_FROM(second));
348            } else {
349                $1 = *(($&1_type)
350                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
351            }
352        }
353        %typemap(in) const pair<T,U>& (std::pair<T,U> temp,
354                                       std::pair<T,U>* m),
355                     const pair<T,U>* (std::pair<T,U> temp,
356                                       std::pair<T,U>* m) {
357            if (SCHEME_PAIRP($input)) {
358                Scheme_Object *first, *second;
359            T *x;
360                first = scheme_car($input);
361                second = scheme_cdr($input);
362                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
363                if (!CHECK_T(first) || !CHECK_U(second))
364                    SWIG_exception(SWIG_TypeError,
365                                   "pair<" #T "," #U "> expected");
366                temp = make_pair(CONVERT_T_FROM(first),
367                               CONVERT_U_FROM(second));
368                $1 = &temp;
369            } else {
370                $1 = ($1_ltype)
371                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
372            }
373        }
374        %typemap(out) pair<T,U> {
375            $result = scheme_make_pair(CONVERT_T_TO($1.first),
376                                       CONVERT_U_TO($1.second));
377        }
378        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
379            /* native pair? */
380            if (SCHEME_PAIRP($input)) {
381                Scheme_Object* first = scheme_car($input);
382                Scheme_Object* second = scheme_cdr($input);
383                if (CHECK_T(first) && CHECK_U(second)) {
384                        $1 = 1;
385                } else {
386                    $1 = 0;
387                }
388            } else {
389                /* wrapped pair? */
390                std::pair<T,U >* p;
391                if (SWIG_ConvertPtr($input,(void **) &p,
392                                    $&1_descriptor, 0) != -1)
393                    $1 = 1;
394                else
395                    $1 = 0;
396            }
397        }
398        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
399                                        const pair<T,U>* {
400            /* native pair? */
401            if (SCHEME_PAIRP($input)) {
402                Scheme_Object* first = scheme_car($input);
403                Scheme_Object* second = scheme_cdr($input);
404                if (CHECK_T(first) && CHECK_U(second)) {
405                        $1 = 1;
406                } else {
407                    $1 = 0;
408                }
409            } else {
410                /* wrapped pair? */
411                std::pair<T,U >* p;
412                if (SWIG_ConvertPtr($input,(void **) &p,
413                                    $1_descriptor, 0) != -1)
414                    $1 = 1;
415                else
416                    $1 = 0;
417            }
418        }
419        pair();
420        pair(T first, U second);
421        pair(const pair& p);
422
423        template <class U1, class U2> pair(const pair<U1, U2> &p);
424
425        T first;
426        U second;
427    };
428    %enddef
429
430
431    specialize_std_pair_on_first(bool,SCHEME_BOOLP,
432                              SCHEME_TRUEP,swig_make_boolean);
433    specialize_std_pair_on_first(int,SCHEME_INTP,
434                              SCHEME_INT_VAL,scheme_make_integer_value);
435    specialize_std_pair_on_first(short,SCHEME_INTP,
436                              SCHEME_INT_VAL,scheme_make_integer_value);
437    specialize_std_pair_on_first(long,SCHEME_INTP,
438                              SCHEME_INT_VAL,scheme_make_integer_value);
439    specialize_std_pair_on_first(unsigned int,SCHEME_INTP,
440                              SCHEME_INT_VAL,scheme_make_integer_value);
441    specialize_std_pair_on_first(unsigned short,SCHEME_INTP,
442                              SCHEME_INT_VAL,scheme_make_integer_value);
443    specialize_std_pair_on_first(unsigned long,SCHEME_INTP,
444                              SCHEME_INT_VAL,scheme_make_integer_value);
445    specialize_std_pair_on_first(double,SCHEME_REALP,
446                              scheme_real_to_double,scheme_make_double);
447    specialize_std_pair_on_first(float,SCHEME_REALP,
448                              scheme_real_to_double,scheme_make_double);
449    specialize_std_pair_on_first(std::string,SCHEME_STRINGP,
450                              swig_scm_to_string,swig_make_string);
451
452    specialize_std_pair_on_second(bool,SCHEME_BOOLP,
453                                SCHEME_TRUEP,swig_make_boolean);
454    specialize_std_pair_on_second(int,SCHEME_INTP,
455                                SCHEME_INT_VAL,scheme_make_integer_value);
456    specialize_std_pair_on_second(short,SCHEME_INTP,
457                                SCHEME_INT_VAL,scheme_make_integer_value);
458    specialize_std_pair_on_second(long,SCHEME_INTP,
459                                SCHEME_INT_VAL,scheme_make_integer_value);
460    specialize_std_pair_on_second(unsigned int,SCHEME_INTP,
461                                SCHEME_INT_VAL,scheme_make_integer_value);
462    specialize_std_pair_on_second(unsigned short,SCHEME_INTP,
463                                SCHEME_INT_VAL,scheme_make_integer_value);
464    specialize_std_pair_on_second(unsigned long,SCHEME_INTP,
465                                SCHEME_INT_VAL,scheme_make_integer_value);
466    specialize_std_pair_on_second(double,SCHEME_REALP,
467                                scheme_real_to_double,scheme_make_double);
468    specialize_std_pair_on_second(float,SCHEME_REALP,
469                                scheme_real_to_double,scheme_make_double);
470    specialize_std_pair_on_second(std::string,SCHEME_STRINGP,
471                                swig_scm_to_string,swig_make_string);
472
473    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
474                               SCHEME_TRUEP,swig_make_boolean,
475                               bool,SCHEME_BOOLP,
476                               SCHEME_TRUEP,swig_make_boolean);
477    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
478                               SCHEME_TRUEP,swig_make_boolean,
479                               int,SCHEME_INTP,
480                               SCHEME_INT_VAL,scheme_make_integer_value);
481    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
482                               SCHEME_TRUEP,swig_make_boolean,
483                               short,SCHEME_INTP,
484                               SCHEME_INT_VAL,scheme_make_integer_value);
485    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
486                               SCHEME_TRUEP,swig_make_boolean,
487                               long,SCHEME_INTP,
488                               SCHEME_INT_VAL,scheme_make_integer_value);
489    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
490                               SCHEME_TRUEP,swig_make_boolean,
491                               unsigned int,SCHEME_INTP,
492                               SCHEME_INT_VAL,scheme_make_integer_value);
493    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
494                               SCHEME_TRUEP,swig_make_boolean,
495                               unsigned short,SCHEME_INTP,
496                               SCHEME_INT_VAL,scheme_make_integer_value);
497    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
498                               SCHEME_TRUEP,swig_make_boolean,
499                               unsigned long,SCHEME_INTP,
500                               SCHEME_INT_VAL,scheme_make_integer_value);
501    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
502                               SCHEME_TRUEP,swig_make_boolean,
503                               double,SCHEME_REALP,
504                               scheme_real_to_double,scheme_make_double);
505    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
506                               SCHEME_TRUEP,swig_make_boolean,
507                               float,SCHEME_REALP,
508                               scheme_real_to_double,scheme_make_double);
509    specialize_std_pair_on_both(bool,SCHEME_BOOLP,
510                               SCHEME_TRUEP,swig_make_boolean,
511                               std::string,SCHEME_STRINGP,
512                               swig_scm_to_string,swig_make_string);
513    specialize_std_pair_on_both(int,SCHEME_INTP,
514                               SCHEME_INT_VAL,scheme_make_integer_value,
515                               bool,SCHEME_BOOLP,
516                               SCHEME_TRUEP,swig_make_boolean);
517    specialize_std_pair_on_both(int,SCHEME_INTP,
518                               SCHEME_INT_VAL,scheme_make_integer_value,
519                               int,SCHEME_INTP,
520                               SCHEME_INT_VAL,scheme_make_integer_value);
521    specialize_std_pair_on_both(int,SCHEME_INTP,
522                               SCHEME_INT_VAL,scheme_make_integer_value,
523                               short,SCHEME_INTP,
524                               SCHEME_INT_VAL,scheme_make_integer_value);
525    specialize_std_pair_on_both(int,SCHEME_INTP,
526                               SCHEME_INT_VAL,scheme_make_integer_value,
527                               long,SCHEME_INTP,
528                               SCHEME_INT_VAL,scheme_make_integer_value);
529    specialize_std_pair_on_both(int,SCHEME_INTP,
530                               SCHEME_INT_VAL,scheme_make_integer_value,
531                               unsigned int,SCHEME_INTP,
532                               SCHEME_INT_VAL,scheme_make_integer_value);
533    specialize_std_pair_on_both(int,SCHEME_INTP,
534                               SCHEME_INT_VAL,scheme_make_integer_value,
535                               unsigned short,SCHEME_INTP,
536                               SCHEME_INT_VAL,scheme_make_integer_value);
537    specialize_std_pair_on_both(int,SCHEME_INTP,
538                               SCHEME_INT_VAL,scheme_make_integer_value,
539                               unsigned long,SCHEME_INTP,
540                               SCHEME_INT_VAL,scheme_make_integer_value);
541    specialize_std_pair_on_both(int,SCHEME_INTP,
542                               SCHEME_INT_VAL,scheme_make_integer_value,
543                               double,SCHEME_REALP,
544                               scheme_real_to_double,scheme_make_double);
545    specialize_std_pair_on_both(int,SCHEME_INTP,
546                               SCHEME_INT_VAL,scheme_make_integer_value,
547                               float,SCHEME_REALP,
548                               scheme_real_to_double,scheme_make_double);
549    specialize_std_pair_on_both(int,SCHEME_INTP,
550                               SCHEME_INT_VAL,scheme_make_integer_value,
551                               std::string,SCHEME_STRINGP,
552                               swig_scm_to_string,swig_make_string);
553    specialize_std_pair_on_both(short,SCHEME_INTP,
554                               SCHEME_INT_VAL,scheme_make_integer_value,
555                               bool,SCHEME_BOOLP,
556                               SCHEME_TRUEP,swig_make_boolean);
557    specialize_std_pair_on_both(short,SCHEME_INTP,
558                               SCHEME_INT_VAL,scheme_make_integer_value,
559                               int,SCHEME_INTP,
560                               SCHEME_INT_VAL,scheme_make_integer_value);
561    specialize_std_pair_on_both(short,SCHEME_INTP,
562                               SCHEME_INT_VAL,scheme_make_integer_value,
563                               short,SCHEME_INTP,
564                               SCHEME_INT_VAL,scheme_make_integer_value);
565    specialize_std_pair_on_both(short,SCHEME_INTP,
566                               SCHEME_INT_VAL,scheme_make_integer_value,
567                               long,SCHEME_INTP,
568                               SCHEME_INT_VAL,scheme_make_integer_value);
569    specialize_std_pair_on_both(short,SCHEME_INTP,
570                               SCHEME_INT_VAL,scheme_make_integer_value,
571                               unsigned int,SCHEME_INTP,
572                               SCHEME_INT_VAL,scheme_make_integer_value);
573    specialize_std_pair_on_both(short,SCHEME_INTP,
574                               SCHEME_INT_VAL,scheme_make_integer_value,
575                               unsigned short,SCHEME_INTP,
576                               SCHEME_INT_VAL,scheme_make_integer_value);
577    specialize_std_pair_on_both(short,SCHEME_INTP,
578                               SCHEME_INT_VAL,scheme_make_integer_value,
579                               unsigned long,SCHEME_INTP,
580                               SCHEME_INT_VAL,scheme_make_integer_value);
581    specialize_std_pair_on_both(short,SCHEME_INTP,
582                               SCHEME_INT_VAL,scheme_make_integer_value,
583                               double,SCHEME_REALP,
584                               scheme_real_to_double,scheme_make_double);
585    specialize_std_pair_on_both(short,SCHEME_INTP,
586                               SCHEME_INT_VAL,scheme_make_integer_value,
587                               float,SCHEME_REALP,
588                               scheme_real_to_double,scheme_make_double);
589    specialize_std_pair_on_both(short,SCHEME_INTP,
590                               SCHEME_INT_VAL,scheme_make_integer_value,
591                               std::string,SCHEME_STRINGP,
592                               swig_scm_to_string,swig_make_string);
593    specialize_std_pair_on_both(long,SCHEME_INTP,
594                               SCHEME_INT_VAL,scheme_make_integer_value,
595                               bool,SCHEME_BOOLP,
596                               SCHEME_TRUEP,swig_make_boolean);
597    specialize_std_pair_on_both(long,SCHEME_INTP,
598                               SCHEME_INT_VAL,scheme_make_integer_value,
599                               int,SCHEME_INTP,
600                               SCHEME_INT_VAL,scheme_make_integer_value);
601    specialize_std_pair_on_both(long,SCHEME_INTP,
602                               SCHEME_INT_VAL,scheme_make_integer_value,
603                               short,SCHEME_INTP,
604                               SCHEME_INT_VAL,scheme_make_integer_value);
605    specialize_std_pair_on_both(long,SCHEME_INTP,
606                               SCHEME_INT_VAL,scheme_make_integer_value,
607                               long,SCHEME_INTP,
608                               SCHEME_INT_VAL,scheme_make_integer_value);
609    specialize_std_pair_on_both(long,SCHEME_INTP,
610                               SCHEME_INT_VAL,scheme_make_integer_value,
611                               unsigned int,SCHEME_INTP,
612                               SCHEME_INT_VAL,scheme_make_integer_value);
613    specialize_std_pair_on_both(long,SCHEME_INTP,
614                               SCHEME_INT_VAL,scheme_make_integer_value,
615                               unsigned short,SCHEME_INTP,
616                               SCHEME_INT_VAL,scheme_make_integer_value);
617    specialize_std_pair_on_both(long,SCHEME_INTP,
618                               SCHEME_INT_VAL,scheme_make_integer_value,
619                               unsigned long,SCHEME_INTP,
620                               SCHEME_INT_VAL,scheme_make_integer_value);
621    specialize_std_pair_on_both(long,SCHEME_INTP,
622                               SCHEME_INT_VAL,scheme_make_integer_value,
623                               double,SCHEME_REALP,
624                               scheme_real_to_double,scheme_make_double);
625    specialize_std_pair_on_both(long,SCHEME_INTP,
626                               SCHEME_INT_VAL,scheme_make_integer_value,
627                               float,SCHEME_REALP,
628                               scheme_real_to_double,scheme_make_double);
629    specialize_std_pair_on_both(long,SCHEME_INTP,
630                               SCHEME_INT_VAL,scheme_make_integer_value,
631                               std::string,SCHEME_STRINGP,
632                               swig_scm_to_string,swig_make_string);
633    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
634                               SCHEME_INT_VAL,scheme_make_integer_value,
635                               bool,SCHEME_BOOLP,
636                               SCHEME_TRUEP,swig_make_boolean);
637    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
638                               SCHEME_INT_VAL,scheme_make_integer_value,
639                               int,SCHEME_INTP,
640                               SCHEME_INT_VAL,scheme_make_integer_value);
641    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
642                               SCHEME_INT_VAL,scheme_make_integer_value,
643                               short,SCHEME_INTP,
644                               SCHEME_INT_VAL,scheme_make_integer_value);
645    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
646                               SCHEME_INT_VAL,scheme_make_integer_value,
647                               long,SCHEME_INTP,
648                               SCHEME_INT_VAL,scheme_make_integer_value);
649    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
650                               SCHEME_INT_VAL,scheme_make_integer_value,
651                               unsigned int,SCHEME_INTP,
652                               SCHEME_INT_VAL,scheme_make_integer_value);
653    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
654                               SCHEME_INT_VAL,scheme_make_integer_value,
655                               unsigned short,SCHEME_INTP,
656                               SCHEME_INT_VAL,scheme_make_integer_value);
657    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
658                               SCHEME_INT_VAL,scheme_make_integer_value,
659                               unsigned long,SCHEME_INTP,
660                               SCHEME_INT_VAL,scheme_make_integer_value);
661    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
662                               SCHEME_INT_VAL,scheme_make_integer_value,
663                               double,SCHEME_REALP,
664                               scheme_real_to_double,scheme_make_double);
665    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
666                               SCHEME_INT_VAL,scheme_make_integer_value,
667                               float,SCHEME_REALP,
668                               scheme_real_to_double,scheme_make_double);
669    specialize_std_pair_on_both(unsigned int,SCHEME_INTP,
670                               SCHEME_INT_VAL,scheme_make_integer_value,
671                               std::string,SCHEME_STRINGP,
672                               swig_scm_to_string,swig_make_string);
673    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
674                               SCHEME_INT_VAL,scheme_make_integer_value,
675                               bool,SCHEME_BOOLP,
676                               SCHEME_TRUEP,swig_make_boolean);
677    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
678                               SCHEME_INT_VAL,scheme_make_integer_value,
679                               int,SCHEME_INTP,
680                               SCHEME_INT_VAL,scheme_make_integer_value);
681    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
682                               SCHEME_INT_VAL,scheme_make_integer_value,
683                               short,SCHEME_INTP,
684                               SCHEME_INT_VAL,scheme_make_integer_value);
685    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
686                               SCHEME_INT_VAL,scheme_make_integer_value,
687                               long,SCHEME_INTP,
688                               SCHEME_INT_VAL,scheme_make_integer_value);
689    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
690                               SCHEME_INT_VAL,scheme_make_integer_value,
691                               unsigned int,SCHEME_INTP,
692                               SCHEME_INT_VAL,scheme_make_integer_value);
693    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
694                               SCHEME_INT_VAL,scheme_make_integer_value,
695                               unsigned short,SCHEME_INTP,
696                               SCHEME_INT_VAL,scheme_make_integer_value);
697    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
698                               SCHEME_INT_VAL,scheme_make_integer_value,
699                               unsigned long,SCHEME_INTP,
700                               SCHEME_INT_VAL,scheme_make_integer_value);
701    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
702                               SCHEME_INT_VAL,scheme_make_integer_value,
703                               double,SCHEME_REALP,
704                               scheme_real_to_double,scheme_make_double);
705    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
706                               SCHEME_INT_VAL,scheme_make_integer_value,
707                               float,SCHEME_REALP,
708                               scheme_real_to_double,scheme_make_double);
709    specialize_std_pair_on_both(unsigned short,SCHEME_INTP,
710                               SCHEME_INT_VAL,scheme_make_integer_value,
711                               std::string,SCHEME_STRINGP,
712                               swig_scm_to_string,swig_make_string);
713    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
714                               SCHEME_INT_VAL,scheme_make_integer_value,
715                               bool,SCHEME_BOOLP,
716                               SCHEME_TRUEP,swig_make_boolean);
717    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
718                               SCHEME_INT_VAL,scheme_make_integer_value,
719                               int,SCHEME_INTP,
720                               SCHEME_INT_VAL,scheme_make_integer_value);
721    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
722                               SCHEME_INT_VAL,scheme_make_integer_value,
723                               short,SCHEME_INTP,
724                               SCHEME_INT_VAL,scheme_make_integer_value);
725    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
726                               SCHEME_INT_VAL,scheme_make_integer_value,
727                               long,SCHEME_INTP,
728                               SCHEME_INT_VAL,scheme_make_integer_value);
729    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
730                               SCHEME_INT_VAL,scheme_make_integer_value,
731                               unsigned int,SCHEME_INTP,
732                               SCHEME_INT_VAL,scheme_make_integer_value);
733    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
734                               SCHEME_INT_VAL,scheme_make_integer_value,
735                               unsigned short,SCHEME_INTP,
736                               SCHEME_INT_VAL,scheme_make_integer_value);
737    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
738                               SCHEME_INT_VAL,scheme_make_integer_value,
739                               unsigned long,SCHEME_INTP,
740                               SCHEME_INT_VAL,scheme_make_integer_value);
741    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
742                               SCHEME_INT_VAL,scheme_make_integer_value,
743                               double,SCHEME_REALP,
744                               scheme_real_to_double,scheme_make_double);
745    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
746                               SCHEME_INT_VAL,scheme_make_integer_value,
747                               float,SCHEME_REALP,
748                               scheme_real_to_double,scheme_make_double);
749    specialize_std_pair_on_both(unsigned long,SCHEME_INTP,
750                               SCHEME_INT_VAL,scheme_make_integer_value,
751                               std::string,SCHEME_STRINGP,
752                               swig_scm_to_string,swig_make_string);
753    specialize_std_pair_on_both(double,SCHEME_REALP,
754                               scheme_real_to_double,scheme_make_double,
755                               bool,SCHEME_BOOLP,
756                               SCHEME_TRUEP,swig_make_boolean);
757    specialize_std_pair_on_both(double,SCHEME_REALP,
758                               scheme_real_to_double,scheme_make_double,
759                               int,SCHEME_INTP,
760                               SCHEME_INT_VAL,scheme_make_integer_value);
761    specialize_std_pair_on_both(double,SCHEME_REALP,
762                               scheme_real_to_double,scheme_make_double,
763                               short,SCHEME_INTP,
764                               SCHEME_INT_VAL,scheme_make_integer_value);
765    specialize_std_pair_on_both(double,SCHEME_REALP,
766                               scheme_real_to_double,scheme_make_double,
767                               long,SCHEME_INTP,
768                               SCHEME_INT_VAL,scheme_make_integer_value);
769    specialize_std_pair_on_both(double,SCHEME_REALP,
770                               scheme_real_to_double,scheme_make_double,
771                               unsigned int,SCHEME_INTP,
772                               SCHEME_INT_VAL,scheme_make_integer_value);
773    specialize_std_pair_on_both(double,SCHEME_REALP,
774                               scheme_real_to_double,scheme_make_double,
775                               unsigned short,SCHEME_INTP,
776                               SCHEME_INT_VAL,scheme_make_integer_value);
777    specialize_std_pair_on_both(double,SCHEME_REALP,
778                               scheme_real_to_double,scheme_make_double,
779                               unsigned long,SCHEME_INTP,
780                               SCHEME_INT_VAL,scheme_make_integer_value);
781    specialize_std_pair_on_both(double,SCHEME_REALP,
782                               scheme_real_to_double,scheme_make_double,
783                               double,SCHEME_REALP,
784                               scheme_real_to_double,scheme_make_double);
785    specialize_std_pair_on_both(double,SCHEME_REALP,
786                               scheme_real_to_double,scheme_make_double,
787                               float,SCHEME_REALP,
788                               scheme_real_to_double,scheme_make_double);
789    specialize_std_pair_on_both(double,SCHEME_REALP,
790                               scheme_real_to_double,scheme_make_double,
791                               std::string,SCHEME_STRINGP,
792                               swig_scm_to_string,swig_make_string);
793    specialize_std_pair_on_both(float,SCHEME_REALP,
794                               scheme_real_to_double,scheme_make_double,
795                               bool,SCHEME_BOOLP,
796                               SCHEME_TRUEP,swig_make_boolean);
797    specialize_std_pair_on_both(float,SCHEME_REALP,
798                               scheme_real_to_double,scheme_make_double,
799                               int,SCHEME_INTP,
800                               SCHEME_INT_VAL,scheme_make_integer_value);
801    specialize_std_pair_on_both(float,SCHEME_REALP,
802                               scheme_real_to_double,scheme_make_double,
803                               short,SCHEME_INTP,
804                               SCHEME_INT_VAL,scheme_make_integer_value);
805    specialize_std_pair_on_both(float,SCHEME_REALP,
806                               scheme_real_to_double,scheme_make_double,
807                               long,SCHEME_INTP,
808                               SCHEME_INT_VAL,scheme_make_integer_value);
809    specialize_std_pair_on_both(float,SCHEME_REALP,
810                               scheme_real_to_double,scheme_make_double,
811                               unsigned int,SCHEME_INTP,
812                               SCHEME_INT_VAL,scheme_make_integer_value);
813    specialize_std_pair_on_both(float,SCHEME_REALP,
814                               scheme_real_to_double,scheme_make_double,
815                               unsigned short,SCHEME_INTP,
816                               SCHEME_INT_VAL,scheme_make_integer_value);
817    specialize_std_pair_on_both(float,SCHEME_REALP,
818                               scheme_real_to_double,scheme_make_double,
819                               unsigned long,SCHEME_INTP,
820                               SCHEME_INT_VAL,scheme_make_integer_value);
821    specialize_std_pair_on_both(float,SCHEME_REALP,
822                               scheme_real_to_double,scheme_make_double,
823                               double,SCHEME_REALP,
824                               scheme_real_to_double,scheme_make_double);
825    specialize_std_pair_on_both(float,SCHEME_REALP,
826                               scheme_real_to_double,scheme_make_double,
827                               float,SCHEME_REALP,
828                               scheme_real_to_double,scheme_make_double);
829    specialize_std_pair_on_both(float,SCHEME_REALP,
830                               scheme_real_to_double,scheme_make_double,
831                               std::string,SCHEME_STRINGP,
832                               swig_scm_to_string,swig_make_string);
833    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
834                               swig_scm_to_string,swig_make_string,
835                               bool,SCHEME_BOOLP,
836                               SCHEME_TRUEP,swig_make_boolean);
837    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
838                               swig_scm_to_string,swig_make_string,
839                               int,SCHEME_INTP,
840                               SCHEME_INT_VAL,scheme_make_integer_value);
841    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
842                               swig_scm_to_string,swig_make_string,
843                               short,SCHEME_INTP,
844                               SCHEME_INT_VAL,scheme_make_integer_value);
845    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
846                               swig_scm_to_string,swig_make_string,
847                               long,SCHEME_INTP,
848                               SCHEME_INT_VAL,scheme_make_integer_value);
849    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
850                               swig_scm_to_string,swig_make_string,
851                               unsigned int,SCHEME_INTP,
852                               SCHEME_INT_VAL,scheme_make_integer_value);
853    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
854                               swig_scm_to_string,swig_make_string,
855                               unsigned short,SCHEME_INTP,
856                               SCHEME_INT_VAL,scheme_make_integer_value);
857    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
858                               swig_scm_to_string,swig_make_string,
859                               unsigned long,SCHEME_INTP,
860                               SCHEME_INT_VAL,scheme_make_integer_value);
861    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
862                               swig_scm_to_string,swig_make_string,
863                               double,SCHEME_REALP,
864                               scheme_real_to_double,scheme_make_double);
865    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
866                               swig_scm_to_string,swig_make_string,
867                               float,SCHEME_REALP,
868                               scheme_real_to_double,scheme_make_double);
869    specialize_std_pair_on_both(std::string,SCHEME_STRINGP,
870                               swig_scm_to_string,swig_make_string,
871                               std::string,SCHEME_STRINGP,
872                               swig_scm_to_string,swig_make_string);
873}
874