ref: 44ce0097b612a1fefd754065bdf8d9d2e5ef60c8
dir: /appl/cmd/calc.b/
implement Calc;
include "sys.m";
sys: Sys;
include "draw.m";
include "arg.m";
arg: Arg;
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "math.m";
maths: Math;
include "rand.m";
rand: Rand;
include "daytime.m";
daytime: Daytime;
Calc: module
{
init: fn(nil: ref Draw->Context, argv: list of string);
};
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
arg = load Arg Arg->PATH;
bufio = load Bufio Bufio->PATH;
maths = load Math Math->PATH;
rand = load Rand Rand->PATH;
daytime = load Daytime Daytime->PATH;
maths->FPcontrol(0, Math->INVAL|Math->ZDIV|Math->OVFL|Math->UNFL|Math->INEX);
rand->init(daytime->now());
rand->init(rand->rand(Big)^rand->rand(Big));
daytime = nil;
arg->init(args);
while((c := arg->opt()) != 0){
case(c){
'b' =>
bits = 1;
'd' =>
debug = 1;
's' =>
strict = 1;
}
}
gargs = args = arg->argv();
if(args == nil){
stdin = 1;
bin = bufio->fopen(sys->fildes(0), Sys->OREAD);
}
else if(tl args == nil)
bin = bufio->open(hd args, Sys->OREAD);
syms = array[Hash] of ref Sym;
pushscope();
for(i := 0; keyw[i].t0 != nil; i++)
enter(keyw[i].t0, keyw[i].t1);
for(i = 0; conw[i].t0 != nil; i++)
adddec(conw[i].t0, Ocon, conw[i].t1, 0);
for(i = 0; varw[i].t0 != nil; i++)
adddec(varw[i].t0, Ovar, varw[i].t1, 0);
for(i = 0; funw[i].t0 != nil; i++)
adddec(funw[i].t0, Olfun, real funw[i].t1, funw[i].t2);
deg = lookup(Deg).dec;
pbase = lookup(Base).dec;
errdec = ref Dec;
pushscope();
for(;;){
e: ref Node;
{
t := lex();
if(t == Oeof)
break;
unlex(t);
ls := lexes;
e = stat(1);
ckstat(e, Onothing, 0);
if(ls == lexes){
t = lex();
error(nil, sys->sprint("syntax error near %s", opstring(t)));
unlex(t);
}
consume(Onl);
}
exception ex{
Eeof =>
e = nil;
err("premature eof");
skip();
"*" =>
e = nil;
err(ex);
skip();
}
if(0 && debug)
prtree(e, 0);
if(e != nil && e.op != Ofn){
(k, v) := (Onothing, 0.0);
{
(k, v) = estat(e);
}
exception ex{
"*" =>
e = nil;
err(ex);
}
if(pexp(e))
printnum(v, "\n");
if(k == Oexit)
exit;
}
}
popscope();
popscope();
}
bits: int;
debug: int;
strict: int;
None: con -2;
Eof: con -1;
Eeof: con "eof";
Hash: con 16;
Big: con 1<<30;
Maxint: con 16r7FFFFFFF;
Nan: con Math->NaN;
Infinity: con Math->Infinity;
Pi: con Math->Pi;
Eps: con 1E-10;
Bigeps: con 1E-2;
Ln2: con 0.6931471805599453;
Ln10: con 2.302585092994046;
Euler: con 2.71828182845904523536;
Gamma: con 0.57721566490153286060;
Phi: con 1.61803398874989484820;
Oeof,
Ostring, Onum, Oident, Ocon, Ovar, Ofun, Olfun,
Oadd, Osub, Omul, Odiv, Omod, Oidiv, Oexp, Oand, Oor, Oxor, Olsh, Orsh,
Oadde, Osube, Omule, Odive, Omode, Oidive, Oexpe, Oande, Oore, Oxore, Olshe, Orshe,
Oeq, One, Ogt, Olt, Oge, Ole,
Oinc, Opreinc, Opostinc, Odec, Opredec, Opostdec,
Oandand, Ooror,
Oexc, Onot, Ofact, Ocom,
Oas, Odas,
Oplus, Ominus, Oinv,
Ocomma, Oscomma, Oquest, Ocolon,
Onand, Onor, Oimp, Oimpby, Oiff,
Olbr, Orbr, Olcbr, Orcbr, Oscolon, Onl,
Onothing,
Oprint, Oread,
Oif, Oelse, Ofor, Owhile, Odo, Obreak, Ocont, Oexit, Oret, Ofn, Oinclude,
Osigma, Opi, Ocfrac, Oderiv, Ointeg, Osolve,
Olog, Olog10, Olog2, Ologb, Oexpf, Opow, Osqrt, Ocbrt, Ofloor, Oceil, Omin, Omax, Oabs, Ogamma, Osign, Oint, Ofrac, Oround, Oerf, Oatan2, Osin, Ocos, Otan, Oasin, Oacos, Oatan, Osinh, Ocosh, Otanh, Oasinh, Oacosh, Oatanh, Orand,
Olast: con iota;
Binary: con (1<<8);
Preunary: con (1<<9);
Postunary: con (1<<10);
Assoc: con (1<<11);
Rassoc: con (1<<12);
Prec: con Binary-1;
opss := array[Olast] of
{
"eof",
"string",
"number",
"identifier",
"constant",
"variable",
"function",
"library function",
"+",
"-",
"*",
"/",
"%",
"//",
"&",
"|",
"^",
"<<",
">>",
"+=",
"-=",
"*=",
"/=",
"%=",
"//=",
"&=",
"|=",
"^=",
"<<=",
">>=",
"==",
"!=",
">",
"<",
">=",
"<=",
"++",
"++",
"++",
"--",
"--",
"--",
"**",
"&&",
"||",
"!",
"!",
"!",
"~",
"=",
":=",
"+",
"-",
"1/",
",",
",",
"?",
":",
"↑",
"↓",
"->",
"<-",
"<->",
"(",
")",
"{",
"}",
";",
"\n",
"",
};
ops := array[Olast] of
{
Oeof => 0,
Ostring => 17,
Onum => 17,
Oident => 17,
Ocon => 17,
Ovar => 17,
Ofun => 17,
Olfun => 17,
Oadd => 12|Binary|Assoc|Preunary,
Osub => 12|Binary|Preunary,
Omul => 13|Binary|Assoc,
Odiv => 13|Binary,
Omod => 13|Binary,
Oidiv => 13|Binary,
Oexp => 14|Binary|Rassoc,
Oand => 8|Binary|Assoc,
Oor => 6|Binary|Assoc,
Oxor => 7|Binary|Assoc,
Olsh => 11|Binary,
Orsh => 11|Binary,
Oadde => 2|Binary|Rassoc,
Osube => 2|Binary|Rassoc,
Omule => 2|Binary|Rassoc,
Odive => 2|Binary|Rassoc,
Omode => 2|Binary|Rassoc,
Oidive => 2|Binary|Rassoc,
Oexpe => 2|Binary|Rassoc,
Oande => 2|Binary|Rassoc,
Oore => 2|Binary|Rassoc,
Oxore => 2|Binary|Rassoc,
Olshe => 2|Binary|Rassoc,
Orshe => 2|Binary|Rassoc,
Oeq => 9|Binary,
One => 9|Binary,
Ogt => 10|Binary,
Olt => 10|Binary,
Oge => 10|Binary,
Ole => 10|Binary,
Oinc => 15|Rassoc|Preunary|Postunary,
Opreinc => 15|Rassoc|Preunary,
Opostinc => 15|Rassoc|Postunary,
Odec => 15|Rassoc|Preunary|Postunary,
Opredec => 15|Rassoc|Preunary,
Opostdec => 15|Rassoc|Postunary,
Oandand => 5|Binary|Assoc,
Ooror => 4|Binary|Assoc,
Oexc => 15|Rassoc|Preunary|Postunary,
Onot => 15|Rassoc|Preunary,
Ofact => 15|Rassoc|Postunary,
Ocom => 15|Rassoc|Preunary,
Oas => 2|Binary|Rassoc,
Odas => 2|Binary|Rassoc,
Oplus => 15|Rassoc|Preunary,
Ominus => 15|Rassoc|Preunary,
Oinv => 15|Rassoc|Postunary,
Ocomma => 1|Binary|Assoc,
Oscomma => 1|Binary|Assoc,
Oquest => 3|Binary|Rassoc,
Ocolon => 3|Binary|Rassoc,
Onand => 8|Binary,
Onor => 6|Binary,
Oimp => 9|Binary,
Oimpby => 9|Binary,
Oiff => 10|Binary|Assoc,
Olbr => 16,
Orbr => 16,
Onothing => 0,
};
Deg: con "degrees";
Base: con "printbase";
Limit: con "solvelimit";
Step: con "solvestep";
keyw := array[] of
{
("include", Oinclude),
("if", Oif),
("else", Oelse),
("for", Ofor),
("while", Owhile),
("do", Odo),
("break", Obreak),
("continue", Ocont),
("exit", Oexit),
("return", Oret),
("print", Oprint),
("read", Oread),
("fn", Ofn),
("", 0),
};
conw := array[] of
{
("π", Pi),
("Pi", Pi),
("e", Euler),
("γ", Gamma),
("Gamma", Gamma),
("φ", Phi),
("Phi", Phi),
("∞", Infinity),
("Infinity", Infinity),
("NaN", Nan),
("Nan", Nan),
("nan", Nan),
("", 0.0),
};
varw := array[] of
{
(Deg, 0.0),
(Base, 10.0),
(Limit, 100.0),
(Step, 1.0),
("", 0.0),
};
funw := array[] of
{
("log", Olog, 1),
("ln", Olog, 1),
("log10", Olog10, 1),
("log2", Olog2, 1),
("logb", Ologb, 2),
("exp", Oexpf, 1),
("pow", Opow, 2),
("sqrt", Osqrt, 1),
("cbrt", Ocbrt, 1),
("floor", Ofloor, 1),
("ceiling", Oceil, 1),
("min", Omin, 2),
("max", Omax, 2),
("abs", Oabs, 1),
("Γ", Ogamma, 1),
("gamma", Ogamma, 1),
("sign", Osign, 1),
("int", Oint, 1),
("frac", Ofrac, 1),
("round", Oround, 1),
("erf", Oerf, 1),
("atan2", Oatan2, 2),
("sin", Osin, 1),
("cos", Ocos, 1),
("tan", Otan, 1),
("asin", Oasin, 1),
("acos", Oacos, 1),
("atan", Oatan, 1),
("sinh", Osinh, 1),
("cosh", Ocosh, 1),
("tanh", Otanh, 1),
("asinh", Oasinh, 1),
("acosh", Oacosh, 1),
("atanh", Oatanh, 1),
("rand", Orand, 0),
("Σ", Osigma, 3),
("sigma", Osigma, 3),
("Π", Opi, 3),
("pi", Opi, 3),
("cfrac", Ocfrac, 3),
("Δ", Oderiv, 2),
("differential", Oderiv, 2),
("∫", Ointeg, 3),
("integral", Ointeg, 3),
("solve", Osolve, 1),
("", 0, 0),
};
stdin: int;
bin: ref Iobuf;
lineno: int = 1;
file: string;
iostack: list of (int, int, int, string, ref Iobuf);
geof: int;
garg: string;
gargs: list of string;
bufc: int = None;
buft: int = Olast;
lexes: int;
lexval: real;
lexstr: string;
lexsym: ref Sym;
syms: array of ref Sym;
deg: ref Dec;
pbase: ref Dec;
errdec: ref Dec;
inloop: int;
infn: int;
Node: adt
{
op: int;
left: cyclic ref Node;
right: cyclic ref Node;
val: real;
str: string;
dec: cyclic ref Dec;
src: int;
};
Dec: adt
{
kind: int;
scope: int;
sym: cyclic ref Sym;
val: real;
na: int;
code: cyclic ref Node;
old: cyclic ref Dec;
next: cyclic ref Dec;
};
Sym: adt
{
name: string;
kind: int;
dec: cyclic ref Dec;
next: cyclic ref Sym;
};
opstring(t: int): string
{
s := opss[t];
if(s != nil)
return s;
for(i := 0; keyw[i].t0 != nil; i++)
if(t == keyw[i].t1)
return keyw[i].t0;
for(i = 0; funw[i].t0 != nil; i++)
if(t == funw[i].t1)
return funw[i].t0;
return s;
}
err(s: string)
{
sys->print("error: %s\n", s);
}
error(n: ref Node, s: string)
{
if(n != nil)
lno := n.src;
else
lno = lineno;
s = sys->sprint("line %d: %s", lno, s);
if(file != nil)
s = sys->sprint("file %s: %s", file, s);
raise s;
}
fatal(s: string)
{
sys->print("fatal: %s\n", s);
exit;
}
stack(s: string, f: ref Iobuf)
{
iostack = (bufc, buft, lineno, file, bin) :: iostack;
bufc = None;
buft = Olast;
lineno = 1;
file = s;
bin = f;
}
unstack()
{
(bufc, buft, lineno, file, bin) = hd iostack;
iostack = tl iostack;
}
doinclude(s: string)
{
f := bufio->open(s, Sys->OREAD);
if(f == nil)
error(nil, sys->sprint("cannot open %s", s));
stack(s, f);
}
getc(): int
{
if((c := bufc) != None)
bufc = None;
else if(bin != nil)
c = bin.getc();
else{
if(garg == nil){
if(gargs == nil){
if(geof == 0){
geof = 1;
c = '\n';
}
else
c = Eof;
}
else{
garg = hd gargs;
gargs = tl gargs;
c = ' ';
}
}
else{
c = garg[0];
garg = garg[1: ];
}
}
if(c == Eof && iostack != nil){
unstack();
return getc();
}
return c;
}
ungetc(c: int)
{
bufc = c;
}
slash(c: int): int
{
if(c != '\\')
return c;
nc := getc();
case(nc){
'b' => return '\b';
'f' => return '\f';
'n' => return '\n';
'r' => return '\r';
't' => return '\t';
}
return nc;
}
lexstring(): int
{
sp := "";
while((c := getc()) != '"'){
if(c == Eof)
raise Eeof;
sp[len sp] = slash(c);
}
lexstr = sp;
return Ostring;
}
lexchar(): int
{
while((c := getc()) != '\''){
if(c == Eof)
raise Eeof;
lexval = real slash(c);
}
return Onum;
}
basev(c: int, base: int): int
{
if(c >= 'a' && c <= 'z')
c += 10-'a';
else if(c >= 'A' && c <= 'Z')
c += 10-'A';
else if(c >= '0' && c <= '9')
c -= '0';
else
return -1;
if(c >= base)
error(nil, "bad digit");
return c;
}
lexe(base: int): int
{
neg := 0;
v := big 0;
c := getc();
if(c == '-')
neg = 1;
else
ungetc(c);
for(;;){
c = getc();
cc := basev(c, base);
if(cc < 0){
ungetc(c);
break;
}
v = big base*v+big cc;
}
if(neg)
v = -v;
return int v;
}
lexnum(): int
{
base := 10;
exp := 0;
r := f := e := 0;
v := big 0;
c := getc();
if(c == '0'){
base = 8;
c = getc();
if(c == '.'){
base = 10;
ungetc(c);
}
else if(c == 'x' || c == 'X')
base = 16;
else
ungetc(c);
}
else
ungetc(c);
for(;;){
c = getc();
if(!r && (c == 'r' || c == 'R')){
if(f || e)
error(nil, "bad base");
r = 1;
base = int v;
if(base < 2 || base > 36)
error(nil, "bad base");
v = big 0;
continue;
}
if(c == '.'){
if(f || e)
error(nil, "bad real");
f = 1;
continue;
}
if(base == 10 && (c == 'e' || c == 'E')){
if(e)
error(nil, "bad E part");
e = 1;
exp = lexe(base);
continue;
}
cc := basev(c, base);
if(cc < 0){
ungetc(c);
break;
}
v = big base*v+big cc;
if(f)
f++;
}
lexval = real v;
if(f)
lexval /= real base**(f-1);
if(exp){
if(exp > 0)
lexval *= real base**exp;
else
lexval *= maths->pow(real base, real exp);
}
return Onum;
}
lexid(): int
{
sp := "";
for(;;){
c := getc();
if(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c >= 'α' && c <= 'ω' || c >= 'Α' && c <= 'Ω' || c == '_')
sp[len sp] = c;
else{
ungetc(c);
break;
}
}
lexsym = enter(sp, Oident);
return lexsym.kind;
}
follow(c: int, c1: int, c2: int): int
{
nc := getc();
if(nc == c)
return c1;
ungetc(nc);
return c2;
}
skip()
{
if((t := buft) != Olast){
lex();
if(t == Onl)
return;
}
for(;;){
c := getc();
if(c == Eof){
ungetc(c);
return;
}
if(c == '\n'){
lineno++;
return;
}
}
}
lex(): int
{
lexes++;
if((t := buft) != Olast){
buft = Olast;
if(t == Onl)
lineno++;
return t;
}
for(;;){
case(c := getc()){
Eof =>
return Oeof;
'#' =>
while((c = getc()) != '\n'){
if(c == Eof)
raise Eeof;
}
lineno++;
'\n' =>
lineno++;
return Onl;
' ' or
'\t' or
'\r' or
'\v' =>
;
'"' =>
return lexstring();
'\'' =>
return lexchar();
'0' to '9' =>
ungetc(c);
return lexnum();
'a' to 'z' or
'A' to 'Z' or
'α' to 'ω' or
'Α' to 'Ω' or
'_' =>
ungetc(c);
return lexid();
'+' =>
c = getc();
if(c == '=')
return Oadde;
ungetc(c);
return follow('+', Oinc, Oadd);
'-' =>
c = getc();
if(c == '=')
return Osube;
if(c == '>')
return Oimp;
ungetc(c);
return follow('-', Odec, Osub);
'*' =>
c = getc();
if(c == '=')
return Omule;
if(c == '*')
return follow('=', Oexpe, Oexp);
ungetc(c);
return Omul;
'/' =>
c = getc();
if(c == '=')
return Odive;
if(c == '/')
return follow('=', Oidive, Oidiv);
ungetc(c);
return Odiv;
'%' =>
return follow('=', Omode, Omod);
'&' =>
c = getc();
if(c == '=')
return Oande;
ungetc(c);
return follow('&', Oandand, Oand);
'|' =>
c = getc();
if(c == '=')
return Oore;
ungetc(c);
return follow('|', Ooror, Oor);
'^' =>
return follow('=', Oxore, Oxor);
'=' =>
return follow('=', Oeq, Oas);
'!' =>
return follow('=', One, Oexc);
'>' =>
c = getc();
if(c == '=')
return Oge;
if(c == '>')
return follow('=', Orshe, Orsh);
ungetc(c);
return Ogt;
'<' =>
c = getc();
if(c == '=')
return Ole;
if(c == '<')
return follow('=', Olshe, Olsh);
if(c == '-')
return follow('>', Oiff, Oimpby);
ungetc(c);
return Olt;
'(' =>
return Olbr;
')' =>
return Orbr;
'{' =>
return Olcbr;
'}' =>
return Orcbr;
'~' =>
return Ocom;
'.' =>
ungetc(c);
return lexnum();
',' =>
return Ocomma;
'?' =>
return Oquest;
':' =>
return follow('=', Odas, Ocolon);
';' =>
return Oscolon;
'↑' =>
return Onand;
'↓' =>
return Onor;
'∞' =>
lexval = Infinity;
return Onum;
* =>
error(nil, sys->sprint("bad character %c", c));
}
}
}
unlex(t: int)
{
lexes--;
buft = t;
if(t == Onl)
lineno--;
}
mustbe(t: int)
{
nt := lex();
if(nt != t)
error(nil, sys->sprint("expected %s not %s", opstring(t), opstring(nt)));
}
consume(t: int)
{
nt := lex();
if(nt != t)
unlex(nt);
}
elex(): int
{
t := lex();
if(binary(t))
return t;
if(hexp(t)){
unlex(t);
return Oscomma;
}
return t;
}
hexp(o: int): int
{
return preunary(o) || o == Olbr || atom(o);
}
atom(o: int): int
{
return o >= Ostring && o <= Olfun;
}
asop(o: int): int
{
return o == Oas || o == Odas || o >= Oadde && o <= Orshe || o >= Oinc && o <= Opostdec;
}
preunary(o: int): int
{
return ops[o]&Preunary;
}
postunary(o: int): int
{
return ops[o]&Postunary;
}
binary(o: int): int
{
return ops[o]&Binary;
}
prec(o: int): int
{
return ops[o]&Prec;
}
assoc(o: int): int
{
return ops[o]&Assoc;
}
rassoc(o: int): int
{
return ops[o]&Rassoc;
}
preop(o: int): int
{
case(o){
Oadd => return Oplus;
Osub => return Ominus;
Oinc => return Opreinc;
Odec => return Opredec;
Oexc => return Onot;
}
return o;
}
postop(o: int): int
{
case(o){
Oinc => return Opostinc;
Odec => return Opostdec;
Oexc => return Ofact;
}
return o;
}
prtree(p: ref Node, in: int)
{
if(p == nil)
return;
for(i := 0; i < in; i++)
sys->print(" ");
sys->print("%s ", opstring(p.op));
case(p.op){
Ostring =>
sys->print("%s", p.str);
Onum =>
sys->print("%g", p.val);
Ocon or
Ovar =>
sys->print("%s(%g)", p.dec.sym.name, p.dec.val);
Ofun or
Olfun =>
sys->print("%s", p.dec.sym.name);
}
sys->print("\n");
# sys->print(" - %d\n", p.src);
prtree(p.left, in+1);
prtree(p.right, in+1);
}
tree(o: int, l: ref Node, r: ref Node): ref Node
{
p := ref Node;
p.op = o;
p.left = l;
p.right = r;
p.src = lineno;
if(asop(o)){
if(o >= Oadde && o <= Orshe){
p = tree(Oas, l, p);
p.right.op += Oadd-Oadde;
}
}
return p;
}
itree(n: int): ref Node
{
return vtree(real n);
}
vtree(v: real): ref Node
{
n := tree(Onum, nil, nil);
n.val = v;
return n;
}
ltree(s: string, a: ref Node): ref Node
{
n := tree(Olfun, a, nil);
n.dec = lookup(s).dec;
return n;
}
ptree(n: ref Node, p: real): ref Node
{
if(isinteger(p)){
i := int p;
if(i == 0)
return itree(1);
if(i == 1)
return n;
if(i == -1)
return tree(Oinv, n, nil);
if(i < 0)
return tree(Oinv, tree(Oexp, n, itree(-i)), nil);
}
return tree(Oexp, n, vtree(p));
}
iscon(n: ref Node): int
{
return n.op == Onum || n.op == Ocon;
}
iszero(n: ref Node): int
{
return iscon(n) && eval(n) == 0.0;
}
isone(n: ref Node): int
{
return iscon(n) && eval(n) == 1.0;
}
isnan(n: ref Node): int
{
return iscon(n) && maths->isnan(eval(n));
}
isinf(n: ref Node): int
{
return iscon(n) && (v := eval(n)) == Infinity || v == -Infinity;
}
stat(scope: int): ref Node
{
e1, e2, e3, e4: ref Node;
consume(Onl);
t := lex();
case(t){
Olcbr =>
if(scope)
pushscope();
for(;;){
e2 = stat(1);
if(e1 == nil)
e1 = e2;
else
e1 = tree(Ocomma, e1, e2);
consume(Onl);
t = lex();
if(t == Oeof)
raise Eeof;
if(t == Orcbr)
break;
unlex(t);
}
if(scope)
popscope();
return e1;
Oprint or
Oread or
Oret =>
if(t == Oret && !infn)
error(nil, "return not in fn");
e1= tree(t, expr(0, 1), nil);
consume(Oscolon);
if(t == Oread)
allvar(e1.left);
return e1;
Oif =>
# mustbe(Olbr);
e1 = expr(0, 1);
# mustbe(Orbr);
e2 = stat(1);
e3 = nil;
consume(Onl);
t = lex();
if(t == Oelse)
e3 = stat(1);
else
unlex(t);
return tree(Oif, e1, tree(Ocomma, e2, e3));
Ofor =>
inloop++;
mustbe(Olbr);
e1 = expr(0, 1);
mustbe(Oscolon);
e2 = expr(0, 1);
mustbe(Oscolon);
e3 = expr(0, 1);
mustbe(Orbr);
e4 = stat(1);
inloop--;
return tree(Ocomma, e1, tree(Ofor, e2, tree(Ocomma, e4, e3)));
Owhile =>
inloop++;
# mustbe(Olbr);
e1 = expr(0, 1);
# mustbe(Orbr);
e2 = stat(1);
inloop--;
return tree(Ofor, e1, tree(Ocomma, e2, nil));
Odo =>
inloop++;
e1 = stat(1);
consume(Onl);
mustbe(Owhile);
# mustbe(Olbr);
e2 = expr(0, 1);
# mustbe(Orbr);
consume(Oscolon);
inloop--;
return tree(Odo, e1, e2);
Obreak or
Ocont or
Oexit =>
if((t == Obreak || t == Ocont) && !inloop)
error(nil, "break/continue not in loop");
consume(Oscolon);
return tree(t, nil, nil);
Ofn =>
if(infn)
error(nil, "nested functions not allowed");
infn++;
mustbe(Oident);
s := lexsym;
d := mkdec(s, Ofun, 1);
d.code = tree(Ofn, nil, nil);
pushscope();
(d.na, d.code.left) = args(0);
allvar(d.code.left);
pushparams(d.code.left);
d.code.right = stat(0);
popscope();
infn--;
return d.code;
Oinclude =>
e1 = expr(0, 0);
if(e1.op != Ostring)
error(nil, "bad include file");
consume(Oscolon);
doinclude(e1.str);
return nil;
* =>
unlex(t);
e1 = expr(0, 1);
consume(Oscolon);
if(debug)
prnode(e1);
return e1;
}
return nil;
}
ckstat(n: ref Node, parop: int, pr: int)
{
if(n == nil)
return;
pr |= n.op == Oprint;
ckstat(n.left, n.op, pr);
ckstat(n.right, n.op, pr);
case(n.op){
Ostring =>
if(!pr || parop != Oprint && parop != Ocomma)
error(n, "illegal string operation");
}
}
pexp(e: ref Node): int
{
if(e == nil)
return 0;
if(e.op == Ocomma)
return pexp(e.right);
return e.op >= Ostring && e.op <= Oiff && !asop(e.op);
}
expr(p: int, zok: int): ref Node
{
n := exp(p, zok);
ckexp(n, Onothing);
return n;
}
exp(p: int, zok: int): ref Node
{
l := prim(zok);
if(l == nil)
return nil;
while(binary(t := elex()) && (o := prec(t)) >= p){
if(rassoc(t))
r := exp(o, 0);
else
r = exp(o+1, 0);
if(t == Oscomma)
t = Ocomma;
l = tree(t, l, r);
}
if(t != Oscomma)
unlex(t);
return l;
}
prim(zok: int): ref Node
{
p: ref Node;
na: int;
t := lex();
if(preunary(t)){
t = preop(t);
return tree(t, exp(prec(t), 0), nil);
}
case(t){
Olbr =>
p = exp(0, zok);
mustbe(Orbr);
Ostring =>
p = tree(t, nil, nil);
p.str = lexstr;
Onum =>
p = tree(t, nil ,nil);
p.val = lexval;
Oident =>
s := lexsym;
d := s.dec;
if(d == nil)
d = mkdec(s, Ovar, 0);
case(t = d.kind){
Ocon or
Ovar =>
p = tree(t, nil, nil);
p.dec = d;
Ofun or
Olfun =>
p = tree(t, nil, nil);
p.dec = d;
(na, p.left) = args(prec(t));
if(!(t == Olfun && d.val == real Osolve && na == 2))
if(na != d.na)
error(p, "wrong number of arguments");
if(t == Olfun){
case(int d.val){
Osigma or
Opi or
Ocfrac or
Ointeg =>
if((op := p.left.left.left.op) != Oas && op != Odas)
error(p.left, "expression not an assignment");
Oderiv =>
if((op := p.left.left.op) != Oas && op != Odas)
error(p.left, "expression not an assignment");
}
}
}
* =>
unlex(t);
if(!zok)
error(nil, "missing expression");
return nil;
}
while(postunary(t = lex())){
t = postop(t);
p = tree(t, p, nil);
}
unlex(t);
return p;
}
ckexp(n: ref Node, parop: int)
{
if(n == nil)
return;
o := n.op;
l := n.left;
r := n.right;
if(asop(o))
var(l);
case(o){
Ovar =>
s := n.dec.sym;
d := s.dec;
if(d == nil){
if(strict)
error(n, sys->sprint("%s undefined", s.name));
d = mkdec(s, Ovar, 1);
}
n.dec = d;
Odas =>
ckexp(r, o);
l.dec = mkdec(l.dec.sym, Ovar, 1);
* =>
ckexp(l, o);
ckexp(r, o);
if(o == Oquest && r.op != Ocolon)
error(n, "bad '?' operator");
if(o == Ocolon && parop != Oquest)
error(n, "bad ':' operator");
}
}
commas(n: ref Node): int
{
if(n == nil || n.op == Ofun || n.op == Olfun)
return 0;
c := commas(n.left)+commas(n.right);
if(n.op == Ocomma)
c++;
return c;
}
allvar(n: ref Node)
{
if(n == nil)
return;
if(n.op == Ocomma){
allvar(n.left);
allvar(n.right);
return;
}
var(n);
}
args(p: int): (int, ref Node)
{
if(!p)
mustbe(Olbr);
a := exp(p, 1);
if(!p)
mustbe(Orbr);
na := 0;
if(a != nil)
na = commas(a)+1;
return (na, a);
}
hash(s: string): int
{
l := len s;
h := 4104;
for(i := 0; i < l; i++)
h = 1729*h ^ s[i];
if(h < 0)
h = -h;
return h&(Hash-1);
}
enter(sp: string, k: int): ref Sym
{
for(s := syms[hash(sp)]; s != nil; s = s.next){
if(sp == s.name)
return s;
}
s = ref Sym;
s.name = sp;
s.kind = k;
h := hash(sp);
s.next = syms[h];
syms[h] = s;
return s;
}
lookup(sp: string): ref Sym
{
return enter(sp, Oident);
}
mkdec(s: ref Sym, k: int, dec: int): ref Dec
{
d := ref Dec;
d.kind = k;
d.val = 0.0;
d.na = 0;
d.sym = s;
d.scope = 0;
if(dec)
pushdec(d);
return d;
}
adddec(sp: string, k: int, v: real, n: int): ref Dec
{
d := mkdec(enter(sp, Oident), k, 1);
d.val = v;
d.na = n;
return d;
}
scope: int;
curscope: ref Dec;
scopes: list of ref Dec;
pushscope()
{
scope++;
scopes = curscope :: scopes;
curscope = nil;
}
popscope()
{
popdecs();
curscope = hd scopes;
scopes = tl scopes;
scope--;
}
pushparams(n: ref Node)
{
if(n == nil)
return;
if(n.op == Ocomma){
pushparams(n.left);
pushparams(n.right);
return;
}
n.dec = mkdec(n.dec.sym, Ovar, 1);
}
pushdec(d: ref Dec)
{
if(0 && debug)
sys->print("dec %s scope %d\n", d.sym.name, scope);
d.scope = scope;
s := d.sym;
if(s.dec != nil && s.dec.scope == scope)
error(nil, sys->sprint("redeclaration of %s", s.name));
d.old = s.dec;
s.dec = d;
d.next = curscope;
curscope = d;
}
popdecs()
{
nd: ref Dec;
for(d := curscope; d != nil; d = nd){
d.sym.dec = d.old;
d.old = nil;
nd = d.next;
d.next = nil;
}
curscope = nil;
}
estat(n: ref Node): (int, real)
{
k: int;
v: real;
if(n == nil)
return (Onothing, 0.0);
l := n.left;
r := n.right;
case(n.op){
Ocomma =>
(k, v) = estat(l);
if(k == Oexit || k == Oret || k == Obreak || k == Ocont)
return (k, v);
return estat(r);
Oprint =>
v = print(l);
return (Onothing, v);
Oread =>
v = read(l);
return (Onothing, v);
Obreak or
Ocont or
Oexit =>
return (n.op, 0.0);
Oret =>
return (Oret, eval(l));
Oif =>
v = eval(l);
if(int v)
return estat(r.left);
else if(r.right != nil)
return estat(r.right);
else
return (Onothing, v);
Ofor =>
for(;;){
v = eval(l);
if(!int v)
break;
(k, v) = estat(r.left);
if(k == Oexit || k == Oret)
return (k, v);
if(k == Obreak)
break;
if(r.right != nil)
v = eval(r.right);
}
return (Onothing, v);
Odo =>
for(;;){
(k, v) = estat(l);
if(k == Oexit || k == Oret)
return (k, v);
if(k == Obreak)
break;
v = eval(r);
if(!int v)
break;
}
return (Onothing, v);
* =>
return (Onothing, eval(n));
}
return (Onothing, 0.0);
}
eval(e: ref Node): real
{
lv, rv: real;
if(e == nil)
return 1.0;
o := e.op;
l := e.left;
r := e.right;
if(o != Ofun && o != Olfun)
lv = eval(l);
if(o != Oandand && o != Ooror && o != Oquest)
rv = eval(r);
case(o){
Ostring =>
return 0.0;
Onum =>
return e.val;
Ocon or
Ovar =>
return e.dec.val;
Ofun =>
return call(e.dec, l);
Olfun =>
return libfun(int e.dec.val, l);
Oadd =>
return lv+rv;
Osub =>
return lv-rv;
Omul =>
return lv*rv;
Odiv =>
return lv/rv;
Omod =>
return real (big lv%big rv);
Oidiv =>
return real (big lv/big rv);
Oand =>
return real (big lv&big rv);
Oor =>
return real (big lv|big rv);
Oxor =>
return real (big lv^big rv);
Olsh =>
return real (big lv<<int rv);
Orsh =>
return real (big lv>>int rv);
Oeq =>
return real (lv == rv);
One =>
return real (lv != rv);
Ogt =>
return real (lv > rv);
Olt =>
return real (lv < rv);
Oge =>
return real (lv >= rv);
Ole =>
return real (lv <= rv);
Opreinc =>
l.dec.val += 1.0;
return l.dec.val;
Opostinc =>
l.dec.val += 1.0;
return l.dec.val-1.0;
Opredec =>
l.dec.val -= 1.0;
return l.dec.val;
Opostdec =>
l.dec.val -= 1.0;
return l.dec.val+1.0;
Oexp =>
if(isinteger(rv) && rv >= 0.0)
return lv**int rv;
return maths->pow(lv, rv);
Oandand =>
if(!int lv)
return lv;
return eval(r);
Ooror =>
if(int lv)
return lv;
return eval(r);
Onot =>
return real !int lv;
Ofact =>
if(isinteger(lv) && lv >= 0.0){
n := int lv;
lv = 1.0;
for(i := 2; i <= n; i++)
lv *= real i;
return lv;
}
return gamma(lv+1.0);
Ocom =>
return real ~big lv;
Oas or
Odas =>
l.dec.val = rv;
return rv;
Oplus =>
return lv;
Ominus =>
return -lv;
Oinv =>
return 1.0/lv;
Ocomma =>
return rv;
Oquest =>
if(int lv)
return eval(r.left);
else
return eval(r.right);
Onand =>
return real !(int lv&int rv);
Onor =>
return real !(int lv|int rv);
Oimp =>
return real (!int lv|int rv);
Oimpby =>
return real (int lv|!int rv);
Oiff =>
return real !(int lv^int rv);
* =>
fatal(sys->sprint("case %s in eval", opstring(o)));
}
return 0.0;
}
var(e: ref Node)
{
if(e == nil || e.op != Ovar || e.dec.kind != Ovar)
error(e, "expected a variable");
}
libfun(o: int, a: ref Node): real
{
a1, a2: real;
case(o){
Osolve =>
return solve(a);
Osigma or
Opi or
Ocfrac =>
return series(o, a);
Oderiv =>
return differential(a);
Ointeg =>
return integral(a);
}
v := 0.0;
if(a != nil && a.op == Ocomma){
a1 = eval(a.left);
a2 = eval(a.right);
}
else
a1 = eval(a);
case(o){
Olog =>
v = maths->log(a1);
Olog10 =>
v = maths->log10(a1);
Olog2 =>
v = maths->log(a1)/maths->log(2.0);
Ologb =>
v = maths->log(a1)/maths->log(a2);
Oexpf =>
v = maths->exp(a1);
Opow =>
v = maths->pow(a1, a2);
Osqrt =>
v = maths->sqrt(a1);
Ocbrt =>
v = maths->cbrt(a1);
Ofloor =>
v = maths->floor(a1);
Oceil =>
v = maths->ceil(a1);
Omin =>
v = maths->fmin(a1, a2);
Omax =>
v = maths->fmax(a1, a2);
Oabs =>
v = maths->fabs(a1);
Ogamma =>
v = gamma(a1);
Osign =>
if(a1 > 0.0)
v = 1.0;
else if(a1 < 0.0)
v = -1.0;
else
v = 0.0;
Oint =>
(vi, nil) := maths->modf(a1);
v = real vi;
Ofrac =>
(nil, v) = maths->modf(a1);
Oround =>
v = maths->rint(a1);
Oerf =>
v = maths->erf(a1);
Osin =>
v = maths->sin(D2R(a1));
Ocos =>
v = maths->cos(D2R(a1));
Otan =>
v = maths->tan(D2R(a1));
Oasin =>
v = R2D(maths->asin(a1));
Oacos =>
v = R2D(maths->acos(a1));
Oatan =>
v = R2D(maths->atan(a1));
Oatan2 =>
v = R2D(maths->atan2(a1, a2));
Osinh =>
v = maths->sinh(a1);
Ocosh =>
v = maths->cosh(a1);
Otanh =>
v = maths->tanh(a1);
Oasinh =>
v = maths->asinh(a1);
Oacosh =>
v = maths->acosh(a1);
Oatanh =>
v = maths->atanh(a1);
Orand =>
v = real rand->rand(Big)/real Big;
* =>
fatal(sys->sprint("case %s in libfun", opstring(o)));
}
return v;
}
series(o: int, a: ref Node): real
{
p0, p1, q0, q1: real;
l := a.left;
r := a.right;
if(o == Osigma)
v := 0.0;
else if(o == Opi)
v = 1.0;
else{
p0 = q1 = 0.0;
p1 = q0 = 1.0;
v = Infinity;
}
i := l.left.left.dec;
ov := i.val;
i.val = eval(l.left.right);
eq := 0;
for(;;){
rv := eval(l.right);
if(i.val > rv)
break;
lv := v;
ev := eval(r);
if(o == Osigma)
v += ev;
else if(o == Opi)
v *= ev;
else{
t := ev*p1+p0;
p0 = p1;
p1 = t;
t = ev*q1+q0;
q0 = q1;
q1 = t;
v = p1/q1;
}
if(v == lv && rv == Infinity){
eq++;
if(eq > 100)
break;
}
else
eq = 0;
i.val += 1.0;
}
i.val = ov;
return v;
}
pushe(a: ref Node, l: list of real): list of real
{
if(a == nil)
return l;
if(a.op == Ocomma){
l = pushe(a.left, l);
return pushe(a.right, l);
}
l = eval(a) :: l;
return l;
}
pusha(f: ref Node, l: list of real, nl: list of real): (list of real, list of real)
{
if(f == nil)
return (l, nl);
if(f.op == Ocomma){
(l, nl) = pusha(f.left, l, nl);
return pusha(f.right, l, nl);
}
l = f.dec.val :: l;
f.dec.val = hd nl;
return (l, tl nl);
}
pop(f: ref Node, l: list of real): list of real
{
if(f == nil)
return l;
if(f.op == Ocomma){
l = pop(f.left, l);
return pop(f.right, l);
}
f.dec.val = hd l;
return tl l;
}
rev(l: list of real): list of real
{
nl: list of real;
for( ; l != nil; l = tl l)
nl = hd l :: nl;
return nl;
}
call(d: ref Dec, a: ref Node): real
{
l: list of real;
nl := rev(pushe(a, nil));
(l, nil) = pusha(d.code.left, nil, nl);
l = rev(l);
(k, v) := estat(d.code.right);
l = pop(d.code.left, l);
if(k == Oexit)
exit;
return v;
}
print(n: ref Node): real
{
if(n == nil)
return 0.0;
if(n.op == Ocomma){
print(n.left);
return print(n.right);
}
if(n.op == Ostring){
sys->print("%s", n.str);
return 0.0;
}
v := eval(n);
printnum(v, "");
return v;
}
read(n: ref Node): real
{
bio: ref Iobuf;
if(n == nil)
return 0.0;
if(n.op == Ocomma){
read(n.left);
return read(n.right);
}
sys->print("%s ? ", n.dec.sym.name);
if(!stdin){
bio = bufio->fopen(sys->fildes(0), Sys->OREAD);
stack(nil, bio);
}
lexnum();
consume(Onl);
n.dec.val = lexval;
if(!stdin && bin == bio)
unstack();
return n.dec.val;
}
isint(v: real): int
{
return v >= -real Maxint && v <= real Maxint;
}
isinteger(v: real): int
{
return v == real int v && isint(v);
}
split(v: real): (int, real)
{
# v >= 0.0
n := int v;
if(real n > v)
n--;
return (n, v-real n);
}
n2c(n: int): int
{
if(n < 10)
return n+'0';
return n-10+'a';
}
gamma(v: real): real
{
(s, lg) := maths->lgamma(v);
return real s*maths->exp(lg);
}
D2R(a: real): real
{
if(deg.val != 0.0)
a *= Pi/180.0;
return a;
}
R2D(a: real): real
{
if(deg.val != 0.0)
a /= Pi/180.0;
return a;
}
side(n: ref Node): int
{
if(n == nil)
return 0;
if(asop(n.op) || n.op == Ofun)
return 1;
return side(n.left) || side(n.right);
}
sametree(n1: ref Node, n2: ref Node): int
{
if(n1 == n2)
return 1;
if(n1 == nil || n2 == nil)
return 0;
if(n1.op != n2.op)
return 0;
case(n1.op){
Ostring =>
return n1.str == n2.str;
Onum =>
return n1.val == n2.val;
Ocon or
Ovar =>
return n1.dec == n2.dec;
Ofun or
Olfun =>
return n1.dec == n2.dec && sametree(n1.left, n2.left);
* =>
return sametree(n1.left, n2.left) && sametree(n1.right, n2.right);
}
return 0;
}
simplify(n: ref Node): ref Node
{
if(n == nil)
return nil;
op := n.op;
l := n.left = simplify(n.left);
r := n.right = simplify(n.right);
if(l != nil && iscon(l) && (r == nil || iscon(r))){
if(isnan(l))
return l;
if(r != nil && isnan(r))
return r;
return vtree(eval(n));
}
case(op){
Onum or
Ocon or
Ovar or
Olfun or
Ocomma =>
return n;
Oplus =>
return l;
Ominus =>
if(l.op == Ominus)
return l.left;
Oinv =>
if(l.op == Oinv)
return l.left;
Oadd =>
if(iszero(l))
return r;
if(iszero(r))
return l;
if(sametree(l, r))
return tree(Omul, itree(2), l);
Osub =>
if(iszero(l))
return simplify(tree(Ominus, r, nil));
if(iszero(r))
return l;
if(sametree(l, r))
return itree(0);
Omul =>
if(iszero(l))
return l;
if(iszero(r))
return r;
if(isone(l))
return r;
if(isone(r))
return l;
if(sametree(l, r))
return tree(Oexp, l, itree(2));
Odiv =>
if(iszero(l))
return l;
if(iszero(r))
return vtree(Infinity);
if(isone(l))
return ptree(r, -1.0);
if(isone(r))
return l;
if(sametree(l, r))
return itree(1);
Oexp =>
if(iszero(l))
return l;
if(iszero(r))
return itree(1);
if(isone(l))
return l;
if(isone(r))
return l;
* =>
fatal(sys->sprint("case %s in simplify", opstring(op)));
}
return n;
}
deriv(n: ref Node, d: ref Dec): ref Node
{
if(n == nil)
return nil;
op := n.op;
l := n.left;
r := n.right;
case(op){
Onum or
Ocon =>
n = itree(0);
Ovar =>
if(d == n.dec)
n = itree(1);
else
n = itree(0);
Olfun =>
case(int n.dec.val){
Olog =>
n = ptree(l, -1.0);
Olog10 =>
n = ptree(tree(Omul, l, vtree(Ln10)), -1.0);
Olog2 =>
n = ptree(tree(Omul, l, vtree(Ln2)), -1.0);
Oexpf =>
n = n;
Opow =>
return deriv(tree(Oexp, l.left, l.right), d);
Osqrt =>
return deriv(tree(Oexp, l, vtree(0.5)), d);
Ocbrt =>
return deriv(tree(Oexp, l, vtree(1.0/3.0)), d);
Osin =>
n = ltree("cos", l);
Ocos =>
n = tree(Ominus, ltree("sin", l), nil);
Otan =>
n = ptree(ltree("cos", l), -2.0);
Oasin =>
n = ptree(tree(Osub, itree(1), ptree(l, 2.0)), -0.5);
Oacos =>
n = tree(Ominus, ptree(tree(Osub, itree(1), ptree(l, 2.0)), -0.5), nil);
Oatan =>
n = ptree(tree(Oadd, itree(1), ptree(l, 2.0)), -1.0);
Osinh =>
n = ltree("cosh", l);
Ocosh =>
n = ltree("sinh", l);
Otanh =>
n = ptree(ltree("cosh", l), -2.0);
Oasinh =>
n = ptree(tree(Oadd, itree(1), ptree(l, 2.0)), -0.5);
Oacosh =>
n = ptree(tree(Osub, ptree(l, 2.0), itree(1)), -0.5);
Oatanh =>
n = ptree(tree(Osub, itree(1), ptree(l, 2.0)), -1.0);
* =>
return vtree(Nan);
}
return tree(Omul, n, deriv(l, d));
Oplus or
Ominus =>
n = tree(op, deriv(l, d), nil);
Oinv =>
n = tree(Omul, tree(Ominus, ptree(l, -2.0), nil), deriv(l, d));
Oadd or
Osub or
Ocomma =>
n = tree(op, deriv(l, d), deriv(r, d));
Omul =>
n = tree(Oadd, tree(Omul, deriv(l, d), r), tree(Omul, l, deriv(r, d)));
Odiv =>
n = tree(Osub, tree(Omul, deriv(l, d), r), tree(Omul, l, deriv(r, d)));
n = tree(Odiv, n, ptree(r, 2.0));
Oexp =>
nn := tree(Oadd, tree(Omul, deriv(l, d), tree(Odiv, r, l)), tree(Omul, ltree("log", l), deriv(r, d)));
n = tree(Omul, n, nn);
* =>
n = vtree(Nan);
}
return n;
}
derivative(n: ref Node, d: ref Dec): ref Node
{
n = simplify(deriv(n, d));
if(isnan(n))
error(n, "no derivative");
if(debug)
prnode(n);
return n;
}
newton(f: ref Node, e: ref Node, d: ref Dec, v1: real, v2: real): (int, real)
{
v := (v1+v2)/2.0;
lv := 0.0;
its := 0;
for(;;){
lv = v;
d.val = v;
v = eval(e);
# if(v < v1 || v > v2)
# return (0, 0.0);
if(maths->isnan(v))
return (0, 0.0);
if(its > 100 || fabs(v-lv) < Eps)
break;
its++;
}
if(fabs(v-lv) > Bigeps || fabs(eval(f)) > Bigeps)
return (0, 0.0);
return (1, v);
}
solve(n: ref Node): real
{
d: ref Dec;
if(n == nil)
return Nan;
if(n.op == Ocomma){ # solve(..., var)
var(n.right);
d = n.right.dec;
n = n.left;
if(!varmem(n, d))
error(n, "variable not in equation");
}
else{
d = findvar(n, nil);
if(d == nil)
error(n, "variable missing");
if(d == errdec)
error(n, "one variable only required");
}
if(n.op == Oeq)
n.op = Osub;
dn := derivative(n, d);
var := tree(Ovar, nil, nil);
var.dec = d;
nr := tree(Osub, var, tree(Odiv, n, dn));
ov := d.val;
lim := lookup(Limit).dec.val;
step := lookup(Step).dec.val;
rval := Infinity;
d.val = -lim-step;
v1 := 0.0;
v2 := eval(n);
for(v := -lim; v <= lim; v += step){
d.val = v;
v1 = v2;
v2 = eval(n);
if(maths->isnan(v2)) # v == nan, v <= nan, v >= nan all give 1
continue;
if(fabs(v2) < Eps){
if(v >= -lim && v <= lim && v != rval){
printnum(v, " ");
rval = v;
}
}
else if(v1*v2 <= 0.0){
(f, rv) := newton(n, nr, var.dec, v-step, v);
if(f && rv >= -lim && rv <= lim && rv != rval){
printnum(rv, " ");
rval = rv;
}
}
}
d.val = ov;
if(rval == Infinity)
error(n, "no roots found");
else
sys->print("\n");
return rval;
}
differential(n: ref Node): real
{
x := n.left.left.dec;
ov := x.val;
v := evalx(derivative(n.right, x), x, eval(n.left.right));
x.val = ov;
return v;
}
integral(n: ref Node): real
{
l := n.left;
r := n.right;
x := l.left.left.dec;
ov := x.val;
a := eval(l.left.right);
b := eval(l.right);
h := b-a;
end := evalx(r, x, a) + evalx(r, x, b);
odd := even := 0.0;
oldarea := 0.0;
area := h*end/2.0;
for(i := 1; i < 1<<16; i <<= 1){
even += odd;
odd = 0.0;
xv := a+h/2.0;
for(j := 0; j < i; j++){
odd += evalx(r, x, xv);
xv += h;
}
h /= 2.0;
oldarea = area;
area = h*(end+4.0*odd+2.0*even)/3.0;
if(maths->isnan(area))
error(n, "integral not found");
if(fabs(area-oldarea) < Eps)
break;
}
if(fabs(area-oldarea) > Bigeps)
error(n, "integral not found");
x.val = ov;
return area;
}
evalx(n: ref Node, d: ref Dec, v: real): real
{
d.val = v;
return eval(n);
}
findvar(n: ref Node, d: ref Dec): ref Dec
{
if(n == nil)
return d;
d = findvar(n.left, d);
d = findvar(n.right, d);
if(n.op == Ovar){
if(d == nil)
d = n.dec;
if(n.dec != d)
d = errdec;
}
return d;
}
varmem(n: ref Node, d: ref Dec): int
{
if(n == nil)
return 0;
if(n.op == Ovar)
return d == n.dec;
return varmem(n.left, d) || varmem(n.right, d);
}
fabs(r: real): real
{
if(r < 0.0)
return -r;
return r;
}
cvt(v: real, base: int): string
{
if(base == 10)
return sys->sprint("%g", v);
neg := 0;
if(v < 0.0){
neg = 1;
v = -v;
}
if(!isint(v)){
n := 0;
lg := maths->log(v)/maths->log(real base);
if(lg < 0.0){
(n, nil) = split(-lg);
v *= real base**n;
n = -n;
}
else{
(n, nil) = split(lg);
v /= real base**n;
}
s := cvt(v, base) + "E" + string n;
if(neg)
s = "-" + s;
return s;
}
(n, f) := split(v);
s := "";
do{
r := n%base;
n /= base;
s[len s] = n2c(r);
}while(n != 0);
ls := len s;
for(i := 0; i < ls/2; i++){
t := s[i];
s[i] = s[ls-1-i];
s[ls-1-i] = t;
}
if(f != 0.0){
s[len s] = '.';
for(i = 0; i < 16 && f != 0.0; i++){
f *= real base;
(n, f) = split(f);
s[len s] = n2c(n);
}
}
s = string base + "r" + s;
if(neg)
s = "-" + s;
return s;
}
printnum(v: real, s: string)
{
base := int pbase.val;
if(!isinteger(pbase.val) || base < 2 || base > 36)
base = 10;
sys->print("%s%s", cvt(v, base), s);
if(bits){
r := array[1] of real;
b := array[8] of byte;
r[0] = v;
maths->export_real(b, r);
for(i := 0; i < 8; i++)
sys->print("%2.2x ", int b[i]);
sys->print("\n");
}
}
Left, Right, Pre, Post: con 1<<iota;
lspace := array[] of { 0, 0, 2, 3, 4, 5, 0, 0, 0, 9, 10, 0, 0, 0, 0, 0, 0, 0 };
rspace := array[] of { 0, 1, 2, 3, 4, 5, 0, 0, 0, 9, 10, 0, 0, 0, 0, 0, 0, 0 };
preced(op1: int, op2: int, s: int): int
{
br := 0;
p1 := prec(op1);
p2 := prec(op2);
if(p1 > p2)
br = 1;
else if(p1 == p2){
if(op1 == op2){
if(rassoc(op1))
br = s == Left;
else
br = s == Right && !assoc(op1);
}
else{
if(rassoc(op1))
br = s == Left;
else
br = s == Right && op1 != Oadd;
if(postunary(op1) && preunary(op2))
br = 1;
}
}
return br;
}
prnode(n: ref Node)
{
pnode(n, Onothing, Pre);
sys->print("\n");
}
pnode(n: ref Node, opp: int, s: int)
{
if(n == nil)
return;
op := n.op;
if(br := preced(opp, op, s))
sys->print("(");
if(op == Oas && n.right.op >= Oadd && n.right.op <= Orsh && n.left == n.right.left){
pnode(n.left, op, Left);
sys->print(" %s ", opstring(n.right.op+Oadde-Oadd));
pnode(n.right.right, op, Right);
}
else if(binary(op)){
p := prec(op);
pnode(n.left, op, Left);
if(lspace[p])
sys->print(" ");
sys->print("%s", opstring(op));
if(rspace[p])
sys->print(" ");
pnode(n.right, op, Right);
}
else if(op == Oinv){ # cannot print postunary -1
sys->print("%s", opstring(op));
pnode(n.left, Odiv, Right);
}
else if(preunary(op)){
sys->print("%s", opstring(op));
pnode(n.left, op, Pre);
}
else if(postunary(op)){
pnode(n.left, op, Post);
sys->print("%s", opstring(op));
}
else{
case(op){
Ostring =>
sys->print("%s", n.str);
Onum =>
sys->print("%g", n.val);
Ocon or
Ovar =>
sys->print("%s", n.dec.sym.name);
Ofun or
Olfun =>
sys->print("%s(", n.dec.sym.name);
pnode(n.left, Onothing, Pre);
sys->print(")");
* =>
fatal(sys->sprint("bad op %s in pnode()", opstring(op)));
}
}
if(br)
sys->print(")");
}