1 /* Copyright 1992 Karl Berry
\r
2 Copyright 2007 TeX Users Group
\r
3 Copyright 2014 Clerk Ma
\r
5 This program is free software; you can redistribute it and/or modify
\r
6 it under the terms of the GNU General Public License as published by
\r
7 the Free Software Foundation; either version 2 of the License, or
\r
8 (at your option) any later version.
\r
10 This program is distributed in the hope that it will be useful, but
\r
11 WITHOUT ANY WARRANTY; without even the implied warranty of
\r
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\r
13 General Public License for more details.
\r
15 You should have received a copy of the GNU General Public License
\r
16 along with this program; if not, write to the Free Software
\r
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
\r
20 #define EXTERN extern
\r
22 #include "yandytex.h"
\r
24 #define BEGINFMTCHECKSUM 367403084L
\r
25 #define ENDFMTCHECKSUM 69069L
\r
28 void do_initex (void);
\r
32 void initialize (void)
\r
38 #ifndef ALLOCATEHYPHEN
\r
44 for (i = 0; i <= 255; i++)
\r
48 xchr[32] = ' '; xchr[33] = '!'; xchr[34] = '"'; xchr[35] = '#';
\r
49 xchr[36] = '$'; xchr[37] = '%'; xchr[38] = '&'; xchr[39] = '\'';
\r
50 xchr[40] = '('; xchr[41] = ')'; xchr[42] = '*'; xchr[43] = '+';
\r
51 xchr[44] = ','; xchr[45] = '-'; xchr[46] = '.'; xchr[47] = '/';
\r
52 xchr[48] = '0'; xchr[49] = '1'; xchr[50] = '2'; xchr[51] = '3';
\r
53 xchr[52] = '4'; xchr[53] = '5'; xchr[54] = '6'; xchr[55] = '7';
\r
54 xchr[56] = '8'; xchr[57] = '9'; xchr[58] = ':'; xchr[59] = ';';
\r
55 xchr[60] = '<'; xchr[61] = '='; xchr[62] = '>'; xchr[63] = '?';
\r
56 xchr[64] = '@'; xchr[65] = 'A'; xchr[66] = 'B'; xchr[67] = 'C';
\r
57 xchr[68] = 'D'; xchr[69] = 'E'; xchr[70] = 'F'; xchr[71] = 'G';
\r
58 xchr[72] = 'H'; xchr[73] = 'I'; xchr[74] = 'J'; xchr[75] = 'K';
\r
59 xchr[76] = 'L'; xchr[77] = 'M'; xchr[78] = 'N'; xchr[79] = 'O';
\r
60 xchr[80] = 'P'; xchr[81] = 'Q'; xchr[82] = 'R'; xchr[83] = 'S';
\r
61 xchr[84] = 'T'; xchr[85] = 'U'; xchr[86] = 'V'; xchr[87] = 'W';
\r
62 xchr[88] = 'X'; xchr[89] = 'Y'; xchr[90] = 'Z'; xchr[91] = '[';
\r
63 xchr[92] = '\\'; xchr[93] = ']'; xchr[94] = '^'; xchr[95] = '_';
\r
64 xchr[96] = '`'; xchr[97] = 'a'; xchr[98] = 'b'; xchr[99] = 'c';
\r
65 xchr[100] = 'd'; xchr[101] = 'e'; xchr[102] = 'f'; xchr[103] = 'g';
\r
66 xchr[104] = 'h'; xchr[105] = 'i'; xchr[106] = 'j'; xchr[107] = 'k';
\r
67 xchr[108] = 'l'; xchr[109] = 'm'; xchr[110] = 'n'; xchr[111] = 'o';
\r
68 xchr[112] = 'p'; xchr[113] = 'q'; xchr[114] = 'r'; xchr[115] = 's';
\r
69 xchr[116] = 't'; xchr[117] = 'u'; xchr[118] = 'v'; xchr[119] = 'w';
\r
70 xchr[120] = 'x'; xchr[121] = 'y'; xchr[122] = 'z'; xchr[123] = '{';
\r
71 xchr[124] = '|'; xchr[125] = '}'; xchr[126] = '~';
\r
73 for (i = 0; i <= 31; i++)
\r
76 for (i = 127; i <= 255; i++)
\r
81 for (i = 0; i <= 255; i++)
\r
82 xord[chr(i)] = invalid_code;
\r
85 for (i = 128; i <= 255 ; i++)
\r
88 for (i = 0; i <= 126; i++)
\r
92 for (i = 0; i <= 255; i++)
\r
93 xord[xchr[i]] = (char) i;
\r
99 if (trace_flag != 0)
\r
101 for (k = 0; k < 256; k++)
\r
110 puts("Inverted mapping xord[] pairs:");
\r
112 for (k = 0; k < 256; k++)
\r
114 if (xord[k] != 127)
\r
115 printf("%lld => %d\n", k, xord[k]);
\r
120 if (interaction < batch_mode)
\r
121 interaction = error_stop_mode;
\r
123 deletions_allowed = true;
\r
124 set_box_allowed = true;
\r
127 use_err_help = false;
\r
129 OK_to_interrupt = true;
\r
132 was_mem_end = mem_min;
\r
133 was_lo_max = mem_bot; // mem_min
\r
134 was_hi_min = mem_top; // mem_max
\r
139 max_nest_stack = 0;
\r
141 head = contrib_head;
\r
142 tail = contrib_head;
\r
143 prev_depth = ignore_depth;
\r
148 page_tail = page_head;
\r
150 #ifdef ALLOCATEMAIN
\r
153 link(page_head) = 0;
\r
155 last_glue = max_halfword;
\r
159 page_max_depth = 0;
\r
161 for (k = int_base; k <= eqtb_size; k++)
\r
162 xeq_level[k] = level_one;
\r
164 no_new_control_sequence = true;
\r
165 next(hash_base) = 0;
\r
166 text(hash_base) = 0;
\r
168 for (k = hash_base + 1; k <= undefined_control_sequence - 1; k++)
\r
169 hash[k] = hash[hash_base];
\r
175 max_save_stack = 0;
\r
183 cur_val_level = int_val;
\r
185 cur_order = normal;
\r
187 for (k = 0; k <= 16; k++)
\r
188 read_open[k] = closed;
\r
195 for (k = 0; k <= font_max; k++)
\r
196 font_used[k] = false;
\r
198 null_character.b0 = min_quarterword;
\r
199 null_character.b1 = min_quarterword;
\r
200 null_character.b2 = min_quarterword;
\r
201 null_character.b3 = min_quarterword;
\r
207 doing_leaders = false;
\r
210 half_buf = dvi_buf_size / 2;
\r
211 dvi_limit = dvi_buf_size;
\r
219 pack_begin_line = 0;
\r
220 empty_field.rh = 0;
\r
221 empty_field.lh = 0;
\r
222 null_delimiter.b0 = 0;
\r
223 null_delimiter.b1 = 0;
\r
224 null_delimiter.b2 = 0;
\r
225 null_delimiter.b3 = 0;
\r
233 /* *not* OK with ALLOCATEHYPHEN, since may not be allocated yet */
\r
234 #ifndef ALLOCATEHYPHEN
\r
235 for (z = 0; z <= hyphen_prime; z++)
\r
243 output_active = false;
\r
244 insert_penalties = 0;
\r
245 ligature_present = false;
\r
246 cancel_boundary = false;
\r
251 long_help_seen = false;
\r
254 for (k = 0; k <= 17; k++)
\r
255 write_open[k] = false;
\r
257 edit_name_start = 0;
\r
265 /* do the part of initialize() that requires mem_top, mem_max or mem[] */
\r
266 /* do this part after allocating main memory */
\r
268 #ifdef ALLOCATEMAIN
\r
269 void initialize_aux (void)
\r
272 was_mem_end = mem_min;
\r
273 was_lo_max = mem_bot; // mem_min
\r
274 was_hi_min = mem_top; // mem_max
\r
278 /* nest_ptr = 0; */
\r
279 /* max_nest_stack = 0; */
\r
281 head = contrib_head;
\r
282 tail = contrib_head;
\r
283 prev_depth = ignore_depth;
\r
286 /* shown_mode = 0; */
\r
287 /* page_contents = 0; */
\r
288 page_tail = page_head;
\r
289 link(page_head) = 0;
\r
293 void line_break (integer final_widow_penalty)
\r
295 boolean auto_breaking;
\r
297 pointer q, r, s, prev_s;
\r
298 internal_font_number f;
\r
299 /* small_number j; */
\r
301 /* unsigned char c; */
\r
304 pack_begin_line = mode_line;
\r
305 link(temp_head) = link(head);
\r
307 if (is_char_node(tail))
\r
308 tail_append(new_penalty(inf_penalty));
\r
309 else if (type(tail) != glue_node)
\r
310 tail_append(new_penalty(inf_penalty));
\r
313 type(tail) = penalty_node;
\r
314 delete_glue_ref(glue_ptr(tail));
\r
315 flush_node_list(leader_ptr(tail));
\r
316 penalty(tail) = inf_penalty;
\r
319 link(tail) = new_param_glue(par_fill_skip_code);
\r
320 init_cur_lang = prev_graf % 65536L;
\r
321 init_l_hyf = prev_graf / 4194304L; /* 2^22 */
\r
322 init_r_hyf = (prev_graf / 65536L) % 64;
\r
324 no_shrink_error_yet = true;
\r
325 check_shrinkage(left_skip);
\r
326 check_shrinkage(right_skip);
\r
329 background[1] = width(q) + width(r);
\r
334 background[2 + stretch_order(q)] = stretch(q);
\r
335 background[2 + stretch_order(r)] = background[2 + stretch_order(r)] + stretch(r);
\r
336 background[6] = shrink(q) + shrink(r);
\r
337 minimum_demerits = awful_bad;
\r
338 minimal_demerits[tight_fit] = awful_bad;
\r
339 minimal_demerits[decent_fit] = awful_bad;
\r
340 minimal_demerits[loose_fit] = awful_bad;
\r
341 minimal_demerits[very_loose_fit] = awful_bad;
\r
343 if (par_shape_ptr == 0)
\r
344 if (hang_indent == 0)
\r
346 last_special_line = 0;
\r
347 second_width = hsize;
\r
352 last_special_line = abs(hang_after);
\r
354 if (hang_after < 0)
\r
356 first_width = hsize - abs(hang_indent);
\r
358 if (hang_indent >= 0)
\r
359 first_indent = hang_indent;
\r
363 second_width = hsize;
\r
368 first_width = hsize;
\r
370 second_width = hsize - abs(hang_indent);
\r
372 if (hang_indent >= 0)
\r
373 second_indent = hang_indent;
\r
380 last_special_line = info(par_shape_ptr) - 1;
\r
381 second_width = mem[par_shape_ptr + 2 * (last_special_line + 1)].cint;
\r
382 second_indent = mem[par_shape_ptr + 2 * last_special_line + 1].cint;
\r
385 if (looseness == 0)
\r
386 easy_line = last_special_line;
\r
388 easy_line = empty_flag;
\r
390 threshold = pretolerance;
\r
392 if (threshold >= 0)
\r
395 if (tracing_paragraphs > 0)
\r
397 begin_diagnostic();
\r
398 print_nl("@firstpass");
\r
402 second_pass = false;
\r
403 final_pass = false;
\r
404 first_pass_count++;
\r
408 threshold = tolerance;
\r
409 second_pass = true;
\r
410 final_pass = (emergency_stretch <= 0);
\r
413 if (tracing_paragraphs > 0)
\r
414 begin_diagnostic();
\r
420 if (threshold > inf_bad)
\r
421 threshold = inf_bad;
\r
428 if (trie_not_ready)
\r
433 cur_lang = init_cur_lang;
\r
434 l_hyf = init_l_hyf;
\r
435 r_hyf = init_r_hyf;
\r
438 q = get_node(active_node_size);
\r
439 type(q) = unhyphenated;
\r
440 fitness(q) = decent_fit;
\r
443 line_number(q) = prev_graf + 1;
\r
444 total_demerits(q) = 0;
\r
446 act_width = background[1];
\r
447 do_all_six(store_background);
\r
449 printed_node = temp_head;
\r
451 font_in_short_display = null_font;
\r
452 cur_p = link(temp_head);
\r
453 auto_breaking = true;
\r
456 while ((cur_p != 0) && (link(active) != active))
\r
458 if (is_char_node(cur_p))
\r
465 act_width = act_width + char_width(f, char_info(f, character(cur_p)));
\r
466 cur_p = link(cur_p);
\r
468 while (!(!is_char_node(cur_p)));
\r
471 switch (type(cur_p))
\r
476 act_width = act_width + width(cur_p);
\r
480 if (subtype(cur_p) == language_node)
\r
482 cur_lang = what_lang(cur_p);
\r
483 l_hyf = what_lhm(cur_p);
\r
484 r_hyf = what_rhm(cur_p);
\r
492 if (is_char_node(prev_p))
\r
493 try_break(0, unhyphenated);
\r
494 else if (precedes_break(prev_p))
\r
495 try_break(0, unhyphenated);
\r
496 else if ((type(prev_p) == kern_node) && (subtype(prev_p) != explicit))
\r
497 try_break(0, unhyphenated);
\r
500 check_shrinkage(glue_ptr(cur_p));
\r
501 q = glue_ptr(cur_p);
\r
502 act_width = act_width+ width(q);
\r
503 active_width[2 + stretch_order(q)] = active_width[2 + stretch_order(q)] + stretch(q);
\r
504 active_width[6] = active_width[6] + shrink(q);
\r
506 if (second_pass && auto_breaking)
\r
515 if (is_char_node(s))
\r
520 else if (type(s) == ligature_node)
\r
521 if (lig_ptr(s) == 0)
\r
529 else if ((type(s) == kern_node) && (subtype(s) == normal))
\r
531 else if (type(s) == whatsit_node)
\r
533 if (subtype(s) == language_node)
\r
535 cur_lang = what_lang(s);
\r
536 l_hyf = what_lhm(s);
\r
537 r_hyf = what_rhm(s);
\r
544 if (lc_code(c) != 0)
\r
545 if ((lc_code(c) == (halfword) c) || (uc_hyph > 0))
\r
554 hyf_char = hyphen_char[hf];
\r
559 if (hyf_char > 255)
\r
564 if (l_hyf + r_hyf > 63)
\r
571 if (is_char_node(s))
\r
576 hyf_bchar = character(s);
\r
580 if (lc_code(c) == 0)
\r
589 hc[hn]= lc_code(c);
\r
590 hyf_bchar = non_char;
\r
592 else if (type(s) == ligature_node)
\r
594 if (font(lig_char(s)) != hf)
\r
601 hyf_bchar = character(q);
\r
607 if (lc_code(c) == 0)
\r
615 hc[j] = lc_code(c);
\r
622 if (odd(subtype(s)))
\r
623 hyf_bchar = font_bchar[hf];
\r
625 hyf_bchar = non_char;
\r
627 else if ((type(s) == kern_node) && (subtype(s) == normal))
\r
630 hyf_bchar = font_bchar[hf];
\r
638 if (hn < l_hyf + r_hyf)
\r
643 if (!(is_char_node(s)))
\r
646 case ligature_node:
\r
650 if (subtype(s) != normal)
\r
678 if (subtype(cur_p) == explicit)
\r
681 act_width = act_width + width(cur_p);
\r
684 case ligature_node:
\r
686 f = font(lig_char(cur_p));
\r
687 act_width = act_width + char_width(f, char_info(f, character(lig_char(cur_p))));
\r
693 s = pre_break(cur_p);
\r
697 try_break(ex_hyphen_penalty, hyphenated);
\r
702 if (is_char_node(s))
\r
705 disc_width = disc_width + char_width(f, char_info(f, character(s)));
\r
707 else switch (type(s))
\r
709 case ligature_node:
\r
711 f = font(lig_char(s));
\r
712 disc_width = disc_width + char_width(f, char_info(f, character(lig_char(s))));
\r
720 disc_width = disc_width + width(s);
\r
725 confusion("disc3");
\r
735 act_width = act_width + disc_width;
\r
736 try_break(hyphen_penalty, hyphenated);
\r
737 act_width = act_width - disc_width;
\r
740 r = replace_count(cur_p);
\r
745 if (is_char_node(s))
\r
748 act_width = act_width + char_width(f, char_info(f, character(s)));
\r
750 else switch (type(s))
\r
752 case ligature_node:
\r
754 f = font(lig_char(s));
\r
755 act_width = act_width + char_width(f, char_info(f, character(lig_char(s))));
\r
763 act_width = act_width + width(s);
\r
768 confusion("disc4");
\r
786 auto_breaking = (subtype(cur_p) == after);
\r
792 try_break(penalty(cur_p), unhyphenated);
\r
802 confusion("paragraph");
\r
809 cur_p = link(cur_p);
\r
815 try_break(eject_penalty, hyphenated);
\r
817 if (link(active) != active)
\r
820 fewest_demerits = awful_bad;
\r
824 if (type(r) != delta_node)
\r
825 if (total_demerits(r) < fewest_demerits)
\r
827 fewest_demerits = total_demerits(r);
\r
833 while (!(r == active));
\r
835 best_line = line_number(best_bet);
\r
837 if (looseness == 0)
\r
844 actual_looseness = 0;
\r
848 if (type(r) != delta_node)
\r
850 line_diff = toint(line_number(r)) - toint(best_line);
\r
852 if (((line_diff < actual_looseness) && (looseness <= line_diff)) ||
\r
853 ((line_diff > actual_looseness) && (looseness >= line_diff)))
\r
856 actual_looseness = line_diff;
\r
857 fewest_demerits = total_demerits(r);
\r
859 else if ((line_diff == actual_looseness) && (total_demerits(r) < fewest_demerits))
\r
862 fewest_demerits = total_demerits(r);
\r
868 while (!(r == active));
\r
870 best_line = line_number(best_bet);
\r
873 if ((actual_looseness == looseness) || final_pass)
\r
882 while (q != active)
\r
886 if (type(q) == delta_node)
\r
887 free_node(q, delta_node_size);
\r
889 free_node(q, active_node_size);
\r
899 free_node(q, passive_node_size);
\r
906 if (tracing_paragraphs > 0)
\r
907 print_nl("@secondpass");
\r
909 threshold = tolerance;
\r
910 second_pass = true;
\r
911 second_pass_count++;
\r
912 final_pass = (emergency_stretch <= 0);
\r
917 if (tracing_paragraphs > 0)
\r
918 print_nl("@emergencypass");
\r
921 background[2] = background[2] + emergency_stretch;
\r
923 ++final_pass_count;
\r
928 if (best_line == decent_fit)
\r
932 if (tracing_paragraphs > 0)
\r
934 end_diagnostic(true);
\r
935 normalize_selector();
\r
939 post_line_break(final_widow_penalty);
\r
942 while (q != active)
\r
946 if (type(q) == delta_node)
\r
947 free_node(q, delta_node_size);
\r
949 free_node(q, active_node_size);
\r
959 free_node(q, passive_node_size);
\r
963 pack_begin_line = 0;
\r
966 void prefixed_command (void)
\r
969 internal_font_number f;
\r
978 while (cur_cmd == prefix)
\r
980 if (!odd(a / cur_chr))
\r
987 while (!((cur_cmd != spacer) && (cur_cmd != relax)));
\r
989 if (cur_cmd <= max_non_prefixed_command)
\r
991 print_err("You can't use a prefix with `");
\r
992 print_cmd_chr(cur_cmd, cur_chr);
\r
994 help1("I'll pretend you didn't say \\long or \\outer or \\global.");
\r
1000 if ((cur_cmd != def) && (a % 4 != 0))
\r
1002 print_err("You can't use `");
\r
1003 print_esc("long");
\r
1005 print_esc("outer");
\r
1006 prints("' with `");
\r
1007 print_cmd_chr(cur_cmd, cur_chr);
\r
1009 help1("I'll pretend you didn't say \\long or \\outer here.");
\r
1013 if (global_defs != 0)
\r
1014 if (global_defs < 0)
\r
1028 define(cur_font_loc, data, cur_chr);
\r
1033 if (odd(cur_chr) && !(a >= 4) && (global_defs >= 0))
\r
1036 e = (cur_chr >= 2);
\r
1039 q = scan_toks(true, e);
\r
1040 define(p, call + (a % 4), def_ref);
\r
1056 while (!(cur_cmd != spacer));
\r
1058 if (cur_tok == other_token + '=')
\r
1062 if (cur_cmd == spacer)
\r
1076 if (cur_cmd >= call)
\r
1077 add_token_ref(cur_chr);
\r
1079 define(p, cur_cmd, cur_chr);
\r
1083 case shorthand_def:
\r
1088 define(p, relax, 256);
\r
1089 scan_optional_equals();
\r
1093 case char_def_code:
\r
1096 define(p, char_given, cur_val);
\r
1100 case math_char_def_code:
\r
1102 scan_fifteen_bit_int();
\r
1103 define(p, math_given, cur_val);
\r
1109 scan_eight_bit_int();
\r
1113 case count_def_code:
\r
1114 define(p, assign_int, count_base + cur_val);
\r
1117 case dimen_def_code:
\r
1118 define(p, assign_dimen, scaled_base + cur_val);
\r
1121 case skip_def_code:
\r
1122 define(p, assign_glue, skip_base + cur_val);
\r
1125 case mu_skip_def_code:
\r
1126 define(p, assign_mu_glue, mu_skip_base + cur_val);
\r
1129 case toks_def_code:
\r
1130 define(p, assign_toks, toks_base + cur_val);
\r
1144 if (!scan_keyword("to"))
\r
1146 print_err("Missing `to' inserted");
\r
1147 help2("You should have said `\\read<number> to \\cs'.",
\r
1148 "I'm going to look for the \\cs now.");
\r
1155 define(p, call, cur_val);
\r
1159 case toks_register:
\r
1164 if (cur_cmd == toks_register)
\r
1166 scan_eight_bit_int();
\r
1167 p = toks_base + cur_val;
\r
1172 scan_optional_equals();
\r
1178 while (!((cur_cmd != spacer) && (cur_cmd != relax)));
\r
1180 if (cur_cmd != left_brace)
\r
1182 if (cur_cmd == toks_register)
\r
1184 scan_eight_bit_int();
\r
1185 cur_cmd = assign_toks;
\r
1186 cur_chr = toks_base + cur_val;
\r
1189 if (cur_cmd == assign_toks)
\r
1191 q = equiv(cur_chr);
\r
1194 define(p, undefined_cs, 0);
\r
1198 define(p, call, q);
\r
1206 q = scan_toks(false, false);
\r
1208 if (link(def_ref) == 0)
\r
1210 define(p, undefined_cs, 0);
\r
1211 free_avail(def_ref);
\r
1215 if (p == output_routine_loc)
\r
1217 link(q) = get_avail();
\r
1219 info(q) = right_brace_token + '}';
\r
1221 info(q) = left_brace_token + '{';
\r
1222 link(q) = link(def_ref);
\r
1223 link(def_ref) = q;
\r
1226 define(p, call, def_ref);
\r
1234 scan_optional_equals();
\r
1236 word_define(p, cur_val);
\r
1240 case assign_dimen:
\r
1243 scan_optional_equals();
\r
1244 scan_dimen(false, false, false);
\r
1245 word_define(p, cur_val);
\r
1250 case assign_mu_glue:
\r
1254 scan_optional_equals();
\r
1256 if (n == assign_mu_glue)
\r
1257 scan_glue(mu_val);
\r
1259 scan_glue(glue_val);
\r
1262 define(p, glue_ref, cur_val);
\r
1268 if (cur_chr == cat_code_base)
\r
1269 n = max_char_code;
\r
1270 else if (cur_chr == math_code_base)
\r
1271 n = 32768L; /* 2^15 */
\r
1272 else if (cur_chr == sf_code_base)
\r
1273 n = 32767; /* 2^15 - 1*/
\r
1274 else if (cur_chr == del_code_base)
\r
1275 n = 16777215L; /* 2^24 - 1 */
\r
1282 scan_optional_equals();
\r
1285 if (((cur_val < 0) && (p < del_code_base)) || (cur_val > n))
\r
1287 print_err("Invalid code(");
\r
1288 print_int(cur_val);
\r
1290 if (p < del_code_base)
\r
1291 prints("), should be in the range 0..");
\r
1293 prints("), should be at most ");
\r
1296 help1("I'm going to use 0 instead of that illegal code value.");
\r
1301 if (p < math_code_base)
\r
1302 define(p, data, cur_val);
\r
1303 else if (p < del_code_base)
\r
1304 define(p, data, cur_val);
\r
1306 word_define(p, cur_val);
\r
1313 scan_four_bit_int();
\r
1315 scan_optional_equals();
\r
1316 scan_font_ident();
\r
1317 define(p, data, cur_val);
\r
1321 case tex_register:
\r
1325 do_register_command(a);
\r
1330 scan_eight_bit_int();
\r
1333 n = 256 + cur_val;
\r
1337 scan_optional_equals();
\r
1339 if (set_box_allowed)
\r
1340 scan_box(box_flag + n);
\r
1343 print_err("Improper ");
\r
1344 print_esc("setbox");
\r
1345 help2("Sorry, \\setbox is not allowed after \\halign in a display,",
\r
1346 "or between \\accent and an accented character.");
\r
1356 case set_prev_graf:
\r
1357 alter_prev_graf();
\r
1360 case set_page_dimen:
\r
1361 alter_page_so_far();
\r
1364 case set_page_int:
\r
1368 case set_box_dimen:
\r
1369 alter_box_dimen();
\r
1374 scan_optional_equals();
\r
1382 p = get_node(2 * n + 1);
\r
1385 for (j = 1; j <= n; j++)
\r
1387 scan_dimen(false, false, false);
\r
1388 mem[p + 2 * j - 1].cint = cur_val;
\r
1389 scan_dimen(false, false, false);
\r
1390 mem[p + 2 * j].cint = cur_val;
\r
1394 define(par_shape_loc, shape_ref, p);
\r
1408 print_err("Patterns can be loaded only by INITEX");
\r
1416 while (!(cur_cmd == right_brace));
\r
1422 new_hyph_exceptions();
\r
1427 case assign_font_dimen:
\r
1429 find_font_dimen(true);
\r
1431 scan_optional_equals();
\r
1432 scan_dimen(false, false, false);
\r
1433 font_info[k].cint = cur_val;
\r
1437 case assign_font_int:
\r
1440 scan_font_ident();
\r
1442 scan_optional_equals();
\r
1446 hyphen_char[f] = cur_val;
\r
1448 skew_char[f] = cur_val;
\r
1456 case set_interaction:
\r
1457 new_interaction();
\r
1462 confusion("prefix");
\r
1469 if (after_token != 0)
\r
1471 cur_tok = after_token;
\r
1477 boolean load_fmt_file (void)
\r
1485 if (x != BEGINFMTCHECKSUM)
\r
1488 undump_int(x); /* mem_bot */
\r
1493 undump_int(x); /* mem_top */
\r
1495 #ifdef ALLOCATEMAIN
\r
1496 /* we already read this once earlier to grab mem_top */
\r
1498 printf("Read from fmt file mem_top = %lld TeX words\n", x);
\r
1500 mem = allocate_main_memory(x);
\r
1503 exit(EXIT_FAILURE);
\r
1505 initialize_aux(); /* do `mem' part of initialize */
\r
1511 undump_int(x); /* eqtb_size */
\r
1513 if (x != eqtb_size)
\r
1516 undump_int(x); /* hash_prime */
\r
1518 if (x != hash_prime)
\r
1521 undump_int(x); /* hyphen_prime */
\r
1523 #ifdef ALLOCATEHYPHEN
\r
1524 /* allow format files dumped with arbitrary (prime) hyphenation exceptions */
\r
1525 realloc_hyphen(x);
\r
1529 if (x != hyphen_prime)
\r
1533 undump_int(x); /* pool_size */
\r
1538 #ifdef ALLOCATESTRING
\r
1539 if (x > current_pool_size)
\r
1542 printf("undump string pool reallocation (%lld > %d)\n", x, current_pool_size);
\r
1544 str_pool = realloc_str_pool(x - current_pool_size + increment_pool_size);
\r
1547 if (x > current_pool_size)
\r
1549 if (x > pool_size)
\r
1552 printf("%s%s\n", "---! Must increase the ", "string pool size");
\r
1560 undump_int(x); /* max_strings */
\r
1565 #ifdef ALLOCATESTRING
\r
1566 if (x > current_max_strings)
\r
1569 printf("undump string pointer reallocation (%lld > %d)\n", x, current_max_strings);
\r
1571 str_start = realloc_str_start(x - current_max_strings + increment_max_strings);
\r
1574 if (x > current_max_strings)
\r
1576 if (x > max_strings)
\r
1579 printf("%s%s\n", "---! Must increase the ", "max strings");
\r
1586 undumpthings(str_start[0], str_ptr + 1);
\r
1587 undumpthings(str_pool[0], pool_ptr);
\r
1588 init_str_ptr = str_ptr;
\r
1589 init_pool_ptr = pool_ptr;
\r
1590 undump(lo_mem_stat_max + 1000, hi_mem_stat_min - 1, lo_mem_max);
\r
1591 undump(lo_mem_stat_max + 1, lo_mem_max, rover);
\r
1597 if (undumpthings(mem[p], q + 2 - p))
\r
1600 p = q + node_size(q);
\r
1602 if ((p > lo_mem_max) || ((q >= rlink(q)) && (rlink(q) != rover)))
\r
1607 while (!(q == rover));
\r
1609 if (undumpthings(mem[p], lo_mem_max + 1 - p))
\r
1612 if (mem_min < mem_bot - 2)
\r
1614 /* or call add_variable_space(mem_bot - (mem_min + 1)) */
\r
1616 puts("Splicing in mem_min space in undump!");
\r
1620 link(mem_min) = 0; /* null */
\r
1621 info(mem_min) = 0; /* null */
\r
1626 link(q) = empty_flag;
\r
1627 node_size(q) = mem_bot - q;
\r
1630 undump(lo_mem_max + 1, hi_mem_stat_min, hi_mem_min);
\r
1631 undump(mem_bot, mem_top, avail);
\r
1632 mem_end = mem_top;
\r
1634 if (undumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min))
\r
1637 undump_int(var_used);
\r
1638 undump_int(dyn_used);
\r
1646 if ((x < 1) || (k + x > (eqtb_size + 1)))
\r
1649 if (undumpthings(eqtb[k], x))
\r
1655 if ((x < 0) || (k + x > (eqtb_size + 1)))
\r
1658 for (j = k; j <= k + x - 1; j++)
\r
1659 eqtb[j] = eqtb[k - 1];
\r
1663 while (!(k > eqtb_size));
\r
1665 undump(hash_base, frozen_control_sequence, par_loc);
\r
1666 par_token = cs_token_flag + par_loc;
\r
1667 undump(hash_base, frozen_control_sequence, write_loc);
\r
1668 undump(hash_base, frozen_control_sequence, hash_used);
\r
1670 p = hash_base - 1;
\r
1674 undump(p + 1, hash_used, p);
\r
1675 undump_hh(hash[p]);
\r
1677 while (!(p == hash_used));
\r
1679 if (undumpthings(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used))
\r
1682 undump_int(cs_count);
\r
1685 printf("itex undump cs_count %lld ", cs_count);
\r
1688 undump_int(x); /* font_mem_size */
\r
1693 #ifdef ALLOCATEFONT
\r
1695 printf("Read from fmt fmem_ptr = %lld\n", x);
\r
1697 if (x > current_font_mem_size)
\r
1700 printf("Undump realloc font_info (%lld > %d)\n", x, current_font_mem_size);
\r
1702 font_info = realloc_font_info (x - current_font_mem_size + increment_font_mem_size);
\r
1705 if (x > current_font_mem_size)
\r
1707 if (x > font_mem_size)
\r
1710 puts("---! Must increase the font mem size");
\r
1718 undumpthings(font_info[0], fmem_ptr);
\r
1719 undump_size(font_base, font_max, "font max", font_ptr);
\r
1720 frozen_font_ptr = font_ptr;
\r
1721 undumpthings(font_check[0], font_ptr + 1);
\r
1722 undumpthings(font_size[0], font_ptr + 1);
\r
1723 undumpthings(font_dsize[0], font_ptr + 1);
\r
1724 undumpthings(font_params[0], font_ptr + 1);
\r
1725 undumpthings(hyphen_char[0], font_ptr + 1);
\r
1726 undumpthings(skew_char[0], font_ptr + 1);
\r
1727 undumpthings(font_name[0], font_ptr + 1);
\r
1728 undumpthings(font_area[0], font_ptr + 1);
\r
1729 undumpthings(font_bc[0], font_ptr + 1);
\r
1730 undumpthings(font_ec[0], font_ptr + 1);
\r
1731 undumpthings(char_base[0], font_ptr + 1);
\r
1732 undumpthings(width_base[0], font_ptr + 1);
\r
1733 undumpthings(height_base[0], font_ptr + 1);
\r
1734 undumpthings(depth_base[0], font_ptr + 1);
\r
1735 undumpthings(italic_base[0], font_ptr + 1);
\r
1736 undumpthings(lig_kern_base[0], font_ptr + 1);
\r
1737 undumpthings(kern_base[0], font_ptr + 1);
\r
1738 undumpthings(exten_base[0], font_ptr + 1);
\r
1739 undumpthings(param_base[0], font_ptr + 1);
\r
1740 undumpthings(font_glue[0], font_ptr + 1);
\r
1741 undumpthings(bchar_label[0], font_ptr + 1);
\r
1742 undumpthings(font_bchar[0], font_ptr + 1);
\r
1743 undumpthings(font_false_bchar[0], font_ptr + 1);
\r
1746 /* log not opened yet, so can't show fonts frozen into format */
\r
1747 /* May be able to avoid the following since we switched to */
\r
1748 /* non_address from font_mem_size to 0 96/Jan/15 ??? */
\r
1750 #ifdef ALLOCATEFONT
\r
1752 int count = 0, oldfont_mem_size = 0;
\r
1754 for (x = 0; x <= font_ptr; x++)
\r
1756 if (bchar_label[x] > oldfont_mem_size)
\r
1757 oldfont_mem_size = bchar_label[x];
\r
1760 if (oldfont_mem_size != non_address && oldfont_mem_size > font_max)
\r
1762 for (x = 0; x <= font_ptr; x++)
\r
1764 if (bchar_label[x] == oldfont_mem_size)
\r
1766 bchar_label[x] = non_address;
\r
1772 printf("oldfont_mem_size is %d --- hit %d times. Using non_address %d\n",
\r
1773 oldfont_mem_size, count, non_address);
\r
1778 undump(0, hyphen_prime, hyph_count);
\r
1780 for (k = 1; k <= hyph_count; k++)
\r
1782 undump(0, hyphen_prime, j);
\r
1783 undump(0, str_ptr, hyph_word[j]);
\r
1784 undump(0, max_halfword, hyph_list[j]);
\r
1787 #ifdef ALLOCATEHYPHEN
\r
1788 /* if user specified new hyphen prime - flush existing exception patterns ! */
\r
1789 /* but, we can reclaim the string storage wasted ... */
\r
1792 if (new_hyphen_prime != 0)
\r
1794 realloc_hyphen(new_hyphen_prime); /* reset_hyphen(); */
\r
1795 hyphen_prime = new_hyphen_prime;
\r
1806 #ifdef ALLOCATETRIES
\r
1809 allocate_tries(x); /* allocate only as much as is needed */
\r
1813 if (x > trie_size)
\r
1815 puts("---! Must increase the trie size");
\r
1827 undumpthings(trie_trl[0], j + 1);
\r
1828 undumpthings(trie_tro[0], j + 1);
\r
1829 undumpthings(trie_trc[0], j + 1);
\r
1830 undump_size(0, trie_op_size, "trie op size", j);
\r
1837 undumpthings(hyf_distance[1], j);
\r
1838 undumpthings(hyf_num[1], j);
\r
1839 undumpthings(hyf_next[1], j);
\r
1844 for (k = 0; k <= 255; k++)
\r
1845 trie_used[k] = min_quarterword;
\r
1853 undump(0, k - 1, k);
\r
1867 trie_not_ready = false;
\r
1870 undump(batch_mode, error_stop_mode, interaction);
\r
1871 undump(0, str_ptr, format_ident);
\r
1874 if ((x != ENDFMTCHECKSUM) || feof(fmt_file))
\r
1880 puts("(Fatal format file error; I'm stymied)");
\r
1885 void final_cleanup (void)
\r
1891 if (job_name == 0)
\r
1894 while (input_ptr > 0)
\r
1896 if (state == token_list)
\r
1899 end_file_reading();
\r
1902 while (open_parens > 0)
\r
1905 decr(open_parens);
\r
1908 if (cur_level > level_one)
\r
1911 print_esc("end occurred ");
\r
1912 prints("inside a group at level ");
\r
1913 print_int(cur_level - 1);
\r
1917 while (cond_ptr != 0)
\r
1920 print_esc("end occurred ");
\r
1922 print_cmd_chr(if_test, cur_if);
\r
1926 prints("on line ");
\r
1927 print_int(if_line);
\r
1930 prints(" was incomplete)");
\r
1931 if_line = if_line_field(cond_ptr);
\r
1932 cur_if = subtype(cond_ptr);
\r
1933 temp_ptr = cond_ptr;
\r
1934 cond_ptr = link(cond_ptr);
\r
1935 free_node(temp_ptr, if_node_size);
\r
1938 if (history != spotless)
\r
1939 if (((history == warning_issued) || (interaction < error_stop_mode)))
\r
1940 if (selector == term_and_log)
\r
1942 selector = term_only;
\r
1943 print_nl("(see the transcript file for additional information)");
\r
1944 selector = term_and_log;
\r
1952 for (c = 0; c <= 4; c++)
\r
1953 if (cur_mark[c] != 0)
\r
1954 delete_token_ref(cur_mark[c]);
\r
1956 if (last_glue != max_halfword)
\r
1957 delete_glue_ref(last_glue);
\r
1964 print_nl("(\\dump is performed only by INITEX)");
\r
1968 void show_frozen (void)
\r
1972 fprintf(log_file, "\n(%lld fonts frozen in format file:\n", font_ptr);
\r
1974 for (i = 1; i <= font_ptr; i++)
\r
1977 fprintf(log_file, ", ");
\r
1980 fprintf(log_file, "\n");
\r
1982 fwrite(&str_pool[str_start[font_name[i]]], 1, length(font_name[i]), log_file);
\r
1985 fprintf(log_file, ") ");
\r
1988 int main_program (void)
\r
1990 history = fatal_error_stop;
\r
1992 if (ready_already == 314159L)
\r
1993 goto start_of_TEX;
\r
1997 if ((half_error_line < 30) || (half_error_line > error_line - 15))
\r
2000 if (max_print_line < 60)
\r
2003 if (dvi_buf_size % 8 != 0)
\r
2006 if (mem_bot + 1100 > mem_top)
\r
2009 if (hash_prime > (hash_size + hash_extra))
\r
2012 if (max_in_open >= 128)
\r
2015 if (mem_top < 256 + 11)
\r
2021 if ((mem_min != 0) || (mem_max != mem_top))
\r
2026 if ((mem_min > mem_bot) || (mem_max < mem_top))
\r
2029 if ((min_quarterword > 0) || (max_quarterword < 255))
\r
2032 if ((min_halfword > 0) || (max_halfword < 32767))
\r
2035 if ((min_quarterword < min_halfword) || (max_quarterword > max_halfword))
\r
2038 if ((mem_min < min_halfword) || (mem_max >= max_halfword) || (mem_bot - mem_min >= max_halfword))
\r
2041 if (mem_max > mem_top + mem_extra_high)
\r
2044 if ((0 < min_quarterword) || (font_max > max_quarterword))
\r
2047 #ifdef INCREASEFONTS
\r
2048 if (font_max > 65535)
\r
2050 if (font_max > 256)
\r
2054 if ((save_size > max_halfword) || (max_strings > max_halfword))
\r
2057 if (buf_size > max_halfword)
\r
2060 if (max_quarterword - min_quarterword < 255)
\r
2063 if (cs_token_flag + undefined_control_sequence > max_halfword)
\r
2066 if (format_default_length > file_name_size)
\r
2069 if (max_halfword < (mem_top - mem_min) / 2)
\r
2074 printf("%s%s%ld\n", "Ouch---my internal constants have been clobbered!",
\r
2075 "---case ", (long) bad);
\r
2085 if (!get_strings_started())
\r
2089 init_str_ptr = str_ptr;
\r
2090 init_pool_ptr = pool_ptr;
\r
2091 fix_date_and_time();
\r
2095 ready_already = 314159L;
\r
2098 selector = term_only;
\r
2105 if (format_ident == 0)
\r
2107 prints(" (preloaded format=");
\r
2108 prints(format_name);
\r
2114 slow_print(format_ident);
\r
2118 update_terminal();
\r
2120 name_in_progress = false;
\r
2121 log_opened = false;
\r
2122 output_file_name = 0;
\r
2131 max_open_parens = 0;
\r
2132 max_buf_stack = 0;
\r
2134 max_param_stack = 0;
\r
2136 #ifdef ALLOCATEBUFFER
\r
2137 memset (buffer, 0, current_buf_size);
\r
2139 memset (buffer, 0, buf_size);
\r
2143 scanner_status = 0;
\r
2144 warning_index = 0;
\r
2151 force_eof = false;
\r
2152 align_state = 1000000L;
\r
2154 if (!init_terminal())
\r
2161 if ((format_ident == 0) || (buffer[loc] == '&') || (buffer[loc] == '+'))
\r
2163 if (format_ident != 0)
\r
2166 if (!open_fmt_file())
\r
2169 if (!load_fmt_file())
\r
2171 #ifdef COMPACTFORMAT
\r
2172 gzclose(gz_fmt_file);
\r
2174 w_close(fmt_file);
\r
2179 #ifdef COMPACTFORMAT
\r
2180 gzclose(gz_fmt_file);
\r
2182 w_close(fmt_file);
\r
2185 while ((loc < limit) && (buffer[loc] == ' '))
\r
2189 if (end_line_char_inactive())
\r
2192 buffer[limit] = end_line_char;
\r
2194 fix_date_and_time();
\r
2195 magic_offset = str_start[886] - 9 * ord_noad;
\r
2197 if (interaction == batch_mode)
\r
2198 selector = no_print;
\r
2200 selector = term_only;
\r
2202 if ((loc < limit) && (cat_code(buffer[loc]) != escape))
\r
2206 if (show_tfm_flag && log_opened && font_ptr > 0)
\r
2209 main_time = clock();
\r
2210 history = spotless;
\r
2212 if (show_cs_names)
\r
2213 print_cs_names(stdout, 0);
\r
2217 if (show_cs_names)
\r
2218 print_cs_names(stdout, 1);
\r
2221 close_files_and_terminate();
\r
2227 update_terminal();
\r
2228 ready_already = 0;
\r
2230 if ((history != spotless) && (history != warning_issued))
\r
2239 #ifdef ALLOCATEMAIN
\r
2240 /* add a block of variable size node space below mem_bot(0) */
\r
2241 void add_variable_space(int size)
\r
2252 mem_min = t - (size + 1); /* first word in new block - 1 */
\r
2254 if (mem_min < mem_start)
\r
2257 puts("WARNING: mem_min < mem_start!");
\r
2259 mem_min = mem_start;
\r
2264 link(mem_min) = 0; /* insert blank word below ??? */
\r
2265 info(mem_min) = 0; /* insert blank word below ??? */
\r
2270 link(q) = empty_flag;
\r
2271 info(q) = t - q; /* block size */
\r
2277 /* split out to allow sharing of code from do_initex and newpattern */
\r
2278 void reset_trie (void)
\r
2282 for (k = -(integer) trie_op_size; k <= trie_op_size; k++)
\r
2283 trie_op_hash[k] = 0;
\r
2285 for (k = 0; k <= 255; k++)
\r
2286 trie_used[k] = min_trie_op;
\r
2288 max_op_used = min_trie_op;
\r
2290 trie_not_ready = true;
\r
2294 trie_not_ready = true;
\r
2296 /* borrowed code from initialize() */
\r
2297 void reset_hyphen(void)
\r
2301 for (z = 0; z <= hyphen_prime; z++)
\r
2309 /* split out to allow optimize for space, not time */
\r
2310 void do_initex (void)
\r
2314 /* hyph_pointer z; */
\r
2316 for (k = mem_bot + 1; k <= lo_mem_stat_max; k++)
\r
2321 while (k <= lo_mem_stat_max)
\r
2323 glue_ref_count(k) = 1;
\r
2324 stretch_order(k) = normal;
\r
2325 shrink_order(k) = normal;
\r
2326 k = k + glue_spec_size;
\r
2329 stretch(fil_glue) = unity;
\r
2330 stretch_order(fil_glue) = fil;
\r
2331 stretch(fill_glue) = unity;
\r
2332 stretch_order(fill_glue) = fill;
\r
2333 stretch(ss_glue) = unity;
\r
2334 stretch_order(ss_glue) = fil;
\r
2335 shrink(ss_glue) = unity;
\r
2336 shrink_order(ss_glue) = fil;
\r
2337 stretch(fil_neg_glue) = -unity;
\r
2338 stretch_order(fil_neg_glue) = fil;
\r
2339 rover = lo_mem_stat_max + 1;
\r
2340 link(rover) = empty_flag;
\r
2341 node_size(rover) = block_size;
\r
2342 llink(rover) = rover;
\r
2343 rlink(rover) = rover;
\r
2344 lo_mem_max = rover + block_size;
\r
2345 link(lo_mem_max) = 0;
\r
2346 info(lo_mem_max) = 0;
\r
2348 for (k = hi_mem_stat_min; k <= mem_top; k++)
\r
2349 mem[k] = mem[lo_mem_max];
\r
2351 info(omit_template) = end_template_token;
\r
2352 link(end_span) = max_quarterword + 1;
\r
2353 info(end_span) = 0;
\r
2354 type(last_active) = hyphenated;
\r
2355 line_number(last_active) = max_halfword;
\r
2356 subtype(last_active) = 0;
\r
2357 subtype(page_ins_head) = 255;
\r
2358 type(page_ins_head) = split_up;
\r
2359 link(mem_top) = page_ins_head;
\r
2360 type(page_head) = glue_node;
\r
2361 subtype(page_head) = normal;
\r
2363 mem_end = mem_top;
\r
2364 hi_mem_min = hi_mem_stat_min;
\r
2365 var_used = lo_mem_stat_max + 1 - mem_bot;
\r
2366 dyn_used = hi_mem_stat_usage;
\r
2367 eq_type(undefined_control_sequence) = undefined_cs;
\r
2368 equiv(undefined_control_sequence) = 0;
\r
2369 eq_level(undefined_control_sequence) = level_zero;
\r
2371 for (k = active_base; k <= undefined_control_sequence - 1; k++)
\r
2372 eqtb[k] = eqtb[undefined_control_sequence];
\r
2374 equiv(glue_base) = zero_glue;
\r
2375 eq_level(glue_base) = level_one;
\r
2376 eq_type(glue_base) = glue_ref;
\r
2378 for (k = glue_base + 1; k <= local_base - 1; k++)
\r
2379 eqtb[k] = eqtb[glue_base];
\r
2381 glue_ref_count(zero_glue) = glue_ref_count(zero_glue) + local_base - glue_base;
\r
2383 par_shape_ptr = 0;
\r
2384 eq_type(par_shape_loc) = shape_ref;
\r
2385 eq_level(par_shape_loc) = level_one;
\r
2387 for (k = output_routine_loc; k <= toks_base + 255; k++)
\r
2388 eqtb[k] = eqtb[undefined_control_sequence];
\r
2391 eq_type(box_base) = box_ref;
\r
2392 eq_level(box_base) = level_one;
\r
2394 for (k = box_base + 1; k <= box_base + 255; k++)
\r
2395 eqtb[k] = eqtb[box_base];
\r
2397 cur_font = null_font;
\r
2398 eq_type(cur_font_loc) = data;
\r
2399 eq_level(cur_font_loc) = level_one;
\r
2401 for (k = math_font_base; k <= math_font_base + 47; k++)
\r
2402 eqtb[k] = eqtb[cur_font_loc];
\r
2404 equiv(cat_code_base) = 0;
\r
2405 eq_type(cat_code_base) = data;
\r
2406 eq_level(cat_code_base) = level_one;
\r
2408 for (k = cat_code_base; k <= int_base - 1; k++)
\r
2409 eqtb[k] = eqtb[cat_code_base];
\r
2411 for (k = 0; k <= 255; k++)
\r
2413 cat_code(k) = other_char;
\r
2415 sf_code(k) = 1000;
\r
2418 cat_code(carriage_return) = car_ret;
\r
2419 cat_code(' ') = spacer;
\r
2420 cat_code('\\') = escape;
\r
2421 cat_code('%') = comment;
\r
2422 cat_code(invalid_code) = invalid_char;
\r
2423 cat_code(null_code) = ignore;
\r
2425 for (k = '0'; k <= '9'; k++)
\r
2426 math_code(k) = k + var_code;
\r
2428 for (k = 'A'; k <= 'Z'; k++)
\r
2430 cat_code(k) = letter;
\r
2431 cat_code(k + 'a' - 'A') = letter;
\r
2432 math_code(k) = k + var_code + 0x100;
\r
2433 math_code(k + 'a' - 'A') = k + 'a' - 'A' + var_code + 0x100;
\r
2434 lc_code(k) = k + 'a' - 'A';
\r
2435 lc_code(k + 'a' - 'A') = k + 'a' - 'A';
\r
2437 uc_code(k + 'a' - 'A') = k;
\r
2441 for (k = int_base; k <= del_code_base - 1; k++)
\r
2445 tolerance = 10000;
\r
2447 max_dead_cycles = 25;
\r
2448 escape_char = '\\';
\r
2449 end_line_char = carriage_return;
\r
2451 for (k = 0; k <= 255; k++)
\r
2454 del_code('.') = 0;
\r
2456 for (k = dimen_base; k <= eqtb_size; k++)
\r
2459 hash_used = frozen_control_sequence;
\r
2463 puts("initex cs_count = 0 ");
\r
2465 eq_type(frozen_dont_expand) = dont_expand;
\r
2466 text(frozen_dont_expand) = 499; /* "notexpanded:" */
\r
2468 font_ptr = null_font;
\r
2470 font_name[null_font] = 795; /* nullfont */
\r
2471 font_area[null_font] = 335; /* "" */
\r
2472 hyphen_char[null_font] = '-';
\r
2473 skew_char[null_font] = -1;
\r
2474 bchar_label[null_font] = non_address;
\r
2475 font_bchar[null_font] = non_char;
\r
2476 font_false_bchar[null_font] = non_char;
\r
2477 font_bc[null_font] = 1;
\r
2478 font_ec[null_font] = 0;
\r
2479 font_size[null_font] = 0;
\r
2480 font_dsize[null_font] = 0;
\r
2481 char_base[null_font] = 0;
\r
2482 width_base[null_font] = 0;
\r
2483 height_base[null_font] = 0;
\r
2484 depth_base[null_font] = 0;
\r
2485 italic_base[null_font] = 0;
\r
2486 lig_kern_base[null_font] = 0;
\r
2487 kern_base[null_font] = 0;
\r
2488 exten_base[null_font] = 0;
\r
2489 font_glue[null_font] = 0;
\r
2490 font_params[null_font] = 7;
\r
2491 param_base[null_font] = -1;
\r
2493 for (k = 0; k <= 6; k++)
\r
2494 font_info[k].cint = 0;
\r
2497 text(frozen_protection) = 1184; /* "inaccessible" */
\r
2498 format_ident = 1251; /* " (INITEX)" */
\r
2499 text(end_write) = 1290; /* "endwrite" */
\r
2500 eq_level(end_write) = level_one;
\r
2501 eq_type(end_write) = outer_call;
\r
2502 equiv(end_write) = 0;
\r
2508 boolean get_strings_started (void)
\r
2517 for (k = 0; k <= 255; k++)
\r
2519 if ( (k < ' ') || (k > '~') )
\r
2525 append_char(k + 64);
\r
2527 append_char(k - 64);
\r
2530 append_lc_hex(k / 16);
\r
2531 append_lc_hex(k % 16);
\r
2537 g = make_string();
\r
2540 g = load_pool_strings(pool_size - string_vacancies);
\r
2544 printf("%s\n", "! You have to increase POOLSIZE." );
\r
2554 void sort_avail (void)
\r
2557 pointer old_rover;
\r
2559 p = get_node(010000000000);
\r
2561 rlink(rover) = empty_flag;
\r
2562 old_rover = rover;
\r
2564 while (p != old_rover)
\r
2577 while (rlink(q) < p)
\r
2581 rlink(p) = rlink(q);
\r
2589 while (rlink(p) != empty_flag)
\r
2591 llink(rlink(p)) = p;
\r
2602 void primitive_ (str_number s, quarterword c, halfword o)
\r
2606 /* small_number l; */
\r
2610 cur_val = s + single_base;
\r
2614 l = str_start[s + 1] - k;
\r
2616 for (j = 0; j <= l - 1; j++)
\r
2617 buffer[j] = str_pool[k + j];
\r
2619 cur_val = id_lookup(0, l);
\r
2621 text(cur_val) = s;
\r
2624 eq_level(cur_val) = level_one;
\r
2625 eq_type(cur_val) = c;
\r
2626 equiv(cur_val) = o;
\r
2632 trie_op_code new_trie_op (small_number d, small_number n, trie_op_code v)
\r
2638 h = abs(n + 313 * d + 361 * v + 1009 * cur_lang) % (trie_op_size + trie_op_size) + neg_trie_op_size;
\r
2642 l = trie_op_hash[h];
\r
2646 if (trie_op_ptr == trie_op_size)
\r
2648 overflow("pattern memory ops", trie_op_size);
\r
2652 u = trie_used[cur_lang];
\r
2654 if (u == max_trie_op)
\r
2656 overflow("pattern memory ops per language", max_trie_op - min_trie_op);
\r
2660 incr(trie_op_ptr);
\r
2662 trie_used[cur_lang] = u;
\r
2664 if (u > max_op_used)
\r
2667 hyf_distance[trie_op_ptr] = d;
\r
2668 hyf_num[trie_op_ptr] = n;
\r
2669 hyf_next[trie_op_ptr] = v;
\r
2670 trie_op_lang[trie_op_ptr] = cur_lang;
\r
2671 trie_op_hash[h] = trie_op_ptr;
\r
2672 trie_op_val[trie_op_ptr] = u;
\r
2676 if ((hyf_distance[l] == d) && (hyf_num[l] == n) && (hyf_next[l] == v) && (trie_op_lang[l] == cur_lang))
\r
2678 return trie_op_val[l];
\r
2681 if (h > - (integer) trie_op_size)
\r
2688 trie_pointer trie_node (trie_pointer p)
\r
2693 /* the 1009, 2718, 3142 are hard-wired constants here (not hyphen_prime) */
\r
2694 /* compute hash value */
\r
2695 h = abs(trie_c[p] + 1009 * trie_o[p] + 2718 * trie_l[p] + 3142 * trie_r[p]) % trie_size;
\r
2707 if ((trie_c[q] == trie_c[p]) && (trie_o[q] == trie_o[p]) &&
\r
2708 (trie_l[q] == trie_l[p]) && (trie_r[q] == trie_r[p]))
\r
2720 trie_pointer compress_trie (trie_pointer p)
\r
2726 trie_l[p] = compress_trie(trie_l[p]);
\r
2727 trie_r[p] = compress_trie(trie_r[p]);
\r
2729 return trie_node(p);
\r
2733 void first_fit (trie_pointer p)
\r
2739 trie_pointer l, r;
\r
2749 if (trie_max < h + 256)
\r
2751 if (trie_size <= h + 256)
\r
2753 overflow("pattern memory", trie_size);
\r
2760 trie_taken[trie_max] = false;
\r
2761 trie_trl[trie_max] = trie_max + 1;
\r
2762 trie_tro[trie_max] = trie_max - 1;
\r
2764 while (!(trie_max == h + 256));
\r
2767 if (trie_taken[h])
\r
2774 if (trie_trl[h + trie_c[q]] == 0)
\r
2787 trie_taken[h] = true;
\r
2793 z = h + trie_c[q];
\r
2803 ll = z; /* short ll */
\r
2812 while (!(l == ll));
\r
2817 while (!(q == 0));
\r
2820 void trie_pack (trie_pointer p)
\r
2828 if ((q > 0) && (trie_hash[q]== 0))
\r
2836 while (!(p == 0));
\r
2839 void trie_fix (trie_pointer p)
\r
2851 trie_trl[z + c] = trie_hash[q];
\r
2852 trie_trc[z + c] = c;
\r
2853 trie_tro[z + c] = trie_o[p];
\r
2860 while (!(p == 0));
\r
2863 void new_patterns (void)
\r
2866 boolean digit_sensed;
\r
2868 trie_pointer p, q;
\r
2869 boolean first_child;
\r
2870 /* ASCII_code c; */
\r
2873 if (!trie_not_ready)
\r
2875 if (allow_patterns)
\r
2878 puts("Resetting patterns");
\r
2882 if (reset_exceptions)
\r
2885 puts("Resetting exceptions");
\r
2892 if (trie_not_ready)
\r
2895 scan_left_brace();
\r
2898 digit_sensed = false;
\r
2908 if (digit_sensed || (cur_chr < '0') || (cur_chr > '9'))
\r
2910 if (cur_chr == '.')
\r
2914 cur_chr = lc_code(cur_chr);
\r
2918 print_err("Nonletter");
\r
2919 help1("(See Appendix H.)");
\r
2929 digit_sensed = false;
\r
2934 hyf[k] = cur_chr - '0';
\r
2935 digit_sensed = true;
\r
2955 v = new_trie_op(k - l, hyf[l], v);
\r
2971 first_child = true;
\r
2973 while ((p > 0) && (c > trie_c[p]))
\r
2977 first_child = false;
\r
2980 if ((p == 0) || (c < trie_c[p]))
\r
2982 if (trie_ptr == trie_size)
\r
2984 overflow("pattern memory", trie_size);
\r
2989 trie_r[trie_ptr] = p;
\r
2999 trie_o[p] = min_trie_op;
\r
3005 if (trie_o[q] != min_trie_op)
\r
3007 print_err("Duplicate pattern");
\r
3008 help1("(See Appendix H.)");
\r
3015 if (cur_cmd == right_brace)
\r
3020 digit_sensed = false;
\r
3025 print_err("Bad ");
\r
3026 print_esc("patterns");
\r
3027 help1("(See Appendix H.)");
\r
3037 print_err("Too late for ");
\r
3038 print_esc("patterns");
\r
3039 help1("All patterns must be given before typesetting begins.");
\r
3041 link(garbage) = scan_toks(false, false);
\r
3042 flush_list(def_ref);
\r
3046 void init_trie (void)
\r
3049 /* integer j, k, t; */
\r
3052 trie_pointer r, s;
\r
3054 op_start[0] = - (integer) min_trie_op;
\r
3056 for (j = 1; j <= 255; j++)
\r
3057 op_start[j] = op_start[j - 1] + trie_used[j - 1];
\r
3059 for (j = 1; j <= trie_op_ptr; j++)
\r
3060 trie_op_hash[j] = op_start[trie_op_lang[j]] + trie_op_val[j];
\r
3062 for (j = 1; j <= trie_op_ptr; j++)
\r
3064 while (trie_op_hash[j] > j)
\r
3066 k = trie_op_hash[j];
\r
3067 t = hyf_distance[k];
\r
3068 hyf_distance[k] = hyf_distance[j];
\r
3069 hyf_distance[j] = t;
\r
3071 hyf_num[k] = hyf_num[j];
\r
3074 hyf_next[k] = hyf_next[j];
\r
3076 trie_op_hash[j] = trie_op_hash[k];
\r
3077 trie_op_hash[k] = k;
\r
3081 for (p = 0; p <= trie_size; p++)
\r
3084 trie_l[0] = compress_trie(trie_l[0]);
\r
3086 for (p = 0; p <= trie_ptr; p++)
\r
3089 for (p = 0; p <= 255; p++)
\r
3090 trie_min[p] = p + 1;
\r
3095 if (trie_l[0] != 0)
\r
3097 first_fit(trie_l[0]);
\r
3098 trie_pack(trie_l[0]);
\r
3101 if (trie_l[0] == 0)
\r
3103 for (r = 0; r <= 256; r++)
\r
3106 trie_tro[r] = min_trie_op;
\r
3114 trie_fix(trie_l[0]);
\r
3123 trie_tro[r] = min_trie_op;
\r
3129 while (!(r > trie_max));
\r
3133 trie_not_ready = false;
\r
3139 void store_fmt_file (void)
\r
3147 puts("! \\dump is performed only by INITEX");
\r
3150 puts(" (Use -i on the command line)");
\r
3155 if (save_ptr != 0)
\r
3157 print_err("You can't dump inside a group");
\r
3158 help1("`{...\\dump}' is a no-no.");
\r
3162 selector = new_string;
\r
3163 prints(" (preloaded format=");
\r
3173 if (interaction == batch_mode)
\r
3174 selector = log_only;
\r
3176 selector = term_and_log;
\r
3179 format_ident = make_string();
\r
3180 pack_job_name(".fmt");
\r
3182 while (!w_open_out(fmt_file))
\r
3183 prompt_file_name("format file name", ".fmt");
\r
3185 print_nl("Beginning to dump on file ");
\r
3186 slow_print(w_make_name_string(fmt_file));
\r
3189 slow_print(format_ident);
\r
3191 dump_int(BEGINFMTCHECKSUM);
\r
3192 dump_int(mem_bot);
\r
3193 dump_int(mem_top);
\r
3194 dump_int(eqtb_size);
\r
3195 dump_int(hash_prime);
\r
3196 dump_int(hyphen_prime);
\r
3197 dump_int(pool_ptr);
\r
3198 dump_int(str_ptr);
\r
3199 dumpthings(str_start[0], str_ptr + 1);
\r
3200 dumpthings(str_pool[0], pool_ptr);
\r
3202 print_int(str_ptr);
\r
3203 prints(" strings of total length ");
\r
3204 print_int(pool_ptr);
\r
3208 dump_int(lo_mem_max);
\r
3216 if (dumpthings(mem[p], q + 2 - p))
\r
3219 x = x + q + 2 - p;
\r
3220 var_used = var_used + q - p;
\r
3221 p = q + node_size(q);
\r
3224 while (!(q == rover));
\r
3226 var_used = var_used + lo_mem_max - p;
\r
3227 dyn_used = mem_end + 1 - hi_mem_min;
\r
3229 if (dumpthings(mem[p], lo_mem_max + 1 - p))
\r
3232 x = x + lo_mem_max + 1 - p;
\r
3233 dump_int(hi_mem_min);
\r
3236 if (dumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min))
\r
3239 x = x + mem_end + 1 - hi_mem_min;
\r
3248 dump_int(var_used);
\r
3249 dump_int(dyn_used);
\r
3252 prints(" memory locations dumped; current usage is ");
\r
3253 print_int(var_used);
\r
3255 print_int(dyn_used);
\r
3263 while (j < (int_base - 1))
\r
3265 if ((equiv(j) == equiv(j + 1)) &&
\r
3266 (eq_type(j) == eq_type(j + 1)) &&
\r
3267 (eq_level(j) == eq_level(j + 1)))
\r
3280 while (j < (int_base - 1))
\r
3282 if ((equiv(j) != equiv(j + 1)) ||
\r
3283 (eq_type(j) != eq_type(j + 1)) ||
\r
3284 (eq_level(j) != eq_level(j + 1)))
\r
3293 if (dumpthings(eqtb[k], l - k))
\r
3299 while (!(k == (int_base)));
\r
3305 while (j < (eqtb_size))
\r
3307 if (eqtb[j].cint == eqtb[j + 1].cint)
\r
3313 l = (eqtb_size + 1);
\r
3320 while (j < (eqtb_size))
\r
3322 if (eqtb[j].cint != eqtb[j + 1].cint)
\r
3331 if (dumpthings(eqtb[k], l - k))
\r
3337 while (!(k > (eqtb_size)));
\r
3339 dump_int(par_loc);
\r
3340 dump_int(write_loc);
\r
3342 dump_int(hash_used);
\r
3343 cs_count = frozen_control_sequence - 1 - hash_used;
\r
3346 printf("itex cs_count %lld hash_size %d hash_extra %d hash_used %d",
\r
3347 cs_count, hash_size, hash_extra, hash_used);
\r
3349 for (p = hash_base; p <= hash_used; p++)
\r
3358 puts("itex.c store_fmt_file() cs_count++ ");
\r
3362 if (dumpthings(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used))
\r
3365 dump_int(cs_count);
\r
3367 print_int(cs_count);
\r
3368 prints(" multiletter control sequences");
\r
3370 dump_int(fmem_ptr);
\r
3373 dumpthings(font_info[0], fmem_ptr);
\r
3374 dump_int(font_ptr);
\r
3375 dumpthings(font_check[0], font_ptr + 1);
\r
3376 dumpthings(font_size[0], font_ptr + 1);
\r
3377 dumpthings(font_dsize[0], font_ptr + 1);
\r
3378 dumpthings(font_params[0], font_ptr + 1);
\r
3379 dumpthings(hyphen_char[0], font_ptr + 1);
\r
3380 dumpthings(skew_char[0], font_ptr + 1);
\r
3381 dumpthings(font_name[0], font_ptr + 1);
\r
3382 dumpthings(font_area[0], font_ptr + 1);
\r
3383 dumpthings(font_bc[0], font_ptr + 1);
\r
3384 dumpthings(font_ec[0], font_ptr + 1);
\r
3385 dumpthings(char_base[0], font_ptr + 1);
\r
3386 dumpthings(width_base[0], font_ptr + 1);
\r
3387 dumpthings(height_base[0], font_ptr + 1);
\r
3388 dumpthings(depth_base[0], font_ptr + 1);
\r
3389 dumpthings(italic_base[0], font_ptr + 1);
\r
3390 dumpthings(lig_kern_base[0], font_ptr + 1);
\r
3391 dumpthings(kern_base[0], font_ptr + 1);
\r
3392 dumpthings(exten_base[0], font_ptr + 1);
\r
3393 dumpthings(param_base[0], font_ptr + 1);
\r
3394 dumpthings(font_glue[0], font_ptr + 1);
\r
3395 dumpthings(bchar_label[0], font_ptr + 1);
\r
3396 dumpthings(font_bchar[0], font_ptr + 1);
\r
3397 dumpthings(font_false_bchar[0], font_ptr + 1);
\r
3399 for (k = 0; k <= font_ptr; k++)
\r
3401 print_nl("\\font");
\r
3403 print(font_id_text(k));
\r
3405 print_file_name(font_name[k], font_area[k], 335);
\r
3407 if (font_size[k] != font_dsize[k])
\r
3410 print_scaled(font_size[k]);
\r
3417 print_int(fmem_ptr - 7);
\r
3418 prints(" words of font info for ");
\r
3419 print_int(font_ptr - font_base);
\r
3420 prints(" preloaded font");
\r
3422 if (font_ptr != font_base + 1)
\r
3425 dump_int(hyph_count);
\r
3427 for (k = 0; k <= hyphen_prime; k++)
\r
3429 if (hyph_word[k] != 0)
\r
3432 dump_int(hyph_word[k]);
\r
3433 dump_int(hyph_list[k]);
\r
3438 print_int(hyph_count);
\r
3439 prints(" hyphenation exception");
\r
3441 if (hyph_count != 1)
\r
3444 if (trie_not_ready)
\r
3447 dump_int(trie_max);
\r
3448 dumpthings(trie_trl[0], trie_max + 1);
\r
3449 dumpthings(trie_tro[0], trie_max + 1);
\r
3450 dumpthings(trie_trc[0], trie_max + 1);
\r
3451 dump_int(trie_op_ptr);
\r
3452 dumpthings(hyf_distance[1], trie_op_ptr);
\r
3453 dumpthings(hyf_num[1], trie_op_ptr);
\r
3454 dumpthings(hyf_next[1], trie_op_ptr);
\r
3455 print_nl("Hyphenation trie of length ");
\r
3456 print_int(trie_max);
\r
3458 print_int(trie_op_ptr);
\r
3461 if (trie_op_ptr != 1)
\r
3464 prints(" out of ");
\r
3465 print_int(trie_op_size);
\r
3467 for (k = 255; k >= 0; k--)
\r
3469 if (trie_used[k] > 0)
\r
3472 print_int(trie_used[k]);
\r
3473 prints(" for language ");
\r
3476 dump_int(trie_used[k]);
\r
3480 dump_int(interaction);
\r
3481 dump_int(format_ident);
\r
3482 dump_int(ENDFMTCHECKSUM);
\r
3483 tracing_stats = 0;
\r
3485 #ifdef COMPACTFORMAT
\r
3486 gz_w_close(gz_fmt_file);
\r
3488 w_close(fmt_file);
\r
3495 void init_prim (void)
\r
3497 no_new_control_sequence = false;
\r
3499 primitive("lineskip", assign_glue, glue_base + line_skip_code);
\r
3500 primitive("baselineskip", assign_glue, glue_base + baseline_skip_code);
\r
3501 primitive("parskip", assign_glue, glue_base + par_skip_code);
\r
3502 primitive("abovedisplayskip", assign_glue, glue_base + above_display_skip_code);
\r
3503 primitive("belowdisplayskip", assign_glue, glue_base + below_display_skip_code);
\r
3504 primitive("abovedisplayshortskip", assign_glue, glue_base + above_display_short_skip_code);
\r
3505 primitive("belowdisplayshortskip", assign_glue, glue_base + below_display_short_skip_code);
\r
3506 primitive("leftskip", assign_glue, glue_base + left_skip_code);
\r
3507 primitive("rightskip", assign_glue, glue_base + right_skip_code);
\r
3508 primitive("topskip", assign_glue, glue_base + top_skip_code);
\r
3509 primitive("splittopskip", assign_glue, glue_base + split_top_skip_code);
\r
3510 primitive("tabskip", assign_glue, glue_base + tab_skip_code);
\r
3511 primitive("spaceskip", assign_glue, glue_base + space_skip_code);
\r
3512 primitive("xspaceskip", assign_glue, glue_base + xspace_skip_code);
\r
3513 primitive("parfillskip", assign_glue, glue_base + par_fill_skip_code);
\r
3514 primitive("thinmuskip", assign_mu_glue, glue_base + thin_mu_skip_code);
\r
3515 primitive("medmuskip", assign_mu_glue, glue_base + med_mu_skip_code);
\r
3516 primitive("thickmuskip", assign_mu_glue, glue_base + thick_mu_skip_code);
\r
3518 primitive("output", assign_toks, output_routine_loc);
\r
3519 primitive("everypar", assign_toks, every_par_loc);
\r
3520 primitive("everymath", assign_toks, every_math_loc);
\r
3521 primitive("everydisplay", assign_toks, every_display_loc);
\r
3522 primitive("everyhbox", assign_toks, every_hbox_loc);
\r
3523 primitive("everyvbox", assign_toks, every_vbox_loc);
\r
3524 primitive("everyjob", assign_toks, every_job_loc);
\r
3525 primitive("everycr", assign_toks, every_cr_loc);
\r
3526 primitive("errhelp", assign_toks, err_help_loc);
\r
3528 primitive("pretolerance", assign_int, int_base + pretolerance_code);
\r
3529 primitive("tolerance", assign_int, int_base + tolerance_code);
\r
3530 primitive("linepenalty", assign_int, int_base + line_penalty_code);
\r
3531 primitive("hyphenpenalty", assign_int, int_base + hyphen_penalty_code);
\r
3532 primitive("exhyphenpenalty", assign_int, int_base + ex_hyphen_penalty_code);
\r
3533 primitive("clubpenalty", assign_int, int_base + club_penalty_code);
\r
3534 primitive("widowpenalty", assign_int, int_base + widow_penalty_code);
\r
3535 primitive("displaywidowpenalty", assign_int, int_base + display_widow_penalty_code);
\r
3536 primitive("brokenpenalty", assign_int, int_base + broken_penalty_code);
\r
3537 primitive("binoppenalty", assign_int, int_base + bin_op_penalty_code);
\r
3538 primitive("relpenalty", assign_int, int_base + rel_penalty_code);
\r
3539 primitive("predisplaypenalty", assign_int, int_base + pre_display_penalty_code);
\r
3540 primitive("postdisplaypenalty", assign_int, int_base + post_display_penalty_code);
\r
3541 primitive("interlinepenalty", assign_int, int_base + inter_line_penalty_code);
\r
3542 primitive("doublehyphendemerits", assign_int, int_base + double_hyphen_demerits_code);
\r
3543 primitive("finalhyphendemerits", assign_int, int_base + final_hyphen_demerits_code);
\r
3544 primitive("adjdemerits", assign_int, int_base + adj_demerits_code);
\r
3545 primitive("mag", assign_int, int_base + mag_code);
\r
3546 primitive("delimiterfactor", assign_int, int_base + delimiter_factor_code);
\r
3547 primitive("looseness", assign_int, int_base + looseness_code);
\r
3548 primitive("time", assign_int, int_base + time_code);
\r
3549 primitive("day", assign_int, int_base + day_code);
\r
3550 primitive("month", assign_int, int_base + month_code);
\r
3551 primitive("year", assign_int, int_base + year_code);
\r
3552 primitive("showboxbreadth", assign_int, int_base + show_box_breadth_code);
\r
3553 primitive("showboxdepth", assign_int, int_base + show_box_depth_code);
\r
3554 primitive("hbadness", assign_int, int_base + hbadness_code);
\r
3555 primitive("vbadness", assign_int, int_base + vbadness_code);
\r
3556 primitive("pausing", assign_int, int_base + pausing_code);
\r
3557 primitive("tracingonline", assign_int, int_base + tracing_online_code);
\r
3558 primitive("tracingmacros", assign_int, int_base + tracing_macros_code);
\r
3559 primitive("tracingstats", assign_int, int_base + tracing_stats_code);
\r
3560 primitive("tracingparagraphs", assign_int, int_base + tracing_paragraphs_code);
\r
3561 primitive("tracingpages", assign_int, int_base + tracing_pages_code);
\r
3562 primitive("tracingoutput", assign_int, int_base + tracing_output_code);
\r
3563 primitive("tracinglostchars", assign_int, int_base + tracing_lost_chars_code);
\r
3564 primitive("tracingcommands", assign_int, int_base + tracing_commands_code);
\r
3565 primitive("tracingrestores", assign_int, int_base + tracing_restores_code);
\r
3566 primitive("uchyph", assign_int, int_base + uc_hyph_code);
\r
3567 primitive("outputpenalty", assign_int, int_base + output_penalty_code);
\r
3568 primitive("maxdeadcycles", assign_int, int_base + max_dead_cycles_code);
\r
3569 primitive("hangafter", assign_int, int_base + hang_after_code);
\r
3570 primitive("floatingpenalty", assign_int, int_base + floating_penalty_code);
\r
3571 primitive("globaldefs", assign_int, int_base + global_defs_code);
\r
3572 primitive("fam", assign_int, int_base + cur_fam_code);
\r
3573 primitive("escapechar", assign_int, int_base + escape_char_code);
\r
3574 primitive("defaulthyphenchar", assign_int, int_base + default_hyphen_char_code);
\r
3575 primitive("defaultskewchar", assign_int, int_base + default_skew_char_code);
\r
3576 primitive("endlinechar", assign_int, int_base + end_line_char_code);
\r
3577 primitive("newlinechar", assign_int, int_base + new_line_char_code);
\r
3578 primitive("language", assign_int, int_base + language_code);
\r
3579 primitive("lefthyphenmin", assign_int, int_base + left_hyphen_min_code);
\r
3580 primitive("righthyphenmin", assign_int, int_base + right_hyphen_min_code);
\r
3581 primitive("holdinginserts", assign_int, int_base + holding_inserts_code);
\r
3582 primitive("errorcontextlines", assign_int, int_base + error_context_lines_code);
\r
3584 primitive("parindent", assign_dimen, dimen_base + par_indent_code);
\r
3585 primitive("mathsurround", assign_dimen, dimen_base + math_surround_code);
\r
3586 primitive("lineskiplimit", assign_dimen, dimen_base + line_skip_limit_code);
\r
3587 primitive("hsize", assign_dimen, dimen_base + hsize_code);
\r
3588 primitive("vsize", assign_dimen, dimen_base + vsize_code);
\r
3589 primitive("maxdepth", assign_dimen, dimen_base + max_depth_code);
\r
3590 primitive("splitmaxdepth", assign_dimen, dimen_base + split_max_depth_code);
\r
3591 primitive("boxmaxdepth", assign_dimen, dimen_base + box_max_depth_code);
\r
3592 primitive("hfuzz", assign_dimen, dimen_base + hfuzz_code);
\r
3593 primitive("vfuzz", assign_dimen, dimen_base + vfuzz_code);
\r
3594 primitive("delimitershortfall", assign_dimen, dimen_base + delimiter_shortfall_code);
\r
3595 primitive("nulldelimiterspace", assign_dimen, dimen_base + null_delimiter_space_code);
\r
3596 primitive("scriptspace", assign_dimen, dimen_base + script_space_code);
\r
3597 primitive("predisplaysize", assign_dimen, dimen_base + pre_display_size_code);
\r
3598 primitive("displaywidth", assign_dimen, dimen_base + display_width_code);
\r
3599 primitive("displayindent", assign_dimen, dimen_base + display_indent_code);
\r
3600 primitive("overfullrule", assign_dimen, dimen_base + overfull_rule_code);
\r
3601 primitive("hangindent", assign_dimen, dimen_base + hang_indent_code);
\r
3602 primitive("hoffset", assign_dimen, dimen_base + h_offset_code);
\r
3603 primitive("voffset", assign_dimen, dimen_base + v_offset_code);
\r
3604 primitive("emergencystretch", assign_dimen, dimen_base + emergency_stretch_code);
\r
3605 primitive(" ", ex_space, 0);
\r
3606 primitive("/", ital_corr, 0);
\r
3607 primitive("accent", accent, 0);
\r
3608 primitive("advance", advance, 0);
\r
3609 primitive("afterassignment", after_assignment, 0);
\r
3610 primitive("aftergroup", after_group, 0);
\r
3611 primitive("begingroup", begin_group, 0);
\r
3612 primitive("char", char_num, 0);
\r
3613 primitive("csname", cs_name, 0);
\r
3614 primitive("delimiter", delim_num, 0);
\r
3615 primitive("divide", divide, 0);
\r
3616 primitive("endcsname", end_cs_name, 0);
\r
3617 primitive("endgroup", end_group, 0);
\r
3618 text(frozen_end_group) = make_string_pool("endgroup");
\r
3619 eqtb[frozen_end_group] = eqtb[cur_val];
\r
3620 primitive("expandafter", expand_after, 0);
\r
3621 primitive("font", def_font, 0);
\r
3622 primitive("fontdimen", assign_font_dimen, 0);
\r
3623 primitive("halign", halign, 0);
\r
3624 primitive("hrule", hrule, 0);
\r
3625 primitive("ignorespaces", ignore_spaces, 0);
\r
3626 primitive("insert", insert, 0);
\r
3627 primitive("mark", mark, 0);
\r
3628 primitive("mathaccent", math_accent, 0);
\r
3629 primitive("mathchar", math_char_num, 0);
\r
3630 primitive("mathchoice", math_choice, 0);
\r
3631 primitive("multiply", multiply, 0);
\r
3632 primitive("noalign", no_align, 0);
\r
3633 primitive("noboundary", no_boundary, 0);
\r
3634 primitive("noexpand", no_expand, 0);
\r
3635 primitive("nonscript", non_script, 0);
\r
3636 primitive("omit", omit, 0);
\r
3637 primitive("parshape", set_shape, 0);
\r
3638 primitive("penalty", break_penalty, 0);
\r
3639 primitive("prevgraf", set_prev_graf, 0);
\r
3640 primitive("radical", radical, 0);
\r
3641 primitive("read", read_to_cs, 0);
\r
3642 primitive("relax", relax, 256);
\r
3643 text(frozen_relax) = make_string_pool("relax");
\r
3644 eqtb[frozen_relax] = eqtb[cur_val];
\r
3645 primitive("setbox", set_box, 0);
\r
3646 primitive("the", the, 0);
\r
3647 primitive("toks", toks_register, 0);
\r
3648 primitive("vadjust", vadjust, 0);
\r
3649 primitive("valign", valign, 0);
\r
3650 primitive("vcenter", vcenter, 0);
\r
3651 primitive("vrule", vrule, 0);
\r
3652 primitive("par", par_end, 256);
\r
3653 par_loc = cur_val;
\r
3654 par_token = cs_token_flag + par_loc;
\r
3655 primitive("input", input, 0);
\r
3656 primitive("endinput", input, 1);
\r
3657 primitive("topmark", top_bot_mark, top_mark_code);
\r
3658 primitive("firstmark", top_bot_mark, first_mark_code);
\r
3659 primitive("botmark", top_bot_mark, bot_mark_code);
\r
3660 primitive("splitfirstmark", top_bot_mark, split_first_mark_code);
\r
3661 primitive("splitbotmark", top_bot_mark, split_bot_mark_code);
\r
3662 primitive("count", tex_register, int_val);
\r
3663 primitive("dimen", tex_register, dimen_val);
\r
3664 primitive("skip", tex_register, glue_val);
\r
3665 primitive("muskip", tex_register, mu_val);
\r
3666 primitive("spacefactor", set_aux, hmode);
\r
3667 primitive("prevdepth", set_aux, vmode);
\r
3668 primitive("deadcycles", set_page_int, 0);
\r
3669 primitive("insertpenalties", set_page_int, 1);
\r
3670 primitive("wd", set_box_dimen, width_offset);
\r
3671 primitive("ht", set_box_dimen, height_offset);
\r
3672 primitive("dp", set_box_dimen, depth_offset);
\r
3673 primitive("lastpenalty", last_item, int_val);
\r
3674 primitive("lastkern", last_item, dimen_val);
\r
3675 primitive("lastskip", last_item, glue_val);
\r
3676 primitive("inputlineno", last_item, input_line_no_code);
\r
3677 primitive("badness", last_item, badness_code);
\r
3678 primitive("number", convert, number_code);
\r
3679 primitive("romannumeral", convert, roman_numeral_code);
\r
3680 primitive("string", convert, string_code);
\r
3681 primitive("meaning", convert, meaning_code);
\r
3682 primitive("fontname", convert, font_name_code);
\r
3683 primitive("jobname", convert, job_name_code);
\r
3684 primitive("if", if_test, if_char_code);
\r
3685 primitive("ifcat", if_test, if_cat_code);
\r
3686 primitive("ifnum", if_test, if_int_code);
\r
3687 primitive("ifdim", if_test, if_dim_code);
\r
3688 primitive("ifodd", if_test, if_odd_code);
\r
3689 primitive("ifvmode", if_test, if_vmode_code);
\r
3690 primitive("ifhmode", if_test, if_hmode_code);
\r
3691 primitive("ifmmode", if_test, if_mmode_code);
\r
3692 primitive("ifinner", if_test, if_inner_code);
\r
3693 primitive("ifvoid", if_test, if_void_code);
\r
3694 primitive("ifhbox", if_test, if_hbox_code);
\r
3695 primitive("ifvbox", if_test, if_vbox_code);
\r
3696 primitive("ifx", if_test, ifx_code);
\r
3697 primitive("ifeof", if_test, if_eof_code);
\r
3698 primitive("iftrue", if_test, if_true_code);
\r
3699 primitive("iffalse", if_test, if_false_code);
\r
3700 primitive("ifcase", if_test, if_case_code);
\r
3701 primitive("fi", fi_or_else, fi_code);
\r
3702 text(frozen_fi) = make_string_pool("fi");
\r
3703 eqtb[frozen_fi] = eqtb[cur_val];
\r
3704 primitive("or", fi_or_else, or_code);
\r
3705 primitive("else", fi_or_else, else_code);
\r
3706 primitive("nullfont", set_font, null_font);
\r
3707 text(frozen_null_font) = 795;
\r
3708 eqtb[frozen_null_font] = eqtb[cur_val];
\r
3709 primitive("span", tab_mark, span_code);
\r
3710 primitive("cr", car_ret, cr_code);
\r
3711 text(frozen_cr) = make_string_pool("cr");
\r
3712 eqtb[frozen_cr] = eqtb[cur_val];
\r
3713 primitive("crcr", car_ret, cr_cr_code);
\r
3714 text(frozen_end_template) = make_string_pool("endtemplate");
\r
3715 text(frozen_endv) = make_string_pool("endtemplate");
\r
3716 eq_type(frozen_endv) = endv;
\r
3717 equiv(frozen_endv) = null_list;
\r
3718 eq_level(frozen_endv) = level_one;
\r
3719 eqtb[frozen_end_template] = eqtb[frozen_endv];
\r
3720 eq_type(frozen_end_template) = end_template;
\r
3721 primitive("pagegoal", set_page_dimen, 0);
\r
3722 primitive("pagetotal", set_page_dimen, 1);
\r
3723 primitive("pagestretch", set_page_dimen, 2);
\r
3724 primitive("pagefilstretch", set_page_dimen, 3);
\r
3725 primitive("pagefillstretch", set_page_dimen, 4);
\r
3726 primitive("pagefilllstretch", set_page_dimen, 5);
\r
3727 primitive("pageshrink", set_page_dimen, 6);
\r
3728 primitive("pagedepth", set_page_dimen, 7);
\r
3729 primitive("end", stop, 0);
\r
3730 primitive("dump", stop, 1);
\r
3731 primitive("hskip", hskip, skip_code);
\r
3732 primitive("hfil", hskip, fil_code);
\r
3733 primitive("hfill", hskip, fill_code);
\r
3734 primitive("hss", hskip, ss_code);
\r
3735 primitive("hfilneg", hskip, fil_neg_code);
\r
3736 primitive("vskip", vskip, skip_code);
\r
3737 primitive("vfil", vskip, fil_code);
\r
3738 primitive("vfill", vskip, fill_code);
\r
3739 primitive("vss", vskip, ss_code);
\r
3740 primitive("vfilneg", vskip, fil_neg_code);
\r
3741 primitive("mskip", mskip, mskip_code);
\r
3742 primitive("kern", kern, explicit);
\r
3743 primitive("mkern", mkern, mu_glue);
\r
3744 primitive("moveleft", hmove, 1);
\r
3745 primitive("moveright", hmove, 0);
\r
3746 primitive("raise", vmove, 1);
\r
3747 primitive("lower", vmove, 0);
\r
3748 primitive("box", make_box, box_code);
\r
3749 primitive("copy", make_box, copy_code);
\r
3750 primitive("lastbox", make_box, last_box_code);
\r
3751 primitive("vsplit", make_box, vsplit_code);
\r
3752 primitive("vtop", make_box, vtop_code);
\r
3753 primitive("vbox", make_box, vtop_code + vmode);
\r
3754 primitive("hbox", make_box, vtop_code + hmode);
\r
3755 primitive("shipout", leader_ship, a_leaders - 1);
\r
3756 primitive("leaders", leader_ship, a_leaders);
\r
3757 primitive("cleaders", leader_ship, c_leaders);
\r
3758 primitive("xleaders", leader_ship, x_leaders);
\r
3759 primitive("indent", start_par, 1);
\r
3760 primitive("noindent", start_par, 0);
\r
3761 primitive("unpenalty", remove_item, penalty_node);
\r
3762 primitive("unkern", remove_item, kern_node);
\r
3763 primitive("unskip", remove_item, glue_node);
\r
3764 primitive("unhbox", un_hbox, box_code);
\r
3765 primitive("unhcopy", un_hbox, copy_code);
\r
3766 primitive("unvbox", un_vbox, box_code);
\r
3767 primitive("unvcopy", un_vbox, copy_code);
\r
3768 primitive("-", discretionary, 1);
\r
3769 primitive("discretionary", discretionary, 0);
\r
3770 primitive("eqno", eq_no, 0);
\r
3771 primitive("leqno", eq_no, 1);
\r
3772 primitive("mathord", math_comp, ord_noad);
\r
3773 primitive("mathop", math_comp, op_noad);
\r
3774 primitive("mathbin", math_comp, bin_noad);
\r
3775 primitive("mathrel", math_comp, rel_noad);
\r
3776 primitive("mathopen", math_comp, open_noad);
\r
3777 primitive("mathclose", math_comp, close_noad);
\r
3778 primitive("mathpunct", math_comp, punct_noad);
\r
3779 primitive("mathinner", math_comp, inner_noad);
\r
3780 primitive("underline", math_comp, under_noad);
\r
3781 primitive("overline", math_comp, over_noad);
\r
3782 primitive("displaylimits", limit_switch, normal);
\r
3783 primitive("limits", limit_switch, limits);
\r
3784 primitive("nolimits", limit_switch, no_limits);
\r
3785 primitive("displaystyle", math_style, display_style);
\r
3786 primitive("textstyle", math_style, text_style);
\r
3787 primitive("scriptstyle", math_style, script_style);
\r
3788 primitive("scriptscriptstyle", math_style, script_script_style);
\r
3789 primitive("above", above, above_code);
\r
3790 primitive("over", above, over_code);
\r
3791 primitive("atop", above, atop_code);
\r
3792 primitive("abovewithdelims", above, delimited_code + above_code);
\r
3793 primitive("overwithdelims", above, delimited_code + over_code);
\r
3794 primitive("atopwithdelims", above, delimited_code + atop_code);
\r
3795 primitive("left", left_right, left_noad);
\r
3796 primitive("right", left_right, right_noad);
\r
3797 text(frozen_right) = make_string_pool("right");
\r
3798 eqtb[frozen_right] = eqtb[cur_val];
\r
3799 primitive("long", prefix, 1);
\r
3800 primitive("outer", prefix, 2);
\r
3801 primitive("global", prefix, 4);
\r
3802 primitive("def", def, 0);
\r
3803 primitive("gdef", def, 1);
\r
3804 primitive("edef", def, 2);
\r
3805 primitive("xdef", def, 3);
\r
3806 primitive("let", let, normal);
\r
3807 primitive("futurelet", let, normal + 1);
\r
3808 primitive("chardef", shorthand_def, char_def_code);
\r
3809 primitive("mathchardef", shorthand_def, math_char_def_code);
\r
3810 primitive("countdef", shorthand_def, count_def_code);
\r
3811 primitive("dimendef", shorthand_def, dimen_def_code);
\r
3812 primitive("skipdef", shorthand_def, skip_def_code);
\r
3813 primitive("muskipdef", shorthand_def, mu_skip_def_code);
\r
3814 primitive("toksdef", shorthand_def, toks_def_code);
\r
3815 primitive("catcode", def_code, cat_code_base);
\r
3816 primitive("mathcode", def_code, math_code_base);
\r
3817 primitive("lccode", def_code, lc_code_base);
\r
3818 primitive("uccode", def_code, uc_code_base);
\r
3819 primitive("sfcode", def_code, sf_code_base);
\r
3820 primitive("delcode", def_code, del_code_base);
\r
3821 primitive("textfont", def_family, math_font_base);
\r
3822 primitive("scriptfont", def_family, math_font_base + script_size);
\r
3823 primitive("scriptscriptfont", def_family, math_font_base + script_script_size);
\r
3824 primitive("hyphenation", hyph_data, 0);
\r
3825 primitive("patterns", hyph_data, 1);
\r
3826 primitive("hyphenchar", assign_font_int, 0);
\r
3827 primitive("skewchar", assign_font_int, 1);
\r
3828 primitive("batchmode", set_interaction, batch_mode);
\r
3829 primitive("nonstopmode", set_interaction, nonstop_mode);
\r
3830 primitive("scrollmode", set_interaction, scroll_mode);
\r
3831 primitive("errorstopmode", set_interaction, error_stop_mode);
\r
3832 primitive("openin", in_stream, 1);
\r
3833 primitive("closein", in_stream, 0);
\r
3834 primitive("message", message, 0);
\r
3835 primitive("errmessage", message, 1);
\r
3836 primitive("lowercase", case_shift, lc_code_base);
\r
3837 primitive("uppercase", case_shift, uc_code_base);
\r
3838 primitive("show", xray, show_code);
\r
3839 primitive("showbox", xray, show_box_code);
\r
3840 primitive("showthe", xray, show_the_code);
\r
3841 primitive("showlists", xray, show_lists);
\r
3842 primitive("openout", extension, open_node);
\r
3843 primitive("write", extension, write_node);
\r
3844 write_loc = cur_val;
\r
3845 primitive("closeout", extension, close_node);
\r
3846 primitive("special", extension, special_node);
\r
3847 primitive("immediate", extension, immediate_code);
\r
3848 primitive("setlanguage", extension, set_language_code);
\r
3849 no_new_control_sequence = true;
\r