Added:

  xcalc-1.0.2
  xclock-1.0.4

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;
+}