Lib/mzscheme/std_pair.i

   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
  26 namespace 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 }