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