fill out do_modfill, fixing some issues with '.. % tuple'
[shedskin:mainline.git] / lib / builtin.hpp
1 #ifndef BUILTIN_HPP
2 #define BUILTIN_HPP
3
4 #ifdef __SS_BIND
5 #include <Python.h>
6 #endif
7
8 #include <gc/gc_allocator.h>
9 #include <gc/gc_cpp.h>
10
11 #include <vector>
12 #include <string>
13 #include <set>
14 #include <iostream>
15 #include <fstream>
16 #include <sstream>
17 #include <cstdarg>
18 #include <cstring>
19 #include <cmath>
20 #include <algorithm>
21 #include <iterator>
22 #include <ctype.h>
23
24 #include <ext/hash_map>
25 #include <ext/hash_set>
26
27 namespace __shedskin__ {
28
29 /* builtin class forward declarations */
30
31 class class_;
32 class pyobj;
33 class str;
34 class int_;
35 class float_;
36 class file;
37
38 template <class T> class pyiter;
39 template <class T> class pyseq;
40
41 template <class T> class __iter;
42 template <class T> class __seqiter;
43 template <class T> class __setiter;
44 template <class T, class U> class __dictiterkeys;
45 template <class T, class U> class __dictitervalues;
46 template <class T, class U> class __dictiteritems;
47 class __fileiter;
48 class __striter;
49 class __rangeiter;
50
51 template <class T> class list;
52 template <class A, class B> class tuple2;
53
54 template <class T> class set;
55 template <class K, class V> class dict;
56
57 class Exception;
58 class AssertionError; class KeyError; class ValueError; class IndexError;
59 class NotImplementedError; class IOError; class OSError; class SyntaxError;
60 class StopIteration; class TypeError; class RuntimeError;
61
62 /* builtin function forward declarations */
63
64 template<class T> list<T> *__list(pyiter<T> *p);
65 template<class T> list<T> *__list(pyseq<T> *p);
66
67 template<class T> tuple2<T,T> *__tuple(pyiter<T> *p);
68 template<class T> tuple2<T,T> *__tuple(pyseq<T> *p);
69
70 template<class K, class V> dict<K,V> *__dict(pyiter<tuple2<K, V> *> *p);
71 template<class K, class V> dict<K,V> *__dict(dict<K,V> *p);
72 template<class K> dict<K,K> *__dict(pyiter<list<K> *> *p);
73
74 int __int();
75 template<class T> int __int(T t) { return t->__int__(); }
76 template<> int __int(str *s);
77 template<> int __int(int i);
78 template<> int __int(bool b);
79 template<> int __int(double d);
80 int __int(str *s, int base);
81
82 double __float();
83 template<class T> double __float(T t) { return t->__float__(); }
84 template<> double __float(int i);
85 template<> double __float(bool b);
86 template<> double __float(double f);
87 template<> double __float(str *s);
88
89 str *__str();
90 template<class T> str *__str(T t);
91 template<> str *__str(double t);
92 str *__str(int t, int base=10);
93 str *__str(bool b);
94
95 template<class T> str *repr(T t);
96 template<> str *repr(double t);
97 template<> str *repr(int t);
98 template<> str *repr(bool b);
99 template<> str *repr(void *t);
100
101 file *open(str *name, str *flags = 0);
102 str *raw_input(str *msg = 0);
103
104 void print(const char *fmt, ...);
105 void print(file *f, const char *fmt, ...);
106 void printc(const char *fmt, ...); /* print comma */
107 void printc(file *f, const char *fmt, ...);
108
109 int isinstance(pyobj *, class_ *);
110 int isinstance(pyobj *, tuple2<class_ *, class_ *> *);
111
112 list<int> *range(int b);
113 list<int> *range(int a, int b, int s=1);
114
115 __iter<int> *xrange(int b);
116 __iter<int> *xrange(int a, int b, int s=1);
117
118 int ord(str *c);
119 str *chr(int i);
120
121 double ___round(double a);
122 double ___round(double a, int n);
123
124 template<class T> T __abs(T t) {
125     return t->__abs__();
126 }
127 template<> int __abs(int a);
128 template<> double __abs(double a);
129 int __abs(bool b);
130
131 template<class T> str *hex(T t) {
132     return t->__hex__();
133 }
134 template<> str *hex(int a);
135 template<> str *hex(bool b);
136
137 template<class T> str *oct(T t) {
138     return t->__oct__();
139 }
140 template<> str *oct(int a);
141 template<> str *oct(bool b);
142
143 str *__mod(str *fmt, ...);
144
145 template<class T> str *__mod(str *fmt, tuple2<T,T> *t); 
146 template<class A, class B> str *__mod(str *fmt, tuple2<A,B> *t);
147
148 /* internal use */
149
150 #define __GC_VECTOR(T) std::vector< T, gc_allocator< T > >
151 #define __GC_STRING std::basic_string<char,std::char_traits<char>,gc_allocator<char> >
152 #define __GC_HASH_SET __gnu_cxx::hash_set<T, hashfunc<T>, hasheq<T>, gc_allocator<T> >
153 #define __GC_HASH_MAP __gnu_cxx::hash_map<K, V, hashfunc<K>, hasheq<K>, gc_allocator<std::pair<K, V> > >
154
155 #ifdef __sun
156 #define INFINITY __builtin_inff()
157 #endif
158
159 void __init();
160 void __exit();
161 void slicenr(int x, int &l, int&u, int&s, int len);
162 int whatsit(__GC_STRING &s);
163
164 /* hashing */
165
166 static inline int hash_combine(int seed, int other) {
167     return seed ^ (other + 0x9e3779b9 + (seed << 6) + (seed >> 2));
168 }
169
170 template<class T> int hasher(T t) {
171     return t->__hash__();
172 };
173 template<> int hasher(int a);
174 template<> int hasher(double a);
175 template<> int hasher(void *a);
176
177 template<class T> class hashfunc
178 {
179     public: int operator()(T t) const { return hasher<T>(t); }
180 };
181
182 template<class T> class hasheq {
183     public: int operator()(T t, T v) const { return __eq(t,v); }
184 };
185
186 /* comparison */
187
188 template<class T> int __cmp(T a, T b) {
189     return a->__cmp__(b);
190 }
191
192 template<> int __cmp(int a, int b);
193 template<> int __cmp(double a, double b);
194 template<> int __cmp(void *a, void *b); /* keep compiler happy */
195
196 template<class T> int cpp_cmp(T a, T b) { 
197     return __cmp(a, b) == -1;
198 }
199 template<class T> int cpp_cmp_rev(T a, T b) {
200     return __cmp(a, b) == 1;
201 }
202 template<class T> class cpp_cmp_custom {
203     typedef int (*hork)(T, T);
204     hork cmp;
205 public:
206     cpp_cmp_custom(hork a) { cmp = a; }
207     int operator()(T a, T b) const { return cmp(a,b) == -1; }
208 };
209 template<class T> class cpp_cmp_custom_rev {
210     typedef int (*hork)(T, T);
211     hork cmp;
212 public:
213     cpp_cmp_custom_rev(hork a) { cmp = a; }
214     int operator()(T a, T b) const { return cmp(a,b) == 1; }
215 };
216
217 template<class T> struct dereference {}; 
218 template<class T> struct dereference <T*> {
219     typedef T type;
220 };
221
222 /* binding */
223
224 #ifdef __SS_BIND
225 template<class T> T __to_ss(PyObject *p) {
226     if(p==Py_None) return 0;
227     return new (typename dereference<T>::type)(p); /* isn't C++ pretty :-) */
228 }
229
230 template<> int __to_ss(PyObject *p);
231 template<> double __to_ss(PyObject *p);
232
233 template<class T> PyObject *__to_py(T t) {
234     if(!t) return Py_None;
235     return t->__to_py__(); 
236 }
237
238 template<> PyObject *__to_py(int i);
239 template<> PyObject *__to_py(double i);
240 #endif
241
242 /* externs */
243
244 extern class_ *cl_str_, *cl_int_, *cl_float_, *cl_list, *cl_tuple, *cl_dict, *cl_set, *cl_object, *cl_rangeiter;
245
246 extern __GC_VECTOR(str *) __letters;
247
248 /* builtin class declarations */
249
250 class pyobj : public gc {
251 public:
252     class_ *__class__;
253
254     virtual str *__repr__();
255     virtual str *__str__() { return __repr__(); }
256
257     virtual int __hash__() {
258         return __gnu_cxx::hash<intptr_t>()((intptr_t)this);
259     }
260
261     virtual int __eq__(pyobj *p) { return this == p; }
262     virtual int __ne__(pyobj *p) { return !__eq__(p); }
263
264     virtual int __cmp__(pyobj *p) {
265         return __cmp<void *>(this, p);
266     }
267
268     virtual int __gt__(pyobj *p) { return __cmp__(p) == 1; }
269     virtual int __lt__(pyobj *p) { return __cmp__(p) == -1; }
270     virtual int __ge__(pyobj *p) { return __cmp__(p) != -1; }
271     virtual int __le__(pyobj *p) { return __cmp__(p) != 1; }
272
273     virtual pyobj *__copy__() { return this; }
274     virtual pyobj *__deepcopy__(dict<void *, pyobj *> *memo) { return this; }
275
276     virtual int __len__() { return 1; }
277     virtual int __nonzero__() { return __len__() != 0; }
278
279 };
280
281 class class_: public pyobj {
282 public:
283     int low, high;
284     str *__name__;
285
286     class_(const char *name, int low, int high);
287     str *__repr__();
288     int __eq__(pyobj *c);
289
290 };
291
292 class int_ : public pyobj {
293 public:
294     int unit;
295     int_(int i);
296     str *__repr__();
297 };
298
299 class float_ : public pyobj {
300 public:
301     double unit;
302     float_(double f);
303     str *__repr__();
304 }; 
305
306 template <class T> class pyiter : public pyobj {
307 public:
308     virtual __iter<T> *__iter__() = 0;
309
310 };
311
312 template<class T> class __iter : public pyiter<T> {
313 public:
314     virtual T next() = 0;
315     virtual int __len__() { return -1; } // XXX throw exception
316
317     __iter<T> *__iter__() { return this; }
318
319     T temp; /* used by FOR_IN macros */
320     int for_has_next();
321     T for_get_next();
322
323     str *__repr__();
324 };
325
326 template <class T> __iter<T> *___iter(pyiter<T> *p) {
327     return p->__iter__();
328 }
329
330 template <class T> class pyseq : public pyiter<T> {
331 public:
332     std::vector<T, gc_allocator<T> > units;
333
334     virtual int __len__() {
335         return units.size();
336     }
337
338     virtual T __getitem__(int i) {
339         i = __wrap(this, i);
340         return units[i];
341     }
342
343     virtual int append(T t) {
344         units.push_back(t);
345         return 0;
346     }
347
348     virtual void slice(int x, int l, int u, int s, pyseq<T> *c) {
349         slicenr(x, l, u, s, __len__());
350         if(s > 0)
351             for(int i=l; i<u; i += s)
352                 c->append(units[i]);
353         else
354             for(int i=l; i>u; i += s)
355                 c->append(units[i]);
356     }
357
358     virtual int __cmp__(pyobj *p) {
359         pyseq<T> *b = (pyseq<T> *)p;
360         int i, cmp;
361         int mnm = __min(this->__len__(), b->__len__());
362
363         for(i = 0; i < mnm; i++) {
364             cmp = __cmp(this->units[i], b->units[i]);
365             if(cmp)
366                 return cmp;
367         }
368         return __cmp(this->__len__(), b->__len__());
369     }
370
371     virtual int __contains__(T t) {
372
373     }
374
375     void resize(int n) {
376         units.resize(n);
377     }
378
379     __seqiter<T> *__iter__() { 
380         return new __seqiter<T>(this);
381     }
382
383 };
384
385 template <class T> class __seqiter : public __iter<T> {
386 public:
387     int counter;
388     pyseq<T> *p;
389     __seqiter<T>();
390     __seqiter<T>(pyseq<T> *p);
391     T next();
392 };
393
394 template <class T> class list : public pyseq<T> {
395 public:
396     using pyseq<T>::units;
397
398     list();
399     list(int count, ...);
400
401     void clear();
402     int __setitem__(int i, T e);
403     int __delitem__(int i);
404     //void init(int count, ...);
405     int __remove__(int i);
406     int empty();
407     list<T> *__slice__(int x, int l, int u, int s);
408     int __setslice__(int x, int l, int u, int s, pyiter<T> *b);
409     int __delete__(int i);
410     int __delete__(int x, int l, int u, int s);
411     int __delslice__(int a, int b);
412     int __contains__(T a);
413
414     list<T> *__add__(list<T> *b);
415     list<T> *__mul__(int b);
416
417     list<T> *__iadd__(pyiter<T> *b);
418     list<T> *__iadd__(pyseq<T> *b);
419     list<T> *__imul__(int n);
420
421     int extend(pyiter<T> *p);
422     int extend(pyseq<T> *p);
423
424     int index(T a);
425     int index(T a, int s);
426     int index(T a, int s, int e); 
427
428     int count(T a);
429     str *__repr__();
430     int __eq__(pyobj *l);
431
432     T __getfirst__() { return this->units[0]; } // XXX remove
433     T __getsecond__() { return this->units[1]; }
434     T __getfast__(int i) {
435         i = __wrap(this, i);
436         return this->units[i];
437     }
438
439     T pop();
440     T pop(int m);
441     int remove(T e);
442     int insert(int m, T e);
443
444     int reverse();
445     int sort(int (*cmp)(T, T), int key, int reverse);
446
447     list<T> *__copy__();
448     list<T> *__deepcopy__(dict<void *, pyobj *> *memo);
449
450 #ifdef __SS_BIND
451     list(PyObject *);
452     PyObject *__to_py__();
453 #endif
454 };
455
456 template<class A, class B> class tuple2 : public pyseq<A> {
457 public:
458     A first;
459     B second;
460
461     tuple2();
462     tuple2(int n, A a, B b);
463
464     void __init2__(A a, B b) {
465         first = a;
466         second = b;
467     }
468
469     A __getfirst__();
470     B __getsecond__();
471
472     str *__repr__();
473
474     //void init(int count, A a, B b);
475
476     int __contains__(A a);
477     int __contains__(B b);
478
479     int __len__();
480
481     int __eq__(tuple2<A,B> *b);
482     int __cmp__(pyobj *p);
483     int __hash__();
484
485     tuple2<A,B> *__copy__();
486     tuple2<A,B> *__deepcopy__(dict<void *, pyobj *> *memo);
487
488 #ifdef __SS_BIND
489     tuple2(PyObject *p);
490     PyObject *__to_py__();
491 #endif
492 };
493  
494 class str : public pyseq<str *> {
495 public:
496     __GC_STRING unit;
497     int cached_hash; 
498
499     str();
500     str(const char *s);
501     str(__GC_STRING s);
502     str(const char *s, int size); /* '\0' delimiter in C */
503
504     int __contains__(str *s);
505     str *strip(str *chars=0);
506     str *lstrip(str *chars=0);
507     str *rstrip(str *chars=0);
508     list<str *> *split(str *sep=0, int maxsplit=-1);
509     int __eq__(pyobj *s);
510     str *__add__(str *b);
511     str *__join(pyseq<str *> *l, int total_len);
512     str *join(pyiter<str *> *l);
513     str *join(pyseq<str *> *l);
514     str *__str__();
515     str *__repr__();
516     str *__mul__(int n);
517     str *__getitem__(int i);
518     str *__getfirst__();
519     str *__getsecond__();
520     int __len__();
521     str *__slice__(int x, int l, int u, int s);
522
523     list<str *> *rsplit(str *sep = 0, int maxsplit = -1);
524     int istitle(void);
525     tuple2<str *, str *> *rpartition(str *sep);
526     tuple2<str *, str *> *partition(str *sep);
527     list<str *> *splitlines(int keepends = 0);
528
529     int __fixstart(int a, int b);
530     int __checkneg(int i);
531
532     int find(str *s, int a=0);
533     int find(str *s, int a, int b);
534     int rfind(str *s, int a=0);
535     int rfind(str *s, int a, int b);
536     int index(str *s, int a=0);
537     int index(str *s, int a, int b);
538     int rindex(str *s, int a=0);
539     int rindex(str *s, int a, int b);
540
541     int count(str *s, int start=0);
542     int count(str *s, int start, int end);
543     int startswith(str *s, int start=0);
544     int startswith(str *s, int start, int end);
545     int endswith(str *s, int start=0);
546     int endswith(str *s, int start, int end);
547
548     str *upper();
549     str *lower();
550     str *title();
551     str *capitalize();
552     str *replace(str *a, str *b, int c=-1);
553     str *translate(str *table, str *delchars=0);
554     str *swapcase();
555     str *center(int w, str *fill=0);
556
557     int __ctype_function(int (*cfunc)(int));
558     int isspace();
559     int isalpha();
560     int isdigit();
561     int islower();
562     int isupper();
563     int isalnum();
564     
565     str *zfill(int width);
566     str *expandtabs(int width=8); 
567
568     str *ljust(int width, str *fchar=0);
569     str *rjust(int width, str *fchar=0);
570
571     int __cmp__(pyobj *p);
572
573     int __hash__();
574
575     __seqiter<str *> *__iter__();
576
577     //str *sorted();
578
579     str *__iadd__(str *b);
580     str *__imul__(int n);
581
582 #ifdef __SS_BIND
583     str(PyObject *p); 
584     PyObject *__to_py__();
585 #endif
586 };
587
588 class __striter : public __seqiter<str *> {
589 public:
590     int counter;
591     str *p;
592
593     __striter(str *p); 
594     str *next();
595 }; 
596
597 template<class T> class tuple2<T,T> : public pyseq<T> {
598 public:
599     using pyseq<T>::units;
600
601     tuple2();
602     tuple2(int count, ...);
603
604     void __init2__(T a, T b) {
605         units.resize(2);
606         units[0] = a;
607         units[1] = b;
608     }
609
610     T __getfirst__();
611     T __getsecond__();
612
613     T __getfast__(int i);
614
615     str *__repr__();
616
617     tuple2<T,T> *__add__(tuple2<T,T> *b);
618     tuple2<T,T> *__mul__(int b);
619
620     tuple2<T,T> *__iadd__(tuple2<T,T> *b);
621     tuple2<T,T> *__imul__(int n);
622
623     //void init(int count, ...);
624
625     int __contains__(T a);
626     int __eq__(pyobj *p);
627
628     tuple2<T,T> *__slice__(int x, int l, int u, int s);
629
630     int __hash__();
631
632     tuple2<T,T> *__deepcopy__(dict<void *, pyobj *> *memo);
633     tuple2<T,T> *__copy__();
634
635 #ifdef __SS_BIND
636     tuple2(PyObject *p);
637     PyObject *__to_py__();
638 #endif
639 };
640
641 template <class K, class V> class dict : public pyiter<K> {
642 public:
643     __GC_HASH_MAP units;
644     typename __GC_HASH_MAP::iterator it;
645
646     dict();
647     dict(int count, ...);
648     int __setitem__(K k, V v);
649     V __getitem__(K k);
650     int __delitem__(K k);
651     list<K> *keys();
652     list<V> *values();
653     list<tuple2<K, V> *> *items();
654     int __len__();
655     str *__repr__();
656     int has_key(K k);
657     int clear();
658     dict<K,V> *copy();
659     V get(K k);
660     V get(K k, V v);
661     V pop(K k);
662     tuple2<K, V> *popitem();
663     int update(dict<K, V> *e);
664     int __contains__(K k);
665     int __eq__(pyobj *e);
666     V setdefault(K k, V v=0);
667
668     __dictiterkeys<K, V> *__iter__();
669     __dictiterkeys<K, V> *iterkeys();
670     __dictitervalues<K, V> *itervalues();
671     __dictiteritems<K, V> *iteritems();
672
673     dict<K, V> *__deepcopy__(dict<void *, pyobj *> *memo);
674     dict<K, V> *__copy__();
675
676     int __addtoitem__(K k, V v);
677
678 #ifdef __SS_BIND
679     dict(PyObject *);
680     PyObject *__to_py__();
681 #endif
682 };
683
684 template <class K, class V> class __dictiterkeys : public __iter<K> {
685 public:
686     dict<K, V> *p;
687     typename __GC_HASH_MAP::iterator iter;
688     int counter;
689
690     __dictiterkeys<K, V>(dict<K, V> *p);
691     K next();
692 };
693
694 template <class K, class V> class __dictitervalues : public __iter<V> {
695 public:
696     dict<K, V> *p;
697     typename __GC_HASH_MAP::iterator iter;
698     int counter;
699
700     __dictitervalues<K, V>(dict<K, V> *p);
701     V next();
702 };
703
704 template <class K, class V> class __dictiteritems : public __iter<tuple2<K, V> *> {
705 public:
706     dict<K, V> *p;
707     typename __GC_HASH_MAP::iterator iter;
708     int counter;
709
710     __dictiteritems<K, V>(dict<K, V> *p);
711     tuple2<K, V> *next();
712 };
713
714 template <class T> class set : public pyiter<T> {
715 public:
716     __GC_HASH_SET units;
717     typename __GC_HASH_SET::iterator it1, it2;
718     int frozen;
719
720     set(int frozen=0);
721     set(pyiter<T> *l, int frozen=0);
722
723     int add(T x);
724     int discard(T a);
725     int remove(T a);
726     T pop();
727
728     int clear();
729     set<T> *copy();
730
731     int __contains__(T a);
732     int __len__();
733
734     set<T> *__ss_union(pyiter<T> *s);
735     set<T> *__ss_union(set<T> *s);
736     int update(pyiter<T> *s);
737     int update(set<T> *s);
738
739     set<T> *difference(set<T> *s);
740     set<T> *__sub__(set<T> *s);
741     int difference_update(set<T> *s);
742     set<T> *intersection(set<T> *s);
743     int intersection_update(set<T> *s);
744     set<T> *symmetric_difference(set<T> *s);
745     int symmetric_difference_update(set<T> *s);
746
747     set<T> *__and__(set<T> *s);
748     set<T> *__or__(set<T> *s);
749     set<T> *__xor__(set<T> *s);
750
751     set<T> *__iand__(set<T> *s);
752     set<T> *__ior__(set<T> *s);
753     set<T> *__ixor__(set<T> *s);
754     set<T> *__isub__(set<T> *s);
755
756     int issubset(pyiter<T> *s);
757     int issubset(set<T> *s);
758     int issuperset(set<T> *s);
759     int issuperset(pyiter<T> *s);
760
761     int __gt__(set<T> *s);
762     int __lt__(set<T> *s);
763     int __ge__(set<T> *s);
764     int __le__(set<T> *s);
765     int __eq__(pyobj *p);
766     int __cmp__(pyobj *p);
767
768     str *__repr__();
769
770     int __hash__();
771
772     __setiter<T> *__iter__() { 
773         return new __setiter<T>(this);
774     }
775
776     set<T> *__copy__();
777     set<T> *__deepcopy__(dict<void *, pyobj *> *memo);
778
779 #ifdef __SS_BIND
780     set(PyObject *);
781     PyObject *__to_py__();
782 #endif
783 };
784
785 template <class T> class __setiter : public __iter<T> {
786 public:
787     set<T> *p;
788     typename __GC_HASH_SET::iterator iter;
789
790     __setiter<T>(set<T> *p);
791     T next();
792 };
793
794 class file : public pyiter<str *> {
795 public:
796     FILE *f;
797     int endoffile;
798     char print_lastchar;
799     int print_space;
800
801     str *name;
802     str *mode;
803     int closed;
804
805     file(str *name, str *mode=0);
806     file(FILE *g);
807     file();
808
809     str *read(int n=-1);
810     str *readline(int n=-1);
811     list<str *> *readlines();
812     int write(str *s);
813     int writelines(pyseq<str *> *p);
814     int flush();
815     int __ss_fileno();
816
817     void __check_closed();
818
819     virtual int getchar();
820     virtual int putchar(int c);
821     virtual int seek(int i, int w=0);
822     virtual int close();
823
824     int tell();
825
826     str *__repr__();
827
828     __iter<str *> *__iter__();
829
830 };
831
832 class __fileiter : public __iter<str *> {
833 public:
834     file *p;
835     __fileiter(file *p); 
836     str *next();
837 }; 
838
839 class object : public pyobj {
840 public:
841     object() { this->__class__ = cl_object; }
842
843 };
844
845 /* exceptions */
846
847 class Exception: public pyobj {
848 public:
849     str *msg;
850     Exception(str *msg=0) { this->msg = msg; }
851     str *__repr__() { return msg ? msg : new str("0"); }
852
853 #ifdef __SS_BIND
854    virtual PyObject *__to_py__() { return PyExc_Exception; }
855 #endif
856 };
857
858 class AssertionError : public Exception { 
859 public: 
860     AssertionError(str *msg=0) : Exception(msg) {} 
861 #ifdef __SS_BIND
862     PyObject *__to_py__() { return PyExc_AssertionError; }
863 #endif
864 };
865
866 class ValueError : public Exception { 
867 public: 
868     ValueError(str *msg=0) : Exception(msg) {} 
869 #ifdef __SS_BIND
870     PyObject *__to_py__() { return PyExc_ValueError; }
871 #endif
872 };
873
874 class KeyError : public Exception { 
875 public: 
876     KeyError(str *msg=0) : Exception(msg) {} 
877 #ifdef __SS_BIND
878     PyObject *__to_py__() { return PyExc_KeyError; }
879 #endif
880 };
881
882 class NotImplementedError : public Exception { 
883 public: 
884     NotImplementedError(str *msg=0) : Exception(msg) {} 
885 #ifdef __SS_BIND
886     PyObject *__to_py__() { return PyExc_NotImplementedError; }
887 #endif
888 };
889
890 class IndexError : public Exception { 
891 public: 
892     IndexError(str *msg=0) : Exception(msg) {} 
893 #ifdef __SS_BIND
894     PyObject *__to_py__() { return PyExc_IndexError; }
895 #endif
896 };
897
898 //class ZeroDivisionError : public Exception { public: ZeroDivisionError(str *msg=0) : Exception(msg) {} };
899
900 class IOError : public Exception { 
901 public: 
902     IOError(str *msg=0) : Exception(msg) {} 
903 #ifdef __SS_BIND
904     PyObject *__to_py__() { return PyExc_IOError; }
905 #endif
906 };
907
908 class OSError : public Exception { 
909 public: 
910     int __ss_errno;
911     str *filename; 
912     str *message;
913     str *strerror;
914
915     OSError(str *message=0); 
916     str *__str__();
917     str *__repr__();
918
919 #ifdef __SS_BIND
920     PyObject *__to_py__() { return PyExc_OSError; }
921 #endif
922 };
923
924 class SyntaxError : public Exception { 
925 public: 
926     SyntaxError(str *msg=0) : Exception(msg) {} 
927 #ifdef __SS_BIND
928     PyObject *__to_py__() { return PyExc_SyntaxError; }
929 #endif
930 };
931
932 class TypeError : public Exception { 
933 public: 
934     TypeError(str *msg=0) : Exception(msg) {} 
935 #ifdef __SS_BIND
936     PyObject *__to_py__() { return PyExc_TypeError; }
937 #endif
938 };
939
940 class RuntimeError : public Exception { 
941 public: 
942     RuntimeError(str *msg=0) : Exception(msg) {} 
943 #ifdef __SS_BIND
944     PyObject *__to_py__() { return PyExc_RuntimeError; }
945 #endif
946 };
947
948 class StopIteration : public Exception { public: StopIteration(str *msg=0) : Exception(msg) {} };
949
950 #define ASSERT(x, y) if(!(x)) throw new AssertionError(y);
951
952 #define FOR_IN(i, m, temp) \
953     __ ## temp = ___iter(m); \
954     while((__ ## temp)->for_has_next()) { \
955         i = (__ ## temp)->for_get_next(); \
956
957 #define FOR_IN_SEQ(i, m, temp, n) \
958     __ ## temp = m; \
959     for(__ ## n = 0; __ ## n < (__ ## temp)->units.size(); __ ## n ++) { \
960         i = (__ ## temp)->units[__ ## n]; \
961
962 #define FOR_IN_T2(i, m, obj, n) \
963     __ ## obj = m; \
964     for(__ ## n = 0; __ ## n < 2; __ ## n ++) { \
965         if (! __ ## n) i = (__ ## obj)->__getfirst__(); \
966         else i = (__ ## obj)->__getsecond__(); \
967
968 #define FAST_FOR(i, l, u, s, t1, t2) \
969     if(s==0) \
970         throw new ValueError(new str("range() step argument must not be zero")); \
971     for(__ ## t1 = l, __ ## t2 = u; __ ## t1 < __ ## t2; __ ## t1 += s) { \
972         i=__ ## t1; \
973
974 #define FAST_FOR_NEG(i, l, u, s, t1, t2) \
975     if(s==0) \
976         throw new ValueError(new str("range() step argument must not be zero")); \
977     for(__ ## t1 = l, __ ## t2 = u; __ ## t1 > __ ## t2; __ ## t1 += s) { \
978         i=__ ## t1; \
979
980 #define END_FOR }
981
982 template<class T> static inline int __wrap(T a, int i) {
983     #ifndef NOWRAP
984     if(i<0) return len(a)+i;
985     #endif
986     #ifdef BOUNDS 
987         if(i<0 || i>= len(a)) 
988             throw new IndexError(new str("index out of range")); 
989     #endif
990     return i;
991 }
992
993 #define ELEM(a,i) a->units[__wrap(a,i)]
994
995 /* representation */
996
997 template<class T> str *__str(T t) { if (!t) return new str("0"); return t->__str__(); }
998 template<class T> str *repr(T t) { if (!t) return new str("0"); return t->__repr__(); }
999
1000 str *__str(void *);
1001
1002 /* return pointer to class object */
1003
1004 template<class T> class_ *__type(T t) { return t->__class__; }
1005 template<> class_ *__type(int i);
1006 template<> class_ *__type(double d);
1007
1008 /* equality, comparison, math operators */
1009
1010 template<class T> int __eq(T a, T b) { return ((a&&b)?(a->__eq__(b)):(a==b)); }
1011 template<> int __eq(void *a, void *b);
1012 template<> int __eq(int a, int b);
1013 template<> int __eq(double a, double b);
1014 template<class T> int __ne(T a, T b) { return ((a&&b)?(a->__ne__(b)):(a!=b)); }
1015 template<> int __ne(void *a, void *b);
1016 template<> int __ne(int a, int b);
1017 template<> int __ne(double a, double b);
1018 template<class T> int __gt(T a, T b) { return a->__gt__(b); }
1019 template<> int __gt(int a, int b);
1020 template<> int __gt(double a, double b);
1021 template<class T> int __ge(T a, T b) { return a->__ge__(b); }
1022 template<> int __ge(int a, int b);
1023 template<> int __ge(double a, double b);
1024 template<class T> int __lt(T a, T b) { return a->__lt__(b); }
1025 template<> int __lt(int a, int b);
1026 template<> int __lt(double a, double b);
1027 template<class T> int __le(T a, T b) { return a->__le__(b); }
1028 template<> int __le(int a, int b);
1029 template<> int __le(double a, double b);
1030 template<class T> T __add(T a, T b) { return a->__add__(b); }
1031 template<> int __add(int a, int b);
1032 template<> double __add(double a, double b);
1033
1034 str *__add_strs(int n, ...);
1035
1036 /* deep copy */
1037
1038 template<class T> T __deepcopy(T t, dict<void *, pyobj *> *memo=0) {
1039     if(!memo) 
1040         memo = new dict<void *, pyobj *>();
1041
1042     T u = (T)(memo->get(t, 0));
1043
1044     if(u) return u;
1045     return (T)(t->__deepcopy__(memo));
1046 }
1047
1048 template<> int __deepcopy(int i, dict<void *, pyobj *> *);
1049 template<> double __deepcopy(double d, dict<void *, pyobj *> *);
1050 template<> void *__deepcopy(void *p, dict<void *, pyobj *> *);
1051
1052 template<class T> T __copy(T t) { return (T)(t->__copy__()); }
1053 template<> int __copy(int i);
1054 template<> double __copy(double d);
1055 template<> void *__copy(void *p);
1056
1057 template<class T> T __mul(int n, T a) {
1058     return a->__mul__(n);
1059 }
1060
1061 template<class T> int len(T x) {
1062     return x->__len__();
1063 }
1064
1065 /* bool */
1066
1067 int __bool();
1068
1069 template<class T> int __bool(T x) {
1070     return (x && x->__nonzero__());
1071 }
1072 template<> int __bool(int x);
1073 template<> int __bool(bool x);
1074 template<> int __bool(double x);
1075
1076 /* logical and, or */
1077
1078 #define __OR(a, b, t) ((__bool(__ ## t = a))?(__ ## t):(b))
1079 #define __AND(a, b, t) ((!__bool(__ ## t = a))?(__ ## t):(b))
1080
1081 /* __iter<T> methods */
1082
1083 template<class T> int __iter<T>::for_has_next() {
1084     try {
1085         temp = next();
1086     } catch(StopIteration *) {
1087         return 0;
1088     }
1089     return 1;
1090 }
1091 template<class T> T __iter<T>::for_get_next() {
1092     return temp;
1093 }
1094
1095 /* dict<K, V> methods */
1096
1097 template<class K, class V> dict<K,V>::dict() {
1098     this->__class__ = cl_dict;
1099 }
1100
1101 template<class K, class V> dict<K, V>::dict(int count, ...)  {
1102     this->__class__ = cl_dict;
1103     va_list ap;
1104     va_start(ap, count);
1105     for(int i=0; i<count; i++) {
1106         typedef tuple2<K, V> * bert;
1107         bert t = va_arg(ap, bert);
1108         __setitem__(t->__getfirst__(), t->__getsecond__());
1109     }
1110     va_end(ap);
1111 }
1112
1113 #ifdef __SS_BIND
1114 template<class K, class V> dict<K, V>::dict(PyObject *p) {
1115     if(!PyDict_Check(p)) 
1116         throw new TypeError(new str("error in conversion to Shed Skin (dictionary expected)"));
1117     
1118     this->__class__ = cl_dict;
1119     PyObject *key, *value;
1120     ssize_t pos = 0;
1121     while(PyDict_Next(p, &pos, &key, &value)) 
1122         __setitem__(__to_ss<K>(key), __to_ss<V>(value));
1123
1124
1125 template<class K, class V> PyObject *dict<K, V>::__to_py__() {
1126     PyObject *p = PyDict_New();
1127     int len = this->__len__();
1128     for (it = units.begin(); it != units.end(); it++)
1129         PyDict_SetItem(p, __to_py(it->first), __to_py(it->second));
1130     return p;
1131 }
1132 #endif
1133
1134 template<class K, class V> int dict<K,V>::__setitem__(K k, V v) {
1135     units[k] = v;
1136     return 0;
1137 }
1138
1139 template<class K, class V> V dict<K,V>::get(K k) {
1140     it = units.find(k);
1141     if(it == units.end())
1142         return 0;
1143     return it->second;
1144 }
1145 template<class K, class V> V dict<K,V>::get(K k, V v) {
1146     it = units.find(k);
1147     if(it == units.end())
1148         return v;
1149     return it->second;
1150 }
1151
1152 template<class K, class V> V dict<K,V>::setdefault(K k, V v) {
1153     it = units.find(k);
1154     if(it == units.end())
1155     {
1156         this->__setitem__(k, v);
1157         return v;
1158     }
1159
1160     return it->second;
1161 }
1162
1163 template<class K, class V> V dict<K,V>::pop(K k) {
1164     V v = this->__getitem__(k);
1165     units.erase(k);
1166     return v;
1167 }
1168
1169 template<class K, class V> int dict<K,V>::__delitem__(K k) {
1170     units.erase(k);
1171     return 0;
1172 }
1173
1174 template<class K, class V> int dict<K,V>::__len__() {
1175     return units.size();
1176 }
1177
1178 template<class K, class V> tuple2<K,V> *dict<K,V>::popitem() {
1179     it = units.begin();
1180     tuple2<K, V> *t = new tuple2<K, V>(2, it->first, it->second);
1181     units.erase(it->first);
1182     return t;
1183 }
1184
1185 template<class K, class V> list<K> *dict<K,V>::keys() {
1186     list<K> *l = new list<K>();
1187     l->units.reserve(__len__());
1188     for (it = units.begin(); it != units.end(); it++)
1189         l->append(it->first);
1190     return l;
1191 }
1192
1193 template<class K, class V> int dict<K,V>::has_key(K k) {
1194     return units.find(k) != units.end();
1195 }
1196
1197 template<class K, class V> int dict<K,V>::clear() {
1198     this->units.clear();
1199     return 0;
1200 }
1201
1202 template<class K, class V> dict<K,V> *dict<K,V>::copy() {
1203     dict<K,V> *n = new dict<K,V>();
1204     n->units = units;
1205     return n;
1206 }
1207
1208 template<class K, class V> dict<K,V> *dict<K,V>::__copy__() {
1209     return copy();
1210 }
1211
1212 template<class K, class V> dict<K,V> *dict<K,V>::__deepcopy__(dict<void *, pyobj *> *memo) {
1213     dict<K,V> *n = new dict<K,V>();
1214     memo->__setitem__(this, n);
1215     for (it = units.begin(); it != units.end(); it++)
1216         n->units[__deepcopy(it->first, memo)] = __deepcopy(it->second, memo);
1217     return n;
1218 }
1219
1220 template<class K, class V> dict<K,V> *__dict(dict<K,V> *p) {
1221     return p->copy();
1222 }
1223
1224 template<class K, class V> list<V> *dict<K,V>::values() {
1225     list<V> *l = new list<V>();
1226     l->units.reserve(__len__());
1227     for (it = units.begin(); it != units.end(); it++)
1228         l->append(it->second);
1229     return l;
1230 }
1231
1232 template<class K, class V> int dict<K,V>::update(dict<K,V> *e) {
1233     for (it = e->units.begin(); it != e->units.end(); it++)
1234         this->__setitem__(it->first, it->second);
1235     return 0;
1236 }
1237
1238 template<class K, class V> list<tuple2<K,V> *> *dict<K,V>::items() {
1239     list<tuple2<K,V> *> *l = new list<tuple2<K,V> *>();
1240     l->units.reserve(__len__());
1241     for (it = units.begin(); it != units.end(); it++)
1242         l->append(new tuple2<K,V>(2, it->first, it->second));
1243     return l;
1244 }
1245
1246 template<class K, class V> int dict<K, V>::__contains__(K k) {
1247     return units.find(k) != units.end();
1248 }
1249
1250 template<class K, class V> str *dict<K,V>::__repr__() {
1251     str *r = new str("{");
1252     int i = units.size();
1253
1254     for (it = units.begin(); it != units.end(); i--, it++) {
1255         r->unit += repr(it->first)->unit + ": " + repr(it->second)->unit;
1256         if( i > 1 )
1257            r->unit += ", ";
1258     }
1259
1260     r->unit += "}";
1261     return r;
1262 }
1263
1264 template<class K, class V> V dict<K,V>::__getitem__(K k) {
1265     typename __GC_HASH_MAP::iterator iter;
1266     iter = units.find(k);
1267     if(iter == units.end()) throw new KeyError(__str(k));
1268     return iter->second;
1269 }
1270
1271 template<class K, class V> int dict<K,V>::__addtoitem__(K k, V v) {
1272     typename __GC_HASH_MAP::iterator iter;
1273     iter = units.find(k);
1274     if(iter == units.end()) throw new KeyError(__str(k));
1275     iter->second = __add(iter->second, v);
1276     return 0;
1277 }
1278
1279 template<class K, class V> int dict<K,V>::__eq__(pyobj *e) {
1280    dict<K, V> *b = (dict<K,V> *)e;
1281    if( b->__len__() != this->__len__()) return 0;
1282
1283    K k;
1284    __iter<K> *__0;
1285    FOR_IN(k, this, 0)
1286        if( !b->__contains__(k) || !__eq(this->__getitem__(k), b->__getitem__(k)))
1287            return 0;
1288    END_FOR
1289    return 1;
1290
1291
1292 template<class K, class V> __dictiterkeys<K, V> *dict<K, V>::__iter__() { 
1293     return new __dictiterkeys<K, V>(this);
1294 }
1295
1296 template<class K, class V> __dictiterkeys<K, V> *dict<K, V>::iterkeys() {
1297     return new __dictiterkeys<K, V>(this);
1298 }
1299
1300 template<class K, class V> __dictitervalues<K, V> *dict<K, V>::itervalues() {
1301     return new __dictitervalues<K, V>(this);
1302
1303
1304 template<class K, class V> __dictiteritems<K, V> *dict<K, V>::iteritems() {
1305     return new __dictiteritems<K, V>(this);
1306
1307     
1308 /* list<T> methods */
1309
1310 template<class T> list<T>::list() {
1311     this->__class__ = cl_list;
1312 }
1313
1314 template<class T> list<T>::list(int count, ...)  {
1315     this->__class__ = cl_list;
1316     va_list ap;
1317     va_start(ap, count);
1318     for(int i=0; i<count; i++) {
1319         T t = va_arg(ap, T);
1320         append(t);
1321     }
1322     va_end(ap);
1323 }
1324
1325 #ifdef __SS_BIND
1326 template<class T> list<T>::list(PyObject *p) {
1327     if(!PyList_Check(p)) 
1328         throw new TypeError(new str("error in conversion to Shed Skin (list expected)"));
1329
1330     this->__class__ = cl_list;
1331     int size = PyList_Size(p);
1332     for(int i=0; i<size; i++)
1333         append(__to_ss<T>(PyList_GetItem(p, i)));
1334 }
1335
1336 template<class T> PyObject *list<T>::__to_py__() {
1337     int len = this->__len__();
1338     PyObject *p = PyList_New(len);
1339     for(int i=0; i<len; i++)
1340         PyList_SetItem(p, i, __to_py(this->__getitem__(i)));
1341     return p;
1342 }
1343 #endif
1344
1345 /*template<class T> void list<T>::init(int count, ...)  {
1346     clear();
1347
1348     va_list ap;
1349     va_start(ap, count);
1350     for(int i=0; i<count; i++) {
1351         T t = va_arg(ap, T);
1352         append(t);
1353     }
1354     va_end(ap);
1355 }*/
1356
1357 template<class T> void list<T>::clear() {
1358     units.resize(0);
1359 }
1360
1361 template<class T> int list<T>::__eq__(pyobj *p) {
1362    list<T> *b = (list<T> *)p;
1363    if( b->__len__() != this->__len__()) return 0;
1364
1365    for(int i = 0; i < this->__len__(); i++)
1366        if(!__eq(this->units[i], b->units[i]))
1367            return 0;
1368    return 1;
1369 }
1370
1371 template<class T> int list<T>::extend(pyiter<T> *p) {
1372     __iter<T> *__0;
1373     T e;
1374     FOR_IN(e, p, 0)
1375         append(e); 
1376     END_FOR
1377     return 0;
1378 }
1379
1380 template<class T> int list<T>::extend(pyseq<T> *p) {
1381     int l1, l2;
1382     l1 = this->__len__(); l2 = p->__len__();
1383
1384     this->units.resize(l1+l2);
1385     memcpy(&(this->units[l1]), &(p->units[0]), sizeof(T)*l2);
1386     return 0;
1387 }
1388
1389 template<class T> int list<T>::__setitem__(int i, T e) {
1390     i = __wrap(this, i);
1391     units[i] = e;
1392     return 0;
1393 }
1394
1395 template<class T> int list<T>::__delitem__(int i) {
1396     i = __wrap(this, i);
1397     units.erase(units.begin()+i,units.begin()+i+1);
1398     return 0;
1399 }
1400
1401 template<class T> int list<T>::__remove__(int i) { 
1402     i = __wrap(this, i);
1403     units.erase(units.begin()+i,units.begin()+i+1);
1404     return 0;
1405 }
1406
1407 template<class T> int list<T>::empty() {
1408     return units.empty();
1409 }
1410
1411 template<class T> list<T> *list<T>::__slice__(int x, int l, int u, int s) {
1412     list<T> *c = new list<T>();
1413     this->slice(x, l, u, s, c);
1414     return c;
1415 }
1416
1417 template<class T> int list<T>::__setslice__(int x, int l, int u, int s, pyiter<T> *b) {
1418     int i, j;
1419     T e;
1420
1421     list<T> *la = new list<T>(); /* XXX optimize for sequences */
1422     __iter<T> *__0;
1423     FOR_IN(e, b, 0)
1424         la->units.push_back(e);
1425     END_FOR
1426
1427     slicenr(x, l, u, s, this->__len__());
1428
1429     if(x&4) { // x&4: extended slice (step 's' is given), check if sizes match 
1430         int slicesize; 
1431         if(l == u) slicesize = 0; // XXX ugly
1432         else if(s > 0 && u < l) slicesize=0; 
1433         else if(s < 0 && l < u) slicesize=0;
1434         else {
1435             int slicelen = std::abs(u-l);
1436             int absstep = std::abs(s);
1437             slicesize = slicelen/absstep; 
1438             if(slicelen%absstep) slicesize += 1;
1439         }
1440
1441         if(slicesize != len(la)) 
1442                 throw new ValueError(__mod(new str("attempt to assign sequence of size %d to extended slice of size %d"), new tuple2<int,int>(2, len(la), slicesize)));  
1443     }
1444
1445     if(s == 1) {
1446         if(!(x&4) && u < l) 
1447             this->units.insert(this->units.begin()+l, la->units.begin(), la->units.end());
1448         else if(l < u) {
1449             this->units.erase(this->units.begin()+l, this->units.begin()+u);
1450             this->units.insert(this->units.begin()+l, la->units.begin(), la->units.end());
1451         } 
1452     }
1453     else {
1454         if(s > 0)
1455             for(i = 0, j = l; j < u; i++, j += s)
1456                 this->units[j] = la->units[i];
1457         else
1458             for(i = 0, j = l; j > u; i++, j += s)
1459                 this->units[j] = la->units[i];
1460     }
1461
1462     return 0;
1463 }
1464
1465 template<class T> int list<T>::__delete__(int i) {
1466     i = __wrap(this, i);
1467     units.erase(units.begin()+i,units.begin()+i+1);
1468     return 0;
1469 }
1470
1471 template<class T> int list<T>::__delete__(int x, int l, int u, int s) {
1472     slicenr(x, l, u, s, this->__len__());
1473
1474     if(s == 1)
1475         units.erase(units.begin()+l,units.begin()+u);
1476     else {
1477         std::vector<T, gc_allocator<T> > v;
1478         for(int i=0; i<this->__len__();i++)
1479             if((i+l) % s)
1480                 v.push_back(this->units[i]);
1481         units = v;
1482     }
1483     return 0;
1484 }
1485
1486 template<class T> int list<T>::__delslice__(int a, int b) {
1487     units.erase(units.begin()+a,units.begin()+b);
1488     return 0;
1489 }
1490
1491 template<class T> int list<T>::__contains__(T a) {
1492     for(int i=0; i<this->__len__(); i++)
1493         if(__eq(this->units[i], a))
1494             return 1;
1495     return 0;
1496 }
1497
1498 template<class T> list<T> *list<T>::__add__(list<T> *b) {
1499     int l1 = this->__len__();
1500     int l2 = b->__len__();
1501
1502     list<T> *c = new list<T>();
1503     c->units.resize(l1+l2);
1504     
1505     memcpy(&(c->units[0]), &(this->units[0]), sizeof(T)*l1);
1506     memcpy(&(c->units[l1]), &(b->units[0]), sizeof(T)*l2);
1507     
1508     return c;
1509 }
1510
1511 template<class T> list<T> *list<T>::__mul__(int b) {
1512     list<T> *c = new list<T>();
1513     if(b<=0) return c;
1514     int len = this->units.size();
1515     if(len==1)
1516         c->units.assign(b, this->units[0]);
1517     else {
1518         c->units.resize(b*len);
1519         for(int i=0; i<b; i++)
1520             memcpy(&(c->units[i*len]), &(this->units[0]), sizeof(T)*len);
1521     }
1522     return c;
1523 }
1524
1525 template<class T> list<T> *list<T>::__copy__() {
1526     list<T> *c = new list<T>();
1527     c->units = this->units;
1528     return c;
1529 }
1530
1531 template<class T> list<T> *list<T>::__deepcopy__(dict<void *, pyobj *> *memo) {
1532     list<T> *c = new list<T>();
1533     memo->__setitem__(this, c);
1534     c->units.resize(this->__len__());
1535     for(int i=0; i<this->__len__(); i++)
1536         c->units[i] = __deepcopy(this->units[i], memo);
1537     return c;
1538 }
1539
1540 template<class T> list<T> *list<T>::__iadd__(pyiter<T> *b) {
1541     extend(b);
1542     return this;
1543 }
1544 template<class T> list<T> *list<T>::__iadd__(pyseq<T> *b) {
1545     extend(b);
1546     return this;
1547 }
1548
1549 template<class T> list<T> *list<T>::__imul__(int n) { 
1550     int l1 = this->__len__();
1551     this->units.resize(l1*n);
1552     for(int i = 1; i <= n-1; i++)
1553         memcpy(&(this->units[l1*i]), &(this->units[0]), sizeof(T)*l1);
1554     return this;
1555 }
1556
1557 template<class T> int list<T>::index(T a) { return index(a, 0, this->__len__()); }
1558 template<class T> int list<T>::index(T a, int s) { return index(a, s, this->__len__()); }
1559 template<class T> int list<T>::index(T a, int s, int e) {
1560     int one = 1;
1561     slicenr(7, s, e, one, this->__len__());
1562     for(int i = s; i<e;i++)
1563         if(__eq(a,units[i]))
1564             return i;
1565     throw new ValueError(new str("list.index(x): x not in list"));
1566
1567
1568 template<class T> int list<T>::count(T a) {
1569     int c = 0;
1570     int len = this->__len__();
1571     for(int i = 0; i<len;i++)
1572         if(__eq(a,units[i]))
1573             c++;
1574     return c;
1575 }
1576
1577 template<class T> str *list<T>::__repr__() {
1578     str *r = new str("[");
1579     int len = this->__len__();
1580     for(int i = 0; i<len;i++) {
1581         r->unit += repr(units[i])->unit;
1582         if (i<len-1)
1583             r->unit += ", ";
1584     }
1585     r->unit += "]";
1586     return r;
1587 }
1588
1589 template<class T> T list<T>::pop(int m) {
1590     if (m<0) m = this->__len__()+m;
1591     T e = units[m];
1592     units.erase(units.begin()+m);
1593     return e;
1594 }
1595 template<class T> T list<T>::pop() {
1596     return pop(-1);
1597 }
1598
1599 template<class T> int list<T>::reverse() {
1600     std::reverse(this->units.begin(), this->units.end());
1601     return 0;
1602 }
1603
1604 template<class T> int list<T>::sort(int (*cmp)(T, T), int key, int reverse) {
1605     if(cmp) {
1606         if(reverse)
1607             std::sort(units.begin(), units.end(), cpp_cmp_custom_rev<T>(cmp));
1608         else
1609             std::sort(units.begin(), units.end(), cpp_cmp_custom<T>(cmp));
1610     } else {
1611         if(reverse)
1612             std::sort(units.begin(), units.end(), cpp_cmp_rev<T>);
1613         else
1614             std::sort(units.begin(), units.end(), cpp_cmp<T>);
1615     }
1616
1617     return 0;
1618 }
1619
1620 template<class T> int list<T>::insert(int m, T e) {
1621     if (m<0) m = this->__len__()+m;
1622     units.insert(units.begin()+m, e);
1623     return 0;
1624 }
1625
1626 template<class T> int list<T>::remove(T e) {
1627     for(int i = 0; i < this->__len__(); i++)
1628         if(__eq(units[i], e)) {
1629             units.erase(units.begin()+i);
1630             return 0;
1631         }
1632     return 0;
1633 }
1634
1635 /* set<T> methods */
1636
1637 template<class T> set<T>::set(int frozen) {
1638     this->__class__ = cl_set;
1639     this->frozen = frozen;
1640 }
1641
1642 #ifdef __SS_BIND
1643 #if (PY_MAJOR_VERSION == 2)
1644 #if (PY_MINOR_VERSION > 4)
1645
1646 template<class T> set<T>::set(PyObject *p) {
1647     if(PyTuple_Check(p) || PyList_Check(p) || PyDict_Check(p) || PyInt_Check(p) || PyFloat_Check(p) || PyString_Check(p)) // XXX
1648         throw new TypeError(new str("error in conversion to Shed Skin (set expected)"));
1649
1650     this->__class__ = cl_set;
1651     PyObject *iter = PyObject_GetIter(p), *item;
1652     while(item = PyIter_Next(iter)) {
1653         add(__to_ss<T>(item));
1654         Py_DECREF(item);
1655     }
1656     Py_DECREF(iter); 
1657
1658
1659 template<class T> PyObject *set<T>::__to_py__() {
1660     PyObject *p = PyObject_CallObject((PyObject *)(&PySet_Type), 0);
1661     for(it1 = units.begin(); it1 != units.end(); it1++) 
1662         PyObject_CallMethod(p, "add", "O", __to_py(*it1));
1663     return p;
1664 }
1665
1666 #endif
1667 #endif
1668 #endif
1669
1670 template<class T> set<T>::set(pyiter<T> *p, int frozen) {
1671     this->__class__ = cl_set;
1672     this->frozen = frozen;
1673
1674     update(p);
1675 }
1676
1677 template<class T> int set<T>::__eq__(pyobj *p) {
1678     set<T> *b = (set<T> *)p;
1679
1680     if( b->__len__() != this->__len__()) return 0;
1681
1682     for(it1 = units.begin(); it1 != units.end(); it1++)
1683         if(!b->__contains__(*it1))
1684             return 0;
1685     return 1;
1686 }
1687
1688 template<class T> int set<T>::__hash__() { 
1689     if(!this->frozen)
1690         throw new TypeError(new str("set objects are unhashable"));
1691     list<int> *seeds = new list<int>();
1692     for(it1 = units.begin(); it1 != units.end(); it1++)
1693         seeds->append(hasher<T>(*it1));
1694     seeds->sort(0, 0, 0); /* XXX */
1695     int seed = 0;
1696     for(int i = 0; i < len(seeds); i++)
1697         seed = hash_combine(seed, seeds->units[i]);
1698     return seed;
1699 }
1700
1701 template<class T> int set<T>::__ge__(set<T> *s) {
1702     return issuperset(s);
1703 }
1704
1705 template<class T> int set<T>::__le__(set<T> *s) {
1706     return issubset(s);
1707 }
1708
1709 template<class T> int set<T>::__lt__(set<T> *s) {
1710     return issubset(s);
1711 }
1712
1713 template<class T> int set<T>::__gt__(set<T> *s) {
1714     return issuperset(s);
1715 }
1716
1717 template<class T> int set<T>::__cmp__(pyobj *p) { /* optimize */
1718     set<T> *b = (set<T> *)p;
1719     if(issubset(b)) return -1;
1720     else if(issuperset(b)) return 1;
1721     return 0;
1722 }
1723
1724 template<class T> int set<T>::add(T x) {
1725     units.insert(x);
1726     return 0;
1727 }
1728 template<class T> int set<T>::remove(T x) {
1729     units.erase(x);
1730     return 0;
1731 }
1732 template<class T> int set<T>::discard(T x) {
1733     units.erase(x);
1734     return 0;
1735 }
1736
1737 template<class T> T set<T>::pop() {
1738     T e = *units.begin();
1739     units.erase(units.begin());
1740     return e;
1741 }
1742
1743 template<class T> set<T> *set<T>::__ss_union(pyiter<T> *s) {
1744     set<T> *c = new set<T>(this->frozen);
1745     c->units = units; 
1746     c->update(s);
1747
1748     return c;
1749 }
1750
1751 template<class T> set<T> *set<T>::__ss_union(set<T> *s) {
1752     set<T> *a, *b;
1753     set<T> *c = new set<T>(this->frozen);
1754
1755     if(len(s) < len(this)) { a = s; b = this; }
1756     else { a = this; b = s; }
1757
1758     c->units = b->units; 
1759     c->update(a);
1760
1761     return c;
1762 }
1763
1764 template<class T> int set<T>::update(pyiter<T> *s) {
1765     T e;
1766     __iter<T> *__0;
1767     FOR_IN(e, s, 0)
1768         add(e);
1769     END_FOR
1770     return 0;
1771 }
1772
1773 template<class T> int set<T>::update(set<T> *s) {
1774     for(it1 = s->units.begin(); it1 != s->units.end(); it1++)
1775         add(*it1);
1776
1777     return 0;
1778 }
1779
1780 template<class T> int set<T>::clear() {
1781     units.clear();
1782     return 0;
1783 }
1784
1785 template<class T> set<T> *set<T>::difference(set<T> *s) { 
1786     set<T> *c = new set<T>(this->frozen);
1787     T e;
1788     __iter<T> *__0;
1789     FOR_IN(e, this, 0)
1790         if(!s->__contains__(e))
1791             c->add(e);
1792     END_FOR
1793     return c;
1794 }
1795 template<class T> set<T> *set<T>::__sub__(set<T> *s) {
1796     return difference(s);
1797 }
1798
1799 template<class T> int set<T>::difference_update(set<T> *s) {
1800     set<T> *c = difference(s);
1801     units = c->units; /* XXX don't copy */
1802     return 0;
1803 }
1804
1805
1806 template<class T> int set<T>::symmetric_difference_update(set<T> *s) {
1807     set<T> *c = symmetric_difference(s);
1808     units = c->units;
1809     return 0;
1810 }
1811
1812 template<class T> set<T> *set<T>::symmetric_difference(set<T> *s) {
1813     set<T> *a, *b;
1814     set<T> *c = new set<T>(this->frozen);
1815
1816     if(len(s) < len(this)) { a = s; b = this; }
1817     else { a = this; b = s; } 
1818
1819     c->units = b->units;
1820
1821     for(it1 = a->units.begin(); it1 != a->units.end(); it1++) {
1822         T e = *it1;
1823         if (!c->units.erase(e)) {
1824             c->add(e);
1825         }
1826     }
1827
1828     return c;
1829 }
1830
1831 template<class T> set<T> *set<T>::intersection(set<T> *s) {
1832     set<T> *a, *b;
1833     set<T> *c = new set<T>(this->frozen);
1834
1835     if(len(s) < len(this)) { a = s; b = this; }
1836     else { a = this; b = s; } 
1837
1838     for(it1 = a->units.begin(); it1 != a->units.end(); it1++) {
1839         T e = *it1;
1840         if(b->__contains__(e))
1841             c->add(e);
1842     }
1843
1844     return c;
1845 }
1846
1847 template<class T> set<T> *set<T>::__and__(set<T> *s) {
1848     return intersection(s);
1849 }
1850 template<class T> set<T> *set<T>::__or__(set<T> *s) {
1851     return __ss_union(s);
1852 }
1853 template<class T> set<T> *set<T>::__xor__(set<T> *s) {
1854     return symmetric_difference(s);
1855 }
1856 template<class T> set<T> *set<T>::__iand__(set<T> *s) {
1857     units = intersection(s)->units;
1858     return this;
1859 }
1860 template<class T> set<T> *set<T>::__ior__(set<T> *s) {
1861     units = __ss_union(s)->units;
1862     return this;
1863 }
1864 template<class T> set<T> *set<T>::__ixor__(set<T> *s) {
1865     units = symmetric_difference(s)->units;
1866     return this;
1867 }
1868 template<class T> set<T> *set<T>::__isub__(set<T> *s) {
1869     units = difference(s)->units;
1870     return this;
1871 }
1872
1873 template<class T> int set<T>::intersection_update(set<T> *s) {
1874     set<T> *c = intersection(s);
1875     units = c->units;
1876     return 0;
1877 }
1878
1879 template<class T> set<T> *set<T>::copy() {
1880     set<T> *c = new set<T>(this->frozen);
1881     c->units = units;
1882     return c;
1883 }
1884
1885 template<class T> int set<T>::issubset(set<T> *s) {
1886     if(__len__() > s->__len__()) { return 0; }
1887     T e;
1888     __iter<T> *__0;
1889     FOR_IN(e, this, 0)
1890         if(!s->__contains__(e))
1891             return 0;
1892     END_FOR
1893     return 1;
1894 }
1895
1896 template<class T> int set<T>::issuperset(set<T> *s) {
1897     if(__len__() < s->__len__()) return 0;
1898     T e;
1899     __iter<T> *__0;
1900     FOR_IN(e, s, 0)
1901         if(!__contains__(e))
1902             return 0;
1903     END_FOR
1904     return 1;
1905 }
1906
1907 template<class T> int set<T>::issubset(pyiter<T> *s) {
1908     return issubset(new set<T>(s));
1909 }
1910
1911 template<class T> int set<T>::issuperset(pyiter<T> *s) {
1912     return issuperset(new set<T>(s));
1913 }
1914
1915 template<class T> int set<T>::__len__() {
1916     return units.size();
1917 }
1918
1919 template<class T> str *set<T>::__repr__() {
1920     str *r;
1921     if(this->frozen) r = new str("frozenset([");
1922     else r = new str("set([");
1923
1924     int rest = units.size()-1;
1925
1926     for (it1 = units.begin(); it1 != units.end(); it1++, rest--) {
1927         r->unit += repr(*it1)->unit;
1928         if(rest)
1929            r->unit += ", ";
1930     }
1931     r->unit += "])";
1932     return r;
1933 }
1934
1935 template<class T> int set<T>::__contains__(T a) {
1936     return units.find(a) != units.end();
1937 }
1938
1939 template<class T> set<T> *set<T>::__copy__() {
1940     set<T> *c = new set<T>();
1941     c->units = this->units;
1942     return c;
1943 }
1944
1945 template<class T> set<T> *set<T>::__deepcopy__(dict<void *, pyobj *> *memo) {
1946     set<T> *c = new set<T>();
1947     memo->__setitem__(this, c);
1948     for (it1 = units.begin(); it1 != units.end(); it1++) 
1949         c->units.insert(__deepcopy(*it1, memo));
1950     return c;
1951 }
1952
1953 /* tuple2<T, T> */
1954
1955 template<class T> tuple2<T, T>::tuple2() {
1956     this->__class__ = cl_tuple;
1957 }
1958
1959 template<class T> tuple2<T, T>::tuple2(int count, ...) {
1960     this->__class__ = cl_tuple;
1961     va_list ap;
1962     va_start(ap, count);
1963     for(int i=0; i<count; i++) {
1964         T t = va_arg(ap, T);
1965         this->units.push_back(t);
1966     }
1967     va_end(ap);
1968 }
1969
1970 template<class T> T tuple2<T, T>::__getfirst__() { 
1971     return this->units[0]; 
1972 }
1973 template<class T> T tuple2<T, T>::__getsecond__() { 
1974     return this->units[1]; 
1975 }
1976 template<class T> T tuple2<T, T>::__getfast__(int i) { 
1977     return this->units[i]; 
1978 }
1979
1980 template<class T> str *tuple2<T, T>::__repr__() {
1981     str *r = new str("(");
1982     for(int i = 0; i<this->__len__();i++) {
1983         r->unit += repr(this->units[i])->unit;
1984         if(this->__len__() == 1 )
1985             r->unit += ",";
1986         if(i<this->__len__()-1)
1987             r->unit += ", ";
1988     }
1989     r->unit += ")";
1990     return r;
1991 }
1992
1993 template<class T> tuple2<T,T> *tuple2<T, T>::__add__(tuple2<T,T> *b) {
1994     tuple2<T,T> *c = new tuple2<T,T>();
1995     for(int i = 0; i<this->__len__();i++)
1996         c->units.push_back(this->units[i]);
1997     for(int i = 0; i<b->__len__();i++)
1998         c->units.push_back(b->units[i]);
1999     return c;
2000 }
2001 template<class T> tuple2<T,T> *tuple2<T, T>::__iadd__(tuple2<T,T> *b) {
2002     return __add__(b);
2003 }
2004
2005 template<class T> tuple2<T,T> *tuple2<T, T>::__mul__(int b) {
2006     tuple2<T,T> *c = new tuple2<T,T>();
2007     if(b<=0) return c;
2008     int hop = this->__len__(); /* XXX merge with list */
2009     if(hop==1)
2010         c->units.insert(c->units.begin(), b, this->units[0]);
2011     else
2012         for(int i=0; i<b; i++)
2013             for(int j=0; j<hop; j++)
2014                 c->units.push_back(this->units[j]);
2015     return c;
2016 }
2017 template<class T> tuple2<T,T> *tuple2<T, T>::__imul__(int b) {
2018     return __mul__(b);
2019 }
2020
2021 /*template<class T> void tuple2<T, T>::init(int count, ...) {
2022     this->units.resize(0);
2023
2024     va_list ap;
2025     va_start(ap, count);
2026     for(int i=0; i<count; i++) {
2027         T t = va_arg(ap, T);
2028         this->units.push_back(t);
2029     }
2030     va_end(ap);
2031 } */
2032
2033 template<class T> int tuple2<T, T>::__contains__(T a) {
2034     for(int i=0; i<this->__len__(); i++)
2035         if(__eq(this->units[i], a))
2036             return 1;
2037     return 0;
2038 }
2039
2040 template<class T> int tuple2<T, T>::__eq__(pyobj *p) {
2041     tuple2<T,T> *b;
2042     b = (tuple2<T,T> *)p;
2043     if( b->__len__() != this->__len__()) return 0;
2044     for(int i = 0; i < this->__len__(); i++)
2045         if(!__eq(this->units[i], b->units[i]))
2046             return 0;
2047     return 1;
2048 }
2049
2050 template<class T> tuple2<T,T> *tuple2<T, T>::__slice__(int x, int l, int u, int s) {
2051     tuple2<T,T> *c = new tuple2<T,T>();
2052     this->slice(x, l, u, s, c);
2053     return c;
2054 }
2055
2056 template<class T> int tuple2<T, T>::__hash__() {
2057     int seed = 0;
2058     for(int i = 0; i<this->__len__();i++) {
2059         seed = hash_combine(seed, hasher<T>(this->units[i]));
2060     }
2061     return seed;
2062 }
2063
2064 template<class T> tuple2<T,T> *tuple2<T,T>::__copy__() {
2065     tuple2<T,T> *c = new tuple2<T,T>();
2066     c->units = this->units;
2067     return c;
2068 }
2069
2070 template<class T> tuple2<T,T> *tuple2<T,T>::__deepcopy__(dict<void *, pyobj *> *memo) {
2071     tuple2<T,T> *c = new tuple2<T,T>();
2072     memo->__setitem__(this, c);
2073     c->units.resize(this->__len__());
2074     for(int i=0; i<this->__len__(); i++)
2075         c->units[i] = __deepcopy(this->units[i], memo);
2076     return c;
2077 }
2078
2079 #ifdef __SS_BIND
2080 template<class T> tuple2<T, T>::tuple2(PyObject *p) {
2081     if(!PyTuple_Check(p)) 
2082         throw new TypeError(new str("error in conversion to Shed Skin (tuple expected)"));
2083
2084     this->__class__ = cl_tuple;
2085     int size = PyTuple_Size(p);
2086     for(int i=0; i<size; i++)
2087         append(__to_ss<T>(PyTuple_GetItem(p, i)));
2088 }
2089
2090 template<class T> PyObject *tuple2<T, T>::__to_py__() {
2091     int len = this->__len__();
2092     PyObject *p = PyTuple_New(len);
2093     for(int i=0; i<len; i++)
2094         PyTuple_SetItem(p, i, __to_py(this->__getitem__(i)));
2095     return p;
2096 }
2097 #endif
2098
2099 /* tuple2<A, B> */
2100
2101 template<class A, class B> tuple2<A, B>::tuple2() {
2102     this->__class__ = cl_tuple;
2103 }
2104
2105 template<class A, class B> tuple2<A, B>::tuple2(int n, A a, B b) {
2106     this->__class__ = cl_tuple;
2107     first = a;
2108     second = b;
2109 }
2110
2111 template<class A, class B> A tuple2<A, B>::__getfirst__() { 
2112     return first; 
2113 }
2114 template<class A, class B> B tuple2<A, B>::__getsecond__() { 
2115     return second; 
2116 }
2117
2118 /*template<class A, class B> void tuple2<A, B>::init(int count, A a, B b) {
2119     first = a;
2120     second = b;
2121 } */
2122
2123 template<class A, class B> int tuple2<A, B>::__contains__(A a) {
2124     return __eq(first, a);
2125 }
2126
2127 template<class A, class B> int tuple2<A, B>::__contains__(B b) {
2128     return __eq(second, b);
2129 }
2130
2131 template<class A, class B> int tuple2<A, B>::__len__() {
2132     return 2;
2133 }
2134
2135 template<class A, class B> int tuple2<A, B>::__eq__(tuple2<A,B> *b) {
2136     return __eq(first, b->__getfirst__()) && __eq(second, b->__getsecond__());
2137 }
2138
2139 template<class A, class B> int tuple2<A, B>::__cmp__(pyobj *p) {
2140     tuple2<A,B> *b = (tuple2<A,B> *)p;
2141     if(int c = __cmp(first, b->first)) return c;
2142     return __cmp(second, b->second);
2143 }
2144
2145 template<class A, class B> int tuple2<A, B>::__hash__() {
2146     int seed = 0;
2147     seed = hash_combine(seed, hasher<A>(first));
2148     seed = hash_combine(seed, hasher<B>(second));
2149     return seed;
2150 }
2151
2152 template<class A, class B> str *tuple2<A, B>::__repr__() { 
2153     __GC_STRING s = "("+repr(first)->unit+", "+repr(second)->unit+")";
2154     return new str(s);
2155 }
2156
2157 template<class A, class B> tuple2<A,B> *tuple2<A,B>::__copy__() {
2158     return new tuple2<A,B>(2, first, second);
2159 }
2160 template<class A, class B> tuple2<A,B> *tuple2<A,B>::__deepcopy__(dict<void *, pyobj *> *memo) {
2161     tuple2<A,B> *n = new tuple2<A,B>();
2162     memo->__setitem__(this, n);
2163     n->first = __deepcopy(first, memo);
2164     n->second = __deepcopy(second, memo);
2165     return n; 
2166 }
2167
2168 #ifdef __SS_BIND
2169 template<class A, class B> tuple2<A, B>::tuple2(PyObject *p) {
2170     if(!PyTuple_Check(p)) 
2171         throw new TypeError(new str("error in conversion to Shed Skin (tuple expected)"));
2172
2173     this->__class__ = cl_tuple;
2174     first = __to_ss<A>(PyTuple_GetItem(p, 0));
2175     second = __to_ss<B>(PyTuple_GetItem(p, 1));
2176 }
2177
2178 template<class A, class B> PyObject *tuple2<A, B>::__to_py__() {
2179     PyObject *p = PyTuple_New(2);
2180     PyTuple_SetItem(p, 0, __to_py(first));
2181     PyTuple_SetItem(p, 1, __to_py(second));
2182     return p;
2183 }
2184 #endif
2185
2186 /* iterators */
2187
2188 template<class T> str *__iter<T>::__repr__() {
2189     return new str("iterator instance"); 
2190 }
2191
2192 template<class T> __seqiter<T>::__seqiter() {}
2193 template<class T> __seqiter<T>::__seqiter(pyseq<T> *p) {
2194     this->p = p;
2195     counter = 0;
2196 }
2197
2198 template<class T> T __seqiter<T>::next() {
2199     if(counter==p->units.size())
2200         throw new StopIteration();
2201     return p->units[counter++];
2202 }
2203
2204 template<class K, class V> __dictiterkeys<K, V>::__dictiterkeys(dict<K, V> *p) {
2205     this->p = p;
2206     iter = p->units.begin();
2207     counter = 0;
2208 }
2209
2210 template<class K, class V> K __dictiterkeys<K, V>::next() {
2211     if(iter == p->units.end())
2212         throw new StopIteration();
2213     return iter++->first;
2214 }
2215
2216 template<class K, class V> __dictitervalues<K, V>::__dictitervalues(dict<K, V> *p) {
2217     this->p = p;
2218     iter = p->units.begin();
2219     counter = 0;
2220 }
2221
2222 template<class K, class V> V __dictitervalues<K, V>::next() {
2223     if(iter == p->units.end())
2224         throw new StopIteration();
2225     return iter++->second;
2226 }
2227
2228 template<class K, class V> __dictiteritems<K, V>::__dictiteritems(dict<K, V> *p) {
2229     this->p = p;
2230     iter = p->units.begin();
2231     counter = 0;
2232 }
2233
2234 template<class K, class V> tuple2<K, V> *__dictiteritems<K, V>::next() {
2235     if(iter == p->units.end())
2236         throw new StopIteration();
2237     tuple2<K, V> *t = new tuple2<K, V>(2, iter->first, iter->second);
2238     iter++;
2239     return t;
2240 }
2241
2242 template<class T> __setiter<T>::__setiter(set<T> *p) {
2243     this->p = p;
2244     iter = p->units.begin();
2245 }
2246
2247 template<class T> T __setiter<T>::next() {
2248     if(iter == p->units.end())
2249         throw new StopIteration();
2250     return *(iter++);
2251 }
2252
2253 /* builtins */
2254
2255 template<class T> list<T> * __list(pyiter<T> *p) {
2256     list<T> *result = new list<T>();
2257     T e;
2258     __iter<T> *__0;
2259     FOR_IN(e, p, 0)
2260         result->append(e);
2261     END_FOR
2262     return result;
2263 }
2264
2265 template<class T> list<T> *__list(pyseq<T> *p) {
2266     list<T> *result = new list<T>();
2267 /*    if(p->__class__ == cl_str_) { // why can't we specialize for str *..
2268         printf("crap %s!\n", ((str *)p)->unit.c_str());
2269         return __list((pyiter<T> *)p);
2270     } */
2271     result->units = p->units;
2272     return result;
2273 }
2274
2275 list<str *> *__list(str *);
2276
2277 template<class T> tuple2<T,T> *__tuple(pyiter<T> *p) {
2278     tuple2<T,T> *result = new tuple2<T,T>();
2279     T e;
2280     __iter<T> *__0;
2281     FOR_IN(e, p, 0)
2282         result->append(e);
2283     END_FOR
2284     return result;
2285 }
2286
2287 template<class T> tuple2<T,T> *__tuple(pyseq<T> *p) {
2288     tuple2<T,T> *result = new tuple2<T,T>();
2289     if(p->__class__ == cl_str_) /* why can't we specialize for str *.. */
2290         return __tuple((pyiter<T> *)p);
2291     result->units = p->units;
2292     return result;
2293 }
2294
2295 template<class K, class V> dict<K,V> *__dict(pyiter<tuple2<K,V> *> *p) {
2296     dict<K,V> *d = new dict<K,V>();
2297     tuple2<K,V> *t;
2298     __iter<tuple2<K,V> *> *__0;
2299     FOR_IN(t, p, 0)
2300         d->__setitem__(t->__getfirst__(), t->__getsecond__());
2301     END_FOR
2302     return d;
2303 }
2304 template <class A> A __sum(pyiter<A> *l, A b) {
2305     A e;
2306     __iter<A> *__0;
2307     FOR_IN(e,l,0)
2308         b = __add(b, e);
2309     END_FOR
2310     return b;
2311 }
2312
2313 template <class A> A __sum(pyiter<A> *l) { return __sum(l, 0); }
2314
2315 int __sum(pyseq<int> *l, int b=0);
2316 double __sum(pyseq<double> *l, double b=0);
2317
2318 template<class T> T __minimum(pyseq<T> *l) {
2319     int len = l->units.size();
2320     int i;
2321     if(len==0)
2322         throw new ValueError(new str("minimum of empty sequence"));
2323     T m = l->units[0];
2324     for(i=1; i<len; i++)
2325         if( l->units[i] < m )
2326             m = l->units[i];
2327     return m;
2328 }
2329
2330 template<class T> T __maximum(pyseq<T> *l) {
2331     int len = l->units.size();
2332     int i;
2333     if(len==0)
2334         throw new ValueError(new str("maximum of empty sequence"));
2335     T m = l->units[0];
2336     for(i=1; i<len; i++)
2337         if( l->units[i] > m )
2338             m = l->units[i];
2339     return m;
2340 }
2341
2342 template<class T> T __max(pyiter<T> *a) {
2343     T e, max = 0;
2344     int first = 1;
2345     __iter<T> *__0;
2346     FOR_IN(e, a, 0)
2347         if(first) {
2348             first = 0;
2349             max = e;
2350         }
2351         else if( __cmp(e,max) == 1 )
2352             max = e;
2353     END_FOR
2354     return max;
2355 }
2356
2357 template<class T> T __max(T a, T b) {
2358     if(__cmp(a, b)==1) return a;
2359     return b;
2360 }
2361
2362 template<class T> T __max(T a, T b, T c) {
2363     if(__cmp(a, b)==1 && __cmp(a, c)==1) return a;
2364     else if(__cmp(b,c)==1) return b;
2365     return c;
2366 }
2367
2368 template<class T> T __max(int n, T a, T b, T c, ...) {
2369     T m = __max(a,b,c);
2370     va_list ap;
2371     va_start(ap, c);
2372
2373     for(int i=0; i<n-3; i++) {
2374         T t = va_arg(ap, T);
2375         if(__cmp(t,m)==1) m=t;
2376     }
2377     va_end(ap);
2378
2379     return m;
2380 }
2381
2382 template<> int __max(int a, int b);
2383 template<> int __max(int a, int b, int c);
2384 template<> double __max(double a, double b);
2385 template<> double __max(double a, double b, double c);
2386
2387 template<class T> T __min(pyiter<T> *a) {
2388     T e, min = 0;
2389     int first = 1;
2390     __iter<T> *__0;
2391     FOR_IN(e, a, 0)
2392         if(first) {
2393             first = 0;
2394             min = e;
2395         }
2396         else if( __cmp(e,min) == -1 )
2397             min = e;
2398     END_FOR
2399     return min;
2400 }
2401
2402 int __min(pyseq<int> *l);
2403 double __min(pyseq<double> *l);
2404
2405 template<class T> T __min(T a, T b) {
2406     if( __cmp(a, b) == -1 ) return a;
2407     return b;
2408 }
2409
2410 template<class T> T __min(T a, T b, T c) {
2411     if(__cmp(a, b)==-1 && __cmp(a, c)==-1) return a;
2412     else if(__cmp(b,c)==-1) return b;
2413     return c;
2414 }
2415
2416 template<class T> T __min(int n, T a, T b, T c, ...) {
2417     T m = __min(a,b,c);
2418     va_list ap;
2419     va_start(ap, c);
2420
2421     for(int i=0; i<n-3; i++) {
2422         T t = va_arg(ap, T);
2423         if(__cmp(t,m)==-1) m=t;
2424     }
2425     va_end(ap);
2426
2427     return m;
2428 }
2429
2430 template<> int __min(int a, int b);
2431 template<> int __min(int a, int b, int c);
2432 template<> double __min(double a, double b);
2433 template<> double __min(double a, double b, double c);
2434
2435 template<class A> static inline list<A> *__list_comp_0(list<A> *result, pyiter<A> *a) {
2436     A e;
2437     result->clear();
2438
2439     __iter<A> *__0;
2440     FOR_IN(e,a,0)
2441         result->append(e);
2442     END_FOR
2443     return result;
2444 }
2445
2446 template <class A> list<A> *sorted(pyiter<A> *x, int (*cmp)(A, A), int key, int reverse) {
2447     list<A> *r = new list<A>();
2448     A e;
2449     __iter<A> *__0;
2450     FOR_IN(e, x, 0)
2451         r->append(e);
2452     END_FOR
2453     r->sort(cmp, key, reverse);
2454     return r;
2455 }
2456 template <class A> list<A> *sorted(pyiter<A> *x, int cmp, int key, int reverse) { /* beh */
2457     return sorted(x, (int (*)(A,A))0, key, reverse); 
2458 }
2459
2460 template <class A> list<A> *sorted(pyseq<A> *x, int (*cmp)(A, A), int key, int reverse) {
2461     list<A> *r = new list<A>();
2462     r->units = x->units;
2463     r->sort(cmp, key, reverse);
2464     return r;
2465 }
2466 template <class A> list<A> *sorted(pyseq<A> *x, int cmp, int key, int reverse) { /* beh */
2467     return sorted(x, (int (*)(A,A))0, key, reverse); 
2468 }
2469
2470 list<str *> *sorted(str *x, int (*cmp)(str *, str *), int key, int reverse);
2471 list<str *> *sorted(str *x, int cmp, int key, int reverse); /* beh */
2472
2473 template<class A> class __ss_reverse : public __iter<A> {
2474 public:
2475     pyseq<A> *p;
2476     int i;
2477     __ss_reverse(pyseq<A> *p) {
2478         this->p = p;
2479         i = len(p)-1;
2480     }
2481
2482     A next() {
2483         if(i>=0)
2484             return p->units[i--];
2485         throw new StopIteration;
2486     }
2487 };
2488
2489 template <class A> __iter<A> *reversed(pyseq<A> *x) {
2490     return new __ss_reverse<A>(x);
2491 }
2492
2493 __iter<int> *reversed(__rangeiter *x); // XXX model rangeiter and such
2494
2495 template <class A> __iter<A> *reversed(pyiter<A> *x) { // fallback? specialized for deque
2496     if(x->__class__ == cl_rangeiter) // XXX model rangeiter and such
2497         return reversed((__rangeiter *)(x));
2498     return new __ss_reverse<A>(__list(x));
2499 }
2500
2501 template<class A> class __enumiter : public __iter<tuple2<int, A> *> {
2502 public:
2503     __iter<A> *p;
2504     int i;
2505
2506     __enumiter(pyiter<A> *p) {
2507         this->p = ___iter(p);
2508         i = 0;
2509     }
2510
2511     tuple2<int, A> *next() {
2512         return new tuple2<int, A>(2, i++, p->next());
2513     }
2514 };
2515
2516 template <class A> __iter<tuple2<int, A> *> *enumerate(pyiter<A> *x) {
2517     return new __enumiter<A>(x);
2518 }
2519
2520 template <class A> list<tuple2<A,A> *> *__zip1(pyiter<A> *a) {
2521     list<A> la;
2522     list<tuple2<A,A> *> *result;
2523     __list_comp_0(&la, a);
2524     int __1, __2, i;
2525     result = (new list<tuple2<A,A> *>());
2526
2527     FAST_FOR(i,0,len(&la),1,1,2)
2528         result->append((new tuple2<A,A>(1, la.units[i])));
2529     END_FOR
2530     return result;
2531 }
2532
2533 template <class A, class B> list<tuple2<A, B> *> *__zip2(pyiter<A> *a, pyiter<B> *b) {
2534     list<int> *__0;
2535     list<A> la;
2536     list<B> lb;
2537     int __1, __2, i;
2538     list<tuple2<A, B> *> *result;
2539
2540     __list_comp_0(&la, a);
2541     __list_comp_0(&lb, b);
2542     result = (new list<tuple2<A, B> *>());
2543
2544     FAST_FOR(i,0,__min(len(&la), len(&lb)),1,1,2)
2545         result->append((new tuple2<A, B>(2, la.units[i], lb.units[i])));
2546     END_FOR
2547     return result;
2548 }
2549
2550 template <class A, class B> list<tuple2<A, B> *> *__zip2(pyseq<A> *a, pyseq<B> *b) {
2551     list<tuple2<A, B> *> *result;
2552     result = new list<tuple2<A, B> *>();
2553
2554     int n = __min(len(a), len(b));
2555     result->units.reserve(n);
2556
2557     tuple2<A, B> *v = new tuple2<A, B>[n];
2558
2559     for(int i=0; i<n; i++) {
2560         v[i].__init2__(a->units[i], b->units[i]);
2561         result->units.push_back(&v[i]);
2562     }
2563
2564     return result;
2565 }
2566
2567 template <class A> list<tuple2<A,A> *> *__zip3(pyiter<A> *a, pyiter<A> *b, pyiter<A> *c) {
2568     list<int> *__0;
2569     list<A> la, lb, lc;
2570     int __1, __2, i;
2571
2572     list<tuple2<A,A> *> *result;
2573
2574     __list_comp_0(&la, a);
2575     __list_comp_0(&lb, b);
2576     __list_comp_0(&lc, c);
2577
2578     result = (new list<tuple2<A,A> *>());
2579
2580     FAST_FOR(i,0,__min(len(&la), len(&lb), len(&lc)),1,1,2)
2581         result->append((new tuple2<A,A>(3, la.units[i], lb.units[i], lc.units[i])));
2582     END_FOR
2583     return result;
2584 }
2585
2586 template <class A> list<tuple2<A,A> *> *__zip3(pyseq<A> *a, pyseq<A> *b, pyseq<A> *c) {
2587     list<tuple2<A, A> *> *result;
2588     result = new list<tuple2<A, A> *>();
2589
2590     int n = __min(__min(len(a), len(b)), len(c));
2591     result->units.reserve(n);
2592
2593     tuple2<A, A> *v = new tuple2<A, A>[n];
2594
2595     for(int i=0; i<n; i++) {
2596         v[i].units.resize(3);
2597         v[i].units[0] = a->units[i];
2598         v[i].units[1] = b->units[i];
2599         v[i].units[2] = c->units[i];
2600         result->units.push_back(&v[i]);
2601     }
2602
2603     return result;
2604 }
2605
2606 /* pow */
2607
2608 template<class A, class B> double __power(A a, B b);
2609 template<> double __power(double a, int b);
2610 template<> double __power(int a, double b);
2611
2612 template<class A> A __power(A a, A b);
2613 template<> double __power(double a, double b);
2614 template<> int __power(int a, int b);
2615
2616 int __power(int a, int b, int c);
2617
2618 int __power2(int a);
2619 double __power2(double a);
2620 int __power3(int a);
2621 double __power3(double a);
2622
2623 /* division */
2624
2625 template<class A, class B> double __divs(A a, B b);
2626 template<> double __divs(double a, int b);
2627 template<> double __divs(int a, double b);
2628
2629 template<class A> A __divs(A a, A b);
2630 template<> double __divs(double a, double b);
2631 template<> int __divs(int a, int b);
2632
2633 template<class A, class B> double __floordiv(A a, B b);
2634 template<> double __floordiv(double a, int b);
2635 template<> double __floordiv(int a, double b);
2636
2637 template<class A> A __floordiv(A a, A b) { return a->__floordiv__(b); }
2638 template<> double __floordiv(double a, double b);
2639 template<> int __floordiv(int a, int b);
2640
2641 template<class A, class B> tuple2<double, double> *divmod(A a, B b);
2642 template<> tuple2<double, double> *divmod(double a, int b);
2643 template<> tuple2<double, double> *divmod(int a, double b);
2644
2645 template<class A> tuple2<A, A> *divmod(A a, A b) {
2646     return a->__divmod__(b);
2647 }
2648 template<> tuple2<double, double> *divmod(double a, double b);
2649 template<> tuple2<int, int> *divmod(int a, int b);
2650
2651 /* dict.fromkeys */
2652
2653 namespace __dict__ {
2654     template<class A, class B> dict<A, B> *fromkeys(pyiter<A> *f, B b) {
2655         dict<A, B> *d = new dict<A, B>();
2656         A e;
2657         __iter<A> *__0;
2658         FOR_IN(e, f, 0)
2659             d->__setitem__(e, b);
2660         END_FOR
2661         return d;
2662     }
2663
2664     template<class A> dict<A, int> *fromkeys(pyiter<A> *f) {
2665         return fromkeys(f, 0);
2666     }
2667
2668 }
2669
2670 /* mod helpers */
2671
2672 int __fmtpos(str *fmt);
2673
2674 #if defined(WIN32) || defined(__sun)
2675 int asprintf(char **ret, const char *format, ...);
2676 #endif
2677
2678 template<class T> void __modfill(str **fmt, T t, str **s) {
2679     char *d;
2680     char c;
2681     int i = (*fmt)->unit.find('%');
2682     int j = __fmtpos(*fmt);
2683
2684     *s = new str((*s)->unit + (*fmt)->unit.substr(0, i));
2685
2686     c = (*fmt)->unit[j];
2687
2688     if(c == 's' or c == 'r') {
2689         str *add;
2690         if(c == 's') add = __str(t);
2691         else add = repr(t);
2692
2693         if((*fmt)->unit[i+1] == '.') {
2694             int maxlen = __int(new str((*fmt)->unit.substr(i+2, j-i-2)));
2695             if(maxlen < len(add))
2696                 add = new str(add->unit.substr(0, maxlen));
2697         }
2698
2699         *s = new str((*s)->unit + add->unit);
2700     }
2701     else if(c  == 'c')
2702         *s = new str((*s)->unit + __str(t)->unit);
2703     else if(c == '%')
2704         *s = new str((*s)->unit + '%');
2705     else {
2706         if(c == 'h') {
2707             //(*fmt)->unit[j] = 'g'; 
2708             (*fmt)->unit.replace(j, 1, ".12g");
2709             j += 3;
2710         }
2711         asprintf(&d, (*fmt)->unit.substr(i, j+1-i).c_str(), t);
2712         *s = new str((*s)->unit + d);
2713         if(c == 'h' && (t-(intptr_t)t == 0)) 
2714             (*s)->unit += ".0";   
2715         free(d); 
2716     }
2717
2718     *fmt = new str((*fmt)->unit.substr(j+1, (*fmt)->unit.size()-j-1));
2719 }
2720
2721 /* mod */
2722
2723 template<class A, class B> double __mods(A a, B b);
2724 template<> double __mods(double a, int b);
2725 template<> double __mods(int a, double b);
2726
2727 template<class A> A __mods(A a, A b);
2728 template<> double __mods(double a, double b);
2729 template<> int __mods(int a, int b);
2730
2731 str *__mod(str *fmt, ...);
2732 void __fmtcheck(str *fmt, int l);
2733
2734 template <class T> str *mod_to_c(T t) { return 0; }
2735 str *mod_to_c(str *s);
2736 str *mod_to_c(int i); 
2737 str *mod_to_c(double d); 
2738
2739 template<class T> int do_modfill(char c, str **fmt, T arg, str **s) {
2740     if(c == '%') {
2741         __modfill(fmt, 0, s);
2742         return 0;
2743     }
2744     else if(c == 'c')
2745         __modfill(fmt, mod_to_c(arg), s);
2746     else if(c == 's' || c == 'r')
2747         __modfill(fmt, arg, s);
2748     else if(__GC_STRING("diouxX").find(c) != -1)
2749         __modfill(fmt, __int(arg), s);
2750     else if(__GC_STRING("eEfFgGh").find(c) != -1)
2751         __modfill(fmt, __float(arg), s);
2752        
2753     return 1;
2754 }
2755
2756 template<class T> str *__mod(str *fmt, tuple2<T,T> *t) {
2757     __fmtcheck(fmt, len(t));
2758
2759     str *fmts = new str(fmt->unit);
2760     str *r = new str();
2761
2762     int j, i = 0;
2763     T arg;
2764     while((j = __fmtpos(fmts)) != -1) {
2765         char c = fmts->unit[j];
2766         arg = t->__getitem__(i);
2767
2768         if(do_modfill(c, &fmts, arg, &r))
2769             i++;
2770     }
2771         
2772     r->unit += fmts->unit;
2773     return r;
2774 }
2775
2776 template<class T> str *__moddict(str *v, dict<str *, T> *d) {
2777     /* autogenerated: get ordered list of keys (names); remove keys */
2778     str *const_5 = new str("%(");
2779     str *const_6 = new str(")");
2780     str *const_7 = new str("(");
2781     str *const_8 = new str("");
2782
2783     list<str *> *names;
2784     set<str *> *__0;
2785     __iter<str *> *__1;
2786     int __2, i, j;
2787     str *name;
2788
2789     j = 0;
2790     names = (new list<str *>());
2791
2792     while (1) {
2793         i = v->find(const_5, j);
2794         if ((i==(-1))) {
2795             break;
2796         }
2797         j = v->find(const_6, i);
2798         if ((j==(-1))) {
2799             break;
2800         }
2801         names->append(v->__slice__(3, (i+2), j, 0));
2802     }
2803
2804     FOR_IN(name,(new set<str *>(names)),1)
2805         v = v->replace(__add_strs(3, const_7, name, const_6), const_8);
2806     END_FOR
2807
2808     /* like __mod2, but with known types */
2809     int k;
2810     int argcount=0;
2811     str *r = new str();
2812     str *fmt = new str(v->unit);
2813     T arg;
2814
2815     while((k = __fmtpos(fmt)) != -1) {
2816         char c = fmt->unit[k];
2817         arg = d->__getitem__(names->__getitem__(argcount));
2818
2819         if(do_modfill(c, &fmt, arg, &r))
2820             argcount++;
2821     }
2822
2823     r->unit += fmt->unit;
2824     return r;
2825 }
2826
2827 template<class A, class B> str *__mod(str *fmt, tuple2<A,B> *t) {
2828     __fmtcheck(fmt, 2);
2829
2830     str *fmts = new str(fmt->unit);
2831     str *r = new str();
2832
2833     int j, i = 0;
2834     int result;
2835     while((j = __fmtpos(fmts)) != -1) {
2836         char c = fmts->unit[j];
2837         if(i==0)
2838             result = do_modfill(c, &fmts, t->__getfirst__(), &r);
2839         else
2840             result = do_modfill(c, &fmts, t->__getsecond__(), &r);
2841
2842         if(result)
2843             i++;
2844     }
2845
2846     r->unit += fmts->unit;
2847     return r;
2848
2849
2850 /* any, all */
2851
2852 template<class A> int any(pyiter<A> *a) {
2853     A b;
2854     __iter<A> *__0;
2855     FOR_IN(b,a,0)
2856         if(__bool(b))
2857             return 1;
2858     END_FOR
2859     return 0;
2860 }
2861
2862 template<class A> int all(pyiter<A> *a) {
2863     A b;
2864     __iter<A> *__0;
2865     FOR_IN(b,a,0)
2866         if(!__bool(b))
2867             return 0;
2868     END_FOR
2869     return 1;
2870 }
2871
2872 /* binding */
2873
2874 #ifdef __SS_BIND
2875 PyObject *__import(char *mod, char *method);
2876 PyObject *__call(PyObject *call, PyObject *args);
2877 PyObject *__call(PyObject *obj, char *method, PyObject *args);
2878 PyObject *__args(int n, ...);
2879 #endif
2880
2881
2882 } // namespace __shedskin__
2883 #endif