fill out do_modfill, fixing some issues with '.. % tuple'
[shedskin:mainline.git] / lib / builtin.cpp
1 #include "builtin.hpp"
2 #include <climits>
3 #include <numeric>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <errno.h>
7 #include <limits.h>
8
9 namespace __shedskin__ {
10
11 class_ *cl_class_, *cl_none, *cl_str_, *cl_int_, *cl_float_, *cl_list, *cl_tuple, *cl_dict, *cl_set, *cl_object, *cl_rangeiter;
12
13 str *sp;
14 __GC_STRING ws, __fmtchars;
15 __GC_VECTOR(str *) __char_cache;
16
17
18 void __init() {
19     GC_INIT();
20 #ifdef __SS_BIND
21     Py_Initialize();
22 #endif
23
24     cl_class_ = new class_ ("class_", 0, 0);
25     cl_none = new class_("none", 1, 1);
26     cl_str_ = new class_("str_", 2, 2);
27     cl_int_ = new class_("int_", 3, 3);
28     cl_float_ = new class_("float_", 4, 4);
29     cl_list = new class_("list", 5, 5);
30     cl_tuple = new class_("tuple", 6, 6);
31     cl_dict = new class_("dict", 7, 7);
32     cl_set = new class_("set", 8, 8);
33     cl_object = new class_("object", 9, 9);
34     cl_rangeiter = new class_("rangeiter", 10, 10);
35
36     ws = " \n\r\t\f\v";
37     __fmtchars = "diouxXeEfFgGhcrs%";
38     sp = new str(" ");
39
40     for(int i=0;i<256;i++) {
41         char c = i;
42         __char_cache.push_back(new str(&c, 1));
43     }
44 }
45
46 double __portableround(double x) {
47     if(x<0) return ceil(x-0.5);
48     return floor(x+0.5);
49 }
50
51 /* int_ methods */
52
53 int_::int_(int i) {
54     unit = i;
55     __class__ = cl_int_;
56 }
57
58 str *int_::__repr__() {
59     return __str(unit);
60
61
62 /* float methods */
63
64 float_::float_(double f) {
65     unit = f;
66     __class__ = cl_float_;
67 }
68
69 str *float_::__repr__() {
70     return __str(unit);
71
72
73 /* str methods */
74
75 str::str() : cached_hash(0) {
76     __class__ = cl_str_;
77 }
78
79 str::str(const char *s) : unit(s), cached_hash(0) {
80     __class__ = cl_str_;
81 }
82
83 str::str(__GC_STRING s) : unit(s), cached_hash(0) {
84     __class__ = cl_str_;
85 }
86
87 str::str(const char *s, int size) : cached_hash(0), unit(__GC_STRING(s, size)) { /* '\0' delimiter in C */
88     __class__ = cl_str_;
89 }
90
91 str *str::__getitem__(int i) {
92     i = __wrap(this, i);
93     return __char_cache[(unsigned char)unit[i]];
94 }
95 str *str::__getfirst__() {
96     return __getitem__(0);
97 }
98 str *str::__getsecond__() {
99     return __getitem__(1);
100 }
101
102 int str::__len__() {
103     return unit.size();
104 }
105
106 str *str::__str__() { // weg?
107     return this;
108 }
109
110 str *str::__repr__() {
111     std::stringstream ss;
112     __GC_STRING sep = "\\\n\r\t";
113     __GC_STRING let = "\\nrt";
114
115     const char *quote = "'";
116     int hasq = unit.find("'");
117     int hasd = unit.find("\"");
118
119     if (hasq != -1 && hasd != -1) {
120         sep += "'"; let += "'";
121     }
122     if (hasq != -1 && hasd == -1)
123         quote = "\"";
124
125     ss << quote;
126     for(int i=0; i<unit.size(); i++)
127     {
128         char c = unit[i];
129         int k;
130
131         if((k = sep.find_first_of(c)) != -1)
132             ss << "\\" << let[k];
133         else {
134             int j = (int)((unsigned char)c);
135
136             if(j<16)
137                 ss << "\\x0" << std::hex << j;
138             else if(j>=' ' && j<='~')
139                 ss << (char)j;
140             else
141                 ss << "\\x" << std::hex << j;
142         }
143     }
144     ss << quote;
145
146     return new str(ss.str().c_str());
147 }
148
149 int str::__contains__(str *s) {
150     return unit.find(s->unit) != -1;
151 }
152
153 int str::isspace() {
154     return unit.size() && (unit.find_first_not_of(ws) == -1);
155 }
156
157 int str::isdigit() {
158     return __ctype_function(&::isdigit);
159 }
160
161 int str::isalpha() {
162     return __ctype_function(&::isalpha);
163 }
164
165 int str::isalnum() {
166     return __ctype_function(&::isalnum);
167 }
168
169 int str::__ctype_function(int (*cfunc)(int))
170 {
171   int i, l = unit.size();
172   if(!l) 
173       return 0;
174   
175   for(i = 0; i < l; i++) 
176       if(!cfunc((int)unit[i])) return 0;
177   
178   return 1;
179 }
180
181 str *str::ljust(int width, str *s) {
182     if(width<=__len__()) return this;
183     if(!s) s = sp;
184     return __add__(s->__mul__(width-__len__()));
185 }
186
187 str *str::rjust(int width, str *s) {
188     if(width<=__len__()) return this;
189     if(!s) s = sp;
190     return s->__mul__(width-__len__())->__add__(this);
191 }
192
193 str *str::zfill(int width) {
194     if(width<=__len__()) return this;
195     return (new str("0"))->__mul__(width-__len__())->__add__(this);
196 }
197
198 str *str::expandtabs(int width) {
199     int i;
200     __GC_STRING r = unit;
201     while((i = r.find("\t")) != -1)
202         r.replace(i, 1, (new str(" "))->__mul__(width-i%width)->unit);
203     return new str(r);
204 }
205
206 int str::islower() {
207     return __ctype_function(&::islower);
208 }
209 int str::isupper() {
210     return __ctype_function(&::isupper);
211 }
212
213 str *str::strip(str *chars) {
214     return lstrip(chars)->rstrip(chars);
215 }
216
217 str *str::lstrip(str *chars) {
218     __GC_STRING remove;
219     if(chars) remove = chars->unit;
220     else remove = ws;
221     int first = unit.find_first_not_of(remove);
222     if( first == -1 ) 
223         return new str("");
224     return new str(unit.substr(first,unit.size()-first));
225 }
226
227
228
229 tuple2<str *, str *> *str::partition(str *sep)
230 {
231     int i;
232     
233     i = unit.find(sep->unit);
234     if(i != -1) 
235         return new tuple2<str *, str *>(3, new str(unit.substr(0, i)), new str(sep->unit), new str(unit.substr(i + sep->unit.length())));
236     else 
237         return new tuple2<str *, str *>(3, new str(unit), new str(""), new str(""));
238 }
239
240 tuple2<str *, str *> *str::rpartition(str *sep)
241 {
242     int i;
243     
244     i = unit.rfind(sep->unit);
245     if(i != -1) 
246         return new tuple2<str *, str *>(3, new str(unit.substr(0, i)), new str(sep->unit), new str(unit.substr(i + sep->unit.length())));
247     else 
248         return new tuple2<str *, str *>(3, new str(unit), new str(""), new str(""));
249 }
250
251 list<str *> *str::rsplit(str *sep, int maxsep)
252 {
253     __GC_STRING ts;
254     list<str *> *r = new list<str *>();
255     int i, j, curi, tslen;
256     
257     curi = 0;
258     i = j = unit.size() - 1;
259     
260     //split by whitespace
261     if(!sep)
262     {
263         while(i > 0 && j > 0 && (curi < maxsep || maxsep < 0))
264         {
265             j = unit.find_last_not_of(ws, i);
266             if(j == -1) break;
267             
268             i = unit.find_last_of(ws, j);
269             
270             //this works out pretty nicely; i will be -1 if no more is found, and thus i + 1 will be 0th index
271             r->append(new str(unit.substr(i + 1, j - i)));
272             curi++;
273         }
274         
275         //thus we only bother about extra stuff here if we *have* found more whitespace
276         if(i > 0 && j >= 0 && (j = unit.find_last_not_of(ws, i)) >= 0) r->append(new str(unit.substr(0, j)));
277     }
278     
279     //split by seperator
280     else
281     {
282         ts = sep->unit;
283         tslen = ts.length();
284         
285         i++;
286         while(i > 0 && j > 0 && (curi < maxsep || maxsep < 0))
287         {
288             j = i;
289             i--;
290             
291             i = unit.rfind(ts, i);
292             if(i == -1)
293             {
294                 i = j;
295                 break;
296             }
297             
298             r->append(new str(unit.substr(i + tslen, j - i - tslen)));
299             
300             curi++;
301         }
302         
303         //either left over (beyond max) or very last match (see loop break)
304         if(i >= 0) r->append(new str(unit.substr(0, i)));
305     }
306     
307     r->reverse();
308     
309     return r;
310 }
311
312 int str::istitle(void)
313 {
314     int i, len;
315     
316     len = unit.size();
317     if(!len)
318         return 0;
319
320     for(i = 0; i < len; )
321     {
322         for( ; !::isalpha((int)unit[i]) && i < len; i++) ;
323         if(i == len) break;
324         
325         if(!::isupper((int)unit[i])) return 0;
326         i++;
327         
328         for( ; ::islower((int)unit[i]) && i < len; i++) ;
329         if(i == len) break;
330         
331         if(::isalpha((int)unit[i])) return 0;
332     }
333     
334     return 1;
335 }
336
337 list<str *> *str::splitlines(int keepends)
338 {
339     list<str *> *r = new list<str *>();
340     int i, j, endlen;
341     const char *ends = "\r\n";
342     
343     endlen = i = 0;
344     do
345     {
346         j = i + endlen;
347         i = unit.find_first_of(ends, j);
348         if(i == -1) break;
349         
350         //for all we know the character sequence could change mid-way...
351         if(unit[i] == '\r' && unit[i + 1] == '\n') endlen = 2;
352         else endlen = 1;
353         
354         r->append(new str(unit.substr(j, i - j + (keepends ? endlen : 0))));
355     }
356     while(i >= 0);
357     
358     if(j != unit.size()) r->append(new str(unit.substr(j)));
359     
360     return r;
361 }
362
363
364
365 str *str::rstrip(str *chars) {
366     __GC_STRING remove;
367     if(chars) remove = chars->unit;
368     else remove = ws;
369     int last = unit.find_last_not_of(remove);
370     if( last == -1 ) 
371         return new str("");
372     return new str(unit.substr(0,last+1));
373 }
374
375 list<str *> *str::split(str *sp, int max_splits) { 
376     __GC_STRING s = unit;
377     int sep_iter, chunk_iter = 0, tmp, num_splits = 0;
378     list<str *> *result = new list<str *>();
379
380     if (sp == NULL)
381     {
382 #define next_separator(iter) (s.find_first_of(ws, (iter)))
383 #define skip_separator(iter) (s.find_first_not_of(ws, (iter)))
384
385         if(next_separator(chunk_iter) == 0) 
386             chunk_iter = skip_separator(chunk_iter);
387         while((max_splits < 0 or num_splits < max_splits)
388               and (sep_iter = next_separator(chunk_iter)) != -1)
389         {
390             result->append(new str(s.substr(chunk_iter, sep_iter - chunk_iter)));
391             if((tmp = skip_separator(sep_iter)) == -1) {
392                 chunk_iter = sep_iter;
393                 break;
394             } else
395                 chunk_iter = tmp;
396             ++num_splits;
397         }
398         if(not (max_splits < 0 or num_splits < max_splits))
399             result->append(new str(s.substr(chunk_iter, s.size()-chunk_iter))); 
400         else if(sep_iter == -1)
401             result->append(new str(s.substr(chunk_iter, s.size()-chunk_iter))); 
402
403 #undef next_separator
404 #undef skip_separator
405
406     } else { /* given separator (slightly different algorithm required)
407               * (python is very inconsistent in this respect) */
408         const char *sep = sp->unit.c_str();
409         int sep_size = sp->unit.size();
410
411 #define next_separator(iter) s.find(sep, (iter))
412 #define skip_separator(iter) ((iter + sep_size) > s.size()? -1 : (iter + sep_size))
413
414         if (max_splits == 0) {
415             result->append(this);
416             return result;
417         }
418         if(next_separator(chunk_iter) == 0) {
419             chunk_iter = skip_separator(chunk_iter);
420             result->append(new str());
421             ++num_splits;
422         }
423         while((max_splits < 0 or num_splits < max_splits)
424               and (sep_iter = next_separator(chunk_iter)) != -1)
425         {
426             result->append(new str(s.substr(chunk_iter, sep_iter - chunk_iter)));
427             if((tmp = skip_separator(sep_iter)) == -1) {
428                 chunk_iter = sep_iter;
429                 break;
430             } else
431                 chunk_iter = tmp;
432             ++num_splits;
433         }
434         if(not (max_splits < 0 or num_splits < max_splits))
435             result->append(new str(s.substr(chunk_iter, s.size()-chunk_iter))); 
436         else if(sep_iter == -1)
437             result->append(new str(s.substr(chunk_iter, s.size()-chunk_iter))); 
438
439
440 #undef next_separator
441 #undef skip_separator
442
443     }
444
445     return result;
446 }
447
448 str *str::translate(str *table, str *delchars) {
449     if(len(table) != 256)
450         throw new ValueError(new str("translation table must be 256 characters long"));
451
452     str *newstr = new str();
453
454     int self_size = unit.size();
455     for(int i = 0; i < self_size; i++) {
456         char c = unit[i];
457         if(!delchars || delchars->unit.find(c) == -1)
458             newstr->unit.push_back(table->unit[(unsigned char)c]);
459     }
460
461     return newstr;
462 }
463
464 str *str::swapcase() {
465     str *r = new str(unit);
466     int len = __len__();
467
468     for(int i = 0; i < len; i++) {
469         char c = unit[i];
470         if( c >= 'a' && c <= 'z' )
471             r->unit[i] = ::toupper(c);
472         else if( c >= 'A' && c <= 'Z' )
473             r->unit[i] = ::tolower(c);
474     }
475
476     return r;
477 }
478
479 str *str::center(int w, str *fill) {
480     int len = __len__();
481     if(w<=len)
482         return this;
483
484     if(!fill) fill = sp;
485     str *r = fill->__mul__(w);
486
487     int j = (w-len)/2;
488     for(int i=0; i<len; i++)
489         r->unit[j+i] = unit[i];
490
491     return r;
492 }
493
494 int str::__cmp__(pyobj *p) {
495     str *b = (str *)p;
496     int r = unit.compare(b->unit);
497     if( r < 0 ) return -1;
498     else if( r > 0 ) return 1;
499     return 0;
500 }
501
502 int str::__eq__(pyobj *p) {
503     return unit == ((str *)p)->unit;
504 }
505
506 str *str::__mul__(int n) { /* optimize */
507     str *r = new str();
508     if(n<=0) return r;
509     __GC_STRING &s = r->unit;
510     int ulen = unit.size();
511
512     if(ulen == 1)
513        r->unit = __GC_STRING(n, unit[0]);
514     else {
515         s.resize(ulen*n);
516
517         for(int i=0; i<ulen*n; i+=ulen)
518             s.replace(i, ulen, unit);
519     }
520
521     return r;
522 }
523 str *str::__imul__(int n) { 
524     return __mul__(n);
525 }
526
527 /* ======================================================================== */
528
529 /* (C) 2004, 2005 Paul Hsieh. Covered under the Paul Hsieh derivative license.
530    http://www.azillionmonkeys.com/qed/{hash,weblicense}.html  */
531
532 #define get16bits(d) (*((const uint16_t *) (d)))
533
534 static inline uint32_t SuperFastHash (const char * data, int len) {
535     uint32_t hash = 0, tmp;
536     int rem;
537
538     if (len <= 0 || data == NULL) return 0;
539
540     rem = len & 3;
541     len >>= 2;
542
543     /* Main loop */
544     for (;len > 0; len--) {
545         hash  += get16bits (data);
546         tmp    = (get16bits (data+2) << 11) ^ hash;
547         hash   = (hash << 16) ^ tmp;
548         data  += 2*sizeof (uint16_t);
549         hash  += hash >> 11;
550     }
551
552     /* Handle end cases */
553     switch (rem) {
554         case 3: hash += get16bits (data);
555                 hash ^= hash << 16;
556                 hash ^= data[sizeof (uint16_t)] << 18;
557                 hash += hash >> 11;
558                 break;
559         case 2: hash += get16bits (data);
560                 hash ^= hash << 11;
561                 hash += hash >> 17;
562                 break;
563         case 1: hash += *data;
564                 hash ^= hash << 10;
565                 hash += hash >> 1;
566     }
567
568     /* Force "avalanching" of final 127 bits */
569     hash ^= hash << 3;
570     hash += hash >> 5;
571     hash ^= hash << 4;
572     hash += hash >> 17;
573     hash ^= hash << 25;
574     hash += hash >> 6;
575
576     return hash;
577 }
578
579 /* ======================================================================== */
580
581 int str::__hash__() {
582     if(cached_hash) 
583         return cached_hash;
584     cached_hash = SuperFastHash(unit.c_str(), unit.size());
585     return cached_hash;
586
587     //return __gnu_cxx::hash<char *>()(unit.c_str());
588 }
589
590 str *str::__add__(str *b) {
591     str *s = new str();
592
593     s->unit.reserve(unit.size()+b->unit.size());
594     s->unit.append(unit);
595     s->unit.append(b->unit);
596
597     return s;
598 }
599 str *str::__iadd__(str *b) {
600     return __add__(b);
601 }
602
603 str *__add_strs(int n, ...) {
604     va_list ap;
605     va_start(ap, n);
606
607     int size;
608     str *result = new str();
609
610     size = 0;
611     for(int i=0; i<n; i++) {
612         size += len(va_arg(ap, str *));
613     }
614     va_end(ap);
615
616     result->unit.resize(size);
617
618     va_start(ap, n);
619     size = 0;
620     int pos = 0;
621     for(int i=0; i<n; i++) {
622         str *s = va_arg(ap, str *);
623
624         memcpy((void *)(result->unit.data()+pos), s->unit.data(), s->unit.size());
625         pos += s->unit.size();
626     }
627     va_end(ap);
628
629     return result;
630 }
631
632 str *str::__join(pyseq<str *> *l, int total_len) {
633     __GC_STRING s;
634     s.resize(total_len);
635
636     int k = 0;
637
638     for(int i = 0; i < len(l); i++) {
639         __GC_STRING &t = l->units[i]->unit;
640
641         memcpy((void *)(s.data()+k), t.data(), t.size());
642         k += t.size();
643
644         if(unit.size()) {
645             memcpy((void *)(s.data()+k), unit.data(), unit.size());
646             k += unit.size();
647         } 
648     }
649
650     s.resize(s.size()-unit.size());
651     return new str(s);
652 }
653
654 str *str::join(pyiter<str *> *l) { 
655     list<str *> *rl = new list<str *>();
656     str *i;
657     int count, total_len;
658     count = total_len = 0;
659     __iter<str *> *__0;
660     FOR_IN(i, l, 0)
661         rl->append(i);
662         total_len += i->unit.size();
663         ++count;
664     END_FOR
665     total_len += count*unit.size();
666
667     return __join(rl, total_len);
668
669
670 str *str::join(pyseq<str *> *l) {
671     int total_len = 0;
672     __GC_VECTOR(str *)::const_iterator it;
673     for(it = l->units.begin(); it < l->units.end(); it++)
674         total_len += (*it)->unit.size();
675     total_len += len(l)*unit.size();
676
677     return __join(l, total_len);
678 }
679
680 str *str::__slice__(int x, int l, int u, int s) {
681     __GC_STRING r;
682     slicenr(x, l, u, s, __len__());
683
684     if(s > 0)
685         for(int i=l; i<u; i += s)
686             r += unit[i];
687     else
688         for(int i=l; i>u; i += s)
689             r += unit[i];
690
691     return new str(r);
692 }
693
694 int str::__fixstart(int a, int b) {
695     if(a == -1) return a;
696     return a+b;
697 }
698
699 int str::find(str *s, int a) { return __fixstart(unit.substr(a, unit.size()-a).find(s->unit), a); }
700 int str::find(str *s, int a, int b) { return __fixstart(unit.substr(a, b-a).find(s->unit), a); }
701
702 int str::rfind(str *s, int a) { return __fixstart(unit.substr(a, unit.size()-a).rfind(s->unit), a); }
703 int str::rfind(str *s, int a, int b) { return __fixstart(unit.substr(a, b-a).rfind(s->unit), a); }
704
705 int str::__checkneg(int i) {
706     if(i == -1)
707         throw new ValueError(new str("substring not found"));
708     return i;
709 }
710
711 int str::index(str *s, int a) { return __checkneg(find(s, a)); }
712 int str::index(str *s, int a, int b) { return __checkneg(find(s, a, b)); }
713
714 int str::rindex(str *s, int a) { return __checkneg(find(s, a)); }
715 int str::rindex(str *s, int a, int b) { return __checkneg(find(s, a, b)); }
716
717 int str::count(str *s, int start) { return count(s, start, __len__()); }
718 int str::count(str *s, int start, int end) {
719     int i, count, one = 1;
720     slicenr(7, start, end, one, __len__());
721
722     i = start; count = 0;
723     while( ((i = unit.find(s->unit, i)) != -1) && (i <= end-len(s)) )
724     {
725         i += len(s);
726         count++;
727     }
728
729     return count; 
730 }
731
732 int str::startswith(str *s, int start) { return startswith(s, start, __len__()); }
733 int str::startswith(str *s, int start, int end) {
734     int i, j, one = 1;
735     slicenr(7, start, end, one, __len__());
736
737     for(i = start, j = 0; i < end && j < len(s); )
738         if (unit[i++] != s->unit[j++])
739             return 0;
740
741     return j == len(s); 
742 }
743
744 int str::endswith(str *s, int start) { return endswith(s, start, __len__()); }
745 int str::endswith(str *s, int start, int end) {
746     int i, j, one = 1;
747     slicenr(7, start, end, one, __len__());
748
749     for(i = end, j = len(s); i > start && j > 0; )
750         if (unit[--i] != s->unit[--j])
751             return 0; 
752
753     return 1;
754 }
755
756 str *str::replace(str *a, str *b, int c) {
757     __GC_STRING s = unit;
758     int i, j = 0;
759     while( ((c==-1) || (j++ != c)) && (i = s.find(a->unit)) != -1 ) 
760         s.replace(i, a->unit.size(), b->unit);
761     return new str(s);
762 }
763
764 str *str::upper() {
765     if(unit.size() == 1)
766         return __char_cache[::toupper(unit[0])];
767
768     str *toReturn = new str(*this);
769     std::transform(toReturn->unit.begin(), toReturn->unit.end(), toReturn->unit.begin(), toupper);
770
771     return toReturn;
772 }
773
774 str *str::lower() {
775     if(unit.size() == 1)
776         return __char_cache[::tolower(unit[0])];
777
778     str *toReturn = new str(*this);
779     std::transform(toReturn->unit.begin(), toReturn->unit.end(), toReturn->unit.begin(), tolower);
780
781     return toReturn;
782 }
783
784 str *str::title() {
785     str *r = new str(unit);
786     int i = 0;
787     while( (i != -1) && (i<unit.size()) )
788     {
789         r->unit[i] = ::toupper(r->unit[i]);
790         i = unit.find(" ", i);
791         if (i != -1)
792             i++;
793     }
794     return r;
795 }
796
797 str *str::capitalize() {
798     str *r = new str(unit);
799     r->unit[0] = ::toupper(r->unit[0]);
800     return r;
801 }
802
803 /* str *str::sorted() {
804     str *s = new str(unit);
805     sort(s->unit.begin(), s->unit.end());
806     return s;
807 } */
808
809 #ifdef __SS_BIND
810 str::str(PyObject *p) : cached_hash(0) {
811     if(!PyString_Check(p)) 
812         throw new TypeError(new str("error in conversion to Shed Skin (string expected)"));
813
814     __class__ = cl_str_;
815     unit = __GC_STRING(PyString_AsString(p), PyString_Size(p));
816 }
817
818 PyObject *str::__to_py__() {
819     return PyString_FromStringAndSize(unit.c_str(), unit.size());
820 }
821 #endif
822
823 class_::class_(const char *name, int low, int high) {
824     this->__name__ = new str(name);
825     this->low = low; this->high = high;
826 }
827
828 str *class_::__repr__() {
829     return (new str("class "))->__add__(__name__);
830 }
831
832 int class_::__eq__(pyobj *c) {
833     return c == this;
834 }
835
836 /* file methods */
837
838 file::file() {
839     endoffile=print_space=0;
840     print_lastchar='\n';
841 }
842
843 file::file(FILE *g) {
844     f = g;
845     endoffile=print_space=0;
846     print_lastchar='\n';
847 }
848
849 file::file(str *name, str *flags) {
850     if (!flags)
851         flags = new str("r");
852     f = fopen(name->unit.c_str(), flags->unit.c_str());
853     this->name = name;
854     this->mode = flags;
855     if(!f) 
856        throw new IOError(__mod(new str("No such file or directory: '%s'"), name));
857     endoffile=print_space=0;
858     print_lastchar='\n';
859 }
860
861 file *open(str *name, str *flags) {
862     return new file(name, flags);
863 }
864
865 int file::getchar() {
866     __check_closed();
867     return fgetc(f);
868 }
869
870 int file::putchar(int c) {
871     __check_closed();
872     fputc(c, f);
873     return 0;
874 }
875
876 int file::write(str *s) {
877     __check_closed();
878   //  fputs(s->unit.c_str(), f);
879
880     for(int i = 0; i < s->unit.size(); i++)
881         putchar(s->unit[i]);
882
883     return 0;
884 }
885
886 void file::__check_closed() {
887     if(closed)
888         throw new ValueError(new str("I/O operation on closed file"));
889 }
890
891 int file::seek(int i, int w) {
892     __check_closed();
893     fseek(f, i, w);
894     endoffile = 0; /* XXX add check */
895     return 0;
896 }
897
898 int file::tell() {
899     __check_closed();
900     return ftell(f);
901 }
902
903 int file::writelines(pyseq<str *> *l) {
904     __check_closed();
905     for(int i=0; i<len(l); i++)
906         write(l->__getitem__(i));
907     return 0;
908 }
909
910 str *file::readline(int n) { 
911     __check_closed();
912     int i = 0;
913     str *r = new str();
914
915     while((n==-1) || (i < n)) {
916         int c = getchar();
917         if(c == EOF) {
918             endoffile = 1;
919             break;
920         }
921         r->unit += c;
922         if(c == '\n')
923             break;
924         i += 1;
925     }
926
927     return r;
928 }
929
930 str *file::read(int n) {
931     __check_closed();
932     int i = 0;
933     str *r = new str();
934
935     while((n==-1) || (i < n)) {
936         int c = getchar();
937         if(c == EOF) {
938             endoffile = 1;
939             break;
940         }
941         r->unit += c;
942         i += 1;
943     }
944
945     return r;
946 }
947
948 list<str *> *file::readlines() {
949     __check_closed();
950     list<str *> *lines = new list<str *>();
951     while(!endoffile) {
952         str *line = readline(); 
953         if(endoffile && !len(line))
954             break;
955         lines->append(line);
956     } 
957
958     return lines;
959 }
960
961 int file::flush() {
962     __check_closed();
963     fflush(f);
964     return 0;
965 }
966
967 int file::close() {
968     fclose(f);
969     closed = 1;
970     return 0;
971 }
972
973 int file::__ss_fileno() {
974     __check_closed();
975     return fileno(f);
976 }
977
978 str *file::__repr__() {
979     return (new str("file '"))->__add__(name)->__add__(new str("'"));
980 }
981
982 /* builtin functions */
983
984 str *pyobj::__repr__() {
985     return __class__->__name__->__add__(new str(" instance"));
986 }
987
988 int whatsit(__GC_STRING &s) {
989     int i = -1;
990     int count = 0;
991
992     while((i = s.find("%", i+1)) > -1)
993     {
994         int j = s.find_first_of("diouxXeEfFgGhcrs", i);
995         s.replace(i, j-i+1, "%s");
996         count += 1;
997     }
998
999     return count;
1000 }
1001
1002 str *raw_input(str *msg) {
1003     __GC_STRING s;
1004     if(msg)
1005         std::cout << msg->unit;
1006     std::getline(std::cin, s);
1007     return new str(s); 
1008 }
1009
1010 int __int() { return 0; }
1011
1012 template<> int __int(str *s) { return __int(s, 10); }
1013 template<> int __int(int i) { return i; }
1014 template<> int __int(bool b) { return b; }
1015 template<> int __int(double d) { return (int)d; }
1016
1017 int __int(str *s, int base) {
1018     char *cp;
1019     s = s->strip();
1020     int i = strtol(s->unit.c_str(), &cp, base);
1021     if(cp != s->unit.c_str()+s->unit.size())
1022         throw new ValueError(new str("invalid literal for int()"));
1023     return i;
1024 }
1025
1026 double __float() { return 0; }
1027 template<> double __float(int p) { return p; }
1028 template<> double __float(bool b) { return __float((int)b); }
1029 template<> double __float(double d) { return d; }
1030 template<> double __float(str *s) {
1031     return atof((char *)(s->unit.c_str()));
1032 }
1033
1034 int isinstance(pyobj *p, class_ *c) {
1035     int classnr = p->__class__->low;
1036     return ((classnr >= c->low) && (classnr <= c->high));
1037 }
1038
1039 int isinstance(pyobj *p, tuple2<class_ *, class_ *> *t) {
1040     int classnr = p->__class__->low;
1041     for(int i = 0; i < t->__len__(); i++)
1042     {
1043        class_ *c = t->__getitem__(i);
1044        if ((classnr >= c->low) && (classnr <= c->high))
1045            return 1;
1046     }
1047     return 0;
1048 }
1049
1050 static int range_len(int lo, int hi, int step) {
1051     /* modified from CPython */
1052     int n = 0;
1053     if ((lo < hi) && (step>0)) {
1054         unsigned int uhi = (unsigned int)hi;
1055         unsigned int ulo = (unsigned int)lo;
1056         unsigned int diff = uhi - ulo - 1;
1057         n = (int)(diff / (unsigned int)step + 1);
1058     }
1059     else {
1060         if ((lo > hi) && (step<0)) {
1061             unsigned int uhi = (unsigned int)lo;
1062             unsigned int ulo = (unsigned int)hi;
1063             unsigned int diff = uhi - ulo - 1;
1064             n = (int)(diff / (unsigned int)(-step) + 1);
1065         }
1066     }
1067     return n;
1068 }
1069
1070 list<int> *range(int a, int b, int s) {
1071     list<int> *r;
1072     int i, pos;
1073
1074     r = new list<int>();
1075     pos = 0;
1076     i = a;
1077
1078     if(s==0)
1079         throw new ValueError(new str("range() step argument must not be zero"));
1080
1081     if(s==1) {
1082         r->units.resize(b-a);
1083         for(; i<b;i++)
1084             r->units[pos++] = i;
1085
1086         return r;
1087     }
1088
1089     r->units.resize(range_len(a,b,s));
1090
1091     if(s>0) {
1092         while((i<b)) {
1093             r->units[pos++] = i;
1094             i += s;
1095         }
1096     }
1097     else {
1098         while((i>b)) {
1099             r->units[pos++] = i;
1100             i += s;
1101         }
1102     }
1103
1104     return r;
1105 }
1106
1107 list<int> *range(int n) {
1108     return range(0, n);
1109 }
1110
1111 class __rangeiter : public __iter<int> {
1112 public:
1113     int i, a, b, s;
1114
1115     __rangeiter(int a, int b, int s) {
1116         this->__class__ = cl_rangeiter;
1117
1118         this->a = a;
1119         this->b = b;
1120         this->s = s;
1121         i = a;
1122         if(s==0)
1123             throw new ValueError(new str("xrange() arg 3 must not be zero"));
1124     }
1125
1126     int next() {
1127         if(s>0) {
1128             if(i<b) {
1129                 i += s;
1130                 return i-s;
1131             }
1132         }
1133         else if(i>b) {
1134                 i += s;
1135                 return i-s;
1136         }
1137
1138         throw new StopIteration();
1139     }
1140
1141     int __len__() {
1142         return range_len(a,b,s);
1143     }
1144 };
1145
1146 __iter<int> *xrange(int a, int b, int s) { return new __rangeiter(a,b,s); }
1147 __iter<int> *xrange(int n) { return new __rangeiter(0, n, 1); }
1148
1149 __iter<int> *reversed(__rangeiter *x) {
1150    return new __rangeiter(x->a+(range_len(x->a,x->b,x->s)-1)*x->s, x->a-x->s, -x->s);
1151 }
1152
1153 int ord(str *s) {
1154     return (unsigned char)(s->unit[0]);
1155 }
1156
1157 str *chr(int i) {
1158     return __char_cache[i];
1159 }
1160
1161 /* copy, deepcopy */
1162
1163 template<> int __deepcopy(int i, dict<void *, pyobj *> *) { return i; }
1164 template<> double __deepcopy(double d, dict<void *, pyobj *> *) { return d; }
1165 template<> void *__deepcopy(void *d, dict<void *, pyobj *> *) { return d; }
1166
1167 template<> int __copy(int i) { return i; }
1168 template<> double __copy(double d) { return d; }
1169 template<> void *__copy(void *d) { return d; }
1170
1171 /* representation */
1172
1173 template<> str *repr(double d) { return __str(d); }
1174 template<> str *repr(int i) { return __str(i); }
1175 template<> str *repr(bool b) { return __str((int)b); }
1176 template<> str *repr(void *v) { return new str("void"); }
1177
1178 str *__str(void *v) { return new str("void"); }
1179
1180 /* equality, comparison, math operators */
1181
1182 template<> int __eq(int a, int b) { return a == b; }
1183 template<> int __eq(double a, double b) { return a == b; }
1184 template<> int __eq(void *a, void *b) { return a == b; }
1185 template<> int __ne(int a, int b) { return a != b; }
1186 template<> int __ne(double a, double b) { return a != b; }
1187 template<> int __ne(void *a, void *b) { return a != b; }
1188 template<> int __gt(int a, int b) { return a > b; }
1189 template<> int __gt(double a, double b) { return a > b; }
1190 template<> int __ge(int a, int b) { return a >= b; }
1191 template<> int __ge(double a, double b) { return a >= b; }
1192 template<> int __lt(int a, int b) { return a < b; }
1193 template<> int __lt(double a, double b) { return a < b; }
1194 template<> int __le(int a, int b) { return a <= b; }
1195 template<> int __le(double a, double b) { return a <= b; }
1196 template<> int __add(int a, int b) { return a + b; }
1197 template<> double __add(double a, double b) { return a + b; }
1198
1199 /* get class pointer */
1200
1201 template<> class_ *__type(int i) { return cl_int_; }
1202 template<> class_ *__type(double d) { return cl_float_; }
1203
1204 /* hashing */
1205
1206 template<> int hasher(int a) { return a; }
1207 template<> int hasher(double v) {
1208     int hipart, expo; /* modified from CPython */
1209     v = frexp(v, &expo);
1210     v *= 32768.0; /* 2**15 */
1211     hipart = (int)v;   /* take the top 16 bits */
1212     v = (v - (double)hipart) * 32768.0; /* get the next 16 bits */
1213     return hipart + (int)v + (expo << 15);
1214 }
1215 template<> int hasher(void *a) { return (intptr_t)a; }
1216
1217 /* pow */
1218
1219 template<> double __power(double a, double b) { return pow(a,b); }
1220 template<> double __power(int a, double b) { return pow(a,b); }
1221 template<> double __power(double a, int b) { return pow(a,b); }
1222
1223 template<> int __power(int a, int b) {
1224     int res, tmp;
1225
1226     res = 1;
1227     tmp = a;
1228
1229     while((b>0)) {
1230         if ((b%2)) {
1231             res = (res*tmp);
1232         }
1233         tmp = (tmp*tmp);
1234         b = (b/2);
1235     }
1236     return res;
1237 }
1238
1239 int __power(int a, int b, int c) {
1240     int res, tmp;
1241
1242     res = 1;
1243     tmp = a;
1244
1245     while((b>0)) {
1246         if ((b%2)) {
1247             res = ((res*tmp)%c);
1248         }
1249         tmp = ((tmp*tmp)%c);
1250         b = (b/2);
1251     }
1252     return res;
1253 }
1254
1255 int __power2(int a) { return a*a; }
1256 double __power2(double a) { return a*a; }
1257 int __power3(int a) { return a*a*a; }
1258 double __power3(double a) { return a*a*a; }
1259
1260 /* division */
1261
1262 template<> double __divs(double a, double b) { return a/b; }
1263 template<> double __divs(int a, double b) { return (double)a/b; }
1264 template<> double __divs(double a, int b) { return a/((double)b); }
1265 template<> int __divs(int a, int b) { return (int)floor(((double)a)/b); }
1266
1267 template<> double __floordiv(double a, double b) { return floor(a/b); }
1268 template<> double __floordiv(int a, double b) { return floor((double)a/b); }
1269 template<> double __floordiv(double a, int b) { return floor(a/((double)b)); }
1270 template<> int __floordiv(int a, int b) { return (int)floor((double)a/b); }
1271
1272 template<> tuple2<double, double> *divmod(double a, double b) {
1273     return new tuple2<double, double>(2, __floordiv(a,b), __mods(a,b));
1274 }
1275 template<> tuple2<double, double> *divmod(double a, int b) { return divmod(a, (double)b); } 
1276 template<> tuple2<double, double> *divmod(int a, double b) { return divmod((double)a, b); }
1277 template<> tuple2<int, int> *divmod(int a, int b) {
1278     return new tuple2<int, int>(2, __floordiv(a,b), __mods(a,b));
1279 }
1280
1281 /* slicing */
1282
1283 void slicenr(int x, int &l, int&u, int&s, int len) {
1284     if((x&4) && (s == 0))
1285         throw new ValueError(new str("slice step cannot be zero"));
1286
1287     if (!(x&4))
1288         s = 1;
1289
1290     if (l<0)
1291         l = len+l;
1292     if (u<0)
1293         u = len+u;
1294
1295     if (l<0)
1296         l = 0;
1297     if (u>=len)
1298         u = len;
1299
1300     if(s<0) {
1301         if (!(x&1))
1302             l = len-1;
1303         if (!(x&2))
1304             u = -1;
1305     }
1306     else {
1307         if (!(x&1))
1308             l = 0;
1309         if (!(x&2))
1310             u = len;
1311     }
1312 }
1313
1314 /* cmp */
1315
1316 template<> int __cmp(int a, int b) { 
1317     if(a < b) return -1;
1318     else if(a > b) return 1;
1319     return 0;
1320
1321
1322 template<> int __cmp(double a, double b) {
1323     if(a < b) return -1;
1324     else if(a > b) return 1;
1325     return 0;
1326 }
1327 template<> int __cmp(void *a, void *b) {
1328     if(a < b) return -1;
1329     else if(a > b) return 1;
1330     return 0;
1331 }
1332
1333 str *__str(int i, int base) {
1334     if(i<10 && i>=0 && base==10)
1335         return __char_cache['0'+i];
1336
1337     char asc[] = "0123456789abcdefghijklmnopqrstuvwxyz";
1338     char buf[12];
1339     char *psz = buf+11;
1340     if(i==INT_MIN)
1341         return new str("-2147483648");
1342     int neg = i<0;
1343     *psz = 0;
1344     if(neg) i = -i;
1345     do {
1346         unsigned lsd = i%base;
1347         i = i/base;
1348         *(--psz) = asc[lsd];
1349     }
1350     while(i != 0);
1351     if(neg) *(--psz) = '-';
1352     return new str(psz);
1353 }
1354
1355 str *__str(bool b) {
1356     return __str((int)b);
1357 }
1358
1359 template<> str *hex(int i) {
1360     return (new str("0x"))->__add__(__str(i, 16));
1361 }
1362 template<> str *hex(bool b) { return hex((int)b); }
1363
1364 template<> str *oct(int i) {
1365     if(i==0) return new str("0");
1366     return (new str("0"))->__add__(__str(i, 8));
1367 }
1368 template<> str *oct(bool b) { return oct((int)b); }
1369
1370 str *__str() { return new str(""); } /* XXX optimize */
1371
1372 template<> str *__str(double t) {
1373     std::stringstream ss;
1374     ss.precision(12);
1375     ss << std::showpoint << t;
1376     __GC_STRING s = ss.str().c_str();
1377     if( s.find('e') == -1)
1378     {
1379         int j = s.find_last_not_of("0");
1380         if( s[j] == '.') j++;
1381         s = s.substr(0, j+1);
1382     }
1383
1384     return new str(s);
1385 }
1386
1387 double ___round(double a) {
1388     return __portableround(a);
1389 }
1390 double ___round(double a, int n) {
1391     return __portableround(pow(10,n)*a)/pow(10,n);
1392 }
1393
1394 /* bool */
1395
1396 int __bool() { return 0; }
1397
1398 template<> int __bool(int x) {
1399     return x;
1400 }
1401 template<> int __bool(bool x) {
1402     return (int)x;
1403 }
1404 template<> int __bool(double x) {
1405     return x!=0;
1406 }
1407
1408 /* sum */
1409
1410 int __sum(pyseq<int> *l, int b) { return accumulate(l->units.begin(), l->units.end(), b); }
1411 double __sum(pyseq<double> *l, double b) { return accumulate(l->units.begin(), l->units.end(), b); }
1412
1413 /* min, max */
1414
1415 int __min(pyseq<int> *l) { return __minimum(l); }
1416 double __min(pyseq<double> *l) { return __minimum(l); }
1417 int __max(pyseq<int> *l) { return __maximum(l); }
1418 double __max(pyseq<double> *l) { return __maximum(l); }
1419
1420 #define __ss_max(a,b) ((a) > (b) ? (a) : (b))
1421 #define __ss_max3(a,b,c) (__ss_max((a), __ss_max((b), (c))))
1422
1423 template<> int __max(int a, int b) { return __ss_max(a,b); }
1424 template<> int __max(int a, int b, int c) { return __ss_max3(a,b,c); }
1425 template<> double __max(double a, double b) { return __ss_max(a,b); }
1426 template<> double __max(double a, double b, double c) { return __ss_max3(a,b,c); }
1427
1428 #define __ss_min(a,b) ((a) < (b) ? (a) : (b))
1429 #define __ss_min3(a,b,c) (__ss_min((a), __ss_min((b), (c))))
1430
1431 template<> int __min(int a, int b) { return __ss_min(a,b); }
1432 template<> int __min(int a, int b, int c) { return __ss_min3(a,b,c); }
1433 template<> double __min(double a, double b) { return __ss_min(a,b); }
1434 template<> double __min(double a, double b, double c) { return __ss_min3(a,b,c); }
1435
1436 /* abs */
1437
1438 template<> int __abs(int a) { return a<0?-a:a; }
1439 template<> double __abs(double a) { return a<0?-a:a; }
1440 int __abs(bool b) { return __abs((int)b); }
1441
1442 /* list */
1443
1444 list<str *> *__list(str *s) {
1445     list<str *> *r = new list<str *>();
1446     r->units.resize(len(s));
1447     int sz = s->unit.size();
1448     for(int i=0; i<sz; i++) 
1449         r->units[i] = __char_cache[s->unit[i]];
1450     return r;
1451 }
1452
1453 /* sorted */
1454
1455 list<str *> *sorted(str *t, int (*cmp)(str *, str *), int key, int reverse) {
1456     list<str *> *l = __list(t);
1457     l->sort(cmp, key, reverse);
1458     return l;
1459 }
1460 list<str *> *sorted(str *t, int cmp, int key, int reverse) {
1461     return sorted(t, (int (*)(str *, str *))0, key, reverse);
1462 }
1463
1464 /* mod helpers */
1465
1466 #if defined(WIN32) || defined(__sun)
1467 int vasprintf(char **ret, const char *format, va_list ap)
1468 {
1469     va_list ap2;
1470     int len= 100;        /* First guess at the size */
1471     if ((*ret= (char *)malloc(len)) == NULL) return -1;
1472     while (1)
1473     {
1474         int nchar;
1475         va_copy(ap2, ap);
1476         nchar= vsnprintf(*ret, len, format, ap2);
1477         if (nchar > -1 && nchar < len) return nchar;
1478         if (nchar > len)
1479             len= nchar+1;
1480         else
1481             len*= 2;
1482         if ((*ret= (char *)realloc(*ret, len)) == NULL)
1483         {
1484             free(*ret);
1485             return -1;
1486         }
1487     }
1488 }
1489
1490 int asprintf(char **ret, const char *format, ...)
1491 {
1492     va_list ap;
1493     int nc;
1494     va_start (ap, format);
1495     nc= vasprintf(ret, format, ap);
1496     va_end(ap);
1497     return nc;
1498 }
1499 #endif
1500
1501 int __fmtpos(str *fmt) {
1502     int i = fmt->unit.find('%');
1503     if(i == -1)
1504         return -1;
1505     return fmt->unit.find_first_of(__fmtchars, i+1);
1506 }
1507
1508 void __fmtcheck(str *fmt, int l) {
1509     int i = 0, j = 0;
1510     while((j = fmt->unit.find('%', j)) != -1) {
1511         char c = fmt->unit[j+1];
1512         if(c != '%')
1513             i++;    
1514         j += 2;
1515     }
1516
1517     if(i < l)
1518         throw new TypeError(new str("not all arguments converted during string formatting"));
1519     if(i > l)
1520         throw new TypeError(new str("not enough arguments for format string"));
1521
1522 }
1523
1524 str *__mod2(str *fmt, va_list args) {
1525     int j;
1526     str *r = new str();
1527
1528     while((j = __fmtpos(fmt)) != -1) {
1529         char c = fmt->unit[j];
1530
1531         if(c == 'c')
1532             __modfill(&fmt, va_arg(args, str *), &r);
1533         else if(c == 's' || c == 'r')
1534             __modfill(&fmt, va_arg(args, pyobj *), &r);
1535         else if(c == '%')
1536             __modfill(&fmt, 0, &r);
1537         else if(__GC_STRING("diouxX").find(c) != -1)
1538             __modfill(&fmt, va_arg(args, int), &r);
1539         else if(__GC_STRING("eEfFgGh").find(c) != -1)
1540             __modfill(&fmt, va_arg(args, double), &r);
1541         else
1542             break;
1543
1544     }
1545
1546     r->unit += fmt->unit;
1547     return r;
1548 }
1549
1550 /* mod */
1551
1552 str *mod_to_c(str *s) { return s; } 
1553 str *mod_to_c(int i) { return chr(i); }
1554 str *mod_to_c(double d) { return chr(__int(d)); }
1555
1556 str *__mod(str *fmt, ...) {
1557      va_list args;
1558      va_start(args, fmt);
1559      str *s = __mod2(new str(fmt->unit), args);
1560      va_end(args);
1561      return s;
1562 }
1563
1564 /* print .., */
1565
1566 char print_lastchar = '\n';
1567 int print_space = 0;
1568
1569 void __exit() {
1570     if(print_lastchar != '\n')
1571         std::cout << '\n';
1572 }
1573
1574 void print(const char *fmt, ...) { // XXX merge four functions (put std::cout in a file instance)
1575      va_list args;
1576      va_start(args, fmt);
1577      str *s = __mod2(new str(fmt), args);
1578
1579      if(print_space && print_lastchar != '\n' && !(len(s) && s->unit[0] == '\n'))
1580          std::cout << " ";
1581
1582      std::cout << s->unit;
1583      va_end(args);
1584
1585      print_lastchar = s->unit[len(s)-1];
1586      print_space = 0;
1587 }
1588
1589 void print(file *f, const char *fmt, ...) {
1590      va_list args;
1591      va_start(args, fmt);
1592      str *s = __mod2(new str(fmt), args);
1593
1594      if(f->print_space && f->print_lastchar != '\n' && !(len(s) && s->unit[0] == '\n'))
1595          f->putchar(' ');
1596
1597      f->write(s);
1598      va_end(args);
1599
1600      f->print_lastchar = s->unit[len(s)-1];
1601      f->print_space = 0;
1602 }
1603
1604 void printc(const char *fmt, ...) {
1605      va_list args;
1606      va_start(args, fmt);
1607      str *s = __mod2(new str(fmt), args);
1608
1609      if(print_space && print_lastchar != '\n' && !(len(s) && s->unit[0] == '\n'))
1610          std::cout << " ";
1611
1612      std::cout << s->unit;
1613      va_end(args);
1614
1615      if(len(s)) print_lastchar = s->unit[len(s)-1];
1616      else print_lastchar = ' ';
1617      print_space = 1;
1618 }
1619
1620 void printc(file *f, const char *fmt, ...) {
1621      va_list args;
1622      va_start(args, fmt);
1623      str *s = __mod2(new str(fmt), args);
1624
1625      if(f->print_space && f->print_lastchar != '\n' && !(len(s) && s->unit[0] == '\n'))
1626          f->putchar(' ');
1627
1628      f->write(s);
1629      va_end(args);
1630
1631      if(len(s)) f->print_lastchar = s->unit[len(s)-1];
1632      else f->print_lastchar = ' ';
1633      f->print_space = 1;
1634 }
1635
1636 /* str, file iteration */
1637
1638 __seqiter<str *> *str::__iter__() {
1639     return new __striter(this);
1640 }
1641
1642 __striter::__striter(str *p) {
1643     this->p = p;
1644     counter = 0;
1645 }
1646
1647 str *__striter::next() {
1648    if(counter == p->unit.size())
1649        throw new StopIteration();
1650    return p->__getitem__(counter++); 
1651 }
1652
1653 __iter<str *> *file::__iter__() {
1654     return new __fileiter(this);
1655 }
1656
1657 __fileiter::__fileiter(file *p) {
1658     this->p = p;
1659 }
1660
1661 str *__fileiter::next() {
1662     if(p->endoffile)
1663         throw new StopIteration();
1664     str *line = p->readline();
1665     if(p->endoffile && !len(line))
1666         throw new StopIteration();
1667     return line;
1668 }
1669
1670 /* mod */
1671
1672 template<> double __mods(double a, double b) {
1673     double f = fmod(a,b);
1674     if((f<0 && b>0)||(f>0 && b<0)) f+=b;
1675     return f;
1676 }
1677 template<> double __mods(int a, double b) { return __mods((double)a, b); }
1678 template<> double __mods(double a, int b) { return __mods(a, (double)b); }
1679
1680 template<> int __mods(int a, int b) {
1681     int m = a%b;
1682     if((m<0 && b>0)||(m>0 && b<0)) m+=b;
1683     return m;
1684 }
1685
1686 /* binding */
1687
1688 #ifdef __SS_BIND
1689 PyObject *__import(char *mod, char *method) {
1690     PyObject *m = PyImport_ImportModule(mod);
1691     PyObject *d = PyObject_GetAttrString(m, (char *)"__dict__");
1692     return PyDict_GetItemString(d, method);
1693 }
1694
1695 PyObject *__call(PyObject *obj, PyObject *args) {
1696     return PyObject_CallObject(obj, args);
1697 }
1698
1699 PyObject *__call(PyObject *obj, char *name, PyObject *args) {
1700     PyObject *method = PyObject_GetAttrString(obj, name);
1701     PyObject *x = PyObject_CallObject(method, args);
1702     return x;
1703 }
1704
1705 PyObject *__args(int n, ...) {
1706     va_list ap;
1707     va_start(ap, n);
1708
1709     PyObject *p = PyTuple_New(n);
1710
1711     for(int i=0; i<n; i++) {
1712         PyObject *t = va_arg(ap, PyObject *);
1713         PyTuple_SetItem(p, i, t);
1714     }
1715     va_end(ap);
1716     return p;
1717 }
1718
1719 template<> PyObject *__to_py(int i) { return PyInt_FromLong(i); }   
1720 template<> PyObject *__to_py(double d) { return PyFloat_FromDouble(d); }
1721
1722 template<> int __to_ss(PyObject *p) { 
1723     if(p==Py_None) return 0;
1724     if(!PyInt_Check(p)) 
1725         throw new TypeError(new str("error in conversion to Shed Skin (integer expected)"));
1726     return PyInt_AsLong(p);
1727 }
1728
1729 template<> double __to_ss(PyObject *p) { 
1730     if(p==Py_None) return 0.0;
1731     if(!PyInt_Check(p) and !PyFloat_Check(p)) 
1732         throw new TypeError(new str("error in conversion to Shed Skin (float or int expected)"));
1733     return PyFloat_AsDouble(p); 
1734 }
1735
1736 #endif
1737
1738 // Exceptions
1739 OSError::OSError(str *filename) {
1740     this->filename = filename;
1741     __ss_errno = errno;
1742     message = new str("");
1743     strerror = new str(::strerror(__ss_errno));
1744 }
1745 str *OSError::__str__() {
1746     return __add_strs(7, new str("[Errno "), __str(__ss_errno), new str("] "), strerror, new str(": '"), filename, new str("'"));
1747 }
1748 str *OSError::__repr__() {
1749     return __add_strs(5, new str("OSError("), __str(__ss_errno), new str(", '"), strerror, new str("')")); 
1750 }
1751
1752 } // namespace __shedskin__
1753