shift some code to make ___min declared before using it (reported by mos4567)
[shedskin:mainline.git] / shedskin / lib / builtin.hpp
1 /* Copyright 2005-2011 Mark Dufour and contributors; License Expat (See LICENSE) */
2
3 #ifndef BUILTIN_HPP
4 #define BUILTIN_HPP
5
6 #ifdef __SS_BIND
7 #include <Python.h>
8 #endif
9
10 #include <gc/gc_allocator.h>
11 #include <gc/gc_cpp.h>
12
13 #include <vector>
14 #include <deque>
15 #include <string>
16 #include <set>
17 #include <iostream>
18 #include <fstream>
19 #include <sstream>
20 #include <cstdarg>
21 #include <cstring>
22 #include <cmath>
23 #include <algorithm>
24 #include <iterator>
25 #include <ctype.h>
26 #include <stdint.h>
27 #include <limits>
28
29 #ifndef WIN32
30 #include <exception>
31 #include <execinfo.h>
32 #include <cxxabi.h>
33 #endif
34
35 #if defined(_MSC_VER)
36 #include "builtin/msvc.hpp"
37 #endif
38
39 namespace __shedskin__ {
40
41 /* integer type */
42
43 #ifdef __SS_LONG
44     typedef long long __ss_int;
45 #else
46     typedef int __ss_int;
47 #endif
48
49 /* forward class declarations */
50
51 class __ss_bool;
52 class complex;
53
54 class pyobj;
55 class class_;
56 class str;
57 class file;
58
59 class int_;
60 class bool_;
61 class float_;
62 class complex_;
63
64 template <class T> class pyiter;
65 template <class T> class pyseq;
66
67 template <class T> class list;
68 template <class A, class B> class tuple2;
69 template <class T> class set;
70 template <class K, class V> class dict;
71
72 template <class T> class __iter;
73 template <class T> class __seqiter;
74 template <class T> class __setiter;
75 template <class T, class U> class __dictiterkeys;
76 template <class T, class U> class __dictitervalues;
77 template <class T, class U> class __dictiteritems;
78 class __fileiter;
79 class __xrange;
80 class __rangeiter;
81
82 class BaseException;
83 class Exception;
84 class StandardError;
85 class AssertionError;
86 class KeyError;
87 class ValueError;
88 class IndexError;
89 class NotImplementedError;
90 class IOError;
91 class OSError;
92 class SyntaxError;
93 class StopIteration;
94 class TypeError;
95 class RuntimeError;
96 class OverflowError;
97
98 /* STL types */
99
100 #define __GC_VECTOR(T) std::vector< T, gc_allocator< T > >
101 #define __GC_DEQUE(T) std::deque< T, gc_allocator< T > >
102 #define __GC_STRING std::basic_string<char,std::char_traits<char>,gc_allocator<char> >
103
104 extern __ss_bool True;
105 extern __ss_bool False;
106
107 /* class declarations */
108
109 class pyobj : public gc {
110 public:
111     class_ *__class__;
112
113     virtual str *__repr__();
114     virtual str *__str__();
115
116     virtual long __hash__();
117     virtual __ss_int __cmp__(pyobj *p);
118
119     virtual __ss_bool __eq__(pyobj *p);
120     virtual __ss_bool __ne__(pyobj *p);
121     virtual __ss_bool __gt__(pyobj *p);
122     virtual __ss_bool __lt__(pyobj *p);
123     virtual __ss_bool __ge__(pyobj *p);
124     virtual __ss_bool __le__(pyobj *p);
125
126     virtual pyobj *__copy__();
127     virtual pyobj *__deepcopy__(dict<void *, pyobj *> *);
128
129     virtual __ss_int __len__();
130     virtual __ss_int __int__();
131
132     virtual __ss_bool __nonzero__();
133     virtual __ss_int __index__();
134
135     static const bool is_pyseq = false;
136 };
137
138 template <class T> class pyiter : public pyobj {
139 public:
140     virtual __iter<T> *__iter__() = 0;
141     virtual __ss_bool __contains__(T t);
142
143     typedef T for_in_unit;
144     typedef __iter<T> * for_in_loop;
145
146     inline __iter<T> *for_in_init();
147     inline bool for_in_has_next(__iter<T> *iter);
148     inline T for_in_next(__iter<T> *iter);
149 };
150
151 template <class T> class pyseq : public pyiter<T> {
152 public:
153     virtual __ss_int __len__() = 0;
154     virtual T __getitem__(__ss_int i) = 0;
155     virtual __ss_int __cmp__(pyobj *p);
156
157     virtual __iter<T> *__iter__();
158
159     typedef T for_in_unit;
160     typedef size_t for_in_loop;
161
162     inline size_t for_in_init();
163     inline bool for_in_has_next(size_t i);
164     inline T for_in_next(size_t &i);
165
166     static const bool is_pyseq = true;
167 };
168
169 template <class R, class A> class pycall1 : public pyobj {
170 public:
171     virtual R __call__(A a) = 0;
172 };
173 template <class R, class A, class B> class pycall2 : public pyobj {
174 public:
175     virtual R __call__(A a, B b) = 0;
176 };
177
178 template <class T> class list : public pyseq<T> {
179 public:
180     __GC_VECTOR(T) units;
181
182     list();
183     list(int count, ...);
184     template <class U> list(U *iter);
185     list(list<T> *p);
186     list(tuple2<T, T> *p);
187     list(str *s);
188
189     void clear();
190     void *__setitem__(__ss_int i, T e);
191     void *__delitem__(__ss_int i);
192     int empty();
193     list<T> *__slice__(__ss_int x, __ss_int l, __ss_int u, __ss_int s);
194     void *__setslice__(__ss_int x, __ss_int l, __ss_int u, __ss_int s, pyiter<T> *b);
195     void *__setslice__(__ss_int x, __ss_int l, __ss_int u, __ss_int s, list<T> *b);
196     void *__delete__(__ss_int i);
197     void *__delete__(__ss_int x, __ss_int l, __ss_int u, __ss_int s);
198     void *__delslice__(__ss_int a, __ss_int b);
199     __ss_bool __contains__(T a);
200
201     list<T> *__add__(list<T> *b);
202     list<T> *__mul__(__ss_int b);
203
204     template <class U> void *extend(U *iter);
205     void *extend(list<T> *p);
206     void *extend(tuple2<T,T> *p);
207     void *extend(str *s);
208
209     template <class U> list<T> *__iadd__(U *iter);
210     list<T> *__imul__(__ss_int n);
211
212     __ss_int index(T a);
213     __ss_int index(T a, __ss_int s);
214     __ss_int index(T a, __ss_int s, __ss_int e);
215
216     __ss_int count(T a);
217     str *__repr__();
218     __ss_bool __eq__(pyobj *l);
219
220     void resize(__ss_int i); /* XXX remove */
221
222     inline T __getfast__(__ss_int i);
223     inline T __getitem__(__ss_int i);
224     inline __ss_int __len__();
225
226     T pop();
227     T pop(int m);
228     void *remove(T e);
229     void *insert(int m, T e);
230
231     void *append(T a);
232
233     void *reverse();
234     template<class U> void *sort(__ss_int (*cmp)(T, T), U (*key)(T), __ss_int reverse);
235     template<class U> void *sort(__ss_int cmp, U (*key)(T), __ss_int reverse);
236     void *sort(__ss_int (*cmp)(T, T), __ss_int key, __ss_int reverse);
237     void *sort(__ss_int cmp, __ss_int key, __ss_int reverse);
238
239     list<T> *__copy__();
240     list<T> *__deepcopy__(dict<void *, pyobj *> *memo);
241
242     /* iteration */
243
244     inline bool for_in_has_next(size_t i);
245     inline T for_in_next(size_t &i);
246 #ifdef __SS_BIND
247     list(PyObject *);
248     PyObject *__to_py__();
249 #endif
250 };
251
252 template<class A, class B> class tuple2 : public pyobj {
253 public:
254     A first;
255     B second;
256
257     tuple2();
258     tuple2(int n, A a, B b);
259     void __init2__(A a, B b);
260
261     A __getfirst__();
262     B __getsecond__();
263
264     str *__repr__();
265     __ss_int __len__();
266
267     __ss_bool __eq__(pyobj *p);
268     __ss_int __cmp__(pyobj *p);
269     long __hash__();
270
271     tuple2<A,B> *__copy__();
272     tuple2<A,B> *__deepcopy__(dict<void *, pyobj *> *memo);
273
274 #ifdef __SS_BIND
275     tuple2(PyObject *p);
276     PyObject *__to_py__();
277 #endif
278 };
279
280 template<class T> class tuple2<T,T> : public pyseq<T> {
281 public:
282     __GC_VECTOR(T) units;
283
284     tuple2();
285     tuple2(int count, ...);
286     template <class U> tuple2(U *iter);
287     tuple2(list<T> *p);
288     tuple2(tuple2<T, T> *p);
289     tuple2(str *s);
290
291     void __init2__(T a, T b);
292
293     T __getfirst__();
294     T __getsecond__();
295
296     inline T __getfast__(__ss_int i);
297     inline T __getitem__(__ss_int i);
298
299     inline __ss_int __len__();
300
301     str *__repr__();
302
303     tuple2<T,T> *__add__(tuple2<T,T> *b);
304     tuple2<T,T> *__mul__(__ss_int b);
305
306     tuple2<T,T> *__iadd__(tuple2<T,T> *b);
307     tuple2<T,T> *__imul__(__ss_int n);
308
309     __ss_bool __contains__(T a);
310     __ss_bool __eq__(pyobj *p);
311
312     tuple2<T,T> *__slice__(__ss_int x, __ss_int l, __ss_int u, __ss_int s);
313
314     long __hash__();
315
316     tuple2<T,T> *__deepcopy__(dict<void *, pyobj *> *memo);
317     tuple2<T,T> *__copy__();
318
319     /* iteration */
320
321     inline bool for_in_has_next(size_t i);
322     inline T for_in_next(size_t &i);
323
324 #ifdef __SS_BIND
325     tuple2(PyObject *p);
326     PyObject *__to_py__();
327 #endif
328 };
329
330 class str : public pyseq<str *> {
331 public:
332     __GC_STRING unit;
333     long hash;
334     bool charcache;
335
336     str();
337     str(const char *s);
338     str(__GC_STRING s);
339     str(const char *s, int size); /* '\0' delimiter in C */
340
341     __ss_bool __contains__(str *s);
342     str *strip(str *chars=0);
343     str *lstrip(str *chars=0);
344     str *rstrip(str *chars=0);
345     list<str *> *split(str *sep=0, int maxsplit=-1);
346     __ss_bool __eq__(pyobj *s);
347     str *__add__(str *b);
348
349     template<class U> str *join(U *);
350
351     str *__str__();
352     str *__repr__();
353     str *__mul__(__ss_int n);
354     inline str *__getitem__(__ss_int n);
355     inline str *__getfast__(__ss_int i);
356     inline __ss_int __len__();
357     str *__slice__(__ss_int x, __ss_int l, __ss_int u, __ss_int s);
358
359     list<str *> *rsplit(str *sep = 0, int maxsplit = -1);
360     tuple2<str *, str *> *rpartition(str *sep);
361     tuple2<str *, str *> *partition(str *sep);
362     list<str *> *splitlines(int keepends = 0);
363
364     int __fixstart(int a, int b);
365     int __checkneg(int i);
366
367     int find(str *s, int a=0);
368     int find(str *s, int a, int b);
369     int rfind(str *s, int a=0);
370     int rfind(str *s, int a, int b);
371     int index(str *s, int a=0);
372     int index(str *s, int a, int b);
373     int rindex(str *s, int a=0);
374     int rindex(str *s, int a, int b);
375
376     __ss_int count(str *s, __ss_int start=0);
377     __ss_int count(str *s, __ss_int start, __ss_int end);
378
379     str *upper();
380     str *lower();
381     str *title();
382     str *capitalize();
383     str *replace(str *a, str *b, int c=-1);
384     str *translate(str *table, str *delchars=0);
385     str *swapcase();
386     str *center(int w, str *fill=0);
387
388     __ss_bool __ctype_function(int (*cfunc)(int));
389
390     __ss_bool istitle();
391     __ss_bool isspace();
392     __ss_bool isalpha();
393     __ss_bool isdigit();
394     __ss_bool islower();
395     __ss_bool isupper();
396     __ss_bool isalnum();
397
398     __ss_bool startswith(str *s, __ss_int start=0);
399     __ss_bool startswith(str *s, __ss_int start, __ss_int end);
400     __ss_bool endswith(str *s, __ss_int start=0);
401     __ss_bool endswith(str *s, __ss_int start, __ss_int end);
402
403     str *zfill(int width);
404     str *expandtabs(int width=8);
405
406     str *ljust(int width, str *fchar=0);
407     str *rjust(int width, str *fchar=0);
408
409     __ss_int __cmp__(pyobj *p);
410     long __hash__();
411
412     __ss_int __int__(); /* XXX compilation warning for int(pyseq<str *> *) */
413
414     str *__iadd__(str *b);
415     str *__imul__(__ss_int n);
416
417     /* iteration */
418
419     inline bool for_in_has_next(size_t i);
420     inline str *for_in_next(size_t &i);
421
422 #ifdef __SS_BIND
423     str(PyObject *p);
424     PyObject *__to_py__();
425 #endif
426 };
427
428 void __throw_index_out_of_range();
429 void __throw_range_step_zero();
430 void __throw_set_changed();
431 void __throw_dict_changed();
432 void __throw_slice_step_zero();
433 void __throw_stop_iteration();
434
435 template<class K, class V> class dictentry;
436
437 const int MINSIZE = 8;
438
439 template<class K, class V> struct dict_looper {
440     __ss_int pos;
441     int si_used;
442     dictentry<K,V> *entry;
443 };
444
445 template <class K, class V> class dict : public pyiter<K> {
446 public:
447         int fill;
448     int used;
449     int mask;
450     dictentry<K,V> *table;
451     dictentry<K,V> smalltable[MINSIZE];
452
453     dict();
454     dict(int count, ...);
455     template<class U> dict(U *other);
456     dict(dict<K, V> *p);
457
458     dict<K,V>& operator=(const dict<K,V>& other);
459
460     void *__setitem__(K k, V v);
461     V __getitem__(K k);
462     void *__delitem__(K k);
463     int do_discard(K key);
464     list<K> *keys();
465     list<V> *values();
466     list<tuple2<K, V> *> *items();
467     __ss_int __len__();
468     str *__repr__();
469     __ss_bool has_key(K k);
470     __ss_bool __contains__(K key);
471     __ss_bool __contains__(dictentry<K,V>* entry);
472     void *clear();
473     dict<K,V> *copy();
474     V get(K k);
475     V get(K k, V v);
476     V pop(K k);
477     tuple2<K, V> *popitem();
478     template <class U> void *update(U *other);
479     void *update(dict<K, V> *e);
480
481     __ss_bool __gt__(dict<K,V> *s);
482     __ss_bool __lt__(dict<K,V> *s);
483     __ss_bool __ge__(dict<K,V> *s);
484     __ss_bool __le__(dict<K,V> *s);
485     __ss_bool __eq__(pyobj *p);
486
487     __ss_int __cmp__(pyobj *p);
488     V setdefault(K k, V v=0);
489
490     __dictiterkeys<K, V> *__iter__() { return new __dictiterkeys<K,V>(this);}
491     __dictiterkeys<K, V> *iterkeys() { return new __dictiterkeys<K,V>(this);}
492     __dictitervalues<K, V> *itervalues() { return new __dictitervalues<K,V>(this);}
493     __dictiteritems<K, V> *iteritems() { return new __dictiteritems<K,V>(this);}
494
495     dict<K, V> *__deepcopy__(dict<void *, pyobj *> *memo);
496     dict<K, V> *__copy__();
497
498     void *__addtoitem__(K k, V v);
499
500     /* iteration */
501
502     typedef K for_in_unit;
503     typedef dict_looper<K,V> for_in_loop;
504
505     inline dict_looper<K,V> for_in_init() { dict_looper<K,V> l; l.pos = 0; l.si_used = used; return l; }
506     inline bool for_in_has_next(dict_looper<K,V> &l) {
507         if (l.si_used != used) {
508             l.si_used = -1;
509             __throw_dict_changed();
510         }
511         int ret = next(&l.pos, &l.entry);
512         if (!ret) return false;
513         return true;
514     }
515     inline K for_in_next(dict_looper<K,V> &l) { return l.entry->key; }
516
517 #ifdef __SS_BIND
518     dict(PyObject *);
519     PyObject *__to_py__();
520 #endif
521
522     // used internally
523     dictentry<K,V>* lookup(K key, long hash) const;
524     void insert_key(K key, V value, long hash);
525     void insert_clean(K key, V value, long hash);
526     int next(__ss_int *pos_ptr, dictentry<K,V> **entry_ptr);
527     void resize(int minused);
528 };
529
530 template<class T> struct setentry;
531
532 template<class T> struct set_looper {
533     int pos;
534     int si_used;
535     setentry<T> *entry;
536 };
537
538 template<class T> class set : public pyiter<T> {
539 public:
540     int frozen;
541     int fill;
542     int used;
543     int mask;
544     setentry<T> *table;
545     setentry<T> smalltable[MINSIZE];
546     long hash;
547
548     template<class U> set(U *other, int frozen);
549     template<class U> set(U *other);
550     set(int frozen=0);
551
552     set<T>& operator=(const set<T>& other);
553
554     void *add(T key);
555     void *add(setentry<T>* entry);
556     void *discard(T key);
557     int do_discard(T key);
558     void *remove(T key);
559     T pop();
560
561     str* __repr__();
562
563     __ss_bool __contains__(T key);
564     __ss_bool __contains__(setentry<T>* entry);
565     __ss_int __len__();
566
567     void *clear();
568     set<T> *copy();
569
570     template <class U> void *update(int, U *other);
571     void *update(int, set<T> *s);
572     template <class U, class V> void *update(int, U *other, V *other2);
573     template <class U, class V, class W> void *update(int, U *other, V *other2, W *other3);
574
575     template <class U> set<T> *intersection(int, U *other);
576     set<T> *intersection(int, set<T> *s);
577     template <class U, class V> set<T> *intersection(int, U *iter, V *iter2);
578     template <class U, class V, class W> set<T> *intersection(int, U *iter, V *iter2, W *iter3);
579
580     template <class U> void *intersection_update(int, U *other);
581     void *intersection_update(int, set<T> *s);
582     template <class U, class V> void *intersection_update(int, U *other, V *other2);
583     template <class U, class V, class W> void *intersection_update(int, U *other, V *other2, W *other3);
584
585     template <class U> set<T> *difference(int, U *other);
586     set<T> *difference(int, set<T> *s);
587     template <class U, class V> set<T> *difference(int, U *other, V *other2);
588     template <class U, class V, class W> set<T> *difference(int, U *other, V *other2, W *other3);
589
590     template <class U> void *difference_update(int, U *other);
591     void *difference_update(int, set<T> *s);
592     template <class U, class V> void *difference_update(int, U *other, V *other2);
593     template <class U, class V, class W> void *difference_update(int, U *other, V *other2, W *other3);
594
595     set<T> *symmetric_difference(set<T> *s);
596     void *symmetric_difference_update(set<T> *s);
597
598     template <class U> set<T> *__ss_union(int, U *other);
599     set<T> *__ss_union(int, set<T> *s);
600     template <class U, class V> set<T> *__ss_union(int, U *other, V *other2);
601     template <class U, class V, class W> set<T> *__ss_union(int, U *other, V *other2, W *other3);
602
603     set<T> *__and__(set<T> *s);
604     set<T> *__or__(set<T> *s);
605     set<T> *__xor__(set<T> *s);
606     set<T> *__sub__(set<T> *s);
607
608     set<T> *__iand__(set<T> *s);
609     set<T> *__ior__(set<T> *s);
610     set<T> *__ixor__(set<T> *s);
611     set<T> *__isub__(set<T> *s);
612
613     __ss_bool issubset(pyiter<T> *s);
614     __ss_bool issubset(set<T> *s);
615     __ss_bool issuperset(set<T> *s);
616     __ss_bool issuperset(pyiter<T> *s);
617
618     __ss_bool isdisjoint(set<T> *s);
619     __ss_bool isdisjoint(pyiter<T> *s);
620
621     __ss_bool __gt__(set<T> *s);
622     __ss_bool __lt__(set<T> *s);
623     __ss_bool __ge__(set<T> *s);
624     __ss_bool __le__(set<T> *s);
625     __ss_bool __eq__(pyobj *p);
626
627     __ss_int __cmp__(pyobj *p);
628
629     __setiter<T> *__iter__() {
630         return new __setiter<T>(this);
631     }
632
633     set<T> *__copy__();
634     set<T> *__deepcopy__(dict<void *, pyobj *> *memo);
635
636     /* iteration */
637
638     typedef T for_in_unit;
639     typedef set_looper<T> for_in_loop;
640
641     inline set_looper<T> for_in_init() { set_looper<T> l; l.pos = 0; l.si_used = used; return l; }
642     inline bool for_in_has_next(set_looper<T> &l) {
643         if (l.si_used != used) {
644             l.si_used = -1;
645             __throw_set_changed();
646         }
647         int ret = next(&l.pos, &l.entry);
648         if (!ret) return false;
649         return true;
650     }
651     inline T for_in_next(set_looper<T> &l) { return l.entry->key; }
652
653 #ifdef __SS_BIND
654     set(PyObject *);
655     PyObject *__to_py__();
656 #endif
657
658     long __hash__();
659
660     // used internally
661     setentry<T>* lookup(T key, long hash) const;
662     void insert_key(T key, long hash);
663     void insert_clean(T key, long hash);
664     int next(int *pos_ptr, setentry<T> **entry_ptr);
665     void resize(int minused);
666 };
667
668 class __ss_bool {
669 public:
670     int value;
671     inline __ss_int operator+(__ss_bool b);
672     inline __ss_bool operator==(__ss_bool b);
673     inline __ss_bool operator&(__ss_bool b);
674     inline __ss_bool operator|(__ss_bool b);
675     inline __ss_bool operator^(__ss_bool b);
676     inline bool operator!();
677     inline operator bool();
678     inline __ss_bool& operator=(int a);
679 };
680
681 class complex {
682 public:
683     double real, imag;
684
685     inline complex operator+(complex b);
686     inline complex operator+(double b);
687     inline complex operator-(complex b);
688     inline complex operator-(double b);
689     inline complex operator*(complex b);
690     inline complex operator*(double b);
691     inline complex operator/(complex b);
692     inline complex operator/(double b);
693     inline complex operator%(complex b);
694     inline complex operator%(double b);
695     inline complex operator+();
696     inline complex operator-();
697     inline __ss_bool operator==(complex b);
698     inline __ss_bool operator==(double b);
699     inline __ss_bool operator!=(complex b);
700     inline __ss_bool operator!=(double b);
701     inline complex& operator=(double a);
702
703     inline complex conjugate();
704     complex parsevalue(str *s);
705
706     inline long __hash__();
707     str *__repr__();
708 };
709
710 complex mcomplex(double real=0.0, double imag=0.0);
711 template<class T> complex mcomplex(T t);
712 complex mcomplex(str *s);
713
714 inline complex operator+(double a, complex b) { return mcomplex(a)+b; }
715 inline complex operator-(double a, complex b) { return mcomplex(a)-b; }
716 inline complex operator*(double a, complex b) { return mcomplex(a)*b; }
717 inline complex operator/(double a, complex b) { return mcomplex(a)/b; }
718 inline complex operator%(double a, complex b) { return mcomplex(a)%b; }
719
720 inline __ss_bool operator==(double a, complex b) { return mcomplex(a)==b; }
721 inline __ss_bool operator!=(double a, complex b) { return mcomplex(a)!=b; }
722
723 class class_: public pyobj {
724 public:
725     str *__name__;
726
727     class_(const char *name);
728     str *__repr__();
729     __ss_bool __eq__(pyobj *c);
730
731 };
732
733 class int_ : public pyobj {
734 public:
735     __ss_int unit;
736     int_(__ss_int i);
737     str *__repr__();
738     __ss_bool __nonzero__();
739 };
740
741 class float_ : public pyobj {
742 public:
743     double unit;
744     float_(double f);
745     str *__repr__();
746     __ss_bool __nonzero__();
747 };
748
749 class bool_ : public pyobj {
750 public:
751     __ss_bool unit;
752     bool_(__ss_bool i);
753     str *__repr__();
754     __ss_bool __nonzero__();
755     __ss_int __index__();
756 };
757
758 class complex_ : public pyobj {
759 public:
760     complex unit;
761     complex_(complex i);
762     str *__repr__();
763     __ss_bool __nonzero__();
764 };
765
766 class object : public pyobj {
767 public:
768     object();
769
770 };
771
772 template<class T> class __iter : public pyiter<T> {
773 public:
774     T __result;
775     bool __stop_iteration;
776
777     __iter<T> *__iter__();
778     virtual T next(); /* __get_next can be overloaded to avoid (slow) exception handling */
779     virtual T __get_next();
780
781     str *__repr__();
782 };
783
784 template <class T> class __setiter : public __iter<T> {
785 public:
786     set<T> *p;
787     int pos;
788     int si_used;
789     int len;
790     setentry<T>* entry;
791
792     __setiter<T>(set<T> *p);
793     T next();
794 };
795
796 class __xrange : public pyiter<__ss_int> {
797 public:
798     __ss_int a, b, s;
799
800     __xrange(__ss_int a, __ss_int b, __ss_int s);
801     __iter<__ss_int> *__iter__();
802     __ss_int __len__();
803     str *__repr__();
804 };
805
806 template <class T> class __seqiter : public __iter<T> {
807 public:
808     size_t counter, size;
809     pyseq<T> *p;
810     __seqiter<T>();
811     __seqiter<T>(pyseq<T> *p);
812     T next();
813 };
814
815 template <class K, class V> class __dictiterkeys : public __iter<K> {
816 public:
817     dict<K,V> *p;
818     __ss_int pos;
819     int si_used;
820     int len;
821     dictentry<K,V>* entry;
822
823     __dictiterkeys<K, V>(dict<K, V> *p);
824     K next();
825 };
826
827 template <class K, class V> class __dictitervalues : public __iter<V> {
828 public:
829     dict<K,V> *p;
830     __ss_int pos;
831     int si_used;
832     int len;
833     dictentry<K,V>* entry;
834
835     __dictitervalues<K, V>(dict<K, V> *p);
836     V next();
837 };
838
839 template <class K, class V> class __dictiteritems : public __iter<tuple2<K, V> *> {
840 public:
841     dict<K,V> *p;
842     __ss_int pos;
843     int si_used;
844     int len;
845     dictentry<K,V>* entry;
846
847     __dictiteritems<K, V>(dict<K, V> *p);
848     tuple2<K, V> *next();
849 };
850 static inline __ss_bool __mbool(bool c) { __ss_bool b; b.value=(int)c; return b; }
851
852 /* builtin function declarations */
853
854 template <class T> __iter<T> *___iter(pyiter<T> *p) {
855     return p->__iter__();
856 }
857
858 file *open(str *name, str *flags = 0);
859 str *raw_input(str *msg = 0);
860
861 void print(int n, file *f, str *end, str *sep, ...);
862 void print2(file *f, int comma, int n, ...);
863
864 list<__ss_int> *range(__ss_int b);
865 list<__ss_int> *range(__ss_int a, __ss_int b, __ss_int s=1);
866
867 __xrange *xrange(__ss_int b);
868 __xrange *xrange(__ss_int a, __ss_int b, __ss_int s=1);
869
870 static inline double __portableround(double x) {
871     if(x<0) return ceil(x-0.5);
872     return floor(x+0.5);
873 }
874 inline double ___round(double a) {
875     return __portableround(a);
876 }
877 inline double ___round(double a, int n) {
878     return __portableround(pow((double)10,n)*a)/pow((double)10,n);
879 }
880
881 template<class T> inline T __abs(T t) { return t->__abs__(); }
882 #ifdef __SS_LONG
883 template<> inline __ss_int __abs(__ss_int a) { return a<0?-a:a; }
884 #endif
885 template<> inline int __abs(int a) { return a<0?-a:a; }
886 template<> inline double __abs(double a) { return a<0?-a:a; }
887 inline int __abs(__ss_bool b) { return __abs(b.value); }
888
889 template<class T> str *hex(T t) {
890     return t->__hex__();
891 }
892 #ifdef __SS_LONG
893 template<> str *hex(__ss_int a);
894 #endif
895 template<> str *hex(int a);
896 template<> str *hex(__ss_bool b);
897
898 template<class T> str *oct(T t) {
899     return t->__oct__();
900 }
901 #ifdef __SS_LONG
902 template<> str *oct(__ss_int a);
903 #endif
904 template<> str *oct(int a);
905 template<> str *oct(__ss_bool b);
906
907 template<class T> str *bin(T t) {
908     return bin(t->__index__());
909 }
910 #ifdef __SS_LONG
911 template<> str *bin(__ss_int a);
912 #endif
913 template<> str *bin(int a);
914 template<> str *bin(__ss_bool b);
915
916 str *__mod4(str *fmt, list<pyobj *> *vals);
917 str *__modct(str *fmt, int n, ...);
918 str *__modcd(str *fmt, list<str *> *l, ...);
919
920 template<class T> str *__modtuple(str *fmt, tuple2<T,T> *t);
921 template<class A, class B> str *__modtuple(str *fmt, tuple2<A,B> *t);
922
923 /* internal use */
924
925 #ifdef __sun
926 #define INFINITY __builtin_inff()
927 #endif
928 #if defined( _MSC_VER )
929 #define INFINITY std::numeric_limits<double>::infinity()
930 #endif
931
932 #define __SS_MIN(a,b) ((a) < (b) ? (a) : (b))
933 #define __SS_MIN3(a,b,c) (__SS_MIN((a), __SS_MIN((b), (c))))
934 #define __SS_MAX(a,b) ((a) > (b) ? (a) : (b))
935 #define __SS_MAX3(a,b,c) (__SS_MAX((a), __SS_MAX((b), (c))))
936
937 void __init();
938 void __start(void (*initfunc)());
939 void __ss_exit(int code=0);
940
941 /* slicing */
942
943 static void inline slicenr(__ss_int x, __ss_int &l, __ss_int &u, __ss_int &s, __ss_int len);
944
945 #include "builtin/hash.hpp"
946 #include "builtin/compare.hpp"
947
948
949 template<class T> inline int __is_none(T *t) { return !t; }
950 template<class T> inline int __is_none(T) { return 0; }
951
952 /* externs */
953
954 extern class_ *cl_str_, *cl_int_, *cl_bool, *cl_float_, *cl_complex, *cl_list, *cl_tuple, *cl_dict, *cl_set, *cl_object, *cl_xrange, *cl_rangeiter;
955
956 extern __GC_VECTOR(str *) __char_cache;
957
958 extern list<str *> *__join_cache;
959
960 extern file *__ss_stdin, *__ss_stdout, *__ss_stderr;
961
962 /* set */
963
964 const int PERTURB_SHIFT = 5;
965
966 const int DISCARD_NOTFOUND = 0;
967 const int DISCARD_FOUND = 1;
968
969 const int unused = 0;
970 const int dummy = 1;
971 const int active = 2;
972
973 template<class T> struct setentry {
974     long hash; // avoid rehashings...
975     T key;
976     int use;
977 };
978
979 template<class K, class V> struct dictentry {
980     long hash;
981     K key;
982     V value;
983     int use;
984 };
985
986 /* int */
987
988 inline __ss_int __int() { return 0; }
989 __ss_int __int(str *s, __ss_int base);
990
991 template<class T> inline __ss_int __int(T t) { return t->__int__(); }
992 #ifdef __SS_LONG
993 template<> inline __ss_int __int(__ss_int i) { return i; }
994 #endif
995 template<> inline __ss_int __int(int i) { return i; }
996 template<> inline __ss_int __int(str *s) { return __int(s, 10); }
997 template<> inline __ss_int __int(__ss_bool b) { return b.value; }
998 template<> inline __ss_int __int(double d) { return (__ss_int)d; }
999
1000 /* float */
1001
1002 inline double __float() { return 0; }
1003 template<class T> inline double __float(T t) { return t->__float__(); }
1004 #ifdef __SS_LONG
1005 template<> inline double __float(__ss_int p) { return p; }
1006 #endif
1007 template<> inline double __float(int p) { return p; }
1008 template<> inline double __float(__ss_bool b) { return __float(b.value); }
1009 template<> inline double __float(double d) { return d; }
1010 template<> double __float(str *s);
1011
1012 /* str */
1013
1014 template<class T> str *__str(T t) { if (!t) return new str("None"); return t->__str__(); }
1015 template<> str *__str(double t);
1016 #ifdef __SS_LONG
1017 str *__str(__ss_int t, __ss_int base=10);
1018 #endif
1019 str *__str(int t, int base=10);
1020 str *__str(__ss_bool b);
1021 str *__str(void *);
1022 str *__str();
1023
1024 str *__add_strs(int n, str *a, str *b, str *c);
1025 str *__add_strs(int n, str *a, str *b, str *c, str *d);
1026 str *__add_strs(int n, str *a, str *b, str *c, str *d, str *e);
1027 str *__add_strs(int n, ...);
1028
1029 /* repr */
1030
1031 template<class T> str *repr(T t) { if (!t) return new str("None"); return t->__repr__(); }
1032 template<> str *repr(double t);
1033 #ifdef __SS_LONG
1034 template<> str *repr(__ss_int t);
1035 #endif
1036 template<> str *repr(int t);
1037 template<> str *repr(__ss_bool b);
1038 template<> str *repr(void *t);
1039
1040 #ifndef __SS_NOASSERT
1041 #define ASSERT(x, y) if(!(x)) throw new AssertionError(y);
1042 #else
1043 #define ASSERT(x, y)
1044 #endif
1045
1046 #include "builtin/iter.hpp"
1047
1048 /* len */
1049
1050 template<class T> inline __ss_int len(T x) { return x->__len__(); }
1051 template<class T> inline __ss_int len(list<T> *x) { return x->units.size(); } /* XXX more general solution? */
1052
1053 #include "builtin/bool.hpp"
1054 #include "builtin/exception.hpp"
1055 #include "builtin/extmod.hpp"
1056
1057
1058 /* file objects */
1059
1060 struct __file_options {
1061     char lastchar;
1062     int space;
1063     bool universal_mode;
1064     bool cr;
1065     __file_options() : lastchar('\n'), space(0), universal_mode(false), cr(false) {}
1066 };
1067
1068 class file : public pyiter<str *> {
1069 public:
1070     str *name;
1071     str *mode;
1072
1073     FILE *f;
1074     __ss_int closed;
1075     __file_options options;
1076     __GC_VECTOR(char) __read_cache;
1077
1078     file(FILE *g=0) : f(g) {}
1079     file(str *name, str *mode=0);
1080
1081     virtual void * close();
1082     virtual void * flush();
1083     virtual int  __ss_fileno();
1084     virtual __ss_bool isatty();
1085     virtual str *  next();
1086     virtual str *  read(int n=-1);
1087     virtual str *  readline(int n=-1);
1088     list<str *> *  readlines(__ss_int size_hint=-1);
1089     virtual void * seek(__ss_int i, __ss_int w=0);
1090     virtual __ss_int tell();
1091     virtual void * truncate(int size);
1092     virtual void * write(str *s);
1093     template<class U> void *writelines(U *iter);
1094     __iter<str *> *xreadlines();
1095     virtual void __enter__();
1096     virtual void __exit__();
1097     virtual __iter<str *> *__iter__();
1098     virtual str *__repr__();
1099     
1100     virtual bool __eof();
1101     virtual bool __error();
1102
1103     inline void __check_closed() {
1104         if(closed)
1105             throw new ValueError(new str("I/O operation on closed file"));
1106     }
1107 };
1108
1109 class __fileiter : public __iter<str *> {
1110 public:
1111     file *p;
1112     __fileiter(file *p);
1113     str *next();
1114 };
1115
1116 /* with statement */
1117
1118 template<class T> class __With {
1119 public:
1120     __With(T expr) : _expr(expr) {
1121         _expr->__enter__();
1122     }
1123     ~__With() {
1124         _expr->__exit__();
1125     }
1126     operator T() const {
1127         return _expr;
1128     }
1129 private:
1130     T _expr;
1131 };
1132
1133 #define WITH(e, n) {           \
1134     __With<typeof(e)> __with##n(e); // TODO unique id
1135
1136 #define WITH_VAR(e, v, n) {    \
1137     __With<typeof(e)> __with##n(e);      \
1138     typeof(e) v = __with##n;
1139
1140 #define END_WITH }
1141
1142 template<class T> static inline int __wrap(T a, int i) {
1143 #ifndef __SS_NOWRAP
1144     if(i<0) return len(a)+i;
1145 #endif
1146 #ifndef __SS_NOBOUNDS
1147         if(i<0 || i>= len(a))
1148             __throw_index_out_of_range();
1149 #endif
1150     return i;
1151 }
1152
1153
1154 /* copy */
1155
1156 template<class T> T __copy(T t) {
1157     if(!t)
1158         return (T)NULL;
1159     return (T)(t->__copy__());
1160 }
1161
1162 #ifdef __SS_LONG
1163 template<> inline __ss_int __copy(__ss_int i) { return i; }
1164 #endif
1165 template<> inline int __copy(int i) { return i; }
1166 template<> inline __ss_bool __copy(__ss_bool b) { return b; }
1167 template<> inline double __copy(double d) { return d; }
1168 template<> inline void *__copy(void *p) { return p; }
1169
1170 template<class T> T __deepcopy(T t, dict<void *, pyobj *> *memo=0) {
1171     if(!t)
1172         return (T)NULL;
1173
1174     if(!memo)
1175         memo = new dict<void *, pyobj *>();
1176     T u = (T)(memo->get(t, 0));
1177     if(u)
1178        return u;
1179
1180     return (T)(t->__deepcopy__(memo));
1181 }
1182
1183 #ifdef __SS_LONG
1184 template<> inline __ss_int __deepcopy(__ss_int i, dict<void *, pyobj *> *) { return i; }
1185 #endif
1186 template<> inline int __deepcopy(int i, dict<void *, pyobj *> *) { return i; }
1187 template<> inline __ss_bool __deepcopy(__ss_bool b, dict<void *, pyobj *> *) { return b; }
1188 template<> inline double __deepcopy(double d, dict<void *, pyobj *> *) { return d; }
1189 template<> inline void *__deepcopy(void *p, dict<void *, pyobj *> *) { return p; }
1190
1191 /* and, or, not */
1192
1193 #define __OR(a, b, t) ((___bool(__ ## t = a))?(__ ## t):(b))
1194 #define __AND(a, b, t) ((!___bool(__ ## t = a))?(__ ## t):(b))
1195 #define __NOT(x) (__mbool(!(x)))
1196
1197 /* 'zero' value for type */
1198
1199 template<class T> T __zero() { return 0; }
1200 template<> inline __ss_bool __zero<__ss_bool>() { return False; }
1201 template<> inline complex __zero<complex>() { return mcomplex(0,0); }
1202
1203 #include "builtin/list.hpp"
1204 #include "builtin/tuple.hpp"
1205 #include "builtin/str.hpp"
1206 #include "builtin/dict.hpp"
1207 #include "builtin/set.hpp"
1208 #include "builtin/file.hpp"
1209 #include "builtin/math.hpp"
1210 #include "builtin/format.hpp"
1211 #include "builtin/function.hpp"
1212 #include "builtin/complex.hpp"
1213
1214 /* pyiter methods */
1215
1216 template<class T> inline __iter<T> *pyiter<T>::for_in_init() {
1217     return this->__iter__();
1218 }
1219
1220 template<class T> inline bool pyiter<T>::for_in_has_next(__iter<T> *iter) {
1221     iter->__result = iter->__get_next();
1222     return not iter->__stop_iteration;
1223 }
1224
1225 template<class T> inline T pyiter<T>::for_in_next(__iter<T> *iter) {
1226     return iter->__result;
1227 }
1228
1229 template<class T> inline __ss_bool pyiter<T>::__contains__(T t) {
1230     T e;
1231     typename pyiter<T>::for_in_loop __3;
1232     int __2;
1233     pyiter<T> *__1;
1234     FOR_IN(e,this,1,2,3)
1235         if(__eq(e,t))
1236             return __mbool(true);
1237     END_FOR 
1238     return __mbool(false);
1239 }
1240
1241 /* pyseq methods */
1242
1243 template<class T> __ss_int pyseq<T>::__cmp__(pyobj *p) {
1244     if (!p) return 1;
1245     pyseq<T> *b = (pyseq<T> *)p;
1246     int i, cmp;
1247     int mnm = ___min(2, 0, this->__len__(), b->__len__());
1248     for(i = 0; i < mnm; i++) {
1249         cmp = __cmp(this->__getitem__(i), b->__getitem__(i));
1250         if(cmp)
1251             return cmp;
1252     }
1253     return __cmp(this->__len__(), b->__len__());
1254 }
1255
1256 template<class T> __iter<T> *pyseq<T>::__iter__() {
1257     return new __seqiter<T>(this);
1258 }
1259
1260 template<class T> inline size_t pyseq<T>::for_in_init() {
1261     return 0;
1262 }
1263
1264 template<class T> inline bool pyseq<T>::for_in_has_next(size_t i) {
1265     return (__ss_int)i != __len__(); /* XXX opt end cond */
1266 }
1267
1268 template<class T> inline T pyseq<T>::for_in_next(size_t &i) {
1269     return __getitem__(i++);
1270 }
1271
1272 /* __iter methods */
1273
1274 template<class T> __iter<T> *__iter<T>::__iter__() { 
1275     __stop_iteration = false; 
1276     return this; 
1277 }
1278
1279 template<class T> T __iter<T>::next() { /* __get_next can be overloaded instead to avoid (slow) exception handling */
1280     __result = this->__get_next();
1281     if(__stop_iteration)
1282         throw new StopIteration();
1283     return __result;
1284
1285
1286 template<class T> T __iter<T>::__get_next() {
1287     try {
1288         __result = this->next();
1289     } catch (StopIteration *) {
1290         __stop_iteration = true;
1291     }
1292     return __result;
1293 }
1294 /* iterators */
1295
1296 template<class T> str *__iter<T>::__repr__() {
1297     return new str("iterator instance");
1298 }
1299
1300 template<class T> __seqiter<T>::__seqiter() {}
1301 template<class T> __seqiter<T>::__seqiter(pyseq<T> *p) {
1302     this->p = p;
1303     size = p->__len__();
1304     counter = 0;
1305 }
1306
1307 template<class T> T __seqiter<T>::next() {
1308     if(counter==size)
1309         __throw_stop_iteration();
1310     return p->__getitem__(counter++);
1311 }
1312
1313
1314 /* slicing */
1315
1316 static void inline slicenr(__ss_int x, __ss_int &l, __ss_int &u, __ss_int &s, __ss_int len) {
1317     if(x&4) {
1318         if (s == 0)
1319             __throw_slice_step_zero();
1320     } else
1321         s = 1;
1322
1323     if (l>=len)
1324         l = len;
1325     else if (l<0) {
1326         l = len+l;
1327         if(l<0)
1328             l = 0;
1329     }
1330     if (u>=len)
1331         u = len;
1332     else if (u<0) {
1333         u = len+u;
1334         if(u<0)
1335             u = 0;
1336     }
1337
1338     if(s<0) {
1339         if (!(x&1))
1340             l = len-1;
1341         if (!(x&2))
1342             u = -1;
1343     }
1344     else {
1345         if (!(x&1))
1346             l = 0;
1347         if (!(x&2))
1348             u = len;
1349     }
1350 }
1351
1352
1353 } // namespace __shedskin__
1354 #endif