1 /* Copyright 1992 Karl Berry
2 Copyright 2007 TeX Users Group
3 Copyright 2014 Clerk Ma
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
24 #define BEGINFMTCHECKSUM 367403084L
25 #define ENDFMTCHECKSUM 69069L
27 extern clock_t start_time, main_time, finish_time;
30 void do_initex (void);
34 void initialize (void)
38 integer flag; /* bkph */
40 #ifndef ALLOCATEHYPHEN
46 for (i = 0; i <= 255; i++)
50 xchr[32] = ' '; xchr[33] = '!'; xchr[34] = '"'; xchr[35] = '#';
51 xchr[36] = '$'; xchr[37] = '%'; xchr[38] = '&'; xchr[39] = '\'';
52 xchr[40] = '('; xchr[41] = ')'; xchr[42] = '*'; xchr[43] = '+';
53 xchr[44] = ','; xchr[45] = '-'; xchr[46] = '.'; xchr[47] = '/';
54 xchr[48] = '0'; xchr[49] = '1'; xchr[50] = '2'; xchr[51] = '3';
55 xchr[52] = '4'; xchr[53] = '5'; xchr[54] = '6'; xchr[55] = '7';
56 xchr[56] = '8'; xchr[57] = '9'; xchr[58] = ':'; xchr[59] = ';';
57 xchr[60] = '<'; xchr[61] = '='; xchr[62] = '>'; xchr[63] = '?';
58 xchr[64] = '@'; xchr[65] = 'A'; xchr[66] = 'B'; xchr[67] = 'C';
59 xchr[68] = 'D'; xchr[69] = 'E'; xchr[70] = 'F'; xchr[71] = 'G';
60 xchr[72] = 'H'; xchr[73] = 'I'; xchr[74] = 'J'; xchr[75] = 'K';
61 xchr[76] = 'L'; xchr[77] = 'M'; xchr[78] = 'N'; xchr[79] = 'O';
62 xchr[80] = 'P'; xchr[81] = 'Q'; xchr[82] = 'R'; xchr[83] = 'S';
63 xchr[84] = 'T'; xchr[85] = 'U'; xchr[86] = 'V'; xchr[87] = 'W';
64 xchr[88] = 'X'; xchr[89] = 'Y'; xchr[90] = 'Z'; xchr[91] = '[';
65 xchr[92] = '\\'; xchr[93] = ']'; xchr[94] = '^'; xchr[95] = '_';
66 xchr[96] = '`'; xchr[97] = 'a'; xchr[98] = 'b'; xchr[99] = 'c';
67 xchr[100] = 'd'; xchr[101] = 'e'; xchr[102] = 'f'; xchr[103] = 'g';
68 xchr[104] = 'h'; xchr[105] = 'i'; xchr[106] = 'j'; xchr[107] = 'k';
69 xchr[108] = 'l'; xchr[109] = 'm'; xchr[110] = 'n'; xchr[111] = 'o';
70 xchr[112] = 'p'; xchr[113] = 'q'; xchr[114] = 'r'; xchr[115] = 's';
71 xchr[116] = 't'; xchr[117] = 'u'; xchr[118] = 'v'; xchr[119] = 'w';
72 xchr[120] = 'x'; xchr[121] = 'y'; xchr[122] = 'z'; xchr[123] = '{';
73 xchr[124] = '|'; xchr[125] = '}'; xchr[126] = '~';
75 for (i = 0; i <= 31; i++)
78 for (i = 127; i <= 255; i++)
83 for (i = 0; i <= 255; i++)
87 for (i = 128; i <= 255 ; i++)
90 for (i = 0; i <= 126; i++)
94 for (i = 0; i <= 255; i++)
95 xord[xchr[i]] = (char) i;
103 for (k = 0; k < 256; k++)
112 puts("Inverted mapping xord[] pairs:");
114 for (k = 0; k < 256; k++)
117 printf("%lld => %d\n", k, xord[k]);
122 if (interaction < batch_mode)
123 interaction = error_stop_mode;
125 deletions_allowed = true;
126 set_box_allowed = true;
129 use_err_help = false;
131 OK_to_interrupt = true;
134 was_mem_end = mem_min;
135 was_lo_max = mem_bot; // mem_min
136 was_hi_min = mem_top; // mem_max
145 prev_depth = ignore_depth;
150 page_tail = page_head;
157 last_glue = empty_flag;
163 for (k = int_base; k <= eqtb_size; k++)
164 xeq_level[k] = level_one;
166 no_new_control_sequence = true;
170 for (k = hash_base + 1; k <= undefined_control_sequence - 1; k++)
171 hash[k] = hash[hash_base];
189 for (k = 0; k <= 16; k++)
197 for (k = 0; k <= font_max; k++)
198 font_used[k] = false;
200 null_character.b0 = 0;
201 null_character.b1 = 0;
202 null_character.b2 = 0;
203 null_character.b3 = 0;
209 doing_leaders = false;
212 half_buf = dvi_buf_size / 2;
213 dvi_limit = dvi_buf_size;
224 null_delimiter.b0 = 0;
225 null_delimiter.b1 = 0;
226 null_delimiter.b2 = 0;
227 null_delimiter.b3 = 0;
235 /* *not* OK with ALLOCATEHYPHEN, since may not be allocated yet */
236 #ifndef ALLOCATEHYPHEN
237 for (z = 0; z <= hyphen_prime; z++)
245 output_active = false;
246 insert_penalties = 0;
247 ligature_present = false;
248 cancel_boundary = false;
253 long_help_seen = false;
256 for (k = 0; k <= 17; k++)
257 write_open[k] = false;
269 /* do the part of initialize() that requires mem_top, mem_max or mem[] */
270 /* do this part after allocating main memory */
273 void initialize_aux (void)
276 was_mem_end = mem_min;
277 was_lo_max = mem_bot; // mem_min
278 was_hi_min = mem_top; // mem_max
283 /* max_nest_stack = 0; */
287 prev_depth = ignore_depth;
290 /* shown_mode = 0; */
291 /* page_contents = 0; */
292 page_tail = page_head;
295 #endif // end of ifdef ALLOCATEMAIN
297 void line_break_ (integer final_widow_penalty)
299 boolean auto_breaking;
301 halfword q, r, s, prevs;
302 internal_font_number f;
303 /* small_number j; */
304 int j; /* 95/Jan/7 */
305 /* unsigned char c; */
306 unsigned int c; /* 95/Jan/7 */
308 pack_begin_line = mode_line;
309 link(temp_head) = link(head);
311 if (is_char_node(tail))
312 tail_append(new_penalty(inf_penalty));
313 else if (type(tail) != glue_node)
314 tail_append(new_penalty(inf_penalty));
317 type(tail) = penalty_node;
318 delete_glue_ref(glue_ptr(tail));
319 flush_node_list(leader_ptr(tail));
320 penalty(tail) = inf_penalty;
323 link(tail) = new_param_glue(par_fill_skip_code);
324 init_cur_lang = prev_graf % 65536L;
325 init_l_hyf = prev_graf / 4194304L; /* 2^22 */
326 init_r_hyf = (prev_graf / 65536L) % 64;
328 no_shrink_error_yet = true;
329 check_shrinkage(left_skip);
330 check_shrinkage(right_skip);
333 background[1] = width(q) + width(r);
338 background[2 + stretch_order(q)] = stretch(q);
339 background[2 + stretch_order(r)] = background[2 + stretch_order(r)] + stretch(r);
340 background[6] = shrink(q) + shrink(r);
341 minimum_demerits = awful_bad;
342 minimal_demerits[tight_fit] = awful_bad;
343 minimal_demerits[decent_fit] = awful_bad;
344 minimal_demerits[loose_fit] = awful_bad;
345 minimal_demerits[very_loose_fit] = awful_bad;
347 if (par_shape_ptr == 0)
348 if (hang_indent == 0)
350 last_special_line = 0;
351 second_width = hsize;
356 last_special_line = abs(hang_after);
360 first_width = hsize - abs(hang_indent);
362 if (hang_indent >= 0)
363 first_indent = hang_indent;
367 second_width = hsize;
374 second_width = hsize - abs(hang_indent);
376 if (hang_indent >= 0)
377 second_indent = hang_indent;
384 last_special_line = info(par_shape_ptr) - 1;
385 second_width = mem[par_shape_ptr + 2 * (last_special_line + 1)].cint;
386 second_indent = mem[par_shape_ptr + 2 * last_special_line + 1].cint;
390 easy_line = last_special_line;
392 easy_line = empty_flag;
394 threshold = pretolerance;
399 if (tracing_paragraphs > 0)
402 print_nl("@firstpass");
408 first_pass_count++; /* 96 Feb 9 */
412 threshold = tolerance;
414 final_pass = (emergency_stretch <= 0);
417 if (tracing_paragraphs > 0)
424 if (threshold > inf_bad)
437 cur_lang = init_cur_lang;
443 type(q) = unhyphenated;
444 fitness(q) = decent_fit;
447 line_number(q) = prev_graf + 1;
448 total_demerits(q) = 0;
450 act_width = background[1];
451 active_width[2] = background[2];
452 active_width[3] = background[3];
453 active_width[4] = background[4];
454 active_width[5] = background[5];
455 active_width[6] = background[6];
458 printed_node = temp_head;
460 font_in_short_display = 0;
462 cur_p = link(temp_head);
463 auto_breaking = true;
466 while ((cur_p != 0) && (link(active) != active))
468 if (is_char_node(cur_p))
475 act_width = act_width + char_width(f, char_info(f, character(cur_p)));
478 while (!(!is_char_node(cur_p)));
486 act_width = act_width + width(cur_p);
490 if (subtype(cur_p) == language_node)
492 cur_lang = what_lang(cur_p);
493 l_hyf = what_lhm(cur_p);
494 r_hyf = what_rhm(cur_p);
502 if (is_char_node(prev_p))
503 try_break(0, unhyphenated);
504 else if ((mem[prev_p].hh.b0 < 9))
505 try_break(0, unhyphenated);
506 else if ((type(prev_p) == kern_node) && (subtype(prev_p) != explicit))
507 try_break(0, unhyphenated);
510 check_shrinkage(glue_ptr(cur_p));
512 act_width = act_width+ width(q);
513 active_width[2 + stretch_order(q)] = active_width[2 + stretch_order(q)] + stretch(q);
514 active_width[6] = active_width[6] + shrink(q);
516 if (second_pass && auto_breaking)
530 else if (type(s) == ligature_node)
539 else if ((type(s) == kern_node) && (subtype(s) == normal))
541 else if (type(s) == whatsit_node)
543 if (subtype(s) == language_node)
545 cur_lang = what_lang(s);
555 if ((lc_code(c) == (halfword) c) || (uc_hyph > 0)) /* fixed signed tyoe */
564 hyf_char = hyphen_char[hf];
574 if (l_hyf + r_hyf > 63)
586 hyf_bchar = character(s);
588 c = hyf_bchar; /* unsigned char c; */
600 hyf_bchar = non_char;
602 else if (type(s) == ligature_node)
604 if (font(lig_char(s)) != hf)
610 if (q != 0) /* 94/Mar/23 BUG FIX */
611 hyf_bchar = character(q);
613 while (q != 0) /* 94/Mar/23 BUG FIX */
633 hyf_bchar = font_bchar[hf];
635 hyf_bchar = non_char;
637 else if ((type(s) == kern_node) && (subtype(s) == normal))
640 hyf_bchar = font_bchar[hf];
648 if (hn < l_hyf + r_hyf)
653 if (!(is_char_node(s)))
659 if (subtype(s) != normal)
684 if (subtype(cur_p) == explicit)
687 act_width = act_width + width(cur_p);
691 f = font(lig_char(cur_p));
692 act_width = act_width + char_width(f, char_info(f, character(lig_char(cur_p))));
697 s = pre_break(cur_p);
701 try_break(ex_hyphen_penalty, hyphenated);
709 disc_width = disc_width + char_width(f, char_info(f, character(s)));
711 else switch (type(s))
715 f = font(lig_char(s));
716 disc_width = disc_width + font_info[width_base[f] + font_info[char_base[f]+ mem[s + 1].hh.b1].qqqq.b0].cint;
723 disc_width = disc_width + width(s);
736 act_width = act_width + disc_width;
737 try_break(hyphen_penalty, hyphenated);
738 act_width = act_width - disc_width;
740 r = replace_count(cur_p);
748 act_width = act_width + char_width(f, char_info(f, character(s)));
750 else switch (type(s))
754 f = font(lig_char(s));
755 act_width = act_width + char_width(f, char_info(f, character(lig_char(s))));
763 act_width = act_width + width(s);
786 auto_breaking = (subtype(cur_p) == after);
792 try_break(penalty(cur_p), unhyphenated);
802 confusion("paragraph");
815 try_break(eject_penalty, hyphenated);
817 if (link(active) != active)
820 fewest_demerits = awful_bad;
825 if (total_demerits(r) < fewest_demerits)
827 fewest_demerits = total_demerits(r);
833 while (!(r == active));
835 best_line = line_number(best_bet);
839 goto done; /* normal exit */
844 actual_looseness = 0;
850 line_diff = toint(line_number(r)) - toint(best_line);
852 if (((line_diff < actual_looseness) && (looseness <= line_diff)) ||
853 ((line_diff > actual_looseness) && (looseness >= line_diff)))
856 actual_looseness = line_diff;
857 fewest_demerits = total_demerits(r);
859 else if ((line_diff == actual_looseness) && (total_demerits(r) < fewest_demerits))
862 fewest_demerits = total_demerits(r);
868 while (!(r == active));
870 best_line = line_number(best_bet);
873 if ((actual_looseness == looseness) || final_pass)
886 if (type(q) == delta_node)
887 free_node(q, delta_node_size);
889 free_node(q, active_node_size);
899 free_node(q, passive_node_size);
906 if (tracing_paragraphs > 0)
907 print_nl("@secondpass");
909 threshold = tolerance;
911 second_pass_count++; /* 96 Feb 9 */
912 final_pass = (emergency_stretch <= 0);
917 if (tracing_paragraphs > 0)
918 print_nl("@emergencypass");
921 background[2] = background[2] + emergency_stretch;
923 ++final_pass_count; /* 96 Feb 9 */
932 if (tracing_paragraphs > 0)
934 end_diagnostic(true);
935 normalize_selector();
939 post_line_break(final_widow_penalty);
946 if (type(q) == delta_node)
947 free_node(q, delta_node_size);
949 free_node(q, active_node_size);
959 free_node(q, passive_node_size);
966 void prefixed_command (void)
969 internal_font_number f;
978 while (cur_cmd == prefix)
980 if (!odd(a / cur_chr))
987 while (!((cur_cmd != spacer) && (cur_cmd != relax)));
989 if (cur_cmd <= max_non_prefixed_command)
991 print_err("You can't use a prefix with `");
992 print_cmd_chr(cur_cmd, cur_chr);
994 help1("I'll pretend you didn't say \\long or \\outer or \\global.");
1000 if ((cur_cmd != def) && (a % 4 != 0))
1002 print_err("You can't use `");
1007 print_cmd_chr(cur_cmd, cur_chr);
1009 help1("I'll pretend you didn't say \\long or \\outer here.");
1013 if (global_defs != 0)
1014 if (global_defs < 0)
1028 define(cur_font_loc, data, cur_chr);
1033 if (odd(cur_chr) && !(a >= 4) && (global_defs >= 0))
1039 q = scan_toks(true, e);
1040 define(p, call + (a % 4), def_ref);
1056 while (!(cur_cmd != spacer));
1058 if (cur_tok == other_token + '=')
1062 if (cur_cmd == spacer)
1076 if (cur_cmd >= call)
1077 add_token_ref(cur_chr);
1079 define(p, cur_cmd, cur_chr);
1088 define(p, relax, 256);
1089 scan_optional_equals();
1096 define(p, char_given, cur_val);
1100 case math_char_def_code:
1102 scan_fifteen_bit_int();
1103 define(p, math_given, cur_val);
1109 scan_eight_bit_int();
1113 case count_def_code:
1114 define(p, assign_int, count_base + cur_val);
1117 case dimen_def_code:
1118 define(p, assign_dimen, scaled_base + cur_val);
1122 define(p, assign_glue, skip_base + cur_val);
1125 case mu_skip_def_code:
1126 define(p, assign_mu_glue, mu_skip_base + cur_val);
1130 define(p, assign_toks, toks_base + cur_val);
1144 if (!scan_keyword("to"))
1146 print_err("Missing `to' inserted");
1147 help2("You should have said `\\read<number> to \\cs'.",
1148 "I'm going to look for the \\cs now.");
1155 define(p, call, cur_val);
1164 if (cur_cmd == toks_register)
1166 scan_eight_bit_int();
1167 p = toks_base + cur_val;
1172 scan_optional_equals();
1178 while (!((cur_cmd != spacer) && (cur_cmd != relax)));
1180 if (cur_cmd != left_brace)
1182 if (cur_cmd == toks_register)
1184 scan_eight_bit_int();
1185 cur_cmd = assign_toks;
1186 cur_chr = toks_base + cur_val;
1189 if (cur_cmd == assign_toks)
1194 define(p, undefined_cs, 0);
1206 q = scan_toks(false, false);
1208 if (link(def_ref) == 0)
1210 define(p, undefined_cs, 0);
1211 free_avail(def_ref);
1215 if (p == output_routine_loc)
1217 link(q) = get_avail();
1219 info(q) = right_brace_token + '}';
1221 info(q) = left_brace_token + '{';
1222 link(q) = link(def_ref);
1226 define(p, call, def_ref);
1234 scan_optional_equals();
1236 word_define(p, cur_val);
1243 scan_optional_equals();
1244 scan_dimen(false, false, false);
1245 word_define(p, cur_val);
1250 case assign_mu_glue:
1254 scan_optional_equals();
1256 if (n == assign_mu_glue)
1259 scan_glue(glue_val);
1262 define(p, glue_ref, cur_val);
1268 if (cur_chr == cat_code_base)
1270 else if (cur_chr == math_code_base)
1271 n = 32768L; /* 2^15 */
1272 else if (cur_chr == sf_code_base)
1273 n = 32767; /* 2^15 - 1*/
1274 else if (cur_chr == del_code_base)
1275 n = 16777215L; /* 2^24 - 1 */
1282 scan_optional_equals();
1285 if (((cur_val < 0) && (p < del_code_base)) ||(cur_val > n))
1287 print_err("Invalid code(");
1290 if (p < del_code_base)
1291 prints("), should be in the range 0..");
1293 prints("), should be at most ");
1296 help1("I'm going to use 0 instead of that illegal code value.");
1301 if (p < math_code_base)
1302 define(p, data, cur_val);
1303 else if (p < del_code_base)
1304 define(p, data, cur_val);
1306 word_define(p, cur_val);
1313 scan_four_bit_int();
1315 scan_optional_equals();
1317 define(p, data, cur_val);
1325 do_register_command(a);
1330 scan_eight_bit_int();
1337 scan_optional_equals();
1339 if (set_box_allowed)
1340 scan_box(box_flag + n);
1343 print_err("Improper ");
1344 print_esc("setbox");
1345 help2("Sorry, \\setbox is not allowed after \\halign in a display,",
1346 "or between \\accent and an accented character.");
1360 case set_page_dimen:
1361 alter_page_so_far();
1374 scan_optional_equals();
1382 p = get_node(2 * n + 1);
1385 for (j = 1; j <= n; j++)
1387 scan_dimen(false, false, false);
1388 mem[p + 2 * j - 1].cint = cur_val;
1389 scan_dimen(false, false, false);
1390 mem[p + 2 * j].cint = cur_val;
1394 define(par_shape_loc, shape_ref, p);
1408 print_err("Patterns can be loaded only by INITEX");
1416 while (!(cur_cmd == right_brace));
1422 new_hyph_exceptions();
1427 case assign_font_dimen:
1429 find_font_dimen(true);
1431 scan_optional_equals();
1432 scan_dimen(false, false, false);
1433 font_info[k].cint = cur_val;
1437 case assign_font_int:
1442 scan_optional_equals();
1446 hyphen_char[f] = cur_val;
1448 skew_char[f] = cur_val;
1456 case set_interaction:
1462 confusion("prefix");
1469 if (after_token != 0)
1471 cur_tok = after_token;
1477 boolean load_fmt_file (void)
1485 if (x != BEGINFMTCHECKSUM)
1488 undump_int(x); /* mem_bot */
1493 undump_int(x); /* mem_top */
1496 /* we already read this once earlier to grab mem_top */
1498 printf("Read from fmt file mem_top = %lld TeX words\n", x);
1500 mem = allocate_main_memory(x); /* allocate main memory at this point */
1503 exit(1); /* redundant sanity test ! */
1505 initialize_aux(); /* do `mem' part of initialize */
1511 undump_int(x); /* eqtb_size */
1516 undump_int(x); /* hash_prime */
1518 if (x != hash_prime)
1521 undump_int(x); /* hyphen_prime */
1523 #ifdef ALLOCATEHYPHEN
1524 /* allow format files dumped with arbitrary (prime) hyphenation exceptions */
1529 if (x != hyphen_prime)
1533 undump_int(x); /* pool_size */
1538 #ifdef ALLOCATESTRING
1539 if (x > current_pool_size)
1542 printf("undump string pool reallocation (%lld > %d)\n", x, current_pool_size);
1544 str_pool = realloc_str_pool (x - current_pool_size + increment_pool_size);
1547 if (x > current_pool_size)
1552 printf("%s%s\n", "---! Must increase the ", "string pool size");
1560 undump_int(x); /* max_strings */
1565 #ifdef ALLOCATESTRING
1566 if (x > current_max_strings)
1569 printf("undump string pointer reallocation (%lld > %d)\n", x, current_max_strings);
1571 str_start = realloc_str_start(x - current_max_strings + increment_max_strings);
1574 if (x > current_max_strings) /* 94/Jan/24 */
1576 if (x > max_strings)
1579 printf("%s%s\n", "---! Must increase the ", "max strings");
1586 if (undumpthings(str_start[0], str_ptr + 1)) /* undump string ptrs */
1589 if (undumpthings(str_pool[0], pool_ptr)) /* undump string pool */
1592 init_str_ptr = str_ptr;
1593 init_pool_ptr = pool_ptr;
1594 undump(lo_mem_stat_max + 1000, hi_mem_stat_min - 1, lo_mem_max);
1595 undump(lo_mem_stat_max + 1, lo_mem_max, rover);
1601 if (undumpthings(mem[p], q + 2 - p))
1604 p = q + node_size(q);
1606 if ((p > lo_mem_max) || ((q >= rlink(q)) && (rlink(q) != rover)))
1611 while (!(q == rover));
1613 if (undumpthings(mem[p], lo_mem_max + 1 - p))
1616 if (mem_min < mem_bot - 2) /* ? splice in block below */
1618 /* or call add_variable_space(mem_bot - (mem_min + 1)) */
1620 puts("Splicing in mem_min space in undump!");
1624 link(mem_min) = 0; /* null */
1625 info(mem_min) = 0; /* null */
1630 link(q) = empty_flag;
1631 node_size(q) = mem_bot - q;
1634 undump(lo_mem_max + 1, hi_mem_stat_min, hi_mem_min);
1635 undump(mem_bot, mem_top, avail);
1638 if (undumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min))
1641 undump_int(var_used);
1642 undump_int(dyn_used);
1650 if ((x < 1) || (k + x > (eqtb_size + 1)))
1653 if (undumpthings(eqtb[k], x))
1659 if ((x < 0) || (k + x > (eqtb_size + 1)))
1662 for (j = k; j <= k + x - 1; j++)
1663 eqtb[j] = eqtb[k - 1];
1667 while (!(k > eqtb_size));
1669 undump(hash_base, frozen_control_sequence, par_loc);
1670 par_token = cs_token_flag + par_loc;
1671 undump(hash_base, frozen_control_sequence, write_loc);
1672 undump(hash_base, frozen_control_sequence, hash_used);
1678 undump(p + 1, hash_used, p);
1681 while (!(p == hash_used));
1683 if (undumpthings(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used))
1686 undump_int(cs_count);
1689 printf("itex undump cs_count %lld ", cs_count);
1692 undump_int(x); /* font_mem_size */
1699 printf("Read from fmt fmem_ptr = %lld\n", x);
1701 if (x > current_font_mem_size)
1704 printf("Undump realloc font_info (%lld > %d)\n", x, current_font_mem_size);
1706 font_info = realloc_font_info (x - current_font_mem_size + increment_font_mem_size);
1709 if (x > current_font_mem_size)
1711 if (x > font_mem_size)
1714 puts("---! Must increase the font mem size");
1722 if (undumpthings(font_info[0], fmem_ptr))
1726 undump_int(x); /* font_max */
1733 puts("---! Must increase the font max");
1740 frozen_font_ptr = font_ptr;
1742 if (undumpthings(font_check[0], font_ptr + 1))
1745 if (undumpthings(font_size[0], font_ptr + 1))
1748 if (undumpthings(font_dsize[0], font_ptr + 1))
1751 if (undumpthings(font_params[0], font_ptr + 1))
1754 if (undumpthings(hyphen_char[0], font_ptr + 1))
1757 if (undumpthings(skew_char[0], font_ptr + 1))
1760 if (undumpthings(font_name[0], font_ptr + 1))
1763 if (undumpthings(font_area[0], font_ptr + 1))
1766 if (undumpthings(font_bc[0], font_ptr + 1))
1769 if (undumpthings(font_ec[0], font_ptr + 1))
1772 if (undumpthings(char_base[0], font_ptr + 1))
1775 if (undumpthings(width_base[0], font_ptr + 1))
1778 if (undumpthings(height_base[0], font_ptr + 1))
1781 if (undumpthings(depth_base[0], font_ptr + 1))
1784 if (undumpthings(italic_base[0], font_ptr + 1))
1787 if (undumpthings(lig_kern_base[0], font_ptr + 1))
1790 if (undumpthings(kern_base[0], font_ptr + 1))
1793 if (undumpthings(exten_base[0], font_ptr + 1))
1796 if (undumpthings(param_base[0], font_ptr + 1))
1799 if (undumpthings(font_glue[0], font_ptr + 1))
1802 if (undumpthings(bchar_label[0], font_ptr + 1))
1805 if (undumpthings(font_bchar[0], font_ptr + 1))
1808 if (undumpthings(font_false_bchar[0], font_ptr + 1))
1812 /* log not opened yet, so can't show fonts frozen into format */
1813 /* May be able to avoid the following since we switched to */
1814 /* non_address from font_mem_size to 0 96/Jan/15 ??? */
1818 int count = 0, oldfont_mem_size = 0;
1820 for (x = 0; x <= font_ptr; x++)
1822 if (bchar_label[x] > oldfont_mem_size)
1823 oldfont_mem_size = bchar_label[x];
1826 if (oldfont_mem_size != non_address && oldfont_mem_size > font_max)
1828 for (x = 0; x <= font_ptr; x++)
1830 if (bchar_label[x] == oldfont_mem_size)
1832 bchar_label[x] = non_address;
1838 printf("oldfont_mem_size is %d --- hit %d times. Using non_address %d\n",
1839 oldfont_mem_size, count, non_address);
1844 undump(0, hyphen_prime, hyph_count);
1846 for (k = 1; k <= hyph_count; k++)
1848 undump(0, hyphen_prime, j);
1849 undump(0, str_ptr, hyph_word[j]);
1850 undump(0, max_halfword, hyph_list[j]);
1853 #ifdef ALLOCATEHYPHEN
1854 /* if user specified new hyphen prime - flush existing exception patterns ! */
1855 /* but, we can reclaim the string storage wasted ... */
1858 if (new_hyphen_prime != 0)
1860 realloc_hyphen(new_hyphen_prime); /* reset_hyphen(); */
1861 hyphen_prime = new_hyphen_prime;
1872 #ifdef ALLOCATETRIES
1875 allocate_tries(x); /* allocate only as much as is needed */
1876 /* trie_size = x; */ /* ??? */
1882 puts("---! Must increase the trie size\n");
1894 if (undumpthings(trie_trl[0], j + 1))
1897 if (undumpthings(trie_tro[0], j + 1))
1900 if (undumpthings(trie_trc[0], j + 1))
1909 if (x > trie_op_size)
1911 puts("---! Must increase the trie op size\n");
1923 if (undumpthings(hyf_distance[1], j))
1926 if (undumpthings(hyf_num[1], j))
1929 if (undumpthings(hyf_next[1], j))
1935 for (k = 0; k <= 255; k++)
1936 trie_used[k] = min_quarterword;
1944 undump(0, k - 1, k);
1958 trie_not_ready = false;
1961 undump(batch_mode, error_stop_mode, interaction);
1962 undump(0, str_ptr, format_ident);
1965 if ((x != ENDFMTCHECKSUM) || feof(fmt_file))
1971 puts("(Fatal format file error; I'm stymied)\n");
1976 void final_cleanup (void)
1985 while (input_ptr > 0)
1995 while (open_parens > 0)
2001 if (cur_level > level_one)
2004 print_esc("end occurred ");
2005 prints("inside a group at level ");
2006 print_int(cur_level - 1);
2010 while (cond_ptr != 0)
2013 print_esc("end occurred ");
2015 print_cmd_chr('i', cur_if);
2023 prints(" was incomplete)");
2024 if_line = mem[cond_ptr + 1].cint;
2025 cur_if = subtype(cond_ptr);
2026 temp_ptr = cond_ptr;
2027 cond_ptr = link(cond_ptr);
2028 free_node(temp_ptr, if_node_size);
2031 if (history != spotless)
2032 if (((history == warning_issued) || (interaction < error_stop_mode)))
2033 if (selector == term_and_log)
2035 selector = term_only;
2036 print_nl("(see the transcript file for additional information)");
2037 selector = term_and_log;
2045 for (c = 0; c <= 4; c++)
2047 if (cur_mark[c] != 0)
2048 delete_token_ref(cur_mark[c]);
2051 if (last_glue != max_halfword)
2052 delete_glue_ref(last_glue);
2053 store_fmt_file(); // returns a value ?
2058 print_nl("(\\dump is performed only by INITEX)");
2062 void show_frozen (void)
2066 fprintf(log_file, "\n");
2067 fprintf(log_file, "(%lld fonts frozen in format file:\n", font_ptr);
2069 for (i = 1; i <= font_ptr; i++)
2072 fprintf(log_file, ", ");
2075 fprintf(log_file, "\n");
2077 n = str_start[font_name[i] + 1] - str_start[font_name[i]];
2079 for (j = 0; j < n; j++)
2081 putc(str_pool[str_start[font_name[i]] + j], log_file);
2085 fprintf(log_file, ") ");
2088 int main_program (void)
2090 history = fatal_error_stop;
2092 if (ready_already == 314159L)
2097 if ((half_error_line < 30) || (half_error_line > error_line - 15))
2100 if (max_print_line < 60)
2103 if (dvi_buf_size % 8 != 0)
2106 if (mem_bot + 1100 > mem_top)
2109 if (hash_prime > (hash_size + hash_extra))
2112 if (max_in_open >= 128)
2115 if (mem_top < 256 + 11)
2121 if ((mem_min != 0) || (mem_max != mem_top))
2126 if ((mem_min > mem_bot) || (mem_max < mem_top))
2129 if ((min_quarterword > 0) || (max_quarterword < 255))
2132 if ((min_halfword > 0) || (max_halfword < 32767))
2135 if ((min_quarterword < min_halfword) || (max_quarterword > max_halfword))
2138 if ((mem_min < min_halfword) || (mem_max >= max_halfword) || (mem_bot - mem_min >= max_halfword))
2141 if (mem_max > mem_top + mem_extra_high)
2144 if ((0 < min_quarterword) || (font_max > max_quarterword))
2147 #ifdef INCREASEFONTS
2148 if (font_max > 65535)
2154 if ((save_size > max_halfword) || (max_strings > max_halfword))
2157 if (buf_size > max_halfword)
2160 if (max_quarterword - min_quarterword < 255)
2163 if (cs_token_flag + undefined_control_sequence > max_halfword)
2166 if (format_default_length > file_name_size)
2169 if (max_halfword < (mem_top - mem_min) / 2)
2174 printf("%s%s%ld\n", "Ouch---my internal constants have been clobbered!",
2175 "---case ", (long) bad);
2185 if (!get_strings_started())
2189 init_str_ptr = str_ptr;
2190 init_pool_ptr = pool_ptr;
2191 fix_date_and_time();
2195 ready_already = 314159L;
2198 selector = term_only;
2202 show_line(tex_version, 0);
2206 printf(" (%s %s/Win64)", application, yandyversion);
2208 printf(" (%s %s/Win32)", application, yandyversion);
2211 printf(" (%s %s/Linux)", application, yandyversion);
2214 if (format_ident > 0)
2215 slow_print(format_ident);
2220 name_in_progress = false;
2222 output_file_name = 0;
2231 max_open_parens = 0;
2234 max_param_stack = 0;
2236 #ifdef ALLOCATEBUFFER
2237 memset (buffer, 0, current_buf_size);
2239 memset (buffer, 0, buf_size);
2252 align_state = 1000000L;
2254 if (!init_terminal())
2261 if ((format_ident == 0) || (buffer[loc] == '&') ||
2262 (buffer[loc] == '+'))
2264 if (format_ident != 0)
2267 if (!open_fmt_file ())
2270 if (!load_fmt_file ())
2272 #ifdef COMPACTFORMAT
2273 gzclose(gz_fmt_file);
2280 #ifdef COMPACTFORMAT
2281 gzclose(gz_fmt_file);
2286 while ((loc < limit) && (buffer[loc] == ' '))
2290 if (end_line_char_inactive())
2293 buffer[limit] = end_line_char;
2295 fix_date_and_time();
2296 magic_offset = str_start[886] - 9 * ord_noad;
2298 if (interaction == batch_mode)
2299 selector = no_print;
2301 selector = term_only;
2303 if ((loc < limit) && (cat_code(buffer[loc]) != escape))
2307 if (show_tfm_flag && log_opened && font_ptr > 0)
2310 main_time = clock();
2314 print_cs_names(stdout, 0);
2319 print_cs_names(stdout, 1);
2322 close_files_and_terminate();
2334 if ((history != 0) && (history != 1))
2344 /* add a block of variable size node space below mem_bot(0) */
2345 void add_variable_space(int size)
2356 mem_min = t - (size + 1); /* first word in new block - 1 */
2358 if (mem_min < mem_start)
2361 puts("WARNING: mem_min < mem_start!");
2363 mem_min = mem_start;
2368 link(mem_min) = 0; /* insert blank word below ??? */
2369 info(mem_min) = 0; /* insert blank word below ??? */
2374 link(q) = empty_flag;
2375 info(q) = t - q; /* block size */
2381 /* split out to allow sharing of code from do_initex and newpattern */
2382 void reset_trie (void)
2386 for (k = -(integer)trie_op_size; k <= trie_op_size; k++)
2387 trie_op_hash[k] = 0;
2389 for (k = 0; k <= 255; k++)
2390 trie_used[k] = min_trie_op;
2392 max_op_used = min_trie_op;
2394 trie_not_ready = true;
2398 trie_not_ready = true;
2400 /* borrowed code from initialize() */
2401 void reset_hyphen(void)
2405 for (z = 0; z <= hyphen_prime; z++)
2413 /* split out to allow optimize for space, not time */
2414 void do_initex (void)
2418 /* hyph_pointer z; */
2420 for (k = mem_bot + 1; k <= lo_mem_stat_max; k++)
2425 while (k <= lo_mem_stat_max)
2427 glue_ref_count(k) = 1;
2428 stretch_order(k) = normal;
2429 shrink_order(k) = normal;
2430 k = k + glue_spec_size;
2433 stretch(fil_glue) = unity;
2434 stretch_order(fil_glue) = fil;
2435 stretch(fill_glue) = unity;
2436 stretch_order(fill_glue) = fill;
2437 stretch(ss_glue) = unity;
2438 stretch_order(ss_glue) = fil;
2439 shrink(ss_glue) = unity;
2440 shrink_order(ss_glue) = fil;
2441 stretch(fil_neg_glue) = -unity;
2442 stretch_order(fil_neg_glue) = fil;
2443 rover = lo_mem_stat_max + 1;
2444 link(rover) = empty_flag;
2445 node_size(rover) = block_size;
2446 llink(rover) = rover;
2447 rlink(rover) = rover;
2448 lo_mem_max = rover + block_size;
2449 link(lo_mem_max) = 0;
2450 info(lo_mem_max) = 0;
2452 for (k = hi_mem_stat_min; k <= mem_top; k++)
2453 mem[k] = mem[lo_mem_max];
2455 info(omit_template) = end_template_token;
2456 link(end_span) = max_quarterword + 1;
2458 type(last_active) = hyphenated;
2459 line_number(last_active) = max_halfword;
2460 subtype(last_active) = 0;
2461 subtype(page_ins_head) = 255;
2462 type(page_ins_head) = split_up;
2463 link(mem_top) = page_ins_head;
2464 type(page_head) = glue_node;
2465 subtype(page_head) = normal;
2468 hi_mem_min = hi_mem_stat_min;
2469 var_used = lo_mem_stat_max + 1 - mem_bot;
2470 dyn_used = hi_mem_stat_usage;
2471 eq_type(undefined_control_sequence) = undefined_cs;
2472 equiv(undefined_control_sequence) = 0;
2473 eq_level(undefined_control_sequence) = level_zero;
2475 for (k = active_base; k <= undefined_control_sequence - 1; k++)
2476 eqtb[k] = eqtb[undefined_control_sequence];
2478 equiv(glue_base) = zero_glue;
2479 eq_level(glue_base) = level_one;
2480 eq_type(glue_base) = glue_ref;
2482 for (k = glue_base + 1; k <= local_base - 1; k++)
2483 eqtb[k] = eqtb[glue_base];
2485 glue_ref_count(zero_glue) = glue_ref_count(zero_glue) + local_base - glue_base;
2488 eq_type(par_shape_loc) = shape_ref;
2489 eq_level(par_shape_loc) = level_one;
2491 for (k = output_routine_loc; k <= toks_base + 255; k++)
2492 eqtb[k] = eqtb[undefined_control_sequence];
2495 eq_type(box_base) = box_ref;
2496 eq_level(box_base) = level_one;
2498 for (k = box_base + 1; k <= box_base + 255; k++)
2499 eqtb[k] = eqtb[box_base];
2501 cur_font = null_font;
2502 eq_type(cur_font_loc) = data;
2503 eq_level(cur_font_loc) = level_one;
2505 for (k = math_font_base; k <= math_font_base + 47; k++)
2506 eqtb[k] = eqtb[cur_font_loc];
2508 equiv(cat_code_base) = 0;
2509 eq_type(cat_code_base) = data;
2510 eq_level(cat_code_base) = level_one;
2512 for (k = cat_code_base; k <= int_base - 1; k++)
2513 eqtb[k] = eqtb[cat_code_base];
2515 for (k = 0; k <= 255; k++)
2517 cat_code(k) = other_char;
2522 cat_code(carriage_return) = car_ret;
2523 cat_code(' ') = spacer;
2524 cat_code('\\') = escape;
2525 cat_code('%') = comment;
2526 cat_code(invalid_code) = invalid_char;
2527 cat_code(null_code) = ignore;
2529 for (k = '0'; k <= '9'; k++)
2530 math_code(k) = k + var_code;
2532 for (k = 'A'; k <= 'Z'; k++)
2534 cat_code(k) = letter;
2535 cat_code(k + 'a' - 'A') = letter;
2536 math_code(k) = k + var_code + 0x100;
2537 math_code(k + 'a' - 'A') = k + 'a' - 'A' + var_code + 0x100;
2538 lc_code(k) = k + 'a' - 'A';
2539 lc_code(k + 'a' - 'A') = k + 'a' - 'A';
2541 uc_code(k + 'a' - 'A') = k;
2545 for (k = int_base; k <= del_code_base - 1; k++)
2551 max_dead_cycles = 25;
2553 end_line_char = carriage_return;
2555 for (k = 0; k <= 255; k++)
2560 for (k = dimen_base; k <= eqtb_size; k++)
2563 hash_used = frozen_control_sequence;
2567 puts("initex cs_count = 0 ");
2569 eq_type(frozen_dont_expand) = dont_expand;
2570 text(frozen_dont_expand) = 499; /* notexpanded */
2572 font_ptr = null_font;
2574 font_name[null_font] = 795; /* nullfont */
2575 font_area[null_font] = 335; /* "" */
2576 hyphen_char[null_font] = '-';
2577 skew_char[null_font] = -1;
2578 bchar_label[null_font] = non_address;
2579 font_bchar[null_font] = non_char;
2580 font_false_bchar[null_font] = non_char;
2581 font_bc[null_font] = 1;
2582 font_ec[null_font] = 0;
2583 font_size[null_font] = 0;
2584 font_dsize[null_font] = 0;
2585 char_base[null_font] = 0;
2586 width_base[null_font] = 0;
2587 height_base[null_font] = 0;
2588 depth_base[null_font] = 0;
2589 italic_base[null_font] = 0;
2590 lig_kern_base[null_font] = 0;
2591 kern_base[null_font] = 0;
2592 exten_base[null_font] = 0;
2593 font_glue[null_font] = 0;
2594 font_params[null_font] = 7;
2595 param_base[null_font] = -1;
2597 for (k = 0; k <= 6; k++)
2598 font_info[k].cint = 0;
2601 text(frozen_protection) = 1184; /* "inaccessible" */
2602 format_ident = 1251;
2603 text(end_write) = 1290;
2604 eq_level(end_write) = level_one;
2605 eq_type(end_write) = outer_call;
2606 equiv(end_write) = 0;
2612 boolean get_strings_started (void)
2621 for (k = 0; k <= 255; k++)
2623 if ( (k < ' ') || (k > '~') )
2629 append_char(k + 64);
2631 append_char(k - 64);
2634 append_lc_hex(k / 16);
2635 append_lc_hex(k % 16);
2644 g = load_pool_strings(pool_size - string_vacancies);
2648 fprintf(stdout, "%s\n", "! You have to increase POOLSIZE." );
2658 void sort_avail (void)
2663 p = get_node(1073741824L); /* 2^30 merge adjacent free nodes */
2665 rlink(rover) = empty_flag;
2668 while (p != old_rover)
2681 while (rlink(q) < p)
2685 rlink(p) = rlink(q);
2693 while (rlink(p) != empty_flag)
2695 llink(rlink(p)) = p;
2706 void primitive_ (str_number s, quarterword c, halfword o)
2710 /* small_number l; */
2714 cur_val = s + single_base;
2718 l = str_start[s + 1] - k; /* small_number l */
2720 for (j = 0; j <= l - 1; j++)
2721 buffer[j] = str_pool[k + j];
2723 cur_val = id_lookup(0, l);
2728 eq_level(cur_val) = level_one;
2729 eq_type(cur_val) = c;
2736 trie_op_code new_trie_op_ (small_number d, small_number n, trie_op_code v)
2742 h = abs(n + 313 * d + 361 * v + 1009 * cur_lang) % (trie_op_size + trie_op_size) + neg_trie_op_size;
2746 l = trie_op_hash[h];
2750 if (trie_op_ptr == trie_op_size)
2752 overflow("pattern memory ops", trie_op_size);
2756 u = trie_used[cur_lang];
2758 if (u == max_trie_op)
2760 overflow("pattern memory ops per language", max_trie_op - min_trie_op);
2766 trie_used[cur_lang] = u;
2768 if (u > max_op_used)
2771 hyf_distance[trie_op_ptr] = d;
2772 hyf_num[trie_op_ptr] = n;
2773 hyf_next[trie_op_ptr] = v;
2774 trie_op_lang[trie_op_ptr] = cur_lang;
2775 trie_op_hash[h] = trie_op_ptr;
2776 trie_op_val[trie_op_ptr] = u;
2780 if ((hyf_distance[l]== d) && (hyf_num[l]== n) && (hyf_next[l]== v) && (trie_op_lang[l]== cur_lang))
2782 return trie_op_val[l];
2785 if (h > - (integer) trie_op_size)
2792 trie_pointer trie_node_ (trie_pointer p)
2797 /* the 1009, 2718, 3142 are hard-wired constants here (not hyphen_prime) */
2798 /* compute hash value */
2799 h = abs(trie_c[p] + 1009 * trie_o[p] + 2718 * trie_l[p] + 3142 * trie_r[p]) % trie_size;
2811 if ((trie_c[q] == trie_c[p]) && (trie_o[q] == trie_o[p]) &&
2812 (trie_l[q] == trie_l[p]) && (trie_r[q] == trie_r[p]))
2824 trie_pointer compress_trie_ (trie_pointer p)
2830 trie_l[p] = compress_trie(trie_l[p]);
2831 trie_r[p] = compress_trie(trie_r[p]);
2832 return trie_node(p);
2836 void first_fit_ (trie_pointer p)
2852 if (trie_max < h + 256)
2854 if (trie_size <= h + 256)
2856 overflow("pattern memory", trie_size);
2857 /* not dynamic ---- but can be set -h=... from command line in ini-TeX */
2864 trie_taken[trie_max] = false;
2865 trie_trl[trie_max] = trie_max + 1;
2866 trie_tro[trie_max] = trie_max - 1;
2868 while (!(trie_max == h + 256));
2878 if (trie_trl[h + trie_c[q]] == 0)
2889 trie_taken[h] = true; /* h may be used without ... */
2905 ll = z; /* short ll */
2922 void trie_pack_ (trie_pointer p)
2930 if ((q > 0) && (trie_hash[q]== 0))
2941 void trie_fix_ (trie_pointer p)
2953 trie_trl[z + c] = trie_hash[q];
2954 trie_trc[z + c] = c;
2955 trie_tro[z + c] = trie_o[p];
2965 void new_patterns (void)
2967 /* ******************************************************************* */
2968 /* was small_number k, l; in 3.141 */
2970 /* ******************************************************************* */
2971 boolean digitsensed;
2976 int c; /* 95/Jan/7 */
2978 if (!trie_not_ready) /* new stuff */
2983 puts("Resetting patterns\n");
2985 reset_trie(); /* RESET PATTERNS - 93/Nov/26 */
2987 if (reset_exceptions)
2990 puts("Resetting exceptions\n");
2992 reset_hyphen(); /* RESET HYPHENEXCEPTIONS - 93/Nov/26 */
2996 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3003 digitsensed = false;
3013 if (digitsensed || (cur_chr < '0') || (cur_chr > '9'))
3019 cur_chr = lc_code(cur_chr);
3023 print_err("Nonletter");
3024 help1("(See Appendix H.)");
3034 digitsensed = false;
3039 hyf[k] = cur_chr - '0';
3059 v = new_trie_op(k - l, hyf[l], v);
3076 while ((p > 0) && (c > trie_c[p])) {
3082 if ((p == 0) || (c < trie_c[p]))
3084 if (trie_ptr == trie_size)
3086 overflow("pattern memory", trie_size); /* pattern memory - NOT DYNAMIC */
3087 /* not dynamic ---- but can be set -h=... from command line in ini-TeX */
3092 trie_r[trie_ptr] = p;
3102 trie_o[p] = min_trie_op;
3107 if (trie_o[q]!= min_trie_op)
3109 print_err("Duplicate pattern");
3110 help1("(See Appendix H.)");
3117 if (cur_cmd == right_brace)
3122 digitsensed = false;
3128 print_esc("patterns");
3129 help1("(See Appendix H.)");
3139 print_err("Too late for ");
3140 print_esc("patterns");
3141 help1("All patterns must be given before typesetting begins.");
3143 link(garbage) = scan_toks(false, false);
3144 flush_list(def_ref);
3148 void init_trie (void)
3151 /* integer j, k, t; */
3153 int t; /* 95/Jan/7 */
3156 op_start[0] = - (integer) min_trie_op;
3158 for (j = 1; j <= 255; j++)
3160 op_start[j] = op_start[j - 1] + trie_used[j - 1];
3163 for (j = 1; j <= trie_op_ptr; j++)
3165 trie_op_hash[j] = op_start[trie_op_lang[j]] + trie_op_val[j];
3168 for (j = 1; j <= trie_op_ptr; j++)
3170 while (trie_op_hash[j] > j)
3172 k = trie_op_hash[j];
3173 t = hyf_distance[k];
3174 hyf_distance[k] = hyf_distance[j];
3175 hyf_distance[j] = t;
3177 hyf_num[k] = hyf_num[j];
3180 hyf_next[k] = hyf_next[j];
3182 trie_op_hash[j] = trie_op_hash[k];
3183 trie_op_hash[k] = k;
3187 for (p = 0; p <= trie_size; p++)
3192 trie_l[0] = compress_trie(trie_l[0]);
3194 for (p = 0; p <= trie_ptr; p++)
3199 for (p = 0; p <= 255; p++)
3201 trie_min[p] = p + 1;
3209 first_fit(trie_l[0]);
3210 trie_pack(trie_l[0]);
3215 for (r = 0; r <= 256; r++)
3218 trie_tro[r] = min_trie_op;
3225 trie_fix(trie_l[0]);
3233 trie_tro[r] = min_trie_op;
3239 while (!(r > trie_max));
3243 trie_not_ready = false;
3249 void store_fmt_file (void)
3257 puts("! \\dump is performed only by INITEX\n");
3260 puts(" (Use -i on the command line)\n");
3267 print_err("You can't dump inside a group");
3268 help1("`{...\\dump}' is a no-no.");
3272 selector = new_string;
3273 prints(" (format=");
3283 if (interaction == 0)
3284 selector = log_only;
3286 selector = term_and_log;
3289 format_ident = make_string();
3290 pack_job_name(".fmt");
3292 while (!w_open_out(fmt_file))
3294 prompt_file_name("format file name", ".fmt");
3297 print_nl("Beginning to dump on file ");
3298 slow_print(w_make_name_string(fmt_file));
3301 slow_print(format_ident);
3303 dump_int(BEGINFMTCHECKSUM);
3306 dump_int(eqtb_size);
3307 dump_int(hash_prime);
3308 dump_int(hyphen_prime);
3312 if (dumpthings(str_start[0], str_ptr + 1))
3315 if (dumpthings(str_pool[0], pool_ptr))
3320 prints(" strings of total length ");
3321 print_int(pool_ptr);
3325 dump_int(lo_mem_max);
3333 if (dumpthings(mem[p], q + 2 - p))
3337 var_used = var_used + q - p;
3338 p = q + node_size(q);
3341 while (!(q == rover));
3343 var_used = var_used + lo_mem_max - p;
3344 dyn_used = mem_end + 1 - hi_mem_min;
3346 if (dumpthings(mem[p], lo_mem_max + 1 - p))
3349 x = x + lo_mem_max + 1 - p;
3350 dump_int(hi_mem_min);
3353 if (dumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min))
3356 x = x + mem_end + 1 - hi_mem_min;
3369 prints(" memory locations dumped; current usage is ");
3370 print_int(var_used);
3372 print_int(dyn_used);
3380 while (j < (int_base - 1))
3382 if ((equiv(j) == equiv(j + 1)) &&
3383 (eq_type(j) == eq_type(j + 1)) &&
3384 (eq_level(j) == eq_level(j + 1)))
3394 while (j < (int_base - 1))
3396 if ((equiv(j) != equiv(j + 1)) ||
3397 (eq_type(j) != eq_type(j + 1)) ||
3398 (eq_level(j) != eq_level(j + 1)))
3405 if (dumpthings(eqtb[k], l - k))
3411 while (!(k == (int_base)));
3417 while (j < (eqtb_size))
3419 if (eqtb[j].cint == eqtb[j + 1].cint)
3424 l = (eqtb_size + 1);
3430 while (j < (eqtb_size))
3432 if (eqtb[j].cint != eqtb[j + 1].cint)
3439 if (dumpthings(eqtb[k], l - k))
3445 while (!(k > (eqtb_size)));
3448 dump_int(write_loc);
3450 dump_int(hash_used);
3451 cs_count = frozen_control_sequence - 1 - hash_used;
3454 printf("itex cs_count %lld hash_size %d hash_extra %d hash_used %d",
3455 cs_count, hash_size, hash_extra, hash_used);
3457 for (p = hash_base; p <= hash_used; p++)
3466 puts("itex cs_count++ ");
3470 if (dumpthings(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used))
3475 print_int(cs_count);
3476 prints(" multiletter control sequences");
3481 if (dumpthings(font_info[0], fmem_ptr))
3486 if (dumpthings(font_check[0], font_ptr + 1))
3489 if (dumpthings(font_size[0], font_ptr + 1))
3492 if (dumpthings(font_dsize[0], font_ptr + 1))
3495 if (dumpthings(font_params[0], font_ptr + 1))
3498 if (dumpthings(hyphen_char[0], font_ptr + 1))
3501 if (dumpthings(skew_char[0], font_ptr + 1))
3504 if (dumpthings(font_name[0], font_ptr + 1))
3507 if (dumpthings(font_area[0], font_ptr + 1))
3510 if (dumpthings(font_bc[0], font_ptr + 1))
3513 if (dumpthings(font_ec[0], font_ptr + 1))
3516 if (dumpthings(char_base[0], font_ptr + 1))
3519 if (dumpthings(width_base[0], font_ptr + 1))
3522 if (dumpthings(height_base[0], font_ptr + 1))
3525 if (dumpthings(depth_base[0], font_ptr + 1))
3528 if (dumpthings(italic_base[0], font_ptr + 1))
3531 if (dumpthings(lig_kern_base[0], font_ptr + 1))
3534 if (dumpthings(kern_base[0], font_ptr + 1))
3537 if (dumpthings(exten_base[0], font_ptr + 1))
3540 if (dumpthings(param_base[0], font_ptr + 1))
3543 if (dumpthings(font_glue[0], font_ptr + 1))
3546 if (dumpthings(bchar_label[0], font_ptr + 1))
3549 if (dumpthings(font_bchar[0], font_ptr + 1))
3552 if (dumpthings(font_false_bchar[0], font_ptr + 1))
3555 for (k = 0; k <= font_ptr; k++)
3559 print(font_id_text(k));
3561 print_file_name(font_name[k], font_area[k], 335);
3563 if (font_size[k] != font_dsize[k])
3566 print_scaled(font_size[k]);
3573 print_int(fmem_ptr - 7);
3574 prints(" words of font info for ");
3575 print_int(font_ptr - 0);
3576 prints(" preloaded font");
3581 dump_int(hyph_count);
3583 for (k = 0; k <= hyphen_prime; k++)
3585 if (hyph_word[k]!= 0)
3588 dump_int(hyph_word[k]);
3589 dump_int(hyph_list[k]);
3594 print_int(hyph_count);
3595 prints(" hyphenation exception");
3597 if (hyph_count != 1)
3605 if (dumpthings(trie_trl[0], trie_max + 1))
3608 if (dumpthings(trie_tro[0], trie_max + 1))
3611 if (dumpthings(trie_trc[0], trie_max + 1))
3614 dump_int(trie_op_ptr);
3616 if (dumpthings(hyf_distance[1], trie_op_ptr))
3619 if (dumpthings(hyf_num[1], trie_op_ptr))
3622 if (dumpthings(hyf_next[1], trie_op_ptr))
3625 print_nl("Hyphenation trie of length ");
3626 print_int(trie_max);
3628 print_int(trie_op_ptr);
3631 if (trie_op_ptr != 1)
3635 print_int(trie_op_size);
3637 for (k = 255; k >= 0; k--)
3639 if (trie_used[k] > 0)
3642 print_int(trie_used[k]);
3643 prints(" for language ");
3646 dump_int(trie_used[k]);
3650 dump_int(interaction);
3651 dump_int(format_ident);
3652 dump_int(ENDFMTCHECKSUM);
3655 #ifdef COMPACTFORMAT
3656 gzclose(gz_fmt_file);
3665 void init_prim (void)
3667 no_new_control_sequence = false;
3669 primitive("lineskip", assign_glue, glue_base + line_skip_code);
3670 primitive("baselineskip", assign_glue, glue_base + baseline_skip_code);
3671 primitive("parskip", assign_glue, glue_base + par_skip_code);
3672 primitive("abovedisplayskip", assign_glue, glue_base + above_display_skip_code);
3673 primitive("belowdisplayskip", assign_glue, glue_base + below_display_skip_code);
3674 primitive("abovedisplayshortskip", assign_glue, glue_base + above_display_short_skip_code);
3675 primitive("belowdisplayshortskip", assign_glue, glue_base + below_display_short_skip_code);
3676 primitive("leftskip", assign_glue, glue_base + left_skip_code);
3677 primitive("rightskip", assign_glue, glue_base + right_skip_code);
3678 primitive("topskip", assign_glue, glue_base + top_skip_code);
3679 primitive("splittopskip", assign_glue, glue_base + split_top_skip_code);
3680 primitive("tabskip", assign_glue, glue_base + tab_skip_code);
3681 primitive("spaceskip", assign_glue, glue_base + space_skip_code);
3682 primitive("xspaceskip", assign_glue, glue_base + xspace_skip_code);
3683 primitive("parfillskip", assign_glue, glue_base + par_fill_skip_code);
3684 primitive("thinmuskip", assign_mu_glue, glue_base + thin_mu_skip_code);
3685 primitive("medmuskip", assign_mu_glue, glue_base + med_mu_skip_code);
3686 primitive("thickmuskip", assign_mu_glue, glue_base + thick_mu_skip_code);
3688 primitive("output", assign_toks, output_routine_loc);
3689 primitive("everypar", assign_toks, every_par_loc);
3690 primitive("everymath", assign_toks, every_math_loc);
3691 primitive("everydisplay", assign_toks, every_display_loc);
3692 primitive("everyhbox", assign_toks, every_hbox_loc);
3693 primitive("everyvbox", assign_toks, every_vbox_loc);
3694 primitive("everyjob", assign_toks, every_job_loc);
3695 primitive("everycr", assign_toks, every_cr_loc);
3696 primitive("errhelp", assign_toks, err_help_loc);
3698 primitive("pretolerance", assign_int, int_base + pretolerance_code);
3699 primitive("tolerance", assign_int, int_base + tolerance_code);
3700 primitive("linepenalty", assign_int, int_base + line_penalty_code);
3701 primitive("hyphenpenalty", assign_int, int_base + hyphen_penalty_code);
3702 primitive("exhyphenpenalty", assign_int, int_base + ex_hyphen_penalty_code);
3703 primitive("clubpenalty", assign_int, int_base + club_penalty_code);
3704 primitive("widowpenalty", assign_int, int_base + widow_penalty_code);
3705 primitive("displaywidowpenalty", assign_int, int_base + display_widow_penalty_code);
3706 primitive("brokenpenalty", assign_int, int_base + broken_penalty_code);
3707 primitive("binoppenalty", assign_int, int_base + bin_op_penalty_code);
3708 primitive("relpenalty", assign_int, int_base + rel_penalty_code);
3709 primitive("predisplaypenalty", assign_int, int_base + pre_display_penalty_code);
3710 primitive("postdisplaypenalty", assign_int, int_base + post_display_penalty_code);
3711 primitive("interlinepenalty", assign_int, int_base + inter_line_penalty_code);
3712 primitive("doublehyphendemerits", assign_int, int_base + double_hyphen_demerits_code);
3713 primitive("finalhyphendemerits", assign_int, int_base + final_hyphen_demerits_code);
3714 primitive("adjdemerits", assign_int, int_base + adj_demerits_code);
3715 primitive("mag", assign_int, int_base + mag_code);
3716 primitive("delimiterfactor", assign_int, int_base + delimiter_factor_code);
3717 primitive("looseness", assign_int, int_base + looseness_code);
3718 primitive("time", assign_int, int_base + time_code);
3719 primitive("day", assign_int, int_base + day_code);
3720 primitive("month", assign_int, int_base + month_code);
3721 primitive("year", assign_int, int_base + year_code);
3722 primitive("showboxbreadth", assign_int, int_base + show_box_breadth_code);
3723 primitive("showboxdepth", assign_int, int_base + show_box_depth_code);
3724 primitive("hbadness", assign_int, int_base + hbadness_code);
3725 primitive("vbadness", assign_int, int_base + vbadness_code);
3726 primitive("pausing", assign_int, int_base + pausing_code);
3727 primitive("tracingonline", assign_int, int_base + tracing_online_code);
3728 primitive("tracingmacros", assign_int, int_base + tracing_macros_code);
3729 primitive("tracingstats", assign_int, int_base + tracing_stats_code);
3730 primitive("tracingparagraphs", assign_int, int_base + tracing_paragraphs_code);
3731 primitive("tracingpages", assign_int, int_base + tracing_pages_code);
3732 primitive("tracingoutput", assign_int, int_base + tracing_output_code);
3733 primitive("tracinglostchars", assign_int, int_base + tracing_lost_chars_code);
3734 primitive("tracingcommands", assign_int, int_base + tracing_commands_code);
3735 primitive("tracingrestores", assign_int, int_base + tracing_restores_code);
3736 primitive("uchyph", assign_int, int_base + uc_hyph_code);
3737 primitive("outputpenalty", assign_int, int_base + output_penalty_code);
3738 primitive("maxdeadcycles", assign_int, int_base + max_dead_cycles_code);
3739 primitive("hangafter", assign_int, int_base + hang_after_code);
3740 primitive("floatingpenalty", assign_int, int_base + floating_penalty_code);
3741 primitive("globaldefs", assign_int, int_base + global_defs_code);
3742 primitive("fam", assign_int, int_base + cur_fam_code);
3743 primitive("escapechar", assign_int, int_base + escape_char_code);
3744 primitive("defaulthyphenchar", assign_int, int_base + default_hyphen_char_code);
3745 primitive("defaultskewchar", assign_int, int_base + default_skew_char_code);
3746 primitive("endlinechar", assign_int, int_base + end_line_char_code);
3747 primitive("newlinechar", assign_int, int_base + new_line_char_code);
3748 primitive("language", assign_int, int_base + language_code);
3749 primitive("lefthyphenmin", assign_int, int_base + left_hyphen_min_code);
3750 primitive("righthyphenmin", assign_int, int_base + right_hyphen_min_code);
3751 primitive("holdinginserts", assign_int, int_base + holding_inserts_code);
3752 primitive("errorcontextlines", assign_int, int_base + error_context_lines_code);
3754 primitive("parindent", assign_dimen, dimen_base + par_indent_code);
3755 primitive("mathsurround", assign_dimen, dimen_base + math_surround_code);
3756 primitive("lineskiplimit", assign_dimen, dimen_base + line_skip_limit_code);
3757 primitive("hsize", assign_dimen, dimen_base + hsize_code);
3758 primitive("vsize", assign_dimen, dimen_base + vsize_code);
3759 primitive("maxdepth", assign_dimen, dimen_base + max_depth_code);
3760 primitive("splitmaxdepth", assign_dimen, dimen_base + split_max_depth_code);
3761 primitive("boxmaxdepth", assign_dimen, dimen_base + box_max_depth_code);
3762 primitive("hfuzz", assign_dimen, dimen_base + hfuzz_code);
3763 primitive("vfuzz", assign_dimen, dimen_base + vfuzz_code);
3764 primitive("delimitershortfall", assign_dimen, dimen_base + delimiter_shortfall_code);
3765 primitive("nulldelimiterspace", assign_dimen, dimen_base + null_delimiter_space_code);
3766 primitive("scriptspace", assign_dimen, dimen_base + script_space_code);
3767 primitive("predisplaysize", assign_dimen, dimen_base + pre_display_size_code);
3768 primitive("displaywidth", assign_dimen, dimen_base + display_width_code);
3769 primitive("displayindent", assign_dimen, dimen_base + display_indent_code);
3770 primitive("overfullrule", assign_dimen, dimen_base + overfull_rule_code);
3771 primitive("hangindent", assign_dimen, dimen_base + hang_indent_code);
3772 primitive("hoffset", assign_dimen, dimen_base + h_offset_code);
3773 primitive("voffset", assign_dimen, dimen_base + v_offset_code);
3774 primitive("emergencystretch", assign_dimen, dimen_base + emergency_stretch_code);
3775 primitive(" ", ex_space, 0);
3776 primitive("/", ital_corr, 0);
3777 primitive("accent", accent, 0);
3778 primitive("advance", advance, 0);
3779 primitive("afterassignment", after_assignment, 0);
3780 primitive("aftergroup", after_group, 0);
3781 primitive("begingroup", begin_group, 0);
3782 primitive("char", char_num, 0);
3783 primitive("csname", cs_name, 0);
3784 primitive("delimiter", delim_num, 0);
3785 primitive("divide", divide, 0);
3786 primitive("endcsname", end_cs_name, 0);
3787 primitive("endgroup", end_group, 0);
3788 text(frozen_end_group) = make_string_pool("endgroup");
3789 eqtb[frozen_end_group] = eqtb[cur_val];
3790 primitive("expandafter", expand_after, 0);
3791 primitive("font", def_font, 0);
3792 primitive("fontdimen", assign_font_dimen, 0);
3793 primitive("halign", halign, 0);
3794 primitive("hrule", hrule, 0);
3795 primitive("ignorespaces", ignore_spaces, 0);
3796 primitive("insert", insert, 0);
3797 primitive("mark", mark, 0);
3798 primitive("mathaccent", math_accent, 0);
3799 primitive("mathchar", math_char_num, 0);
3800 primitive("mathchoice", math_choice, 0);
3801 primitive("multiply", multiply, 0);
3802 primitive("noalign", no_align, 0);
3803 primitive("noboundary", no_boundary, 0);
3804 primitive("noexpand", no_expand, 0);
3805 primitive("nonscript", non_script, 0);
3806 primitive("omit", omit, 0);
3807 primitive("parshape", set_shape, 0);
3808 primitive("penalty", break_penalty, 0);
3809 primitive("prevgraf", set_prev_graf, 0);
3810 primitive("radical", radical, 0);
3811 primitive("read", read_to_cs, 0);
3812 primitive("relax", relax, 256);
3813 text(frozen_relax) = make_string_pool("relax");
3814 eqtb[frozen_relax] = eqtb[cur_val];
3815 primitive("setbox", set_box, 0);
3816 primitive("the", the, 0);
3817 primitive("toks", toks_register, 0);
3818 primitive("vadjust", vadjust, 0);
3819 primitive("valign", valign, 0);
3820 primitive("vcenter", vcenter, 0);
3821 primitive("vrule", vrule, 0);
3822 primitive("par", par_end, 256);
3824 par_token = cs_token_flag + par_loc;
3825 primitive("input", input, 0);
3826 primitive("endinput", input, 1);
3827 primitive("topmark", top_bot_mark, 0);
3828 primitive("firstmark", top_bot_mark, 1);
3829 primitive("botmark", top_bot_mark, 2);
3830 primitive("splitfirstmark", top_bot_mark, 3);
3831 primitive("splitbotmark", top_bot_mark, 4);
3832 primitive("count", tex_register, 0);
3833 primitive("dimen", tex_register, 1);
3834 primitive("skip", tex_register, 2);
3835 primitive("muskip", tex_register, 3);
3836 primitive("spacefactor", set_aux, 102);
3837 primitive("prevdepth", set_aux, 1);
3838 primitive("deadcycles", set_page_int, 0);
3839 primitive("insertpenalties", set_page_int, 1);
3840 primitive("wd", set_box_dimen, 1);
3841 primitive("ht", set_box_dimen, 3);
3842 primitive("dp", set_box_dimen, 2);
3843 primitive("lastpenalty", last_item, 0);
3844 primitive("lastkern", last_item, 1);
3845 primitive("lastskip", last_item, 2);
3846 primitive("inputlineno", last_item, 3);
3847 primitive("badness", last_item, 4);
3848 primitive("number", convert, 0);
3849 primitive("romannumeral", convert, 1);
3850 primitive("string", convert, 2);
3851 primitive("meaning", convert, 3);
3852 primitive("fontname", convert, 4);
3853 primitive("jobname", convert, 5);
3854 primitive("if", if_test, 0);
3855 primitive("ifcat", if_test, 1);
3856 primitive("ifnum", if_test, 2);
3857 primitive("ifdim", if_test, 3);
3858 primitive("ifodd", if_test, 4);
3859 primitive("ifvmode", if_test, 5);
3860 primitive("ifhmode", if_test, 6);
3861 primitive("ifmmode", if_test, 7);
3862 primitive("ifinner", if_test, 8);
3863 primitive("ifvoid", if_test, 9);
3864 primitive("ifhbox", if_test, 10);
3865 primitive("ifvbox", if_test, 11);
3866 primitive("ifx", if_test, 12);
3867 primitive("ifeof", if_test, 13);
3868 primitive("iftrue", if_test, 14);
3869 primitive("iffalse", if_test, 15);
3870 primitive("ifcase", if_test, 16);
3871 primitive("fi", fi_or_else, 2);
3872 text(frozen_fi) = make_string_pool("fi");
3873 eqtb[frozen_fi] = eqtb[cur_val];
3874 primitive("or", fi_or_else, 4);
3875 primitive("else", fi_or_else, 3);
3876 primitive("nullfont", set_font, 0);
3877 text(frozen_null_font) = 795;
3878 eqtb[frozen_null_font] = eqtb[cur_val];
3879 primitive("span", tab_mark, 256);
3880 primitive("cr", car_ret, 257);
3881 text(frozen_cr) = make_string_pool("cr");
3882 eqtb[frozen_cr] = eqtb[cur_val];
3883 primitive("crcr", car_ret, 258);
3884 text(frozen_end_template) = make_string_pool("endtemplate");
3885 text(frozen_endv) = make_string_pool("endtemplate");
3886 eq_type(frozen_endv) = endv;
3887 equiv(frozen_endv) = null_list;
3888 eq_level(frozen_endv) = level_one;
3889 eqtb[frozen_end_template] = eqtb[frozen_endv];
3890 eq_type(frozen_end_template) = end_template;
3891 primitive("pagegoal", set_page_dimen, 0);
3892 primitive("pagetotal", set_page_dimen, 1);
3893 primitive("pagestretch", set_page_dimen, 2);
3894 primitive("pagefilstretch", set_page_dimen, 3);
3895 primitive("pagefillstretch", set_page_dimen, 4);
3896 primitive("pagefilllstretch", set_page_dimen, 5);
3897 primitive("pageshrink", set_page_dimen, 6);
3898 primitive("pagedepth", set_page_dimen, 7);
3899 primitive("end", end_match, 0);
3900 primitive("dump", stop, 1);
3901 primitive("hskip", hskip, 4);
3902 primitive("hfil", hskip, 0);
3903 primitive("hfill", hskip, 1);
3904 primitive("hss", hskip, 2);
3905 primitive("hfilneg", hskip, 3);
3906 primitive("vskip", vskip, 4);
3907 primitive("vfil", vskip, 0);
3908 primitive("vfill", vskip, 1);
3909 primitive("vss", vskip, 2);
3910 primitive("vfilneg", vskip, 3);
3911 primitive("mskip", mskip, 5);
3912 primitive("kern", kern, 1);
3913 primitive("mkern", mkern, 99);
3914 primitive("moveleft", hmove, 1);
3915 primitive("moveright", hmove, 0);
3916 primitive("raise", vmove, 1);
3917 primitive("lower", vmove, 0);
3918 primitive("box", make_box, 0);
3919 primitive("copy", make_box, 1);
3920 primitive("lastbox", make_box, 2);
3921 primitive("vsplit", make_box, 3);
3922 primitive("vtop", make_box, 4);
3923 primitive("vbox", make_box, 5);
3924 primitive("hbox", make_box, 106);
3925 primitive("shipout", leader_ship, 99);
3926 primitive("leaders", leader_ship, 100);
3927 primitive("cleaders", leader_ship, 101);
3928 primitive("xleaders", leader_ship, 102);
3929 primitive("indent", start_par, 1);
3930 primitive("noindent", start_par, 0);
3931 primitive("unpenalty", remove_item, 12);
3932 primitive("unkern", remove_item, 11);
3933 primitive("unskip", remove_item, 10);
3934 primitive("unhbox", un_hbox, 0);
3935 primitive("unhcopy", un_hbox, 1);
3936 primitive("unvbox", un_vbox, 0);
3937 primitive("unvcopy", un_vbox, 1);
3938 primitive("-", discretionary, 1);
3939 primitive("discretionary", discretionary, 0);
3940 primitive("eqno", eq_no, 0);
3941 primitive("leqno", eq_no, 1);
3942 primitive("mathord", math_comp, 16);
3943 primitive("mathop", math_comp, 17);
3944 primitive("mathbin", math_comp, 18);
3945 primitive("mathrel", math_comp, 19);
3946 primitive("mathopen", math_comp, 20);
3947 primitive("mathclose", math_comp, 21);
3948 primitive("mathpunct", math_comp, 22);
3949 primitive("mathinner", math_comp, 23);
3950 primitive("underline", math_comp, 26);
3951 primitive("overline", math_comp, 27);
3952 primitive("displaylimits", limit_switch, 0);
3953 primitive("limits", limit_switch, 1);
3954 primitive("nolimits", limit_switch, 2);
3955 primitive("displaystyle", math_style, 0);
3956 primitive("textstyle", math_style, 2);
3957 primitive("scriptstyle", math_style, 4);
3958 primitive("scriptscriptstyle", math_style, 6);
3959 primitive("above", above, 0);
3960 primitive("over", above, 1);
3961 primitive("atop", above, 2);
3962 primitive("abovewithdelims", above, 3);
3963 primitive("overwithdelims", above, 4);
3964 primitive("atopwithdelims", above, 5);
3965 primitive("left", left_right, 30);
3966 primitive("right", left_right, 31);
3967 text(frozen_right) = make_string_pool("right");
3968 eqtb[frozen_right] = eqtb[cur_val];
3969 primitive("long", prefix, 1);
3970 primitive("outer", prefix, 2);
3971 primitive("global", prefix, 4);
3972 primitive("def", def, 0);
3973 primitive("gdef", def, 1);
3974 primitive("edef", def, 2);
3975 primitive("xdef", def, 3);
3976 primitive("let", let, 0);
3977 primitive("futurelet", let, 1);
3978 primitive("chardef", shorthand_def, 0);
3979 primitive("mathchardef", shorthand_def, 1);
3980 primitive("countdef", shorthand_def, 2);
3981 primitive("dimendef", shorthand_def, 3);
3982 primitive("skipdef", shorthand_def, 4);
3983 primitive("muskipdef", shorthand_def, 5);
3984 primitive("toksdef", shorthand_def, 6);
3985 primitive("catcode", def_code, cat_code_base);
3986 primitive("mathcode", def_code, math_code_base);
3987 primitive("lccode", def_code, lc_code_base);
3988 primitive("uccode", def_code, uc_code_base);
3989 primitive("sfcode", def_code, sf_code_base);
3990 primitive("delcode", def_code, del_code_base);
3991 primitive("textfont", def_family, math_font_base);
3992 primitive("scriptfont", def_family, math_font_base + script_size);
3993 primitive("scriptscriptfont", def_family, math_font_base + script_script_size);
3994 primitive("hyphenation", hyph_data, 0);
3995 primitive("patterns", hyph_data, 1);
3996 primitive("hyphenchar", assign_font_int, 0);
3997 primitive("skewchar", assign_font_int, 1);
3998 primitive("batchmode", set_interaction, 0);
3999 primitive("nonstopmode", set_interaction, 1);
4000 primitive("scrollmode", set_interaction, 2);
4001 primitive("errorstopmode", set_interaction, 3);
4002 primitive("openin", in_stream, 1);
4003 primitive("closein", in_stream, 0);
4004 primitive("message", message, 0);
4005 primitive("errmessage", message, 1);
4006 primitive("lowercase", case_shift, lc_code_base);
4007 primitive("uppercase", case_shift, uc_code_base);
4008 primitive("show", xray, 0);
4009 primitive("showbox", xray, 1);
4010 primitive("showthe", xray, 2);
4011 primitive("showlists", xray, 3);
4012 primitive("openout", extension, 0);
4013 primitive("write", extension, 1);
4014 write_loc = cur_val;
4015 primitive("closeout", extension, 2);
4016 primitive("special", extension, 3);
4017 primitive("immediate", extension, 4);
4018 primitive("setlanguage", extension, 5);
4019 no_new_control_sequence = true;