ref: 6b3d59a3256a292b582e4313325ca14154211671
dir: /arithmetic.c/
#include <u.h> #include <libc.h> #include <bio.h> #include "dat.h" #include "fns.h" typedef struct ArithFunc2 ArithFunc2; typedef struct ArithFunc1 ArithFunc1; struct ArithFunc2 { Term *(*intint)(vlong, vlong); Term *(*floatfloat)(double, double); Term *(*floatint)(double, vlong); Term *(*intfloat)(vlong, double); }; struct ArithFunc1 { Term *(*i)(vlong); Term *(*f)(double); }; static Term *addi(vlong, vlong); static Term *addf(double, double); static Term *addfi(double, vlong); static Term *addif(vlong, double); static Term *subi(vlong, vlong); static Term *subf(double, double); static Term *subfi(double, vlong); static Term *subif(vlong, double); static Term *muli(vlong, vlong); static Term *mulf(double, double); static Term *mulfi(double, vlong); static Term *mulif(vlong, double); static Term *intdivi(vlong, vlong); static Term *divii(vlong, vlong); static Term *divf(double, double); static Term *divfi(double, vlong); static Term *divif(vlong, double); static Term *remi(vlong, vlong); static Term *modi(vlong, vlong); static Term *poweri(vlong, vlong); static Term *powerf(double, double); static Term *powerfi(double, vlong); static Term *powerif(vlong, double); static Term *shiftlefti(vlong, vlong); static Term *shiftrighti(vlong, vlong); static Term *bitandi(vlong, vlong); static Term *bitori(vlong, vlong); static Term *negi(vlong); static Term *negf(double); static Term *absi(vlong); static Term *absf(double); static Term *signi(vlong); static Term *signf(double); static Term *intpartf(double); static Term *fractpartf(double); static Term *floati(vlong); static Term *floatf(double); static Term *floorf(double); static Term *truncatef(double); static Term *roundf(double); static Term *ceilingf(double); static Term *sini(vlong); static Term *sinf(double); static Term *cosi(vlong); static Term *cosf(double); static Term *atani(vlong); static Term *atanf(double); static Term *expi(vlong); static Term *expf(double); static Term *logi(vlong); static Term *logf(double); static Term *sqrti(vlong); static Term *sqrtf(double); static Term *bitcompli(vlong); Term *binaryeval(Rune *, Term *, Term *, int *); Term *unaryeval(Rune *, Term *, int *); Term * aritheval(Term *expr, int *waserror) { /* Not every arithmetic operation is defined right now. */ *waserror = 0; if(expr->tag == VariableTerm){ *waserror = 1; return instantiationerror(); }else if(expr->tag == AtomTerm){ *waserror = 1; return typeerror(L"number", expr); }else if(expr->tag == FloatTerm || expr->tag == IntegerTerm) return expr; else if(expr->tag == CompoundTerm && expr->arity == 2){ Term *A = aritheval(expr->children, waserror); if(*waserror) return A; Term *B = aritheval(expr->children->next, waserror); if(*waserror) return B; return binaryeval(expr->text, A, B, waserror); }else if(expr->tag == CompoundTerm && expr->arity == 1){ Term *A = aritheval(expr->children, waserror); if(*waserror) return A; return unaryeval(expr->text, A, waserror); }else{ *waserror = 1; Term *functor; Term *arity; if(expr->tag == CompoundTerm){ functor = mkatom(expr->text); arity = mkinteger(expr->arity); }else{ functor = expr; arity = mkinteger(0); } functor->next = arity; Term *pi = mkcompound(L"/", 2, functor); return typeerror(L"evaluable", pi); } } Term * binaryeval(Rune *f, Term *a, Term *b, int *waserror) { Term *result; ArithFunc2 func; if(runestrcmp(f, L"+") == 0) func = (ArithFunc2){addi, addf, addfi, addif}; else if(runestrcmp(f, L"-") == 0) func = (ArithFunc2){subi, subf, subfi, subif}; else if(runestrcmp(f, L"*") == 0) func = (ArithFunc2){muli, mulf, mulfi, mulif}; else if(runestrcmp(f, L"//") == 0) func = (ArithFunc2){intdivi, nil, nil, nil}; else if(runestrcmp(f, L"/") == 0) func = (ArithFunc2){divii, divf, divfi, divif}; else if(runestrcmp(f, L"rem") == 0) func = (ArithFunc2){remi, nil, nil, nil}; else if(runestrcmp(f, L"mod") == 0) func = (ArithFunc2){modi, nil, nil, nil}; else if(runestrcmp(f, L"**") == 0) func = (ArithFunc2){poweri, powerf, powerfi, powerif}; else if(runestrcmp(f, L"<<") == 0) func = (ArithFunc2){shiftlefti, nil, nil, nil}; else if(runestrcmp(f, L">>") == 0) func = (ArithFunc2){shiftrighti, nil, nil, nil}; else if(runestrcmp(f, L"/\\") == 0) func = (ArithFunc2){bitandi, nil, nil, nil}; else if(runestrcmp(f, L"\\/") == 0) func = (ArithFunc2){bitori, nil, nil, nil}; else{ *waserror = 1; Term *functor = mkatom(f); functor->next = mkinteger(2); Term *pi = mkcompound(L"/", 2, functor); return typeerror(L"evaluable", pi); } if(a->tag == IntegerTerm && b->tag == IntegerTerm && func.intint) result = func.intint(a->ival, b->ival); else if(a->tag == FloatTerm && b->tag == FloatTerm && func.floatfloat) result = func.floatfloat(a->dval, b->dval); else if(a->tag == FloatTerm && b->tag == IntegerTerm && func.floatint) result = func.floatint(a->dval, b->ival); else if(a->tag == IntegerTerm && b->tag == FloatTerm && func.intfloat) result = func.intfloat(a->ival, b->dval); else{ /* There must have been a type error */ int type1, type2; if(func.intint){ type1 = IntegerTerm; type2 = IntegerTerm; }else if(func.floatfloat){ type1 = FloatTerm; type2 = FloatTerm; }else if(func.floatint){ type1 = FloatTerm; type2 = IntegerTerm; }else{ type1 = IntegerTerm; type2 = FloatTerm; } if(a->tag != type1) result = typeerror(type1 == IntegerTerm ? L"integer" : L"float", a); else result = typeerror(type2 == IntegerTerm ? L"integer" : L"float", b); } if(result->tag != IntegerTerm && result->tag != FloatTerm) *waserror = 1; return result; } Term * unaryeval(Rune *f, Term *a, int *waserror) { Term *result; ArithFunc1 func; if(runestrcmp(f, L"-") == 0) func = (ArithFunc1){negi, negf}; else if(runestrcmp(f, L"abs") == 0) func = (ArithFunc1){absi, absf}; else if(runestrcmp(f, L"sign") == 0) func = (ArithFunc1){signi, signf}; else if(runestrcmp(f, L"float_integer_part") == 0) func = (ArithFunc1){nil, intpartf}; else if(runestrcmp(f, L"float_fractional_part") == 0) func = (ArithFunc1){nil, fractpartf}; else if(runestrcmp(f, L"float") == 0) func = (ArithFunc1){floati, floatf}; else if(runestrcmp(f, L"floor") == 0) func = (ArithFunc1){nil, floorf}; else if(runestrcmp(f, L"truncate") == 0) func = (ArithFunc1){nil, truncatef}; else if(runestrcmp(f, L"round") == 0) func = (ArithFunc1){nil, roundf}; else if(runestrcmp(f, L"ceiling") == 0) func = (ArithFunc1){nil, ceilingf}; else if(runestrcmp(f, L"sin") == 0) func = (ArithFunc1){sini, sinf}; else if(runestrcmp(f, L"cos") == 0) func = (ArithFunc1){cosi, cosf}; else if(runestrcmp(f, L"atan") == 0) func = (ArithFunc1){atani, atanf}; else if(runestrcmp(f, L"exp") == 0) func = (ArithFunc1){expi, expf}; else if(runestrcmp(f, L"log") == 0) func = (ArithFunc1){logi, logf}; else if(runestrcmp(f, L"sqrt") == 0) func = (ArithFunc1){sqrti, sqrtf}; else if(runestrcmp(f, L"\\") == 0) func = (ArithFunc1){bitcompli, nil}; else{ *waserror = 1; Term *functor = mkatom(f); functor->next = mkinteger(1); Term *pi = mkcompound(L"/", 2, functor); return typeerror(L"evaluable", pi); } if(a->tag == IntegerTerm && func.i) result = func.i(a->ival); else if(a->tag == FloatTerm && func.f) result = func.f(a->dval); else{ if(func.i) result = typeerror(L"integer", a); else result = typeerror(L"float", a); } if(result->tag != IntegerTerm && result->tag != FloatTerm) *waserror = 1; return result; } static Term * addi(vlong x, vlong y) { return mkinteger(x + y); } static Term * addf(double x, double y) { return mkfloat(x + y); } static Term * addfi(double x, vlong y) { return addf(x, y); } static Term * addif(vlong x, double y) { return addf(x, y); } static Term * subi(vlong x, vlong y) { return mkinteger(x - y); } static Term * subf(double x, double y) { return addf(x, -y); } static Term * subfi(double x, vlong y) { return subf(x, y); } static Term * subif(vlong x, double y) { return subf(x, y); } static Term * muli(vlong x, vlong y) { return mkinteger(x * y); } static Term * mulf(double x, double y) { return mkfloat(x * y); } static Term * mulfi(double x, vlong y) { return mulf(x, y); } static Term * mulif(vlong x, double y) { return mulf(x, y); } static Term * intdivi(vlong x, vlong y) { if(y == 0) return evaluationerror(L"zero_divisor"); else return mkinteger(x / y); } static Term * divii(vlong x, vlong y) { return divf(x, y); } static Term * divf(double x, double y) { if(y == 0) return evaluationerror(L"zero_divisor"); else return mkfloat(x / y); } static Term * divfi(double x, vlong y) { return divf(x, y); } static Term * divif(vlong x, double y) { return divf(x, y); } static Term * remi(vlong x, vlong y) { if(y == 0) return evaluationerror(L"zero_divisor"); else return mkinteger(x - (x/y) * y); } static Term * modi(vlong x, vlong y) { if(y == 0) return evaluationerror(L"zero_divisor"); else return mkinteger(x - (floor((double)x/(double)y) * y)); } static Term * poweri(vlong x, vlong y) { return powerf(x, y); } static Term * powerf(double x, double y) { if(x == 0 && y == 0) return mkfloat(1); else if(x == 0 && y < 0) return evaluationerror(L"undefined"); else return mkfloat(pow(x, y)); } static Term * powerfi(double x, vlong y) { return powerf(x, y); } static Term * powerif(vlong x, double y) { return powerf(x, y); } static Term * shiftlefti(vlong x, vlong y) { return mkinteger(x << y); } static Term * shiftrighti(vlong x, vlong y) { return mkinteger(x >> y); } static Term * bitandi(vlong x, vlong y) { return mkinteger(x & y); } static Term * bitori(vlong x, vlong y) { return mkinteger(x | y); } static Term * negi(vlong x) { return mkinteger(-x); } static Term * negf(double x) { return mkfloat(-x); } static Term * absi(vlong x) { return mkinteger(x < 0 ? -x : x); } static Term * absf(double x) { return mkfloat(x < 0 ? -x : x); } static Term * signi(vlong x) { if(x < 0) return mkinteger(-1); else if(x > 0) return mkinteger(1); else return mkinteger(0); } static Term * signf(double x) { if(x < 0) return mkfloat(-1); else if(x > 0) return mkfloat(1); else return mkfloat(0); } static Term * intpartf(double x) { return mkfloat(signf(x)->dval * floorf(absf(x)->dval)->dval); } static Term * fractpartf(double x) { return mkfloat(x - intpartf(x)->dval); } static Term * floati(vlong x) { return mkfloat(x); } static Term * floatf(double x) { return mkfloat(x); } static Term * floorf(double x) { return mkfloat(floor(x)); } static Term * truncatef(double x) { if(x >= 0) return floorf(x); else return mkfloat(-floorf(absf(x)->dval)->dval); } static Term * roundf(double x) { return floorf(x + 0.5); } static Term * ceilingf(double x) { return mkfloat(-floorf(-x)->dval); } static Term * sini(vlong x) { return sinf(x); } static Term * sinf(double x) { return mkfloat(sin(x)); } static Term * cosi(vlong x) { return cosf(x); } static Term * cosf(double x) { return mkfloat(cos(x)); } static Term * atani(vlong x) { return atanf(x); } static Term * atanf(double x) { return mkfloat(atan(x)); } static Term * expi(vlong x) { return expf(x); } static Term * expf(double x) { return mkfloat(exp(x)); } static Term * logi(vlong x) { return logf(x); } static Term * logf(double x) { if(x <= 0) return evaluationerror(L"undefined"); else return mkfloat(log(x)); } static Term * sqrti(vlong x) { return sqrtf(x); } static Term * sqrtf(double x) { if(x < 0) return evaluationerror(L"undefined"); else return mkfloat(sqrt(x)); } static Term * bitcompli(vlong x) { return mkinteger(~x); }