home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / Tex29 / StTeXsrc.zoo / src / eq.c < prev    next >
C/C++ Source or Header  |  1988-03-13  |  15KB  |  613 lines
  1.  
  2. /*
  3.  * @(#)eq.c 2.5 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "token.h"
  15. #include "box.h"
  16. #include "tfm.h"
  17.  
  18. mword   eqtb[EQTB_SIZE+1];
  19. qword   xeq_level[EQTB_SIZE+1 - INT_BASE];
  20.  
  21. print_skip_param (n)
  22.     int     n;
  23. {
  24.     switch (n)
  25.     {
  26.     case LINE_SKIP_CODE:
  27.         print_esc("lineskip"); 
  28.         break;
  29.  
  30.     case BASELINE_SKIP_CODE:
  31.         print_esc("baselineskip"); 
  32.         break;
  33.  
  34.     case PAR_SKIP_CODE:
  35.         print_esc("parskip"); 
  36.         break;
  37.  
  38.     case ABOVE_DISPLAY_SKIP_CODE:
  39.         print_esc("abovedisplayskip"); 
  40.         break;
  41.  
  42.     case BELOW_DISPLAY_SKIP_CODE:
  43.         print_esc("belowdisplayskip"); 
  44.         break;
  45.  
  46.     case ABOVE_DISPLAY_SHORT_SKIP_CODE:
  47.         print_esc("abovedisplayshortskip"); 
  48.         break;
  49.  
  50.     case BELOW_DISPLAY_SHORT_SKIP_CODE:
  51.         print_esc("belowdisplayshortskip"); 
  52.         break;
  53.  
  54.     case LEFT_SKIP_CODE:
  55.         print_esc("leftskip"); 
  56.         break;
  57.  
  58.     case RIGHT_SKIP_CODE:
  59.         print_esc("rightskip"); 
  60.         break;
  61.  
  62.     case TOP_SKIP_CODE:
  63.         print_esc("topskip"); 
  64.         break;
  65.  
  66.     case SPLIT_TOP_SKIP_CODE:
  67.         print_esc("splittopskip"); 
  68.         break;
  69.  
  70.     case TAB_SKIP_CODE:
  71.         print_esc("tabskip"); 
  72.         break;
  73.  
  74.     case SPACE_SKIP_CODE:
  75.         print_esc("spaceskip"); 
  76.         break;
  77.  
  78.     case XSPACE_SKIP_CODE:
  79.         print_esc("xspaceskip"); 
  80.         break;
  81.  
  82.     case PAR_FILL_SKIP_CODE:
  83.         print_esc("parfillskip"); 
  84.         break;
  85.  
  86.     case THIN_MU_SKIP_CODE:
  87.         print_esc("thinmuskip"); 
  88.         break;
  89.  
  90.     case MED_MU_SKIP_CODE:
  91.         print_esc("medmuskip"); 
  92.         break;
  93.  
  94.     case THICK_MU_SKIP_CODE:
  95.         print_esc("thickmuskip"); 
  96.         break;
  97.  
  98.     default:
  99.         print("[unknown glue parameter!]"); 
  100.         break;
  101.     }
  102. }
  103.  
  104. print_param (n)
  105.     int     n;
  106. {
  107.     switch (n)
  108.     {
  109.     case PRETOLERANCE_CODE:
  110.         print_esc("pretolerance"); 
  111.         break;
  112.  
  113.     case TOLERANCE_CODE:
  114.         print_esc("tolerance"); 
  115.         break;
  116.  
  117.     case LINE_PENALTY_CODE:
  118.         print_esc("linepenalty"); 
  119.         break;
  120.  
  121.     case HYPHEN_PENALTY_CODE:
  122.         print_esc("hyphenpenalty"); 
  123.         break;
  124.  
  125.     case EX_HYPHEN_PENALTY_CODE:
  126.         print_esc("exhyphenpenalty"); 
  127.         break;
  128.  
  129.     case CLUB_PENALTY_CODE:
  130.         print_esc("clubpenalty"); 
  131.         break;
  132.  
  133.     case WIDOW_PENALTY_CODE:
  134.         print_esc("widowpenalty"); 
  135.         break;
  136.  
  137.     case DISPLAY_WIDOW_PENALTY_CODE:
  138.         print_esc("displaywidowpenalty"); 
  139.         break;
  140.  
  141.     case BROKEN_PENALTY_CODE:
  142.         print_esc("brokenpenalty"); 
  143.         break;
  144.  
  145.     case BIN_OP_PENALTY_CODE:
  146.         print_esc("binoppenalty"); 
  147.         break;
  148.  
  149.     case REL_PENALTY_CODE:
  150.         print_esc("relpenalty"); 
  151.         break;
  152.  
  153.     case PRE_DISPLAY_PENALTY_CODE:
  154.         print_esc("predisplaypenalty"); 
  155.         break;
  156.  
  157.     case POST_DISPLAY_PENALTY_CODE:
  158.         print_esc("postdisplaypenalty"); 
  159.         break;
  160.  
  161.     case INTER_LINE_PENALTY_CODE:
  162.         print_esc("interlinepenalty"); 
  163.         break;
  164.  
  165.     case DOUBLE_HYPHEN_DEMERITS_CODE:
  166.         print_esc("doublehyphendemerits"); 
  167.         break;
  168.  
  169.     case FINAL_HYPHEN_DEMERITS_CODE:
  170.         print_esc("finalhyphendemerits"); 
  171.         break;
  172.  
  173.     case ADJ_DEMERITS_CODE:
  174.         print_esc("adjdemerits"); 
  175.         break;
  176.  
  177.     case MAG_CODE:
  178.         print_esc("mag"); 
  179.         break;
  180.  
  181.     case DELIMITER_FACTOR_CODE:
  182.         print_esc("delimiterfactor"); 
  183.         break;
  184.  
  185.     case LOOSENESS_CODE:
  186.         print_esc("looseness"); 
  187.         break;
  188.  
  189.     case TIME_CODE:
  190.         print_esc("time"); 
  191.         break;
  192.  
  193.     case DAY_CODE:
  194.         print_esc("day"); 
  195.         break;
  196.  
  197.     case MONTH_CODE:
  198.         print_esc("month"); 
  199.         break;
  200.  
  201.     case YEAR_CODE:
  202.         print_esc("year"); 
  203.         break;
  204.  
  205.     case SHOW_BOX_BREADTH_CODE:
  206.         print_esc("showboxbreadth"); 
  207.         break;
  208.  
  209.     case SHOW_BOX_DEPTH_CODE:
  210.         print_esc("showboxdepth"); 
  211.         break;
  212.  
  213.     case HBADNESS_CODE:
  214.         print_esc("hbadness"); 
  215.         break;
  216.  
  217.     case VBADNESS_CODE:
  218.         print_esc("vbadness"); 
  219.         break;
  220.  
  221.     case PAUSING_CODE:
  222.         print_esc("pause"); 
  223.         break;
  224.  
  225.     case TRACING_ONLINE_CODE:
  226.         print_esc("tracingonline"); 
  227.         break;
  228.  
  229.     case TRACING_MACROS_CODE:
  230.         print_esc("tracingmacros"); 
  231.         break;
  232.  
  233.     case TRACING_STATS_CODE:
  234.         print_esc("tracingstats"); 
  235.         break;
  236.  
  237.     case TRACING_PARAGRAPHS_CODE:
  238.         print_esc("tracingparagraphs"); 
  239.         break;
  240.  
  241.     case TRACING_PAGES_CODE:
  242.         print_esc("tracingpages"); 
  243.         break;
  244.  
  245.     case TRACING_OUTPUT_CODE:
  246.         print_esc("tracingoutput"); 
  247.         break;
  248.  
  249.     case TRACING_LOST_CHARS_CODE:
  250.         print_esc("tracinglostchars"); 
  251.         break;
  252.  
  253.     case TRACING_COMMANDS_CODE:
  254.         print_esc("tracingcommands"); 
  255.         break;
  256.  
  257.     case TRACING_RESTORES_CODE:
  258.         print_esc("tracingrestores"); 
  259.         break;
  260.  
  261.     case UC_HYPH_CODE:
  262.         print_esc("uchyph"); 
  263.         break;
  264.  
  265.     case OUTPUT_PENALTY_CODE:
  266.         print_esc("outputpenalty"); 
  267.         break;
  268.  
  269.     case MAX_DEAD_CYCLES_CODE:
  270.         print_esc("maxdeadcycles"); 
  271.         break;
  272.  
  273.     case HANG_AFTER_CODE:
  274.         print_esc("hangafter"); 
  275.         break;
  276.  
  277.     case FLOATING_PENALTY_CODE:
  278.         print_esc("floatingpenalty"); 
  279.         break;
  280.  
  281.     case GLOBAL_DEFS_CODE:
  282.         print_esc("globaldefs"); 
  283.         break;
  284.  
  285.     case CUR_FAM_CODE:
  286.         print_esc("fam"); 
  287.         break;
  288.  
  289.     case ESCAPE_CHAR_CODE:
  290.         print_esc("escapechar"); 
  291.         break;
  292.  
  293.     case DEFAULT_HYPHEN_CHAR_CODE:
  294.         print_esc("defaulthyphenchar"); 
  295.         break;
  296.  
  297.     case DEFAULT_SKEW_CHAR_CODE:
  298.         print_esc("defaultskewchar"); 
  299.         break;
  300.  
  301.     case END_LINE_CHAR_CODE:
  302.         print_esc("endlinechar"); 
  303.         break;
  304.  
  305.     case NEW_LINE_CHAR_CODE:
  306.         print_esc("newlinechar"); 
  307.         break;
  308.  
  309.     default:
  310.         print("[unknown integer parameter!]"); 
  311.         break;
  312.     }
  313. }
  314.  
  315. print_length_param (n)
  316.     int     n;
  317. {
  318.     switch (n)
  319.     {
  320.     case PAR_INDENT_CODE:
  321.         print_esc("parindent"); 
  322.         break;
  323.  
  324.     case MATH_SURROUND_CODE:
  325.         print_esc("mathsurround"); 
  326.         break;
  327.  
  328.     case LINE_SKIP_LIMIT_CODE:
  329.         print_esc("lineskiplimit"); 
  330.         break;
  331.  
  332.     case HSIZE_CODE:
  333.         print_esc("hsize"); 
  334.         break;
  335.  
  336.     case VSIZE_CODE:
  337.         print_esc("vsize"); 
  338.         break;
  339.  
  340.     case MAX_DEPTH_CODE:
  341.         print_esc("maxdepth"); 
  342.         break;
  343.  
  344.     case SPLIT_MAX_DEPTH_CODE:
  345.         print_esc("splitmaxdepth"); 
  346.         break;
  347.  
  348.     case BOX_MAX_DEPTH_CODE:
  349.         print_esc("boxmaxdepth"); 
  350.         break;
  351.  
  352.     case HFUZZ_CODE:
  353.         print_esc("hfuzz"); 
  354.         break;
  355.  
  356.     case VFUZZ_CODE:
  357.         print_esc("vfuzz"); 
  358.         break;
  359.  
  360.     case DELIMITER_SHORTFALL_CODE:
  361.         print_esc("delimitershortfall"); 
  362.         break;
  363.  
  364.     case NULL_DELIMITER_SPACE_CODE:
  365.         print_esc("nulldelimiterspace"); 
  366.         break;
  367.  
  368.     case SCRIPT_SPACE_CODE:
  369.         print_esc("scriptspace"); 
  370.         break;
  371.  
  372.     case PRE_DISPLAY_SIZE_CODE:
  373.         print_esc("predisplaysize"); 
  374.         break;
  375.  
  376.     case DISPLAY_INDENT_CODE:
  377.         print_esc("displayindent"); 
  378.         break;
  379.  
  380.     case DISPLAY_WIDTH_CODE:
  381.         print_esc("displaywidth"); 
  382.         break;
  383.  
  384.     case OVERFULL_RULE_CODE:
  385.         print_esc("overfullrule"); 
  386.         break;
  387.  
  388.     case HANG_INDENT_CODE:
  389.         print_esc("hangindent"); 
  390.         break;
  391.  
  392.     case H_OFFSET_CODE:
  393.         print_esc("hoffset"); 
  394.         break;
  395.  
  396.     case V_OFFSET_CODE:
  397.         print_esc("voffset"); 
  398.         break;
  399.  
  400.     default:
  401.         print("[unknown dimen parameter!]"); 
  402.         break;
  403.     }
  404. }
  405.  
  406. #ifdef STAT
  407. show_eqtb (n)
  408.     ptr     n;
  409. {
  410.     if (n < ACTIVE_BASE) {
  411.         print_char('?');
  412.     } else if (n < GLUE_BASE) {
  413.         sprint_cs(n);
  414.         print_char('=');
  415.         print_cmd_chr(eq_type(n), equiv(n));
  416.         if (eq_type(n) >= CALL) {
  417.             print_char(':');
  418.             show_token_list(token_link(equiv(n)), NULL, 32L);
  419.         }
  420.     } else if (n < LOCAL_BASE) {
  421.         if (n < SKIP_BASE) {
  422.             print_skip_param(n - GLUE_BASE);
  423.             print_char('=');
  424.             if (n < GLUE_BASE + THIN_MU_SKIP_CODE)
  425.                 print_spec(equiv(n), "pt");
  426.             else print_spec(equiv(n), "mu");
  427.         } else if (n < MU_SKIP_BASE) {
  428.             print_esc("skip");
  429.             print_int(n - SKIP_BASE); 
  430.             print_char('=');
  431.             print_spec(equiv(n), "pt");
  432.         } else {
  433.             print_esc("muskip");
  434.             print_int(n - MU_SKIP_BASE);
  435.             print_char('=');
  436.             print_spec(equiv(n), "mu");
  437.         }
  438.     } else if (n < INT_BASE) {
  439.         if (n == PAR_SHAPE_LOC) {
  440.             print_esc("parshape");
  441.             print_char('=');
  442.             if (par_shape_ptr == NULL)
  443.                 print_char('O');
  444.             else print_int(info(par_shape_ptr));
  445.         } else if (n < TOKS_BASE) {
  446.             print_cmd_chr(ASSIGN_TOKS, n);
  447.             print_char('=');
  448.             if (equiv(n) != NULL)
  449.                 show_token_list(token_link(equiv(n)), NULL, 32L);
  450.         } else if (n < BOX_BASE) {
  451.             print_esc("toks");
  452.             print_int(n - TOKS_BASE);
  453.             print_char('=');
  454.             if (equiv(n) != NULL)
  455.                 show_token_list(token_link(equiv(n)), NULL, 32L);
  456.         } else if (n < CUR_FONT_LOC) {
  457.             print_esc("box");
  458.             print_int(n - BOX_BASE);
  459.             print_char('=');
  460.             if (equiv(n) == NULL)
  461.                 print("void");
  462.             else {
  463.                 depth_threshold = 0;
  464.                 breadth_max = 1;
  465.                 show_node_list(equiv(n));
  466.             }
  467.         } else if (n < CAT_CODE_BASE) {
  468.             if (n == CUR_FONT_LOC)
  469.                 print("current font");
  470.             else if (n < MATH_FONT_BASE + 16) {
  471.                 print_esc("textfont");
  472.                 print_int(n - MATH_FONT_BASE);
  473.             } else if (n < MATH_FONT_BASE + 32) {
  474.                 print_esc("scriptfont");
  475.                 print_int(n - MATH_FONT_BASE - 16);
  476.             } else {
  477.                 print_esc("scriptscritpfont");
  478.                 print_int(n - MATH_FONT_BASE - 32);
  479.             }
  480.             print_char('=');
  481.             print_esc("");
  482.             print_str(hash[FONT_ID_BASE + equiv(n)].hh1.rh);
  483.         } else {
  484.             if (n < MATH_CODE_BASE) {
  485.                 if (n < LC_CODE_BASE) {
  486.                     print_esc("catcode");
  487.                     print_int(n - CAT_CODE_BASE);
  488.                 } else if (n < UC_CODE_BASE) {
  489.                     print_esc("lccode");
  490.                     print_int(n - LC_CODE_BASE);
  491.                 } else if (n < SF_CODE_BASE) {
  492.                     print_esc("uccode");
  493.                     print_int(n - UC_CODE_BASE);
  494.                 } else {
  495.                     print_esc("sfcode");
  496.                     print_int(n - SF_CODE_BASE);
  497.                 }
  498.                 print_char('=');
  499.                 print_int(equiv(n));
  500.             } else {
  501.                 print_esc("math_code");
  502.                 print_int(n - MATH_CODE_BASE);
  503.                 print_char('=');
  504.                 print_int(ho(equiv(n)));
  505.             }
  506.         }
  507.     } else if (n < DIMEN_BASE) {
  508.         if (n < COUNT_BASE)
  509.             print_param(n - INT_BASE);
  510.         else if (n < DEL_CODE_BASE) {
  511.             print_esc("count");
  512.             print_int(n - COUNT_BASE);
  513.         } else {
  514.             print_esc("delcode");
  515.             print_int(n - DEL_CODE_BASE);
  516.         }
  517.         print_char('=');
  518.         print_val(eqtb[n].i);
  519.     } else if (n <= EQTB_SIZE) {
  520.         if (n < SCALED_BASE) {
  521.             print_length_param(n - DIMEN_BASE);
  522.         } else {
  523.             print_esc("dimen");
  524.             print_int(n - SCALED_BASE);
  525.         }
  526.         print_char('=');
  527.         print_scaled(eqtb[n].sc);
  528.         print("pt");
  529.     } else {
  530.         print_char('?');
  531.     }
  532. }
  533. #endif
  534.  
  535. init_eq ()
  536. {
  537.     int     k;
  538.  
  539.     for (k = 0; k <= EQTB_SIZE - INT_BASE; incr(k))
  540.         xeq_level[k] = LEVEL_ONE;
  541.  
  542. #ifdef INIT
  543.     eq_type(UNDEFINED_CONTROL_SEQUENCE) = UNDEFINED_CS;
  544.     equiv(UNDEFINED_CONTROL_SEQUENCE) = NULL;
  545.     eq_level(UNDEFINED_CONTROL_SEQUENCE) = LEVEL_ZERO;
  546.     for (k = ACTIVE_BASE; k < UNDEFINED_CONTROL_SEQUENCE; incr(k))
  547.         eqtb[k]= eqtb[UNDEFINED_CONTROL_SEQUENCE];
  548.             
  549.     equiv(GLUE_BASE) = zero_glue;
  550.     eq_level(GLUE_BASE) = LEVEL_ONE;
  551.     eq_type(GLUE_BASE) = GLUE_REF;
  552.     for (k = GLUE_BASE + 1; k < LOCAL_BASE; incr(k))
  553.         eqtb[k] = eqtb[GLUE_BASE];
  554.     glue_ref_count(zero_glue) += LOCAL_BASE - GLUE_BASE;
  555.  
  556.     par_shape_ptr = NULL;
  557.     eq_type(PAR_SHAPE_LOC) = SHAPE_REF;
  558.     eq_level(PAR_SHAPE_LOC)= LEVEL_ONE;
  559.     for (k = OUTPUT_ROUTINE_LOC; k < TOKS_BASE + 256; incr(k))
  560.         eqtb[k] = eqtb[UNDEFINED_CONTROL_SEQUENCE];
  561.     box(0) = NULL;
  562.     eq_type(BOX_BASE) = BOX_REF;
  563.     eq_level(BOX_BASE) = LEVEL_ONE;
  564.     for (k = BOX_BASE + 1; k < BOX_BASE + 256; incr(k))
  565.         eqtb[k] = eqtb[BOX_BASE];
  566.     cur_font = null_font;
  567.     eq_type(CUR_FONT_LOC) = DATA;
  568.     eq_level(CUR_FONT_LOC) = LEVEL_ONE;
  569.     for (k = MATH_FONT_BASE; k < MATH_FONT_BASE + 48; incr(k))
  570.         eqtb[k] = eqtb[CUR_FONT_LOC];
  571.     equiv(CAT_CODE_BASE) = 0;
  572.     eq_type(CAT_CODE_BASE) = DATA;
  573.     eq_level(CAT_CODE_BASE) = LEVEL_ONE;
  574.     for (k = CAT_CODE_BASE; k < INT_BASE; incr(k))
  575.         eqtb[k] = eqtb[CAT_CODE_BASE];
  576.     for (k = 0; k <= 255; incr(k)) {
  577.         cat_code(k) = OTHER_CHAR;
  578.         math_code(k) = hi(k);
  579.         sf_code(k) = 1000;
  580.     }
  581.     cat_code(CARRIAGE_RETURN) = CAR_RET;
  582.     cat_code(' ') = SPACER;
  583.     cat_code('^') = SUP_MARK;
  584.     cat_code('\\') = ESCAPE;
  585.     cat_code('%') = COMMENT;
  586.     cat_code(INVALID_CODE) = INVALID_CHAR;
  587.     cat_code(NULL_CODE) = IGNORE;
  588.     for (k = '0'; k <= '9'; incr(k))
  589.         math_code(k) = hi(k + VAR_CODE);
  590.     for (k = 'A'; k <= 'Z'; incr(k)) {
  591.         cat_code(k) = cat_code(k + 'a' - 'A') = LETTER;
  592.         math_code(k) = hi(k + VAR_CODE + 0x100);
  593.         math_code(k + 'a' - 'A') = hi(k + 'a' - 'A'+ VAR_CODE + 0x100);
  594.         lc_code(k) = lc_code(k + 'a' - 'A') = k + 'a' - 'A';
  595.         uc_code(k) = uc_code(k + 'a' - 'A') = k;
  596.         sf_code(k) = 999;
  597.     }
  598.     for (k = INT_BASE; k < DEL_CODE_BASE; incr(k))
  599.         eqtb[k].i = 0;
  600.     mag = 1000;
  601.     tolerance = 10000;
  602.     hang_after = 1;
  603.     max_dead_cycles = 25;
  604.     escape_char = '\\';
  605.     end_line_char = CARRIAGE_RETURN;
  606.     for (k = 0; k <= 255; incr(k))
  607.         del_code(k) = -1;
  608.     del_code('.') = 0;
  609.     for (k = DIMEN_BASE; k <= EQTB_SIZE; incr(k))
  610.         eqtb[k].sc = 0;
  611. #endif
  612. }
  613.