home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / math / pac / stack.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-05  |  3.8 KB  |  192 lines
  1. /* stack.c */
  2. /**********************************************************************
  3. *    File Name     : stack.c
  4. *    Function      : user stack
  5. *    Author        : Istvan Mohos, 1987
  6. ***********************************************************************/
  7.  
  8. #include "defs.h"
  9.  
  10. linkup()
  11. {
  12.     register struct stk_cell *sr;
  13.     register int ri;
  14.     static char *fid = "linkup";
  15.  
  16.     _TR
  17.     sr = &Stk[0];
  18.     for(ri = STACKDEEP+1; --ri; sr++)  /* leave last one dangling */
  19.         sr->link = sr+1;
  20.     TR_
  21. }
  22.  
  23. fill_stack(from)
  24. char *from;
  25. {
  26.     register struct stk_cell *sr;
  27.     register char *rc = from;
  28.     register int ri;
  29.     static char *fid = "fill_stack";
  30.  
  31.     _TR
  32.     linkup();
  33.  
  34.     sr = &Stk[0];                /* accumulator */
  35.     if (from == ZERO) {
  36.         strcpy(sr->cell, Emptycell+2); /* no base char */
  37.         ++sr;
  38.         for (ri = STACKDEEP; --ri >= 0; sr++)
  39.             strcpy(sr->cell, Emptycell);
  40.     }
  41.     else {
  42.         *(rc + STACKMAX) = 0;
  43.         strcpy(sr->cell, Emptycell+2);  /* no base char in accum */
  44.         ++sr;
  45.         for (ri = STACKDEEP; --ri >= 0; sr++) {
  46.             *(rc + STACKMAX) = 0;
  47.             strcpy(sr->cell, rc);
  48.             rc += STACKMAX + 1;
  49.         }
  50.     }
  51.     TR_
  52. }
  53.  
  54. show_stack()
  55. {
  56.     register struct stk_cell *sr;
  57.     register int ri;
  58.     static char *fid = "show_stack";
  59.  
  60.     _TR
  61.     sr = Stk[0].link;                /* skip accumulator */
  62.     for (ri = STACKTOP; ri <= STACKBOT; ri++) {
  63.         move(ri, STACKLEFT);
  64.         printw("%s", sr->cell);
  65.         sr = sr->link;
  66.     }
  67.     standout();
  68.     for (ri = STACKTOP; ri <= STACKBOT; ri++) {
  69.         mvaddch(ri, LBOUND, 'h' + ri - STACKTOP);
  70.     }
  71.     standend();
  72.     TR_
  73. }
  74.  
  75. struct stk_cell *
  76. find(stkpos)
  77. int stkpos;    /* accumulator = 0, h = 1 */
  78. {
  79.     register struct stk_cell *sr;
  80.     register int ri;
  81.     static char *fid = "find";
  82.  
  83.     _TR
  84.     sr = &Stk[0];
  85.     for (ri = stkpos; --ri >= 0; sr = sr->link);
  86.     TR_
  87.     return(sr);
  88. }
  89.  
  90. save_stack(to, revstrip)
  91. char *to;
  92. int revstrip;
  93. {
  94.     register struct stk_cell *sr;
  95.     register char *rc = to;
  96.     register int ri;
  97.     static char *fid = "save_stack";
  98.  
  99.     _TR
  100.     sr = Stk[0].link;                /* skip accumulator */
  101.     for (ri = STACKDEEP; --ri >= 0; sr = sr->link) {
  102.         strcpy(rc, sr->cell);
  103.         rc += STACKMAX;
  104.         if (revstrip) {
  105.             while(*--rc == ' ');
  106.             ++rc;
  107.         }
  108.         *rc++ = '\n';
  109.     }
  110.     *rc = '\0';
  111.     TR_
  112. }
  113.  
  114. popstack(stkpos)
  115. int stkpos;    /* h = 1 */
  116. {
  117.     register struct stk_cell *sr, *br;
  118.     static char *fid = "popstack";
  119.  
  120.     _TR
  121.     sr = find(stkpos - 1);
  122.     br = sr->link;
  123.     sr->link = br->link;
  124.     sr = find(STACKDEEP - 1);  /* one is already unlinked */
  125.     sr->link = br;
  126.     strcpy(br->cell, Emptycell);
  127.     show_stack();
  128.     TR_
  129. }
  130.  
  131. clearstack(stkpos)
  132. int stkpos;
  133. {
  134.     register struct stk_cell *sr;
  135.     static char *fid = "clearstack";
  136.  
  137.     _TR
  138.     if (stkpos == 0) {
  139.         linkup();
  140.         fill_stack(ZERO);
  141.     }
  142.     else {
  143.         sr = find(stkpos);
  144.         strcpy(sr->cell, Emptycell);
  145.     }
  146.     show_stack();
  147.     TR_
  148. }
  149.  
  150. pushstack(stkpos)
  151. int stkpos;
  152. {
  153.     register struct stk_cell *sr, *br, *tr;
  154.     static char *fid = "pushstack";
  155.  
  156.     _TR
  157.     sr = find(stkpos - 1);
  158.     tr = find(STACKDEEP);
  159.     br = sr->link;
  160.     sr->link = tr;
  161.     tr->link = br;
  162.     show_stack();
  163.     TR_
  164. }
  165.  
  166. onereg(stkpos)
  167. int stkpos;
  168. {
  169.     register struct stk_cell *sr;
  170.     static char *fid = "onereg";
  171.  
  172.     _TR
  173.     sr = find(stkpos);
  174.     strcpy(Onebuf, sr->cell);
  175.     TR_
  176. }
  177.  
  178. stack_reg(stkpos, source)
  179. int stkpos, source;
  180. {
  181.     register struct stk_cell *sr, *br;
  182.     static char *fid = "stack_reg";
  183.  
  184.     _TR
  185.     sr = find(stkpos);
  186.     br = find(source);
  187.     strcpy(sr->cell, br->cell);
  188.     show_stack();
  189.     TR_
  190. }
  191.  
  192.