home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / Tex29 / StTeXsrc.zoo / src / eqstack.c < prev    next >
C/C++ Source or Header  |  1988-03-13  |  7KB  |  291 lines
  1.  
  2. /*
  3.  * @(#)eqstack.c 2.6 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "token.h"
  15. #include "tokenstack.h"
  16. #include "tokenlists.h"
  17. #include "eqstack.h"
  18.  
  19. ptr     save_ptr = 0;
  20. mword   save_stack[SAVE_SIZE];
  21. ptr     max_save_stack = 0;
  22. qword   cur_level = LEVEL_ONE;
  23. group   cur_group = BOTTOM_LEVEL;
  24. ptr     cur_boundary = 0;
  25.  
  26. #define check_full_save_stack() \
  27.     {if (save_ptr > max_save_stack) { \
  28.         max_save_stack = save_ptr; \
  29.         if (max_save_stack > SAVE_SIZE - 6) \
  30.             overflow("save size", SAVE_SIZE);}}
  31.  
  32. new_save_level (c)
  33.     group   c;
  34. {
  35.     check_full_save_stack();
  36.     save_type(save_ptr) = LEVEL_BOUNDARY;
  37.     save_level(save_ptr) = cur_group;
  38.     save_index(save_ptr) = cur_boundary;
  39.     if (cur_level == MAX_QUARTERWORD)
  40.         overflow("grouping levels", MAX_QUARTERWORD - MIN_QUARTERWORD);
  41.     cur_boundary = save_ptr;
  42.     cur_group = c;
  43.     incr(cur_level);
  44.     incr(save_ptr);
  45. }
  46.  
  47. eq_destroy (w)
  48.     mword   w;
  49. {
  50.     ptr     q;
  51.  
  52.     switch (eq_type_field(w))
  53.     {
  54.     case CALL:
  55.     case LONG_CALL:
  56.     case LONG_OUTER_CALL:
  57.         delete_token_ref(equiv_field(w));
  58.         break;
  59.  
  60.     case GLUE_REF:
  61.         delete_glue_ref(equiv_field(w));
  62.         break;
  63.  
  64.     case SHAPE_REF:
  65.         q = equiv_field(w);
  66.         if (q != NULL)
  67.             free_node(q, link(q) + link(q) + 1);
  68.         break;
  69.  
  70.     case BOX_REF:
  71.         flush_node_list(equiv_field(w));
  72.         break;
  73.     }
  74. }
  75.  
  76. eq_save (p, l)
  77.     ptr     p;
  78.     qword   l;
  79. {
  80.     check_full_save_stack();
  81.     if (l == LEVEL_ZERO)
  82.         save_type(save_ptr) = RESTORE_ZERO;
  83.     else {
  84.         save_stack[save_ptr] = eqtb[p];
  85.         incr(save_ptr);
  86.         save_type(save_ptr)= RESTORE_OLD_VALUE;
  87.     }
  88.     save_index(save_ptr) = p;
  89.     save_level(save_ptr) = l;
  90.     incr(save_ptr);
  91. }
  92.  
  93. eq_define (p, t, e)
  94.     ptr     p;
  95.     qword   t;
  96.     hword   e;
  97. {
  98.     if (eq_level(p) == cur_level)
  99.         eq_destroy(eqtb[p]);
  100.     else if (cur_level > LEVEL_ONE)
  101.         eq_save(p, eq_level(p));
  102.     eq_level(p) = cur_level;
  103.     eq_type(p) = t;
  104.     equiv(p) = e;
  105. }
  106.  
  107. eq_word_define (p, w)
  108.     ptr     p;
  109.     val     w;
  110. {
  111.     if (xeq_level[p - INT_BASE] != cur_level) {
  112.         eq_save(p, xeq_level[p - INT_BASE]);
  113.         xeq_level[p - INT_BASE] = cur_level;
  114.     }
  115.     eqtb[p].i = w;
  116. }
  117.  
  118. geq_define (p, t, e)
  119.     ptr     p;
  120.     qword   t;
  121.     hword   e;
  122. {
  123.     eq_destroy(eqtb[p]);
  124.     eq_level(p) = LEVEL_ONE;
  125.     eq_type(p) = t;
  126.     equiv(p) = e;
  127. }
  128.  
  129. geq_word_define (p, w)
  130.     ptr     p;
  131.     val     w;
  132. {
  133.     eqtb[p].i = w;
  134.     xeq_level[p - INT_BASE] = LEVEL_ONE;
  135. }
  136.  
  137. save_for_after (t)
  138.     hword   t;
  139. {
  140.     check_full_save_stack();
  141.     save_type(save_ptr) = INSERT_TOKEN;
  142.     save_level(save_ptr) = LEVEL_ZERO;
  143.     save_index(save_ptr) = t;
  144.     incr(save_ptr);
  145. }
  146.  
  147. unsave ()
  148. {
  149.     qword   l;
  150.     ptr     p;
  151.     hword   t;
  152.  
  153.     if (cur_level > LEVEL_ONE) {
  154.         decr(cur_level);
  155.         loop {
  156.             decr(save_ptr);
  157.             if (save_type(save_ptr) == LEVEL_BOUNDARY)  
  158.                 break;
  159.             p = save_index(save_ptr);
  160.             if (save_type(save_ptr) == INSERT_TOKEN) {
  161.                 t = cur_tok;
  162.                 cur_tok = p;
  163.                 back_input();
  164.                 cur_tok = t;
  165.             } else {
  166.                 if (save_type(save_ptr) == RESTORE_OLD_VALUE) {
  167.                     l = save_level(save_ptr);
  168.                     decr(save_ptr);
  169.                 } else 
  170.                     save_stack[save_ptr] = eqtb[UNDEFINED_CONTROL_SEQUENCE];
  171. #ifdef STAT
  172.                 if (p < INT_BASE) {
  173.                     if (eq_level(p) == LEVEL_ONE) {
  174.                         eq_destroy(save_stack[save_ptr]);
  175.                         if (tracing_restores > 0)
  176.                             restore_trace(p, "retaining");
  177.                     } else {
  178.                         eq_destroy(eqtb[p]);
  179.                         eqtb[p] = save_stack[save_ptr];
  180.                         if (tracing_restores > 0)
  181.                             restore_trace(p, "restoring");
  182.                     }
  183.                 } else if (xeq_level[p - INT_BASE] != LEVEL_ONE) {
  184.                     eqtb[p] = save_stack[save_ptr];
  185.                     xeq_level[p - INT_BASE] = l;
  186.                     if (tracing_restores > 0)
  187.                         restore_trace(p, "restoring");
  188.                 } else {
  189.                     if (tracing_restores > 0)
  190.                         restore_trace(p, "retaining");
  191.                 }
  192. #else
  193.                 if (p < INT_BASE) {
  194.                     if (eq_level(p) == LEVEL_ONE)
  195.                         eq_destroy(save_stack[save_ptr]);
  196.                     else {
  197.                         eq_destroy(eqtb[p]);
  198.                         eqtb[p] = save_stack[save_ptr];
  199.                     }
  200.                 } else if (xeq_level[p - INT_BASE] != LEVEL_ONE) {
  201.                     eqtb[p] = save_stack[save_ptr];
  202.                     xeq_level[p - INT_BASE] = l;
  203.                 }
  204. #endif
  205.             }
  206.         }
  207.         cur_group = save_level(save_ptr);
  208.         cur_boundary = save_index(save_ptr);
  209.     } else
  210.         confusion("curlevel");
  211. }
  212.  
  213. off_save ()
  214. {   
  215.     ptr     p;
  216.  
  217.     if (cur_group == BOTTOM_LEVEL) {
  218.         print_err("Extra ");
  219.         print_cmd_chr(cur_cmd, cur_chr);
  220.         help_offsave_xtra();
  221.         error();
  222.     } else {
  223.         back_input();
  224.         p = new_token();
  225.         token_link(temp_toks) = p;
  226.         print_err("Missing ");
  227.         switch (cur_group) 
  228.         {
  229.         case SEMI_SIMPLE_GROUP:
  230.             token(p) = CS_TOKEN_FLAG + FROZEN_END_GROUP;
  231.             print_esc("groupend");
  232.             break;
  233.         
  234.         case MATH_SHIFT_GROUP:
  235.             token(p) = MATH_SHIFT_TOKEN + '$';
  236.             print_char('$');
  237.             break;
  238.         
  239.         case MATH_LEFT_GROUP:
  240.             token(p) = CS_TOKEN_FLAG + FROZEN_RIGHT;
  241.             token_link(p) = new_token();
  242.             p = token_link(p);
  243.             token(p) = OTHER_TOKEN + '.';
  244.             print_esc("right.");
  245.             break;
  246.         
  247.         default:
  248.             token(p) = RIGHT_BRACE_TOKEN + '}';
  249.             print_char('}');
  250.             break;
  251.         }
  252.         print(" inserted");
  253.         ins_list(token_link(temp_toks));
  254.         help_offsave_missing();
  255.         error();
  256.     }
  257. }
  258.  
  259. #ifdef STAT
  260. restore_trace (p, s)
  261.     ptr     p;
  262.     char*   s;
  263. {
  264.     begin_diagnostic();
  265.     print_char('{');
  266.     print(s);
  267.     print_char(' ');
  268.     show_eqtb(p);
  269.     print_char('}');
  270.     end_diagnostic(FALSE);
  271. }
  272. #endif
  273.  
  274. /*
  275.  *  Help text
  276.  */
  277.  
  278. help_offsave_xtra ()
  279. {   
  280.     help1("Things are pretty mixed up, but I think the worst is over.");
  281. }
  282.  
  283. help_offsave_missing ()
  284. {
  285.     help5("I've inserted something that you may have forgotten.",
  286.     "(See the <inserted text> above.)",
  287.     "With luck, this will get me unwedged. But if you",
  288.     "really didn't forget anything, try typing `2' now; then",
  289.     "my insertion and my current dilemma will both disappear.");
  290. }
  291.