home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / TEKST / CMTEX330 / SOURCE / SYM.C < prev    next >
C/C++ Source or Header  |  1992-04-21  |  17KB  |  946 lines
  1.  
  2. /*
  3.  * %Y%:%M%:%I%:%Q%
  4.  *
  5.  * Copyright 1987,1988,1991,1992 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  *
  11.  */
  12.  
  13. #ifndef lint
  14. static char *sccsid = "%A%";
  15. #endif
  16.  
  17. #include "tex.h"
  18.  
  19. sym    cur_cs;
  20. sym    warning_cs;
  21.  
  22. sym    par_cs;
  23. sym    par_shape_cs;
  24. sym    undefined_cs;
  25. sym    null_cs;
  26.  
  27. #define HASH_SIZE    1231
  28.  
  29. sym    *active_base;
  30. sym    *single_base;
  31. sym    *hash_base;
  32. sym    *frozen_cs_base;
  33. sym    *font_id_base;
  34.  
  35. reg    *box_reg;
  36. reg    *mu_skip_reg;
  37. reg    *skip_reg;
  38. reg    *dimen_reg;
  39. reg    *int_reg;
  40. reg    *fnt_reg;
  41. reg    *toks_reg;
  42. reg    *cat_code_reg;
  43. reg    *lc_code_reg;
  44. reg    *uc_code_reg;
  45. reg    *sf_code_reg;
  46. reg    *math_code_reg;
  47. reg    *del_code_reg;
  48.  
  49.  
  50. ptr    hold_head;
  51. ptr    zero_glue;
  52. ptr    fil_glue;
  53. ptr     fill_glue;
  54. ptr    ss_glue;
  55. ptr    fil_neg_glue;
  56.  
  57. bool    no_new_control_sequence;
  58.  
  59. #ifdef STAT
  60. int    cs_count;
  61. #endif
  62.  
  63. int    cur_level;
  64. int    cur_group;
  65.  
  66. #define SAVE_SIZE    1000
  67. #define SAVE_INC    300
  68.  
  69. int    nsaves;
  70. reg    save_stack;
  71. reg    save_end;
  72. reg    save_ptr;
  73. reg    max_save_stack;
  74.  
  75. sym
  76. id_lookup (s, l)
  77.     str    s;
  78.     int    l;
  79. {
  80.     int    h;
  81.     int    k;
  82.     sym    c;
  83.     str    t;
  84.  
  85.     t = s;
  86.     h = *t++;
  87.     k = l - 1;
  88.     while (k--) {
  89.         h = h + h + *t++;
  90.         while (h >= HASH_SIZE) {
  91.             h -= HASH_SIZE;
  92.         }
  93.     }
  94.     for (c = hash_base[h]; c; c = hash(c)) {
  95.         if (length(c) == l && str_eqn(text(c), s, l)) {
  96.             return c;
  97.         }
  98.         if (hash(c) == null_sym) {
  99.             if (no_new_control_sequence) {
  100.                 return undefined_cs;
  101.             }
  102.             k = l;
  103.             str_room(k);
  104.             while (k--) {
  105.                 append_char(*s++);
  106.             }
  107.             c = hash(c) = new_sym(make_str(), l);
  108. #ifdef STAT
  109.             incr(cs_count);
  110. #endif
  111.             return c;
  112.         }
  113.     }
  114.     k = l;
  115.     str_room(k);
  116.     while (k--) {
  117.         append_char(*s++);
  118.     }
  119. #ifdef STAT
  120.     incr(cs_count);
  121. #endif
  122.     return (hash_base[h] = new_sym(make_str(), l));
  123. }
  124.  
  125. bool
  126. isactive (s)
  127.     sym    s;
  128. {
  129.     return (active_base[0] <= s && s <= active_base[255]);
  130. }
  131.  
  132. bool
  133. issingle (s)
  134.     sym    s;
  135. {
  136.     return (single_base[0] <= s && s <= single_base[255]);
  137. }
  138.  
  139. bool
  140. isfrozen (s)
  141.     sym    s;
  142. {
  143.     int    i;
  144.  
  145.     for (i = 1; i < FROZEN_CONTROLS; incr(i)) {
  146.         if (s == FROZEN_CONTROL_SEQUENCE[i]) {
  147.             return 1;
  148.         }
  149.     }
  150.     return 0;
  151. }
  152.  
  153. sym
  154. new_sym (s, l)
  155.     str    s;
  156.     int    l;
  157. {
  158.     sym    c;
  159.     
  160.     c = (sym) new_node(sizeof(sym_t));
  161.     eq_type(c) = UNDEFINED_CS;
  162.     eq_level(c) = LEVEL_ONE;
  163.     equiv(c) = 0;
  164.     text(c) = s;
  165.     length(c) = l;
  166.     hash(c) = null_sym;
  167.  
  168.     return  c;
  169. }
  170.  
  171. void
  172. print_cs (s)
  173.     sym    s;
  174. {    
  175.     str     t;
  176.     int    i;
  177.  
  178.     if (s == null_cs) {
  179.         print_esc("csname");
  180.         print_esc("endcsname");
  181.     } else if (isactive(s)) {
  182.         print_ASCII(textbyte(s));
  183.     } else if (issingle(s)) {
  184.         print_esc("");
  185.         print_ASCII(textbyte(s));
  186.         if (cat_code(textbyte(s)) == LETTER)
  187.             print(" ");
  188.     } else {
  189.         t = text(s);
  190.         print_esc(null_str);
  191.         for (i = 0; i < length(s); incr(i)) {
  192.             print_ASCII(t[i]);
  193.         }
  194.         print(" ");
  195.     }
  196. }
  197.  
  198. void
  199. sprint_cs (s)
  200.     sym    s;
  201. {
  202.     str     t;
  203.     int    i;
  204.  
  205.     if (s == null_cs) {
  206.         print_esc("csname");
  207.         print_esc("endcsname");
  208.     } else if (isactive(s)) {
  209.         print_ASCII(textbyte(s));
  210.     } else if (issingle(s)) {
  211.         print_esc("");
  212.         print_ASCII(textbyte(s));
  213.     } else {
  214.         t = text(s);
  215.         print_esc(null_str);
  216.         for (i = 0; i < length(s); incr(i)) {
  217.             print_ASCII(t[i]);
  218.         }
  219.     }
  220. }
  221.  
  222. sym
  223. primitive (s, code, order)
  224.     str    s;
  225.     int    code;
  226.     int    order;
  227. {
  228.     int    l;
  229.  
  230.     if (s[1] == NUL) {
  231.         cur_cs = single_base[s[0]];
  232.     } else {
  233.         l = str_length(s);
  234.         cur_cs = id_lookup(s, l);
  235.     }
  236.     eq_level(cur_cs) = LEVEL_ONE;
  237.     eq_type(cur_cs) = code;
  238.     equiv(cur_cs) = order;
  239.  
  240.     return cur_cs;
  241. }
  242.  
  243. sym
  244. freeze (s)
  245.     sym    s;
  246. {
  247.     sym    t;
  248.  
  249.     t = new_sym(text(s), length(s));
  250.     eq_level(t) = eq_level(s);
  251.     eq_type(t) = eq_type(s);
  252.     equiv(t) = equiv(s);
  253.  
  254.     return t;
  255. }
  256.  
  257. #define check_full_save_stack() \
  258. {    if (save_ptr > max_save_stack) { \
  259.         if (max_save_stack > save_end - 6 \
  260.         && !realloc_save_stack()) \
  261.             overflow("save size", nsaves); \
  262.         max_save_stack = save_ptr; \
  263.     } \
  264. }
  265.  
  266. bool
  267. realloc_save_stack ()
  268. {
  269.     reg    rtmp;
  270.     int    ntmp;
  271.  
  272.     nsaves += SAVE_INC;
  273.     ntmp = save_ptr - save_stack;
  274.     rtmp = (reg)realloc(save_stack, nsaves * sizeof(mcell));
  275.     if (rtmp == (reg) 0) {
  276.         overflow("save stack", nsaves);
  277.     }
  278.     save_stack = rtmp;
  279.     save_end = save_stack + nsaves - 1;
  280.     save_ptr = save_stack + ntmp;
  281. }
  282.  
  283. void
  284. new_save_level (c)
  285.     int    c;
  286. {
  287.     check_full_save_stack();
  288.     save_type(save_ptr) = LEVEL_BOUNDARY;
  289.     save_level(save_ptr) = cur_group;
  290.     if (cur_level == MAX_QUARTERWORD) {
  291.         overflow("grouping levels", MAX_QUARTERWORD - MIN_QUARTERWORD);
  292.     }
  293.     cur_group = c;
  294.     incr(cur_level);
  295.     incr(save_ptr);
  296. }
  297.  
  298. void
  299. reg_destroy (r)
  300.     reg    r;
  301. {
  302.     ptr    p;
  303.  
  304.     switch (reg_type(r))
  305.     {
  306.     case SET_SHAPE:
  307.         p = reg_equiv(r);
  308.         if (p != null) {
  309.             free_node(p, sizeof(mcell) + info(p) * sizeof(shape_t));
  310.         }
  311.         break;
  312.  
  313.     case CALL:
  314.     case LONG_CALL:
  315.     case LONG_OUTER_CALL:
  316.         delete_token_ref(reg_equiv(r));
  317.         break;
  318.  
  319.     case SKIP_REG:
  320.     case MU_SKIP_REG:
  321.         delete_glue_ref(reg_equiv(r));
  322.         break;
  323.  
  324.     case BOX_REG:
  325.         flush_node_list(reg_equiv(r));
  326.         break;
  327.  
  328.     case TOKS_REG:
  329.         if (reg_equiv(r) != null) {
  330.             delete_token_ref(reg_equiv(r));
  331.         }
  332.         break;
  333.     }
  334. }
  335.  
  336. void
  337. reg_save (r, l)
  338.     reg    r;
  339.     int    l;
  340. {
  341.     check_full_save_stack();
  342.     *save_ptr++ = *r;
  343.     save_type(save_ptr) = RESTORE_OLD_VALUE;
  344.     save_level(save_ptr) = l;
  345.     save_index(save_ptr) = (int) r;
  346.     incr(save_ptr);
  347. }
  348.  
  349. void
  350. eq_define (s, t, e)
  351.     sym    s;
  352.     int    t;
  353.     int    e;
  354. {
  355.     if (eq_level(s) == cur_level) {
  356.         reg_destroy(sym2reg(s));
  357.     } else if (cur_level > LEVEL_ONE) {
  358.         reg_save(sym2reg(s), eq_level(s));
  359.     }
  360.     eq_level(s) = cur_level;
  361.     eq_type(s) = t;
  362.     equiv(s) = e;
  363. }
  364.  
  365. void
  366. reg_define (r, t, e)
  367.     reg    r;
  368.     int    t;
  369.     int    e;
  370. {
  371.     if (reg_level(r) == cur_level) {
  372.         reg_destroy(r);
  373.     } else if (cur_level > LEVEL_ONE) {
  374.         reg_save(r, reg_level(r));
  375.     }
  376.     reg_level(r) = cur_level;
  377.     reg_type(r) = t;
  378.     reg_equiv(r) = e;
  379. }
  380.  
  381. void
  382. eq_gdefine (s, t, e)
  383.     sym    s;
  384.     int    t;
  385.     int    e;
  386. {
  387.     reg_destroy(sym2reg(s));
  388.     eq_level(s) = LEVEL_ONE;
  389.     eq_type(s) = t;
  390.     equiv(s) = e;
  391. }
  392.  
  393. void
  394. reg_gdefine (r, t, e)
  395.     reg    r;
  396.     int    t;
  397.     int    e;
  398. {
  399.     reg_destroy(r);
  400.     reg_level(r) = LEVEL_ONE;
  401.     reg_type(r) = t;
  402.     reg_equiv(r) = e;
  403. }
  404.  
  405. void
  406. save_for_after (t)
  407.     tok    t;
  408. {
  409.     if (cur_level > LEVEL_ONE) {
  410.         check_full_save_stack();
  411.         save_type(save_ptr) = INSERT_TOKEN;
  412.         save_level(save_ptr) = LEVEL_ZERO;
  413.         save_index(save_ptr) = t;
  414.         incr(save_ptr);
  415.     }
  416. }
  417.  
  418. void
  419. unsave ()
  420. {
  421.     reg    r;
  422.     tok    t;
  423.  
  424.     if (cur_level > LEVEL_ONE) {
  425.         decr(cur_level);
  426.         loop {
  427.             decr(save_ptr);
  428.             if (save_type(save_ptr) == LEVEL_BOUNDARY) {
  429.                 break;
  430.             }
  431.             r = (reg) save_index(save_ptr);
  432.             if (save_type(save_ptr) == INSERT_TOKEN) {
  433.                 t = cur_tok;
  434.                 cur_tok = (tok) r;
  435.                 back_input();
  436.                 cur_tok = t;
  437.             } else if (save_type(save_ptr) == RESTORE_OLD_VALUE) {
  438.                 decr(save_ptr);
  439.                 if (reg_level(r) == LEVEL_ONE) {
  440.                     reg_destroy(save_ptr);
  441.                     if (tracing_restores > 0) {
  442.                         restore_trace(r, "retaining");
  443.                     }
  444.                 } else {
  445.                     reg_destroy(r);
  446.                     *r = *save_ptr;
  447.                     if (tracing_restores > 0) {
  448.                         restore_trace(r, "restoring");
  449.                     }
  450.                 }
  451.             }
  452.         }
  453.         cur_group = save_level(save_ptr);
  454.     } else {
  455.         confusion("curlevel");
  456.     }
  457. }
  458.  
  459. void
  460. off_save ()
  461. {    
  462.     ptr    h;
  463.     ptr    p;
  464.  
  465.     if (cur_group == BOTTOM_LEVEL) {
  466.         print_err("Extra ");
  467.         print_cmd_chr(cur_cmd, cur_chr);
  468.         help_offsave_xtra();
  469.         error();
  470.     } else {
  471.         back_input();
  472.         h = p = new_token();
  473.         print_err("Missing ");
  474.         switch (cur_group) 
  475.         {
  476.         case SEMI_SIMPLE_GROUP:
  477.             token(p) = sym2tok(FROZEN_END_GROUP);
  478.             print_esc("endgroup");
  479.             break;
  480.         
  481.         case MATH_SHIFT_GROUP:
  482.             token(p) = MATH_SHIFT_TOKEN + '$';
  483.             print("$");
  484.             break;
  485.         
  486.         case MATH_LEFT_GROUP:
  487.             token(p) = sym2tok(FROZEN_RIGHT);
  488.             p = token_link(p) = new_token();
  489.             token(p) = OTHER_TOKEN + '.';
  490.             print_esc("right.");
  491.             break;
  492.         
  493.         default:
  494.             token(p) = RIGHT_BRACE_TOKEN + '}';
  495.             print("}");
  496.             break;
  497.         }
  498.         print(" inserted");
  499.         ins_list(h);
  500.         help_offsave_missing();
  501.         error();
  502.     }
  503. }
  504.  
  505. void
  506. restore_trace (r, s)
  507.     reg    r;
  508.     str    s;
  509. {
  510.     begin_diagnostic();
  511.     print("{");
  512.     print(s);
  513.     print(" ");
  514.     show_reg(r);
  515.     print("}");
  516.     end_diagnostic(FALSE);
  517. }
  518.  
  519. void
  520. show_reg (r)
  521.     reg    r;
  522. {
  523.     int    n;
  524.  
  525.     if (reg_type(r) < BOX_REG) {
  526.         sym s = (sym) r;
  527.         sprint_cs(s);
  528.         print("=");
  529.         if (s == par_shape_cs) {
  530.             if (par_shape_ptr == null) {
  531.                 print("0");
  532.             } else {
  533.                 print_int(info(par_shape_ptr));
  534.             }
  535.         } else {
  536.             print_cmd_chr(eq_type(s), equiv(s));
  537.             if (eq_type(s) >= CALL) {
  538.                 print(":");
  539.                 show_token_list(token_link(equiv(s)),
  540.                     null, 32);
  541.             }
  542.         }
  543.         return;
  544.     }
  545.     switch (reg_type(r))
  546.     {
  547.     case BOX_REG:
  548.         print_esc("box");
  549.         print_int(r - box_reg[0]);
  550.         print("=");
  551.         if (reg_equiv(r) == null) {
  552.             print("void");
  553.         } else {
  554.             depth_threshold = 0;
  555.             breadth_max = 1;
  556.             show_node_list(reg_equiv(r));
  557.         }
  558.         break;
  559.  
  560.     case MU_SKIP_REG:
  561.         n = r - mu_skip_reg[0];
  562.         if (n < MU_GLUE_PARS) {
  563.             print_mu_skip_param(n);
  564.             print("=");
  565.             print_spec(reg_equiv(r), "mu");
  566.         } else {
  567.             print_esc("muskip");
  568.             print_int(n - MU_GLUE_PARS);
  569.             print("=");
  570.             print_spec(reg_equiv(r), "mu");
  571.         }
  572.         break;
  573.  
  574.     case SKIP_REG:
  575.         n = r - skip_reg[0];
  576.         if (n < GLUE_PARS) {
  577.             print_skip_param(n);
  578.             print("=");
  579.             print_spec(reg_equiv(r), "pt");
  580.         } else {
  581.             print_esc("skip");
  582.             print_int(n - GLUE_PARS);
  583.             print("=");
  584.             print_spec(reg_equiv(r), "pt");
  585.         }
  586.         break;
  587.  
  588.     case DIMEN_REG:
  589.         n = r - dimen_reg[0];
  590.         if (n < DIMEN_PARS) {
  591.             print_length_param(n);
  592.         } else {
  593.             print_esc("dimen");
  594.             print_int(n - DIMEN_PARS);
  595.         }
  596.         print("=");
  597.         print_scaled(reg_equiv(r));
  598.         print("pt");
  599.         break;
  600.  
  601.     case INT_REG:
  602.         n = r - int_reg[0];
  603.         if (n < INT_PARS) {
  604.             print_param(n);
  605.         } else {
  606.             print_esc("count");
  607.             print_int(n - INT_PARS);
  608.         }
  609.         print("=");
  610.         print_int(reg_equiv(r));
  611.         break;
  612.  
  613.     case TOKS_REG:
  614.         n = r - toks_reg[0];
  615.         if (n < TOK_PARS) {
  616.             print_toks_param(n);
  617.         } else {
  618.             print_esc("toks");
  619.             print_int(n = TOK_PARS);
  620.         }
  621.         print("=");
  622.         if (reg_equiv(r) != null)
  623.             show_token_list(token_link(reg_equiv(r)),
  624.                 null, 32);
  625.         break;
  626.  
  627.     case FNT_REG:
  628.         n = r - fnt_reg[0];
  629.         if (n == 0) {
  630.             print("current font");
  631.         } else if (n <= 16) {
  632.             print_esc("textfont");
  633.             print_int(n - 1);
  634.         } else if (n <= 32) {
  635.             print_esc("scriptfont");
  636.             print_int(n - 17);
  637.         } else {
  638.             print_esc("scriptscriptfont");
  639.             print_int(n - 33);
  640.         }
  641.         print("=");
  642.         sprint_cs(font_id(reg_equiv(r)));
  643.         break;
  644.  
  645.     case CAT_CODE_REG:
  646.         print_esc("catcode");
  647.         print_int(r - cat_code_reg[0]);
  648.         print("=");
  649.         print_int(reg_equiv(r));
  650.         break;
  651.  
  652.     case LC_CODE_REG:
  653.         print_esc("lccode");
  654.         print_int(r - lc_code_reg[0]);
  655.         print("=");
  656.         print_int(reg_equiv(r));
  657.         break;
  658.  
  659.     case UC_CODE_REG:
  660.         print_esc("uccode");
  661.         print_int(r - uc_code_reg[0]);
  662.         print("=");
  663.         print_int(reg_equiv(r));
  664.         break;
  665.  
  666.     case SF_CODE_REG:
  667.         print_esc("sfcode");
  668.         print_int(r - sf_code_reg[0]);
  669.         print("=");
  670.         print_int(reg_equiv(r));
  671.         break;
  672.  
  673.     case MATH_CODE_REG:
  674.         print_esc("mathcode");
  675.         print_int(r - math_code_reg[0]);
  676.         print("=");
  677.         print_int(reg_equiv(r));
  678.         break;
  679.  
  680.     case DEL_CODE_REG:
  681.         print_esc("delcode");
  682.         print_int(r - del_code_reg[0]);
  683.         print("=");
  684.         print_int(reg_equiv(r));
  685.         break;
  686.  
  687.     default:
  688.         print("?");
  689.         break;
  690.     }
  691. }
  692.  
  693. sym *
  694. sym_alloc (i)
  695.     int    i;
  696. {
  697.     sym    *s;
  698.  
  699.     s = (sym *)malloc(i * sizeof(sym));
  700.     if (s == (sym *) 0) {
  701.         overflow("sym alloc", i);
  702.     }
  703.     while (i--) {
  704.         s[i] = null_sym;
  705.     }
  706.     return    s;
  707. }
  708.  
  709. reg *
  710. reg_alloc (i)
  711.     int    i;
  712. {
  713.     int    ii;
  714.     reg    r;
  715.     reg    *p;
  716.  
  717.     p = (reg *)malloc(i * sizeof(reg));
  718.     if (p == (reg *) 0) {
  719.         overflow("reg alloc", i);
  720.     }
  721.     r = (reg) malloc(i * sizeof(reg_t));
  722.     if (r == (reg) 0) {
  723.         overflow("reg alloc", i);
  724.     }
  725.     for (ii = 0; ii < i; ii++) {
  726.         p[ii] = r++;
  727.     }
  728.     return    p;
  729. }
  730.  
  731. void
  732. _sym_init ()
  733. {
  734.     cur_level = LEVEL_ONE;
  735.     cur_group = BOTTOM_LEVEL;
  736.     no_new_control_sequence = TRUE;
  737.     max_save_stack = save_ptr = save_stack;
  738.     cur_cs = null_sym;
  739.     warning_cs = null_sym;
  740. }
  741.  
  742. void
  743. _sym_init_once ()
  744. {
  745.     int    k;
  746.     sym    s;
  747.  
  748.     nsaves = SAVE_SIZE;
  749.     save_stack = (reg)malloc(nsaves * sizeof(mcell));
  750.     if (save_stack == (reg) 0) {
  751.         overflow("save stack", nsaves);
  752.     }
  753.     save_end = save_stack + nsaves - 1;
  754. #ifdef STAT
  755.     cs_count = 0;
  756. #endif
  757.  
  758.     active_base=sym_alloc(256);
  759.     single_base=sym_alloc(256);
  760.     hash_base=sym_alloc(HASH_SIZE);
  761.     frozen_cs_base=sym_alloc(FROZEN_CONTROLS);
  762.     font_id_base=sym_alloc(FONT_MAX);
  763.     box_reg=reg_alloc(256);
  764.     mu_skip_reg=reg_alloc(MU_GLUE_PARS + 256);
  765.     skip_reg=reg_alloc(GLUE_PARS + 256);
  766.     dimen_reg=reg_alloc(DIMEN_PARS + 256);
  767.     int_reg=reg_alloc(INT_PARS + 256);
  768.     toks_reg=reg_alloc(TOK_PARS + 256);
  769.     cat_code_reg=reg_alloc(256);
  770.     lc_code_reg=reg_alloc(256);
  771.     uc_code_reg=reg_alloc(256);
  772.     sf_code_reg=reg_alloc(256);
  773.     math_code_reg=reg_alloc(256);
  774.     del_code_reg=reg_alloc(256);
  775.     fnt_reg=reg_alloc(49);
  776.     hold_head=new_avail();
  777.  
  778.     zero_glue=new_node(GLUE_SPEC_SIZE);
  779.     glue_ref_count(zero_glue) = 0;
  780.     glue_width(zero_glue) = 0;
  781.     stretch(zero_glue) = 0;
  782.     stretch_order(zero_glue) = NORMAL;
  783.     shrink(zero_glue) = 0;
  784.     shrink_order(zero_glue) = NORMAL;
  785.  
  786.     fil_glue=new_spec(zero_glue);
  787.     stretch(fil_glue) = UNITY;
  788.     stretch_order(fil_glue) = FIL;
  789.  
  790.     fill_glue=new_spec(zero_glue);
  791.     stretch(fill_glue) = UNITY;
  792.     stretch_order(fill_glue) = FILL;
  793.  
  794.     ss_glue=new_spec(zero_glue);
  795.     stretch(ss_glue) = UNITY;
  796.     stretch_order(ss_glue) = FIL;
  797.     shrink(ss_glue) = UNITY;
  798.     shrink_order(ss_glue) = FIL;
  799.  
  800.     fil_neg_glue=new_spec(zero_glue);
  801.     stretch(fil_neg_glue) = -UNITY;
  802.     stretch_order(fil_neg_glue) = FIL;
  803.  
  804.     for (k = 0; k <= 48; incr(k)) {
  805.         reg_type(fnt_reg[k]) = FNT_REG;
  806.         reg_level(fnt_reg[k]) = LEVEL_ONE;
  807.         reg_equiv(fnt_reg[k]) = null_font;
  808.     }
  809.     undefined_cs = new_sym("undefined", 9);
  810.     null_cs = new_sym("",0);
  811.     s = (sym)malloc(256 * sizeof(sym_t));
  812.     if (s == (sym) 0) {
  813.         overflow("active cs alloc", 256);
  814.     }
  815.     for (k = 0; k < 256; incr(k), incr(s)) {
  816.         active_base[k] = s;
  817.         hash(s) = null_sym;
  818.         append_char(k);
  819.         text(s) = make_str();
  820.         length(s) = 1;
  821.         eq_type(s) = UNDEFINED_CS;
  822.         eq_level(s) = LEVEL_ONE;
  823.         equiv(s) = 0;
  824.     }
  825.     s = (sym)malloc(256 * sizeof(sym_t));
  826.     if (s == (sym) 0) {
  827.         overflow("single cs alloc", 256);
  828.     }
  829.     for (k = 0; k < 256; incr(k), incr(s)) {
  830.         single_base[k] = s;
  831.         hash(s) = null_sym;
  832.         append_char(k);
  833.         text(s) = make_str();
  834.         length(s) = 1;
  835.         eq_type(s) = UNDEFINED_CS;
  836.         eq_level(s) = LEVEL_ZERO;
  837.         equiv(s) = 0;
  838.     }
  839.     s = (sym)malloc(FONT_MAX * sizeof(sym_t));
  840.     if (s == (sym) 0) {
  841.         overflow("font id cs alloc", FONT_MAX);
  842.     }
  843.     for (k = 0; k < FONT_MAX; incr(k), incr(s)) {
  844.         font_id_base[k] = s;
  845.         hash(s) = null_sym;
  846.         text(s) = null_str;
  847.         length(s) = 0;
  848.         eq_type(s) = UNDEFINED_CS;
  849.         eq_level(s) = LEVEL_ZERO;
  850.     }
  851.     for (k = 0; k < TOK_PARS + 256; incr(k)) {
  852.         reg_type(toks_reg[k]) = TOKS_REG;
  853.         reg_level(toks_reg[k]) = LEVEL_ZERO;
  854.         reg_equiv(toks_reg[k]) = null;
  855.     }
  856.     for (k = 0; k < MU_GLUE_PARS + 256; incr(k)) {
  857.         reg_type(mu_skip_reg[k]) = MU_SKIP_REG;
  858.         reg_level(mu_skip_reg[k]) = LEVEL_ONE;
  859.         reg_equiv(mu_skip_reg[k]) = zero_glue;
  860.     }
  861.     for (k = 0; k < GLUE_PARS + 256; incr(k)) {
  862.         reg_type(skip_reg[k]) = SKIP_REG;
  863.         reg_level(skip_reg[k]) = LEVEL_ONE;
  864.         reg_equiv(skip_reg[k]) = zero_glue;
  865.     }
  866.     glue_ref_count(zero_glue) += 512 + MU_GLUE_PARS + GLUE_PARS;
  867.     for (k = 0; k < INT_PARS + 256; incr(k)) {
  868.         reg_type(int_reg[k]) = INT_REG;
  869.         reg_level(int_reg[k]) = LEVEL_ONE;
  870.         reg_equiv(int_reg[k]) = 0;
  871.     }
  872.     mag = 1000;
  873.     tolerance = 10000;
  874.     hang_after = 1;
  875.     max_dead_cycles = 25;
  876.     escape_char = '\\';
  877.     end_line_char = CARRIAGE_RETURN;
  878.     for (k = 0; k < DIMEN_PARS + 256; incr(k)) {
  879.         reg_type(dimen_reg[k]) = DIMEN_REG;
  880.         reg_level(dimen_reg[k]) = LEVEL_ONE;
  881.         reg_equiv(dimen_reg[k]) = 0;
  882.     }
  883.     for (k = 0; k < 256; incr(k)) {
  884.         reg_type(box_reg[k]) = BOX_REG;
  885.         reg_level(box_reg[k]) = LEVEL_ONE;
  886.         reg_equiv(box_reg[k]) = null;
  887.     }    
  888.     for (k = 0; k < 256; incr(k)) {
  889.         reg_type(cat_code_reg[k]) = CAT_CODE_REG;
  890.         reg_level(cat_code_reg[k]) = LEVEL_ONE;
  891.         reg_equiv(cat_code_reg[k]) = OTHER_CHAR;
  892.         reg_type(lc_code_reg[k]) = LC_CODE_REG;
  893.         reg_level(lc_code_reg[k]) = LEVEL_ONE;
  894.         reg_equiv(lc_code_reg[k]) = 0;
  895.         reg_type(uc_code_reg[k]) = UC_CODE_REG;
  896.         reg_level(uc_code_reg[k]) = LEVEL_ONE;
  897.         reg_equiv(uc_code_reg[k]) = 0;
  898.         reg_type(sf_code_reg[k]) = SF_CODE_REG;
  899.         reg_level(sf_code_reg[k]) = LEVEL_ONE;
  900.         reg_equiv(sf_code_reg[k]) = 1000;
  901.         reg_type(math_code_reg[k]) = MATH_CODE_REG;
  902.         reg_level(math_code_reg[k]) = LEVEL_ONE;
  903.         reg_equiv(math_code_reg[k]) = k;
  904.         reg_type(del_code_reg[k]) = DEL_CODE_REG;
  905.         reg_level(del_code_reg[k]) = LEVEL_ONE;
  906.         reg_equiv(del_code_reg[k]) = -1;
  907.     }
  908.     cat_code(CARRIAGE_RETURN) = CAR_RET;
  909.     cat_code(' ') = SPACER;
  910.     cat_code('^') = SUP_MARK;
  911.     cat_code('\\') = ESCAPE;
  912.     cat_code('%') = COMMENT;
  913.     cat_code(INVALID_CODE) = INVALID_CHAR;
  914.     cat_code(NULL_CODE) = IGNORE;
  915.     for (k = '0'; k <= '9'; incr(k)) {
  916.         math_code(k) = k + VAR_CODE;
  917.     }
  918.     for (k = 'A'; k <= 'Z'; incr(k)) {
  919.         cat_code(k) = cat_code(k + 'a' - 'A') = LETTER;
  920.         math_code(k) = k + VAR_CODE + 0x100;
  921.         math_code(k + 'a' - 'A') = k + 'a' - 'A'+ VAR_CODE + 0x100;
  922.         lc_code(k) = lc_code(k + 'a' - 'A') = k + 'a' - 'A';
  923.         uc_code(k) = uc_code(k + 'a' - 'A') = k;
  924.         sf_code(k) = 999;
  925.     }
  926.     del_code('.') = 0;
  927. }
  928.  
  929. /*
  930. **    Help text
  931. */
  932.  
  933. help_offsave_xtra ()
  934. {    
  935.     help1("Things are pretty mixed up, but I think the worst is over.");
  936. }
  937.  
  938. help_offsave_missing ()
  939. {
  940.     help5("I've inserted something that you may have forgotten.",
  941.     "(See the <inserted text> above.)",
  942.     "With luck, this will get me unwedged. But if you",
  943.     "really didn't forget anything, try typing `2' now; then",
  944.     "my insertion and my current dilemma will both disappear.");
  945. }
  946.