home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / Tex29 / StTeXsrc.zoo / src / def.c < prev    next >
C/C++ Source or Header  |  1988-03-13  |  24KB  |  1,015 lines
  1.  
  2. /*
  3.  * @(#)def.c 2.7 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 "eqstack.h"
  15. #include "evalstack.h"
  16. #include "hash.h"
  17. #include "token.h"
  18. #include "scan.h"
  19. #include "tokenstack.h"
  20. #include "expand.h"
  21. #include "box.h"
  22. #include "boxlists.h"
  23. #include "tokenlists.h"
  24. #include "file.h"
  25. #include "tfm.h"
  26. #include "dvi.h"
  27. #include "page.h"
  28. #include "def.h"
  29.  
  30. hword   after_token;
  31. bool    long_help_seen;
  32. val     mag_set;
  33.  
  34. #define glob    (a >= 4)
  35.  
  36. #define def(code, type, value) \
  37.     {if (glob) \
  38.         geq_define(code, type, value); \
  39.     else eq_define(code, type, value);}
  40.  
  41. #define word_def(code, value) \
  42.     {if (glob) \
  43.         geq_word_define(code, value); \
  44.     else eq_word_define(code, value);}
  45.  
  46. get_r_token ()
  47. {
  48. restart:
  49.     do get_token();
  50.     while (cur_tok == SPACE_TOKEN);
  51.     if (cur_cs == 0 || cur_cs > FROZEN_CONTROL_SEQUENCE) {
  52.         print_err("Missing control sequence inserted");
  53.         help_missing_cs();
  54.         if (cur_cs == 0) back_input();
  55.         cur_tok = CS_TOKEN_FLAG + FROZEN_PROTECTION;
  56.         ins_error();
  57.         goto restart;
  58.     }
  59. }
  60.  
  61. prefixed_command ()
  62. {
  63.     int     a;
  64.     bool    e;
  65.     fnt     f;
  66.     int     j;
  67.     int     k;
  68.     val     n;
  69.     ptr     p;
  70.     ptr     q;
  71.     ptr     r;
  72.  
  73.     a = 0;
  74.     while (cur_cmd == PREFIX) {
  75.         if (!odd(a / cur_chr))
  76.             a += cur_chr;
  77.         get_nbrx_token();
  78.         if (cur_cmd <= MAX_NON_PREFIXED_COMMAND) {
  79.             print_err("You can't use a prefix with `");
  80.             print_cmd_chr(cur_cmd, cur_chr);
  81.             print("'");
  82.             help_prefix();
  83.             back_error();
  84.             return;
  85.         }
  86.     }
  87.  
  88.     if (cur_cmd != DEF && a % 4 != 0) {
  89.         print_err("You can't use `");
  90.         print_esc("long");
  91.         print("' or `");
  92.         print_esc("outer");
  93.         print("' with `");
  94.         print_cmd_chr(cur_cmd, cur_chr);
  95.         print("'");
  96.         help_pref();
  97.         error();
  98.     }
  99.  
  100.     if (global_defs != 0) {
  101.         if (global_defs < 0) {
  102.             if (glob) a -= 4;
  103.         } else {
  104.             if (!glob) a += 4;
  105.         }
  106.     }
  107.  
  108.     switch (cur_cmd)
  109.     {
  110.     case SET_FONT:
  111.         def(CUR_FONT_LOC, DATA, cur_chr);
  112.         break;
  113.  
  114.     case DEF:
  115.         if (odd(cur_chr) && !glob && global_defs >= 0)
  116.             a += 4;
  117.         e = (cur_chr >= 2);
  118.         get_r_token();
  119.         p = cur_cs;
  120.         scan_toks(TRUE, e);
  121.         def(p, CALL + (a % 4), def_ref);
  122.         break;
  123.  
  124.     case LET:
  125.         n = cur_chr;
  126.         get_r_token();
  127.         p = cur_cs;
  128.         if (n == NORMAL) {
  129.             do  get_token();
  130.             while (cur_cmd == SPACER);
  131.             if (cur_tok == OTHER_TOKEN + '=') {
  132.                 get_token();
  133.                 if (cur_cmd == SPACER)
  134.                     get_token();
  135.             }
  136.         } else {
  137.             get_token();
  138.             q = cur_tok;
  139.             get_token();
  140.             back_input();
  141.             cur_tok = q;
  142.             back_input();
  143.         }
  144.         if (cur_cmd >= CALL)
  145.             add_token_ref(cur_chr);
  146.         def(p, cur_cmd, cur_chr);
  147.         break;
  148.     
  149.     case SHORTHAND_DEF:
  150.         n = cur_chr;
  151.         get_r_token();
  152.         p = cur_cs; 
  153.         def(p, RELAX, 256);
  154.         scan_optional_equals();
  155.         switch ((hword) n)
  156.         {
  157.         case CHAR_DEF_CODE:
  158.             scan_char_num();
  159.             def(p, CHAR_GIVEN, (hword) cur_val);
  160.             break;
  161.  
  162.         case MATH_CHAR_DEF_CODE:
  163.             scan_fifteen_bit_int();
  164.             def(p, MATH_GIVEN, (hword) cur_val);
  165.             break;
  166.  
  167.         default:
  168.             scan_eight_bit_int();
  169.             switch ((hword) n)
  170.             {
  171.             case COUNT_DEF_CODE:
  172.                 def(p, ASSIGN_INT, (hword) (COUNT_BASE + cur_val));
  173.                 break;
  174.  
  175.             case DIMEN_DEF_CODE:
  176.                 def(p, ASSIGN_DIMEN, (hword) (SCALED_BASE + cur_val));
  177.                 break;
  178.  
  179.             case SKIP_DEF_CODE:
  180.                 def(p, ASSIGN_GLUE, (hword) (SKIP_BASE + cur_val));
  181.                 break;
  182.  
  183.             case MU_SKIP_DEF_CODE:
  184.                 def(p, ASSIGN_MU_GLUE, (hword) (MU_SKIP_BASE + cur_val));
  185.                 break;
  186.  
  187.             case TOKS_DEF_CODE:
  188.                 def(p, ASSIGN_TOKS, (hword) (TOKS_BASE + cur_val));
  189.                 break;
  190.             }
  191.             break;
  192.         }
  193.         break;
  194.  
  195.     case READ_TO_CS:
  196.         scan_int();
  197.         n = (int) cur_val;
  198.         if (!scan_keyword("to")) {
  199.             print_err("Missing `to' inserted");
  200.             help_read_to();
  201.             error();
  202.         }
  203.         get_r_token();
  204.         p = cur_cs;
  205.         read_toks(n, p);
  206.         def(p, CALL, (hword) cur_val);
  207.         break;
  208.     
  209.     case TOKS_REGISTER:
  210.     case ASSIGN_TOKS:
  211.         q = cur_cs;
  212.         if (cur_cmd == TOKS_REGISTER) {
  213.             scan_eight_bit_int();
  214.             p = TOKS_BASE + cur_val;
  215.         } else p = cur_chr;
  216.         scan_optional_equals();
  217.         get_nbrx_token();
  218.         if (cur_cmd != LEFT_BRACE) {
  219.             if (cur_cmd == TOKS_REGISTER) {
  220.                 scan_eight_bit_int();
  221.                 cur_cmd = ASSIGN_TOKS;
  222.                 cur_chr = TOKS_BASE + cur_val;
  223.             }
  224.             if (cur_cmd == ASSIGN_TOKS) {
  225.                 q = equiv(cur_chr);
  226.                 if (q == NULL) {
  227.                     def(p, UNDEFINED_CS, NULL);
  228.                 } else {    
  229.                     add_token_ref(q);
  230.                     def(p, CALL, q);
  231.                 }
  232.                 break;
  233.             }
  234.         }
  235.         back_input();
  236.         cur_cs = q;
  237.         q = scan_toks(FALSE, FALSE);
  238.         if (token_link(def_ref) == NULL) {
  239.             def(p, UNDEFINED_CS, NULL);
  240.             free_token(def_ref);
  241.         } else {
  242.             if (p == OUTPUT_ROUTINE_LOC) {
  243.                 token_link(q) = new_token();
  244.                 q = token_link(q);
  245.                 token(q) = RIGHT_BRACE_TOKEN + '}';
  246.                 q = new_token();
  247.                 token(q) = LEFT_BRACE_TOKEN + '{';
  248.                 token_link(q) = token_link(def_ref);
  249.                 token_link(def_ref) = q;
  250.             }
  251.             def(p, CALL, def_ref);
  252.         }
  253.         break;
  254.  
  255.     case ASSIGN_INT:
  256.         p = cur_chr;
  257.         scan_optional_equals();
  258.         scan_int();
  259.         word_def(p, cur_val); 
  260.         break;
  261.     
  262.     case ASSIGN_DIMEN:
  263.         p = cur_chr;
  264.         scan_optional_equals();
  265.         scan_normal_dimen();
  266.         word_def(p, cur_val); 
  267.         break;
  268.     
  269.     case ASSIGN_GLUE:
  270.     case ASSIGN_MU_GLUE:
  271.         p = cur_chr;
  272.         n = cur_cmd;
  273.         scan_optional_equals();
  274.         if (n == ASSIGN_MU_GLUE)
  275.             scan_glue(MU_VAL);
  276.         else scan_glue(GLUE_VAL);
  277.         trap_zero_glue();
  278.         def(p, GLUE_REF, (ptr) cur_val); 
  279.         break;
  280.     
  281.     case DEF_CODE:
  282.         if (cur_chr == CAT_CODE_BASE)
  283.             n = MAX_CHAR_CODE;
  284.         else if (cur_chr == MATH_CODE_BASE)
  285.             n = 0100000;
  286.         else if (cur_chr == SF_CODE_BASE)
  287.             n = 077777;
  288.         else if (cur_chr == DEL_CODE_BASE)
  289.             n = 077777777;
  290.         else n = 127;
  291.         p = cur_chr;
  292.         scan_seven_bit_int();
  293.         p += cur_val;
  294.         scan_optional_equals();
  295.         scan_int(); 
  296.         if (cur_val < 0 && p < DEL_CODE_BASE || cur_val > n) {
  297.             print_err("Invalid code (");
  298.             print_val(cur_val);
  299.             if (p < DEL_CODE_BASE)
  300.                 print("), should be in the range 0..");
  301.             else print("), should be at most ");
  302.             print_val(n);
  303.             help_code();
  304.             error();
  305.             cur_val = 0;
  306.         }
  307.         if (p < MATH_CODE_BASE) {
  308.             def(p, DATA, (hword) cur_val);
  309.         } else if (p < DEL_CODE_BASE) {
  310.             def(p, DATA, (hword) hi(cur_val));
  311.         } else word_def(p, cur_val);
  312.         break;
  313.     
  314.     case DEF_FAMILY:
  315.         p = cur_chr;
  316.         scan_four_bit_int();
  317.         p += cur_val;
  318.         scan_optional_equals();
  319.         scan_font_ident();
  320.         def(p, DATA, (hword) cur_val);
  321.         break;
  322.  
  323.     case REGISTER:
  324.     case ADVANCE:
  325.     case MULTIPLY:
  326.     case DIVIDE:
  327.         do_register_command(a);
  328.         break;
  329.     
  330.     case SET_BOX:
  331.         scan_eight_bit_int();
  332.         if (glob)
  333.             saved(0) = BOX_FLAG + 256 + cur_val;
  334.         else saved(0) = BOX_FLAG + cur_val;
  335.         scan_optional_equals();
  336.         scan_box();
  337.         break;
  338.     
  339.     case SET_AUX:
  340.         alter_aux();
  341.         break;
  342.  
  343.     case SET_PREV_GRAF:
  344.         alter_prev_graf();
  345.         break;
  346.         
  347.     case SET_PAGE_DIMEN:
  348.         alter_page_so_far();
  349.         break;
  350.  
  351.     case SET_PAGE_INT:
  352.         alter_integer();
  353.         break;
  354.  
  355.     case SET_BOX_DIMEN:
  356.         alter_box_dimen();
  357.         break;
  358.  
  359.     case SET_SHAPE:
  360.         scan_optional_equals();
  361.         scan_int();
  362.         n = cur_val;
  363.         if (n <= 0)
  364.             p = NULL;
  365.         else {
  366.             p = get_node(2 * n + 1);
  367.             info(p) = n;
  368.             for (j = 1; j <= n; incr(j)) {
  369.                 scan_normal_dimen();
  370.                 mem[p + 2 * j - 1].sc = cur_val;
  371.                 scan_normal_dimen();
  372.                 mem[p + 2 * j].sc = cur_val;
  373.             }
  374.         }
  375.         def(PAR_SHAPE_LOC, SHAPE_REF, p);
  376.         break;
  377.     
  378.     case HYPH_DATA:
  379. #ifdef  INIT
  380.         if (cur_chr == 1) 
  381.             new_patterns();
  382. #else
  383.         if (cur_chr == 1) {
  384.             print_err("Patterns can only be loaded by INITEX");
  385.             error();
  386.         }
  387. #endif
  388.         else new_hyph_exceptions();
  389.         break;
  390.     
  391.     case ASSIGN_FONT_DIMEN:
  392.         find_font_dimen(TRUE);
  393.         k = cur_val;
  394.         scan_optional_equals();
  395.         scan_normal_dimen();
  396.         font_info[k].sc = cur_val;
  397.         break;
  398.     
  399.     case ASSIGN_FONT_INT:
  400.         n = cur_chr;
  401.         scan_font_ident();
  402.         f = cur_val;
  403.         scan_optional_equals();
  404.         scan_int(); 
  405.         if (n == 0)
  406.             hyphen_char[f] = cur_val;
  407.         else skew_char[f] = cur_val;
  408.         break;
  409.  
  410.     case DEF_FONT:
  411.         new_font(a);
  412.         break;
  413.  
  414.     case SET_INTERACTION:
  415.         new_interaction();
  416.         break;
  417.  
  418.     default:
  419.         confusion("prefix");
  420.         break;
  421.     }
  422.     if (after_token != 0) {
  423.         cur_tok = after_token;
  424.         back_input();
  425.         after_token = 0;
  426.     }
  427. } 
  428.  
  429. trap_zero_glue()
  430. {
  431.     if (width(cur_val) == 0 &&
  432.         stretch(cur_val) == 0 &&
  433.         shrink(cur_val) == 0) {
  434.         add_glue_ref(zero_glue);
  435.         delete_glue_ref(cur_val);
  436.         cur_val = zero_glue;
  437.     }
  438. }
  439.  
  440. do_register_command (a)
  441.     int     a;
  442. {
  443.     ptr     l;
  444.     ptr     p;
  445.     ptr     q;
  446.     ptr     r;
  447.     ptr     s;
  448.  
  449.     q = cur_cmd;
  450.     if (q != REGISTER) {
  451.         get_x_token();
  452.         if (cur_cmd >= ASSIGN_INT && cur_cmd <= ASSIGN_MU_GLUE) {
  453.             l = cur_chr;
  454.             p = cur_cmd - ASSIGN_INT;
  455.             goto found;
  456.         }
  457.         if (cur_cmd != REGISTER) {
  458.             print_err("You can't use `");
  459.             print_cmd_chr(cur_cmd, cur_chr);
  460.             print("' after ");
  461.             print_cmd_chr(q, 0);
  462.             help_register();
  463.             error();
  464.             return;
  465.         }
  466.     }
  467.     p = cur_chr;
  468.     scan_eight_bit_int();
  469.     switch (p) 
  470.     {
  471.     case INT_VAL:
  472.         l = cur_val + COUNT_BASE;
  473.         break;
  474.  
  475.     case DIMEN_VAL:
  476.         l = cur_val + SCALED_BASE;
  477.         break;
  478.         
  479.     case GLUE_VAL:
  480.         l = cur_val + SKIP_BASE;
  481.         break;
  482.         
  483.     case MU_VAL:
  484.         l = cur_val + MU_SKIP_BASE;
  485.         break;
  486.     }
  487.  
  488. found:
  489.     if (q == REGISTER)
  490.         scan_optional_equals();
  491.     else scan_keyword("by");
  492.     arith_error = FALSE;
  493.     if (q < MULTIPLY)  {
  494.         if (p < GLUE_VAL) {
  495.             if (p == INT_VAL)
  496.                 scan_int();
  497.             else scan_normal_dimen();
  498.             if (q == ADVANCE)
  499.                 cur_val += eqtb[l].i;
  500.         } else {
  501.             scan_glue(p);
  502.             if (q == ADVANCE) {
  503.                 q = new_spec(cur_val);
  504.                 r = equiv(l);
  505.                 delete_glue_ref(cur_val);
  506.                 width(q) += width(r);
  507.                 if (stretch(q) == 0)
  508.                     stretch_order(q) = NORMAL;
  509.                 if (stretch_order(q) == stretch_order(r)) {
  510.                     stretch(q) += stretch(r);
  511.                 } else if (stretch_order(q) < stretch_order(r) && stretch(r)) {
  512.                     stretch(q) = stretch(r);
  513.                     stretch_order(q) = stretch_order(r);
  514.                 }
  515.                 if (shrink(q) == 0)
  516.                     shrink_order(q) = NORMAL;
  517.                 if (shrink_order(q) == shrink_order(r)) {
  518.                     shrink(q) += shrink(r);
  519.                 } else if (shrink_order(q) < shrink_order(r) && shrink(r)) {
  520.                     shrink(q) = shrink(r); 
  521.                     shrink_order(q) = shrink_order(r);
  522.                 }
  523.                 cur_val = q;
  524.             }
  525.         }
  526.     } else {
  527.         scan_int();
  528.         if (p < GLUE_VAL) {
  529.             if (q == MULTIPLY)
  530.                 cur_val = nx_plus_y(eqtb[l].i, cur_val, 0L);
  531.             else cur_val = x_over_n(eqtb[l].i, cur_val);
  532.         } else {
  533.             s = equiv(l);
  534.             r = new_spec(s);
  535.             if (q == MULTIPLY) {
  536.                 width(r) = nx_plus_y(width(s), cur_val, 0L);
  537.                 stretch(r) = nx_plus_y(stretch(s), cur_val, 0L);
  538.                 shrink(r) = nx_plus_y(shrink(s), cur_val, 0L);
  539.             } else {
  540.                 width(r) = x_over_n(width(s), cur_val);
  541.                 stretch(r) = x_over_n(stretch(s), cur_val);
  542.                 shrink(r) = x_over_n(shrink(s), cur_val);
  543.             }
  544.             cur_val = r;
  545.         }
  546.     }
  547.     if (arith_error) {
  548.         print_err("Arithmetic overflow");
  549.         help_overflow();
  550.         error();
  551.         return;
  552.     }
  553.     if (p < GLUE_VAL) {
  554.         word_def(l, cur_val);
  555.     } else {
  556.         trap_zero_glue();
  557.         def(l, GLUE_REF, (ptr) cur_val);
  558.     }
  559. }
  560.  
  561. alter_aux()
  562. {
  563.     hword   c;
  564.  
  565.     if (cur_chr != abs(mode)) {
  566.         report_illegal_case();
  567.     } else {
  568.         c = cur_chr;
  569.         scan_optional_equals();
  570.         if (c == VMODE)  {
  571.             scan_normal_dimen();
  572.             prev_depth = cur_val;
  573.         } else {
  574.             scan_int();
  575.             if (cur_val <= 0 || cur_val > 32767) {
  576.                 print_err("Bad space factor");
  577.                 help_space_factor();
  578.                 int_error(cur_val);
  579.             } else {
  580.                 space_factor = cur_val;
  581.             }
  582.         }
  583.     }
  584. }
  585.  
  586. alter_prev_graf ()
  587. {
  588.     ptr     p;
  589.  
  590.     nest[nest_ptr] = cur_list;
  591.     p = nest_ptr;
  592.     while (abs(nest[p].mode_field) != VMODE)    
  593.         decr(p);
  594.     scan_optional_equals();
  595.     scan_int();
  596.     if (cur_val < 0) {
  597.         print_err("Bad ");
  598.         print_esc("prevgraf");
  599.         help_prevgraf();
  600.         int_error(cur_val);
  601.     } else {
  602.         nest[p].pg_field = cur_val;
  603.         cur_list = nest[nest_ptr];
  604.     }
  605. }
  606.  
  607. alter_page_so_far ()
  608. {
  609.     hword   c;
  610.  
  611.     c = cur_chr;
  612.     scan_optional_equals(); 
  613.     scan_normal_dimen();
  614.     page_so_far[c] = cur_val;
  615. }
  616.  
  617. alter_integer ()
  618. {
  619.     hword   c;
  620.     
  621.     c = cur_chr;
  622.     scan_optional_equals();
  623.     scan_int();
  624.     if (c == 0)
  625.         dead_cycles = cur_val;
  626.     else insert_penalties = cur_val;
  627. }
  628.  
  629. alter_box_dimen ()
  630. {
  631.     hword   b;
  632.     hword   c;
  633.     
  634.     c = cur_chr;
  635.     scan_eight_bit_int();
  636.     b = cur_val; 
  637.     scan_optional_equals();
  638.     scan_normal_dimen();
  639.     if (box(b) != NULL)
  640.         mem[box(b) + c].sc = cur_val;
  641. }
  642.  
  643. new_font (a)
  644.     int     a;
  645. {
  646.     fnt     f;
  647.     scal    s;
  648.     str     t;
  649.     ptr     u;
  650.     int     old_setting;
  651.  
  652.     if (job_name == 0)
  653.         open_log_file();
  654.     get_r_token();
  655.     u = cur_cs;
  656.     if (u >= HASH_BASE) {
  657.         t = text(u);
  658.     } else if (u >= SINGLE_BASE) {
  659.         if (u == NULL_CS)
  660.             t = make_str_given("FONT");
  661.         else t = u - SINGLE_BASE;
  662.     } else {
  663.         old_setting = selector;
  664.         selector = NEW_STRING;
  665.         print("FONT");
  666.         print_str(u - ACTIVE_BASE);
  667.         selector = old_setting;
  668.         str_room(1);
  669.         t = make_str();
  670.     }
  671.     def(u, SET_FONT, null_font);
  672.     scan_optional_equals();
  673.     scan_file_name();
  674.     name_in_progress = TRUE;
  675.     if (scan_keyword("at")) {
  676.         scan_normal_dimen();
  677.         s = cur_val;
  678.         if (s <= 0 || s >= 01000000000) {
  679.             print_err("Improper `at' size (");
  680.             print_scaled(s);
  681.             print("pt), replaced by 10pt");
  682.             help_font_at();
  683.             error();
  684.             s = 10 * UNITY;
  685.         }
  686.     } else if (scan_keyword("scaled")) {
  687.         scan_int();
  688.         s = -cur_val;
  689.         if (cur_val <= 0 || cur_val > 32768) {
  690.             print_err("Illegal magnification has been changed to 1000");
  691.             help_font_magnification();
  692.             int_error(cur_val);
  693.             s = -1000;
  694.         }
  695.     } else {
  696.         s = -1000;
  697.     }
  698.     name_in_progress = FALSE;
  699.     for (f = FONT_BASE + 1; f <= font_ptr; f++) {
  700.         if (str_eq_str(font_name[f], cur_name) &&
  701.             str_eq_str(font_area[f], cur_area)) {
  702.             if (s > 0) {
  703.                 if (s == font_size[f])
  704.                     goto common_end;
  705.             } else if (font_size[f] == xn_over_d(font_dsize[f], -s, 1000L)) {
  706.                 goto common_end;
  707.             }
  708.         }
  709.     }
  710.     f = read_font_info(u, cur_name, cur_area, s);
  711.  
  712. common_end:
  713.     equiv(u) = f;
  714.     eqtb[FONT_ID_BASE + f] = eqtb[u];
  715.     font_id_text(f) = t;
  716. }
  717.  
  718. prepare_mag ()
  719. {
  720.     if (mag_set > 0 && mag != mag_set) {
  721.         print_err("Incompatible magnification (");
  722.         print_val(mag);
  723.         print(");");
  724.         print_nl(" the previous value will be retained");
  725.         help_mag();
  726.         int_error(mag_set);
  727.         geq_word_define((ptr) INT_BASE + MAG_CODE, mag_set);
  728.     }
  729.     if (mag <= 0 || mag > 32768) {
  730.         print_err("Illegal magnification has been changed to 1000");
  731.         help_ill_mag();
  732.         int_error(mag);
  733.         geq_word_define((ptr) INT_BASE + MAG_CODE, 1000L);
  734.     }
  735.     mag_set = mag;
  736. }
  737.         
  738. new_interaction ()
  739. {
  740.     print_ln();
  741.     interaction = cur_chr;
  742.     if (interaction == BATCH_MODE)
  743.         selector = NO_PRINT;
  744.     else selector = TERM_ONLY;
  745.     if (job_name != 0)
  746.         selector += 2;
  747. }
  748.  
  749. do_assignments ()
  750. {
  751.     loop {
  752.         get_nbrx_token();
  753.         if (cur_cmd <= MAX_NON_PREFIXED_COMMAND)
  754.             break;
  755.         prefixed_command();
  756.     }
  757. }
  758.  
  759. clopen_stream ()
  760. {   
  761.     int     c;
  762.     int     n;
  763.  
  764.     c = cur_chr;
  765.     scan_four_bit_int();
  766.     n = cur_val; 
  767.     if (read_open[n] != CLOSED) {
  768.         a_close(read_file[n]);
  769.         read_open[n] = CLOSED;
  770.     }
  771.     if (c != 0) {
  772.         scan_optional_equals();
  773.         scan_file_name();
  774.         if (cur_ext == null_str)
  775.             cur_ext = str_tex;
  776.         pack_cur_name();
  777.         if (read_file[n] = a_open_in())
  778.             read_open[n] = JUST_OPENED;
  779.     }
  780. }
  781.  
  782. issue_message ()
  783. {
  784.     int     c;
  785.     str     s;
  786.     int     old_setting;
  787.  
  788.     c = cur_chr;
  789.     scan_toks(FALSE, TRUE);
  790.     old_setting = selector;
  791.     selector = NEW_STRING;
  792.     token_show(def_ref);
  793.     selector = old_setting;
  794.     flush_list(def_ref);
  795.     str_room(1);
  796.     s = make_str();
  797.     if (c == 0) {
  798.         if (term_offset + length(s) > MAX_PRINT_LINE - 2)
  799.             print_ln();
  800.         else if (term_offset > 0 || file_offset > 0)
  801.             print_char(' ');
  802.         print_str(s);
  803.         update_terminal();
  804.     } else {
  805.         print_err("");
  806.         print_str(s);
  807.         if (err_help != NULL)
  808.             use_err_help = TRUE;
  809.         else if (long_help_seen)
  810.             help_err_msg();
  811.         else {
  812.             if (interaction < ERROR_STOP_MODE)
  813.                 long_help_seen = TRUE;
  814.             help_poirot();
  815.         }
  816.         error();
  817.         use_err_help = FALSE;
  818.     }
  819.     flush_string();
  820. }
  821.  
  822. give_err_help ()
  823. {
  824.     token_show(err_help);
  825. }
  826.  
  827. shift_case ()
  828. {
  829.     ptr     b;
  830.     byte    c;
  831.     ptr     p;
  832.     tok     t;
  833.  
  834.     b = cur_chr;
  835.     scan_toks(FALSE, FALSE);
  836.     for (p = token_link(def_ref); p != NULL; p = token_link(p)) {
  837.         t = token(p);
  838.         if (t < CS_TOKEN_FLAG + SINGLE_BASE) {
  839.             if (t >= CS_TOKEN_FLAG)
  840.                 t -= ACTIVE_BASE;
  841.             c = t % 256;
  842.             if (c < 128 && equiv(b + c) != 0)
  843.                 t = 256 * (t / 256) + equiv(b + c);
  844.             if (t >= CS_TOKEN_FLAG)
  845.                 token(p) = t + ACTIVE_BASE;
  846.             else token(p) = t;
  847.         }
  848.     }
  849.     back_list(token_link(def_ref));
  850.     free_token(def_ref);
  851. }
  852.  
  853. show_whatever ()
  854. {
  855.     switch (cur_chr)
  856.     {
  857.     case SHOW_LISTS:
  858.         begin_diagnostic();
  859.         show_activities();
  860.         break;
  861.  
  862.     case SHOW_BOX_CODE:
  863.         scan_eight_bit_int();
  864.         begin_diagnostic();
  865.         print_nl("> \\box");
  866.         print_val(cur_val);
  867.         print_char('=');
  868.         if (box(cur_val) == NULL)
  869.             print("void");
  870.         else show_box(box(cur_val));
  871.         break;
  872.     
  873.     case SHOW_CODE:
  874.         get_token();
  875.         print_nl("> ");
  876.         if (cur_cs != 0) {
  877.             sprint_cs(cur_cs);
  878.             print_char('=');
  879.         }
  880.         print_meaning();
  881.         goto common_end;
  882.         break;
  883.     
  884.     default:
  885.         the_toks();
  886.         print_nl("> ");
  887.         token_show(temp_toks);
  888.         flush_list(token_link(temp_toks));
  889.         goto common_end;
  890.         break;
  891.     }
  892.     end_diagnostic(TRUE);
  893.     print_err("OK");
  894.     if (selector == TERM_AND_LOG && tracing_online <= 0) {
  895.         selector = TERM_ONLY;
  896.         print(" (see the transcript file)");
  897.         selector = TERM_AND_LOG;
  898.     }
  899.  
  900. common_end:
  901.     if (interaction < ERROR_STOP_MODE) {
  902.         help0();
  903.         decr(error_count);
  904.     } else if (tracing_online > 0)
  905.         help_show_online();
  906.     else help_show();
  907.     error();
  908. }
  909.  
  910. /*
  911.  *  Help text
  912.  */
  913.  
  914. help_missing_cs ()
  915. {
  916.     help5("Please don't say `\\def cs{...}', say `\\def\\cs{...}'.",
  917.     "I've inserted an inaccessible control sequence so that your",
  918.     "definition will be completed without mixing me up too badly.",
  919.     "You can recover graciously from this error, if you're",
  920.     "careful; see exercise 27.2 in The TeXbook.");
  921. }
  922.  
  923. help_prefix ()
  924. {
  925.     help1("I'll pretend you didn't say \\long or \\outer or \\global.");
  926. }
  927.  
  928. help_pref ()
  929. {
  930.     help1("I'll pretend you didn't say \\long or \\outer here.");
  931. }
  932.  
  933. help_read_to ()
  934. {
  935.     help2("You should have said `\\read<number> to \\cs'.",
  936.     "I'm going to look for the \\cs now.");
  937. }
  938.  
  939. help_code ()
  940. {
  941.     help1("I'm going to use 0 instead of that illegal code value.");
  942. }
  943.  
  944. help_register ()
  945. {
  946.     help1("I'm forgetting what you said and not changing anything.");
  947. }
  948.  
  949. help_space_factor ()
  950. {
  951.     help1("I allow only values in the range 1..32767 here.");
  952. }
  953.  
  954. help_prevgraf ()
  955. {
  956.     help1("I allow only nonnegative values here.");
  957. }
  958.  
  959. help_overflow ()
  960. {
  961.     help2("I can't carry out that multiplication or division,",
  962.     "since the result is out of range.");
  963. }
  964.  
  965. help_font_at ()
  966. {
  967.     help2("I can only handle fonts at positive sizes that are",
  968.     "less than 2048pt, so I've changed what you said to 10pt.");
  969. }
  970.  
  971. help_font_magnification ()
  972. {
  973.     help1("The magnification ratio must be between 1 and 32768.");
  974. }
  975.  
  976. help_mag()
  977. {
  978.     help2("I can handle only one magnification ratio per job. So I've",
  979.     "reverted to the magnification you used earlier on this run.");
  980. }
  981.  
  982. help_ill_mag ()
  983. {
  984.     help1("The magnification ratio must be between 1 and 32768.");
  985. }
  986.  
  987. help_err_msg ()
  988. {
  989.     help1("(That was another \\errmessage.)");
  990. }
  991.  
  992. help_poirot ()
  993. {
  994.     help4("This error message was generated by an \\errmessage",
  995.     "command, so I can't give any explicit help.",
  996.     "Pretend that you're Hercule Poirot: Examine all clues,",
  997.     "and deduce the truth by order and method.");
  998. }
  999.  
  1000. help_show_online ()
  1001. {
  1002.     help3("This isn't an error message; I'm just \\showing something.",
  1003.     "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1004.     "\\showthe\\count10, \\showbox255, \\showlists).");
  1005. }
  1006.  
  1007. help_show ()
  1008. {
  1009.     help5("This isn't an error message; I'm just \\showing something.",
  1010.     "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1011.     "\\showthe\\count10, \\showbox255, \\showlists).",
  1012.     "And type `I\\tracingonline=1\\show...' to show boxes and",
  1013.     "lists on your terminal as well as in the transcript file.");
  1014. }
  1015.