Lib/mzscheme/std_map.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_map.i
   6  *
   7  * SWIG typemaps for std::map
   8  * ----------------------------------------------------------------------------- */
   9
  10 %include <std_common.i>
  11
  12 // ------------------------------------------------------------------------
  13 // std::map
  14 //
  15 // The aim of all that follows would be to integrate std::map with
  16 // MzScheme as much as possible, namely, to allow the user to pass and
  17 // be returned Scheme association lists.
  18 // const declarations are used to guess the intent of the function being
  19 // exported; therefore, the following rationale is applied:
  20 //
  21 //   -- f(std::map<T>), f(const std::map<T>&), f(const std::map<T>*):
  22 //      the parameter being read-only, either a Scheme alist or a
  23 //      previously wrapped std::map<T> can be passed.
  24 //   -- f(std::map<T>&), f(std::map<T>*):
  25 //      the parameter must be modified; therefore, only a wrapped std::map
  26 //      can be passed.
  27 //   -- std::map<T> f():
  28 //      the map is returned by copy; therefore, a Scheme alist
  29 //      is returned which is most easily used in other Scheme functions
  30 //   -- std::map<T>& f(), std::map<T>* f(), const std::map<T>& f(),
  31 //      const std::map<T>* f():
  32 //      the map is returned by reference; therefore, a wrapped std::map
  33 //      is returned
  34 // ------------------------------------------------------------------------
  35
  36 %{
  37 #include <map>
  38 #include <algorithm>
  39 #include <stdexcept>
  40 %}
  41
  42 // exported class
  43
  44 namespace std {
  45
  46     template<class K, class T> class map {
  47         %typemap(in) map<K,T> (std::map<K,T>* m) {
  48             if (SCHEME_NULLP($input)) {
  49                 $1 = std::map<K,T >();
  50             } else if (SCHEME_PAIRP($input)) {
  51                 $1 = std::map<K,T >();
  52                 Scheme_Object* alist = $input;
  53                 while (!SCHEME_NULLP(alist)) {
  54                     K* k;
  55                     T* x;
  56                     Scheme_Object *entry, *key, *val;
  57                     entry = scheme_car(alist);
  58                     if (!SCHEME_PAIRP(entry))
  59                         SWIG_exception(SWIG_TypeError,"alist expected");
  60                     key = scheme_car(entry);
  61                     val = scheme_cdr(entry);
  62                     k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
  63                     if (SWIG_ConvertPtr(val,(void**) &x,
  64                                     $descriptor(T *), 0) == -1) {
  65                         if (!SCHEME_PAIRP(val))
  66                             SWIG_exception(SWIG_TypeError,"alist expected");
  67                         val = scheme_car(val);
  68                         x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
  69                     }
  70                     (($1_type &)$1)[*k] = *x;
  71                     alist = scheme_cdr(alist);
  72                 }
  73             } else {
  74                 $1 = *(($&1_type)
  75                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
  76             }
  77         }
  78         %typemap(in) const map<K,T>& (std::map<K,T> temp,
  79                                       std::map<K,T>* m),
  80                      const map<K,T>* (std::map<K,T> temp,
  81                                       std::map<K,T>* m) {
  82             if (SCHEME_NULLP($input)) {
  83                 temp = std::map<K,T >();
  84                 $1 = &temp;
  85             } else if (SCHEME_PAIRP($input)) {
  86                 temp = std::map<K,T >();
  87                 $1 = &temp;
  88                 Scheme_Object* alist = $input;
  89                 while (!SCHEME_NULLP(alist)) {
  90                     K* k;
  91                     T* x;
  92                     Scheme_Object *entry, *key, *val;
  93                     entry = scheme_car(alist);
  94                     if (!SCHEME_PAIRP(entry))
  95                         SWIG_exception(SWIG_TypeError,"alist expected");
  96                     key = scheme_car(entry);
  97                     val = scheme_cdr(entry);
  98                     k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
  99                     if (SWIG_ConvertPtr(val,(void**) &x,
 100                                     $descriptor(T *), 0) == -1) {
 101                         if (!SCHEME_PAIRP(val))
 102                             SWIG_exception(SWIG_TypeError,"alist expected");
 103                         val = scheme_car(val);
 104                         x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
 105                     }
 106                     temp[*k] = *x;
 107                     alist = scheme_cdr(alist);
 108                 }
 109             } else {
 110                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
 111             }
 112         }
 113         %typemap(out) map<K,T> {
 114             Scheme_Object* alist = scheme_null;
 115             for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 116                                                   i!=$1.rend(); ++i) {
 117                 K* key = new K(i->first);
 118                 T* val = new T(i->second);
 119                 Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
 120                 Scheme_Object* x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
 121                 Scheme_Object* entry = scheme_make_pair(k,x);
 122                 alist = scheme_make_pair(entry,alist);
 123             }
 124             $result = alist;
 125         }
 126         %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
 127             /* native sequence? */
 128             if (SCHEME_NULLP($input)) {
 129                 /* an empty sequence can be of any type */
 130                 $1 = 1;
 131             } else if (SCHEME_PAIRP($input)) {
 132                 /* check the first element only */
 133                 K* k;
 134                 T* x;
 135                 Scheme_Object* head = scheme_car($input);
 136                 if (SCHEME_PAIRP(head)) {
 137                     Scheme_Object* key = scheme_car(head);
 138                     Scheme_Object* val = scheme_cdr(head);
 139                     if (SWIG_ConvertPtr(key,(void**) &k,
 140                                     $descriptor(K *), 0) == -1) {
 141                         $1 = 0;
 142                     } else {
 143                         if (SWIG_ConvertPtr(val,(void**) &x,
 144                                         $descriptor(T *), 0) != -1) {
 145                             $1 = 1;
 146                         } else if (SCHEME_PAIRP(val)) {
 147                             val = scheme_car(val);
 148                             if (SWIG_ConvertPtr(val,(void**) &x,
 149                                             $descriptor(T *), 0) != -1)
 150                                 $1 = 1;
 151                             else
 152                                 $1 = 0;
 153                         } else {
 154                             $1 = 0;
 155                         }
 156                     }
 157                 } else {
 158                     $1 = 0;
 159                 }
 160             } else {
 161                 /* wrapped map? */
 162                 std::map<K,T >* m;
 163                 if (SWIG_ConvertPtr($input,(void **) &m,
 164                                 $&1_descriptor, 0) != -1)
 165                     $1 = 1;
 166                 else
 167                     $1 = 0;
 168             }
 169         }
 170         %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
 171                                        const map<K,T>* {
 172             /* native sequence? */
 173             if (SCHEME_NULLP($input)) {
 174                 /* an empty sequence can be of any type */
 175                 $1 = 1;
 176             } else if (SCHEME_PAIRP($input)) {
 177                 /* check the first element only */
 178                 K* k;
 179                 T* x;
 180                 Scheme_Object* head = scheme_car($input);
 181                 if (SCHEME_PAIRP(head)) {
 182                     Scheme_Object* key = scheme_car(head);
 183                     Scheme_Object* val = scheme_cdr(head);
 184                     if (SWIG_ConvertPtr(key,(void**) &k,
 185                                     $descriptor(K *), 0) == -1) {
 186                         $1 = 0;
 187                     } else {
 188                         if (SWIG_ConvertPtr(val,(void**) &x,
 189                                         $descriptor(T *), 0) != -1) {
 190                             $1 = 1;
 191                         } else if (SCHEME_PAIRP(val)) {
 192                             val = scheme_car(val);
 193                             if (SWIG_ConvertPtr(val,(void**) &x,
 194                                             $descriptor(T *), 0) != -1)
 195                                 $1 = 1;
 196                             else
 197                                 $1 = 0;
 198                         } else {
 199                             $1 = 0;
 200                         }
 201                     }
 202                 } else {
 203                     $1 = 0;
 204                 }
 205             } else {
 206                 /* wrapped map? */
 207                 std::map<K,T >* m;
 208                 if (SWIG_ConvertPtr($input,(void **) &m,
 209                                 $1_descriptor, 0) != -1)
 210                     $1 = 1;
 211                 else
 212                     $1 = 0;
 213             }
 214         }
 215         %rename("length") size;
 216         %rename("null?") empty;
 217         %rename("clear!") clear;
 218         %rename("ref") __getitem__;
 219         %rename("set!") __setitem__;
 220         %rename("delete!") __delitem__;
 221         %rename("has-key?") has_key;
 222       public:
 223         map();
 224         map(const map<K,T> &);
 225
 226         unsigned int size() const;
 227         bool empty() const;
 228         void clear();
 229         %extend {
 230             T& __getitem__(const K& key) throw (std::out_of_range) {
 231                 std::map<K,T >::iterator i = self->find(key);
 232                 if (i != self->end())
 233                     return i->second;
 234                 else
 235                     throw std::out_of_range("key not found");
 236             }
 237             void __setitem__(const K& key, const T& x) {
 238                 (*self)[key] = x;
 239             }
 240             void __delitem__(const K& key) throw (std::out_of_range) {
 241                 std::map<K,T >::iterator i = self->find(key);
 242                 if (i != self->end())
 243                     self->erase(i);
 244                 else
 245                     throw std::out_of_range("key not found");
 246             }
 247             bool has_key(const K& key) {
 248                 std::map<K,T >::iterator i = self->find(key);
 249                 return i != self->end();
 250             }
 251             Scheme_Object* keys() {
 252                 Scheme_Object* result = scheme_null;
 253                 for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 254                                                       i!=$1.rend(); ++i) {
 255                     K* key = new K(i->first);
 256                     Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
 257                     result = scheme_make_pair(k,result);
 258                 }
 259                 return result;
 260             }
 261         }
 262     };
 263
 264
 265     // specializations for built-ins
 266
 267     %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
 268
 269     template<class T> class map<K,T> {
 270         %typemap(in) map<K,T> (std::map<K,T>* m) {
 271             if (SCHEME_NULLP($input)) {
 272                 $1 = std::map<K,T >();
 273             } else if (SCHEME_PAIRP($input)) {
 274                 $1 = std::map<K,T >();
 275                 Scheme_Object* alist = $input;
 276                 while (!SCHEME_NULLP(alist)) {
 277                     T* x;
 278                     Scheme_Object *entry, *key, *val;
 279                     entry = scheme_car(alist);
 280                     if (!SCHEME_PAIRP(entry))
 281                         SWIG_exception(SWIG_TypeError,"alist expected");
 282                     key = scheme_car(entry);
 283                     val = scheme_cdr(entry);
 284                     if (!CHECK(key))
 285                         SWIG_exception(SWIG_TypeError,
 286                                        "map<" #K "," #T "> expected");
 287                     if (SWIG_ConvertPtr(val,(void**) &x,
 288                                     $descriptor(T *), 0) == -1) {
 289                         if (!SCHEME_PAIRP(val))
 290                             SWIG_exception(SWIG_TypeError,"alist expected");
 291                         val = scheme_car(val);
 292                         x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
 293                     }
 294                     (($1_type &)$1)[CONVERT_FROM(key)] = *x;
 295                     alist = scheme_cdr(alist);
 296                 }
 297             } else {
 298                 $1 = *(($&1_type)
 299                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
 300             }
 301         }
 302         %typemap(in) const map<K,T>& (std::map<K,T> temp,
 303                                       std::map<K,T>* m),
 304                      const map<K,T>* (std::map<K,T> temp,
 305                                       std::map<K,T>* m) {
 306             if (SCHEME_NULLP($input)) {
 307                 temp = std::map<K,T >();
 308                 $1 = &temp;
 309             } else if (SCHEME_PAIRP($input)) {
 310                 temp = std::map<K,T >();
 311                 $1 = &temp;
 312                 Scheme_Object* alist = $input;
 313                 while (!SCHEME_NULLP(alist)) {
 314                     T* x;
 315                     Scheme_Object *entry, *key, *val;
 316                     entry = scheme_car(alist);
 317                     if (!SCHEME_PAIRP(entry))
 318                         SWIG_exception(SWIG_TypeError,"alist expected");
 319                     key = scheme_car(entry);
 320                     val = scheme_cdr(entry);
 321                     if (!CHECK(key))
 322                         SWIG_exception(SWIG_TypeError,
 323                                        "map<" #K "," #T "> expected");
 324                     if (SWIG_ConvertPtr(val,(void**) &x,
 325                                     $descriptor(T *), 0) == -1) {
 326                         if (!SCHEME_PAIRP(val))
 327                             SWIG_exception(SWIG_TypeError,"alist expected");
 328                         val = scheme_car(val);
 329                         x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
 330                     }
 331                     temp[CONVERT_FROM(key)] = *x;
 332                     alist = scheme_cdr(alist);
 333                 }
 334             } else {
 335                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
 336             }
 337         }
 338         %typemap(out) map<K,T> {
 339             Scheme_Object* alist = scheme_null;
 340             for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 341                                                   i!=$1.rend(); ++i) {
 342                 T* val = new T(i->second);
 343                 Scheme_Object* k = CONVERT_TO(i->first);
 344                 Scheme_Object* x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
 345                 Scheme_Object* entry = scheme_make_pair(k,x);
 346                 alist = scheme_make_pair(entry,alist);
 347             }
 348             $result = alist;
 349         }
 350         %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
 351             // native sequence?
 352             if (SCHEME_NULLP($input)) {
 353                 /* an empty sequence can be of any type */
 354                 $1 = 1;
 355             } else if (SCHEME_PAIRP($input)) {
 356                 // check the first element only
 357                 T* x;
 358                 Scheme_Object* head = scheme_car($input);
 359                 if (SCHEME_PAIRP(head)) {
 360                     Scheme_Object* key = scheme_car(head);
 361                     Scheme_Object* val = scheme_cdr(head);
 362                     if (!CHECK(key)) {
 363                         $1 = 0;
 364                     } else {
 365                         if (SWIG_ConvertPtr(val,(void**) &x,
 366                                         $descriptor(T *), 0) != -1) {
 367                             $1 = 1;
 368                         } else if (SCHEME_PAIRP(val)) {
 369                             val = scheme_car(val);
 370                             if (SWIG_ConvertPtr(val,(void**) &x,
 371                                             $descriptor(T *), 0) != -1)
 372                                 $1 = 1;
 373                             else
 374                                 $1 = 0;
 375                         } else {
 376                             $1 = 0;
 377                         }
 378                     }
 379                 } else {
 380                     $1 = 0;
 381                 }
 382             } else {
 383                 // wrapped map?
 384                 std::map<K,T >* m;
 385                 if (SWIG_ConvertPtr($input,(void **) &m,
 386                                 $&1_descriptor, 0) != -1)
 387                     $1 = 1;
 388                 else
 389                     $1 = 0;
 390             }
 391         }
 392         %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
 393                                        const map<K,T>* {
 394             // native sequence?
 395             if (SCHEME_NULLP($input)) {
 396                 /* an empty sequence can be of any type */
 397                 $1 = 1;
 398             } else if (SCHEME_PAIRP($input)) {
 399                 // check the first element only
 400                 T* x;
 401                 Scheme_Object* head = scheme_car($input);
 402                 if (SCHEME_PAIRP(head)) {
 403                     Scheme_Object* key = scheme_car(head);
 404                     Scheme_Object* val = scheme_cdr(head);
 405                     if (!CHECK(key)) {
 406                         $1 = 0;
 407                     } else {
 408                         if (SWIG_ConvertPtr(val,(void**) &x,
 409                                         $descriptor(T *), 0) != -1) {
 410                             $1 = 1;
 411                         } else if (SCHEME_PAIRP(val)) {
 412                             val = scheme_car(val);
 413                             if (SWIG_ConvertPtr(val,(void**) &x,
 414                                             $descriptor(T *), 0) != -1)
 415                                 $1 = 1;
 416                             else
 417                                 $1 = 0;
 418                         } else {
 419                             $1 = 0;
 420                         }
 421                     }
 422                 } else {
 423                     $1 = 0;
 424                 }
 425             } else {
 426                 // wrapped map?
 427                 std::map<K,T >* m;
 428                 if (SWIG_ConvertPtr($input,(void **) &m,
 429                                 $1_descriptor, 0) != -1)
 430                     $1 = 1;
 431                 else
 432                     $1 = 0;
 433             }
 434         }
 435         %rename("length") size;
 436         %rename("null?") empty;
 437         %rename("clear!") clear;
 438         %rename("ref") __getitem__;
 439         %rename("set!") __setitem__;
 440         %rename("delete!") __delitem__;
 441         %rename("has-key?") has_key;
 442       public:
 443         map();
 444         map(const map<K,T> &);
 445
 446         unsigned int size() const;
 447         bool empty() const;
 448         void clear();
 449         %extend {
 450             T& __getitem__(K key) throw (std::out_of_range) {
 451                 std::map<K,T >::iterator i = self->find(key);
 452                 if (i != self->end())
 453                     return i->second;
 454                 else
 455                     throw std::out_of_range("key not found");
 456             }
 457             void __setitem__(K key, const T& x) {
 458                 (*self)[key] = x;
 459             }
 460             void __delitem__(K key) throw (std::out_of_range) {
 461                 std::map<K,T >::iterator i = self->find(key);
 462                 if (i != self->end())
 463                     self->erase(i);
 464                 else
 465                     throw std::out_of_range("key not found");
 466             }
 467             bool has_key(K key) {
 468                 std::map<K,T >::iterator i = self->find(key);
 469                 return i != self->end();
 470             }
 471             Scheme_Object* keys() {
 472                 Scheme_Object* result = scheme_null;
 473                 for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 474                                                       i!=$1.rend(); ++i) {
 475                     Scheme_Object* k = CONVERT_TO(i->first);
 476                     result = scheme_make_pair(k,result);
 477                 }
 478                 return result;
 479             }
 480         }
 481     };
 482     %enddef
 483
 484     %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
 485     template<class K> class map<K,T> {
 486         %typemap(in) map<K,T> (std::map<K,T>* m) {
 487             if (SCHEME_NULLP($input)) {
 488                 $1 = std::map<K,T >();
 489             } else if (SCHEME_PAIRP($input)) {
 490                 $1 = std::map<K,T >();
 491                 Scheme_Object* alist = $input;
 492                 while (!SCHEME_NULLP(alist)) {
 493                     K* k;
 494                     Scheme_Object *entry, *key, *val;
 495                     entry = scheme_car(alist);
 496                     if (!SCHEME_PAIRP(entry))
 497                         SWIG_exception(SWIG_TypeError,"alist expected");
 498                     key = scheme_car(entry);
 499                     val = scheme_cdr(entry);
 500                     k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
 501                     if (!CHECK(val)) {
 502                         if (!SCHEME_PAIRP(val))
 503                             SWIG_exception(SWIG_TypeError,"alist expected");
 504                         val = scheme_car(val);
 505                         if (!CHECK(val))
 506                             SWIG_exception(SWIG_TypeError,
 507                                            "map<" #K "," #T "> expected");
 508                     }
 509                     (($1_type &)$1)[*k] = CONVERT_FROM(val);
 510                     alist = scheme_cdr(alist);
 511                 }
 512             } else {
 513                 $1 = *(($&1_type)
 514                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
 515             }
 516         }
 517         %typemap(in) const map<K,T>& (std::map<K,T> temp,
 518                                       std::map<K,T>* m),
 519                      const map<K,T>* (std::map<K,T> temp,
 520                                       std::map<K,T>* m) {
 521             if (SCHEME_NULLP($input)) {
 522                 temp = std::map<K,T >();
 523                 $1 = &temp;
 524             } else if (SCHEME_PAIRP($input)) {
 525                 temp = std::map<K,T >();
 526                 $1 = &temp;
 527                 Scheme_Object* alist = $input;
 528                 while (!SCHEME_NULLP(alist)) {
 529                     K* k;
 530                     Scheme_Object *entry, *key, *val;
 531                     entry = scheme_car(alist);
 532                     if (!SCHEME_PAIRP(entry))
 533                         SWIG_exception(SWIG_TypeError,"alist expected");
 534                     key = scheme_car(entry);
 535                     val = scheme_cdr(entry);
 536                     k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
 537                     if (!CHECK(val)) {
 538                         if (!SCHEME_PAIRP(val))
 539                             SWIG_exception(SWIG_TypeError,"alist expected");
 540                         val = scheme_car(val);
 541                         if (!CHECK(val))
 542                             SWIG_exception(SWIG_TypeError,
 543                                            "map<" #K "," #T "> expected");
 544                     }
 545                     temp[*k] = CONVERT_FROM(val);
 546                     alist = scheme_cdr(alist);
 547                 }
 548             } else {
 549                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
 550             }
 551         }
 552         %typemap(out) map<K,T> {
 553             Scheme_Object* alist = scheme_null;
 554             for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 555                                                   i!=$1.rend(); ++i) {
 556                 K* key = new K(i->first);
 557                 Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
 558                 Scheme_Object* x = CONVERT_TO(i->second);
 559                 Scheme_Object* entry = scheme_make_pair(k,x);
 560                 alist = scheme_make_pair(entry,alist);
 561             }
 562             $result = alist;
 563         }
 564         %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
 565             // native sequence?
 566             if (SCHEME_NULLP($input)) {
 567                 /* an empty sequence can be of any type */
 568                 $1 = 1;
 569             } else if (SCHEME_PAIRP($input)) {
 570                 // check the first element only
 571                 K* k;
 572                 Scheme_Object* head = scheme_car($input);
 573                 if (SCHEME_PAIRP(head)) {
 574                     Scheme_Object* key = scheme_car(head);
 575                     Scheme_Object* val = scheme_cdr(head);
 576                     if (SWIG_ConvertPtr(val,(void **) &k,
 577                                     $descriptor(K *), 0) == -1) {
 578                         $1 = 0;
 579                     } else {
 580                         if (CHECK(val)) {
 581                             $1 = 1;
 582                         } else if (SCHEME_PAIRP(val)) {
 583                             val = scheme_car(val);
 584                             if (CHECK(val))
 585                                 $1 = 1;
 586                             else
 587                                 $1 = 0;
 588                         } else {
 589                             $1 = 0;
 590                         }
 591                     }
 592                 } else {
 593                     $1 = 0;
 594                 }
 595             } else {
 596                 // wrapped map?
 597                 std::map<K,T >* m;
 598                 if (SWIG_ConvertPtr($input,(void **) &m,
 599                                 $&1_descriptor, 0) != -1)
 600                     $1 = 1;
 601                 else
 602                     $1 = 0;
 603             }
 604         }
 605         %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
 606                                        const map<K,T>* {
 607             // native sequence?
 608             if (SCHEME_NULLP($input)) {
 609                 /* an empty sequence can be of any type */
 610                 $1 = 1;
 611             } else if (SCHEME_PAIRP($input)) {
 612                 // check the first element only
 613                 K* k;
 614                 Scheme_Object* head = scheme_car($input);
 615                 if (SCHEME_PAIRP(head)) {
 616                     Scheme_Object* key = scheme_car(head);
 617                     Scheme_Object* val = scheme_cdr(head);
 618                     if (SWIG_ConvertPtr(val,(void **) &k,
 619                                     $descriptor(K *), 0) == -1) {
 620                         $1 = 0;
 621                     } else {
 622                         if (CHECK(val)) {
 623                             $1 = 1;
 624                         } else if (SCHEME_PAIRP(val)) {
 625                             val = scheme_car(val);
 626                             if (CHECK(val))
 627                                 $1 = 1;
 628                             else
 629                                 $1 = 0;
 630                         } else {
 631                             $1 = 0;
 632                         }
 633                     }
 634                 } else {
 635                     $1 = 0;
 636                 }
 637             } else {
 638                 // wrapped map?
 639                 std::map<K,T >* m;
 640                 if (SWIG_ConvertPtr($input,(void **) &m,
 641                                 $1_descriptor, 0) != -1)
 642                     $1 = 1;
 643                 else
 644                     $1 = 0;
 645             }
 646         }
 647         %rename("length") size;
 648         %rename("null?") empty;
 649         %rename("clear!") clear;
 650         %rename("ref") __getitem__;
 651         %rename("set!") __setitem__;
 652         %rename("delete!") __delitem__;
 653         %rename("has-key?") has_key;
 654       public:
 655         map();
 656         map(const map<K,T> &);
 657
 658         unsigned int size() const;
 659         bool empty() const;
 660         void clear();
 661         %extend {
 662             T __getitem__(const K& key) throw (std::out_of_range) {
 663                 std::map<K,T >::iterator i = self->find(key);
 664                 if (i != self->end())
 665                     return i->second;
 666                 else
 667                     throw std::out_of_range("key not found");
 668             }
 669             void __setitem__(const K& key, T x) {
 670                 (*self)[key] = x;
 671             }
 672             void __delitem__(const K& key) throw (std::out_of_range) {
 673                 std::map<K,T >::iterator i = self->find(key);
 674                 if (i != self->end())
 675                     self->erase(i);
 676                 else
 677                     throw std::out_of_range("key not found");
 678             }
 679             bool has_key(const K& key) {
 680                 std::map<K,T >::iterator i = self->find(key);
 681                 return i != self->end();
 682             }
 683             Scheme_Object* keys() {
 684                 Scheme_Object* result = scheme_null;
 685                 for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 686                                                       i!=$1.rend(); ++i) {
 687                     K* key = new K(i->first);
 688                     Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
 689                     result = scheme_make_pair(k,result);
 690                 }
 691                 return result;
 692             }
 693         }
 694     };
 695     %enddef
 696
 697     %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
 698                                        T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
 699     template<> class map<K,T> {
 700         %typemap(in) map<K,T> (std::map<K,T>* m) {
 701             if (SCHEME_NULLP($input)) {
 702                 $1 = std::map<K,T >();
 703             } else if (SCHEME_PAIRP($input)) {
 704                 $1 = std::map<K,T >();
 705                 Scheme_Object* alist = $input;
 706                 while (!SCHEME_NULLP(alist)) {
 707                     Scheme_Object *entry, *key, *val;
 708                     entry = scheme_car(alist);
 709                     if (!SCHEME_PAIRP(entry))
 710                         SWIG_exception(SWIG_TypeError,"alist expected");
 711                     key = scheme_car(entry);
 712                     val = scheme_cdr(entry);
 713                     if (!CHECK_K(key))
 714                         SWIG_exception(SWIG_TypeError,
 715                                            "map<" #K "," #T "> expected");
 716                     if (!CHECK_T(val)) {
 717                         if (!SCHEME_PAIRP(val))
 718                             SWIG_exception(SWIG_TypeError,"alist expected");
 719                         val = scheme_car(val);
 720                         if (!CHECK_T(val))
 721                             SWIG_exception(SWIG_TypeError,
 722                                            "map<" #K "," #T "> expected");
 723                     }
 724                     (($1_type &)$1)[CONVERT_K_FROM(key)] =
 725                                                CONVERT_T_FROM(val);
 726                     alist = scheme_cdr(alist);
 727                 }
 728             } else {
 729                 $1 = *(($&1_type)
 730                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
 731             }
 732         }
 733         %typemap(in) const map<K,T>& (std::map<K,T> temp,
 734                                       std::map<K,T>* m),
 735                      const map<K,T>* (std::map<K,T> temp,
 736                                       std::map<K,T>* m) {
 737             if (SCHEME_NULLP($input)) {
 738                 temp = std::map<K,T >();
 739                 $1 = &temp;
 740             } else if (SCHEME_PAIRP($input)) {
 741                 temp = std::map<K,T >();
 742                 $1 = &temp;
 743                 Scheme_Object* alist = $input;
 744                 while (!SCHEME_NULLP(alist)) {
 745                     Scheme_Object *entry, *key, *val;
 746                     entry = scheme_car(alist);
 747                     if (!SCHEME_PAIRP(entry))
 748                         SWIG_exception(SWIG_TypeError,"alist expected");
 749                     key = scheme_car(entry);
 750                     val = scheme_cdr(entry);
 751                     if (!CHECK_K(key))
 752                         SWIG_exception(SWIG_TypeError,
 753                                            "map<" #K "," #T "> expected");
 754                     if (!CHECK_T(val)) {
 755                         if (!SCHEME_PAIRP(val))
 756                             SWIG_exception(SWIG_TypeError,"alist expected");
 757                         val = scheme_car(val);
 758                         if (!CHECK_T(val))
 759                             SWIG_exception(SWIG_TypeError,
 760                                            "map<" #K "," #T "> expected");
 761                     }
 762                     temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
 763                     alist = scheme_cdr(alist);
 764                 }
 765             } else {
 766                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
 767             }
 768         }
 769         %typemap(out) map<K,T> {
 770             Scheme_Object* alist = scheme_null;
 771             for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 772                                                   i!=$1.rend(); ++i) {
 773                 Scheme_Object* k = CONVERT_K_TO(i->first);
 774                 Scheme_Object* x = CONVERT_T_TO(i->second);
 775                 Scheme_Object* entry = scheme_make_pair(k,x);
 776                 alist = scheme_make_pair(entry,alist);
 777             }
 778             $result = alist;
 779         }
 780         %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
 781             // native sequence?
 782             if (SCHEME_NULLP($input)) {
 783                 /* an empty sequence can be of any type */
 784                 $1 = 1;
 785             } else if (SCHEME_PAIRP($input)) {
 786                 // check the first element only
 787                 Scheme_Object* head = scheme_car($input);
 788                 if (SCHEME_PAIRP(head)) {
 789                     Scheme_Object* key = scheme_car(head);
 790                     Scheme_Object* val = scheme_cdr(head);
 791                     if (!CHECK_K(key)) {
 792                         $1 = 0;
 793                     } else {
 794                         if (CHECK_T(val)) {
 795                             $1 = 1;
 796                         } else if (SCHEME_PAIRP(val)) {
 797                             val = scheme_car(val);
 798                             if (CHECK_T(val))
 799                                 $1 = 1;
 800                             else
 801                                 $1 = 0;
 802                         } else {
 803                             $1 = 0;
 804                         }
 805                     }
 806                 } else {
 807                     $1 = 0;
 808                 }
 809             } else {
 810                 // wrapped map?
 811                 std::map<K,T >* m;
 812                 if (SWIG_ConvertPtr($input,(void **) &m,
 813                                 $&1_descriptor, 0) != -1)
 814                     $1 = 1;
 815                 else
 816                     $1 = 0;
 817             }
 818         }
 819         %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
 820                                        const map<K,T>* {
 821             // native sequence?
 822             if (SCHEME_NULLP($input)) {
 823                 /* an empty sequence can be of any type */
 824                 $1 = 1;
 825             } else if (SCHEME_PAIRP($input)) {
 826                 // check the first element only
 827                 Scheme_Object* head = scheme_car($input);
 828                 if (SCHEME_PAIRP(head)) {
 829                     Scheme_Object* key = scheme_car(head);
 830                     Scheme_Object* val = scheme_cdr(head);
 831                     if (!CHECK_K(key)) {
 832                         $1 = 0;
 833                     } else {
 834                         if (CHECK_T(val)) {
 835                             $1 = 1;
 836                         } else if (SCHEME_PAIRP(val)) {
 837                             val = scheme_car(val);
 838                             if (CHECK_T(val))
 839                                 $1 = 1;
 840                             else
 841                                 $1 = 0;
 842                         } else {
 843                             $1 = 0;
 844                         }
 845                     }
 846                 } else {
 847                     $1 = 0;
 848                 }
 849             } else {
 850                 // wrapped map?
 851                 std::map<K,T >* m;
 852                 if (SWIG_ConvertPtr($input,(void **) &m,
 853                                 $1_descriptor, 0) != -1)
 854                     $1 = 1;
 855                 else
 856                     $1 = 0;
 857             }
 858         }
 859         %rename("length") size;
 860         %rename("null?") empty;
 861         %rename("clear!") clear;
 862         %rename("ref") __getitem__;
 863         %rename("set!") __setitem__;
 864         %rename("delete!") __delitem__;
 865         %rename("has-key?") has_key;
 866       public:
 867         map();
 868         map(const map<K,T> &);
 869
 870         unsigned int size() const;
 871         bool empty() const;
 872         void clear();
 873         %extend {
 874             T __getitem__(K key) throw (std::out_of_range) {
 875                 std::map<K,T >::iterator i = self->find(key);
 876                 if (i != self->end())
 877                     return i->second;
 878                 else
 879                     throw std::out_of_range("key not found");
 880             }
 881             void __setitem__(K key, T x) {
 882                 (*self)[key] = x;
 883             }
 884             void __delitem__(K key) throw (std::out_of_range) {
 885                 std::map<K,T >::iterator i = self->find(key);
 886                 if (i != self->end())
 887                     self->erase(i);
 888                 else
 889                     throw std::out_of_range("key not found");
 890             }
 891             bool has_key(K key) {
 892                 std::map<K,T >::iterator i = self->find(key);
 893                 return i != self->end();
 894             }
 895             Scheme_Object* keys() {
 896                 Scheme_Object* result = scheme_null;
 897                 for (std::map<K,T >::reverse_iterator i=$1.rbegin();
 898                                                       i!=$1.rend(); ++i) {
 899                     Scheme_Object* k = CONVERT_K_TO(i->first);
 900                     result = scheme_make_pair(k,result);
 901                 }
 902                 return result;
 903             }
 904         }
 905     };
 906     %enddef
 907
 908
 909     specialize_std_map_on_key(bool,SCHEME_BOOLP,
 910                               SCHEME_TRUEP,swig_make_boolean);
 911     specialize_std_map_on_key(int,SCHEME_INTP,
 912                               SCHEME_INT_VAL,scheme_make_integer_value);
 913     specialize_std_map_on_key(short,SCHEME_INTP,
 914                               SCHEME_INT_VAL,scheme_make_integer_value);
 915     specialize_std_map_on_key(long,SCHEME_INTP,
 916                               SCHEME_INT_VAL,scheme_make_integer_value);
 917     specialize_std_map_on_key(unsigned int,SCHEME_INTP,
 918                               SCHEME_INT_VAL,scheme_make_integer_value);
 919     specialize_std_map_on_key(unsigned short,SCHEME_INTP,
 920                               SCHEME_INT_VAL,scheme_make_integer_value);
 921     specialize_std_map_on_key(unsigned long,SCHEME_INTP,
 922                               SCHEME_INT_VAL,scheme_make_integer_value);
 923     specialize_std_map_on_key(double,SCHEME_REALP,
 924                               scheme_real_to_double,scheme_make_double);
 925     specialize_std_map_on_key(float,SCHEME_REALP,
 926                               scheme_real_to_double,scheme_make_double);
 927     specialize_std_map_on_key(std::string,SCHEME_STRINGP,
 928                               swig_scm_to_string,swig_make_string);
 929
 930     specialize_std_map_on_value(bool,SCHEME_BOOLP,
 931                                 SCHEME_TRUEP,swig_make_boolean);
 932     specialize_std_map_on_value(int,SCHEME_INTP,
 933                                 SCHEME_INT_VAL,scheme_make_integer_value);
 934     specialize_std_map_on_value(short,SCHEME_INTP,
 935                                 SCHEME_INT_VAL,scheme_make_integer_value);
 936     specialize_std_map_on_value(long,SCHEME_INTP,
 937                                 SCHEME_INT_VAL,scheme_make_integer_value);
 938     specialize_std_map_on_value(unsigned int,SCHEME_INTP,
 939                                 SCHEME_INT_VAL,scheme_make_integer_value);
 940     specialize_std_map_on_value(unsigned short,SCHEME_INTP,
 941                                 SCHEME_INT_VAL,scheme_make_integer_value);
 942     specialize_std_map_on_value(unsigned long,SCHEME_INTP,
 943                                 SCHEME_INT_VAL,scheme_make_integer_value);
 944     specialize_std_map_on_value(double,SCHEME_REALP,
 945                                 scheme_real_to_double,scheme_make_double);
 946     specialize_std_map_on_value(float,SCHEME_REALP,
 947                                 scheme_real_to_double,scheme_make_double);
 948     specialize_std_map_on_value(std::string,SCHEME_STRINGP,
 949                                 swig_scm_to_string,swig_make_string);
 950
 951     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 952                                SCHEME_TRUEP,swig_make_boolean,
 953                                bool,SCHEME_BOOLP,
 954                                SCHEME_TRUEP,swig_make_boolean);
 955     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 956                                SCHEME_TRUEP,swig_make_boolean,
 957                                int,SCHEME_INTP,
 958                                SCHEME_INT_VAL,scheme_make_integer_value);
 959     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 960                                SCHEME_TRUEP,swig_make_boolean,
 961                                short,SCHEME_INTP,
 962                                SCHEME_INT_VAL,scheme_make_integer_value);
 963     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 964                                SCHEME_TRUEP,swig_make_boolean,
 965                                long,SCHEME_INTP,
 966                                SCHEME_INT_VAL,scheme_make_integer_value);
 967     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 968                                SCHEME_TRUEP,swig_make_boolean,
 969                                unsigned int,SCHEME_INTP,
 970                                SCHEME_INT_VAL,scheme_make_integer_value);
 971     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 972                                SCHEME_TRUEP,swig_make_boolean,
 973                                unsigned short,SCHEME_INTP,
 974                                SCHEME_INT_VAL,scheme_make_integer_value);
 975     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 976                                SCHEME_TRUEP,swig_make_boolean,
 977                                unsigned long,SCHEME_INTP,
 978                                SCHEME_INT_VAL,scheme_make_integer_value);
 979     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 980                                SCHEME_TRUEP,swig_make_boolean,
 981                                double,SCHEME_REALP,
 982                                scheme_real_to_double,scheme_make_double);
 983     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 984                                SCHEME_TRUEP,swig_make_boolean,
 985                                float,SCHEME_REALP,
 986                                scheme_real_to_double,scheme_make_double);
 987     specialize_std_map_on_both(bool,SCHEME_BOOLP,
 988                                SCHEME_TRUEP,swig_make_boolean,
 989                                std::string,SCHEME_STRINGP,
 990                                swig_scm_to_string,swig_make_string);
 991     specialize_std_map_on_both(int,SCHEME_INTP,
 992                                SCHEME_INT_VAL,scheme_make_integer_value,
 993                                bool,SCHEME_BOOLP,
 994                                SCHEME_TRUEP,swig_make_boolean);
 995     specialize_std_map_on_both(int,SCHEME_INTP,
 996                                SCHEME_INT_VAL,scheme_make_integer_value,
 997                                int,SCHEME_INTP,
 998                                SCHEME_INT_VAL,scheme_make_integer_value);
 999     specialize_std_map_on_both(int,SCHEME_INTP,
1000                                SCHEME_INT_VAL,scheme_make_integer_value,
1001                                short,SCHEME_INTP,
1002                                SCHEME_INT_VAL,scheme_make_integer_value);
1003     specialize_std_map_on_both(int,SCHEME_INTP,
1004                                SCHEME_INT_VAL,scheme_make_integer_value,
1005                                long,SCHEME_INTP,
1006                                SCHEME_INT_VAL,scheme_make_integer_value);
1007     specialize_std_map_on_both(int,SCHEME_INTP,
1008                                SCHEME_INT_VAL,scheme_make_integer_value,
1009                                unsigned int,SCHEME_INTP,
1010                                SCHEME_INT_VAL,scheme_make_integer_value);
1011     specialize_std_map_on_both(int,SCHEME_INTP,
1012                                SCHEME_INT_VAL,scheme_make_integer_value,
1013                                unsigned short,SCHEME_INTP,
1014                                SCHEME_INT_VAL,scheme_make_integer_value);
1015     specialize_std_map_on_both(int,SCHEME_INTP,
1016                                SCHEME_INT_VAL,scheme_make_integer_value,
1017                                unsigned long,SCHEME_INTP,
1018                                SCHEME_INT_VAL,scheme_make_integer_value);
1019     specialize_std_map_on_both(int,SCHEME_INTP,
1020                                SCHEME_INT_VAL,scheme_make_integer_value,
1021                                double,SCHEME_REALP,
1022                                scheme_real_to_double,scheme_make_double);
1023     specialize_std_map_on_both(int,SCHEME_INTP,
1024                                SCHEME_INT_VAL,scheme_make_integer_value,
1025                                float,SCHEME_REALP,
1026                                scheme_real_to_double,scheme_make_double);
1027     specialize_std_map_on_both(int,SCHEME_INTP,
1028                                SCHEME_INT_VAL,scheme_make_integer_value,
1029                                std::string,SCHEME_STRINGP,
1030                                swig_scm_to_string,swig_make_string);
1031     specialize_std_map_on_both(short,SCHEME_INTP,
1032                                SCHEME_INT_VAL,scheme_make_integer_value,
1033                                bool,SCHEME_BOOLP,
1034                                SCHEME_TRUEP,swig_make_boolean);
1035     specialize_std_map_on_both(short,SCHEME_INTP,
1036                                SCHEME_INT_VAL,scheme_make_integer_value,
1037                                int,SCHEME_INTP,
1038                                SCHEME_INT_VAL,scheme_make_integer_value);
1039     specialize_std_map_on_both(short,SCHEME_INTP,
1040                                SCHEME_INT_VAL,scheme_make_integer_value,
1041                                short,SCHEME_INTP,
1042                                SCHEME_INT_VAL,scheme_make_integer_value);
1043     specialize_std_map_on_both(short,SCHEME_INTP,
1044                                SCHEME_INT_VAL,scheme_make_integer_value,
1045                                long,SCHEME_INTP,
1046                                SCHEME_INT_VAL,scheme_make_integer_value);
1047     specialize_std_map_on_both(short,SCHEME_INTP,
1048                                SCHEME_INT_VAL,scheme_make_integer_value,
1049                                unsigned int,SCHEME_INTP,
1050                                SCHEME_INT_VAL,scheme_make_integer_value);
1051     specialize_std_map_on_both(short,SCHEME_INTP,
1052                                SCHEME_INT_VAL,scheme_make_integer_value,
1053                                unsigned short,SCHEME_INTP,
1054                                SCHEME_INT_VAL,scheme_make_integer_value);
1055     specialize_std_map_on_both(short,SCHEME_INTP,
1056                                SCHEME_INT_VAL,scheme_make_integer_value,
1057                                unsigned long,SCHEME_INTP,
1058                                SCHEME_INT_VAL,scheme_make_integer_value);
1059     specialize_std_map_on_both(short,SCHEME_INTP,
1060                                SCHEME_INT_VAL,scheme_make_integer_value,
1061                                double,SCHEME_REALP,
1062                                scheme_real_to_double,scheme_make_double);
1063     specialize_std_map_on_both(short,SCHEME_INTP,
1064                                SCHEME_INT_VAL,scheme_make_integer_value,
1065                                float,SCHEME_REALP,
1066                                scheme_real_to_double,scheme_make_double);
1067     specialize_std_map_on_both(short,SCHEME_INTP,
1068                                SCHEME_INT_VAL,scheme_make_integer_value,
1069                                std::string,SCHEME_STRINGP,
1070                                swig_scm_to_string,swig_make_string);
1071     specialize_std_map_on_both(long,SCHEME_INTP,
1072                                SCHEME_INT_VAL,scheme_make_integer_value,
1073                                bool,SCHEME_BOOLP,
1074                                SCHEME_TRUEP,swig_make_boolean);
1075     specialize_std_map_on_both(long,SCHEME_INTP,
1076                                SCHEME_INT_VAL,scheme_make_integer_value,
1077                                int,SCHEME_INTP,
1078                                SCHEME_INT_VAL,scheme_make_integer_value);
1079     specialize_std_map_on_both(long,SCHEME_INTP,
1080                                SCHEME_INT_VAL,scheme_make_integer_value,
1081                                short,SCHEME_INTP,
1082                                SCHEME_INT_VAL,scheme_make_integer_value);
1083     specialize_std_map_on_both(long,SCHEME_INTP,
1084                                SCHEME_INT_VAL,scheme_make_integer_value,
1085                                long,SCHEME_INTP,
1086                                SCHEME_INT_VAL,scheme_make_integer_value);
1087     specialize_std_map_on_both(long,SCHEME_INTP,
1088                                SCHEME_INT_VAL,scheme_make_integer_value,
1089                                unsigned int,SCHEME_INTP,
1090                                SCHEME_INT_VAL,scheme_make_integer_value);
1091     specialize_std_map_on_both(long,SCHEME_INTP,
1092                                SCHEME_INT_VAL,scheme_make_integer_value,
1093                                unsigned short,SCHEME_INTP,
1094                                SCHEME_INT_VAL,scheme_make_integer_value);
1095     specialize_std_map_on_both(long,SCHEME_INTP,
1096                                SCHEME_INT_VAL,scheme_make_integer_value,
1097                                unsigned long,SCHEME_INTP,
1098                                SCHEME_INT_VAL,scheme_make_integer_value);
1099     specialize_std_map_on_both(long,SCHEME_INTP,
1100                                SCHEME_INT_VAL,scheme_make_integer_value,
1101                                double,SCHEME_REALP,
1102                                scheme_real_to_double,scheme_make_double);
1103     specialize_std_map_on_both(long,SCHEME_INTP,
1104                                SCHEME_INT_VAL,scheme_make_integer_value,
1105                                float,SCHEME_REALP,
1106                                scheme_real_to_double,scheme_make_double);
1107     specialize_std_map_on_both(long,SCHEME_INTP,
1108                                SCHEME_INT_VAL,scheme_make_integer_value,
1109                                std::string,SCHEME_STRINGP,
1110                                swig_scm_to_string,swig_make_string);
1111     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1112                                SCHEME_INT_VAL,scheme_make_integer_value,
1113                                bool,SCHEME_BOOLP,
1114                                SCHEME_TRUEP,swig_make_boolean);
1115     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1116                                SCHEME_INT_VAL,scheme_make_integer_value,
1117                                int,SCHEME_INTP,
1118                                SCHEME_INT_VAL,scheme_make_integer_value);
1119     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1120                                SCHEME_INT_VAL,scheme_make_integer_value,
1121                                short,SCHEME_INTP,
1122                                SCHEME_INT_VAL,scheme_make_integer_value);
1123     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1124                                SCHEME_INT_VAL,scheme_make_integer_value,
1125                                long,SCHEME_INTP,
1126                                SCHEME_INT_VAL,scheme_make_integer_value);
1127     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1128                                SCHEME_INT_VAL,scheme_make_integer_value,
1129                                unsigned int,SCHEME_INTP,
1130                                SCHEME_INT_VAL,scheme_make_integer_value);
1131     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1132                                SCHEME_INT_VAL,scheme_make_integer_value,
1133                                unsigned short,SCHEME_INTP,
1134                                SCHEME_INT_VAL,scheme_make_integer_value);
1135     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1136                                SCHEME_INT_VAL,scheme_make_integer_value,
1137                                unsigned long,SCHEME_INTP,
1138                                SCHEME_INT_VAL,scheme_make_integer_value);
1139     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1140                                SCHEME_INT_VAL,scheme_make_integer_value,
1141                                double,SCHEME_REALP,
1142                                scheme_real_to_double,scheme_make_double);
1143     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1144                                SCHEME_INT_VAL,scheme_make_integer_value,
1145                                float,SCHEME_REALP,
1146                                scheme_real_to_double,scheme_make_double);
1147     specialize_std_map_on_both(unsigned int,SCHEME_INTP,
1148                                SCHEME_INT_VAL,scheme_make_integer_value,
1149                                std::string,SCHEME_STRINGP,
1150                                swig_scm_to_string,swig_make_string);
1151     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1152                                SCHEME_INT_VAL,scheme_make_integer_value,
1153                                bool,SCHEME_BOOLP,
1154                                SCHEME_TRUEP,swig_make_boolean);
1155     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1156                                SCHEME_INT_VAL,scheme_make_integer_value,
1157                                int,SCHEME_INTP,
1158                                SCHEME_INT_VAL,scheme_make_integer_value);
1159     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1160                                SCHEME_INT_VAL,scheme_make_integer_value,
1161                                short,SCHEME_INTP,
1162                                SCHEME_INT_VAL,scheme_make_integer_value);
1163     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1164                                SCHEME_INT_VAL,scheme_make_integer_value,
1165                                long,SCHEME_INTP,
1166                                SCHEME_INT_VAL,scheme_make_integer_value);
1167     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1168                                SCHEME_INT_VAL,scheme_make_integer_value,
1169                                unsigned int,SCHEME_INTP,
1170                                SCHEME_INT_VAL,scheme_make_integer_value);
1171     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1172                                SCHEME_INT_VAL,scheme_make_integer_value,
1173                                unsigned short,SCHEME_INTP,
1174                                SCHEME_INT_VAL,scheme_make_integer_value);
1175     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1176                                SCHEME_INT_VAL,scheme_make_integer_value,
1177                                unsigned long,SCHEME_INTP,
1178                                SCHEME_INT_VAL,scheme_make_integer_value);
1179     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1180                                SCHEME_INT_VAL,scheme_make_integer_value,
1181                                double,SCHEME_REALP,
1182                                scheme_real_to_double,scheme_make_double);
1183     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1184                                SCHEME_INT_VAL,scheme_make_integer_value,
1185                                float,SCHEME_REALP,
1186                                scheme_real_to_double,scheme_make_double);
1187     specialize_std_map_on_both(unsigned short,SCHEME_INTP,
1188                                SCHEME_INT_VAL,scheme_make_integer_value,
1189                                std::string,SCHEME_STRINGP,
1190                                swig_scm_to_string,swig_make_string);
1191     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1192                                SCHEME_INT_VAL,scheme_make_integer_value,
1193                                bool,SCHEME_BOOLP,
1194                                SCHEME_TRUEP,swig_make_boolean);
1195     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1196                                SCHEME_INT_VAL,scheme_make_integer_value,
1197                                int,SCHEME_INTP,
1198                                SCHEME_INT_VAL,scheme_make_integer_value);
1199     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1200                                SCHEME_INT_VAL,scheme_make_integer_value,
1201                                short,SCHEME_INTP,
1202                                SCHEME_INT_VAL,scheme_make_integer_value);
1203     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1204                                SCHEME_INT_VAL,scheme_make_integer_value,
1205                                long,SCHEME_INTP,
1206                                SCHEME_INT_VAL,scheme_make_integer_value);
1207     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1208                                SCHEME_INT_VAL,scheme_make_integer_value,
1209                                unsigned int,SCHEME_INTP,
1210                                SCHEME_INT_VAL,scheme_make_integer_value);
1211     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1212                                SCHEME_INT_VAL,scheme_make_integer_value,
1213                                unsigned short,SCHEME_INTP,
1214                                SCHEME_INT_VAL,scheme_make_integer_value);
1215     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1216                                SCHEME_INT_VAL,scheme_make_integer_value,
1217                                unsigned long,SCHEME_INTP,
1218                                SCHEME_INT_VAL,scheme_make_integer_value);
1219     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1220                                SCHEME_INT_VAL,scheme_make_integer_value,
1221                                double,SCHEME_REALP,
1222                                scheme_real_to_double,scheme_make_double);
1223     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1224                                SCHEME_INT_VAL,scheme_make_integer_value,
1225                                float,SCHEME_REALP,
1226                                scheme_real_to_double,scheme_make_double);
1227     specialize_std_map_on_both(unsigned long,SCHEME_INTP,
1228                                SCHEME_INT_VAL,scheme_make_integer_value,
1229                                std::string,SCHEME_STRINGP,
1230                                swig_scm_to_string,swig_make_string);
1231     specialize_std_map_on_both(double,SCHEME_REALP,
1232                                scheme_real_to_double,scheme_make_double,
1233                                bool,SCHEME_BOOLP,
1234                                SCHEME_TRUEP,swig_make_boolean);
1235     specialize_std_map_on_both(double,SCHEME_REALP,
1236                                scheme_real_to_double,scheme_make_double,
1237                                int,SCHEME_INTP,
1238                                SCHEME_INT_VAL,scheme_make_integer_value);
1239     specialize_std_map_on_both(double,SCHEME_REALP,
1240                                scheme_real_to_double,scheme_make_double,
1241                                short,SCHEME_INTP,
1242                                SCHEME_INT_VAL,scheme_make_integer_value);
1243     specialize_std_map_on_both(double,SCHEME_REALP,
1244                                scheme_real_to_double,scheme_make_double,
1245                                long,SCHEME_INTP,
1246                                SCHEME_INT_VAL,scheme_make_integer_value);
1247     specialize_std_map_on_both(double,SCHEME_REALP,
1248                                scheme_real_to_double,scheme_make_double,
1249                                unsigned int,SCHEME_INTP,
1250                                SCHEME_INT_VAL,scheme_make_integer_value);
1251     specialize_std_map_on_both(double,SCHEME_REALP,
1252                                scheme_real_to_double,scheme_make_double,
1253                                unsigned short,SCHEME_INTP,
1254                                SCHEME_INT_VAL,scheme_make_integer_value);
1255     specialize_std_map_on_both(double,SCHEME_REALP,
1256                                scheme_real_to_double,scheme_make_double,
1257                                unsigned long,SCHEME_INTP,
1258                                SCHEME_INT_VAL,scheme_make_integer_value);
1259     specialize_std_map_on_both(double,SCHEME_REALP,
1260                                scheme_real_to_double,scheme_make_double,
1261                                double,SCHEME_REALP,
1262                                scheme_real_to_double,scheme_make_double);
1263     specialize_std_map_on_both(double,SCHEME_REALP,
1264                                scheme_real_to_double,scheme_make_double,
1265                                float,SCHEME_REALP,
1266                                scheme_real_to_double,scheme_make_double);
1267     specialize_std_map_on_both(double,SCHEME_REALP,
1268                                scheme_real_to_double,scheme_make_double,
1269                                std::string,SCHEME_STRINGP,
1270                                swig_scm_to_string,swig_make_string);
1271     specialize_std_map_on_both(float,SCHEME_REALP,
1272                                scheme_real_to_double,scheme_make_double,
1273                                bool,SCHEME_BOOLP,
1274                                SCHEME_TRUEP,swig_make_boolean);
1275     specialize_std_map_on_both(float,SCHEME_REALP,
1276                                scheme_real_to_double,scheme_make_double,
1277                                int,SCHEME_INTP,
1278                                SCHEME_INT_VAL,scheme_make_integer_value);
1279     specialize_std_map_on_both(float,SCHEME_REALP,
1280                                scheme_real_to_double,scheme_make_double,
1281                                short,SCHEME_INTP,
1282                                SCHEME_INT_VAL,scheme_make_integer_value);
1283     specialize_std_map_on_both(float,SCHEME_REALP,
1284                                scheme_real_to_double,scheme_make_double,
1285                                long,SCHEME_INTP,
1286                                SCHEME_INT_VAL,scheme_make_integer_value);
1287     specialize_std_map_on_both(float,SCHEME_REALP,
1288                                scheme_real_to_double,scheme_make_double,
1289                                unsigned int,SCHEME_INTP,
1290                                SCHEME_INT_VAL,scheme_make_integer_value);
1291     specialize_std_map_on_both(float,SCHEME_REALP,
1292                                scheme_real_to_double,scheme_make_double,
1293                                unsigned short,SCHEME_INTP,
1294                                SCHEME_INT_VAL,scheme_make_integer_value);
1295     specialize_std_map_on_both(float,SCHEME_REALP,
1296                                scheme_real_to_double,scheme_make_double,
1297                                unsigned long,SCHEME_INTP,
1298                                SCHEME_INT_VAL,scheme_make_integer_value);
1299     specialize_std_map_on_both(float,SCHEME_REALP,
1300                                scheme_real_to_double,scheme_make_double,
1301                                double,SCHEME_REALP,
1302                                scheme_real_to_double,scheme_make_double);
1303     specialize_std_map_on_both(float,SCHEME_REALP,
1304                                scheme_real_to_double,scheme_make_double,
1305                                float,SCHEME_REALP,
1306                                scheme_real_to_double,scheme_make_double);
1307     specialize_std_map_on_both(float,SCHEME_REALP,
1308                                scheme_real_to_double,scheme_make_double,
1309                                std::string,SCHEME_STRINGP,
1310                                swig_scm_to_string,swig_make_string);
1311     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1312                                swig_scm_to_string,swig_make_string,
1313                                bool,SCHEME_BOOLP,
1314                                SCHEME_TRUEP,swig_make_boolean);
1315     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1316                                swig_scm_to_string,swig_make_string,
1317                                int,SCHEME_INTP,
1318                                SCHEME_INT_VAL,scheme_make_integer_value);
1319     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1320                                swig_scm_to_string,swig_make_string,
1321                                short,SCHEME_INTP,
1322                                SCHEME_INT_VAL,scheme_make_integer_value);
1323     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1324                                swig_scm_to_string,swig_make_string,
1325                                long,SCHEME_INTP,
1326                                SCHEME_INT_VAL,scheme_make_integer_value);
1327     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1328                                swig_scm_to_string,swig_make_string,
1329                                unsigned int,SCHEME_INTP,
1330                                SCHEME_INT_VAL,scheme_make_integer_value);
1331     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1332                                swig_scm_to_string,swig_make_string,
1333                                unsigned short,SCHEME_INTP,
1334                                SCHEME_INT_VAL,scheme_make_integer_value);
1335     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1336                                swig_scm_to_string,swig_make_string,
1337                                unsigned long,SCHEME_INTP,
1338                                SCHEME_INT_VAL,scheme_make_integer_value);
1339     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1340                                swig_scm_to_string,swig_make_string,
1341                                double,SCHEME_REALP,
1342                                scheme_real_to_double,scheme_make_double);
1343     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1344                                swig_scm_to_string,swig_make_string,
1345                                float,SCHEME_REALP,
1346                                scheme_real_to_double,scheme_make_double);
1347     specialize_std_map_on_both(std::string,SCHEME_STRINGP,
1348                                swig_scm_to_string,swig_make_string,
1349                                std::string,SCHEME_STRINGP,
1350                                swig_scm_to_string,swig_make_string);
1351 }