home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 247_02 / ratcalc.c < prev    next >
Text File  |  1989-04-19  |  21KB  |  786 lines
  1. /*
  2.  *       MIRACL RATIONAL CALCULATOR - IBM-PC VERSION
  3.  *       Compiles with Turbo C V1.0 or Microsoft C V3.0+
  4.  *  **   Change display mode for 40/80 column operation (e.g. 'mode 40' to DOS)
  5.  *  **   Change colour/B&W below
  6.  */
  7.  
  8. #include <stdio.h>     /*** IBM-PC specific section ***/
  9. #include <dos.h>        
  10. #include "miracl.h"
  11.  
  12. #define ESC 27
  13. #define SPACE 32
  14. #define BELL 7
  15.  
  16. #define DVERT 186
  17. #define DHORZ 205
  18. #define DTLHC 201
  19. #define DTRHC 187
  20. #define DBLHC 200
  21. #define DBRHC 188
  22. #define VERT 179        
  23. #define HORZ 196
  24. #define TLHC 218
  25. #define TRHC 191
  26. #define BLHC 192
  27. #define BRHC 217
  28. #define LSIDE 199
  29. #define RSIDE 182
  30.  
  31. /* Globals */
  32. /* set colours          B/W       Colours (suggested) */
  33.  
  34. int ORDINARY=0x07; /*   0x07        0x17    blue-white        */
  35. int INVER   =0x70; /*   0x70        0x40    red-black         */
  36. int BOLD    =0x0F; /*   0x0F        0x70    white-black       */
  37. int BLINKING=0x87; /*   0x87        0xF4    white-red (blink) */
  38. int HELPCOL =0x07; /*   0x07        0x02    black-green       */
  39. int PRESSED =0x0F; /*   0x0F        0x4F    red-white (bold)  */
  40. int STATCOL =0x07; /*   0x07        0x74    white-red         */
  41. int BGROUND =0x07; /*   0x07        0x07    black-white       */
  42.  
  43. int dmode;
  44.  
  45.                 /*** Constants 16-bit values ***/
  46.  
  47. char cpi[] = "2646693125139304345/842468587426513207";
  48. char clg2[]= "28575556407596679551/41225813519882571900";
  49. char clg10[]="9948944967727459672/4320771900243161573";
  50.  
  51.                 /*** Device independent data ***/
  52.  
  53. extern big w15;
  54.  
  55. char *settings[4][4]= {"   ","HYP","","",
  56.                        "Be ","B2 ","B10","",
  57.                        "RAD","DEG","GRA","",
  58.                        "DEC","HEX","OCT","BIN"};
  59. int nops[]= {1,2,1,3};         /* number of options   */
  60. int opp[] = {0,1,1,2,2,3,3,2}; /* operator precedence */
  61.  
  62. char *keys[6][7]= {"SIN","COS","TAN","EXP","F-D","CLR","OFF",
  63.                    "ASN","ACS","ATN","LOG","SET","MOD","DEL",
  64.                    " 7 "," 8 "," 9 ","Y^X","X√Y"," ÷ "," RM",    /******/
  65.                    " 4 "," 5 "," 6 "," X²","²√X"," x "," M+",
  66.                    " 1 "," 2 "," 3 ","1/X"," π "," - ","+/-",
  67.                    " 0 "," / "," . "," ( "," ) "," + "," = "};
  68.  
  69. int qkeys[6][7]=  {'s','k','t','e','f','c','o',
  70.                    'S','K','T','l','g','%','<',
  71.                    '7','8','9','y','x','\\','r',
  72.                    '4','5','6','q','v','*','m',
  73.                    '1','2','3','i','p','-',';',
  74.                    '0','/','.','(',')','+','='};
  75.  
  76. char *htext[]=  {"Arrow keys find, space bar activates OR",
  77.                  "use numeric keys  (with  A-F  for hex),",
  78.                  "brackets,  and mnemonic keys as below: ",
  79.                  " FUNCTION      KEY   FUNCTION       KEY",
  80.                  "   SIN          s      ASN           S ",
  81.                  "   COS          k      ACS           K ",
  82.                  "   TAN          t      ATN           T ",
  83.                  "   EXP(e/2/10)  e      LOG(e/2/10)   l ",
  84.                  "   Y^X          y      X√Y           x ",   /******/
  85.                  "    X²          q      ²√X           v ",
  86.                  "   1/X          i       π            p ",
  87.                  "   F-D          f      SET           g ",
  88.                  "   MOD          %      CLR           c ",
  89.                  "    ÷      d or \\       x       b or * ",
  90.                  "    -           -       +       , or + ",
  91.                  "   OFF          o      DEL    DEL or < ",
  92.                  "    RM          r       M+           m ",
  93.                  "   +/-          ;       =     RET or = ",
  94.                  "Note: / means 'over'  as in fractions  ",
  95.                  "F-D converts  fraction  <-->  decimal  ",
  96.                  "SET changes settings - use arrow keys  ",
  97.                  "Alternative arrow keys -   u  h  j  n  ",
  98.                  "Report any problems to M.Scott |NIHED  ",
  99.                  "This program is Public Domain  |Dublin "};     /******/
  100.  
  101. char display[]=   "   MIRACL RATIONAL CALCULATOR V2.0   ";
  102. char  status[]=   "                                     ";
  103. char oldstat[]=   "                                     ";
  104.  
  105. int erptr=0;
  106. int mmptr=6;
  107. int exptr=10;
  108. int typtr=16;
  109. int stptr[]={22,26,30,34};
  110.  
  111. int dbeg=2;
  112. int dlen=37;
  113. int top=7;
  114. int width=80;      /* screen width can be 40 or 80 columns */
  115. char mybuff[40];
  116.  
  117. flash x,y[8],m,t;
  118. flash radeg,loge2,loge10;
  119. int ipt,op[8],prop[8],sp,brkt,lgbase;
  120. bool flag,newx,result,hyp,degrees,delim;
  121. int option[]={0,0,0,0};
  122.  
  123. /* Device specific code - IBM-PC versions */
  124.  
  125. void curser(x,y)
  126. int x,y;
  127. { /* position cursor at x,y */
  128.     union REGS regs;
  129.     regs.h.ah=2;
  130.     regs.h.dh=y-1;
  131.     regs.h.dl=x-1;
  132.     regs.h.bh=0;              /* Video page 0 */
  133.     int86(0x10,®s,®s);  /* Use Dos Interrupt 10h */
  134. }
  135.  
  136. void screen()
  137. { /* initialise screen */
  138.     union REGS regs;
  139.     regs.h.ah=0x0F;  /* get screen mode */
  140.     regs.h.al=0;
  141.     int86(0x10,®s,®s);
  142.     dmode=regs.h.al;
  143.     if ((dmode&2)!=0) width=80;
  144.     else                  width=40;
  145.     regs.h.ah=6;     /* clear screen */
  146.     regs.h.al=0;
  147.     regs.h.cl=0;
  148.     regs.h.ch=0;
  149.     regs.h.dl=width-1;
  150.     regs.h.dh=24;
  151.     regs.h.bh=BGROUND;
  152.     regs.h.bl=0;
  153.     int86(0x10,®s,®s);
  154. }
  155.  
  156. void restore()
  157. {  /* restore situation */
  158.     union REGS inregs,outregs;
  159.     inregs.h.ah=0;       /* reset initial display mode */
  160.     inregs.h.al=dmode;
  161.     int86(0x10,&inregs,&outregs);
  162. }
  163.  
  164. void apchar(attr,x,y,ch)
  165. int attr,x,y;
  166. char ch;
  167. { /* output character with attribute at x,y */
  168.     union REGS regs;
  169.     curser(x,y);
  170.     regs.h.ah=9;              /* output a character */
  171.     regs.h.al=ch;
  172.     regs.h.bh=0;
  173.     regs.h.bl=attr;
  174.     regs.h.cl=1;
  175.     regs.h.ch=0;
  176.     int86(0x10,®s,®s);
  177. }
  178.  
  179. void aprint(attr,x,y,text)
  180. int attr,x,y;
  181. char* text;
  182. { /* attribute print */
  183.     while (*text!='\0')
  184.     {
  185.         apchar(attr,x++,y,*text);
  186.         text++;
  187.     }
  188. }
  189.  
  190. void lclr(x,y)
  191. int x,y;
  192. { /* clear from x,y to end of line */
  193.     aprint(BGROUND,x,y,"                                       ");
  194. }
  195.  
  196. void cset(k)
  197. int k;
  198. { /* select special character set */
  199.     return;
  200. }
  201.  
  202. int gethit()
  203. { /* get single keystroke */
  204.     int ch;
  205.     ch=getch();
  206.     if (ch!=0) return ch;
  207.     ch=getch();
  208.     if (ch==72) return 'u';  /* transform some useful extended codes */
  209.     if (ch==75) return 'h';
  210.     if (ch==77) return 'j';
  211.     if (ch==80) return 'n';
  212.     if (ch==83) return 127;
  213.     return 0;
  214. }
  215.  
  216. /*** Device independent code ***/
  217.  
  218. int arrow(c)
  219. int c;
  220. { /* check for arrow key             *
  221.    * returns 1 for up, 2 for down,   *
  222.    * 3 for right, 4 for left, else 0 */
  223.     if (c=='u') return 1;
  224.     if (c=='n') return 2;
  225.     if (c=='j') return 3;
  226.     if (c=='h') return 4;
  227.     return 0;
  228. }
  229.  
  230. void instat(ptr,strg)
  231. int ptr;
  232. char *strg;
  233. { /* insert a status setting into status line */
  234.     strncpy(&status[ptr],strg,strlen(strg));
  235. }
  236.  
  237. void getstat()
  238. { /* set status line */
  239.     int i;
  240.     if (ERNUM) instat(erptr,"ERROR");
  241.     else       instat(erptr,"     ");
  242.     if (EXACT) instat(exptr,"EXACT");
  243.     else       instat(exptr,"     ");
  244.     if (size(m)!=0) instat(mmptr,"MEM");
  245.     else            instat(mmptr,"   ");
  246.     if (POINT) instat(typtr,"POINT");
  247.     else       instat(typtr,"FRACT");
  248.     for (i=0;i<4;i++)
  249.          instat(stptr[i],settings[i][option[i]]);
  250. }
  251.  
  252. void setopts()
  253. { /* set options */
  254.     if (option[0]==0) hyp=FALSE;
  255.     else              hyp=TRUE;
  256.     lgbase=0;
  257.     if (option[1]==1) lgbase=2;
  258.     if (option[1]==2) lgbase=10;
  259.     if (option[2]==0) degrees=FALSE;
  260.     else              degrees=TRUE;
  261.     IOBASE=10;
  262.     if (option[3]==1) IOBASE=16;
  263.     if (option[3]==2) IOBASE=8;
  264.     if (option[3]==3) IOBASE=2;
  265. } 
  266.  
  267. void show(force)
  268. bool force;
  269. { /* output display */
  270.     if (force || strcmp(oldstat,status)!=0)
  271.     {
  272.         if (ERNUM) aprint(BLINKING,2,2,status);
  273.         else       aprint(STATCOL,2,2,status);
  274.         strcpy(oldstat,status);
  275.     }
  276.     aprint(BOLD,dbeg,3,display);
  277. }
  278.  
  279. void clr()
  280. { /* clear input buffer */
  281.     mybuff[0]='0';
  282.     mybuff[1]='\0';
  283.     ipt=0;
  284.     delim=FALSE;
  285. }
  286.  
  287. void just(buff)
  288. char buff[];
  289. { /* justify buff into display (if possible) *
  290.    * and update status                       */
  291.     int i,mp,df;
  292.     bool dot;
  293.     dot=FALSE;
  294.     mp=0;
  295.     while (mp<=dlen && buff[mp]!='\0')
  296.     {
  297.         if (buff[mp]=='.') dot=TRUE;
  298.         if (mp==dlen && !dot) ERNUM=(-1);
  299.         mp++;
  300.     }
  301.     if (mp>dlen) mp=dlen;
  302.     if (!ERNUM)
  303.     {
  304.         df=dlen-mp;
  305.         for (i=0;i<df;i++) display[i]=' ';
  306.         for (i=0;i<mp;i++) display[df+i]=buff[i];
  307.     }
  308.     display[dlen]='\0';
  309. }
  310.  
  311. void drawit()
  312. { /* Draw calculator */
  313.     int i,j;
  314.     char line[40],tline[40],bline[40];
  315.     cset(1);
  316.     line[0]=DTLHC;
  317.     for (i=1;i<38;i++) line[i]=DHORZ;
  318.     line[38]=DTRHC;
  319.     line[39]='\0';
  320.     aprint(ORDINARY,1,1,line);
  321.     for (i=1;i<22;i++) apchar(ORDINARY,1,1+i,DVERT); 
  322.     line[0]=DBLHC;
  323.     line[38]=DBRHC;
  324.     aprint(ORDINARY,1,23,line);
  325.     for (i=1;i<22;i++) apchar(ORDINARY,39,1+i,DVERT);
  326.     line[0]=LSIDE;  /* draw in the bar */
  327.     for (i=1;i<38;i++) line[i]=HORZ;
  328.     line[38]=RSIDE;
  329.     aprint(ORDINARY,1,4,line);
  330.     line[0]=tline[0]=bline[0]=SPACE;
  331.     line[36]=tline[36]=bline[36]=SPACE;
  332.     line[37]=tline[37]=bline[37]='\0';
  333.     for (i=1;i<36;i++)
  334.     {
  335.         switch (i%5)
  336.         {
  337.         case 1 : tline[i]=TLHC;
  338.                  bline[i]=BLHC;
  339.                  line[i]=VERT;
  340.                  break;
  341.         default: tline[i]=HORZ;
  342.                  bline[i]=HORZ;
  343.                  line[i]=SPACE;
  344.                  break;
  345.         case 0 : tline[i]=TRHC;
  346.                  bline[i]=BRHC;
  347.                  line[i]=VERT;
  348.                  break;
  349.         }
  350.     } 
  351.     for (j=0;j<6;j++)
  352.     {
  353.         aprint(ORDINARY,2,5+3*j,tline);
  354.         aprint(ORDINARY,2,6+3*j,line);
  355.         aprint(ORDINARY,2,7+3*j,bline);
  356.     }
  357.     cset(0);
  358.     for (j=0;j<6;j++)
  359.         for (i=0;i<7;i++)
  360.             aprint(ORDINARY,4+5*i,6+3*j,keys[j][i]);
  361.     aprint(HELPCOL,2,24,"Type 'H' for help on/off, 'O' to exit");
  362.     cotnum(x,stdout);
  363.     just(OBUFF);
  364.     getstat();
  365.     show(TRUE);
  366. }
  367.  
  368. bool next(ch)
  369. int ch;
  370. { /* get next digit - returns FALSE if there is a problem  */
  371.     int cv;
  372.     result=FALSE;
  373.     if (ipt>=dlen) return FALSE;
  374.     if (ch=='/' || ch=='.')
  375.     {
  376.         if (delim || (ch=='/' && ipt==0)) return FALSE;
  377.         delim=TRUE;
  378.     }
  379.     else
  380.     {
  381.         if (ch>='A' && ch<='F') cv=10+(ch-'A');
  382.         else                    cv=ch-'0';
  383.         if (IOBASE<=cv) return FALSE;
  384.     }
  385.     if (ipt==0 && ch=='0') clr();
  386.     else
  387.     {
  388.         mybuff[ipt++]=ch;
  389.         mybuff[ipt]='\0';
  390.     }
  391.     just(mybuff);
  392.     strcpy(IBUFF,mybuff);
  393.     cinnum(x,stdin);
  394.     newx=TRUE;
  395.     return TRUE;
  396. }
  397.  
  398. void swap()
  399. { /* swap x with top of stack */
  400.     flash t;
  401.     t=x;
  402.     x=y[sp];
  403.     y[sp]=t;
  404. }
  405.  
  406. int prec(no)
  407. int no;
  408. { /* return new operator precedence */
  409.     return 4*brkt+opp[no];
  410. }
  411.  
  412. void equals(no)
  413. int no;
  414. { /* perform binary operation */
  415.     bool pop;
  416.     newx=FALSE;
  417.     pop=TRUE;
  418.     while (pop)
  419.     {
  420.         if (prec(no)>prop[sp])
  421.         { /* if higher precedence, keep this one pending */
  422.             if (sp==top)
  423.             {
  424.                 ERNUM=(-1);
  425.                 result=FALSE;
  426.                 newx=TRUE;
  427.             }
  428.             else sp++;
  429.             return;
  430.         }
  431.         newx=TRUE;
  432.         if (flag && op[sp]!=3 && op[sp]!=0) swap();
  433.         switch (op[sp])
  434.         {
  435.         case 7: fdiv(x,y[sp],t);
  436.                 ftrunc(t,t,t);
  437.                 fmul(t,y[sp],t);
  438.                 fsub(x,t,x);
  439.                 break;
  440.         case 6: fpowf(x,y[sp],x);
  441.                 break;
  442.         case 5: frecip(y[sp],t);
  443.                 fpowf(x,t,x);
  444.                 break;
  445.         case 4: fdiv(x,y[sp],x);
  446.                 break;
  447.         case 3: fmul(x,y[sp],x);
  448.                 break;
  449.         case 2: fsub(x,y[sp],x);
  450.                 break;
  451.         case 1: fadd(x,y[sp],x);
  452.                 break;
  453.         case 0: break;
  454.         }
  455.         if (sp>0 && (prec(no)<=prop[sp-1])) sp--;
  456.         else pop=FALSE;
  457.     }
  458. }
  459.  
  460. void chekit(no)
  461. int no;
  462. { /* deal with operator */
  463.     if (flag && newx) equals(no);
  464.     else newx=FALSE;
  465.     flag=ON;
  466.     copy(x,y[sp]);
  467.     op[sp]=no;
  468.     prop[sp]=prec(no);
  469. }
  470.  
  471. void clrall()
  472. { /* clear all */
  473.     ERNUM=0;
  474.     zero(x);
  475.     zero(y[0]);
  476.     zero(m);
  477.     sp=0;
  478.     op[sp]=0;
  479.     prop[sp]=0;
  480.     brkt=0;
  481.     POINT=ON;
  482.     EXACT=TRUE;
  483. }
  484.  
  485. bool act(p,q)
  486. int p,q;
  487. { /* act on selected key */
  488.     int k,n,c;
  489.     aprint(PRESSED,4+5*p,6+3*q,keys[q][p]);
  490.     switch(p+7*q)
  491.     {
  492.     case 0:  if (degrees) fmul(x,radeg,x);
  493.              if (hyp) fsinh(x,x);
  494.              else     fsin(x,x);
  495.              newx=TRUE;
  496.              break;
  497.     case 1:  if (degrees) fmul(x,radeg,x);
  498.              if (hyp) fcosh(x,x);
  499.              else     fcos(x,x);
  500.              newx=TRUE;
  501.              break;
  502.     case 2:  if (degrees) fmul(x,radeg,x);
  503.              if (hyp) ftanh(x,x);
  504.              else     ftan(x,x);
  505.              newx=TRUE;
  506.              break;
  507.     case 3:  if (lgbase>0)
  508.              {
  509.                  n=size(x);
  510.                  if (abs(n)<TOOBIG)
  511.                  {
  512.                      convert(lgbase,x);
  513.                      if (n<0) frecip(x,x);
  514.                      fpower(x,abs(n),x);
  515.                      newx=TRUE;
  516.                      break;
  517.                  }
  518.                  if (lgbase==2)  fmul(x,loge2,x);
  519.                  if (lgbase==10) fmul(x,loge10,x);
  520.              }
  521.              fexp(x,x);
  522.              newx=TRUE;
  523.              break;
  524.     case 4:  POINT=!POINT;
  525.              newx=TRUE;
  526.              break;
  527.     case 5:  clrall();
  528.              newx=TRUE;
  529.              break;
  530.     case 6:  return TRUE;
  531.     case 7:  if (hyp) fasinh(x,x);
  532.              else     fasin(x,x);
  533.              if (degrees) fdiv(x,radeg,x);
  534.              newx=TRUE;
  535.              break;
  536.     case 8:  if (hyp) facosh(x,x);
  537.              else     facos(x,x);
  538.              if (degrees) fdiv(x,radeg,x);
  539.              newx=TRUE;
  540.              break;
  541.     case 9:  if (hyp) fatanh(x,x);
  542.              else     fatan(x,x);
  543.              if (degrees) fdiv(x,radeg,x);
  544.              newx=TRUE;
  545.              break;
  546.     case 10: flog(x,x);
  547.              if (lgbase==2)  fdiv(x,loge2,x);
  548.              if (lgbase==10) fdiv(x,loge10,x);
  549.              newx=TRUE;
  550.              break;
  551.     case 11: newx=TRUE;
  552.              k=3;
  553.              forever
  554.              {
  555.                  aprint(INVER,2+stptr[k],2,settings[k][option[k]]);
  556.                  curser(2+stptr[k],2);
  557.                  c=arrow(gethit());
  558.                  if (c==1)
  559.                  {
  560.                      if (option[k]==nops[k]) option[k]=0;
  561.                      else option[k]+=1;
  562.                      continue;
  563.                  }
  564.                  aprint(STATCOL,2+stptr[k],2,settings[k][option[k]]);
  565.                  if (c==0 || c==2) break;
  566.                  if (c==4 && k>0) k--;
  567.                  if (c==3 && k<3) k++;
  568.              }
  569.              setopts();
  570.              break;
  571.     case 12: chekit(7);
  572.              break;
  573.     case 13: result=FALSE;
  574.              if (ipt==0) break;
  575.              ipt--;
  576.              mybuff[ipt]='\0';
  577.              if (ipt==0) clr();
  578.              just(mybuff);
  579.              strcpy(IBUFF,mybuff);
  580.              cinnum(x,stdin);
  581.              newx=TRUE;
  582.              break;
  583.     case 14: if (!next('7')) putchar(BELL);
  584.              break;
  585.     case 15: if (!next('8')) putchar(BELL);
  586.              break;
  587.     case 16: if (!next('9')) putchar(BELL);
  588.              break;
  589.     case 17: chekit(6);
  590.              break;
  591.     case 18: chekit(5);
  592.              break;
  593.     case 19: chekit(4);
  594.              break;
  595.     case 20: copy(m,x);
  596.              newx=TRUE;
  597.              break;
  598.     case 21: if (!next('4')) putchar(BELL);
  599.              break;
  600.     case 22: if (!next('5')) putchar(BELL);
  601.              break;
  602.     case 23: if (!next('6')) putchar(BELL);
  603.              break;
  604.     case 24: fmul(x,x,x);
  605.              newx=TRUE;
  606.              break;
  607.     case 25: froot(x,2,x);
  608.              newx=TRUE;
  609.              break;
  610.     case 26: chekit(3);
  611.              break;
  612.     case 27: brkt=0;
  613.              chekit(0);
  614.              flag=OFF;
  615.              fadd(m,x,m);
  616.              newx=TRUE;
  617.              break;
  618.     case 28: if (!next('1')) putchar(BELL);
  619.              break;
  620.     case 29: if (!next('2')) putchar(BELL);
  621.              break;
  622.     case 30: if (!next('3')) putchar(BELL);
  623.              break;
  624.     case 31: frecip(x,x);
  625.              newx=TRUE;
  626.              break;
  627.     case 32: fpi(x);
  628.              newx=TRUE;
  629.              break;
  630.     case 33: chekit(2);
  631.              break;
  632.     case 34: negate(x,x);
  633.              newx=TRUE;
  634.              break;
  635.     case 35: if (!next('0')) putchar(BELL);
  636.              break;
  637.     case 36: if (!next('/')) putchar(BELL);
  638.              break;
  639.     case 37: if (!next('.')) putchar(BELL);
  640.              break;
  641.     case 38: if (ipt>0)
  642.              {
  643.                  putchar(BELL);
  644.                  result=FALSE;
  645.              }
  646.              else
  647.              {
  648.                  zero(x);
  649.                  brkt+=1;
  650.                  newx=TRUE;
  651.              }
  652.              break;
  653.     case 39: if (brkt>0)
  654.              {
  655.                  chekit(0);
  656.                  brkt-=1;
  657.              }
  658.              else
  659.              {
  660.                  putchar(BELL);
  661.                  result=FALSE;
  662.              }
  663.              break;
  664.     case 40: chekit(1);
  665.              break;
  666.     case 41: brkt=0;
  667.              equals(0);
  668.              flag=OFF;
  669.              break;
  670.     }
  671.     return FALSE;
  672. }
  673.  
  674. main()
  675. { /*  MIRACL rational calculator */
  676.     int i,j,k,p,q,c,hpos;
  677.     bool over,help;
  678.     screen();
  679.     mirsys(10,MAXBASE);     /*** 16-bit computer ***/
  680. /*  mirsys(6,MAXBASE);           32-bit computer ***/
  681.     x=mirvar(0);
  682.     for (i=0;i<=top;i++) y[i]=mirvar(0);
  683.     m=mirvar(0);
  684.     t=mirvar(0);
  685.     radeg=mirvar(0);
  686.     loge2=mirvar(0);
  687.     loge10=mirvar(0);
  688.     strcpy(IBUFF,cpi);      /* read in constants */
  689.     cinnum(w15,stdin);
  690.     fpmul(w15,1,180,radeg);
  691.     strcpy(IBUFF,clg2);
  692.     cinnum(loge2,stdin);
  693.     strcpy(IBUFF,clg10);
  694.     cinnum(loge10,stdin);
  695.     help=OFF;
  696.     ERCON=TRUE;
  697.     STROUT=TRUE;
  698.     show(TRUE);
  699.     p=6;
  700.     q=0;
  701.     flag=OFF;
  702.     newx=OFF;
  703.     over=FALSE;
  704.     setopts();
  705.     clrall();
  706.     drawit();
  707.     while (!over)
  708.     { /* main loop */
  709.         if (ERNUM)
  710.         {
  711.             aprint(ORDINARY,4+5*p,6+3*q,keys[q][p]);
  712.             p=5,q=0;
  713.         }
  714.         if (width==80 || !help)
  715.         {
  716.             aprint(INVER,4+5*p,6+3*q,keys[q][p]);
  717.             curser(1,24);
  718.             c=gethit();
  719.             aprint(ORDINARY,4+5*p,6+3*q,keys[q][p]);
  720.         }
  721.         else while ((c=gethit())!='H');
  722.         result=TRUE;
  723.         if ((k=arrow(c))!=0)
  724.         { /* arrow key hit */
  725.             if (k==1 && q>0) q--;
  726.             if (k==2 && q<5) q++;
  727.             if (k==3 && p<6) p++;
  728.             if (k==4 && p>0) p--;
  729.             continue;
  730.         }
  731.         if (c=='H')
  732.         { /* switch help on/off */
  733.             help=!help;
  734.             for (i=1;i<=24;i++)
  735.             {
  736.                 if (width==80) hpos=41;
  737.                 else           hpos=1;
  738.                 if (help) aprint(HELPCOL,hpos,i,htext[i-1]);
  739.                 else lclr(hpos,i);
  740.             }
  741.             if (width==40 && !help) drawit();
  742.             continue;
  743.         }            
  744.         if (c>='A' && c<='F')
  745.         { /* hex only */
  746.             if (!next(c)) putchar(BELL);
  747.             else show(FALSE);
  748.             continue;
  749.         }
  750.         for (j=0;j<6;j++)
  751.             for (i=0;i<7;i++)
  752.                 if (c==qkeys[j][i]) p=i,q=j,c=' ';
  753.         if (c==8 || c==127) p=6,q=1,c=' ';       /* aliases */
  754.         if (c==',' || c=='a') p=5,q=5,c=' ';
  755.         if (c=='O') p=6,q=0,c=' ';
  756.         if (c==13)  p=6,q=5,c=' ';
  757.         if (c=='[' || c=='{') p=3,q=5,c=' ';
  758.         if (c==']' || c=='}') p=4,q=5,c=' ';
  759.         if (c=='d') p=5,q=2,c=' ';
  760.         if (c=='b') p=5,q=3,c=' ';
  761.         if (c==' ') over=act(p,q);
  762.         else        continue;
  763.         if (result)
  764.         { /* output result to display */
  765.             cotnum(x,stdout);
  766.             just(OBUFF);
  767.             if (ERNUM<0)
  768.             { /* convert to radix and try again */
  769.                 ERNUM=0;
  770.                 POINT=ON;
  771.                 cotnum(x,stdout);
  772.                 putchar(BELL);
  773.                 just(OBUFF);
  774.             }
  775.             clr();
  776.         }
  777.         if (newx)
  778.         { /* update display */
  779.             getstat();
  780.             show(FALSE);
  781.         }
  782.     }
  783.     curser(1,24);
  784.     restore();
  785. }
  786.