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