home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / math / pac / interpre.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-05  |  24.0 KB  |  833 lines
  1. /* interpret.c */
  2. /**********************************************************************
  3. *    File Name     : interpret.c
  4. *    Function      : pac calculator input tokenizer
  5. *    Author        : Istvan Mohos, 1987
  6. ***********************************************************************/
  7.  
  8. #include "defs.h"
  9. #include "toktab.h"
  10. #define INTERMAP
  11. #include "maps.h"
  12. #undef INTERMAP
  13.  
  14. #define HIDE_RES Hide = 1; rh = Stack; Stack = DISA; \
  15.                  prec = Precision; Precision = 32; show_result(1); \
  16.                  Hide = 0; Stack = rh; Precision = prec
  17. #define RECOVER  conv_bc(sr->cell, ZERO, 1, 0); addto_ubuf(Convbuf)
  18.  
  19. interpret(source)
  20. char *source;
  21. {
  22.     char *eye, *nxeye;
  23.     char *ip, itemp[LINEMAX];
  24.     char stacbuf[PIPEMAX];
  25.     int ri, rh, prec;
  26.     int cur_cnt = 0;
  27.     int type, value, nex_type;
  28.     int first;                /* so conversion can refer to Mainbuf */
  29.     int conv_flag;            /* to show that TO has taken place */
  30.     char c_val;
  31.     static char onechar[2];
  32.     static struct stk_cell *sr = &Stk[0];
  33.     static char *fid = "interpret";
  34.  
  35.     _TR
  36.  
  37. #ifdef TOX
  38.     static char Tk[100];
  39.     char *tk = &Tk[0];
  40. #endif
  41.             
  42.  
  43.     /* transfer raw characters from user window to Spreadbuf,
  44.        insert spaces between all but contiguous alphanumeric characters
  45.        to prepare for pactok */
  46.     fill_spreadbuf(source);
  47.  
  48.     /* strip spaces and commas, null terminate tokens */
  49.     place_pointers();
  50.     *Ubuf = '\0';
  51.     *Controlbuf = '\0';
  52.     first = TRUE;
  53.     conv_flag = FALSE;
  54.  
  55.     while ((eye = Tokp[++cur_cnt]) != ZERO) {
  56.         type = lookup(eye);
  57.  
  58.         if ((nxeye = Tokp[cur_cnt + 1]) != ZERO)
  59.             nex_type = lookup(nxeye);
  60.         else
  61.             nex_type = -1;
  62.  
  63. #ifdef TOX
  64.         sprintf(tk, "%d,", type);
  65.         tk = Tk + strlen(Tk);
  66. #endif
  67.  
  68.         switch(type) {
  69.  
  70.         default:
  71.         case NOTINLIST:
  72.             upcase(eye);
  73.             addto_ubuf(eye);
  74.             break;
  75.  
  76.         case IB:
  77.         case IBASE:
  78.             show_result(1);
  79.  
  80.             /* ZERO pointer: no more tokens
  81.                Convbuf returned: next token not in preferred list
  82.                    in either case, leave right side alone */
  83.  
  84.             if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  85.                 == ZERO || eye == Convbuf) {
  86.                 --cur_cnt;
  87.                 Ibase = IB_DFLT;
  88.             }
  89.             else {
  90.                 conv_bc(eye, ZERO, Ibase, 10);
  91.                 Ibase = atoi(Convbuf);
  92.                 if (Ibase > 16 || Ibase < 2)
  93.                     Ibase = IB_DFLT;
  94.             }
  95.             sprintf(Mop, "ibase=A;ibase=%d\n",Ibase);
  96.             addto_controlbuf(Mop);
  97.             show_result(0);
  98.             break;
  99.  
  100.         case OB:
  101.         case OBASE:
  102.             show_result(1);
  103.             if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  104.                 == ZERO || eye == Convbuf) {
  105.                 --cur_cnt;
  106.                 Obase = OB_DFLT;
  107.             }
  108.             else {
  109.                 conv_bc(eye, ZERO, Ibase, 10);
  110.                 Obase = atoi(Convbuf);
  111.                 if (Obase > 16 || Obase < 2)
  112.                     Obase = OB_DFLT;
  113.             }
  114.             sprintf(Mop, "ibase=A;obase=%d;ibase=%d\n", Obase, Ibase);
  115.             addto_controlbuf(Mop);
  116.             show_result(0);
  117.             break;
  118.  
  119.         case TE:
  120.         case TERSE:
  121.         case VER:
  122.         case VERBOSE:
  123.         case XT:
  124.         case XTERSE:
  125.             show_result(1);
  126.             if (type == TE || type == TERSE)
  127.                 Hf = FTER;
  128.             else if (type == VER || type == VERBOSE)
  129.                 Hf = FVER;
  130.             else
  131.                 Hf = FXTER;
  132.             show_result(0);
  133.             break;
  134.  
  135.         case FIX:
  136.         case RIGHT:
  137.         case RI:
  138.         case LE:
  139.         case LEFT:
  140.         case CM:
  141.         case COMMA:
  142.         case SP:
  143.         case SPACE:
  144.             show_result(1);
  145.             if (type == FIX)
  146.                 Justify = JF;
  147.             else if (type == RIGHT || type == RI)
  148.                 Justify = JR;
  149.             else if (type == LE || type == LEFT)
  150.                 Justify = JL;
  151.             else if (type == CM || type == COMMA)
  152.                 Separator = ',', Format = COMMA_;
  153.             else if (type == SP || type == SPACE)
  154.                 Separator = ' ', Format = SPACE_;
  155.             show_result(0);
  156.             break;
  157.  
  158.         case QUESTION:
  159.         case HELP:
  160.             if (nex_type == -1)
  161.                 show_help(HELP);
  162.             else {
  163.                 ++cur_cnt;
  164.                 show_help(nex_type);
  165.             }
  166.             break;
  167.  
  168.         case TO:
  169.             if (!first) {
  170.                   HIDE_RES;
  171.             }
  172.             RECOVER;
  173.             eye = Tokp[++cur_cnt];
  174.             if (eye == ZERO)
  175.                 --cur_cnt;
  176.             else if ((ri = conv_id(eye)) != -1)
  177.                 Convsel = ri;
  178.             else
  179.                 --cur_cnt;
  180.             Do_conv = conv_flag = TRUE;
  181.             HIDE_RES;
  182.             show_result(0);
  183.             RECOVER;
  184.             break;
  185.  
  186.         case AND:
  187.         case OR:
  188.         case XOR:
  189.             if (!first) {
  190.                  HIDE_RES;
  191.             }
  192.             /* resolve left side; convert it to base 2 */
  193.             conv_bc(sr->cell, ZERO, 1, 2);
  194.             strcpy(itemp, Convbuf);
  195.  
  196.             if ((eye = substivar(-1, Tokp[++cur_cnt], 2))
  197.             == ZERO || eye == Convbuf)
  198.                 --cur_cnt, eye = itemp;
  199.             else if (eye == Tokp[cur_cnt]) {
  200.                 /* nextok is a digit string */
  201.                 conv_bc(eye, ZERO, -1, 2);
  202.                 eye = Convbuf;
  203.             }
  204.             if ((ip = bitwise(type, itemp, eye, &ri)) == ZERO) {
  205.                 pac_err("conversion range");
  206.                 TR_
  207.                 return;
  208.             }
  209.             conv_bc(ip, ZERO, 1, 0);
  210.             addto_ubuf(Convbuf);
  211.             HIDE_RES;
  212.             RECOVER;
  213.             break;
  214.  
  215.         case TW:
  216.         case TWOSCOMP:
  217.         case NOT:
  218.             if (type == TWOSCOMP)
  219.                  type = TW;
  220.             if (!first) {
  221.                  HIDE_RES;
  222.             }
  223.             /* resolve left side; convert it to base 2 */
  224.             conv_bc(sr->cell, ZERO, 1, 2);
  225.             strcpy(itemp, Convbuf);
  226.  
  227.             if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  228.             == ZERO || eye == Convbuf) {
  229.                 --cur_cnt;
  230.                 /* reuse previous result */
  231.                 conv_bc(sr->cell, ZERO, 1, 10);
  232.                 eye = Convbuf;
  233.             }
  234.             else if (eye == Tokp[cur_cnt]) {
  235.                 /* nextok is a digit string */
  236.                 conv_bc(eye, ZERO, -1, 10);
  237.                 eye = Convbuf;
  238.             }
  239.             if ((ip = bitwise(type, itemp, eye, &ri)) == ZERO) {
  240.                 pac_err("conversion range");
  241.                 TR_
  242.                 return;
  243.             }
  244.             if (ri)
  245.                 addto_ubuf("-");
  246.             conv_bc(ip, ZERO, 1, 0);
  247.             addto_ubuf(Convbuf);
  248.             if (type == TW)
  249.                 addto_ubuf((ri) ? "-1" : "+1");
  250.             HIDE_RES;
  251.             RECOVER;
  252.             break;
  253.  
  254.         case MOD:
  255.             if (!first) {
  256.                 HIDE_RES;
  257.             }
  258.             ri = Precision;
  259.             sprintf(Mop,"ibase=A;scale=0;ibase=%d\n", Ibase);
  260.             addto_controlbuf(Mop);
  261.             show_result(0);
  262.             conv_bc(sr->cell, ZERO, 1, 0);
  263.             addto_ubuf(Convbuf);
  264.             addto_ubuf("\%");
  265.             if ((eye = substivar(-1, Tokp[++cur_cnt], 0))
  266.                 == ZERO || eye == Convbuf) {
  267.                 --cur_cnt;
  268.                 eye = Convbuf;
  269.             }
  270.             addto_ubuf(eye);
  271.             HIDE_RES;
  272.             sprintf(Mop,"ibase=A;scale=%d;ibase=%d\n",ri, Ibase);
  273.             addto_controlbuf(Mop);
  274.             show_result(0);
  275.             RECOVER;
  276.             break;
  277.  
  278.         case BANG:
  279.             if (!first) {
  280.                 HIDE_RES;
  281.             }
  282.             /* resolve left side; convert it to base 10 */
  283.             conv_bc(sr->cell, ZERO, 1, 10);
  284.             value = atoi(Convbuf);
  285.             if (value < 0)
  286.                  value = 0;
  287.             else if (value > 35)
  288.                  value = 35;
  289.             conv_bc(factab[value], ZERO, 1, 0);
  290.             addto_ubuf(Convbuf);
  291.             HIDE_RES;
  292.             RECOVER;
  293.             break;
  294.  
  295.         case JUSTIFY:
  296.         case JU:
  297.             eye = Tokp[++cur_cnt];
  298.             if (eye == ZERO) {
  299.                 show_result(1);
  300.                 Justify = JUS_DFLT;
  301.                 show_result(0);
  302.             }
  303.             --cur_cnt;
  304.             break;
  305.  
  306.         case HF:
  307.         case HARDFORM:
  308.             eye = Tokp[++cur_cnt];
  309.             if (eye == ZERO) {
  310.                 show_result(1);
  311.                 Hf = HF_DFLT;
  312.                 show_result(0);
  313.             }
  314.             --cur_cnt;
  315.             break;
  316.  
  317.         case SHARP: /* comment start */
  318.             (conv_flag || Autoconv == ENA) ? (O_conv = TRUE)
  319.                                            : (O_conv = FALSE);
  320.             show_result(2);
  321.             TR_
  322.             return;
  323.  
  324.         case SEMI:
  325.             show_result(1);
  326.             first = 2;
  327.             break;
  328.  
  329.         case STACK:
  330.         case ST:
  331.         case SB:
  332.         case STAYBASE:
  333.         case AUTOTIME:
  334.         case AT:
  335.             ip = stacbuf;
  336.             ri = 0;
  337.             show_result(1);
  338.             eye = Tokp[++cur_cnt];
  339.             if (eye == ZERO) {
  340.                 --cur_cnt;
  341.                 if (type == STACK || type == ST)
  342.                     (Stack == ENA) ? (ri = 1) : (Stack = ENA);
  343.                 else if (type == STAYBASE || type == SB)
  344.                     Staybase = ENA;
  345.                 else if (type == AUTOTIME || type == AT)
  346.                     Autotime = ENA;
  347.                 show_result(0);
  348.             }
  349.             else {
  350.                 value = lookup(eye);
  351.                 if (value == ON)
  352.                     value = ENA;
  353.                 else if (value == OFF)
  354.                     value = DISA;
  355.                 else {
  356.                     --cur_cnt;
  357.                     value = ENA;
  358.                 }
  359.                 if (type == STACK || type == ST) {
  360.                     if (value == ENA && Stack == ENA)
  361.                         ri = 1;
  362.                     Stack = value;
  363.                 }
  364.                 else if (type == STAYBASE || type == SB)
  365.                     Staybase = value;
  366.                 else if (type == AUTOTIME || type == AT)
  367.                     Autotime = value;
  368.                 show_result(0);
  369.             }
  370.             if (Hc != -1 && ri) {
  371.                 save_stack(ip, 1);
  372.                 ri = strlen(stacbuf);
  373.                 if ((write(Hc, stacbuf, ri)) != ri)
  374.                     fatal("hardcopy stack write");
  375.             }
  376.             break;
  377.  
  378.         case FORMAT:
  379.         case FO:
  380.             show_result(1);
  381.             eye = Tokp[++cur_cnt];
  382.             if (eye == ZERO) {
  383.                 --cur_cnt;
  384.                 Format = FORM_DFLT;
  385.                 (FORM_DFLT == COMMA_) ? (Separator = '.')
  386.                                      : (Separator = ' ');
  387.             }
  388.             else {
  389.                 value = lookup(eye);
  390.                 switch (value) {
  391.                     case CM:
  392.                     case COMMA:
  393.                         Separator = ',';
  394.                         Format = COMMA_;
  395.                         break;
  396.                     default:
  397.                         --cur_cnt;
  398.                         Format = FORM_DFLT;
  399.                         (FORM_DFLT == COMMA_) ? (Separator = '.')
  400.                                              : (Separator = ' ');
  401.                         break;
  402.                     case SP:
  403.                     case SPACE:
  404.                         Separator = ' ';
  405.                         Format = SPACE_;
  406.                         break;
  407.                     case OFF:
  408.                         Separator = ' ';
  409.                         Format = DISA;
  410.                         break;
  411.                 }
  412.             }
  413.             show_result(0);
  414.             break;
  415.  
  416.         case PR:
  417.         case PRECISION:
  418.         case SCALE:
  419.         case DP:
  420.             show_result(1);
  421.             /* get right side literal for input */
  422.             if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  423.                 == ZERO || eye == Convbuf) {
  424.                 --cur_cnt;
  425.                 Precision = PREC_DFLT;
  426.             }
  427.             else {
  428.                 Precision = atoi(eye);
  429.                 if (Precision < 0  || Precision > 32)
  430.                     Precision = PREC_DFLT;
  431.             }
  432.             sprintf(Mop,"ibase=A;scale=%d;ibase=%d\n",Precision, Ibase);
  433.             addto_controlbuf(Mop);
  434.             show_result(0);
  435.             break;
  436.  
  437.         case PP: /* PercentPlus */
  438.         case PPLUS:
  439.         case PM: /* PercentMinus */
  440.         case PMINUS:
  441.         case PD: /* PercentDelta */
  442.         case PDELTA:
  443.         case PDIFF:
  444.         case PV: /* PercentVersus */
  445.         case PVERSUS:
  446.         case PO: /* PercentOf */
  447.         case POF:
  448.         case PE: /* PercentEqual */
  449.         case PEQUAL:
  450.             if (!first) {
  451.                 HIDE_RES;
  452.             }
  453.             conv_bc(sr->cell, ZERO, 1, 0); /* left side is input */
  454.  
  455.             /* get right side literal for input */
  456.             if ((eye = substivar(-1, Tokp[++cur_cnt], 0))
  457.                 == ZERO || eye == Convbuf) {
  458.                 --cur_cnt;
  459.                 eye = Convbuf;
  460.             }
  461.             ip = itemp;
  462.             switch (type) {
  463.                 case PP:
  464.                 case PPLUS:
  465.                     sprintf(ip, "%s+(%s*%s/%s)",
  466.                         Convbuf,Convbuf,eye,hundred[Ibase]);
  467.                     break;
  468.                 case PM:
  469.                 case PMINUS:
  470.                     sprintf(ip, "%s-(%s*%s/%s)",
  471.                         Convbuf,Convbuf,eye,hundred[Ibase]);
  472.                     break;
  473.                 case PV:
  474.                 case PVERSUS:
  475.                     sprintf(ip, "%s*%s/%s",
  476.                         eye,hundred[Ibase],Convbuf);
  477.                     break;
  478.                 case PD:
  479.                 case PDELTA:
  480.                 case PDIFF:
  481.                     sprintf(ip, "(%s*(%s-%s))/%s",
  482.                         hundred[Ibase],eye,Convbuf,Convbuf);
  483.                     break;
  484.                 case PO:
  485.                 case POF:
  486.                     sprintf(ip, "(%s*%s/%s)",
  487.                         eye,Convbuf,hundred[Ibase]);
  488.                     break;
  489.                 case PE:
  490.                 case PEQUAL:
  491.                     sprintf(ip, "(%s*%s/%s)",
  492.                         eye,hundred[Ibase],Convbuf);
  493.                     break;
  494.             }
  495.             addto_ubuf(ip);
  496.             break;
  497.  
  498.         case LOG:
  499.             *onechar = *eye;
  500.             addto_ubuf(onechar);
  501.             break;
  502.  
  503.         case SQRT:
  504.             addto_ubuf(eye);
  505.             break;
  506.  
  507.         case INIT_:
  508.             show_result(1);
  509.             pacinit();
  510.             sprintf(Mop, "ibase=A;obase=%d;ibase=%d\n", Obase, Ibase);
  511.             addto_controlbuf(Mop);
  512.             show_result(0);
  513.             break;
  514.  
  515.         case DONTSAVE:
  516.         case DS:
  517.             Dontsave = 1;
  518.             break;
  519.  
  520.         /* copy accum into chosen stack cell, or onto top of stack.
  521.            Other cells are not disturbed */
  522.         case STO:
  523.             show_result(1);
  524.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  525.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w')))
  526.                 c_val = 'h';
  527.             else {
  528.                 c_val = *nxeye;
  529.                 ++cur_cnt;
  530.             }
  531.             stack_reg(c_val - 'g', 0);
  532.             break;
  533.  
  534.         case IF:
  535.         case WHILE:
  536.         case FOR:
  537.         case BREAK:
  538.         case DEFINE:
  539.         case LENGTH:
  540.             pac_err("unimplemented key");
  541.             TR_
  542.             return;
  543.  
  544.         case QUIT:
  545.         case EXIT:
  546.             go_away(ZERO, 0);
  547.  
  548.         case BYE:
  549.             clearstack(0);
  550.             Amt = Rate = Years = 0.;
  551.             go_away("I", 0);
  552.  
  553.         /* value = sum of bytes' ascii values of next token are
  554.            substituted (in current Ibase) in input to bc */
  555.         case TICK:
  556.             value = 0;
  557.             if ((eye = Tokp[++cur_cnt]) == ZERO)
  558.                 --cur_cnt;
  559.             else
  560.                 while (*eye)
  561.                     value += *eye++;
  562.             sprintf(Mop, "%c %d",Base_str[10], value);
  563.             conv_bc(Mop, ZERO, 1, 0);
  564.             addto_ubuf(Convbuf);
  565.             break;
  566.  
  567.         case BACKSLASH:
  568.             RECOVER;
  569.             break;
  570.  
  571.         case KILO:
  572.         case ATTO:
  573.         case FEMTO:
  574.         case GIGA:
  575.         case MEGA:
  576.         case MICRO:
  577.         case MILLI:
  578.         case NANO:
  579.         case PICO:
  580.         case TERA:
  581.         case PETA:
  582.         case EXA:
  583.             if (first) {
  584.                 RECOVER;
  585.             }
  586.             addto_ubuf("*");
  587.             addto_ubuf(substivar(type, ZERO, Ibase));
  588.             break;
  589.  
  590.         case X_LOWER:
  591.         case X_UPPER:
  592.             sprintf(itemp, "%s", sixteen[Ibase]);
  593.             addto_ubuf(itemp);
  594.             break;
  595.  
  596.         /* shift Stack down from named register (or top, if no arg);
  597.            bottom gets lost. Copy accum into named element.
  598.            works independently (in addition to) stack effect */
  599.         case PSH:
  600.             show_result(1);
  601.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  602.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  603.                 pushstack(1);
  604.                 stack_reg(1, 0);
  605.             }
  606.             else {
  607.                 pushstack(*nxeye - 'g');
  608.                 stack_reg(*nxeye - 'g', 0);
  609.                 ++cur_cnt;
  610.             }
  611.             break;
  612.  
  613.         /* Move stack element (or top, if no arg) into accum, move up
  614.            all elements below it.  Move 0 into bottom location */
  615.         case PLL:
  616.             show_result(1);
  617.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  618.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  619.                 onereg(1);
  620.                 popstack(1);
  621.             }
  622.             else {
  623.                 onereg(*nxeye - 'g');
  624.                 popstack(*nxeye - 'g');
  625.                 ++cur_cnt;
  626.             }
  627.             conv_bc(Onebuf, ZERO, 1, 0);
  628.             addto_ubuf(Convbuf);
  629.             HIDE_RES;
  630.             break;
  631.  
  632.         /* Swap accum and stacktop (no args), or accum and cell (1 arg),
  633.            other registers remain intact */
  634.         case SWP:
  635.             show_result(1);
  636.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  637.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  638.                 onereg(1);
  639.                 stack_reg(1, 0);
  640.             }
  641.             else {
  642.                 onereg(*nxeye - 'g');
  643.                 stack_reg(*nxeye - 'g', 0);
  644.                 ++cur_cnt;
  645.             }
  646.             conv_bc(Onebuf, ZERO, 1, 0);
  647.             addto_ubuf(Convbuf);
  648.             HIDE_RES;
  649.             break;
  650.  
  651.         /* Discard top of stack, (no args) or named stack cell (1 arg);
  652.            move up lower locations.  Move 0 into bottom location */
  653.         case POP:
  654.             show_result(1);
  655.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  656.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w')))
  657.                 popstack(1);
  658.             else {
  659.                 popstack(*nxeye - 'g');
  660.                 ++cur_cnt;
  661.             }
  662.             break;
  663.  
  664.         case MOHOS:
  665. #ifdef TRACE
  666.             if (first) {
  667.                 Trace = !Trace;
  668.                 if (Trace && Tf == NULL) {
  669.                     Tlev = 18; /* pop 2 off 20 maxdeep tabs */
  670.                     if ((Tf = fopen("pactrace", "w")) == NULL)
  671.                         go_away("bad trace file", 1);
  672.                 }
  673.                 if (!Trace && Tf != NULL) {
  674.                     fclose(Tf);
  675.                     Tf = NULL;
  676.                 }
  677.             }
  678. #endif
  679.             *Ubuf = '\0';
  680.             *Controlbuf = '\0';
  681.             first = TRUE;
  682.             conv_flag = FALSE;
  683.             break;
  684.  
  685.         case PI:
  686.         case ASTRO:     
  687.         case AMASS:      
  688.         case AVOGADRO:  
  689.         case BOLTZMANN: 
  690.         case ECHARGE:    
  691.         case CHROMA:    
  692.         case EMASS:  
  693.         case EULER:     
  694.         case FARADAY:   
  695.         case G_:        
  696.         case GAS:       
  697.         case GRAVITY:   
  698.         case HEAT:      
  699.         case LIGHT:     
  700.         case LIGHTYEAR: 
  701.         case MOONMASS:     
  702.         case SUNMASS:      
  703.         case EARTHMASS:    
  704.         case NATURAL:   
  705.         case NMASS:   
  706.         case PARSEC:    
  707.         case PARALLAX:    
  708.         case PLANCK:    
  709.         case PMASS:    
  710.         case MOONRAD:     
  711.         case SUNRAD:      
  712.         case EARTHRAD:    
  713.         case RYDBERG:   
  714.         case SOUND:     
  715.         case STEFAN:    
  716.         case TOMOON:    
  717.         case TOSUN:    
  718.         case WIEN:      
  719.             addto_ubuf(substivar(type, ZERO, Ibase));
  720.             break;
  721.  
  722.         case H_:
  723.         case I_:
  724.         case J_:
  725.         case K_:
  726.         case L_:
  727.         case M_:
  728.         case N_:
  729.         case O_:
  730.         case P_:
  731.         case Q_:
  732.         case R_:
  733.         case S_:
  734.         case T_:
  735.         case U_:
  736.         case V_:
  737.         case W_:
  738.             conv_bc((char *)find(*eye - 'g'), ZERO, 1, 0);
  739.             addto_ubuf(Convbuf);
  740.             break;
  741.  
  742.         case SIN:
  743.         case COS:
  744.         case EXP:
  745.         case ARCT:
  746.             if (Ibase != 10) {
  747.                 pac_err("active in 10 base only");
  748.                 TR_
  749.                 return;
  750.             }
  751.             *onechar = *eye;
  752.             addto_ubuf(onechar);
  753.             break;
  754.  
  755.         /* Put 0 into a  specific stack cell, or into
  756.            all cells including accum */
  757.         case CLR:
  758.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  759.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  760.                 clearstack(0);
  761.                 addto_ubuf(";0;");
  762.             }
  763.             else {
  764.                 clearstack(*nxeye - 'g');
  765.                 ++cur_cnt;
  766.             }
  767.             show_result(1);
  768.             break;
  769.  
  770.         /* Values below named cell (or top) move down, bottom gets lost,
  771.            named cell is copied into cell below */
  772.         case DUP:
  773.             show_result(1);
  774.             if (nxeye == ZERO || strlen(nxeye) > 1 ||
  775.                 (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  776.                 stack_reg('w' - 'g', 0); /* copy it into W first */
  777.                 pushstack(1);
  778.             }
  779.             else {
  780.                 stack_reg('w' - 'g', *nxeye - 'g');
  781.                 pushstack(*nxeye - 'g');
  782.                 ++cur_cnt;
  783.             }
  784.             break;
  785.  
  786.         /* Turn continuous conversion on/off */
  787.         case AU:
  788.         case AUTO:
  789.         case AUTOCONV:
  790.             show_result(1);
  791.             Do_conv = TRUE;
  792.             eye = Tokp[++cur_cnt];
  793.             if (eye == ZERO) {
  794.                 --cur_cnt;
  795.                 Autoconv = ENA;
  796.                 show_result(0);
  797.                 break;
  798.             }
  799.             value = lookup(eye);
  800.             if (value != ON && value != OFF) {
  801.                 --cur_cnt;
  802.                 Autoconv = ENA;
  803.             }
  804.             else if (value == ON)
  805.                 Autoconv = ENA;
  806.             else {
  807.                 Autoconv = DISA;
  808.                 Do_conv = FALSE;
  809.             }
  810.             show_result(0);
  811.             break;
  812.  
  813.         }
  814.         (first == 2) ? (first = TRUE) : (first = FALSE);
  815.         /* FALSE after evaluating the first token */
  816.     }
  817.     (conv_flag || Autoconv == ENA) ? (O_conv = TRUE) : (O_conv = FALSE);
  818.     show_result(2);
  819.  
  820. #ifdef TOX
  821.     clear_wline(BOT, ULEFT, RBOUND, 1, 1);
  822.     standout();
  823.     mvaddstr(BOT, ULEFT, Tk);
  824.     standend();
  825.     pfresh();
  826.     sleep(5);
  827.     move(CY, CX);
  828. #endif
  829.  
  830.     TR_
  831. }
  832.  
  833.