aboutsummaryrefslogtreecommitdiff
path: root/apps/xcalc/math.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/xcalc/math.c')
-rw-r--r--apps/xcalc/math.c1025
1 files changed, 1025 insertions, 0 deletions
diff --git a/apps/xcalc/math.c b/apps/xcalc/math.c
new file mode 100644
index 000000000..46ddadadb
--- /dev/null
+++ b/apps/xcalc/math.c
@@ -0,0 +1,1025 @@
+/* $XConsortium: math.c,v 1.17 91/07/25 17:51:34 rws Exp $
+ * $MIT: contrib/programs/xcalc/math.c,v 3.2 1999/12/14 18:53:00 gjcoram Exp$
+ * $XFree86: xc/programs/xcalc/math.c,v 1.5tsi Exp $
+ * $XdotOrg: xc/programs/xcalc/math.c,v 1.3 2004/05/23 20:03:49 alanc Exp $
+ *
+ * math.c - mathematics functions for a hand calculator under X
+ *
+ * Author: John H. Bradley, University of Pennsylvania
+ * (bradley@cis.upenn.edu)
+ * March, 1987
+ *
+ * RPN mode added and port to X11 by Mark Rosenstein, MIT Project Athena
+ *
+ * Modified to be a client of the Xt toolkit and the Athena widget set by
+ * Donna Converse, MIT X Consortium. This is all that remains of the
+ * original calculator, and it still needs to be rewritten. The HP
+ * functionality should be separated from the TI functionality.
+ * Beware the HP functions: there are still errors here.
+ *
+ * Geoffrey Coram fixed most of the HP mode bugs.
+ */
+
+#include <stdio.h>
+#include <X11/Xos.h>
+#include <math.h>
+#include <signal.h>
+#if !defined(IEEE) && defined(SVR4)
+#include <siginfo.h>
+#endif
+#include <setjmp.h>
+#include "xcalc.h"
+#include <errno.h>
+#include <X11/Xlocale.h>
+
+#ifdef _CRAY /* kludge around Cray STDC compiler */
+double (*log_p)() = log;
+#define log ((*log_p))
+double (*exp_p)() = exp;
+#define exp ((*exp_p))
+double (*sqrt_p)() = sqrt;
+#define sqrt ((*sqrt_p))
+double (*log10_p)() = log10;
+#define log10 ((*log10_p))
+double (*atan2_p)() = atan2;
+#define atan2 ((*atan2_p))
+double (*asin_p)() = asin;
+#define asin ((*asin_p))
+double (*acos_p)() = acos;
+#define acos ((*acos_p))
+double (*atan_p)() = atan;
+#define atan ((*atan_p))
+double (*sin_p)() = sin;
+#define sin ((*sin_p))
+double (*cos_p)() = cos;
+#define cos ((*cos_p))
+double (*tan_p)() = tan;
+#define tan ((*tan_p))
+double (*pow_p)() = pow;
+#define pow ((*pow_p))
+#endif /* _CRAY */
+
+#ifndef PI /* sometimes defined in math.h */
+#define PI 3.14159265358979
+#endif
+#define E 2.71828182845904
+#define MAXDISP 11
+#define DEG 0 /* DRG mode. used for trig calculations */
+#define RAD 1
+#define GRAD 2
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#define True 1
+#define False 0
+
+extern int rpn;
+extern char dispstr[];
+extern void draw();
+extern void ringbell();
+extern void setflag();
+extern void Quit();
+
+#ifndef IEEE
+ jmp_buf env;
+#endif
+
+
+/* This section is all of the state machine that implements the calculator
+ * functions. Much of it is shared between the infix and rpn modes.
+ */
+
+int flagINV, flagPAREN, flagM, drgmode; /* display flags */
+
+static double drg2rad=PI/180.0; /* Conversion factors for trig funcs */
+static double rad2drg=180.0/PI;
+static int entered=1; /* true if display contains a valid number.
+ if==2, then use 'dnum', rather than the string
+ stored in the display. (for accuracy)
+ if==3, then error occurred, only CLR & AC work */
+/* entered seems to be overloaded - dmc */
+static int lift_enabled = 0; /* for rpn mode only */
+
+static int CLR =0; /* CLR clears display. if 1, clears acc, also */
+static int Dpoint=0; /* to prevent using decimal pt twice in a # */
+static int clrdisp=1; /* if true clears display before entering # */
+static int lastop =kCLR;
+static int memop =kCLR;
+static int exponent=0;
+static double acc =0.0;
+static double dnum=0.0;
+#define XCALC_MEMORY 10
+static double mem[XCALC_MEMORY] = { 0.0 };
+
+static void DrawDisplay(void);
+static void PushOp(int op);
+static int PopOp(void);
+static int isopempty(void);
+#ifdef DEBUG
+static void showstack(char *string);
+#endif
+static void PushNum(double num);
+static double PopNum(void);
+static void RollNum(int dir);
+static void ClearStacks(void);
+static int priority(int op);
+
+/*
+ * The following is to deal with the unfortunate assumption that if errno
+ * is non-zero then an error has occurred. On some systems (e.g. Ultrix),
+ * sscanf will call lower level routines that will set errno.
+ */
+
+static void
+parse_double (src, fmt, dp)
+ char *src;
+ char *fmt;
+ double *dp;
+{
+ int olderrno = errno;
+
+ (void) sscanf (src, fmt, dp);
+ errno = olderrno;
+ return;
+}
+
+
+/*********************************/
+int pre_op(keynum)
+ int keynum;
+{
+ if (keynum==-1) return(0);
+
+ errno = 0; /* for non-IEEE machines */
+
+ if ( (entered==3) && !(keynum==kCLR || keynum==kOFF)) {
+ if (rpn) {
+ clrdisp++;
+ } else {
+ ringbell();
+ return(1); /* the intent was probably not to do the operation */
+ }
+ }
+
+ if (keynum != kCLR) CLR=0;
+ return(0);
+}
+
+#ifndef IEEE
+
+/* cannot assign result of setjmp under ANSI C, use global instead */
+static volatile int SignalKind;
+static volatile int SignalCode;
+
+void fail_op()
+{
+ if (SignalKind == SIGFPE)
+ switch (SignalCode) {
+#ifdef SVR4
+ case FPE_INTDIV: /* integer divide by zero */
+ case FPE_FLTDIV: /* floating point divide by zero */
+ strcpy(dispstr, "divide by 0");
+ break;
+ case FPE_INTOVF: /* integer overflow */
+ case FPE_FLTOVF: /* floating point overflow */
+ strcpy(dispstr, "overflow");
+ break;
+ case FPE_FLTUND: /* floating point underflow */
+ strcpy(dispstr, "underflow");
+ break;
+ case FPE_FLTRES: /* floating point inexact result */
+ strcpy(dispstr, "inexact result");
+ break;
+ case FPE_FLTINV: /* invalid floating point operation */
+ strcpy(dispstr, "invalid op");
+ break;
+ case FPE_FLTSUB: /* subscript out of range */
+ strcpy(dispstr, "out of range");
+ break;
+
+#endif /*SVR4*/
+
+#ifdef FPE_FLTDIV_TRAP
+ case FPE_FLTDIV_TRAP: strcpy(dispstr,"div by zero"); break;
+#endif
+#ifdef FPE_FLTDIV_FAULT
+ case FPE_FLTDIV_FAULT: strcpy(dispstr,"div by zero"); break;
+#endif
+#ifdef FPE_FLTOVF_TRAP
+ case FPE_FLTOVF_TRAP: strcpy(dispstr,"overflow"); break;
+#endif
+#ifdef FPE_FLTOVF_FAULT
+ case FPE_FLTOVF_FAULT: strcpy(dispstr,"overflow"); break;
+#endif
+#ifdef FPE_FLTUND_TRAP
+ case FPE_FLTUND_TRAP: strcpy(dispstr,"underflow"); break;
+#endif
+#ifdef FPE_FLTUND_FAULT
+ case FPE_FLTUND_FAULT: strcpy(dispstr,"underflow"); break;
+#endif
+ default: strcpy(dispstr,"error");
+ }
+ else
+ if (SignalKind == SIGILL)
+ strcpy(dispstr, "illegal operand");
+
+ entered=3;
+ DrawDisplay();
+ return;
+}
+
+
+/* keep SVR4 compiler from complaining about scope of arg declaration below */
+typedef struct sigcontext * sigcontextstructp;
+/*ARGSUSED*/
+signal_t fperr(sig,code,scp)
+ int sig,code;
+ sigcontextstructp scp;
+{
+#if defined(SYSV) || defined(SVR4) || defined(linux)
+ signal(SIGFPE,(signal_t (*)())fperr);
+#endif
+ SignalKind = sig;
+ SignalCode = code;
+ longjmp(env,1);
+}
+
+/* for VAX BSD4.3 */
+/*ARGSUSED*/
+signal_t illerr(sig,code,scp)
+ int sig,code;
+ sigcontextstructp scp;
+{
+ /* not reset when caught? */
+ signal(SIGILL,(signal_t (*)())illerr);
+
+ SignalKind = sig;
+ SignalCode = code;
+ longjmp(env,1);
+}
+
+#endif /* not IEEE */
+
+
+void post_op()
+{
+#ifdef DEBUG
+ showstack("\0");
+#endif
+#ifndef IEEE
+ if (errno) {
+ strcpy(dispstr,"error");
+ DrawDisplay();
+ entered=3;
+ errno=0;
+ }
+#endif
+}
+/*-------------------------------------------------------------------------*/
+static void
+DrawDisplay(void)
+{
+ if ((int) strlen(dispstr) > 12) { /* strip out some decimal digits */
+ char tmp[32];
+ char *estr = index(dispstr,'e'); /* search for exponent part */
+ if (!estr) dispstr[12]='\0'; /* no exp, just trunc. */
+ else {
+ if ((int) strlen(estr) <= 4)
+ sprintf(tmp,"%.8s",dispstr); /* leftmost 8 chars */
+ else
+ sprintf(tmp,"%.7s",dispstr); /* leftmost 7 chars */
+ strcat (tmp,estr); /* plus exponent */
+ strcpy (dispstr,tmp);
+ }
+ }
+ draw(dispstr);
+ setflag(XCalc_MEMORY, (flagM));
+ setflag(XCalc_INVERSE, (flagINV));
+ setflag(XCalc_DEGREE, (drgmode==DEG));
+ setflag(XCalc_RADIAN, (drgmode==RAD));
+ setflag(XCalc_GRADAM, (drgmode==GRAD));
+ setflag(XCalc_PAREN, (flagPAREN));
+}
+
+/*-------------------------------------------------------------------------*/
+void
+numeric(keynum)
+ int keynum;
+{
+ char st[2];
+ int cell = 0;
+
+ flagINV=0;
+
+ if (rpn && (memop == kSTO || memop == kRCL || memop == kSUM)) {
+ switch (keynum) {
+ case kONE: cell = 1; break;
+ case kTWO: cell = 2; break;
+ case kTHREE: cell = 3; break;
+ case kFOUR: cell = 4; break;
+ case kFIVE: cell = 5; break;
+ case kSIX: cell = 6; break;
+ case kSEVEN: cell = 7; break;
+ case kEIGHT: cell = 8; break;
+ case kNINE: cell = 9; break;
+ case kZERO: cell = 0; break;
+ }
+ switch (memop) {
+ case kSTO:
+ mem[cell] = dnum;
+ lift_enabled = 1;
+ entered = 2;
+ clrdisp++;
+ break;
+ case kRCL:
+ PushNum(dnum);
+ dnum = mem[cell];
+ sprintf(dispstr, "%.8g", dnum);
+ lift_enabled = 1;
+ entered = 1;
+ clrdisp++;
+ break;
+ case kSUM:
+ mem[cell] += dnum;
+ lift_enabled = 1;
+ entered = 2;
+ clrdisp++;
+ break;
+ }
+ memop = kCLR;
+ DrawDisplay();
+ return;
+ }
+
+ if (clrdisp) {
+ dispstr[0]='\0';
+ exponent=Dpoint=0;
+/* if (rpn && entered==2)
+ PushNum(dnum);
+ */
+ if (rpn & lift_enabled)
+ PushNum(dnum);
+ }
+ if ((int) strlen(dispstr) >= MAXDISP)
+ return;
+
+ switch (keynum){
+ case kONE: st[0] = '1'; break;
+ case kTWO: st[0] = '2'; break;
+ case kTHREE: st[0] = '3'; break;
+ case kFOUR: st[0] = '4'; break;
+ case kFIVE: st[0] = '5'; break;
+ case kSIX: st[0] = '6'; break;
+ case kSEVEN: st[0] = '7'; break;
+ case kEIGHT: st[0] = '8'; break;
+ case kNINE: st[0] = '9'; break;
+ case kZERO: st[0] = '0'; break;
+ }
+ st[1] = '\0';
+ strcat(dispstr,st);
+
+ DrawDisplay();
+ if (clrdisp && keynum != kZERO)
+ clrdisp=0; /*no leading 0s*/
+ memop = keynum;
+ entered=1;
+ lift_enabled = 0;
+}
+
+void
+bkspf(void)
+{
+
+ lift_enabled = 0;
+
+ if (! flagINV)
+ {
+ if (entered!=1) {
+ clearf();
+ return;
+ }
+ if (clrdisp)
+ return;
+ if ((int) strlen(dispstr) > 0) {
+#ifndef X_LOCALE
+ const char *dp = localeconv()->decimal_point;
+ size_t dp_len = strlen(dp);
+ size_t ds_len = strlen(dispstr);
+ if (ds_len >= dp_len && strcmp(dispstr + ds_len - dp_len, dp) == 0)
+ Dpoint=0;
+#else
+ if (dispstr[strlen(dispstr)-1] == '.')
+ Dpoint=0;
+#endif
+ dispstr[strlen(dispstr)-1] = 0;
+ }
+ if (strlen(dispstr) == 0) {
+ strcat(dispstr, "0");
+ clrdisp++;
+ }
+ }
+ else
+ {
+ strcpy(dispstr, "0");
+ dnum = 0.0;
+ clrdisp++;
+ flagINV = 0;
+ }
+ DrawDisplay();
+}
+
+void
+decf(void)
+{
+ flagINV=0;
+ if (clrdisp) {
+ if (rpn && lift_enabled)
+ PushNum(dnum);
+ strcpy(dispstr,"0");
+ }
+ if (!Dpoint) {
+#ifndef X_LOCALE
+ strcat(dispstr, localeconv()->decimal_point);
+#else
+ strcat(dispstr, ".");
+#endif
+ DrawDisplay();
+ Dpoint++;
+ }
+ clrdisp=0;
+ entered=1;
+}
+
+void
+eef(void)
+{
+ flagINV=0;
+ if (clrdisp) {
+ if (rpn && lift_enabled)
+ PushNum(dnum);
+ strcpy(dispstr, rpn ? "1" : "0");
+ }
+ if (!exponent) {
+ strcat(dispstr,"E+");
+ DrawDisplay();
+ exponent=strlen(dispstr)-1; /* where the '-' goes */
+ }
+ clrdisp=0;
+ entered=1;
+}
+
+void
+clearf(void)
+{
+ flagINV=0;
+ if (CLR && !rpn) { /* clear all */
+ ClearStacks();
+ flagPAREN=0;
+ }
+ CLR++;
+ exponent=Dpoint=0;
+ clrdisp=1;
+ entered=1;
+ strcpy(dispstr,"0");
+ DrawDisplay();
+}
+
+void
+negf(void)
+{
+ flagINV=0;
+ if (exponent) { /* neg the exponent */
+ if (dispstr[exponent]=='-')
+ dispstr[exponent]='+';
+ else
+ dispstr[exponent]='-';
+ DrawDisplay();
+ return;
+ }
+
+ if (strcmp("0",dispstr)==0)
+ return; /* don't neg a zero */
+ if (dispstr[0]=='-') /* already neg-ed */
+ strcpy(dispstr,dispstr+1); /* move str left once */
+ else { /* not neg-ed. add a '-' */
+ char tmp[32];
+ sprintf(tmp,"-%s",dispstr);
+ strcpy(dispstr,tmp);
+ }
+ if (entered==2)
+ dnum = -1.0 * dnum;
+ DrawDisplay();
+}
+
+/* Two operand functions for infix calc */
+void
+twoop(int keynum)
+{
+ if (flagINV) {
+ flagINV=0;
+ DrawDisplay();
+ }
+
+ if (!entered) { /* something like "5+*" */
+ if (!isopempty())
+ (void) PopOp(); /* replace the prev op */
+ PushOp(keynum); /* with the new one */
+ return;
+ }
+
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+
+ clrdisp=CLR=1;
+ entered=Dpoint=exponent=0;
+
+ if (!isopempty()) { /* there was a previous op */
+ lastop=PopOp(); /* get it */
+
+ if (lastop==kLPAR) { /* put it back */
+ PushOp(kLPAR);
+ PushOp(keynum);
+ PushNum(dnum);
+ return;
+ }
+
+ /* now, if the current op (keynum) is of
+ higher priority than the lastop, the current
+ op and number are just pushed on top
+ Priorities: (Y^X) > *,/ > +,- */
+
+ if (priority(keynum) > priority(lastop)) {
+ PushNum(dnum);
+ PushOp(lastop);
+ PushOp(keynum);
+ } else { /* execute lastop on lastnum and dnum, push
+ result and current op on stack */
+ acc=PopNum();
+ switch (lastop) { /* perform the operation */
+ case kADD: acc += dnum; break;
+ case kSUB: acc -= dnum; break;
+ case kMUL: acc *= dnum; break;
+ case kDIV: acc /= dnum; break;
+ case kPOW: acc = pow(acc,dnum); break;
+ }
+ PushNum(acc);
+ PushOp(keynum);
+ sprintf(dispstr,"%.8g",acc);
+ DrawDisplay();
+ dnum=acc;
+ }
+ }
+ else { /* op stack is empty, push op and num */
+ PushOp(keynum);
+ PushNum(dnum);
+ }
+}
+
+/* Two operand functions for rpn calc */
+void
+twof(int keynum)
+{
+ if (flagINV) {
+ flagINV=0;
+ DrawDisplay();
+ }
+ if (!entered)
+ return;
+ if (entered==1)
+ parse_double(dispstr, "%lf", &dnum);
+ acc = PopNum();
+ switch(keynum) {
+ case kADD: acc += dnum; break;
+ case kSUB: acc -= dnum; break;
+ case kMUL: acc *= dnum; break;
+ case kDIV: acc /= dnum; break;
+ case kPOW: acc = pow(acc,dnum); break;
+ case kXXY: PushNum(dnum);
+ }
+ sprintf(dispstr, "%.8g", acc);
+ DrawDisplay();
+ clrdisp++;
+ Dpoint = exponent = 0;
+ entered = 2;
+ lift_enabled = 1;
+ dnum = acc;
+}
+
+void
+entrf(void)
+{
+ flagINV=0;
+ if (!entered)
+ return;
+
+ clrdisp=CLR=1;
+ Dpoint=exponent=0;
+
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ entered=2;
+ memop = kENTR;
+ PushNum(dnum);
+ lift_enabled = 0;
+}
+
+void
+equf(void)
+{
+ flagINV=0;
+ if (!entered)
+ return;
+
+ clrdisp=CLR=1;
+ Dpoint=exponent=0;
+
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ entered=2;
+
+ PushNum(dnum);
+
+ while (!isopempty()) { /* do all pending ops */
+ dnum=PopNum();
+ acc=PopNum();
+ lastop=PopOp();
+ switch (lastop) {
+ case kADD: acc += dnum;
+ break;
+ case kSUB: acc -= dnum;
+ break;
+ case kMUL: acc *= dnum;
+ break;
+ case kDIV: acc /= dnum;
+ break;
+ case kPOW: acc = pow(acc,dnum);
+ break;
+ case kLPAR: flagPAREN--;
+ PushNum(acc);
+ break;
+ }
+ dnum=acc;
+ PushNum(dnum);
+ }
+
+ sprintf(dispstr,"%.8g",dnum);
+ DrawDisplay();
+}
+
+void
+lparf(void)
+{
+ flagINV=0;
+ PushOp(kLPAR);
+ flagPAREN++;
+ DrawDisplay();
+}
+
+void
+rollf(void)
+{
+ if (!entered)
+ return;
+ if (entered==1)
+ parse_double(dispstr, "%lf", &dnum);
+ entered = 2;
+ lift_enabled = 1;
+ RollNum(flagINV);
+ flagINV=0;
+ clrdisp++;
+ sprintf(dispstr, "%.8g", dnum);
+ DrawDisplay();
+}
+
+void
+rparf(void)
+{
+ flagINV=0;
+ if (!entered)
+ return;
+
+ if (!flagPAREN)
+ return;
+
+ clrdisp++;
+ Dpoint=exponent=0;
+
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ entered=2;
+
+ PushNum(dnum);
+ while (!isopempty() && (lastop=PopOp())!=kLPAR) {
+ /* do all pending ops, back to left paren */
+ dnum=PopNum();
+ acc=PopNum();
+ switch (lastop) {
+ case kADD: acc += dnum;
+ break;
+ case kSUB: acc -= dnum;
+ break;
+ case kMUL: acc *= dnum;
+ break;
+ case kDIV: acc /= dnum;
+ break;
+ case kPOW: acc = pow(acc,dnum);
+ break;
+ }
+ dnum=acc;
+ PushNum(dnum);
+ }
+ (void) PopNum();
+ flagPAREN--;
+ entered=2;
+ sprintf(dispstr,"%.8g",dnum);
+ DrawDisplay();
+}
+
+void
+drgf(void)
+{
+ if (flagINV) {
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ switch (drgmode) {
+ case DEG: dnum=dnum*PI/180.0; break;
+ case RAD: dnum=dnum*200.0/PI; break;
+ case GRAD: dnum=dnum*90.0/100.0; break;
+ }
+ entered=2;
+ clrdisp=1;
+ flagINV=0;
+ sprintf(dispstr,"%.8g",dnum);
+ }
+
+ flagINV=0;
+ drgmode = (drgmode + 1) % 3;
+ switch (drgmode) {
+ case DEG: drg2rad=PI / 180.0;
+ rad2drg=180.0 / PI;
+ break;
+ case RAD: drg2rad=1.0;
+ rad2drg=1.0;
+ break;
+ case GRAD: drg2rad=PI / 200.0;
+ rad2drg=200.0 / PI;
+ break;
+ }
+ DrawDisplay();
+}
+
+void
+invf(void)
+{
+ flagINV = ~flagINV;
+ DrawDisplay();
+}
+
+void
+memf(int keynum)
+{
+ memop = keynum;
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ entered = 2;
+ clrdisp++;
+ lift_enabled = 0;
+}
+
+void
+oneop(int keynum)
+{
+ int i,j;
+ double dtmp;
+
+ if (entered==1)
+ parse_double(dispstr,"%lf",&dnum);
+ entered = 2;
+
+ switch (keynum) { /* do the actual math fn. */
+ case kE: if (rpn && memop != kENTR) PushNum(dnum); dnum=E; break;
+ case kPI: if (rpn && memop != kENTR) PushNum(dnum); dnum=PI; break;
+ case kRECIP: dnum=1.0/dnum; break;
+ case kSQR: flagINV = !flagINV; /* fall through to */
+ case kSQRT: if (flagINV) dnum=dnum*dnum;
+ else dnum=sqrt(dnum);
+ break;
+ case k10X: flagINV = !flagINV; /* fall through to */
+ case kLOG: if (flagINV) dnum=pow(10.0,dnum);
+ else dnum=log10(dnum);
+ break;
+ case kEXP: flagINV = !flagINV; /* fall through to */
+ case kLN: if (flagINV) dnum=exp(dnum);
+ else dnum=log(dnum);
+ break;
+ case kSIN: if (flagINV) dnum=asin(dnum)*rad2drg;
+ else dnum=sin(dnum*drg2rad);
+ break;
+ case kCOS: if (flagINV) dnum=acos(dnum)*rad2drg;
+ else dnum=cos(dnum*drg2rad);
+ break;
+ case kTAN: if (flagINV) dnum=atan(dnum)*rad2drg;
+ else dnum=tan(dnum*drg2rad);
+ break;
+ case kSTO: mem[0]=dnum; flagM=!(mem[0]==0.0); break;
+ case kRCL: if (rpn && lift_enabled) PushNum(dnum);
+ dnum=mem[0]; flagM=!(mem[0]==0.0); break;
+ case kSUM: mem[0]+=dnum; flagM=!(mem[0]==0.0); break;
+ case kEXC: dtmp=dnum; dnum=mem[0]; mem[0]=dtmp;
+ flagM=!(mem[0]==0.0); break;
+ case kFACT: if (floor(dnum)!=dnum || dnum<0.0 || dnum>500.0) {
+ strcpy(dispstr,"error");
+ entered=3;
+ break;
+ }
+ i=(int) (floor(dnum));
+ for (j=1,dnum=1.0; j<=i; j++)
+ dnum*=(float) j;
+ break;
+ }
+
+ if (entered==3) { /* error */
+ DrawDisplay();
+ return;
+ }
+
+ memop = keynum;
+ entered=2;
+ clrdisp=1;
+ flagINV=0;
+ lift_enabled = 1;
+ sprintf(dispstr,"%.8g",dnum);
+ DrawDisplay();
+}
+
+void
+offf(void)
+{
+ /* full reset */
+ int i;
+ ResetCalc();
+ entered=clrdisp=1;
+ lift_enabled = 0;
+ dnum=mem[0]=0.0;
+ if (rpn)
+ for (i=1; i < XCALC_MEMORY; i++)
+ mem[i]=0.0;
+ exponent=Dpoint=0;
+ DrawDisplay();
+}
+
+
+#define STACKMAX 32
+static int opstack[STACKMAX];
+static int opsp;
+static double numstack[STACKMAX];
+static int numsp;
+
+
+/*******/
+static void
+PushOp(op)
+ int op;
+/*******/
+{
+ if (opsp==STACKMAX) {strcpy(dispstr,"stack error"); entered=3;}
+ else opstack[opsp++]=op;
+}
+
+/*******/
+static int
+PopOp(void)
+/*******/
+{
+ if (opsp==0) {
+ strcpy(dispstr,"stack error");
+ entered=3;
+ return(kNOP);
+ } else
+ return(opstack[--opsp]);
+}
+
+/*******/
+static int
+isopempty(void)
+/*******/
+{
+ return( opsp ? 0 : 1 );
+}
+
+#ifdef DEBUG
+static void
+showstack(string)
+ char *string;
+{
+ fprintf(stderr, "%s: %lf %lf %lf\n", string, numstack[0], numstack[1],
+ numstack[2]);
+}
+#endif
+
+/*******/
+static void
+PushNum(num)
+ double num;
+/*******/
+{
+ if (rpn) {
+ numstack[2] = numstack[1];
+ numstack[1] = numstack[0];
+ numstack[0] = num;
+ return;
+ }
+ if (numsp==STACKMAX) {
+ strcpy(dispstr,"stack error");
+ entered=3;
+ } else
+ numstack[numsp++]=num;
+}
+
+/*******/
+static double
+PopNum(void)
+/*******/
+{
+ if (rpn) {
+ double tmp = numstack[0];
+ numstack[0] = numstack[1];
+ numstack[1] = numstack[2];
+ return(tmp);
+ }
+ if (numsp==0) {
+ strcpy(dispstr,"stack error");
+ entered=3;
+ return 0.0;
+ } else
+ return(numstack[--numsp]);
+}
+
+/*******/
+static void
+RollNum(int dir)
+/*******/
+{
+ double tmp;
+
+ if (dir) { /* roll up */
+ tmp = dnum;
+ dnum = numstack[2];
+ numstack[2] = numstack[1];
+ numstack[1] = numstack[0];
+ numstack[0] = tmp;
+ } else { /* roll down */
+ tmp = dnum;
+ dnum = numstack[0];
+ numstack[0] = numstack[1];
+ numstack[1] = numstack[2];
+ numstack[2] = tmp;
+ }
+}
+
+
+/*******/
+static void
+ClearStacks(void)
+/*******/
+{
+ if (rpn)
+ numstack[0] = numstack[1] = numstack[2] = 0.;
+ opsp=numsp=0;
+}
+
+
+/*******/
+static int
+priority(op)
+ int op;
+/*******/
+{
+ switch (op) {
+ case kPOW: return(2);
+ case kMUL:
+ case kDIV: return(1);
+ case kADD:
+ case kSUB: return(0);
+ }
+ return 0;
+}
+
+
+/********/
+void
+ResetCalc(void)
+/********/
+{
+ flagM=flagINV=flagPAREN=0; drgmode=DEG;
+ setflag(XCalc_MEMORY, False);
+ setflag(XCalc_INVERSE, False);
+ setflag(XCalc_PAREN, False);
+ setflag(XCalc_RADIAN, False);
+ setflag(XCalc_GRADAM, False);
+ setflag(XCalc_DEGREE, True);
+ strcpy(dispstr,"0");
+ draw(dispstr);
+ ClearStacks();
+ drg2rad=PI/180.0;
+ rad2drg=180.0/PI;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-23 18:27:28 +0000