home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / bcalcs / bigcalc.c next >
Encoding:
C/C++ Source or Header  |  1989-02-04  |  45.5 KB  |  2,179 lines
  1. /*
  2.  *    **************************************************
  3.  *    *                                                *
  4.  *    *                   BIGCALC.C                    *
  5.  *    *                                                *
  6.  *    *          Extended Precision Calculator         *
  7.  *    *                                                *
  8.  *    *                  Main Module                   *
  9.  *    *                                                *
  10.  *    *              Version 4.3 02-04-89              *
  11.  *    *                                                *
  12.  *    *              Judson D. McClendon               *
  13.  *    *              329 37th Court N.E.               *
  14.  *    *              Birmingham, AL 35215              *
  15.  *    *                 205-853-8440                   *
  16.  *    *            Compuserve [74415,1003]             *
  17.  *    *                                                *
  18.  *    **************************************************
  19.  */
  20.  
  21.  
  22.  
  23. /*
  24.  *    **************************************************
  25.  *    *                                                *
  26.  *    *                   Includes                     *
  27.  *    *                                                *
  28.  *    **************************************************
  29.  */
  30.  
  31. #include <ctype.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  35. #include "bigcalc.h"
  36.  
  37.  
  38.  
  39. /*
  40.  *    **************************************************
  41.  *    *                                                *
  42.  *    *           Global Variable Definition           *
  43.  *    *                                                *
  44.  *    **************************************************
  45.  */
  46.  
  47. NORMTYPE
  48.    stack[4],               /* Stack registers  */
  49.    reg[10],                /* Memory registers */
  50.    lastx;                  /* Last X register  */
  51.  
  52. WORKTYPE
  53.    work[3];                /* Work registers   */
  54.  
  55. int
  56.    normprec = 0,           /* Normal precision  */
  57.    compprec = 0,           /* Compute precision */
  58.    workprec = 0,           /* Work precision    */
  59.    groupsize = 0,          /* Digit group size  */
  60.    entrysignrow,           /* Row for X entry   */
  61.    menunbr = 0,            /* Menu number       */
  62.    chr = 0;                /* Input Character   */
  63.  
  64. long
  65.    minfloatprn,            /* Min exp for float */
  66.    maxfloatprn;            /* Max exp for float */
  67.  
  68. FILE
  69.    *printfile;             /* Print file handle */
  70.  
  71. char
  72.    stackname[4]            /* Stack register names */
  73.       = {'X','Y','Z','T'},
  74.    printid[15]             /* Print file name      */
  75.       = "Printer";
  76.  
  77. BOOLEAN
  78.    stacklift = TRUE,       /* Lift stack for new X if TRUE */
  79.    scinotation = FALSE,    /* Force sci notation if TRUE   */
  80.    charpresent = FALSE,    /* Character present if TRUE    */
  81.    menucleared = TRUE,     /* Screen menu cleared if TRUE  */
  82.    printtoscreen = FALSE;  /* Print to screen if TRUE      */
  83.  
  84.  
  85.  
  86. /*
  87.  *    **************************************************
  88.  *    *                                                *
  89.  *    *                     Main                       *
  90.  *    *                                                *
  91.  *    **************************************************
  92.  */
  93.  
  94. extern void main(int argc,char *argv[])
  95.  
  96. {
  97.  
  98.    Initialize(argc, argv[1]);
  99.  
  100.    chr = GetPrompt();
  101.  
  102.    while (chr != ESCAPE) {
  103.  
  104.       switch (chr) {
  105.  
  106.          case (ADD):
  107.             Add();               /* Add Y + X */
  108.             break;
  109.  
  110.          case (SUBTRACT):
  111.             Subtract();          /* Subtract Y - X */
  112.             break;
  113.  
  114.          case (MULTIPLY):
  115.             Multiply();          /* Multiply Y * X */
  116.             break;
  117.  
  118.          case (DIVIDE):
  119.             Divide();            /* Divide Y / X */
  120.             break;
  121.  
  122.          case (HELP):
  123.             HelpScreen();        /* Help Screen */
  124.             break;
  125.  
  126.          case (POWER):
  127.             Power();             /* Power (Y^X) */
  128.             break;
  129.  
  130.          case (SQUAREROOT):
  131.             SquareRoot();        /* Square Root X */
  132.             break;
  133.  
  134.          case (SQUARE):
  135.             Square();            /* Square X */
  136.             break;
  137.  
  138.          case (RECIPROCAL):
  139.             Reciprocal();        /* Reciprocal X */
  140.             break;
  141.  
  142.          case (FACTORIAL):
  143.             Factorial();         /* Factorial X */
  144.             break;
  145.  
  146.          case (INTEGER):
  147.             IntegerPart();       /* Integer Part X */
  148.             break;
  149.  
  150.          case (FRACTION):
  151.             FractionPart();      /* Fraction Part X */
  152.             break;
  153.  
  154.          case (SIN):
  155.             Sin();               /* Sine X */
  156.             break;
  157.  
  158.          case (ARCSIN):
  159.             ArcSin();            /* ArcSine X */
  160.             break;
  161.  
  162.          case (COS):
  163.             Cos();               /* Cosine X */
  164.             break;
  165.  
  166.          case (ARCCOS):
  167.             ArcCos();            /* ArcCosine X */
  168.             break;
  169.  
  170.          case (TAN):
  171.             Tan();               /* Tangent X */
  172.             break;
  173.  
  174.          case (ARCTAN):
  175.             ArcTan();            /* ArcTangent X */
  176.             break;
  177.  
  178.          case (LOG):
  179.             Log();               /* Common Log X */
  180.             break;
  181.  
  182.          case (EXP10):
  183.             Exp10();             /* Exponent 10^X */
  184.             break;
  185.  
  186.          case (LN):
  187.             Ln();                /* Natural Log X */
  188.             break;
  189.  
  190.          case (EXPE):
  191.             ExpE();              /* Exponent e^X */
  192.             break;
  193.  
  194.          case (RECALLPI):
  195.             RecallPi();          /* Recall pi */
  196.             break;
  197.  
  198.          case (RECALLE):
  199.             RecallE();           /* Recall e */
  200.             break;
  201.  
  202.          case (LASTX):
  203.             RecallLastX();       /* Recall Last X */
  204.             break;
  205.  
  206.          case (CHGSIGN):
  207.             ChangeSign();        /* Change sign X */
  208.             break;
  209.  
  210.          case (PRINTDISK):
  211.             PrintDisk();         /* Toggle Print to Disk */
  212.             break;
  213.  
  214.          case (GROUPSIZE):
  215.             GroupSize();         /* Toggle Group Size (3/5) */
  216.             break;
  217.  
  218.          case (MENUROLL):
  219.             MenuRoll();          /* Roll Function Key Menu */
  220.             break;
  221.  
  222.          case (VIEWREG):
  223.             ViewReg();           /* View Register on Screen */
  224.             break;
  225.  
  226.          case ('0'):
  227.          case ('1'):
  228.          case ('2'):
  229.          case ('3'):
  230.          case ('4'):
  231.          case ('5'):
  232.          case ('6'):
  233.          case ('7'):
  234.          case ('8'):
  235.          case ('9'):
  236.          case ('.'):
  237.          case ('E'):
  238.             AcceptX();           /* Accept new X from keyboard with first */
  239.             break;               /*  character passed to AcceptX routine */
  240.  
  241.          case (CLEARX):
  242.             ClearX();            /* Clear X to zero */
  243.             break;
  244.  
  245.          case (ENTER):
  246.             Enter();             /* Push up stack */
  247.             break;
  248.  
  249.          case (SCINOT):
  250.             SciNotation();       /* Use Scientific Notation */
  251.             break;
  252.  
  253.          case (CLEAR):
  254.             Clear();             /* Clear (prompt for what) */
  255.             break;
  256.  
  257.          case (PRINT):
  258.             Print();             /* Print on printer (prompt for what) */
  259.             break;
  260.  
  261.          case (STOREX):
  262.             StoreX();            /* Store X in register (prompt for which) */
  263.             break;
  264.  
  265.          case (RECALLREG):
  266.             RecallReg();         /* Recall register to X (prompt for which) */
  267.             break;
  268.  
  269.          case (XCHGXY1):
  270.          case (XCHGXY2):
  271.             ExchangeXY();        /* Exchange X and Y */
  272.             break;
  273.  
  274.          case (XCHGXREG):
  275.             ExchangeXReg();      /* Exchange X and Reg (prompt for which) */
  276.             break;
  277.  
  278.          case (ROLLDOWN):
  279.             RollDown();          /* Roll stack down */
  280.             break;
  281.  
  282.          case (ROLLUP):
  283.             RollUp();            /* Roll stack up */
  284.             break;
  285.  
  286.          default:
  287.             Beep();              /* Unknown key */
  288.  
  289.          }  /* end switch */
  290.  
  291.       flushall();
  292.  
  293.       chr = GetPrompt();
  294.  
  295.       }  /* while */
  296.  
  297.  
  298.    ScrTerm();
  299.  
  300.    exit(0);
  301.  
  302. }
  303.  
  304.  
  305.  
  306.  
  307.  
  308. /*
  309.  *    **************************************************
  310.  *    *                                                *
  311.  *    *              Initialize Variables              *
  312.  *    *                                                *
  313.  *    **************************************************
  314.  */
  315.  
  316. static void Initialize(int argc, char *argv)
  317.  
  318. {
  319.  
  320.    ScrInit();                    /* Initialize screen drivers */
  321.  
  322.    if (argc > 1)
  323.       while (*argv) {            /* Convert *argv to number */
  324.          if (isdigit(*argv)) {
  325.             normprec = (normprec * 10) + (*argv - '0');
  326.             if (normprec <= MAXNORM)
  327.                argv++;
  328.                continue;
  329.             }
  330.          normprec = 0;
  331.          break;
  332.          }
  333.  
  334.    if ( (normprec < MINPREC)
  335.          ||
  336.         (normprec > MAXNORM) )
  337.       normprec = DEFAULTPREC;
  338.  
  339.    compprec = COMPPREC;
  340.    workprec = WORKPREC;
  341.  
  342.    ClearStack(0, 3);             /* Initialize work areas */
  343.    ClearReg(0, 9);
  344.    lastx = stack[0];
  345.    printfile = stdprn;
  346.                                  /* Allow full screen entry for big numbers */
  347.    if (normprec > SIZEOFSMALL)
  348.       entrysignrow = ENTRYSIGNROWBIG;
  349.    else
  350.       entrysignrow = ENTRYSIGNROWSMALL;
  351.  
  352.    GroupSize();                  /* Toggle group size to 5 & set xxxfloatprn */
  353.  
  354.    InitialScreen();              /* Welcome screen */
  355.  
  356. }
  357.  
  358.  
  359.  
  360.  
  361. /*
  362.  *    **************************************************
  363.  *    *                                                *
  364.  *    *                Process Routines                *
  365.  *    *                                                *
  366.  *    **************************************************
  367.  */
  368.  
  369.  
  370.  
  371. /*
  372.  *    **************************************************
  373.  *    *                                                *
  374.  *    *                 Add X = Y + X                  *
  375.  *    *                                                *
  376.  *    **************************************************
  377.  */
  378.  
  379. static void Add(void)
  380.  
  381. {
  382.  
  383.    MoveStackWork(0, 0);
  384.    MoveStackWork(1, 1);
  385.  
  386.    if (ExtendedAdd() ) {
  387.       lastx = stack[0];
  388.       DropStack();
  389.       MoveWorkStack(2, 0);
  390.       WriteStack(0, 2);
  391.       stacklift = TRUE;
  392.       }
  393.  
  394. }
  395.  
  396.  
  397.  
  398.  
  399. /*
  400.  *    **************************************************
  401.  *    *                                                *
  402.  *    *              Subtract X = Y - X                *
  403.  *    *                                                *
  404.  *    **************************************************
  405.  */
  406.  
  407. static void Subtract(void)
  408.  
  409. {
  410.  
  411.    MoveStackWork(0, 0);
  412.    MoveStackWork(1, 1);
  413.  
  414.    if (ExtendedSubtract() ) {
  415.       lastx = stack[0];
  416.       DropStack();
  417.       MoveWorkStack(2, 0);
  418.       WriteStack(0, 2);
  419.       stacklift = TRUE;
  420.       }
  421.  
  422. }
  423.  
  424.  
  425.  
  426.  
  427. /*
  428.  *    **************************************************
  429.  *    *                                                *
  430.  *    *              Multiply X = Y * X                *
  431.  *    *                                                *
  432.  *    **************************************************
  433.  */
  434.  
  435. static void Multiply(void)
  436.  
  437. {
  438.  
  439.    MessageEsc("Multiplying");
  440.  
  441.    MoveStackWork(0, 0);
  442.    MoveStackWork(1, 1);
  443.  
  444.    if (ExtendedMultiply() ) {
  445.       lastx = stack[0];
  446.       DropStack();
  447.       MoveWorkStack(2, 0);
  448.       WriteStack(0, 2);
  449.       stacklift = TRUE;
  450.       }
  451.  
  452. }
  453.  
  454.  
  455.  
  456.  
  457. /*
  458.  *    **************************************************
  459.  *    *                                                *
  460.  *    *               Divide X = Y / X                 *
  461.  *    *                                                *
  462.  *    **************************************************
  463.  */
  464.  
  465. static void Divide(void)
  466.  
  467. {
  468.  
  469.    MessageEsc("Dividing");
  470.  
  471.    MoveStackWork(0, 0);
  472.    MoveStackWork(1, 1);
  473.  
  474.    if (ExtendedDivide() ) {
  475.       lastx = stack[0];
  476.       DropStack();
  477.       MoveWorkStack(2, 0);
  478.       WriteStack(0, 2);
  479.       stacklift = TRUE;
  480.       }
  481.  
  482. }
  483.  
  484.  
  485.  
  486.  
  487. /*
  488.  *    **************************************************
  489.  *    *                                                *
  490.  *    *                  Power (Y^X)                   *
  491.  *    *                                                *
  492.  *    **************************************************
  493.  */
  494.  
  495. static void Power(void)
  496.  
  497. {
  498.  
  499.    MessageEsc("Computing Y^X");
  500.  
  501.    MoveStackWork(0, 0);
  502.    MoveStackWork(1, 1);
  503.  
  504.    if (ExtendedPower() ) {
  505.       if (ExtendedRound(2)) {
  506.          lastx = stack[0];
  507.          DropStack();
  508.          MoveWorkStack(2, 0);
  509.          WriteStack(0, 2);
  510.          stacklift = TRUE;
  511.          }
  512.       }
  513.  
  514. }
  515.  
  516.  
  517.  
  518.  
  519. /*
  520.  *    **************************************************
  521.  *    *                                                *
  522.  *    *               Square Root of X                 *
  523.  *    *                                                *
  524.  *    **************************************************
  525.  */
  526.  
  527. static void SquareRoot(void)
  528.  
  529. {
  530.  
  531.    MessageEsc("Computing √X");
  532.  
  533.    MoveStackWork(0, 0);
  534.    if (ExtendedSquareRoot() ) {
  535.       lastx = stack[0];
  536.       MoveWorkStack(2, 0);
  537.       WriteStack(0, 0);
  538.       stacklift = TRUE;
  539.       }
  540.  
  541. }
  542.  
  543.  
  544.  
  545.  
  546. /*
  547.  *    **************************************************
  548.  *    *                                                *
  549.  *    *                 Square of X                    *
  550.  *    *                                                *
  551.  *    **************************************************
  552.  */
  553.  
  554. static void Square(void)
  555.  
  556. {
  557.  
  558.    MessageEsc("Computing X²");
  559.  
  560.    MoveStackWork(0, 0);
  561.    MoveStackWork(0, 1);
  562.  
  563.    if (ExtendedMultiply() ) {
  564.       lastx = stack[0];
  565.       MoveWorkStack(2, 0);
  566.       WriteStack(0, 0);
  567.       stacklift = TRUE;
  568.       }
  569.  
  570. }
  571.  
  572.  
  573.  
  574.  
  575. /*
  576.  *    **************************************************
  577.  *    *                                                *
  578.  *    *                Reciprocal of X                 *
  579.  *    *                                                *
  580.  *    **************************************************
  581.  */
  582.  
  583. static void Reciprocal(void)
  584.  
  585. {
  586.  
  587.    MessageEsc("Computing 1/X");
  588.  
  589.    MoveStackWork(0, 0);
  590.  
  591.    if (ExtendedReciprocal() ) {
  592.       lastx = stack[0];
  593.       MoveWorkStack(2, 0);
  594.       WriteStack(0, 0);
  595.       stacklift = TRUE;
  596.       }
  597.  
  598. }
  599.  
  600.  
  601.  
  602.  
  603. /*
  604.  *    **************************************************
  605.  *    *                                                *
  606.  *    *                Factorial of X                  *
  607.  *    *                                                *
  608.  *    **************************************************
  609.  */
  610.  
  611. static void Factorial(void)
  612.  
  613. {
  614.  
  615.    MessageEsc("Computing X!");
  616.  
  617.    MoveStackWork(0, 0);
  618.  
  619.    if (ExtendedFactorial() ) {
  620.       lastx = stack[0];
  621.       MoveWorkStack(2, 0);
  622.       WriteStack(0, 0);
  623.       stacklift = TRUE;
  624.       }
  625.  
  626. }
  627.  
  628.  
  629.  
  630.  
  631. /*
  632.  *    **************************************************
  633.  *    *                                                *
  634.  *    *           Extract Integer Part of X            *
  635.  *    *                                                *
  636.  *    **************************************************
  637.  */
  638.  
  639. static void IntegerPart(void)
  640.  
  641. {
  642.  
  643.    MoveStackWork(0, 0);
  644.  
  645.    if (ExtendedIntegerPart() ) {
  646.       lastx = stack[0];
  647.       MoveWorkStack(0, 0);
  648.       WriteStack(0, 0);
  649.       stacklift = TRUE;
  650.       }
  651.  
  652. }
  653.  
  654.  
  655.  
  656.  
  657. /*
  658.  *    **************************************************
  659.  *    *                                                *
  660.  *    *          Extract Fraction Part of X            *
  661.  *    *                                                *
  662.  *    **************************************************
  663.  */
  664.  
  665. static void FractionPart(void)
  666.  
  667. {
  668.  
  669.    MoveStackWork(0, 0);
  670.  
  671.    if (ExtendedFractionPart() ) {
  672.       lastx = stack[0];
  673.       MoveWorkStack(0, 0);
  674.       WriteStack(0, 0);
  675.       stacklift = TRUE;
  676.       }
  677.  
  678. }
  679.  
  680.  
  681.  
  682.  
  683. /*
  684.  *    **************************************************
  685.  *    *                                                *
  686.  *    *                   Sine of X                    *
  687.  *    *                                                *
  688.  *    **************************************************
  689.  */
  690.  
  691. static void Sin(void)
  692.  
  693. {
  694.  
  695.    MessageEsc("Computing SinX");
  696.  
  697.    MoveStackWork(0, 0);
  698.  
  699.    if (ExtendedSinCos(0) ) {
  700.       lastx = stack[0];
  701.       MoveWorkStack(2, 0);
  702.       WriteStack(0, 0);
  703.       stacklift = TRUE;
  704.       }
  705.  
  706. }
  707.  
  708.  
  709.  
  710.  
  711. /*
  712.  *    **************************************************
  713.  *    *                                                *
  714.  *    *                 ArcSine of X                   *
  715.  *    *                                                *
  716.  *    **************************************************
  717.  */
  718.  
  719. static void ArcSin(void)
  720.  
  721. {
  722.  
  723.    MessageEsc("Computing ArcSinX");
  724.  
  725.    MoveStackWork(0, 0);
  726.  
  727.    if (ExtendedArcSinCos(0) ) {
  728.       lastx = stack[0];
  729.       MoveWorkStack(2, 0);
  730.       WriteStack(0, 0);
  731.       stacklift = TRUE;
  732.       }
  733.  
  734. }
  735.  
  736.  
  737.  
  738.  
  739. /*
  740.  *    **************************************************
  741.  *    *                                                *
  742.  *    *                  Cosine of X                   *
  743.  *    *                                                *
  744.  *    **************************************************
  745.  */
  746.  
  747. static void Cos(void)
  748.  
  749. {
  750.  
  751.    MessageEsc("Computing CosX");
  752.  
  753.    MoveStackWork(0, 0);
  754.  
  755.    if (ExtendedSinCos(1) ) {
  756.       lastx = stack[0];
  757.       MoveWorkStack(2, 0);
  758.       WriteStack(0, 0);
  759.       stacklift = TRUE;
  760.       }
  761.  
  762. }
  763.  
  764.  
  765.  
  766.  
  767. /*
  768.  *    **************************************************
  769.  *    *                                                *
  770.  *    *                ArcCosine of X                  *
  771.  *    *                                                *
  772.  *    **************************************************
  773.  */
  774.  
  775. static void ArcCos(void)
  776.  
  777. {
  778.  
  779.    MessageEsc("Computing ArcCosX");
  780.  
  781.    MoveStackWork(0, 0);
  782.  
  783.    if (ExtendedArcSinCos(1) ) {
  784.       lastx = stack[0];
  785.       MoveWorkStack(2, 0);
  786.       WriteStack(0, 0);
  787.       stacklift = TRUE;
  788.       }
  789.  
  790. }
  791.  
  792.  
  793.  
  794.  
  795. /*
  796.  *    **************************************************
  797.  *    *                                                *
  798.  *    *                 Tangent of X                   *
  799.  *    *                                                *
  800.  *    **************************************************
  801.  */
  802.  
  803. static void Tan(void)
  804.  
  805. {
  806.  
  807.    MessageEsc("Computing TanX");
  808.  
  809.    MoveStackWork(0, 0);
  810.  
  811.    if (ExtendedTan() ) {
  812.       lastx = stack[0];
  813.       MoveWorkStack(2, 0);
  814.       WriteStack(0, 0);
  815.       stacklift = TRUE;
  816.       }
  817.  
  818. }
  819.  
  820.  
  821.  
  822.  
  823. /*
  824.  *    **************************************************
  825.  *    *                                                *
  826.  *    *                ArcTangent of X                 *
  827.  *    *                                                *
  828.  *    **************************************************
  829.  */
  830.  
  831. static void ArcTan(void)
  832.  
  833. {
  834.  
  835.    MessageEsc("Computing ArcTanX");
  836.  
  837.    MoveStackWork(0, 0);
  838.  
  839.    if (ExtendedArcTan() ) {
  840.       lastx = stack[0];
  841.       MoveWorkStack(2, 0);
  842.       WriteStack(0, 0);
  843.       stacklift = TRUE;
  844.       }
  845.  
  846. }
  847.  
  848.  
  849.  
  850.  
  851. /*
  852.  *    **************************************************
  853.  *    *                                                *
  854.  *    *              Common Logarithm of X             *
  855.  *    *                                                *
  856.  *    **************************************************
  857.  */
  858.  
  859. static void Log(void)
  860.  
  861. {
  862.  
  863.    MessageEsc("Computing LogX");
  864.  
  865.    MoveStackWork(0, 0);
  866.  
  867.    if (ExtendedLog() ) {
  868.       lastx = stack[0];
  869.       MoveWorkStack(2, 0);
  870.       WriteStack(0, 0);
  871.       stacklift = TRUE;
  872.       }
  873.  
  874. }
  875.  
  876.  
  877.  
  878.  
  879. /*
  880.  *    **************************************************
  881.  *    *                                                *
  882.  *    *           Common Antilogarithm of X            *
  883.  *    *                                                *
  884.  *    **************************************************
  885.  */
  886.  
  887. static void Exp10(void)
  888.  
  889. {
  890.  
  891.    MessageEsc("Computing 10^X");
  892.  
  893.    MoveStackWork(0, 0);
  894.  
  895.    if (ExtendedExp10() ) {
  896.       lastx = stack[0];
  897.       MoveWorkStack(2, 0);
  898.       WriteStack(0, 0);
  899.       stacklift = TRUE;
  900.       }
  901.  
  902. }
  903.  
  904.  
  905.  
  906.  
  907. /*
  908.  *    **************************************************
  909.  *    *                                                *
  910.  *    *             Natural Logarithm of X             *
  911.  *    *                                                *
  912.  *    **************************************************
  913.  */
  914.  
  915. static void Ln(void)
  916.  
  917. {
  918.  
  919.    MessageEsc("Computing lnX");
  920.  
  921.    MoveStackWork(0, 0);
  922.  
  923.    if (ExtendedLn() ) {
  924.       lastx = stack[0];
  925.       MoveWorkStack(2, 0);
  926.       WriteStack(0, 0);
  927.       stacklift = TRUE;
  928.       }
  929.  
  930. }
  931.  
  932.  
  933.  
  934.  
  935. /*
  936.  *    **************************************************
  937.  *    *                                                *
  938.  *    *          Natural Antilogarithm of X            *
  939.  *    *                                                *
  940.  *    **************************************************
  941.  */
  942.  
  943. static void ExpE(void)
  944.  
  945. {
  946.  
  947.    MessageEsc("Computing e^X");
  948.  
  949.    MoveStackWork(0, 0);
  950.  
  951.    if (ExtendedExpE() ) {
  952.       lastx = stack[0];
  953.       MoveWorkStack(2, 0);
  954.       WriteStack(0, 0);
  955.       stacklift = TRUE;
  956.       }
  957.  
  958. }
  959.  
  960.  
  961.  
  962.  
  963. /*
  964.  *    **************************************************
  965.  *    *                                                *
  966.  *    *                Recall pi to X                  *
  967.  *    *                                                *
  968.  *    **************************************************
  969.  */
  970.  
  971. static void RecallPi(void)
  972.  
  973. {
  974.  
  975.    if (stacklift) {
  976.       PushStack();
  977.       WriteStack(1, 3);
  978.       }
  979.  
  980.    ExtendedRecallPi(0);
  981.    MoveWorkStack(0, 0);
  982.    WriteStack(0, 0);
  983.    stacklift = TRUE;
  984.  
  985. }
  986.  
  987.  
  988.  
  989.  
  990. /*
  991.  *    **************************************************
  992.  *    *                                                *
  993.  *    *                Recall e to X                   *
  994.  *    *                                                *
  995.  *    **************************************************
  996.  */
  997.  
  998. static void RecallE(void)
  999.  
  1000. {
  1001.  
  1002.    if (stacklift) {
  1003.       PushStack();
  1004.       WriteStack(1, 3);
  1005.       }
  1006.  
  1007.    ExtendedRecallE(0);
  1008.    MoveWorkStack(0, 0);
  1009.    WriteStack(0, 0);
  1010.    stacklift = TRUE;
  1011.  
  1012. }
  1013.  
  1014.  
  1015.  
  1016.  
  1017. /*
  1018.  *    **************************************************
  1019.  *    *                                                *
  1020.  *    *                Recall Last X                   *
  1021.  *    *                                                *
  1022.  *    **************************************************
  1023.  */
  1024.  
  1025. static void RecallLastX(void)
  1026.  
  1027. {
  1028.  
  1029.    if (stacklift) {
  1030.       PushStack();
  1031.       WriteStack(1, 3);
  1032.       }
  1033.  
  1034.    stack[0] = lastx;
  1035.    WriteStack(0, 0);
  1036.    stacklift = TRUE;
  1037.  
  1038. }
  1039.  
  1040.  
  1041.  
  1042.  
  1043. /*
  1044.  *    **************************************************
  1045.  *    *                                                *
  1046.  *    *               Change Sign of X                 *
  1047.  *    *                                                *
  1048.  *    **************************************************
  1049.  */
  1050.  
  1051. static void ChangeSign(void)
  1052.  
  1053. {
  1054.  
  1055.    if (stack[0].digits) {        /* Only if X non zero */
  1056.       stack[0].sign = FlipSign(stack[0].sign);
  1057.       CurPos(XSIGNROW, SIGNDISPCOL);
  1058.       if (stack[0].sign == '-')
  1059.          WChar('-');
  1060.       else
  1061.          WChar(' ');
  1062.       }
  1063.  
  1064.    stacklift = TRUE;
  1065.  
  1066. }
  1067.  
  1068.  
  1069.  
  1070.  
  1071. /*
  1072.  *    **************************************************
  1073.  *    *                                                *
  1074.  *    *              Toggle Print to Disk              *
  1075.  *    *                                                *
  1076.  *    **************************************************
  1077.  */
  1078.  
  1079. static void PrintDisk(void)
  1080.  
  1081. {
  1082.  
  1083.    if (printid[0] == 'B') {
  1084.       fclose(printfile);                  /* BIGCALC.PRN open, close */
  1085.       strcpy(printid, "Printer");         /*  and switch to printer  */
  1086.       printfile = stdprn;
  1087.       }
  1088.    else {                                 /* Open BIGCALC.PRN */
  1089.       strcpy(printid, "BIGCALC.PRN");
  1090.       if ((printfile = fopen(printid, "ab")) == NULL) {
  1091.          strcpy(printid, "Printer");
  1092.          printfile = stdprn;
  1093.          MessageWait("** Cannot open disk file **");
  1094.          }
  1095.       }
  1096.  
  1097.    Heading2();
  1098.  
  1099. }
  1100.  
  1101.  
  1102.  
  1103.  
  1104. /*
  1105.  *    **************************************************
  1106.  *    *                                                *
  1107.  *    *             Toggle Group Size (3/5)            *
  1108.  *    *                                                *
  1109.  *    **************************************************
  1110.  */
  1111.  
  1112. static void GroupSize(void)
  1113.  
  1114. {
  1115.  
  1116.    BOOLEAN flag;
  1117.  
  1118.    if (groupsize)             /* First time thru groupsize == 0 */
  1119.       flag = TRUE;
  1120.    else
  1121.       flag = FALSE;
  1122.  
  1123.    if (groupsize == 5) {
  1124.       groupsize = 3;
  1125.       minfloatprn = (long)normprec - 1077L;
  1126.       maxfloatprn = 1080L;
  1127.       }
  1128.    else {
  1129.       groupsize = 5;
  1130.       minfloatprn = (long)normprec - 1195L;
  1131.       maxfloatprn = 1200L;
  1132.       }
  1133.  
  1134.    if (flag)
  1135.       Heading2();
  1136.  
  1137. }
  1138.  
  1139.  
  1140.  
  1141.  
  1142. /*
  1143.  *    **************************************************
  1144.  *    *                                                *
  1145.  *    *             Roll Function Key Menu             *
  1146.  *    *                                                *
  1147.  *    **************************************************
  1148.  */
  1149.  
  1150. static void MenuRoll(void)
  1151.  
  1152. {
  1153.  
  1154.    menunbr = 1 - menunbr;     /* Toggle menunbr 0/1 */
  1155.  
  1156.    OnScreenMenu();
  1157.  
  1158. }
  1159.  
  1160.  
  1161.  
  1162.  
  1163. /*
  1164.  *    **************************************************
  1165.  *    *                                                *
  1166.  *    *             View Register on Screen            *
  1167.  *    *                                                *
  1168.  *    **************************************************
  1169.  */
  1170.  
  1171. static void ViewReg(void)
  1172.  
  1173. {
  1174.  
  1175.    int r;
  1176.  
  1177.    Message("Press to view (X,Y,Z,T, 0-9, Esc=Exit):");
  1178.  
  1179.    while ((chr = GetChar()) != ESCAPE) {
  1180.  
  1181.       switch (chr) {
  1182.  
  1183.          case ('X'):
  1184.             DisplayStack(0);
  1185.             return;
  1186.  
  1187.          case ('Y'):
  1188.             DisplayStack(1);
  1189.             return;
  1190.  
  1191.          case ('Z'):
  1192.             DisplayStack(2);
  1193.             return;
  1194.  
  1195.          case ('T'):
  1196.             DisplayStack(3);
  1197.             return;
  1198.  
  1199.          case ('0'):
  1200.          case ('1'):
  1201.          case ('2'):
  1202.          case ('3'):
  1203.          case ('4'):
  1204.          case ('5'):
  1205.          case ('6'):
  1206.          case ('7'):
  1207.          case ('8'):
  1208.          case ('9'):
  1209.             r = chr - '0';
  1210.             DisplayReg(r);
  1211.             return;
  1212.  
  1213.          default:
  1214.             Beep();
  1215.  
  1216.          }  /* switch */
  1217.  
  1218.       }  /* while */
  1219.  
  1220. }
  1221.  
  1222.  
  1223.  
  1224.  
  1225. /*
  1226.  *    **************************************************
  1227.  *    *                                                *
  1228.  *    *               Accept X from KBD                *
  1229.  *    *                                                *
  1230.  *    **************************************************
  1231.  */
  1232.  
  1233. static void AcceptX(void)
  1234.  
  1235. {
  1236.  
  1237.    NORMTYPE *temp;
  1238.  
  1239.    if ((temp = GETNORMTEMP(1)) == NULL) {
  1240.       MemoryError();
  1241.       return;
  1242.       }
  1243.  
  1244.    CurPos(entrysignrow, 1);      /* Clear area to enter new X */
  1245.    EraEop();
  1246.    menucleared = TRUE;
  1247.    WriteAt(entrysignrow, 1, "X:");
  1248.    Message("Entering X: S=ChgSign, E=Exp, BakSpc=Backup, Other=Complete,"
  1249.            " ESC=Exit");
  1250.  
  1251.    if (normprec > SIZEOFSMALL) {
  1252.  
  1253.       CurPos(entrysignrow - 1, 1);  /* Big numbers, use full screen */
  1254.       EraEol();
  1255.       WriteAt(entrysignrow - 1, 1, "========================="
  1256.                                    "  E N T E R I N G   X  "
  1257.                                    "=========================");
  1258.       if (ExtendedGetX() ) {
  1259.           if (stacklift)
  1260.              PushStack();
  1261.          MoveWorkStack(0, 0);
  1262.          stacklift = TRUE;
  1263.          }
  1264.       WorkScreen();
  1265.       }
  1266.  
  1267.    else {
  1268.  
  1269.       if (stacklift) {              /* Small numbers, use bottom of screen */
  1270.          *temp = stack[3];
  1271.          PushStack();
  1272.          WriteStack(1, 3);
  1273.          }
  1274.       if (ExtendedGetX() ) {
  1275.          MoveWorkStack(0, 0);
  1276.          stacklift = TRUE;
  1277.          }
  1278.       else
  1279.          if (stacklift) {
  1280.             DropStack();
  1281.             stack[3] = *temp;
  1282.             WriteStack(1, 3);
  1283.          }
  1284.       CurPos(entrysignrow, SIGNDISPCOL);
  1285.       EraEop();
  1286.       WriteStack(0, 0);
  1287.       }
  1288.  
  1289.    free(temp);
  1290.  
  1291. }
  1292.  
  1293.  
  1294.  
  1295.  
  1296. /*
  1297.  *    **************************************************
  1298.  *    *                                                *
  1299.  *    *                    Clear X                     *
  1300.  *    *                                                *
  1301.  *    **************************************************
  1302.  */
  1303.  
  1304. static void ClearX(void)
  1305.  
  1306. {
  1307.  
  1308.    ClearStack(0, 0);
  1309.    WriteStack(0, 0);
  1310.    stacklift = FALSE;
  1311.  
  1312. }
  1313.  
  1314.  
  1315.  
  1316.  
  1317. /*
  1318.  *    **************************************************
  1319.  *    *                                                *
  1320.  *    *                    Enter                       *
  1321.  *    *                                                *
  1322.  *    **************************************************
  1323.  */
  1324.  
  1325. static void Enter(void)
  1326.  
  1327. {
  1328.  
  1329.    PushStack();
  1330.    WriteStack(1, 3);
  1331.    stacklift = FALSE;
  1332.  
  1333. }
  1334.  
  1335.  
  1336.  
  1337.  
  1338. /*
  1339.  *    **************************************************
  1340.  *    *                                                *
  1341.  *    *          Toggle Scientific Notation            *
  1342.  *    *                                                *
  1343.  *    **************************************************
  1344.  */
  1345.  
  1346. static void SciNotation(void)
  1347.  
  1348. {
  1349.  
  1350.    if (scinotation)
  1351.       scinotation = FALSE;
  1352.    else
  1353.       scinotation = TRUE;
  1354.  
  1355.    WriteReg(0, 9);
  1356.    WriteStack(0, 3);
  1357.  
  1358. }
  1359.  
  1360.  
  1361.  
  1362.  
  1363. /*
  1364.  *    **************************************************
  1365.  *    *                                                *
  1366.  *    *        Clear (S, X,Y,Z,T, R, 0-9, All)         *
  1367.  *    *                                                *
  1368.  *    **************************************************
  1369.  */
  1370.  
  1371. static void Clear(void)
  1372.  
  1373. {
  1374.  
  1375.    int r;
  1376.  
  1377.    Message("Press to clear (S, X,Y,Z,T, R, 0-9, A=All, Esc=Exit):");
  1378.  
  1379.    while ((chr = GetChar()) != ESCAPE) {
  1380.  
  1381.       switch (chr) {
  1382.  
  1383.          case ('S'):
  1384.             ClearStack(0, 3);
  1385.             WriteStack(0, 3);
  1386.             return;
  1387.  
  1388.          case ('X'):
  1389.             ClearStack(0, 0);
  1390.             WriteStack(0, 0);
  1391.             return;
  1392.  
  1393.          case ('Y'):
  1394.             ClearStack(1, 1);
  1395.             WriteStack(1, 1);
  1396.             return;
  1397.  
  1398.          case ('Z'):
  1399.             ClearStack(2, 2);
  1400.             WriteStack(2, 2);
  1401.             return;
  1402.  
  1403.          case ('T'):
  1404.             ClearStack(3, 3);
  1405.             WriteStack(3, 3);
  1406.             return;
  1407.  
  1408.          case ('R'):
  1409.             ClearReg(0, 9);
  1410.             WriteReg(0, 9);
  1411.             return;
  1412.  
  1413.          case ('0'):
  1414.          case ('1'):
  1415.          case ('2'):
  1416.          case ('3'):
  1417.          case ('4'):
  1418.          case ('5'):
  1419.          case ('6'):
  1420.          case ('7'):
  1421.          case ('8'):
  1422.          case ('9'):
  1423.             r = chr - '0';
  1424.             ClearReg(r, r);
  1425.             WriteReg(r, r);
  1426.             return;
  1427.  
  1428.          case ('A'):
  1429.             ClearReg(0, 9);
  1430.             ClearStack(0, 3);
  1431.             WriteReg(0, 9);
  1432.             WriteStack(0, 3);
  1433.             return;
  1434.  
  1435.          default:
  1436.             Beep();
  1437.  
  1438.          }  /* switch */
  1439.  
  1440.       }  /* while */
  1441.  
  1442. }
  1443.  
  1444.  
  1445.  
  1446.  
  1447. /*
  1448.  *    **************************************************
  1449.  *    *                                                *
  1450.  *    *        Print (S, X,Y,Z,T, R, 0-9, All)         *
  1451.  *    *                                                *
  1452.  *    **************************************************
  1453.  */
  1454.  
  1455. static void Print(void)
  1456.  
  1457. {
  1458.  
  1459.    int r;
  1460.  
  1461.    Message("Press to print (S, X,Y,Z,T, R, 0-9, A=All, P=Page Eject,"
  1462.            " Esc=Exit):");
  1463.  
  1464.    while ((chr = GetChar()) != ESCAPE) {
  1465.  
  1466.       switch (chr) {
  1467.  
  1468.          case ('S'):
  1469.             PrintHeading();
  1470.             PrintStack(0, 3);
  1471.             return;
  1472.  
  1473.          case ('X'):
  1474.             PrintHeading();
  1475.             PrintStack(0, 0);
  1476.             return;
  1477.  
  1478.          case ('Y'):
  1479.             PrintHeading();
  1480.             PrintStack(1, 1);
  1481.             return;
  1482.  
  1483.          case ('Z'):
  1484.             PrintHeading();
  1485.             PrintStack(2, 2);
  1486.             return;
  1487.  
  1488.          case ('T'):
  1489.             PrintHeading();
  1490.             PrintStack(3, 3);
  1491.             return;
  1492.  
  1493.          case ('R'):
  1494.             PrintReg(0, 9);
  1495.             return;
  1496.  
  1497.          case ('0'):
  1498.          case ('1'):
  1499.          case ('2'):
  1500.          case ('3'):
  1501.          case ('4'):
  1502.          case ('5'):
  1503.          case ('6'):
  1504.          case ('7'):
  1505.          case ('8'):
  1506.          case ('9'):
  1507.             r = chr - '0';
  1508.             PrintHeading();
  1509.             PrintReg(r, r);
  1510.             return;
  1511.  
  1512.          case ('A'):
  1513.             PrintHeading();
  1514.             PrintReg(0, 9);
  1515.             PrintStack(0, 3);
  1516.             return;
  1517.  
  1518.          case ('P'):
  1519.             NewPage();
  1520.             return;
  1521.  
  1522.          default:
  1523.             Beep();
  1524.  
  1525.          }  /* switch */
  1526.  
  1527.       }  /* while */
  1528.  
  1529. }
  1530.  
  1531.  
  1532.  
  1533.  
  1534. /*
  1535.  *    **************************************************
  1536.  *    *                                                *
  1537.  *    *              Store X in Register               *
  1538.  *    *                                                *
  1539.  *    *             Allows + - * / as well             *
  1540.  *    *                                                *
  1541.  *    **************************************************
  1542.  */
  1543.  
  1544. static void StoreX(void)
  1545.  
  1546. {
  1547.  
  1548.    int r;
  1549.  
  1550.    Message("Store X to: Press Reg (0-9) or Operation (+,-,*,/)"
  1551.            " then Reg (0-9) or Esc:");
  1552.  
  1553.    while ((chr = GetChar()) != ESCAPE) {
  1554.  
  1555.       if (isdigit(chr) ) {
  1556.          r = chr - '0';
  1557.          reg[r] = stack[0];
  1558.          WriteReg(r, r);
  1559.          stacklift = TRUE;
  1560.          return;
  1561.          }
  1562.  
  1563.       switch (chr) {
  1564.  
  1565.          case (ADD):
  1566.             AddXReg();
  1567.             return;
  1568.  
  1569.          case (SUBTRACT):
  1570.             SubtractXReg();
  1571.             return;
  1572.  
  1573.          case (MULTIPLY):
  1574.             MultiplyXReg();
  1575.             return;
  1576.  
  1577.          case (DIVIDE):
  1578.             DivideXReg();
  1579.             return;
  1580.  
  1581.          default:
  1582.             Beep();
  1583.  
  1584.          }  /* switch */
  1585.  
  1586.       } /* while */
  1587.  
  1588. }
  1589.  
  1590.  
  1591.  
  1592.  
  1593. /*
  1594.  *    **************************************************
  1595.  *    *                                                *
  1596.  *    *               Add X to Register                *
  1597.  *    *                                                *
  1598.  *    **************************************************
  1599.  */
  1600.  
  1601. static void AddXReg(void)
  1602.  
  1603. {
  1604.  
  1605.    int r;
  1606.  
  1607.    Message("Add X to: Reg (0-9) or Esc:");
  1608.  
  1609.    while ((chr = GetChar()) != ESCAPE) {
  1610.  
  1611.       if (isdigit(chr) ) {
  1612.          r = chr - '0';
  1613.          MoveStackWork(0, 0);
  1614.          MoveRegWork(r, 1);
  1615.  
  1616.          if (ExtendedAdd() ) {
  1617.             MoveWorkReg(2, r);
  1618.             WriteReg(r, r);
  1619.             stacklift = TRUE;
  1620.             return;
  1621.             }
  1622.          return;
  1623.          }
  1624.       else
  1625.          Beep();
  1626.  
  1627.       }  /* while */
  1628.  
  1629. }
  1630.  
  1631.  
  1632.  
  1633.  
  1634. /*
  1635.  *    **************************************************
  1636.  *    *                                                *
  1637.  *    *           Subtract X from Register             *
  1638.  *    *                                                *
  1639.  *    **************************************************
  1640.  */
  1641.  
  1642. static void SubtractXReg(void)
  1643.  
  1644. {
  1645.  
  1646.    int r;
  1647.  
  1648.    Message("Subtract X from: Reg (0-9) or Esc:");
  1649.  
  1650.    while ((chr = GetChar()) != ESCAPE) {
  1651.  
  1652.       if (isdigit(chr) ) {
  1653.          r = chr - '0';
  1654.          MoveStackWork(0, 0);
  1655.          MoveRegWork(r, 1);
  1656.  
  1657.          if (ExtendedSubtract() ) {
  1658.             MoveWorkReg(2, r);
  1659.             WriteReg(r, r);
  1660.             stacklift = TRUE;
  1661.             return;
  1662.             }
  1663.          return;
  1664.          }
  1665.       else
  1666.          Beep();
  1667.  
  1668.       }  /* while */
  1669.  
  1670. }
  1671.  
  1672.  
  1673.  
  1674.  
  1675. /*
  1676.  *    **************************************************
  1677.  *    *                                                *
  1678.  *    *            Multiply X times Register           *
  1679.  *    *                                                *
  1680.  *    **************************************************
  1681.  */
  1682.  
  1683. static void MultiplyXReg(void)
  1684.  
  1685. {
  1686.  
  1687.    int r;
  1688.  
  1689.    Message("Multiply X times: Reg (0-9) or Esc:");
  1690.  
  1691.    while ((chr = GetChar()) != ESCAPE) {
  1692.  
  1693.       if (isdigit(chr) ) {
  1694.          MessageEsc("Multiplying");
  1695.  
  1696.          r = chr - '0';
  1697.          MoveStackWork(0, 0);
  1698.          MoveRegWork(r, 1);
  1699.  
  1700.          if (ExtendedMultiply() ) {
  1701.             MoveWorkReg(2, r);
  1702.             WriteReg(r, r);
  1703.             stacklift = TRUE;
  1704.             return;
  1705.             }
  1706.          return;
  1707.          }
  1708.       else
  1709.          Beep();
  1710.  
  1711.       }  /* while */
  1712.  
  1713. }
  1714.  
  1715.  
  1716.  
  1717.  
  1718. /*
  1719.  *    **************************************************
  1720.  *    *                                                *
  1721.  *    *             Divide X into Register             *
  1722.  *    *                                                *
  1723.  *    **************************************************
  1724.  */
  1725.  
  1726. static void DivideXReg(void)
  1727.  
  1728. {
  1729.  
  1730.    int r;
  1731.  
  1732.    Message("Divide X into: Reg (0-9) or Esc:");
  1733.  
  1734.    while ((chr = GetChar()) != ESCAPE) {
  1735.  
  1736.       if (isdigit(chr) ) {
  1737.          MessageEsc("Dividing");
  1738.  
  1739.          r = chr - '0';
  1740.          MoveStackWork(0, 0);
  1741.          MoveRegWork(r, 1);
  1742.  
  1743.          if (ExtendedDivide() ) {
  1744.             MoveWorkReg(2, r);
  1745.             WriteReg(r, r);
  1746.             stacklift = TRUE;
  1747.             return;
  1748.             }
  1749.          return;
  1750.          }
  1751.       else
  1752.          Beep();
  1753.  
  1754.       }  /* while */
  1755.  
  1756. }
  1757.  
  1758.  
  1759.  
  1760.  
  1761. /*
  1762.  *    **************************************************
  1763.  *    *                                                *
  1764.  *    *             Recall Register to X               *
  1765.  *    *                                                *
  1766.  *    **************************************************
  1767.  */
  1768.  
  1769. static void RecallReg(void)
  1770.  
  1771. {
  1772.  
  1773.    int r;
  1774.  
  1775.    Message("Recall to X: Press Reg (0-9) or Operation (+,-,*,/)"
  1776.            " then Reg (0-9) or Esc:");
  1777.  
  1778.    while ((chr = GetChar()) != ESCAPE) {
  1779.  
  1780.       if (isdigit(chr) ) {
  1781.          r = chr - '0';
  1782.          if (stacklift)
  1783.             PushStack();
  1784.          stack[0] = reg[r];
  1785.          if (stacklift)
  1786.             WriteStack(0, 3);
  1787.          else
  1788.             WriteStack(0, 0);
  1789.          stacklift = TRUE;
  1790.          return;
  1791.          }
  1792.  
  1793.       switch (chr) {
  1794.  
  1795.          case (ADD):
  1796.             AddRegX();
  1797.             return;
  1798.  
  1799.          case (SUBTRACT):
  1800.             SubtractRegX();
  1801.             return;
  1802.  
  1803.          case (MULTIPLY):
  1804.             MultiplyRegX();
  1805.             return;
  1806.  
  1807.          case (DIVIDE):
  1808.             DivideRegX();
  1809.             return;
  1810.  
  1811.          default:
  1812.             Beep();
  1813.  
  1814.          }  /* switch */
  1815.  
  1816.       } /* while */
  1817.  
  1818. }
  1819.  
  1820.  
  1821.  
  1822.  
  1823. /*
  1824.  *    **************************************************
  1825.  *    *                                                *
  1826.  *    *               Add Register to X                *
  1827.  *    *                                                *
  1828.  *    **************************************************
  1829.  */
  1830.  
  1831. static void AddRegX(void)
  1832.  
  1833. {
  1834.  
  1835.    int r;
  1836.  
  1837.    Message("Add to X: Reg (0-9) or Esc:");
  1838.  
  1839.    while ((chr = GetChar()) != ESCAPE) {
  1840.  
  1841.       if (isdigit(chr) ) {
  1842.          r = chr - '0';
  1843.          MoveRegWork(r, 0);
  1844.          MoveStackWork(0, 1);
  1845.  
  1846.          if (ExtendedAdd() ) {
  1847.             lastx = stack[0];
  1848.             MoveWorkStack(2, 0);
  1849.             WriteStack(0, 0);
  1850.             stacklift = TRUE;
  1851.             return;
  1852.             }
  1853.          return;
  1854.          }
  1855.       else
  1856.          Beep();
  1857.  
  1858.       }  /* while */
  1859.  
  1860. }
  1861.  
  1862.  
  1863.  
  1864.  
  1865. /*
  1866.  *    **************************************************
  1867.  *    *                                                *
  1868.  *    *           Subtract Register from X             *
  1869.  *    *                                                *
  1870.  *    **************************************************
  1871.  */
  1872.  
  1873. static void SubtractRegX(void)
  1874.  
  1875. {
  1876.  
  1877.    int r;
  1878.  
  1879.    Message("Subtract from X: Reg (0-9) or Esc:");
  1880.  
  1881.    while ((chr = GetChar()) != ESCAPE) {
  1882.  
  1883.       if (isdigit(chr) ) {
  1884.          r = chr - '0';
  1885.          MoveRegWork(r, 0);
  1886.          MoveStackWork(0, 1);
  1887.  
  1888.          if (ExtendedSubtract() ) {
  1889.             lastx = stack[0];
  1890.             MoveWorkStack(2, 0);
  1891.             WriteStack(0, 0);
  1892.             stacklift = TRUE;
  1893.             return;
  1894.             }
  1895.          return;
  1896.          }
  1897.       else
  1898.          Beep();
  1899.  
  1900.       }  /* while */
  1901.  
  1902. }
  1903.  
  1904.  
  1905.  
  1906.  
  1907. /*
  1908.  *    **************************************************
  1909.  *    *                                                *
  1910.  *    *            Multiply Register times X           *
  1911.  *    *                                                *
  1912.  *    **************************************************
  1913.  */
  1914.  
  1915. static void MultiplyRegX(void)
  1916.  
  1917. {
  1918.  
  1919.    int r;
  1920.  
  1921.    Message("Multiply times X: Reg (0-9) or Esc:");
  1922.  
  1923.    while ((chr = GetChar()) != ESCAPE) {
  1924.  
  1925.       if (isdigit(chr) ) {
  1926.          MessageEsc("Multiplying");
  1927.  
  1928.          r = chr - '0';
  1929.          MoveRegWork(r, 0);
  1930.          MoveStackWork(0, 1);
  1931.  
  1932.          if (ExtendedMultiply() ) {
  1933.             lastx = stack[0];
  1934.             MoveWorkStack(2, 0);
  1935.             WriteStack(0, 0);
  1936.             stacklift = TRUE;
  1937.             return;
  1938.             }
  1939.          return;
  1940.          }
  1941.       else
  1942.          Beep();
  1943.  
  1944.       } /* while */
  1945.  
  1946. }
  1947.  
  1948.  
  1949.  
  1950.  
  1951. /*
  1952.  *    **************************************************
  1953.  *    *                                                *
  1954.  *    *             Divide Register into X             *
  1955.  *    *                                                *
  1956.  *    **************************************************
  1957.  */
  1958.  
  1959. static void DivideRegX(void)
  1960.  
  1961. {
  1962.  
  1963.    int r;
  1964.  
  1965.    Message("Divide into X: Reg (0-9) or Esc:");
  1966.  
  1967.    while ((chr = GetChar()) != ESCAPE) {
  1968.  
  1969.       if (isdigit(chr) ) {
  1970.          MessageEsc("Dividing");
  1971.  
  1972.          r = chr - '0';
  1973.          MoveRegWork(r, 0);
  1974.          MoveStackWork(0, 1);
  1975.  
  1976.          if (ExtendedDivide() ) {
  1977.             lastx = stack[0];
  1978.             MoveWorkStack(2, 0);
  1979.             WriteStack(0, 0);
  1980.             stacklift = TRUE;
  1981.             return;
  1982.             }
  1983.          return;
  1984.          }
  1985.       else
  1986.          Beep();
  1987.  
  1988.       }  /* while */
  1989.  
  1990. }
  1991.  
  1992.  
  1993.  
  1994.  
  1995. /*
  1996.  *    **************************************************
  1997.  *    *                                                *
  1998.  *    *                Exchange X & Y                  *
  1999.  *    *                                                *
  2000.  *    **************************************************
  2001.  */
  2002.  
  2003. static void ExchangeXY(void)
  2004.  
  2005. {
  2006.  
  2007.    NORMTYPE *temp;
  2008.  
  2009.    if ((temp = GETNORMTEMP(1)) == NULL) {
  2010.       MemoryError();
  2011.       return;
  2012.       }
  2013.  
  2014.    *temp = stack[0];
  2015.    stack[0] = stack[1];
  2016.    stack[1] = *temp;
  2017.  
  2018.    WriteStack(0, 1);
  2019.    stacklift = TRUE;
  2020.  
  2021.    free(temp);
  2022.  
  2023. }
  2024.  
  2025.  
  2026.  
  2027.  
  2028. /*
  2029.  *    **************************************************
  2030.  *    *                                                *
  2031.  *    *             Exchange X & Register              *
  2032.  *    *                                                *
  2033.  *    **************************************************
  2034.  */
  2035.  
  2036. static void ExchangeXReg(void)
  2037.  
  2038. {
  2039.  
  2040.    int r;
  2041.    NORMTYPE *temp;
  2042.  
  2043.    Message("Exchange X with: Press Reg (0-9) or Esc:");
  2044.  
  2045.    while ((chr = GetChar()) != ESCAPE) {
  2046.  
  2047.       if (isdigit(chr) ) {
  2048.  
  2049.       if ((temp = GETNORMTEMP(1)) == NULL) {
  2050.          MemoryError();
  2051.          return;
  2052.          }
  2053.  
  2054.          r = chr - '0';
  2055.          *temp = stack[0];
  2056.          stack[0] = reg[r];
  2057.          reg[r] = *temp;
  2058.          WriteReg(r, r);
  2059.          WriteStack(0, 0);
  2060.          stacklift = TRUE;
  2061.          free(temp);
  2062.          return;
  2063.          }
  2064.  
  2065.       } /* while */
  2066.  
  2067. }
  2068.  
  2069.  
  2070.  
  2071.  
  2072. /*
  2073.  *    **************************************************
  2074.  *    *                                                *
  2075.  *    *                Roll Stack Down                 *
  2076.  *    *                                                *
  2077.  *    **************************************************
  2078.  */
  2079.  
  2080. static void RollDown(void)
  2081.  
  2082. {
  2083.  
  2084.    NORMTYPE *temp;
  2085.  
  2086.    if ((temp = GETNORMTEMP(1)) == NULL) {
  2087.       MemoryError();
  2088.       return;
  2089.       }
  2090.  
  2091.    *temp = stack[0];
  2092.    DropStack();
  2093.    stack[3] = *temp;
  2094.  
  2095.    WriteStack(0, 3);
  2096.    stacklift = TRUE;
  2097.  
  2098.    free(temp);
  2099.  
  2100. }
  2101.  
  2102.  
  2103.  
  2104.  
  2105. /*
  2106.  *    **************************************************
  2107.  *    *                                                *
  2108.  *    *                 Roll Stack Up                  *
  2109.  *    *                                                *
  2110.  *    **************************************************
  2111.  */
  2112.  
  2113. static void RollUp(void)
  2114.  
  2115. {
  2116.  
  2117.    NORMTYPE *temp;
  2118.  
  2119.    if ((temp = GETNORMTEMP(1)) == NULL) {
  2120.       MemoryError();
  2121.       return;
  2122.       }
  2123.  
  2124.    *temp = stack[3];
  2125.    PushStack();
  2126.    stack[0] = *temp;
  2127.  
  2128.    WriteStack(0, 3);
  2129.    stacklift = TRUE;
  2130.  
  2131.    free(temp);
  2132.  
  2133. }
  2134.  
  2135.  
  2136.  
  2137.  
  2138. /*
  2139.  *    **************************************************
  2140.  *    *                                                *
  2141.  *    *                  Push Stack                    *
  2142.  *    *                                                *
  2143.  *    **************************************************
  2144.  */
  2145.  
  2146. static void PushStack(void)
  2147.  
  2148. {
  2149.  
  2150.    int s;
  2151.  
  2152.    for (s = 3; s >= 1; s--)
  2153.       stack[s] = stack[s - 1];
  2154.  
  2155. }
  2156.  
  2157.  
  2158.  
  2159.  
  2160. /*
  2161.  *    **************************************************
  2162.  *    *                                                *
  2163.  *    *                  Drop Stack                    *
  2164.  *    *                                                *
  2165.  *    **************************************************
  2166.  */
  2167.  
  2168. static void DropStack(void)
  2169.  
  2170. {
  2171.  
  2172.    int s;
  2173.  
  2174.    for (s = 0; s <= 2; s++)
  2175.       stack[s] = stack[s + 1];
  2176.  
  2177. }
  2178.  
  2179.