complex complex::parsevalue(str *s) {
complex mult;
if ((!___bool(s))) {
return mcomplex(0.0, 0.0);
}
mult = mcomplex(1.0, 0.0);
if (__eq(s->__getitem__((-1)), new str("j"))) {
s = s->__slice__(2, 0, (-1), 0);
mult = mcomplex(0.0, 1.0);
}
if (((new list<str *>(2, new str("+"), new str("-"))))->__contains__(s)) {
s = s->__iadd__(new str("1"));
}
return mult * __float(s);
}
template <class B> str *filter(B (*func)(str *), str *a) {
str *result = new str();
int size = len(a);
char e;
str *c;
for(int i=0; i<size; i++) {
e = a->unit[i];
if(func) {
c = __char_cache[((unsigned char)e)];
if(___bool((*func)(c)))
result->unit.push_back(e);
} else
result->unit.push_back(e);
}
return result;
}
tuple2<str *, str *> *split(str *p) {
/**
Split a pathname. Returns tuple "(head, tail)" where "tail" is
everything after the final slash. Either part may be empty.
*/
str *__7, *__8, *head, *tail;
__ss_int i;
i = (p->rfind(const_4)+1);
__7 = p->__slice__(2, 0, i, 0);
__8 = p->__slice__(1, i, 0, 0);
head = __7;
tail = __8;
if ((___bool(head) && __ne(head, (const_4)->__mul__(len(head))))) {
head = head->rstrip(const_4);
}
return (new tuple2<str *, str *>(2, head, tail));
}
__ss_bool DynamInt::__eq__(DynamInt *num) {
/**
Overloaded == function
Checks if this DynamInt is equal to this one
@param num reference to an existing DynamInt
@return added DynamInt
*/
str *lhs, *rhs;
__ss_bool compare;
int i, j;
if ((this->size>num->size)) {
return False;
}
else if ((this->size<num->size)) {
return False;
}
j = (this->size-1);
i = (num->size-1);
lhs = this->data;
rhs = num->data;
while ((i>=0)) {
/**
Have we run out of bottom digits ?
*/
if ((j>=0)) {
compare = ___bool(__ne(lhs->__getitem__(i), rhs->__getitem__(i)));
if (compare) {
return False;
}
j = (j-1);
}
else {
/**
No more bottom digits, add any leftover carryover
*/
return False;
}
i = (i-1);
}
return True;
}
str *commonprefix(list<str *> *m) {
/**
Given a list of pathnames, returns the longest common leading component
*/
str *s1, *s2;
__ss_int __11, __12, i, n;
if ((!___bool(m))) {
return const_0;
}
s1 = ___min(1, 0, m);
s2 = ___max(1, 0, m);
n = ___min(2, 0, len(s1), len(s2));
FAST_FOR(i,0,n,1,11,12)
if (__ne(s1->__getitem__(i), s2->__getitem__(i))) {
return s1->__slice__(2, 0, i, 0);
}
END_FOR
return s1->__slice__(2, 0, n, 0);
}
tuple2<list<tuple2<str *, str *> *> *, list<str *> *> *gnu_getopt(list<str *> *args, str *shortopts, pyiter<str *> *longopts) {
/**
getopt(args, options[, long_options]) -> opts, args
This function works like getopt(), except that GNU style scanning
mode is used by default. This means that option and non-option
arguments may be intermixed. The getopt() function stops
processing options as soon as a non-option argument is
encountered.
If the first character of the option string is `+', or if the
environment variable POSIXLY_CORRECT is set, then option
processing stops as soon as a non-option argument is encountered.
*/
list<str *> *prog_args;
list<tuple2<str *, str *> *> *opts;
__ss_int all_options_first;
tuple2<list<tuple2<str *, str *> *> *, list<str *> *> *__5, *__6;
opts = (new list<tuple2<str *, str *> *>());
prog_args = (new list<str *>());
longopts = new list<str *>(longopts);
if (shortopts->startswith(const_3)) {
shortopts = shortopts->__slice__(1, 1, 0, 0);
all_options_first = 1;
}
else if (___bool((__os__::__ss_environ)->get(const_4))) {
all_options_first = 1;
}
else {
all_options_first = 0;
}
while(___bool(args)) {
if (__eq(args->__getfast__(0), const_2)) {
prog_args = prog_args->__iadd__(args->__slice__(1, 1, 0, 0));
break;
}
if (__eq((args->__getfast__(0))->__slice__(2, 0, 2, 0), const_2)) {
__5 = do_longs(opts, (args->__getfast__(0))->__slice__(1, 2, 0, 0), longopts, args->__slice__(1, 1, 0, 0));
opts = __5->__getfirst__();
args = __5->__getsecond__();
}
else if (__eq((args->__getfast__(0))->__slice__(2, 0, 1, 0), const_1)) {
__6 = do_shorts(opts, (args->__getfast__(0))->__slice__(1, 1, 0, 0), shortopts, args->__slice__(1, 1, 0, 0));
opts = __6->__getfirst__();
args = __6->__getsecond__();
}
else {
if (all_options_first) {
prog_args = prog_args->__iadd__(args);
break;
}
else {
prog_args->append(args->__getfast__(0));
args = args->__slice__(1, 1, 0, 0);
}
}
}
return (new tuple2<list<tuple2<str *, str *> *> *, list<str *> *>(2, opts, prog_args));
}
__ss_int writer::join_append_data(str *field, __ss_int quote_empty, __ss_int quoted) {
str *lineterm;
Excel *dialect;
__ss_int __17, __18, __19, __20, __21, __22, __23, want_escape;
dialect = this->dialect;
lineterm = dialect->lineterminator;
if ((this->num_fields>0)) {
(this->rec)->append(dialect->delimiter);
}
if (quoted) {
(this->rec)->append(dialect->quotechar);
}
str *c;
str::for_in_loop __3;
int __2;
str *__1;
FOR_IN_NEW(c,field,1,2,3)
want_escape = 0;
if (__eq(c, const_7)) {
break;
}
if (__OR(__eq(c, dialect->delimiter), __OR(__eq(c, dialect->escapechar), __OR(__eq(c, dialect->quotechar), lineterm->__contains__(c), 20), 19), 18)) {
if ((dialect->quoting==QUOTE_NONE)) {
want_escape = 1;
}
else {
if (__eq(c, dialect->quotechar)) {
if (dialect->doublequote) {
(this->rec)->append(dialect->quotechar);
}
else {
want_escape = 1;
}
}
if ((!want_escape)) {
quoted = 1;
}
}
if (want_escape) {
if ((!___bool(dialect->escapechar))) {
throw ((new Error(const_18)));
}
(this->rec)->append(dialect->escapechar);
}
}
(this->rec)->append(c);
END_FOR
if (__AND((!___bool(field)), quote_empty, 22)) {
if ((dialect->quoting==QUOTE_NONE)) {
throw ((new Error(const_19)));
}
else {
quoted = 1;
}
}
if (quoted) {
(this->rec)->append(dialect->quotechar);
}
return quoted;
}
__ss_bool DynamInt::__gt__(DynamInt *num) {
/**
Overloaded > function
Checks if this DynamInt is greater than existing DynamInt
@param num reference to an existing DynamInt
@return added DynamInt
*/
str *lhs, *rhs;
__ss_bool greater;
int i, j;
/**
Performs greater than function by applying > function on each pair of integers
i.e
to find which is 12345 is greater than 1234, the code makes a configuration similar to
1 0 3 4 5
> 1 2 3 4
-------------
T F T T T
-------------
Where T refers to True, F to False
It uses the last compare value, in this case, T which means 10345 is greater than 1234
Another example,
1 0 3 4 5
> 9 2 3 4 0
-------------
F F T T T
-------------
In this case it uses False, since 10345 is less than 92340
*/
if (__eq(this, num)) {
return False;
}
if ((this->size>num->size)) {
return True;
}
else if ((this->size<num->size)) {
return False;
}
/**
Temporary Variables used in addition process
*/
greater = False;
j = (this->size-1);
i = (num->size-1);
lhs = this->data;
rhs = num->data;
while ((i>=0)) {
/**
Have we run out of bottom digits ?
*/
if ((j>=0)) {
greater = ___bool(__gt(lhs->__getitem__(i), rhs->__getitem__(i)));
j = (j-1);
}
else {
/**
No more bottom digits, add any leftover carryover
*/
greater = True;
}
i = (i-1);
}
return greater;
}
