str *commonprefix(list<str *> *m) {
/**
Given a list of pathnames, returns the longest common leading component
*/
list<str *> *__24;
list<str *>::for_in_loop __123;
__ss_int __26, __27, __28, i;
str *item, *prefix;
if ((!___bool(m))) {
return const_1;
}
prefix = m->__getfast__(0);
FOR_IN(item,m,24,26,123)
FAST_FOR(i,0,len(prefix),1,27,28)
if (__ne(prefix->__slice__(2, 0, (i+1), 0), item->__slice__(2, 0, (i+1), 0))) {
prefix = prefix->__slice__(2, 0, i, 0);
if ((i==0)) {
return const_1;
}
break;
}
END_FOR
END_FOR
return prefix;
}
str *joinl(list<str *> *l) {
/**
Join two or more pathname components, inserting "\" as needed
*/
list<str *> *__3, *__4, *p;
list<str *>::for_in_loop __123;
__iter<str *> *__5;
str *__2, *b, *path;
__ss_int __10, __11, __12, __13, __14, __6, __7, __8, __9, b_wins;
__2 = l->__getfast__(0);
__3 = l->__slice__(1, 1, 0, 0);
path = __2;
p = __3;
FOR_IN(b,p,4,6,123)
b_wins = 0;
if (__eq(path, const_1)) {
b_wins = 1;
}
else if (isabs(b)) {
if (__OR(__ne(path->__slice__(3, 1, 2, 0), const_19), __eq(b->__slice__(3, 1, 2, 0), const_19), 7)) {
b_wins = 1;
}
else if (__OR((len(path)>3), __AND((len(path)==3), (!(const_18)->__contains__(path->__getitem__(-1))), 10), 9)) {
b_wins = 1;
}
}
if (b_wins) {
path = b;
}
else {
ASSERT((len(path)>0), 0);
if ((const_18)->__contains__(path->__getitem__(-1))) {
if ((___bool(b) && (const_18)->__contains__(b->__getitem__(0)))) {
path = path->__iadd__(b->__slice__(1, 1, 0, 0));
}
else {
path = path->__iadd__(b);
}
}
else if (__eq(path->__getitem__(-1), const_19)) {
path = path->__iadd__(b);
}
else if (___bool(b)) {
if ((const_18)->__contains__(b->__getitem__(0))) {
path = path->__iadd__(b);
}
else {
path = __add_strs(3, path, const_4, b);
}
}
else {
path = path->__iadd__(const_4);
}
}
END_FOR
return path;
}
template<class T> template<class U> tuple2<T, T>::tuple2(U *iter) {
this->__class__ = cl_tuple;
typename U::for_in_unit e;
typename U::for_in_loop __3;
int __2;
U *__1;
FOR_IN(e,iter,1,2,3)
this->units.push_back(e);
END_FOR
}
template<class U> void *file::writelines(U *iter) {
__check_closed();
typename U::for_in_unit e;
typename U::for_in_loop __3;
int __2;
U *__1;
FOR_IN(e,iter,1,2,3)
write(e);
END_FOR
return NULL;
}
template <class A> list<tuple2<typename A::for_in_unit, typename A::for_in_unit> *> *__zip(int nn, A *iter) {
list<tuple2<typename A::for_in_unit, typename A::for_in_unit> *> *result = (new list<tuple2<typename A::for_in_unit, typename A::for_in_unit> *>());
typename A::for_in_unit e;
typename A::for_in_loop __3;
int __2;
A *__1;
FOR_IN(e,iter,1,2,3)
result->append((new tuple2<typename A::for_in_unit, typename A::for_in_unit>(1, e)));
END_FOR
return result;
}
template <class U, class V, class W> list<typename U::for_in_unit> *sorted(U *iter, V cmp, W key, __ss_int reverse) {
typename U::for_in_unit e;
typename U::for_in_loop __3;
int __2;
U *__1;
list<typename U::for_in_unit> *l = new list<typename U::for_in_unit>();
FOR_IN(e,iter,1,2,3)
l->units.push_back(e);
END_FOR
l->sort(cmp, key, reverse);
return l;
}
str * next() {
switch(__last_yield) {
case 0: goto __after_yield_0;
case 1: goto __after_yield_1;
case 2: goto __after_yield_2;
case 3: goto __after_yield_3;
default: break;
}
if ((!has_magic(pathname))) {
if (__os__::__path__::lexists(pathname)) {
__last_yield = 0;
return pathname;
__after_yield_0:;
}
throw new StopIteration();
}
__0 = __os__::__path__::split(pathname);
dirname = __0->__getfirst__();
basename = __0->__getsecond__();
if ((!___bool(dirname))) {
FOR_IN_SEQ(name,glob1(__os__::curdir, basename),1,3)
__last_yield = 1;
return name;
__after_yield_1:;
END_FOR
throw new StopIteration();
}
if (has_magic(dirname)) {
dirs = iglob(dirname);
}
else {
dirs = (new list<str *>(1, dirname));
}
if (has_magic(basename)) {
FOR_IN(dirname,dirs,5)
FOR_IN_SEQ(name,glob1(dirname, basename),7,9)
__last_yield = 2;
return __os__::__path__::join(2, dirname, name);
__after_yield_2:;
END_FOR
END_FOR
}
else {
template <class U> str *str::join(U *iter) {
int sz, total, __2;
bool only_ones = true;
typename U::for_in_unit e;
typename U::for_in_loop __3;
U *__1;
__join_cache->units.resize(0);
total = 0;
FOR_IN(e,iter,1,2,3)
__join_cache->units.push_back(e);
sz = e->unit.size();
if(sz != 1)
only_ones = false;
total += sz;
END_FOR
int unitsize = unit.size();
int elems = len(__join_cache);
if(elems==1)
return __join_cache->units[0];
str *s = new str();
if(unitsize == 0 and only_ones) {
s->unit.resize(total);
for(int j=0; j<elems; j++)
s->unit[j] = __join_cache->units[j]->unit[0];
}
else if(elems) {
total += (elems-1)*unitsize;
s->unit.resize(total);
int tsz;
int k = 0;
for(int m = 0; m<elems; m++) {
str *t = __join_cache->units[m];
tsz = t->unit.size();
if (tsz == 1)
s->unit[k] = t->unit[0];
else
memcpy((void *)(s->unit.data()+k), t->unit.data(), tsz);
k += tsz;
if (unitsize && m < elems-1) {
if (unitsize==1)
s->unit[k] = unit[0];
else
memcpy((void *)(s->unit.data()+k), unit.data(), unit.size());
k += unitsize;
}
}
}
return s;
}
str *capwords(str *s, str *sep) {
list<str *> *__3 = s->split(sep);
list<str *> *result = new list<str *>();
result->resize(len(__3));
str *e;
list<str *>::for_in_loop __4;
int __2;
list<str *> *__1;
FOR_IN(e,__3,1,2,4)
result->units[__2] = e->capitalize();
END_FOR
if(!sep) sep = const_0;
return sep->join(result);
}
