;
/* darn, need to know mem_top, mem_max etc for the following ... */
#ifdef DEBUG
- wasmemend = mem_min;
-/* waslomax = mem_min; */
- waslomax = mem_bot;
-/* washimin = mem_max; */
- washimin = mem_top;
+ was_mem_end = mem_min;
+/* was_lo_max = mem_min; */
+ was_lo_max = mem_bot;
+/* was_hi_min = mem_max; */
+ was_hi_min = mem_top;
panicking = false;
#endif /* DEBUG */
nest_ptr = 0;
max_nest_stack = 0;
mode = 1;
- head = mem_top - 1;
- tail = mem_top - 1;
+ head = contrib_head;
+ tail = contrib_head;
cur_list.aux_field.cint = ignore_depth;
- mode_line = 0;
-/* *********************************************************************** */
-/* cur_list .lhmfield = 0; */ /* removed in 3.14159 */
-/* cur_list .rhmfield = 0; */ /* removed in 3.14159 */
-/* *********************************************************************** */
+ mode_line = 0;
prev_graf = 0;
shown_mode = 0;
page_contents = 0;
- page_tail = mem_top - 2;
+ page_tail = page_head;
#ifdef ALLOCATEMAIN
if (is_initex) /* in iniTeX we did already allocate mem [] */
#endif
- mem[mem_top - 2].hh.v.RH = 0;
+ mem[page_head].hh.v.RH = 0;
/* last_glue = 262143L; */ /* NO! */
last_glue = empty_flag;
last_penalty = 0;
#ifdef ALLOCATEMAIN
void initialize_aux (void)
-{/* ??? */
+{
#ifdef DEBUG
- wasmemend = mem_min;
-/* waslomax = mem_min; */
- waslomax = mem_bot;
-/* washimin = mem_max; */
- washimin = mem_top;
+ was_mem_end = mem_min;
+/* was_lo_max = mem_min; */
+ was_lo_max = mem_bot;
+/* was_hi_min = mem_max; */
+ was_hi_min = mem_top;
panicking = false;
#endif /* DEBUG */
/* nest_ptr = 0; */
/* max_nest_stack = 0; */
mode = 1;
- head = mem_top - 1;
- tail = mem_top - 1;
+ head = contrib_head;
+ tail = contrib_head;
cur_list.aux_field.cint = ignore_depth;
mode_line = 0;
prev_graf = 0;
/* shown_mode = 0; */
/* page_contents = 0; */
- page_tail = mem_top - 2;
+ page_tail = page_head;
//mem[mem_top - 2].hh.v.RH = 0;
- link(mem_top-2) = 0;
+ link(page_head) = 0;
}
#endif // end of ifdef ALLOCATEMAIN
/* savedbadness = 0; */ /* 96/Feb/9 */
pack_begin_line = mode_line;
- mem[mem_top - 3].hh.v.RH = link(head);
+ mem[temp_head].hh.v.RH = link(head);
if((tail >= hi_mem_min))
{
link(tail) = new_penalty(10000);
q = get_node(3);
mem[q].hh.b0 = 0;
mem[q].hh.b1 = 2;
- mem[q].hh.v.RH = mem_top - 7;
+ mem[q].hh.v.RH = active;
mem[q + 1].hh.v.RH = 0;
mem[q + 1].hh.v.LH = prev_graf + 1;
mem[q + 2].cint = 0;
- mem[mem_top - 7].hh.v.RH = q;
+ mem[active].hh.v.RH = q;
active_width[1] = background[1];
active_width[2] = background[2];
active_width[3] = background[3];
active_width[6] = background[6];
/* passive:=null; printed_node:=temp_head; pass_number:=0; */
passive = 0;
- printed_node = mem_top - 3;
+ printed_node = temp_head;
pass_number = 0;
font_in_short_display = 0;
- cur_p = mem[mem_top - 3].hh.v.RH;
+ cur_p = mem[temp_head].hh.v.RH;
autobreaking = true;
prevp = cur_p;
/* while (cur_p<>null)and(link(active)<>last_active) do */
- while((cur_p != 0)&&(mem[mem_top - 7].hh.v.RH != mem_top - 7))
+ while((cur_p != 0)&&(mem[active].hh.v.RH != active))
{
if((cur_p >= hi_mem_min))
{
if(cur_p == 0)
{
try_break(-10000, 1);
- if(mem[mem_top - 7].hh.v.RH != mem_top - 7)
+ if(mem[active].hh.v.RH != active)
{
- r = mem[mem_top - 7].hh.v.RH;
+ r = mem[active].hh.v.RH;
fewest_demerits = 1073741823L; /* 2^30 - 1 */
do {
if(mem[r].hh.b0 != 2)
best_bet = r;
}
r = mem[r].hh.v.RH;
- } while(!(r == mem_top - 7));
+ } while(!(r == active));
best_line = mem[best_bet + 1].hh.v.LH;
/* if looseness=0 then goto done; */
if(eqtb[(hash_size + 3182)].cint == 0){
}
{
/* r:=link(active); actual_looseness:=0; */
- r = mem[mem_top - 7].hh.v.RH;
+ r = mem[active].hh.v.RH;
actual_looseness = 0;
do {
if(mem[r].hh.b0 != 2)
}
}
r = mem[r].hh.v.RH;
- } while(!(r == mem_top - 7));
+ } while(!(r == active));
best_line = mem[best_bet + 1].hh.v.LH;
}
/* if (actual_looseness=looseness)or final_pass then goto done; */
}
}
}
- q = mem[mem_top - 7].hh.v.RH;
- while(q != mem_top - 7){
+ q = mem[active].hh.v.RH;
+ while(q != active){
cur_p = mem[q].hh.v.RH;
if(mem[q].hh.b0 == 2)
free_node(q, 7);
}
#endif /* STAT */
post_line_break(finalwidowpenalty);
- q = mem[mem_top - 7].hh.v.RH;
- while(q != mem_top - 7){
+ q = mem[active].hh.v.RH;
+ while(q != active){
cur_p = mem[q].hh.v.RH;
if(mem[q].hh.b0 == 2)
free_node(q, 7);
}
/* info(omit_template) <- end_template_token; p.790 */
/* @d end_template_token==cs_token_flag+frozen_end_template */
-/* mem[mem_top - 10].hh.v.LH = 14114; */
-/* mem[mem_top - 10].hh.v.LH = 10019 + 4095; */ /* + eqtbextra ? NO */
-/* mem[mem_top - 10].hh.v.LH = (hash_size + 4614); */
-/* mem[mem_top - 10].hh.v.LH = (hash_size + 4095 + 519); */
- mem[mem_top - 10].hh.v.LH = (hash_size + hash_extra + 4095 + 519);
+/* mem[omit_template].hh.v.LH = 14114; */
+/* mem[omit_template].hh.v.LH = 10019 + 4095; */ /* + eqtbextra ? NO */
+/* mem[omit_template].hh.v.LH = (hash_size + 4614); */
+/* mem[omit_template].hh.v.LH = (hash_size + 4095 + 519); */
+ mem[omit_template].hh.v.LH = (hash_size + hash_extra + 4095 + 519);
/* link(end_span) <- max_quarterword + 1 p.797 */
-/* mem[mem_top - 9].hh.v.RH = 256; */ /* 94/Apr/4 ? */
- mem[mem_top - 9].hh.v.RH = max_quarterword + 1; /* 96/Oct/12 ??? */
+/* mem[end_span].hh.v.RH = 256; */ /* 94/Apr/4 ? */
+ mem[end_span].hh.v.RH = max_quarterword + 1; /* 96/Oct/12 ??? */
/* info(end_span) <- null p.797 */
- mem[mem_top - 9].hh.v.LH = 0;
+ mem[end_span].hh.v.LH = 0;
/* type(last_active) <- hyphenated; p.820 */
- mem[mem_top - 7].hh.b0 = 1;
+ mem[active].hh.b0 = 1;
/* line_number(last_active) <- max_halfword; p.820 */
/* mem[mem_top - 6].hh.v.LH = 262143L; */
mem[mem_top - 6].hh.v.LH = empty_flag; /* max_halfword ? */
/* subtype(last_active) <- 0; p.820 */
- mem[mem_top - 7].hh.b1 = 0;
+ mem[active].hh.b1 = 0;
/* subtype(page_ins_head) <- 255; p.981 */
mem[mem_top].hh.b1 = 255; /* subtype(page_ins_head) = qi(255) p.981 */
/* type(page_ins_head) <- split_up; p.981 */
/* link(page_ins_head) <- page_ins_head; p.981 */
mem[mem_top].hh.v.RH = mem_top;
/* type(page_head) <- glue_node; p. 988 */
- mem[mem_top - 2].hh.b0 = 10;
+ mem[page_head].hh.b0 = 10;
/* subtype(page_head) <- normal; p. 988 */
- mem[mem_top - 2].hh.b1 = 0;
+ mem[page_head].hh.b1 = 0;
avail = 0; /* avail <- null p.164 */
mem_end = mem_top; /* mem_end <- mem_top */
hi_mem_min = mem_top - 13; /* hi_mem_min <- hi_mem_stat_min */
print_esc("patterns");
help1("All patterns must be given before typesetting begins.");
error ();
- mem[mem_top - 12].hh.v.RH = scan_toks(false, false);
+ mem[lig_trick].hh.v.RH = scan_toks(false, false);
flush_list(def_ref);
}
}
#ifdef INITEX
void init_prim (void)
{
- no_new_control_sequence = false;
- primitive(373, 75, (hash_size + 782)); /* lineskip */
- primitive(374, 75, (hash_size + 783)); /* baselineskip */
- primitive(375, 75, (hash_size + 784)); /* parskip */
- primitive(376, 75, (hash_size + 785)); /* abovedisplayskip */
- primitive(377, 75, (hash_size + 786)); /* belowdisplayskip */
- primitive(378, 75, (hash_size + 787)); /* abovedisplayshortskip */
- primitive(379, 75, (hash_size + 788)); /* belowdisplayshortskip */
- primitive(380, 75, (hash_size + 789)); /* leftskip */
- primitive(381, 75, (hash_size + 790)); /* rightskip */
- primitive(382, 75, (hash_size + 791)); /* topskip */
- primitive(383, 75, (hash_size + 792)); /* splittopskip */
- primitive(384, 75, (hash_size + 793)); /* tabskip */
- primitive(385, 75, (hash_size + 794)); /* spaceskip */
- primitive(386, 75, (hash_size + 795)); /* xspaceskip */
- primitive(387, 75, (hash_size + 796)); /* parfillskip */
- primitive(388, 76, (hash_size + 797)); /* thinmuskip */
- primitive(389, 76, (hash_size + 798)); /* medmuskip */
- primitive(390, 76, (hash_size + 799)); /* thickmuskip */
- primitive(395, 72, (hash_size + 1313)); /* output */
- primitive(396, 72, (hash_size + 1314)); /* everypar */
- primitive(397, 72, (hash_size + 1315)); /* everymath */
- primitive(398, 72, (hash_size + 1316)); /* everydisplay */
- primitive(399, 72, (hash_size + 1317)); /* everyhbox */
- primitive(400, 72, (hash_size + 1318)); /* everyvbox */
- primitive(401, 72, (hash_size + 1319)); /* everyjob */
- primitive(402, 72, (hash_size + 1320)); /* everycr */
- primitive(403, 72, (hash_size + 1321)); /* errhelp */
- primitive(417, 73, (hash_size + 3163)); /* pretolerance */
- primitive(418, 73, (hash_size + 3164)); /* tolerance */
- primitive(419, 73, (hash_size + 3165)); /* linepenalty */
- primitive(420, 73, (hash_size + 3166)); /* hyphenpenalty */
- primitive(421, 73, (hash_size + 3167)); /* exhyphenpenalty */
- primitive(422, 73, (hash_size + 3168)); /* clubpenalty */
- primitive(423, 73, (hash_size + 3169)); /* widowpenalty */
- primitive(424, 73, (hash_size + 3170)); /* displaywidowpenalty */
- primitive(425, 73, (hash_size + 3171)); /* brokenpenalty */
- primitive(426, 73, (hash_size + 3172)); /* binoppenalty */
- primitive(427, 73, (hash_size + 3173)); /* relpenalty */
- primitive(428, 73, (hash_size + 3174)); /* predisplaypenalty */
- primitive(429, 73, (hash_size + 3175)); /* postdisplaypenalty */
- primitive(430, 73, (hash_size + 3176)); /* interlinepenalty */
- primitive(431, 73, (hash_size + 3177)); /* doublehyphendemerits */
- primitive(432, 73, (hash_size + 3178)); /* finalhyphendemerits */
- primitive(433, 73, (hash_size + 3179)); /* adjdemerits */
- primitive(434, 73, (hash_size + 3180)); /* mag */
- primitive(435, 73, (hash_size + 3181)); /* delimiterfactor */
- primitive(436, 73, (hash_size + 3182)); /* looseness */
- primitive(437, 73, (hash_size + 3183)); /* time */
- primitive(438, 73, (hash_size + 3184)); /* day */
- primitive(439, 73, (hash_size + 3185)); /* month */
- primitive(440, 73, (hash_size + 3186)); /* year */
- primitive(441, 73, (hash_size + 3187)); /* showboxbreadth */
- primitive(442, 73, (hash_size + 3188)); /* showboxdepth */
- primitive(443, 73, (hash_size + 3189)); /* hbadness */
- primitive(444, 73, (hash_size + 3190)); /* vbadness */
- primitive(445, 73, (hash_size + 3191)); /* pausing */
- primitive(446, 73, (hash_size + 3192)); /* tracingonline */
- primitive(447, 73, (hash_size + 3193)); /* tracingmacros */
- primitive(448, 73, (hash_size + 3194)); /* tracingstats */
- primitive(449, 73, (hash_size + 3195)); /* tracingparagraphs */
- primitive(450, 73, (hash_size + 3196)); /* tracingpages */
- primitive(451, 73, (hash_size + 3197)); /* tracingoutput */
- primitive(452, 73, (hash_size + 3198)); /* tracinglostchars */
- primitive(453, 73, (hash_size + 3199)); /* tracingcommands */
- primitive(454, 73, (hash_size + 3200)); /* tracingrestores */
- primitive(455, 73, (hash_size + 3201)); /* uchyph */
- primitive(456, 73, (hash_size + 3202)); /* outputpenalty */
- primitive(457, 73, (hash_size + 3203)); /* maxdeadcycles */
- primitive(458, 73, (hash_size + 3204)); /* hangafter */
- primitive(459, 73, (hash_size + 3205)); /* floatingpenalty */
- primitive(460, 73, (hash_size + 3206)); /* globaldefs */
- primitive(461, 73, (hash_size + 3207)); /* fam */
- primitive(462, 73, (hash_size + 3208)); /* escapechar */
- primitive(463, 73, (hash_size + 3209)); /* defaulthyphenchar */
- primitive(464, 73, (hash_size + 3210)); /* defaultskewchar */
- primitive(465, 73, (hash_size + 3211)); /* endlinechar */
- primitive(466, 73, (hash_size + 3212)); /* newlinechar */
- primitive(467, 73, (hash_size + 3213)); /* language */
- primitive(468, 73, (hash_size + 3214)); /* lefthyphenmin */
- primitive(469, 73, (hash_size + 3215)); /* righthyphenmin */
- primitive(470, 73, (hash_size + 3216)); /* holdinginserts */
- primitive(471, 73, (hash_size + 3217)); /* errorcontextlines */
- primitive(475, 74, (hash_size + 3730)); /* parindent */
- primitive(476, 74, (hash_size + 3731)); /* mathsurround */
- primitive(477, 74, (hash_size + 3732)); /* lineskiplimit */
- primitive(478, 74, (hash_size + 3733)); /* hsize */
- primitive(479, 74, (hash_size + 3734)); /* vsize */
- primitive(480, 74, (hash_size + 3735)); /* maxdepth */
- primitive(481, 74, (hash_size + 3736)); /* splitmaxdepth */
- primitive(482, 74, (hash_size + 3737)); /* boxmaxdepth */
- primitive(483, 74, (hash_size + 3738)); /* hfuzz */
- primitive(484, 74, (hash_size + 3739)); /* vfuzz */
- primitive(485, 74, (hash_size + 3740)); /* delimitershortfall */
- primitive(486, 74, (hash_size + 3741)); /* nulldelimiterspace */
- primitive(487, 74, (hash_size + 3742)); /* scriptspace */
- primitive(488, 74, (hash_size + 3743)); /* predisplaysize */
- primitive(489, 74, (hash_size + 3744)); /* displaywidth */
- primitive(490, 74, (hash_size + 3745)); /* displayindent */
- primitive(491, 74, (hash_size + 3746)); /* overfullrule */
- primitive(492, 74, (hash_size + 3747)); /* hangindent */
- primitive(493, 74, (hash_size + 3748)); /* hoffset */
- primitive(494, 74, (hash_size + 3749)); /* voffset */
- primitive(495, 74, (hash_size + 3750)); /* emergencystretch */
- primitive(32, 64, 0); /* */
- primitive(47, 44, 0); /* / */
- primitive(505, 45, 0); /* accent */
- primitive(506, 90, 0); /* advance */
- primitive(507, 40, 0); /* afterassignment */
- primitive(508, 41, 0); /* aftergroup */
- primitive(509, 61, 0); /* begingroup */
- primitive(510, 16, 0); /* char */
- primitive(501, 107, 0); /* csname */
- primitive(511, 15, 0); /* delimiter */
- primitive(512, 92, 0); /* divide */
- primitive(502, 67, 0); /* endcsname */
- primitive(513, 62, 0); /* endgroup */
+ no_new_control_sequence = false;
+ primitive(373, assign_glue, (hash_size + 782)); /* lineskip */
+ primitive(374, assign_glue, (hash_size + 783)); /* baselineskip */
+ primitive(375, assign_glue, (hash_size + 784)); /* parskip */
+ primitive(376, assign_glue, (hash_size + 785)); /* abovedisplayskip */
+ primitive(377, assign_glue, (hash_size + 786)); /* belowdisplayskip */
+ primitive(378, assign_glue, (hash_size + 787)); /* abovedisplayshortskip */
+ primitive(379, assign_glue, (hash_size + 788)); /* belowdisplayshortskip */
+ primitive(380, assign_glue, (hash_size + 789)); /* leftskip */
+ primitive(381, assign_glue, (hash_size + 790)); /* rightskip */
+ primitive(382, assign_glue, (hash_size + 791)); /* topskip */
+ primitive(383, assign_glue, (hash_size + 792)); /* splittopskip */
+ primitive(384, assign_glue, (hash_size + 793)); /* tabskip */
+ primitive(385, assign_glue, (hash_size + 794)); /* spaceskip */
+ primitive(386, assign_glue, (hash_size + 795)); /* xspaceskip */
+ primitive(387, assign_glue, (hash_size + 796)); /* parfillskip */
+ primitive(388, assign_mu_glue, (hash_size + 797)); /* thinmuskip */
+ primitive(389, assign_mu_glue, (hash_size + 798)); /* medmuskip */
+ primitive(390, assign_mu_glue, (hash_size + 799)); /* thickmuskip */
+ primitive(395, assign_toks, (hash_size + 1313)); /* output */
+ primitive(396, assign_toks, (hash_size + 1314)); /* everypar */
+ primitive(397, assign_toks, (hash_size + 1315)); /* everymath */
+ primitive(398, assign_toks, (hash_size + 1316)); /* everydisplay */
+ primitive(399, assign_toks, (hash_size + 1317)); /* everyhbox */
+ primitive(400, assign_toks, (hash_size + 1318)); /* everyvbox */
+ primitive(401, assign_toks, (hash_size + 1319)); /* everyjob */
+ primitive(402, assign_toks, (hash_size + 1320)); /* everycr */
+ primitive(403, assign_toks, (hash_size + 1321)); /* errhelp */
+ primitive(417, assign_int, (hash_size + 3163)); /* pretolerance */
+ primitive(418, assign_int, (hash_size + 3164)); /* tolerance */
+ primitive(419, assign_int, (hash_size + 3165)); /* linepenalty */
+ primitive(420, assign_int, (hash_size + 3166)); /* hyphenpenalty */
+ primitive(421, assign_int, (hash_size + 3167)); /* exhyphenpenalty */
+ primitive(422, assign_int, (hash_size + 3168)); /* clubpenalty */
+ primitive(423, assign_int, (hash_size + 3169)); /* widowpenalty */
+ primitive(424, assign_int, (hash_size + 3170)); /* displaywidowpenalty */
+ primitive(425, assign_int, (hash_size + 3171)); /* brokenpenalty */
+ primitive(426, assign_int, (hash_size + 3172)); /* binoppenalty */
+ primitive(427, assign_int, (hash_size + 3173)); /* relpenalty */
+ primitive(428, assign_int, (hash_size + 3174)); /* predisplaypenalty */
+ primitive(429, assign_int, (hash_size + 3175)); /* postdisplaypenalty */
+ primitive(430, assign_int, (hash_size + 3176)); /* interlinepenalty */
+ primitive(431, assign_int, (hash_size + 3177)); /* doublehyphendemerits */
+ primitive(432, assign_int, (hash_size + 3178)); /* finalhyphendemerits */
+ primitive(433, assign_int, (hash_size + 3179)); /* adjdemerits */
+ primitive(434, assign_int, (hash_size + 3180)); /* mag */
+ primitive(435, assign_int, (hash_size + 3181)); /* delimiterfactor */
+ primitive(436, assign_int, (hash_size + 3182)); /* looseness */
+ primitive(437, assign_int, (hash_size + 3183)); /* time */
+ primitive(438, assign_int, (hash_size + 3184)); /* day */
+ primitive(439, assign_int, (hash_size + 3185)); /* month */
+ primitive(440, assign_int, (hash_size + 3186)); /* year */
+ primitive(441, assign_int, (hash_size + 3187)); /* showboxbreadth */
+ primitive(442, assign_int, (hash_size + 3188)); /* showboxdepth */
+ primitive(443, assign_int, (hash_size + 3189)); /* hbadness */
+ primitive(444, assign_int, (hash_size + 3190)); /* vbadness */
+ primitive(445, assign_int, (hash_size + 3191)); /* pausing */
+ primitive(446, assign_int, (hash_size + 3192)); /* tracingonline */
+ primitive(447, assign_int, (hash_size + 3193)); /* tracingmacros */
+ primitive(448, assign_int, (hash_size + 3194)); /* tracingstats */
+ primitive(449, assign_int, (hash_size + 3195)); /* tracingparagraphs */
+ primitive(450, assign_int, (hash_size + 3196)); /* tracingpages */
+ primitive(451, assign_int, (hash_size + 3197)); /* tracingoutput */
+ primitive(452, assign_int, (hash_size + 3198)); /* tracinglostchars */
+ primitive(453, assign_int, (hash_size + 3199)); /* tracingcommands */
+ primitive(454, assign_int, (hash_size + 3200)); /* tracingrestores */
+ primitive(455, assign_int, (hash_size + 3201)); /* uchyph */
+ primitive(456, assign_int, (hash_size + 3202)); /* outputpenalty */
+ primitive(457, assign_int, (hash_size + 3203)); /* maxdeadcycles */
+ primitive(458, assign_int, (hash_size + 3204)); /* hangafter */
+ primitive(459, assign_int, (hash_size + 3205)); /* floatingpenalty */
+ primitive(460, assign_int, (hash_size + 3206)); /* globaldefs */
+ primitive(461, assign_int, (hash_size + 3207)); /* fam */
+ primitive(462, assign_int, (hash_size + 3208)); /* escapechar */
+ primitive(463, assign_int, (hash_size + 3209)); /* defaulthyphenchar */
+ primitive(464, assign_int, (hash_size + 3210)); /* defaultskewchar */
+ primitive(465, assign_int, (hash_size + 3211)); /* endlinechar */
+ primitive(466, assign_int, (hash_size + 3212)); /* newlinechar */
+ primitive(467, assign_int, (hash_size + 3213)); /* language */
+ primitive(468, assign_int, (hash_size + 3214)); /* lefthyphenmin */
+ primitive(469, assign_int, (hash_size + 3215)); /* righthyphenmin */
+ primitive(470, assign_int, (hash_size + 3216)); /* holdinginserts */
+ primitive(471, assign_int, (hash_size + 3217)); /* errorcontextlines */
+ primitive(475, assign_dimen, (hash_size + 3730)); /* parindent */
+ primitive(476, assign_dimen, (hash_size + 3731)); /* mathsurround */
+ primitive(477, assign_dimen, (hash_size + 3732)); /* lineskiplimit */
+ primitive(478, assign_dimen, (hash_size + 3733)); /* hsize */
+ primitive(479, assign_dimen, (hash_size + 3734)); /* vsize */
+ primitive(480, assign_dimen, (hash_size + 3735)); /* maxdepth */
+ primitive(481, assign_dimen, (hash_size + 3736)); /* splitmaxdepth */
+ primitive(482, assign_dimen, (hash_size + 3737)); /* boxmaxdepth */
+ primitive(483, assign_dimen, (hash_size + 3738)); /* hfuzz */
+ primitive(484, assign_dimen, (hash_size + 3739)); /* vfuzz */
+ primitive(485, assign_dimen, (hash_size + 3740)); /* delimitershortfall */
+ primitive(486, assign_dimen, (hash_size + 3741)); /* nulldelimiterspace */
+ primitive(487, assign_dimen, (hash_size + 3742)); /* scriptspace */
+ primitive(488, assign_dimen, (hash_size + 3743)); /* predisplaysize */
+ primitive(489, assign_dimen, (hash_size + 3744)); /* displaywidth */
+ primitive(490, assign_dimen, (hash_size + 3745)); /* displayindent */
+ primitive(491, assign_dimen, (hash_size + 3746)); /* overfullrule */
+ primitive(492, assign_dimen, (hash_size + 3747)); /* hangindent */
+ primitive(493, assign_dimen, (hash_size + 3748)); /* hoffset */
+ primitive(494, assign_dimen, (hash_size + 3749)); /* voffset */
+ primitive(495, assign_dimen, (hash_size + 3750)); /* emergencystretch */
+ primitive(32, ex_space, 0); /* */
+ primitive(47, ital_corr, 0); /* / */
+ primitive(505, accent, 0); /* accent */
+ primitive(506, advance, 0); /* advance */
+ primitive(507, after_assignment, 0); /* afterassignment */
+ primitive(508, after_group, 0); /* aftergroup */
+ primitive(509, begin_group, 0); /* begingroup */
+ primitive(510, char_num, 0); /* char */
+ primitive(501, cs_name, 0); /* csname */
+ primitive(511, delim_num, 0); /* delimiter */
+ primitive(512, divide, 0); /* divide */
+ primitive(502, end_cs_name, 0); /* endcsname */
+ primitive(513, end_group, 0); /* endgroup */
/* hash[(hash_size + 516)].v.RH = 513; */
hash[(hash_size + hash_extra + 516)].v.RH = 513; /* endgroup */
/* eqtb[(hash_size + 516)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 516)]= eqtb[cur_val];
- primitive(514, 102, 0); /* expandafter */
- primitive(515, 88, 0); /* font */
- primitive(516, 77, 0); /* fontdimen */
- primitive(517, 32, 0); /* halign */
- primitive(518, 36, 0); /* hrule */
- primitive(519, 39, 0); /* ignorespaces */
- primitive(327, 37, 0); /* insert */
- primitive(348, 18, 0); /* mark */
- primitive(520, 46, 0); /* mathaccent */
- primitive(521, 17, 0); /* mathchar */
- primitive(522, 54, 0); /* mathchoice */
- primitive(523, 91, 0); /* multiply */
- primitive(524, 34, 0); /* noalign */
- primitive(525, 65, 0); /* noboundary */
- primitive(526, 103, 0); /* noexpand */
- primitive(332, 55, 0); /* nonscript */
- primitive(527, 63, 0); /* omit */
- primitive(405, 84, 0); /* parshape */
- primitive(528, 42, 0); /* penalty */
- primitive(529, 80, 0); /* prevgraf */
- primitive(530, 66, 0); /* radical */
- primitive(531, 96, 0); /* read */
- primitive(532, 0, 256); /* primitive("relax",relax,256); */
+ primitive(514, expand_after, 0); /* expandafter */
+ primitive(515, def_font, 0); /* font */
+ primitive(516, assign_font_dimen, 0); /* fontdimen */
+ primitive(517, halign, 0); /* halign */
+ primitive(518, hrule, 0); /* hrule */
+ primitive(519, ignore_spaces, 0); /* ignorespaces */
+ primitive(327, insert, 0); /* insert */
+ primitive(348, mark, 0); /* mark */
+ primitive(520, math_accent, 0); /* mathaccent */
+ primitive(521, math_char_num, 0); /* mathchar */
+ primitive(522, math_choice, 0); /* mathchoice */
+ primitive(523, multiply, 0); /* multiply */
+ primitive(524, no_align, 0); /* noalign */
+ primitive(525, no_boundary, 0); /* noboundary */
+ primitive(526, no_expand, 0); /* noexpand */
+ primitive(332, non_script, 0); /* nonscript */
+ primitive(527, omit, 0); /* omit */
+ primitive(405, set_shape, 0); /* parshape */
+ primitive(528, break_penalty, 0); /* penalty */
+ primitive(529, set_prev_graf, 0); /* prevgraf */
+ primitive(530, radical, 0); /* radical */
+ primitive(531, read_to_cs, 0); /* read */
+ primitive(532, relax, 256); /* primitive("relax",relax,256); */
/* hash[(hash_size + 521)].v.RH = 532; */
hash[(hash_size + hash_extra + 521)].v.RH = 532; /* read */
/* eqtb[(hash_size + 521)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 521)]= eqtb[cur_val];
- primitive(533, 98, 0); /* setbox */
- primitive(534, 109, 0); /* the */
- primitive(404, 71, 0); /* toks */
- primitive(349, 38, 0); /* vadjust */
- primitive(535, 33, 0); /* valign */
- primitive(536, 56, 0); /* vcenter */
- primitive(537, 35, 0); /* vrule */
- primitive(594, 13, 256); /* par */
+ primitive(533, set_box, 0); /* setbox */
+ primitive(534, the, 0); /* the */
+ primitive(404, toks_register, 0); /* toks */
+ primitive(349, vadjust, 0); /* vadjust */
+ primitive(535, valign, 0); /* valign */
+ primitive(536, vcenter, 0); /* vcenter */
+ primitive(537, vrule, 0); /* vrule */
+ primitive(594, par_end, 256); /* par */
par_loc = cur_val;
par_token = 4095 + par_loc;
- primitive(626, 104, 0); /* input */
- primitive(627, 104, 1); /* endinput */
- primitive(628, 110, 0); /* topmark */
- primitive(629, 110, 1); /* firstmark */
- primitive(630, 110, 2); /* botmark */
- primitive(631, 110, 3); /* splitfirstmark */
- primitive(632, 110, 4); /* splitbotmark */
- primitive(473, 89, 0); /* count */
- primitive(497, 89, 1); /* dimen */
- primitive(392, 89, 2); /* skip */
- primitive(393, 89, 3); /* muskip */
- primitive(665, 79, 102); /* spacefactor */
- primitive(666, 79, 1); /* prevdepth */
- primitive(667, 82, 0); /* dead_cycles */
- primitive(668, 82, 1); /* insert_penalties */
- primitive(669, 83, 1); /* wd */
- primitive(670, 83, 3); /* ht */
- primitive(671, 83, 2); /* dp */
- primitive(672, 70, 0); /* last_penalty */
- primitive(673, 70, 1); /* last_kern */
- primitive(674, 70, 2); /* lastskip */
- primitive(675, 70, 3); /* inputlineno */
- primitive(676, 70, 4); /* badness */
- primitive(732, 108, 0); /* number */
- primitive(733, 108, 1); /* romannumeral */
- primitive(734, 108, 2); /* string */
- primitive(735, 108, 3); /* meaning */
- primitive(736, 108, 4); /* font_name */
- primitive(737, 108, 5); /* job_name */
- primitive(753, 105, 0); /* if */
- primitive(754, 105, 1); /* ifcat */
- primitive(755, 105, 2); /* ifnum */
- primitive(756, 105, 3); /* ifdim */
- primitive(757, 105, 4); /* ifodd */
- primitive(758, 105, 5); /* ifvmode */
- primitive(759, 105, 6); /* ifhmode */
- primitive(760, 105, 7); /* ifmmode */
- primitive(761, 105, 8); /* ifinner */
- primitive(762, 105, 9); /* ifvoid */
- primitive(763, 105, 10); /* ifhbox */
- primitive(764, 105, 11); /* ifvbox */
- primitive(765, 105, 12); /* ifx */
- primitive(766, 105, 13); /* ifeof */
- primitive(767, 105, 14); /* iftrue */
- primitive(768, 105, 15); /* iffalse */
- primitive(769, 105, 16); /* ifcase */
- primitive(770, 106, 2); /* fi */
+ primitive(626, input, 0); /* input */
+ primitive(627, input, 1); /* endinput */
+ primitive(628, top_bot_mark, 0); /* topmark */
+ primitive(629, top_bot_mark, 1); /* firstmark */
+ primitive(630, top_bot_mark, 2); /* botmark */
+ primitive(631, top_bot_mark, 3); /* splitfirstmark */
+ primitive(632, top_bot_mark, 4); /* splitbotmark */
+ primitive(473, tex_register, 0); /* count */
+ primitive(497, tex_register, 1); /* dimen */
+ primitive(392, tex_register, 2); /* skip */
+ primitive(393, tex_register, 3); /* muskip */
+ primitive(665, set_aux, 102); /* spacefactor */
+ primitive(666, set_aux, 1); /* prevdepth */
+ primitive(667, set_page_int, 0); /* dead_cycles */
+ primitive(668, set_page_int, 1); /* insert_penalties */
+ primitive(669, set_box_dimen, 1); /* wd */
+ primitive(670, set_box_dimen, 3); /* ht */
+ primitive(671, set_box_dimen, 2); /* dp */
+ primitive(672, last_item, 0); /* last_penalty */
+ primitive(673, last_item, 1); /* last_kern */
+ primitive(674, last_item, 2); /* lastskip */
+ primitive(675, last_item, 3); /* inputlineno */
+ primitive(676, last_item, 4); /* badness */
+ primitive(732, convert, 0); /* number */
+ primitive(733, convert, 1); /* romannumeral */
+ primitive(734, convert, 2); /* string */
+ primitive(735, convert, 3); /* meaning */
+ primitive(736, convert, 4); /* font_name */
+ primitive(737, convert, 5); /* job_name */
+ primitive(753, if_test, 0); /* if */
+ primitive(754, if_test, 1); /* ifcat */
+ primitive(755, if_test, 2); /* ifnum */
+ primitive(756, if_test, 3); /* ifdim */
+ primitive(757, if_test, 4); /* ifodd */
+ primitive(758, if_test, 5); /* ifvmode */
+ primitive(759, if_test, 6); /* ifhmode */
+ primitive(760, if_test, 7); /* ifmmode */
+ primitive(761, if_test, 8); /* ifinner */
+ primitive(762, if_test, 9); /* ifvoid */
+ primitive(763, if_test, 10); /* ifhbox */
+ primitive(764, if_test, 11); /* ifvbox */
+ primitive(765, if_test, 12); /* ifx */
+ primitive(766, if_test, 13); /* ifeof */
+ primitive(767, if_test, 14); /* iftrue */
+ primitive(768, if_test, 15); /* iffalse */
+ primitive(769, if_test, 16); /* ifcase */
+ primitive(770, fi_or_else, 2); /* fi */
/* hash[(hash_size + 518)].v.RH = 770; */
hash[(hash_size + hash_extra + 518)].v.RH = 770; /* fi */
/* eqtb[(hash_size + 518)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 518)]= eqtb[cur_val];
- primitive(771, 106, 4); /* or */
- primitive(772, 106, 3); /* else */
- primitive(795, 87, 0); /* nullfont */
+ primitive(771, fi_or_else, 4); /* or */
+ primitive(772, fi_or_else, 3); /* else */
+ primitive(795, set_font, 0); /* nullfont */
/* hash[(hash_size + 524)].v.RH = 795; */ /* hash[frozen_null_font] */
hash[(hash_size + hash_extra + 524)].v.RH = 795; /* nullfont */
/* eqtb[(hash_size + 524)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 524)]= eqtb[cur_val];
- primitive(892, 4, 256); /* span */
+ primitive(892, tab_mark, 256); /* span */
/* primitive("span",tab_mark,span_code); */
- primitive(893, 5, 257); /* cr */
+ primitive(893, car_ret, 257); /* cr */
/* primitive("cr",car_ret,cr_code); */
/* hash[(hash_size + 515)].v.RH = 893; */
hash[(hash_size + hash_extra + 515)].v.RH = 893; /* cr */
/* eqtb[(hash_size + 515)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 515)]= eqtb[cur_val];
- primitive(894, 5, 258); /* cr cr */
+ primitive(894, car_ret, 258); /* cr cr */
/* hash[(hash_size + 519)].v.RH = 895; */
hash[(hash_size + hash_extra + 519)].v.RH = 895; /* endtemplate */
/* hash[(hash_size + 520)].v.RH = 895; */
hash[(hash_size + hash_extra + 520)].v.RH = 895; /* endtemplate */
/* eqtb[(hash_size + 520)].hh.b0 = 9; */
eqtb[(hash_size + hash_extra + 520)].hh.b0 = 9;
-/* eqtb[(hash_size + 520)].hh.v.RH = mem_top - 11; */
- eqtb[(hash_size + hash_extra + 520)].hh.v.RH = mem_top - 11;
+/* eqtb[(hash_size + 520)].hh.v.RH = null_list; */
+ eqtb[(hash_size + hash_extra + 520)].hh.v.RH = null_list;
/* eqtb[(hash_size + 520)].hh.b1 = 1; */
eqtb[(hash_size + hash_extra + 520)].hh.b1 = 1;
/* eqtb[(hash_size + 519)]= eqtb[(hash_size + 520)]; */
eqtb[(hash_size + hash_extra + 520)];
/* eqtb[(hash_size + 519)].hh.b0 = 115; */
eqtb[(hash_size + hash_extra + 519)].hh.b0 = 115;
- primitive(964, 81, 0); /* pagegoal */
- primitive(965, 81, 1); /* pagetotal */
- primitive(966, 81, 2); /* pagestretch */
- primitive(967, 81, 3); /* pagefilstretch */
- primitive(968, 81, 4); /* pagefillstretch */
- primitive(969, 81, 5); /* pagefilllstretch */
- primitive(970, 81, 6); /* pageshrink */
- primitive(971, 81, 7); /* pagedepth */
- primitive(1019, 14, 0); /* end */
- primitive(1020, 14, 1); /* dump */
- primitive(1021, 26, 4); /* hskip */
- primitive(1022, 26, 0); /* hfil */
- primitive(1023, 26, 1); /* hfill */
- primitive(1024, 26, 2); /* hss */
- primitive(1025, 26, 3); /* hfilneg */
- primitive(1026, 27, 4); /* vskip */
- primitive(1027, 27, 0); /* vfil */
- primitive(1028, 27, 1); /* vfill */
- primitive(1029, 27, 2); /* vss */
- primitive(1030, 27, 3); /* vfilneg */
- primitive(333, 28, 5); /* mskip */
- primitive(337, 29, 1); /* kern */
- primitive(339, 30, 99); /* mkern */
- primitive(1048, 21, 1); /* moveleft */
- primitive(1049, 21, 0); /* moveright */
- primitive(1050, 22, 1); /* raise */
- primitive(1051, 22, 0); /* lower */
- primitive(406, 20, 0); /* box */
- primitive(1052, 20, 1); /* copy */
- primitive(1053, 20, 2); /* lastbox */
- primitive(959, 20, 3); /* vsplit */
- primitive(1054, 20, 4); /* vtop */
- primitive(961, 20, 5); /* vbox */
- primitive(1055, 20, 106); /* hbox */
- primitive(1056, 31, 99); /* ship_out */
- primitive(1057, 31, 100); /* leaders */
- primitive(1058, 31, 101); /* cleaders */
- primitive(1059, 31, 102); /* xleaders */
- primitive(1074, 43, 1); /* indent */
- primitive(1075, 43, 0); /* noindent */
- primitive(1084, 25, 12); /* unpenalty */
- primitive(1085, 25, 11); /* unkern */
- primitive(1086, 25, 10); /* unskip */
- primitive(1087, 23, 0); /* unhbox */
- primitive(1088, 23, 1); /* unhcopy */
- primitive(1089, 24, 0); /* unvbox */
- primitive(1090, 24, 1); /* unvcopy */
- primitive(45, 47, 1); /* - */
- primitive(346, 47, 0); /* discretionary */
- primitive(1121, 48, 0); /* eqno */
- primitive(1122, 48, 1); /* leqno */
- primitive(860, 50, 16); /* mathord */
- primitive(861, 50, 17); /* mathop */
- primitive(862, 50, 18); /* mathbin */
- primitive(863, 50, 19); /* mathrel */
- primitive(864, 50, 20); /* mathopen */
- primitive(865, 50, 21); /* mathclose */
- primitive(866, 50, 22); /* mathpunct */
- primitive(867, 50, 23); /* mathinner */
- primitive(869, 50, 26); /* underline */
- primitive(868, 50, 27); /* overline */
- primitive(1123, 51, 0); /* displaylimits */
- primitive(872, 51, 1); /* limits */
- primitive(873, 51, 2); /* nolimits */
- primitive(855, 53, 0); /* displaystyle */
- primitive(856, 53, 2); /* textstyle */
- primitive(857, 53, 4); /* scriptstyle */
- primitive(858, 53, 6); /* scriptscriptstyle */
- primitive(1141, 52, 0); /* above */
- primitive(1142, 52, 1); /* over */
- primitive(1143, 52, 2); /* atop */
- primitive(1144, 52, 3); /* abovewithdelims */
- primitive(1145, 52, 4); /* overwithdelims */
- primitive(1146, 52, 5); /* atopwithdelims */
- primitive(870, 49, 30); /* left */
- primitive(871, 49, 31); /* right */
+ primitive(964, set_page_dimen, 0); /* pagegoal */
+ primitive(965, set_page_dimen, 1); /* pagetotal */
+ primitive(966, set_page_dimen, 2); /* pagestretch */
+ primitive(967, set_page_dimen, 3); /* pagefilstretch */
+ primitive(968, set_page_dimen, 4); /* pagefillstretch */
+ primitive(969, set_page_dimen, 5); /* pagefilllstretch */
+ primitive(970, set_page_dimen, 6); /* pageshrink */
+ primitive(971, set_page_dimen, 7); /* pagedepth */
+ primitive(1019, end_match, 0); /* end */
+ primitive(1020, stop, 1); /* dump */
+ primitive(1021, hskip, 4); /* hskip */
+ primitive(1022, hskip, 0); /* hfil */
+ primitive(1023, hskip, 1); /* hfill */
+ primitive(1024, hskip, 2); /* hss */
+ primitive(1025, hskip, 3); /* hfilneg */
+ primitive(1026, vskip, 4); /* vskip */
+ primitive(1027, vskip, 0); /* vfil */
+ primitive(1028, vskip, 1); /* vfill */
+ primitive(1029, vskip, 2); /* vss */
+ primitive(1030, vskip, 3); /* vfilneg */
+ primitive(333, mskip, 5); /* mskip */
+ primitive(337, kern, 1); /* kern */
+ primitive(339, mkern, 99); /* mkern */
+ primitive(1048, hmove, 1); /* moveleft */
+ primitive(1049, hmove, 0); /* moveright */
+ primitive(1050, vmove, 1); /* raise */
+ primitive(1051, vmove, 0); /* lower */
+ primitive(406, make_box, 0); /* box */
+ primitive(1052, make_box, 1); /* copy */
+ primitive(1053, make_box, 2); /* lastbox */
+ primitive(959, make_box, 3); /* vsplit */
+ primitive(1054, make_box, 4); /* vtop */
+ primitive(961, make_box, 5); /* vbox */
+ primitive(1055, make_box, 106); /* hbox */
+ primitive(1056, leader_ship, 99); /* ship_out */
+ primitive(1057, leader_ship, 100); /* leaders */
+ primitive(1058, leader_ship, 101); /* cleaders */
+ primitive(1059, leader_ship, 102); /* xleaders */
+ primitive(1074, start_par, 1); /* indent */
+ primitive(1075, start_par, 0); /* noindent */
+ primitive(1084, remove_item, 12); /* unpenalty */
+ primitive(1085, remove_item, 11); /* unkern */
+ primitive(1086, remove_item, 10); /* unskip */
+ primitive(1087, un_hbox, 0); /* unhbox */
+ primitive(1088, un_hbox, 1); /* unhcopy */
+ primitive(1089, un_vbox, 0); /* unvbox */
+ primitive(1090, un_vbox, 1); /* unvcopy */
+ primitive(45, discretionary, 1); /* - */
+ primitive(346, discretionary, 0); /* discretionary */
+ primitive(1121, eq_no, 0); /* eqno */
+ primitive(1122, eq_no, 1); /* leqno */
+ primitive(860, math_comp, 16); /* mathord */
+ primitive(861, math_comp, 17); /* mathop */
+ primitive(862, math_comp, 18); /* mathbin */
+ primitive(863, math_comp, 19); /* mathrel */
+ primitive(864, math_comp, 20); /* mathopen */
+ primitive(865, math_comp, 21); /* mathclose */
+ primitive(866, math_comp, 22); /* mathpunct */
+ primitive(867, math_comp, 23); /* mathinner */
+ primitive(869, math_comp, 26); /* underline */
+ primitive(868, math_comp, 27); /* overline */
+ primitive(1123, limit_switch, 0); /* displaylimits */
+ primitive(872, limit_switch, 1); /* limits */
+ primitive(873, limit_switch, 2); /* nolimits */
+ primitive(855, math_style, 0); /* displaystyle */
+ primitive(856, math_style, 2); /* textstyle */
+ primitive(857, math_style, 4); /* scriptstyle */
+ primitive(858, math_style, 6); /* scriptscriptstyle */
+ primitive(1141, above, 0); /* above */
+ primitive(1142, above, 1); /* over */
+ primitive(1143, above, 2); /* atop */
+ primitive(1144, above, 3); /* abovewithdelims */
+ primitive(1145, above, 4); /* overwithdelims */
+ primitive(1146, above, 5); /* atopwithdelims */
+ primitive(870, left_right, 30); /* left */
+ primitive(871, left_right, 31); /* right */
/* hash[(hash_size + 517)].v.RH = 871; */
hash[(hash_size + hash_extra + 517)].v.RH = 871; /* right */
/* eqtb[(hash_size + 517)]= eqtb[cur_val]; */
eqtb[(hash_size + hash_extra + 517)]= eqtb[cur_val];
- primitive(1165, 93, 1); /* long */
- primitive(1166, 93, 2); /* outer */
- primitive(1167, 93, 4); /* global */
- primitive(1168, 97, 0); /* def */
- primitive(1169, 97, 1); /* gdef */
- primitive(1170, 97, 2); /* edef */
- primitive(1171, 97, 3); /* xdef */
- primitive(1185, 94, 0); /* let */
- primitive(1186, 94, 1); /* futurelet */
- primitive(1187, 95, 0); /* chardef */
- primitive(1188, 95, 1); /* mathchardef */
- primitive(1189, 95, 2); /* countdef */
- primitive(1190, 95, 3); /* dimendef */
- primitive(1191, 95, 4); /* skipdef */
- primitive(1192, 95, 5); /* muskipdef */
- primitive(1193, 95, 6); /* toksdef */
- primitive(412, 85, (hash_size + 1883)); /* catcode */
- primitive(416, 85, (hash_size + 2907)); /* mathcode */
- primitive(413, 85, (hash_size + 2139)); /* lccode */
- primitive(414, 85, (hash_size + 2395)); /* uccode */
- primitive(415, 85, (hash_size + 2651)); /* sfcode */
- primitive(474, 85, (hash_size + 3474)); /* delcode */
- primitive(409, 86, (hash_size + 1835)); /* textfont */
- primitive(410, 86, (hash_size + 1851)); /* scriptfont */
- primitive(411, 86, (hash_size + 1867)); /* scriptscriptfont */
- primitive(935, 99, 0); /* hyphenation */
- primitive(947, 99, 1); /* patterns */
- primitive(1211, 78, 0); /* hyphen_char */
- primitive(1212, 78, 1); /* skew_char */
- primitive(272, 100, 0); /* batchmode */
- primitive(273, 100, 1); /* nonstopmode */
- primitive(274, 100, 2); /* scrollmode */
- primitive(1221, 100, 3); /* errorstopmode */
- primitive(1222, 60, 1); /* openin */
- primitive(1223, 60, 0); /* closein */
- primitive(1224, 58, 0); /* message */
- primitive(1225, 58, 1); /* errmessage */
- primitive(1231, 57, (hash_size + 2139)); /* lowercase */
- primitive(1232, 57, (hash_size + 2395)); /* uppercase */
- primitive(1233, 19, 0); /* show */
- primitive(1234, 19, 1); /* show_box */
- primitive(1235, 19, 2); /* showthe */
- primitive(1236, 19, 3); /* showlists */
- primitive(1279, 59, 0); /* openout */
- primitive(591, 59, 1); /* write */
+ primitive(1165, prefix, 1); /* long */
+ primitive(1166, prefix, 2); /* outer */
+ primitive(1167, prefix, 4); /* global */
+ primitive(1168, def, 0); /* def */
+ primitive(1169, def, 1); /* gdef */
+ primitive(1170, def, 2); /* edef */
+ primitive(1171, def, 3); /* xdef */
+ primitive(1185, let, 0); /* let */
+ primitive(1186, let, 1); /* futurelet */
+ primitive(1187, shorthand_def, 0); /* chardef */
+ primitive(1188, shorthand_def, 1); /* mathchardef */
+ primitive(1189, shorthand_def, 2); /* countdef */
+ primitive(1190, shorthand_def, 3); /* dimendef */
+ primitive(1191, shorthand_def, 4); /* skipdef */
+ primitive(1192, shorthand_def, 5); /* muskipdef */
+ primitive(1193, shorthand_def, 6); /* toksdef */
+ primitive(412, def_code, (hash_size + 1883)); /* catcode */
+ primitive(416, def_code, (hash_size + 2907)); /* mathcode */
+ primitive(413, def_code, (hash_size + 2139)); /* lccode */
+ primitive(414, def_code, (hash_size + 2395)); /* uccode */
+ primitive(415, def_code, (hash_size + 2651)); /* sfcode */
+ primitive(474, def_code, (hash_size + 3474)); /* delcode */
+ primitive(409, def_family, (hash_size + 1835)); /* textfont */
+ primitive(410, def_family, (hash_size + 1851)); /* scriptfont */
+ primitive(411, def_family, (hash_size + 1867)); /* scriptscriptfont */
+ primitive(935, hyph_data, 0); /* hyphenation */
+ primitive(947, hyph_data, 1); /* patterns */
+ primitive(1211, assign_font_int, 0); /* hyphen_char */
+ primitive(1212, assign_font_int, 1); /* skew_char */
+ primitive(272, set_interaction, 0); /* batchmode */
+ primitive(273, set_interaction, 1); /* nonstopmode */
+ primitive(274, set_interaction, 2); /* scrollmode */
+ primitive(1221, set_interaction, 3); /* errorstopmode */
+ primitive(1222, in_stream, 1); /* openin */
+ primitive(1223, in_stream, 0); /* closein */
+ primitive(1224, message, 0); /* message */
+ primitive(1225, message, 1); /* errmessage */
+ primitive(1231, case_shift, (hash_size + 2139)); /* lowercase */
+ primitive(1232, case_shift, (hash_size + 2395)); /* uppercase */
+ primitive(1233, xray, 0); /* show */
+ primitive(1234, xray, 1); /* show_box */
+ primitive(1235, xray, 2); /* showthe */
+ primitive(1236, xray, 3); /* showlists */
+ primitive(1279, extension, 0); /* openout */
+ primitive(591, extension, 1); /* write */
write_loc = cur_val;
- primitive(1280, 59, 2); /* closeout */
- primitive(1281, 59, 3); /* special */
- primitive(1282, 59, 4); /* immediate */
- primitive(1283, 59, 5); /* setlanguage */
+ primitive(1280, extension, 2); /* closeout */
+ primitive(1281, extension, 3); /* special */
+ primitive(1282, extension, 4); /* immediate */
+ primitive(1283, extension, 5); /* setlanguage */
no_new_control_sequence = true;
}
#endif /* INITEX */
#define MAXCHRS 256
#define NOTDEF 127
-void read_xchr_sub (FILE *input)
+void read_xchr_sub (FILE *pinput)
{
char buffer[PATH_MAX];
int k, from, to, count = 0;
#ifdef USEMEMSET
memset (xchr, NOTDEF, MAXCHRS); /* mark unused */
#else
- for (k = 0; k < MAXCHRS; k++) xchr[k]= -1; */ /* mark unused */
+ for (k = 0; k < MAXCHRS; k++) xchr[k]= -1; /* mark unused */
#endif
#ifdef USEMEMSET
memset (xord, NOTDEF, MAXCHRS); /* mark unused */
#else
- for (k = 0; k < MAXCHRS; k++) xord[k]= -1; */ /* mark unused */
+ for (k = 0; k < MAXCHRS; k++) xord[k]= -1; /* mark unused */
#endif
#ifdef ALLOCATEBUFFER
- while (fgets(buffer, current_buf_size, input) != NULL)
+ while (fgets(buffer, current_buf_size, pinput) != NULL)
#else
- while (fgets(buffer, sizeof(buffer), input) != NULL)
+ while (fgets(buffer, sizeof(buffer), pinput) != NULL)
#endif
{
if (*buffer == '%' || *buffer == ';' || *buffer == '\n') continue;
char *replacement[MAXCHRS]; /* pointers to replacement strings */
-void read_repl_sub (FILE *input)
+void read_repl_sub (FILE *pinput)
{
int k, n, m, chrs;
char buffer[PATH_MAX];
for (k = 0; k < MAXCHRS; k++) replacement[k] = NULL;
#endif
- while (fgets(buffer, PATH_MAX, input) != NULL) {
+ while (fgets(buffer, PATH_MAX, pinput) != NULL) {
if (*buffer == '%' || *buffer == ';' || *buffer == '\n') continue;
if ((m = sscanf (buffer, "%d%n %s", &chrs, &n, &charname)) == 0)
continue;
int read_xchr_file (char *filename, int flag, char *argv[])
{
- FILE *input;
+ FILE *pinput;
char infile[PATH_MAX];
char *s;
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag); /* 94/July/12 */
- if (input == NULL) {
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag); /* 94/July/12 */
+ if (pinput == NULL) {
if (strrchr(infile, '.') == NULL) {
if (flag == 0) strcat(infile, ".map");
else strcat(infile, ".key");
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag); /* 94/July/12 */
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag); /* 94/July/12 */
}
}
- if (input == NULL) {
+ if (pinput == NULL) {
/* strcpy (infile, gargv[0]); */ /* try TeX program path */
strcpy (infile, argv[0]); /* try TeX program path */
if ((s = strrchr (infile, '\\')) != NULL) *(s+1) = '\0';
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag); /* 94/July/12 */
- if (input == NULL) {
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag); /* 94/July/12 */
+ if (pinput == NULL) {
if (strchr(infile, '.') == NULL) {
if (flag == 0) strcat(infile, ".map");
else strcat(infile, ".key");
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag); /* 94/July/12 */
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag); /* 94/July/12 */
}
}
}
- if (input == NULL) { /* 97/July/31 */
+ if (pinput == NULL) { /* 97/July/31 */
/* strcpy (infile, gargv[0]); */ /* try TeX program path\keyboard */
strcpy (infile, argv[0]); /* try TeX program path */
if ((s = strrchr (infile, '\\')) != NULL) *(s+1) = '\0';
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag);
- if (input == NULL) {
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag);
+ if (pinput == NULL) {
if (strchr(infile, '.') == NULL) {
if (flag == 0) strcat(infile, ".map");
else strcat(infile, ".key");
sprintf(log_line, "Trying %s\n", infile);
show_line(log_line, 0);
}
- if (share_flag == 0) input = fopen (infile, "r");
- else input = _fsopen (infile, "r", share_flag);
+ if (share_flag == 0) pinput = fopen (infile, "r");
+ else pinput = _fsopen (infile, "r", share_flag);
}
}
}
/* Note: can't look in TeX source file dir, since that is not known yet */
- if (input == NULL) {
+ if (pinput == NULL) {
sprintf(log_line, "ERROR: Sorry, cannot find %s file %s",
flag ? " xchr[]" : "key mapping", filename);
show_line(log_line, 1);
}
if (flag == 0)
- read_xchr_sub (input);
+ read_xchr_sub (pinput);
else
- read_repl_sub (input);
+ read_repl_sub (pinput);
- (void) fclose (input);
+ (void) fclose (pinput);
return 1;
}
{ /* set up full file name for dviwindo.ini */
char dviwindoini[PATH_MAX];
char line[PATH_MAX];
- FILE *input;
+ FILE *pinput;
char *windir;
int em = strlen(envsection);
int wm = strlen(wndsection);
if (*dviwindoini != '\0') {
dviwindo = xstrdup(dviwindoini); /* avoid PATH_MAX string */
/* check whether dviwindo.ini actually has [Environment] section */
- if (share_flag == 0) input = fopen(dviwindo, "r");
- else input = _fsopen(dviwindo, "r", share_flag);
- if (input != NULL) {
- while (fgets (line, sizeof(line), input) != NULL) {
+ if (share_flag == 0) pinput = fopen(dviwindo, "r");
+ else pinput = _fsopen(dviwindo, "r", share_flag);
+ if (pinput != NULL) {
+ while (fgets (line, sizeof(line), pinput) != NULL) {
if (*line == ';') continue;
if (*line == '\n') continue;
if (*line == '[') {
}
}
if (envflag) {
- (void) fclose(input);
+ (void) fclose(pinput);
return true;
}
if (trace_flag)
show_line("Failed to find [Environment]", 1); /* DEBUGGING */
- (void) fclose(input);
+ (void) fclose(pinput);
}
else if (trace_flag) perrormod(dviwindo); /* DEBUGGING */
strcpy(dviwindo, ""); /* failed, for one reason or another */
char *grabenv (char *varname)
{
char line[PATH_MAX];
- FILE *input;
+ FILE *pinput;
char *s;
int m, n;
/* int m = strlen(envsection); */
else return xstrdup(s); /* make safe 98/Jan/31 */
}
- if (share_flag == 0) input = fopen(dviwindo, "r");
- else input = _fsopen(dviwindo, "r", share_flag);
+ if (share_flag == 0) pinput = fopen(dviwindo, "r");
+ else pinput = _fsopen(dviwindo, "r", share_flag);
- if (input != NULL) {
+ if (pinput != NULL) {
m = strlen(envsection);
/* search for [Environment] section */ /* should be case insensitive */
- while (fgets (line, sizeof(line), input) != NULL) {
+ while (fgets (line, sizeof(line), pinput) != NULL) {
if (*line == ';') continue;
if (*line == '\n') continue;
if (_strnicmp(line, envsection, m) == 0) { /* 98/Jan/31 */
/* search for varname=... */ /* should be case sensitive ? */
n = strlen(varname);
- while (fgets (line, sizeof(line), input) != NULL) {
+ while (fgets (line, sizeof(line), pinput) != NULL) {
if (*line == ';') continue;
if (*line == '[') break;
/* if (*line == '\n') break; */ /* ??? */
/* if (strncmp(line, varname, n) == 0 && */
if (_strnicmp(line, varname, n) == 0 &&
*(line+n) == '=') { /* found it ? */
- (void) fclose (input);
+ (void) fclose (pinput);
/* flush trailing white space */
s = line + strlen(line) - 1;
while (*s <= ' ' && s > line) *s-- = '\0';
/* break; */ /* ? not found in designated section */
} /* end of search for [Environment] section */
}
- (void) fclose (input);
+ (void) fclose (pinput);
} /* end of if fopen */
s = getenv(varname); /* failed, so try and get from environment */
/* if (s != NULL) return s; */
/* can this be reentered ? */
/* supply extension if none */
-void extension (char *fname, char *ext)
+void yy_extension (char *fname, char *ext)
{
char *s, *t;
if ((s = strrchr(fname, '.')) == NULL ||
/* Try first in current directory (or use full name as specified) */
strcpy(commandfile, filename);
- extension(commandfile, "cmd");
+ yy_extension(commandfile, "cmd");
if (share_flag == 0)
command = fopen(commandfile, "r");
else
/* don't need fancy footwork, since programpath non-empty */
strcat(commandfile, "\\");
strcat(commandfile, filename);
- extension(commandfile, "cmd");
+ yy_extension(commandfile, "cmd");
if (share_flag == 0)
command = fopen(commandfile, "r");
else
void print_err (const char * s)
{
if (interaction == error_stop_mode);
- print_nl("! ");
+ print_nl("! ");
print_string(s);
}
+
void tex_help (unsigned int n, ...)
{
unsigned int i;
if (n > 6) n = 6;
help_ptr = n;
va_start(help_arg, n);
- for (i = 0; i <= n - 1; i++)
+ for (i = n - 1; i > n - 1; --i)
help_line[i] = va_arg(help_arg, char *);
va_end(help_arg);
}
// print newline
/* sec 0058 */
-void print_ln(void)
-{
- switch(selector){
- case term_and_log:
- {
- show_char('\n');
- term_offset = 0;
- (void) putc ('\n', log_file);
- file_offset = 0;
- }
- break;
- case log_only:
- {
- (void) putc ('\n', log_file);
- file_offset = 0;
- }
- break;
- case term_only:
- {
- show_char('\n');
- term_offset = 0;
- }
- break;
- case no_print:
- case pseudo:
- case new_string: ;
- break;
- default:
- (void) putc ('\n', write_file[selector]);
- break;
- }
-}
-/* sec 0059 */
-void print_char_(ASCII_code s)
-{/* 10 */
- if(s == eqtb[(hash_size + 3212)].cint)
- if(selector < pseudo){
- print_ln ();
- return;
- }
- switch(selector){
+void print_ln (void)
+{
+ switch (selector) {
case term_and_log:
- {
- (void) show_char(Xchr(s));
- incr(term_offset);
- (void) putc(Xchr(s), log_file);
- incr(file_offset);
- if(term_offset == max_print_line){
+ {
show_char('\n');
- term_offset = 0;
- }
- if(file_offset == max_print_line){
+ term_offset = 0;
+ (void) putc ('\n', log_file);
+ file_offset = 0;
+ }
+ break;
+ case log_only:
+ {
(void) putc ('\n', log_file);
- file_offset = 0;
- }
- }
- break;
+ file_offset = 0;
+ }
+ break;
+ case term_only:
+ {
+ show_char('\n');
+ term_offset = 0;
+ }
+ break;
+ case no_print:
+ case pseudo:
+ case new_string:
+ ;
+ break;
+ default:
+ (void) putc ('\n', write_file[selector]);
+ break;
+ }
+}
+/* sec 0059 */
+void print_char_ (ASCII_code s)
+{
+ if(s == eqtb[(hash_size + 3212)].cint)
+ if (selector < pseudo) {
+ print_ln ();
+ return;
+ }
+ switch (selector) {
+ case term_and_log:
+ {
+ (void) show_char(Xchr(s));
+ incr(term_offset);
+ (void) putc(Xchr(s), log_file);
+ incr(file_offset);
+ if (term_offset == max_print_line) {
+ show_char('\n');
+ term_offset = 0;
+ }
+ if (file_offset == max_print_line) {
+ (void) putc ('\n', log_file);
+ file_offset = 0;
+ }
+ }
+ break;
case log_only:
- {
- (void) putc(Xchr(s), log_file);
- incr(file_offset);
- if(file_offset == max_print_line)print_ln ();
- }
- break;
+ {
+ (void) putc(Xchr(s), log_file);
+ incr(file_offset);
+ if (file_offset == max_print_line) print_ln ();
+ }
+ break;
case term_only:
- {
- (void) show_char(Xchr(s));
- incr(term_offset);
- if(term_offset == max_print_line)print_ln ();
- }
- break;
- case no_print:
- ;
- break;
- case pseudo:
+ {
+ (void) show_char(Xchr(s));
+ incr(term_offset);
+ if (term_offset == max_print_line) print_ln ();
+ }
+ break;
+ case no_print:
+ ;
+ break;
+ case pseudo:
if(tally < trick_count)
- trick_buf[tally % error_line]= s;
- break;
- case new_string:
- {
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
+ trick_buf[tally % error_line]= s;
+ break;
+ case new_string:
+ {
#ifdef ALLOCATESTRING
- if(pool_ptr + 1 > current_pool_size) {
- str_pool = realloc_str_pool (increment_pool_size); /* 94/Jan/24 */
- }
- if(pool_ptr < current_pool_size) /* 94/Jan/24 */
+ if (pool_ptr + 1 > current_pool_size) {
+ str_pool = realloc_str_pool (increment_pool_size);
+ }
+ if (pool_ptr < current_pool_size) {
+ str_pool[pool_ptr]= s;
+ incr(pool_ptr);
+ }
#else
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- if(pool_ptr < pool_size)
+ if (pool_ptr < pool_size) {
+ str_pool[pool_ptr]= s;
+ incr(pool_ptr);
+ }
#endif
- {
- str_pool[pool_ptr]= s;
- incr(pool_ptr);
- }
- }
- break;
+ }
+ break;
default:
- (void) putc(Xchr(s), write_file[selector]);
+ (void) putc(Xchr(s), write_file[selector]);
break;
- } /* end of switch(selector) */
- incr(tally);
-}
+ }
+ incr(tally);
+}
/* sec 0059 */
/* This could be made more efficient using fputs ? ... bkph */
-void print_(integer s)
-{/* 10 */
- pool_pointer j;
- integer nl;
- if(s >= str_ptr) s = 259; /* ??? */
- else if(s < 256)
- if(s < 0) s = 259; /* ??? */
+void print_ (integer s)
+{
+ pool_pointer j;
+ integer nl;
+ if (s >= str_ptr) s = 259; /* ??? */
+ else if (s < 256)
+ if (s < 0) s = 259; /* ??? */
else {
- if(selector > pseudo){
- print_char(s);
- return;
- }
- if((s == eqtb[(hash_size + 3212)].cint))
- if(selector < 20){
- print_ln ();
- return;
- }
+ if (selector > pseudo){
+ print_char(s);
+ return;
+ }
+ if ((s == eqtb[(hash_size + 3212)].cint))
+ if (selector < 20) {
+ print_ln ();
+ return;
+ }
nl = eqtb[(hash_size + 3212)].cint; /* save eol */
eqtb[(hash_size + 3212)].cint = -1;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
-/* if (!show_in_hex && s < 256) */ /* show control chars also ?? */
- if (! show_in_hex && s < 256 && s >= 32) { /* 94/Jan/26 */
+/* if (!show_in_hex && s < 256) */ /* show control chars also ?? */
+ if (!show_in_hex && s < 256 && s >= 32) { /* 94/Jan/26 */
/* following added 1996/Jan/20 */
if (show_in_dos && s > 127) { /* translate ANSI to DOS 850 */
if (wintodos[s-128] > 0) print_char (wintodos[s-128]);
incr(j);
}
}
- }
- else print_char(s); /* don't translate to hex */
- }
- else { /* not just a character */
+ } else print_char(s); /* don't translate to hex */
+ } else { /* not just a character */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
j = str_start[s];
while(j < str_start[s + 1]){
}
void print_string_ (unsigned char *s)
{
- // 2000 Jun 18
while (*s > 0) print_char(*s++);
}
/* sec 0060 */
// print string number s from string pool by calling print_
-void slow_print_(integer s)
-{
- pool_pointer j;
- if((s >= str_ptr)||(s < 256)) print(s);
+void slow_print_ (integer s)
+{
+ pool_pointer j;
+ if ((s >= str_ptr) || (s < 256)) print(s);
else {
- j = str_start[s];
- while(j < str_start[s + 1]){
-// if (str_pool[j]>= 128) print(str_pool[j]-128); // debugging only
-// if (str_pool[j]== 0) print(36); // debugging only
- print(str_pool[j]);
- incr(j);
- }
- }
-}
+ j = str_start[s];
+ while (j < str_start[s + 1]) {
+// if (str_pool[j]>= 128) print(str_pool[j]-128); // debugging only
+// if (str_pool[j]== 0) print(36); // debugging only
+ print(str_pool[j]);
+ incr(j);
+ }
+ }
+}
/* sec 0062 */
// print newline followed by string number s (unless at start of line)
-void print_nl_(char * s)
-{
- if(((term_offset > 0) && (odd(selector)))||
- ((file_offset > 0) && (selector >= log_only)))
- print_ln ();
- print_string(s);
-}
+void print_nl_ (char * s)
+{
+ if (((term_offset > 0) && (odd(selector))) ||
+ ((file_offset > 0) && (selector >= log_only)))
+ print_ln ();
+ print_string(s);
+}
/* sec 0063 */
// print string number s preceded by escape character
-void print_esc_(char * s)
-{
- integer c;
- c = eqtb[(hash_size + 3208)].cint;
+void print_esc_ (char * s)
+{
+ integer c;
+ c = eqtb[(hash_size + 3208)].cint;
if(c >= 0)
- if(c < 256) print(c);
- //slow_print(s);
+ if(c < 256) print(c);
+ //slow_print(s);
print_string(s);
}
/* sec 0064 */
-void print_the_digs_(eight_bits k)
-{
- while(k > 0){
- decr(k);
+void print_the_digs_ (eight_bits k)
+{
+ while (k > 0) {
+ decr(k);
if(dig[k]< 10)
- print_char(48 + dig[k]);
+ print_char('0' + dig[k]);
else
- print_char(55 + dig[k]);
- }
-}
+ print_char('A' + dig[k]);
+ }
+}
/* sec 0065 */
-void print_int_(integer n)
+void print_int_ (integer n)
{
- char k;
- integer m;
- k = 0;
- if(n < 0)
- {
- print_char(45); /* - */
+ char k;
+ integer m;
+ k = 0;
+ if (n < 0) {
+ print_char('-');
if(n > -100000000L)
- n = - (integer) n;
+ n = - (integer) n;
else {
- m = -1 - n;
- n = m / 10;
- m =(m % 10)+ 1;
- k = 1;
+ m = -1 - n;
+ n = m / 10;
+ m =(m % 10)+ 1;
+ k = 1;
if(m < 10)
-/* dig[0]= m; */ /* keep compiler happy */
- dig[0]= (char) m;
+ dig[0]= (char) m;
else {
- dig[0]= 0;
- incr(n);
- }
- }
- }
+ dig[0]= 0;
+ incr(n);
+ }
+ }
+ }
do {
-/* dig[k]= n % 10; */ /* keep compiler happy */
- dig[k]= (char) (n % 10);
- n = n / 10;
- incr(k);
- } while(!(n == 0));
- print_the_digs(k);
-}
+ dig[k]= (char) (n % 10);
+ n = n / 10;
+ incr(k);
+ } while(!(n == 0));
+ print_the_digs(k);
+}
/* sec 0262 */
-void print_cs_(integer p)
-{
- if(p < 514) /* if p < hash_base then ... p.262 */
- if(p >= 257) /* if p > single_base then ... p.262 */
- if(p == 513) /* if p = null_cs then ... p.262 */
+void print_cs_ (integer p)
+{
+ if (p < 514) /* if p < hash_base then ... p.262 */
+ if (p >= 257) /* if p > single_base then ... p.262 */
+ if (p == 513) /* if p = null_cs then ... p.262 */
{
print_esc("csname");
print_esc("endcsname");
- print_char(' ');
- }
- else {
+ print_char(' ');
+ } else {
//print_esc(p - 257); /* p - single_base */
- print_esc("");print(p - 257);
+ print_esc("");print(p - 257);
/* if cat_code(p - single_base) = letter then ... p.262 */
if(eqtb[(hash_size + 1883) + p - 257].hh.v.RH == 11)
print_char(' ');
}
- else if(p < 1)
+ else if (p < 1)
print_esc("IMPOSSIBLE.");
else print(p - 1);
- else if(p >= (hash_size + 781)) /* undefined_control_sequence */
+ else if (p >= (hash_size + 781)) /* undefined_control_sequence */
print_esc("IMPOSSIBLE.");
- else if((hash[p].v.RH >= str_ptr))
+ else if ((hash[p].v.RH >= str_ptr))
print_esc("NONEXISTENT.");
else {
//print_esc(hash[p].v.RH);
- print_esc(""); print(hash[p].v.RH);
+ print_esc(""); print(hash[p].v.RH);
print_char(32); /* */
- }
-}
+ }
+}
/* sec 0263 */
void sprint_cs_(halfword p)
{
//print_esc(p - 257); /* print (p - single_base); */
{print_esc(""); print(p-257);}
else {
- print_esc("csname"); /* */
- print_esc("endcsname"); /* */
+ print_esc("csname");
+ print_esc("endcsname");
}
else //print_esc(hash[p].v.RH);
{
- print_esc(""); print(hash[p].v.RH);
+ print_esc(""); print(hash[p].v.RH);
}
}
/* sec 0518 */
void print_write_whatsit_(str_number s, halfword p)
{
//print_esc(s);
- print_esc(""); print(s);
- if(mem[p + 1].hh.v.LH < 16)
+ print_esc(""); print(s);
+ if (mem[p + 1].hh.v.LH < 16)
print_int(mem[p + 1].hh.v.LH);
- else if(mem[p + 1].hh.v.LH == 16)
- print_char(42); /* * */
- else print_char(45); /* - */
+ else if (mem[p + 1].hh.v.LH == 16)
+ print_char('*');
+ else print_char('-');
}
#ifdef DEBUG
#endif /* DEBUG */
#ifndef _WINDOWS
fflush(stdout);
#endif
- ready_already = 0;
+ ready_already = 0;
if (trace_flag) show_line("EXITING at JUMPOUT\n", 0);
// abort_flag++; // TURN OFF THE POWER ???
- if((history != 0)&&(history != 1)) code = 1;
- else code = 0;
+ if ((history != 0) && (history != 1))
+ code = 1;
+ else
+ code = 0;
uexit(code);
// longjmp(jumpbuffer, code+1);
}
/* sec 0082 */
// deal with error by asking for user response 0-9, D, E, H, I, X, Q, R, S
// NOTE: this may JUMPOUT either via X, or because of too many errors
-void error(void)
+void error (void)
{/* 22 10 */
ASCII_code c;
integer s1, s2, s3, s4;
- if(history < 2) history = 2;
+ if (history < 2) history = 2;
- print_char(46); /* . */
- show_context ();
+ print_char('.');
+ show_context();
- if(interaction == 3)
- while(true){
+ if (interaction == 3)
+ while (true) {
lab22: /* loop */
- clear_for_error_prompt ();
+ clear_for_error_prompt ();
{
- ;
+ ;
print_string("? ");
- term_input(264, help_ptr);
+ term_input(264, help_ptr);
}
- if(last == first)return; // no input
+ if (last == first) return; // no input
c = buffer[first]; // analyze first letter typed
if(c >= 97) // uppercase letter first
-/* c = c - 32; */ /* keep compiler happy */
c = (unsigned char) (c - 32);
- switch(c){
- case 48 : /* 0 */
- case 49 : /* 1 */
- case 50 :
- case 51 :
- case 52 :
- case 53 :
- case 54 :
- case 55 :
- case 56 :
- case 57 : /* 9 */
+ switch (c) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
if(deletions_allowed) {
s1 = cur_tok;
s2 = cur_cmd;
s4 = align_state;
align_state = 1000000L;
OK_to_interrupt = false;
- if((last > first + 1)&&(buffer[first + 1]>= 48)&&
- (buffer[first + 1]<= 57))
+ if ((last > first + 1) && (buffer[first + 1]>= 48) && (buffer[first + 1]<= 57))
c = (unsigned char) (c * 10 + buffer[first + 1]- 48 * 11);
- else c = (unsigned char) (c - 48);
- while(c > 0){
- get_token ();
- decr(c);
- }
- cur_tok = s1;
- cur_cmd = s2;
- cur_chr = s3;
- align_state = s4;
+ else
+ c = (unsigned char) (c - 48);
+ while (c > 0) {
+ get_token ();
+ decr(c);
+ }
+ cur_tok = s1;
+ cur_cmd = s2;
+ cur_chr = s3;
+ align_state = s4;
OK_to_interrupt = true;
- help2("I have just deleted some text, as you asked.",
- "You can now delete more, or insert, or whatever.");
- show_context ();
+ help2("I have just deleted some text, as you asked.",
+ "You can now delete more, or insert, or whatever.");
+ show_context ();
goto lab22; /* loop again */
}
break;
;
#ifdef DEBUG
- case 68 : /* D */
- {
- debug_help ();
- goto lab22; /* loop again */
- }
- break;
+ case 'D':
+ {
+ debug_help ();
+ goto lab22; /* loop again */
+ }
+ break;
#endif /* DEBUG */
- case 69 : /* E */
- if(base_ptr > 0){
- edit_name_start = str_start[input_stack[base_ptr].name_field];
- edit_name_length = str_start[input_stack[base_ptr].name_field + 1]-
- str_start[input_stack[base_ptr].name_field];
- edit_line = line;
+ case 'E':
+ if (base_ptr > 0) {
+ edit_name_start = str_start[input_stack[base_ptr].name_field];
+ edit_name_length = str_start[input_stack[base_ptr].name_field + 1] -
+ str_start[input_stack[base_ptr].name_field];
+ edit_line = line;
jump_out();
// return; // can drop through now 99/Oct/20
- }
- break;
- case 72 : /* H */
- {
- if(use_err_help)
+ }
+ break;
+ case 'H':
{
- give_err_help ();
- use_err_help = false;
- }
- else {
- if(help_ptr == 0)
- help2("Sorry, I don't know how to help in this situation.",
- "Maybe you should try asking a human?");
- do {
- decr(help_ptr);
- //print(help_line[help_ptr]);
- print_string(help_line[help_ptr]);
- print_ln ();
- } while(!(help_ptr == 0));
+ if (use_err_help)
+ {
+ give_err_help ();
+ use_err_help = false;
+ } else {
+ if (help_ptr == 0)
+ help2("Sorry, I don't know how to help in this situation.",
+ "Maybe you should try asking a human?");
+ do {
+ decr(help_ptr);
+ print_string(help_line[help_ptr]);
+ print_ln ();
+ } while (!(help_ptr == 0));
+ }
+ help4("Sorry, I already gave what help I could...",
+ "Maybe you should try asking a human?",
+ "An error might have occurred before I noticed any problems.",
+ "``If all else fails, read the instructions.''");
+ goto lab22; /* loop again */
}
- help4("Sorry, I already gave what help I could...",
- "Maybe you should try asking a human?",
- "An error might have occurred before I noticed any problems.",
- "``If all else fails, read the instructions.''");
- goto lab22; /* loop again */
- }
- break;
- case 73 : /* I */
- {
- begin_file_reading ();
- if(last > first + 1)
+ break;
+ case 'I':
{
- cur_input.loc_field = first + 1;
- buffer[first]= 32;
- }
- else {
+ begin_file_reading ();
+ if (last > first + 1)
{
- ;
- print_string("insert>");
- term_input(276, 0);
- }
- cur_input.loc_field = first;
- }
- first = last;
- cur_input.limit_field = last - 1;
- return;
- }
- break;
- case 81 : /* Q, R, S */
- case 82 :
- case 83 :
+ cur_input.loc_field = first + 1;
+ buffer[first]= 32;
+ } else {
+ {
+ ;
+ print_string("insert>");
+ term_input(276, 0);
+ }
+ cur_input.loc_field = first;
+ }
+ first = last;
+ cur_input.limit_field = last - 1;
+ return;
+ }
+ break;
+ case 'Q':
+ case 'R':
+ case 'S':
{
error_count = 0;
interaction = 0 + c - 81; /* Q = 0, R = 1, S = 2, T = 3 */
help2("If you really absolutely need more capacity,",
"you can ask a wizard to enlarge me.");
if (! knuth_flag) { /* Additional comments 98/Jan/5 */
- //if (s == 945 && n == trie_size) {
- if (!strcmp(s, "pattern memory") && n == trie_size) {
+ if (!strcmp(s, "pattern memory") && n == trie_size) {
sprintf(log_line, "\n (Maybe use -h=... on command line in ini-TeX)\n");
show_line(log_line, 0);
- }
- //else if (s == 942 && n == hyphen_prime) {
- else if (!strcmp(s, "exception dictionary") && n == hyphen_prime) {
+ } else if (!strcmp(s, "exception dictionary") && n == hyphen_prime) {
sprintf(log_line, "\n (Maybe use -e=... on command line in ini-TeX)\n");
show_line(log_line, 0);
}
}
- if (interaction == 3) interaction = 2;
- if(log_opened){
+ if (interaction == 3)
+ interaction = 2;
+ if (log_opened) {
error ();
}
;
#ifdef DEBUG
- if(interaction > 0)debug_help ();
-#endif /* DEBUG */
- history = 3;
+ if (interaction > 0)
+ debug_help ();
+#endif
+ history = 3;
jump_out();
-// return; // can drop through now 99/Oct/20
}
/* sec 0095 */
void confusion_(str_number s)
{
normalize_selector ();
- if(history < 2) {
+ if (history < 2) {
print_err("This can't happen(");
print(s);
print_char(41); /*)*/
help1("I'm broken. Please show this to someone who can fix can fix");
- }
- else {
+ } else {
print_err("I can't go on meeting you like this");
help2("One of your faux pas seems to have wounded me deeply...",
"in fact, I'm barely conscious. Please fix it and try again.");
- }
+ }
{
- if(interaction == 3)interaction = 2;
- if(log_opened){
- error ();
+ if (interaction == 3)
+ interaction = 2;
+ if (log_opened) {
+ error();
}
;
#ifdef DEBUG
- if(interaction > 0)debug_help ();
-#endif /* DEBUG */
- history = 3;
+ if (interaction > 0)
+ debug_help();
+#endif
+ history = 3;
jump_out();
-// return; // can drop through now 99/Oct/20
- }
-}
+ }
+}
/* sec 0037 */
bool init_terminal (void)
{/* 10 */
register bool Result;
int flag;
- t_open_in ();
+ t_open_in();
- if(last > first) {
+ if (last > first) {
cur_input.loc_field = first;
while((cur_input.loc_field < last) && (buffer[cur_input.loc_field]== ' '))
incr(cur_input.loc_field); // step over initial white space
while(true){
;
#ifdef _WINDOWS
- flag = ConsoleInput("**", "Please type a file name or a control sequence\r\n(or ^z to exit)",
- (char *) &buffer[first]);
+ flag = ConsoleInput("**", "Please type a file name or a control sequence\r\n(or ^z to exit)", (char *) &buffer[first]);
last = first + strlen((char *) &buffer[first]); /* -1 ? */
// may need to be more elaborate see input_line in texmf.c
#else
- (void) fputs("**", stdout); /* ** PROMPT */
+ (void) fputs("**", stdout);
fflush(stdout);
flag = input_ln(stdin, true);
#endif
if(! flag){
show_char('\n');
- show_line("! End of file on the terminal... why?\n", 1);
- Result = false;
- return Result;
- }
+ show_line("! End of file on the terminal... why?\n", 1);
+ Result = false;
+ return Result;
+ }
- cur_input.loc_field = first;
- while((cur_input.loc_field < last)&&
- (buffer[cur_input.loc_field]== ' '))
+ cur_input.loc_field = first;
+ while ((cur_input.loc_field < last) && (buffer[cur_input.loc_field]== ' '))
incr(cur_input.loc_field); // step over intial white space
- if(cur_input.loc_field < last){
- Result = true;
+ if (cur_input.loc_field < last) {
+ Result = true;
return Result; // there is an input file name
}
- sprintf(log_line, "%s\n", "Please type the name of your input file.");
+ sprintf(log_line, "%s\n", "Please type the name of your input file.");
show_line(log_line, 1);
}
-// return Result;
-}
+}
/* sec 0043 */
// Make string from str_start[str_ptr]to pool_ptr
-str_number make_string (void)
+str_number make_string (void)
{
register str_number Result;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
#ifdef ALLOCATESTRING
- if(str_ptr == current_max_strings)
+ if (str_ptr == current_max_strings)
str_start = realloc_str_start(increment_max_strings);
- if(str_ptr == current_max_strings){ /* 94/Jan/24 */
-// printf("**********MAKESTRING**********"); // debugging only
+ if (str_ptr == current_max_strings) {
+// printf("**********MAKESTRING**********"); // debugging only
overflow("number of strings", current_max_strings - init_str_ptr); /* 97/Mar/9 */
return 0; // abort_flag set
}
#else
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- if(str_ptr == max_strings){
+ if (str_ptr == max_strings) {
overflow("number of strings", max_strings - init_str_ptr); /* number of strings */
return 0; // abort_flag set
}
#endif
incr(str_ptr);
- str_start[str_ptr] = pool_ptr;
- Result = str_ptr - 1;
- return Result;
+ str_start[str_ptr] = pool_ptr;
+ Result = str_ptr - 1;
+ return Result;
}
/* sec 0044 */
-bool str_eq_buf_(str_number s, integer k)
-{/* 45 */
- register bool Result;
- pool_pointer j;
- bool result;
- j = str_start[s];
- while(j < str_start[s + 1]) {
- if(str_pool[j]!= buffer[k])
+bool str_eq_buf_ (str_number s, integer k)
+{
+ register bool Result;
+ pool_pointer j;
+ bool result;
+ j = str_start[s];
+ while (j < str_start[s + 1]) {
+ if (str_pool[j]!= buffer[k])
{
- result = false;
- goto lab45;
+ result = false;
+ goto lab45;
}
- incr(j);
- incr(k);
+ incr(j);
+ incr(k);
}
- result = true;
- lab45: Result = result;
+ result = true;
+lab45: Result = result;
return Result;
}
/* sec 0045 */
-bool str_eq_str_(str_number s, str_number t)
-{/* 45 */
- register bool Result;
- pool_pointer j, k;
- bool result;
- result = false;
- if((str_start[s + 1]- str_start[s])!=(str_start[t + 1]-
- str_start[t]))
- goto lab45;
- j = str_start[s];
- k = str_start[t];
- while(j < str_start[s + 1]){
- if(str_pool[j]!= str_pool[k])
- goto lab45;
- incr(j);
- incr(k);
- }
- result = true;
- lab45: Result = result;
- return Result;
-}
+bool str_eq_str_ (str_number s, str_number t)
+{
+ register bool Result;
+ pool_pointer j, k;
+ bool result;
+ result = false;
+ if ((str_start[s + 1] - str_start[s]) != (str_start[t + 1] - str_start[t]))
+ goto lab45;
+ j = str_start[s];
+ k = str_start[t];
+ while (j < str_start[s + 1]) {
+ if (str_pool[j] != str_pool[k])
+ goto lab45;
+ incr(j);
+ incr(k);
+ }
+ result = true;
+ lab45: Result = result;
+ return Result;
+}
/* sec 0066 */
void print_two_(integer n)
{
- n = abs(n) % 100;
- print_char(48 +(n / 10));
- print_char(48 +(n % 10));
+ n = abs(n) % 100;
+ print_char('0' + (n / 10));
+ print_char('0' + (n % 10));
}
/* sec 0067 */
void print_hex_(integer n)
{
- char k;
- k = 0;
- print_char(34); /* " */
+ char k;
+ k = 0;
+ print_char('"');
do {
- dig[k]= (unsigned char) (n % 16);
- n = n / 16;
- incr(k);
- } while(!(n == 0));
- print_the_digs(k);
-}
+ dig[k] = (unsigned char) (n % 16);
+ n = n / 16;
+ incr(k);
+ } while (!(n == 0));
+ print_the_digs(k);
+}
/* sec 0069 */
void print_roman_int_(integer n)
-{/* 10 */
- pool_pointer j, k;
- nonnegative_integer u, v;
+{
+ pool_pointer j, k;
+ nonnegative_integer u, v;
j = str_start[260]; /* m2d5c2l5x2v5i */
- v = 1000;
- while(true){
- while(n >= v){
- print_char(str_pool[j]);
- n = n - v;
+ v = 1000;
+ while (true) {
+ while (n >= v) {
+ print_char(str_pool[j]);
+ n = n - v;
}
- if(n <= 0)
- return;
- k = j + 2;
- u = v /(str_pool[k - 1]- 48);
- if(str_pool[k - 1]== 50)
+ if (n <= 0)
+ return;
+ k = j + 2;
+ u = v / (str_pool[k - 1]- 48);
+ if (str_pool[k - 1]== 50)
{
- k = k + 2;
- u = u /(str_pool[k - 1]- 48);
- }
- if(n + u >= v)
+ k = k + 2;
+ u = u / (str_pool[k - 1]- 48);
+ }
+ if (n + u >= v)
{
- print_char(str_pool[k]);
- n = n + u;
- }
- else {
- j = j + 2;
- v = v /(str_pool[j - 1]- 48);
- }
- }
-}
+ print_char(str_pool[k]);
+ n = n + u;
+ } else {
+ j = j + 2;
+ v = v / (str_pool[j - 1]- 48);
+ }
+ }
+}
/* sec 0070 */
-void print_current_string(void)
+void print_current_string (void)
{
pool_pointer j;
j = str_start[str_ptr];
- while(j < pool_ptr) {
+ while (j < pool_ptr) {
print_char(str_pool[j]);
incr(j);
}
int stringlength (int str_ptr)
{
int nstart, nnext;
- nstart = str_start[ str_ptr];
- nnext = str_start[ str_ptr + 1];
+ nstart = str_start[str_ptr];
+ nnext = str_start[str_ptr + 1];
return (nnext - nstart) + 2;
}
char * add_string (char *s, int str_ptr)
{
int nstart, nnext, n;
- nstart = str_start[ str_ptr];
- nnext = str_start[ str_ptr + 1];
+ nstart = str_start[str_ptr];
+ nnext = str_start[str_ptr + 1];
n = nnext - nstart;
memcpy(s, &str_pool[nstart], n);
s += n;
char * make_up_help_string (int nhelplines)
{
- char *helpstring, *s;
+ char * helpstring, *s;
int k, nlen=0;
// get length of help for this specific message
for (k = nhelplines-1; k >= 0; k--) {
- nlen += stringlength(help_line[k]);
+ //nlen += stringlength(help_line[k]);
+ nlen += strlen(help_line[k]);
}
nlen += 2; // for blank line separator
if (addextrahelp) {
return helpstring;
}
-char * make_up_query_string (int promptstr)
+char * make_up_query_string (int promptstr)
{
char *querystr;
int nstart, nnext, n;
memcpy(s, &str_pool[nstart], n);
s += n;
*s = '\0';
- return querystr;
+ return querystr;
}
// abort_flag set if input_line / ConsoleInput returns non-zero
{
integer k;
int flag;
- char *helpstring = NULL;
- char *querystring = NULL;
+ char * helpstring = NULL;
+ char * querystring = NULL;
// if (nhelplines != 0) {
// helpstring = make_up_help_string (nhelplines);
// printf(helpstring);
print_ln ();
incr(selector); // reset selector again
#endif
-}
-
-void int_error_ (integer n)
+}
+/* sec 0091 */
+void int_error_ (integer n)
{
print_string(" (");
- print_int(n);
- print_char(41); /*)*/
- error();
-}
-
-void normalize_selector (void)
+ print_int(n);
+ print_char(')');
+ error();
+}
+/* sec 0092 */
+void normalize_selector (void)
{
if (log_opened)
selector = 19;
else
selector = 17;
if (job_name == 0)
- open_log_file ();
+ open_log_file();
if (interaction == 0)
decr(selector);
}
-
-void pause_for_instructions (void)
+/* sec 0098 */
+void pause_for_instructions (void)
{
if (OK_to_interrupt) {
- interaction = 3;
- if((selector == 18)||(selector == 16))
+ interaction = 3;
+ if ((selector == 18)||(selector == 16))
incr(selector);
print_err("Interruption");
help3("You rang?",
"Try to insert some instructions for me (e.g.,`I\\showlists'),",
"unless you just want to quit by typing `X'.");
- deletions_allowed = false;
- error ();
- deletions_allowed = true;
- interrupt = 0;
- }
-}
-
+ deletions_allowed = false;
+ error ();
+ deletions_allowed = true;
+ interrupt = 0;
+ }
+}
+/* sec 0100 */
integer half_(integer x)
{
register integer Result;
- if(odd(x))
- Result =(x + 1)/ 2;
- else Result = x / 2;
- return Result;
-}
-
+ if (odd(x))
+ Result =(x + 1)/ 2;
+ else Result = x / 2;
+ return Result;
+}
+/* sec 0102 */
scaled round_decimals_(small_number k)
{
- register scaled Result;
- integer a;
- a = 0;
- while(k > 0){
- decr(k);
- a =(a + dig[k]* 131072L)/ 10; /* 2^17 */
- }
- Result =(a + 1)/ 2;
- return Result;
-}
-
+ register scaled Result;
+ integer a;
+ a = 0;
+ while (k > 0) {
+ decr(k);
+ a = (a + dig[k]* 131072L) / 10; /* 2^17 */
+ }
+ Result =(a + 1)/ 2;
+ return Result;
+}
+/* sec 0103 */
/* This has some minor speedup changes - no real advantage probably ... */
void print_scaled_(scaled s)
{
scaled delta;
- if(s < 0)
+ if (s < 0)
{
- print_char(45); /* '-' */
- s = - (integer) s;
- }
- print_int(s / 65536L);
- print_char(46); /* '.' */
- s = 10 *(s % 65536L)+ 5;
- delta = 10;
+ print_char('-');
+ s = - (integer) s;
+ }
+ print_int(s / 65536L);
+ print_char('.');
+ s = 10 * (s % 65536L) + 5;
+ delta = 10;
do {
- if(delta > 65536L)
- s = s - 17232; /* 2^15 - 50000 - rounding */
- print_char(48 +(s / 65536L)); /* '0' + */
- s = 10 *(s % 65536L);
- delta = delta * 10;
- } while(!(s <= delta));
-}
-
+ if (delta > 65536L)
+ s = s - 17232; /* 2^15 - 50000 - rounding */
+ print_char('0' + (s / 65536L));
+ s = 10 * (s % 65536L);
+ delta = delta * 10;
+ } while (!(s <= delta));
+}
+/* sec 0105 */
scaled mult_and_add_(integer n, scaled x, scaled y, scaled maxanswer)
{
register scaled Result;
- if(n < 0)
+ if (n < 0)
{
- x = - (integer) x;
- n = - (integer) n;
- }
- if(n == 0)
- Result = y;
- else if(((x <=(maxanswer - y)/ n)&&(- (integer) x <=(maxanswer + y)/ n)))
- Result = n * x + y;
+ x = - (integer) x;
+ n = - (integer) n;
+ }
+ if (n == 0)
+ Result = y;
+ else if(((x <= (maxanswer - y) / n) && (- (integer) x <= (maxanswer + y) / n)))
+ Result = n * x + y;
else {
- arith_error = true;
- Result = 0;
- }
- return Result;
-}
-
+ arith_error = true;
+ Result = 0;
+ }
+ return Result;
+}
+/* sec 0106 */
scaled x_over_n_(scaled x, integer n)
{
- register scaled Result;
- bool negative;
- negative = false;
- if(n == 0)
+ register scaled Result;
+ bool negative;
+ negative = false;
+ if (n == 0)
{
- arith_error = true;
- Result = 0;
- tex_remainder = x;
- }
- else {
-
- if(n < 0)
+ arith_error = true;
+ Result = 0;
+ tex_remainder = x;
+ } else {
+ if (n < 0)
{
- x = - (integer) x;
- n = - (integer) n;
- negative = true;
- }
- if(x >= 0)
+ x = - (integer) x;
+ n = - (integer) n;
+ negative = true;
+ }
+ if (x >= 0)
{
- Result = x / n;
- tex_remainder = x % n;
- }
- else {
-
- Result = - (integer)((- (integer) x)/ n);
- tex_remainder = - (integer)((- (integer) x)% n);
- }
- }
- if(negative)
- tex_remainder = - (integer) tex_remainder;
- return Result;
-}
-
+ Result = x / n;
+ tex_remainder = x % n;
+ } else {
+ Result = - (integer) ((- (integer) x)/ n);
+ tex_remainder = - (integer) ((- (integer) x)% n);
+ }
+ }
+ if (negative)
+ tex_remainder = - (integer) tex_remainder;
+ return Result;
+}
+/* sec 0107 */
scaled xn_over_d_(scaled x, integer n, integer d)
{
- register scaled Result;
- bool positive;
- nonnegative_integer t, u, v;
- if(x >= 0)
- positive = true;
+ register scaled Result;
+ bool positive;
+ nonnegative_integer t, u, v;
+ if (x >= 0)
+ positive = true;
else {
-
- x = - (integer) x;
- positive = false;
- }
+ x = - (integer) x;
+ positive = false;
+ }
/* t =(x % 32768L)* n; */
- t =(x & 32767L)* n;
+ t =(x & 32767L) * n;
/* u =(x / 32768L)* n +(t / 32768L); */
- u =(x >> 15)* n +(t >> 15);
+ u =(x >> 15) * n + (t >> 15);
/* v =(u % d)* 32768L +(t % 32768L); */
- v =((u % d)<< 15)+(t & 32767L);
- if(u / d >= 32768L)
- arith_error = true;
+ v =((u % d) << 15) + (t & 32767L);
+ if (u / d >= 32768L)
+ arith_error = true;
/* else u = 32768L *(u / d)+(v / d); */
- else u =((u / d)<< 15)+(v / d);
- if(positive)
+ else u =((u / d) << 15) + (v / d);
+ if (positive)
{
- Result = u;
- tex_remainder = v % d;
- }
- else {
-
- Result = - (integer) u;
- tex_remainder = - (integer)(v % d);
- }
- return Result;
-}
-
+ Result = u;
+ tex_remainder = v % d;
+ } else {
+ Result = - (integer) u;
+ tex_remainder = - (integer)(v % d);
+ }
+ return Result;
+}
+/* sec 0108 */
halfword badness_(scaled t, scaled s)
{
register halfword Result;
- integer r;
- if(t == 0)
- Result = 0;
- else if(s <= 0)
- Result = 10000;
- else {
- if(t <= 7230584L)
- r =(t * 297)/ s;
- else if(s >= 1663497L)
- r = t /(s / 297);
- else r = t;
- if(r > 1290)
+ integer r;
+ if (t == 0)
+ Result = 0;
+ else if (s <= 0)
Result = 10000;
+ else {
+ if (t <= 7230584L)
+ r = (t * 297) / s;
+ else if (s >= 1663497L)
+ r = t / (s / 297);
+ else
+ r = t;
+ if (r > 1290)
+ Result = 10000;
/* safe to assume that r is positive ? */
/* else Result =(r * r * r + 131072L)/ 262144L; */
- else Result =(r * r * r + 131072L)>> 18; /* 2^17 */
- }
- return Result;
-}
+ else Result = (r * r * r + 131072L) >> 18; /* 2^17 */
+ }
+ return Result;
+}
#ifdef DEBUG
void print_word_(memory_word w)
{
print_int(w.cint);
- print_char(32); /* */
+ print_char(' ');
print_scaled(w.cint);
- print_char(32); /* */
- print_scaled(round(65536L * w.gr));
- print_ln ();
- print_int(w.hh.v.LH);
- print_char(61); /* = */
- print_int(w.hh.b0);
- print_char(58); /* : */
- print_int(w.hh.b1);
- print_char(59); /*; */
- print_int(w.hh.v.RH);
- print_char(32); /* */
+ print_char(' ');
+ print_scaled(round(65536L * w.gr));
+ print_ln ();
+ print_int(w.hh.v.LH);
+ print_char('=');
+ print_int(w.hh.b0);
+ print_char(':');
+ print_int(w.hh.b1);
+ print_char(';');
+ print_int(w.hh.v.RH);
+ print_char(' ');
print_int(w.qqqq.b0);
- print_char(58); /* : */
+ print_char(':');
print_int(w.qqqq.b1);
- print_char(58); /* : */
+ print_char(':');
print_int(w.qqqq.b2);
- print_char(58); /* : */
- print_int(w.qqqq.b3);
+ print_char(':');
+ print_int(w.qqqq.b3);
}
-
/* need this version only if SHORTFONTINFO defined */
-
void zprintfword(fmemoryword w)
{
print_int(w.cint);
- print_char(32); /* */
- print_scaled(w.cint);
- print_char(32); /* */
- print_scaled(round(65536L * w.gr));
- print_ln ();
- print_int(w.hh.v.LH);
- print_char(61); /* = */
- print_int(w.hh.b0);
- print_char(58); /* : */
- print_int(w .hh.b1);
- print_char(59); /*; */
- print_int(w.hh.v.RH);
- print_char(32); /* */
- print_int(w.qqqq.b0);
- print_char(58); /* : */
- print_int(w.qqqq.b1);
- print_char(58); /* : */
- print_int(w.qqqq.b2);
- print_char(58); /* : */
- print_int(w.qqqq.b3);
-}
-#endif /* DEBUG */
+ print_char(' ');
+ print_scaled(w.cint);
+ print_char(' ');
+ print_scaled(round(65536L * w.gr));
+ print_ln ();
+ print_int(w.hh.v.LH);
+ print_char('=');
+ print_int(w.hh.b0);
+ print_char(':');
+ print_int(w .hh.b1);
+ print_char(';');
+ print_int(w.hh.v.RH);
+ print_char(' ');
+ print_int(w.qqqq.b0);
+ print_char(':');
+ print_int(w.qqqq.b1);
+ print_char(':');
+ print_int(w.qqqq.b2);
+ print_char(':');
+ print_int(w.qqqq.b3);
+}
+#endif
void show_token_list_(integer p, integer q, integer l)
-{/* 10 */
- integer m, c;
- ASCII_code matchchr;
- ASCII_code n;
- matchchr = 35;
- n = 48;
- tally = 0;
+{
+ integer m, c;
+ ASCII_code matchchr;
+ ASCII_code n;
+ matchchr = 35;
+ n = 48;
+ tally = 0;
/* while (p<>null) and (tally<l) do l.6239 */
- while((p != 0)&&(tally < l)) {
-
- if(p == q)
+ while ((p != 0) && (tally < l)) {
+ if (p == q)
{
- first_count = tally;
- trick_count = tally + 1 + error_line - half_error_line;
- if(trick_count < error_line)
- trick_count = error_line;
- }
- if((p < hi_mem_min)||(p > mem_end))
+ first_count = tally;
+ trick_count = tally + 1 + error_line - half_error_line;
+ if (trick_count < error_line)
+ trick_count = error_line;
+ }
+ if ((p < hi_mem_min) || (p > mem_end))
{
- print_esc("CLOBBERED."); /* */
- return;
- }
- if(mem[p].hh.v.LH >= 4095)
- print_cs(mem[p].hh.v.LH - 4095);
- else {
-
- m = mem[p].hh.v.LH / 256;
-/* m = mem[p].hh.v.LH >> 8; */
- c = mem[p].hh.v.LH % 256;
-/* c = mem[p].hh.v.LH & 255; */
- if(mem[p].hh.v.LH < 0)
- print_esc("BAD."); /* */
- else switch(m)
- {case 1 :
- case 2 :
- case 3 :
- case 4 :
- case 7 :
- case 8 :
- case 10 :
- case 11 :
- case 12 :
- print(c);
- break;
- case 6 :
- {
- print(c);
- print(c);
- }
- break;
- case 5 :
- {
- print(matchchr);
- if(c <= 9)
- print_char(c + 48);
+ print_esc("CLOBBERED.");
+ return;
+ }
+ if (mem[p].hh.v.LH >= 4095)
+ print_cs(mem[p].hh.v.LH - 4095);
else {
- print_char(33); /* ! */
- return;
- }
- }
- break;
- case 13 :
- {
-/* matchchr = c; */ /* keep compiler happy */
- matchchr = (ASCII_code) c;
- print(c);
- incr(n);
- print_char(n);
- if(n > 57)
- return;
- }
- break;
- case 14 :
- print_string("->");
- break;
- default:
- print_esc("BAD. ");
- break;
- }
- }
+ m = mem[p].hh.v.LH / 256;
+ c = mem[p].hh.v.LH % 256;
+ if (mem[p].hh.v.LH < 0)
+ print_esc("BAD.");
+ else
+ switch (m)
+ {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 7:
+ case 8:
+ case 10:
+ case 11:
+ case 12:
+ print(c);
+ break;
+ case 6:
+ {
+ print(c);
+ print(c);
+ }
+ break;
+ case 5:
+ {
+ print(matchchr);
+ if (c <= 9)
+ print_char(c + '0');
+ else {
+ print_char('!');
+ return;
+ }
+ }
+ break;
+ case 13:
+ {
+ matchchr = (ASCII_code) c;
+ print(c);
+ incr(n);
+ print_char(n);
+ if (n > 57)
+ return;
+ }
+ break;
+ case 14:
+ print_string("->");
+ break;
+ default:
+ print_esc("BAD. ");
+ break;
+ }
+ }
p = mem[p].hh.v.RH;
}
/* if p<>null then print_esc("ETC."); l.6244 */
- if(p != 0)
- print_esc("ETC."); /* */
-}
-
-void runaway (void)
+ if (p != 0)
+ print_esc("ETC.");
+}
+/* sec 0306 */
+void runaway (void)
{
- halfword p;
- if(scanner_status > 1)
+ halfword p;
+ if (scanner_status > 1)
{
- print_nl("Runaway "); /* */
- switch(scanner_status)
- {case 2 :
- {
- print_string("definition");
- p = def_ref;
- }
- break;
- case 3 :
- {
- print_string("argument");
- p = mem_top - 3;
- }
- break;
- case 4 :
- {
- print_string("preamble");
- p = mem_top - 4;
- }
- break;
- case 5 :
- {
- print_string("text");
- p = def_ref;
- }
- break;
- }
- print_char(63); /* ? */
- print_ln ();
+ print_nl("Runaway ");
+ switch (scanner_status)
+ {
+ case 2:
+ {
+ print_string("definition");
+ p = def_ref;
+ }
+ break;
+ case 3:
+ {
+ print_string("argument");
+ p = temp_head;
+ }
+ break;
+ case 4:
+ {
+ print_string("preamble");
+ p = hold_head;
+ }
+ break;
+ case 5:
+ {
+ print_string("text");
+ p = def_ref;
+ }
+ break;
+ }
+ print_char('?');
+ print_ln ();
/* p may be used without being initialized -- OK */
show_token_list(mem[p].hh.v.RH, 0, error_line - 10);
- }
-}
-
+ }
+}
+/* sec 0120 */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
-/* first try list of available nodes (avail != NULL) */
-/* then see if can go upwards (mem_end < mem_max) */
-/* then see if can go downwards (hi_mem_min > lo_mem_max) */
-/* if not, extend memory at the top and grab from there --- new */
-/* else fail ! */ /* paragraph 120 */
+/* first try list of available nodes (avail != NULL) */
+/* then see if can go upwards (mem_end < mem_max) */
+/* then see if can go downwards (hi_mem_min > lo_mem_max) */
+/* if not, extend memory at the top and grab from there --- new */
+/* else fail ! paragraph 120 */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
-halfword get_avail (void)
+halfword get_avail (void)
{
- register halfword Result;
- halfword p;
- p = avail;
- if(p != 0) /* while p<>null do */
- avail = mem[avail].hh.v.RH;
- else if(mem_end < mem_max) /* mem_end + 1 < mem_max ? NO */
+ register halfword Result;
+ halfword p;
+ p = avail;
+ if (p != 0) /* while p<>null do */
+ avail = link(avail);
+ else if (mem_end < mem_max) /* mem_end + 1 < mem_max ? NO */
{
- incr(mem_end);
- p = mem_end;
- }
- else {
- decr(hi_mem_min);
- p = hi_mem_min;
+ incr(mem_end);
+ p = mem_end;
+ } else {
+ decr(hi_mem_min);
+ p = hi_mem_min;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- if(hi_mem_min <= lo_mem_max){ /* have we run out in middle ? */
- incr(hi_mem_min); /* undo the change */
+ if (hi_mem_min <= lo_mem_max) { /* have we run out in middle ? */
+ incr(hi_mem_min); /* undo the change */
/* realloc_main (0, mem_top/2); */ /* extend main memory at hi end */
- mem = realloc_main (0, mem_top/2); /* zzzaa = zmem = mem */
- if (mem == NULL) {
- return 0;
- }
+ mem = realloc_main (0, mem_top / 2); /* zzzaa = zmem = mem */
+ if (mem == NULL) {
+ return 0;
+ }
/* presumably now mem_end < mem_max - but need test in case allocation fails */
- if (mem_end >= mem_max) {
- runaway ();
- overflow("main memory size", mem_max + 1 - mem_min); /* main memory size */
- return 0; // abort_flag set
- }
- incr(mem_end); /* then grab from new area */
- p = mem_end; /* 1993/Dec/14 */
- }
+ if (mem_end >= mem_max) {
+ runaway ();
+ overflow("main memory size", mem_max + 1 - mem_min); /* main memory size */
+ return 0; // abort_flag set
+ }
+ incr(mem_end); /* then grab from new area */
+ p = mem_end; /* 1993/Dec/14 */
+ }
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- }
+ }
mem[p].hh.v.RH = 0; /* link(p) = null !!! */
;
#ifdef STAT
Result = p;
return Result;
}
-
+/* sec 0123 */
void flush_list_(halfword p) /* paragraph 123 */
{
halfword q, r;
- if(p != 0) /* null !!! */
+ if (p != 0) /* null !!! */
{
- r = p;
+ r = p;
do {
- q = r;
- r = mem[r].hh.v.RH;
- ;
+ q = r;
+ r = link(r);
+ ;
#ifdef STAT
- decr(dyn_used);
+ decr(dyn_used);
#endif /* STAT */
- } while(!(r == 0)); /* r != null */
- mem[q].hh.v.RH = avail;
- avail = p;
- }
-}
-
-halfword get_node_(integer s)
-{/* 40 10 20 */
- register halfword Result;
- halfword p;
- halfword q;
- integer r;
- integer t;
- lab20: p = rover;
+ } while (!(r == 0)); /* r != null */
+ link(q) = avail;
+ avail = p;
+ }
+}
+/* sec 0125 */
+halfword get_node_(integer s)
+{
+ register halfword Result;
+ halfword p;
+ halfword q;
+ integer r;
+ integer t;
+lab20: p = rover;
do {
- q = p + mem[p].hh.v.LH;
+ q = p + mem[p].hh.v.LH;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
/* while((mem[q].hh.v.RH == 262143L)) { */ /* NO! */
- while((mem[q].hh.v.RH == empty_flag)) {
+ while ((mem[q].hh.v.RH == empty_flag)) {
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
-
- if (q == 0) {
+ if (q == 0) {
/* should never happen, since this field is reference count for zeroglue */
- } /* debugging code 93/DEC/15 */ /* eventually remove */
-
+ } /* debugging code 93/DEC/15 */ /* eventually remove */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- t = mem[q + 1].hh.v.RH;
- if(q == rover)
- rover = t;
- mem[t + 1].hh.v.LH = mem[q + 1].hh.v.LH;
- mem[mem[q + 1].hh.v.LH + 1].hh.v.RH = t;
- q = q + mem[q].hh.v.LH;
- }
- r = q - s;
- if(r > toint(p + 1))
- {
- mem[p].hh.v.LH = r - p;
- rover = p;
- goto lab40;
- }
- if(r == p)
- if(mem[p + 1].hh.v.RH != p)
- {
- rover = mem[p + 1].hh.v.RH;
- t = mem[p + 1].hh.v.LH;
- mem[rover + 1].hh.v.LH = t;
- mem[t + 1].hh.v.RH = rover;
- goto lab40;
- }
- mem[p].hh.v.LH = q - p;
- p = mem[p + 1].hh.v.RH;
- } while(!(p == rover));
- if(s == 1073741824L) /* 2^30 - special case - merge adjacent */
+ t = mem[q + 1].hh.v.RH;
+ if (q == rover)
+ rover = t;
+ mem[t + 1].hh.v.LH = mem[q + 1].hh.v.LH;
+ mem[mem[q + 1].hh.v.LH + 1].hh.v.RH = t;
+ q = q + mem[q].hh.v.LH;
+ }
+ r = q - s;
+ if (r > toint(p + 1))
+ {
+ mem[p].hh.v.LH = r - p;
+ rover = p;
+ goto lab40;
+ }
+ if (r == p)
+ if (mem[p + 1].hh.v.RH != p)
+ {
+ rover = mem[p + 1].hh.v.RH;
+ t = mem[p + 1].hh.v.LH;
+ mem[rover + 1].hh.v.LH = t;
+ mem[t + 1].hh.v.RH = rover;
+ goto lab40;
+ }
+ mem[p].hh.v.LH = q - p;
+ p = mem[p + 1].hh.v.RH;
+ } while (!(p == rover));
+ if (s == 1073741824L) /* 2^30 - special case - merge adjacent */
{
-/* Result = 262143L; */ /* NO ! */
- Result = empty_flag;
+ Result = empty_flag;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- if (trace_flag) show_line("Merged adjacent multi-word nodes\n", 0);
+ if (trace_flag)
+ show_line("Merged adjacent multi-word nodes\n", 0);
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- return Result;
- }
+ return Result;
+ }
/* maybe try downward epxansion first instead ? */
- if(lo_mem_max + 2 < hi_mem_min)
-
+ if (lo_mem_max + 2 < hi_mem_min)
/* if(lo_mem_max + 2 <= 262143L) */ /* NO! */
- if(lo_mem_max + 2 <= mem_bot + max_halfword) /* silly ? flush 93/Dec/16 */
-
- {
+ if(lo_mem_max + 2 <= mem_bot + max_halfword) /* silly ? flush 93/Dec/16 */
+ {
/* if(hi_mem_min - lo_mem_max >= 1998) */
- if(hi_mem_min - lo_mem_max >= (block_size + block_size - 2))
+ if (hi_mem_min - lo_mem_max >= (block_size + block_size - 2))
/* t = lo_mem_max + 1000; */
- t = lo_mem_max + block_size;
- else t = lo_mem_max + 1 +(hi_mem_min - lo_mem_max)/ 2;
- p = mem[rover + 1].hh.v.LH;
- q = lo_mem_max;
- mem[p + 1].hh.v.RH = q;
- mem[rover + 1].hh.v.LH = q;
-
+ t = lo_mem_max + block_size;
+ else
+ t = lo_mem_max + 1 +(hi_mem_min - lo_mem_max) / 2;
+ p = mem[rover + 1].hh.v.LH;
+ q = lo_mem_max;
+ mem[p + 1].hh.v.RH = q;
+ mem[rover + 1].hh.v.LH = q;
/* if(t > 262143L) t = 262143L; */ /* NO! */
- if(t > mem_bot + max_halfword)
- t = mem_bot + max_halfword; /* silly ? flush 93/Dec/16 */
-
- mem[q + 1].hh.v.RH = rover;
- mem[q + 1].hh.v.LH = p;
-/* mem[q].hh.v.RH = 262143L; */ /* NO! */
- mem[q].hh.v.RH = empty_flag;
- mem[q].hh.v.LH = t - lo_mem_max; /* block size */
- lo_mem_max = t;
- mem[lo_mem_max].hh.v.RH = 0;
- mem[lo_mem_max].hh.v.LH = 0;
- rover = q;
- goto lab20;
- }
+ if (t > mem_bot + max_halfword)
+ t = mem_bot + max_halfword; /* silly ? flush 93/Dec/16 */
+ mem[q + 1].hh.v.RH = rover;
+ mem[q + 1].hh.v.LH = p;
+ mem[q].hh.v.RH = empty_flag;
+ mem[q].hh.v.LH = t - lo_mem_max; /* block size */
+ lo_mem_max = t;
+ mem[lo_mem_max].hh.v.RH = 0;
+ mem[lo_mem_max].hh.v.LH = 0;
+ rover = q;
+ goto lab20;
+ }
/* overflow("main memory size", mem_max + 1 - mem_min); */ /* what used to happen! */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
/* we've run out of space in the middle for variable length blocks */
void free_node_(halfword p, halfword s)
{
- halfword q;
- mem[p].hh.v.LH = s;
-/* mem[p].hh.v.RH = 262143L; */ /* NO! */
- mem[p].hh.v.RH = empty_flag;
- q = mem[rover + 1].hh.v.LH;
- mem[p + 1].hh.v.LH = q;
- mem[p + 1].hh.v.RH = rover;
- mem[rover + 1].hh.v.LH = p;
- mem[q + 1].hh.v.RH = p;
+ halfword q;
+ mem[p].hh.v.LH = s;
+ mem[p].hh.v.RH = empty_flag;
+ q = mem[rover + 1].hh.v.LH;
+ mem[p + 1].hh.v.LH = q;
+ mem[p + 1].hh.v.RH = rover;
+ mem[rover + 1].hh.v.LH = p;
+ mem[q + 1].hh.v.RH = p;
;
#ifdef STAT
var_used = var_used - s;
halfword new_null_box (void)
{
- register halfword Result;
+ register halfword Result;
halfword p;
- p = get_node(7);
- mem[p].hh.b0 = 0;
- mem[p].hh.b1 = 0;
- mem[p + 1].cint = 0;
- mem[p + 2].cint = 0;
- mem[p + 3].cint = 0;
- mem[p + 4].cint = 0;
- mem[p + 5].hh.v.RH = 0;
- mem[p + 5].hh.b0 = 0;
- mem[p + 5].hh.b1 = 0;
- mem[p + 6].gr = 0.0;
- Result = p;
- return Result;
+ p = get_node(7);
+ mem[p].hh.b0 = 0;
+ mem[p].hh.b1 = 0;
+ mem[p + 1].cint = 0;
+ mem[p + 2].cint = 0;
+ mem[p + 3].cint = 0;
+ mem[p + 4].cint = 0;
+ mem[p + 5].hh.v.RH = 0;
+ mem[p + 5].hh.b0 = 0;
+ mem[p + 5].hh.b1 = 0;
+ mem[p + 6].gr = 0.0;
+ Result = p;
+ return Result;
}
// @ A new rule node is delivered by the |new_rule| function. It
{/* 31 32 */
halfword p, q;
bool clobbered;
- {register integer for_end; p = mem_min; for_end = lo_mem_max; if(p <=
- for_end) do
- freearr[p]= false;
- while(p++ < for_end); }
- {register integer for_end; p = hi_mem_min; for_end = mem_end; if(p <=
- for_end) do
- freearr[p]= false;
- while(p++ < for_end); }
- p = avail;
- q = 0;
- clobbered = false;
- while(p != 0){ /* while p<>null do */
- if((p > mem_end)||(p < hi_mem_min))
- clobbered = true;
- else if(freearr[p])
- clobbered = true;
- if(clobbered)
+ {
+ register integer for_end;
+ p = mem_min;
+ for_end = lo_mem_max;
+ if(p <= for_end) do
+ freearr[p]= false;
+ while (p++ < for_end);
+ }
+ {
+ register integer for_end;
+ p = hi_mem_min;
+ for_end = mem_end;
+ if(p <= for_end) do
+ freearr[p]= false;
+ while (p++ < for_end);
+ }
+ p = avail;
+ q = 0;
+ clobbered = false;
+ while (p != 0) { /* while p<>null do */
+ if ((p > mem_end) || (p < hi_mem_min))
+ clobbered = true;
+ else if (freearr[p])
+ clobbered = true;
+ if (clobbered)
{
- print_nl("AVAIL list clobbered at "); /* */
- print_int(q);
- goto lab31;
- }
- freearr[p]= true;
- q = p;
- p = mem[q].hh.v.RH;
- }
- lab31:;
- p = rover;
+ print_nl("AVAIL list clobbered at ");
+ print_int(q);
+ goto lab31;
+ }
+ freearr[p] = true;
+ q = p;
+ p = mem[q].hh.v.RH;
+ }
+lab31:;
+ p = rover;
q = 0; /* q:=null */
- clobbered = false;
+ clobbered = false;
do {
- if((p >= lo_mem_max)||(p < mem_min))
- clobbered = true;
- else if((mem[p + 1].hh.v.RH >= lo_mem_max)||(mem[p + 1].hh.v.RH < mem_min))
- clobbered = true;
+ if ((p >= lo_mem_max) || (p < mem_min))
+ clobbered = true;
+ else if ((mem[p + 1].hh.v.RH >= lo_mem_max) || (mem[p + 1].hh.v.RH < mem_min))
+ clobbered = true;
/* else if(!((mem[p].hh.v.RH == 262143L)) ||(mem[p].hh *//*NO!*/
else if(!((mem[p].hh.v.RH == empty_flag)) ||
(mem[p].hh .v.LH < 2) ||
clobbered = true;
if(clobbered)
{
- print_nl("Double-AVAIL list clobbered at "); /* */
- print_int(q);
- goto lab32;
+ print_nl("Double-AVAIL list clobbered at ");
+ print_int(q);
+ goto lab32;
}
- {register integer for_end; q = p; for_end = p + mem[p].hh.v.LH - 1
- ; if(q <= for_end) do
+ {
+ register integer for_end;
+ q = p;
+ for_end = p + mem[p].hh.v.LH - 1;
+ if (q <= for_end) do
{
- if(freearr[q])
- {
- print_nl("Doubly free location at "); /* */
- print_int(q);
- goto lab32;
- }
- freearr[q]= true;
- }
- while(q++ < for_end); }
- q = p;
- p = mem[p + 1].hh.v.RH;
- } while(!(p == rover));
- lab32:;
- p = mem_min;
- while(p <= lo_mem_max){sss
-/* if((mem[p].hh.v.RH == 262143L)) */ /* NO! */
+ if (freearr[q])
+ {
+ print_nl("Doubly free location at ");
+ print_int(q);
+ goto lab32;
+ }
+ freearr[q]= true;
+ } while (q++ < for_end);
+ }
+ q = p;
+ p = mem[p + 1].hh.v.RH;
+ } while (!(p == rover));
+lab32:;
+ p = mem_min;
+ while (p <= lo_mem_max) {
if((mem[p].hh.v.RH == empty_flag))
{
- print_nl("Bad flag at "); /* */
- print_int(p);
- }
- while((p <= lo_mem_max)&& ! freearr[p])incr(p);
- while((p <= lo_mem_max)&& freearr[p])incr(p);
- }
- if(printlocs)
+ print_nl("Bad flag at ");
+ print_int(p);
+ }
+ while ((p <= lo_mem_max) && !freearr[p]) incr(p);
+ while ((p <= lo_mem_max) && freearr[p]) incr(p);
+ }
+ if (printlocs)
{
- print_nl("New busy locs:"); /* */
- {register integer for_end; p = mem_min; for_end = lo_mem_max; if(p <=
- for_end) do
- if(! freearr[p]&&((p > waslomax)|| wasfree[p]))
- {
- print_char(32); /* */
- print_int(p);
- }
- while(p++ < for_end); }
- {register integer for_end; p = hi_mem_min; for_end = mem_end; if(p <=
- for_end) do
- if(! freearr[p]&&((p < washimin)||(p > wasmemend)||
- wasfree[p]))
- {
- print_char(32); /* */
- print_int(p);
- }
- while(p++ < for_end); }
+ print_nl("New busy locs:");
+ {
+ register integer for_end;
+ p = mem_min;
+ for_end = lo_mem_max;
+ if(p <= for_end) do
+ if (!freearr[p] && ((p > was_lo_max) || wasfree[p]))
+ {
+ print_char(' ');
+ print_int(p);
+ } while (p++ < for_end);
+ }
+ {
+ register integer for_end;
+ p = hi_mem_min;
+ for_end = mem_end;
+ if (p <= for_end) do
+ if (!freearr[p] && ((p < was_hi_min) || (p > was_mem_end) || wasfree[p]))
+ {
+ print_char(' ');
+ print_int(p);
+ } while (p++ < for_end);
+ }
}
- {register integer for_end; p = mem_min; for_end = lo_mem_max; if(p <=
- for_end) do
- wasfree[p]= freearr[p];
- while(p++ < for_end); }
- {register integer for_end; p = hi_mem_min; for_end = mem_end; if(p <=
- for_end) do
- wasfree[p]= freearr[p];
- while(p++ < for_end); }
- wasmemend = mem_end;
- waslomax = lo_mem_max;
- washimin = hi_mem_min;
-}
+ {
+ register integer for_end;
+ p = mem_min;
+ for_end = lo_mem_max;
+ if(p <= for_end) do
+ wasfree[p]= freearr[p];
+ while (p++ < for_end);
+ }
+ {
+ register integer for_end;
+ p = hi_mem_min;
+ for_end = mem_end;
+ if(p <= for_end) do
+ wasfree[p] = freearr[p];
+ while (p++ < for_end);
+ }
+ was_mem_end = mem_end;
+ was_lo_max = lo_mem_max;
+ was_hi_min = hi_mem_min;
+}
#endif /* DEBUG */
#ifdef DEBUG
void search_mem_(halfword p)
{
integer q;
- {register integer for_end; q = mem_min; for_end = lo_mem_max; if(q <=
- for_end) do
+ {
+ register integer for_end;
+ q = mem_min;
+ for_end = lo_mem_max;
+ if(q <= for_end) do
{
- if(mem[q].hh.v.RH == p)
+ if (link(q) == p)
{
- print_nl("LINK("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- if(mem[q].hh.v.LH == p)
+ print_nl("LINK(");
+ print_int(q);
+ print_char(')');
+ }
+ if (info(q) == p)
{
- print_nl("INFO("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- }
- while(q++ < for_end); }
- {register integer for_end; q = hi_mem_min; for_end = mem_end; if(q <=
- for_end) do
+ print_nl("INFO(");
+ print_int(q);
+ print_char(')');
+ }
+ } while (q++ < for_end);
+ }
+ {
+ register integer for_end;
+ q = hi_mem_min;
+ for_end = mem_end;
+ if (q <= for_end) do
{
- if(mem[q].hh.v.RH == p)
+ if(link(q) == p)
{
- print_nl("LINK("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- if(mem[q].hh.v.LH == p)
+ print_nl("LINK(");
+ print_int(q);
+ print_char(')');
+ }
+ if (info(q) == p)
{
- print_nl("INFO("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- }
- while(q++ < for_end); }
- {register integer for_end; q = 1; for_end = (hash_size + 1833); if(q <= for_end) do
+ print_nl("INFO(");
+ print_int(q);
+ print_char(')');
+ }
+ } while (q++ < for_end);
+ }
+ {
+ register integer for_end;
+ q = 1;
+ for_end = (hash_size + 1833);
+ if (q <= for_end) do
{
if(eqtb[q].hh.v.RH == p)
{
- print_nl("EQUIV("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- }
- while(q++ < for_end); }
- if(save_ptr > 0)
- {register integer for_end; q = 0; for_end = save_ptr - 1; if(q <=
- for_end) do
+ print_nl("EQUIV(");
+ print_int(q);
+ print_char(')');
+ }
+ } while(q++ < for_end);
+ }
+ if (save_ptr > 0)
+ {
+ register integer for_end;
+ q = 0;
+ for_end = save_ptr - 1;
+ if(q <= for_end) do
{
- if(save_stack[q].hh.v.RH == p)
+ if (save_stack[q].hh.v.RH == p)
{
- print_nl("SAVE("); /* */
- print_int(q);
- print_char(41); /*)*/
- }
- }
- while(q++ < for_end); }
+ print_nl("SAVE(");
+ print_int(q);
+ print_char(41);
+ }
+ } while (q++ < for_end);
+ }
/* {register integer for_end; q = 0; for_end = 607; if(q <= for_end) do */
- {register integer for_end; q = 0; for_end = hyphen_prime; if(q <= for_end) do
+ {
+ register integer for_end;
+ q = 0;
+ for_end = hyphen_prime;
+ if (q <= for_end) do
{
- if(hyph_list[q]== p)
+ if (hyph_list[q]== p)
{
- print_nl("HYPH(");
- print_int(q);
- print_char(41); /*)*/
- }
- }
- while(q++ < for_end); }
-}
+ print_nl("HYPH(");
+ print_int(q);
+ print_char(')');
+ }
+ } while(q++ < for_end);
+ }
+}
#endif /* DEBUG */
void short_display_(integer p)
{
integer n;
/* while(p > mem_min){ */
- while(p != 0){ /* want p != null here bkph 93/Dec/15 !!! */
+ while (p != 0) { /* want p != null here bkph 93/Dec/15 !!! */
/* NOTE: still not fixed in 3.14159 ! */
- if((p >= hi_mem_min)) /* is_char_node(p) */
+ if ((p >= hi_mem_min)) /* is_char_node(p) */
+ {
+ if (p <= mem_end)
+ {
+ if (mem[p].hh.b0 != font_in_short_display) /* font(p) */
+ {
+ if ((mem[p].hh.b0 > font_max))
+ print_char('*');
+/* else print_esc(hash[(hash_size + 524) + mem[p].hh.b0].v.RH); */
+ else //print_esc(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);
+ {print_esc("");print(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);}
+/* 96/Jan/10 */
+ print_char(' ');
+ font_in_short_display = mem[p].hh.b0;
+ }
+ print(mem[p].hh.b1); /* character(p) */
+ }
+ } else switch (mem[p].hh.b0)
{
- if(p <= mem_end)
- {
- if(mem[p].hh.b0 != font_in_short_display) /* font(p) */
- {
- if((mem[p].hh.b0 > font_max))
- print_char(42); /* * */
+ case 0:
+ case 1:
+ case 3:
+ case 8:
+ case 4:
+ case 5:
+ case 13:
+ print_string("[]");
+ break;
+ case 2:
+ print_char('|');
+ break;
+ case 10:
+ if (mem[p + 1].hh.v.LH != 0)
+ print_char(' ');
+ break;
+ case 9:
+ print_char('$');
+ break;
+ case 6:
+ short_display(mem[p + 1].hh.v.RH);
+ break;
+ case 7:
+ {
+ short_display(mem[p + 1].hh.v.LH);
+ short_display(mem[p + 1].hh.v.RH);
+ n = mem[p].hh.b1;
+ while (n > 0) {
+ if(link(p) != 0) /* if link(p)<>null then */
+ p = mem[p].hh.v.RH;
+ decr(n);
+ }
+ }
+ break;
+ default:
+ ;
+ break;
+ }
+ p = mem[p].hh.v.RH;
+ }
+}
+
+void print_font_and_char_ (integer p)
+{
+ if (p > mem_end)
+ print_esc("CLOBBERED.");
+ else {
+ if((mem[p].hh.b0 > font_max)) /* font(p) */
+ print_char(42); /* * */
/* else print_esc(hash[(hash_size + 524) + mem[p].hh.b0].v.RH); */
- else //print_esc(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);
- {print_esc("");print(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);}
- /* 96/Jan/10 */
- print_char(32); /* */
- font_in_short_display = mem[p].hh.b0;
- }
- print(mem[p].hh.b1); /* character(p) */
- }
- }
- else switch(mem[p].hh.b0)
- {case 0 :
- case 1 :
- case 3 :
- case 8 :
- case 4 :
- case 5 :
- case 13 :
- print_string("[]");
- break;
- case 2 :
- print_char(124); /* | */
- break;
- case 10 :
- if(mem[p + 1].hh.v.LH != 0)
- print_char(32); /* */
- break;
- case 9 :
- print_char(36); /* $ */
- break;
- case 6 :
- short_display(mem[p + 1].hh.v.RH);
- break;
- case 7 :
- {
- short_display(mem[p + 1].hh.v.LH);
- short_display(mem[p + 1].hh.v.RH);
- n = mem[p].hh.b1;
- while(n > 0){
- if(mem[p].hh.v.RH != 0) /* if link(p)<>null then */
- p = mem[p].hh.v.RH;
- decr(n);
- }
- }
- break;
- default:
- ;
- break;
- }
- p = mem[p].hh.v.RH;
- }
-}
-
-void print_font_and_char_ (integer p)
-{
- if(p > mem_end)
- print_esc("CLOBBERED.");
- else {
- if((mem[p].hh.b0 > font_max)) /* font(p) */
- print_char(42); /* * */
-/* else print_esc(hash[(hash_size + 524) + mem[p].hh.b0].v.RH); */
- else
- //print_esc(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH); /* 96/Jan/10 */
- {print_esc("");print(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);}
- print_char(32); /* */
- print(mem[p].hh.b1); /* character(p) */
+ else
+ //print_esc(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH); /* 96/Jan/10 */
+ {print_esc("");print(hash[(hash_size + hash_extra + 524) + mem[p].hh.b0].v.RH);}
+ print_char(' ');
+ print(mem[p].hh.b1); /* character(p) */
}
}
void print_mark_ (integer p)
{
- print_char(123); /* { */
- if((p < hi_mem_min)||(p > mem_end))
+ print_char('{');
+ if ((p < hi_mem_min)||(p > mem_end))
print_esc("CLOBBERED.");
- else show_token_list(mem[p].hh.v.RH, 0, max_print_line - 10);
- print_char(125); /* } */
+ else
+ show_token_list(mem[p].hh.v.RH, 0, max_print_line - 10);
+ print_char('}');
}
void print_rule_dimen_ (scaled d)
{
- if((d == -1073741824L)) /* - 2^30 */
- print_char(42); /* * */
+ if ((d == -1073741824L)) /* - 2^30 */
+ print_char('*');
else
- print_scaled(d);
-}
+ print_scaled(d);
+}
void print_glue_(scaled d, integer order, str_number s)
{
print_scaled(d);
- if((order < 0)||(order > 3))
+ if ((order < 0)||(order > 3))
print_string("foul");
- else if(order > 0)
+ else if (order > 0)
{
print_string("fil");
- while(order > 1){
- print_char(108); /* l */
- decr(order);
- }
- }
- else if(s != 0)
- print(s);
-}
+ while (order > 1) {
+ print_char('l');
+ decr(order);
+ }
+ } else if(s != 0)
+ print(s);
+}
void print_spec_(integer p, str_number s)
{
- if((p < mem_min)||(p >= lo_mem_max))
- print_char(42); /* * */
+ if ((p < mem_min)||(p >= lo_mem_max))
+ print_char('*');
else {
- print_scaled(mem[p + 1].cint);
- if(s != 0)
- print(s);
- if(mem[p + 2].cint != 0)
+ print_scaled(mem[p + 1].cint);
+ if (s != 0)
+ print(s);
+ if (mem[p + 2].cint != 0)
{
print_string("plus");
- print_glue(mem[p + 2].cint, mem[p].hh.b0, s);
- }
- if(mem[p + 3].cint != 0)
+ print_glue(mem[p + 2].cint, mem[p].hh.b0, s);
+ }
+ if (mem[p + 3].cint != 0)
{
print_string("minus");
- print_glue(mem[p + 3].cint, mem[p].hh.b1, s);
- }
- }
-}
+ print_glue(mem[p + 3].cint, mem[p].hh.b1, s);
+ }
+ }
+}
void print_fam_and_char_(halfword p)
-{
+{
print_esc("fam");
- print_int(mem[p].hh.b0);
- print_char(32); /* */
- print(mem[p].hh.b1);
-}
+ print_int(mem[p].hh.b0);
+ print_char(' ');
+ print(mem[p].hh.b1);
+}
void print_delimiter_(halfword p)
{
- integer a;
- a = mem[p].qqqq.b0 * 256 + mem[p].qqqq.b1;
- a = a * 4096 + mem[p].qqqq.b2 * 256 + mem[p].qqqq.b3;
- if(a < 0)
- print_int(a);
- else print_hex(a);
+ integer a;
+ a = mem[p].qqqq.b0 * 256 + mem[p].qqqq.b1;
+ a = a * 4096 + mem[p].qqqq.b2 * 256 + mem[p].qqqq.b3;
+ if (a < 0)
+ print_int(a);
+ else
+ print_hex(a);
}
void print_subsidiary_data_(halfword p, ASCII_code c)
{
- if((pool_ptr - str_start[str_ptr]) >= depth_threshold)
+ if ((pool_ptr - str_start[str_ptr]) >= depth_threshold)
{
- if(mem[p].hh.v.RH != 0)
- print_string("[]");
- }
- else {
+ if (mem[p].hh.v.RH != 0)
+ print_string("[]");
+ } else {
{
- str_pool[pool_ptr]= c;
- incr(pool_ptr);
- }
- temp_ptr = p;
- switch(mem[p].hh.v.RH)
- {case 1 :
- {
- print_ln ();
- print_current_string ();
- print_fam_and_char(p);
- }
- break;
- case 2 :
- show_info ();
- break;
- case 3 :
- if(mem[p].hh.v.LH == 0)
- {
- print_ln ();
- print_current_string ();
- print_string("{}");
- }
- else show_info ();
- break;
- default:
- ;
- break;
- }
- decr(pool_ptr);
- }
-}
+ str_pool[pool_ptr]= c;
+ incr(pool_ptr);
+ }
+ temp_ptr = p;
+ switch (mem[p].hh.v.RH)
+ {
+ case 1:
+ {
+ print_ln ();
+ print_current_string ();
+ print_fam_and_char(p);
+ }
+ break;
+ case 2:
+ show_info ();
+ break;
+ case 3:
+ if (mem[p].hh.v.LH == 0)
+ {
+ print_ln ();
+ print_current_string ();
+ print_string("{}");
+ } else show_info ();
+ break;
+ default:
+ ;
+ break;
+ }
+ decr(pool_ptr);
+ }
+}
/* sec 0694 */
void print_style_(integer c)
{
- switch(c / 2)
+ switch (c / 2)
{
- case 0 :
- print_esc("displaystyle");
- break;
- case 1 :
- print_esc("textstyle");
- break;
- case 2 :
- print_esc("scriptstyle");
- break;
- case 3 :
- print_esc("scriptscriptstyle");
- break;
- default:
- print_string("Unknown style!");
- break;
- }
-}
+ case 0:
+ print_esc("displaystyle");
+ break;
+ case 1:
+ print_esc("textstyle");
+ break;
+ case 2:
+ print_esc("scriptstyle");
+ break;
+ case 3:
+ print_esc("scriptscriptstyle");
+ break;
+ default:
+ print_string("Unknown style!");
+ break;
+ }
+}
/* sec 0225 */
void print_skip_param_(integer n)
{
integer n;
real g;
/* begin if cur_length>depth_threshold then */
- if((pool_ptr - str_start[str_ptr])> depth_threshold)
+ if ((pool_ptr - str_start[str_ptr]) > depth_threshold)
{
/* if(p > 0) */ /* was p>null !!! line 3662 in tex.web */
if(p != 0) /* fixed 94/Mar/23 BUG FIX */
/* NOTE: still not fixed in 3.14159 ! */
print_ln ();
print_current_string ();
- if(p > mem_end)
+ if (p > mem_end)
{
print_string("Bad link, display aborted.");
- return;
- }
- incr(n);
- if(n > breadth_max)
+ return;
+ }
+ incr(n);
+ if (n > breadth_max)
{
print_string("etc.");
- return;
- }
- if((p >= hi_mem_min))
- print_font_and_char(p);
- else switch(mem[p].hh.b0)
- {case 0 :
- case 1 :
- case 13 :
- {
- if(mem[p].hh.b0 == 0)
- print_esc("h");
- else if(mem[p].hh.b0 == 1)
- print_esc("v");
- else print_esc("unset");
- print_string("box(");
- print_scaled(mem[p + 3].cint);
- print_char(43); /* + */
- print_scaled(mem[p + 2].cint);
- print_string(", shifted ");
- print_scaled(mem[p + 1].cint);
- if(mem[p].hh.b0 == 13)
- {
- if(mem[p].hh.b1 != 0)
- {
- print_string(" (");
- print_int(mem[p].hh.b1 + 1);
- print_string(" columns)");
- }
- if(mem[p + 6].cint != 0)
- {
- print_string(", stretch");
- print_glue(mem[p + 6].cint, mem[p + 5].hh.b1, 0);
- }
- if(mem[p + 4].cint != 0)
- {
- print_string(", shrink");
- print_glue(mem[p + 4].cint, mem[p + 5].hh.b0, 0);
- }
- }
- else {
-
- g = mem[p + 6].gr;
- if((g != 0.0)&&(mem[p + 5].hh.b0 != 0))
- {
- print_string(", glue set");
- if(mem[p + 5].hh.b0 == 2)
- print_string("- ");
- if(fabs(g)> 20000.0)
- {
- if(g > 0.0)
- print_char(62); /* '>' */
- else print_string("< -");
- print_glue(20000 * 65536L, mem[p + 5].hh.b1, 0);
- }
- else print_glue(round(65536L * g), mem[p + 5].hh.b1, 0)
- ;
- }
- if(mem[p + 4].cint != 0)
- {
- print_string("shifted");
- print_scaled(mem[p + 4].cint);
- }
- }
- {
- {
- str_pool[pool_ptr]= 46;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 5].hh.v.RH);
- decr(pool_ptr);
- }
- }
- break;
- case 2 :
- {
- print_esc("rule(");
- print_rule_dimen(mem[p + 3].cint);
- print_char(43); /* '+' */
- print_rule_dimen(mem[p + 2].cint);
- print_string(")x");
- print_rule_dimen(mem[p + 1].cint);
- }
- break;
- case 3 :
- {
- print_esc("insert");
- print_int(mem[p].hh.b1);
- print_string(",natural size ");
- print_scaled(mem[p + 3].cint);
- print_string("; split(");
- print_spec(mem[p + 4].hh.v.RH, 0);
- print_char(44); /* ',' */
- print_scaled(mem[p + 2].cint);
- print_string("(; float cost");
- print_int(mem[p + 1].cint);
- {
- {
- str_pool[pool_ptr]= 46;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 4].hh.v.LH);
- decr(pool_ptr);
- }
- }
- break;
- case 8 :
- switch(mem[p].hh.b1)
- {case 0 :
- {
- print_write_whatsit(1279, p); /* debug # (-1 to exit): */
- print_char(61); /* = */
- print_file_name(mem[p + 1].hh.v.RH, mem[p + 2].hh.v.LH,
- mem[p + 2].hh.v.RH);
- }
- break;
- case 1 :
- {
- print_write_whatsit(591, p); /* write */
- print_mark(mem[p + 1].hh.v.RH);
- }
- break;
- case 2 :
- print_write_whatsit(1280, p); /* closeout */
- break;
- case 3 :
- {
- print_esc("special");
- print_mark(mem[p + 1].hh.v.RH);
- }
- break;
- case 4 :
- {
- print_esc("setlanguage");
- print_int(mem[p + 1].hh.v.RH);
- print_string(" (hyphenmin");
- print_int(mem[p + 1].hh.b0);
- print_char(44); /*, */
- print_int(mem[p + 1].hh.b1);
- print_char(41); /*)*/
- }
- break;
- default:
- print_string("whatsit");
- break;
- }
- break;
- case 10 :
- if(mem[p].hh.b1 >= 100)
- {
- print_esc("");
- if(mem[p].hh.b1 == 101)
- print_char(99); /* c */
- else if(mem[p].hh.b1 == 102)
- print_char(120); /* x */
- print_string("leaders ");
- print_spec(mem[p + 1].hh.v.LH, 0);
- {
- {
- str_pool[pool_ptr]= 46;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].hh.v.RH);
- decr(pool_ptr);
- }
- }
- else {
-
- print_esc("glue");
- if(mem[p].hh.b1 != 0)
- {
- print_char(40); /*(*/
- if(mem[p].hh.b1 < 98)
- print_skip_param(mem[p].hh.b1 - 1);
- else if(mem[p].hh.b1 == 98)
- print_esc("nonscript");
- else print_esc("mskip");
- print_char(41); /*)*/
- }
- if(mem[p].hh.b1 != 98)
- {
- print_char(32); /* */
- if(mem[p].hh.b1 < 98)
- print_spec(mem[p + 1].hh.v.LH, 0);
- else print_spec(mem[p + 1].hh.v.LH, 334); /* mu */
- }
- }
- break;
- case 11 :
- if(mem[p].hh.b1 != 99)
- {
- print_esc("kern");
- if(mem[p].hh.b1 != 0)
- print_char(32); /* */
- print_scaled(mem[p + 1].cint);
- if(mem[p].hh.b1 == 2)
- print_string(" (for accent)");
- }
- else {
- print_esc("mkern");
- print_scaled(mem[p + 1].cint);
- print_string("mu");
- }
- break;
- case 9 :
- {
- print_esc("math");
- if(mem[p].hh.b1 == 0)
- print_string("on");
- else print_string("off");
- if(mem[p + 1].cint != 0)
- {
- print_string(", surrounded");
- print_scaled(mem[p + 1].cint);
- }
- }
- break;
- case 6 :
- {
- print_font_and_char(p + 1);
- print_string("(ligature");
- if(mem[p].hh.b1 > 1)
- print_char(124); /* | */
- font_in_short_display = mem[p + 1].hh.b0;
- short_display(mem[p + 1].hh.v.RH);
- if(odd(mem[p].hh.b1))
- print_char(124); /* | */
- print_char(41); /*)*/
- }
- break;
- case 12 :
- {
- print_esc("penalty ");
- print_int(mem[p + 1].cint);
- }
- break;
- case 7 :
- {
- print_esc("discretionary");
- if(mem[p].hh.b1 > 0)
- {
- print_string(" replacing ");
- print_int(mem[p].hh.b1);
- }
- {
- {
- str_pool[pool_ptr]= 46;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].hh.v.LH);
- decr(pool_ptr);
- }
- {
- str_pool[pool_ptr]= 124;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].hh.v.RH);
- decr(pool_ptr);
- }
- break;
- case 4 :
- {
- print_esc("mark");
- print_mark(mem[p + 1].cint);
- }
- break;
- case 5 :
- {
- print_esc("vadjust");
- {
- {
- str_pool[pool_ptr]= 46;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].cint);
- decr(pool_ptr);
- }
- }
- break;
- case 14 :
- print_style(mem[p].hh.b1);
- break;
- case 15 :
- {
- print_esc("mathchoice");
- {
- str_pool[pool_ptr]= 68;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].hh.v.LH);
- decr(pool_ptr);
- {
- str_pool[pool_ptr]= 84;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 1].hh.v.RH);
- decr(pool_ptr);
- {
- str_pool[pool_ptr]= 83;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 2].hh.v.LH);
- decr(pool_ptr);
- {
- str_pool[pool_ptr]= 115;
- incr(pool_ptr);
- }
- show_node_list(mem[p + 2].hh.v.RH);
- decr(pool_ptr);
- }
- break;
- case 16 :
- case 17 :
- case 18 :
- case 19 :
- case 20 :
- case 21 :
- case 22 :
- case 23 :
- case 24 :
- case 27 :
- case 26 :
- case 29 :
- case 28 :
- case 30 :
- case 31 :
- {
- switch(mem[p].hh.b0)
- {case 16 :
- print_esc("mathord");
- break;
- case 17 :
- print_esc("mathop");
- break;
- case 18 :
- print_esc("mathbin");
- break;
- case 19 :
- print_esc("mathrel");
- break;
- case 20 :
- print_esc("mathopen");
- break;
- case 21 :
- print_esc("mathclose");
- break;
- case 22 :
- print_esc("mathpunct");
- break;
- case 23 :
- print_esc("mathinner");
- break;
- case 27 :
- print_esc("overline");
- break;
- case 26 :
- print_esc("underline");
- break;
- case 29 :
- print_esc("vcenter");
- break;
- case 24 :
- {
- print_esc("radical");
- print_delimiter(p + 4);
- }
- break;
- case 28 :
- {
- print_esc("accent");
- print_fam_and_char(p + 4);
- }
- break;
- case 30 :
- {
- print_esc("left");
- print_delimiter(p + 1);
- }
- break;
- case 31 :
+ return;
+ }
+ if ((p >= hi_mem_min))
+ print_font_and_char(p);
+ else switch (mem[p].hh.b0)
{
- print_esc("right");
- print_delimiter(p + 1);
- }
- break;
- }
- if(mem[p].hh.b1 != 0)
- if(mem[p].hh.b1 == 1)
- print_esc("limits");
- else print_esc("nolimits");
- if(mem[p].hh.b0 < 30)
- print_subsidiary_data(p + 1, 46);
- print_subsidiary_data(p + 2, 94);
- print_subsidiary_data(p + 3, 95);
- }
- break;
- case 25 :
- {
- print_esc("fraction");
- if(mem[p + 1].cint == 1073741824L) /* 2^30 */
- print_string("= default");
- else print_scaled(mem[p + 1].cint);
- if((mem[p + 4].qqqq.b0 != 0)||(mem[p + 4].qqqq.b1 !=
- 0)||(mem[p + 4].qqqq.b2 != 0)||(mem[p + 4].qqqq.b3
- != 0))
- {
- print_string(", left");
- print_delimiter(p + 4);
- }
- if((mem[p + 5].qqqq.b0 != 0)||(mem[p + 5].qqqq.b1 !=
- 0)||(mem[p + 5].qqqq.b2 != 0)||(mem[p + 5].qqqq.b3
- != 0))
- {
- print_string(", right");
- print_delimiter(p + 5);
- }
- print_subsidiary_data(p + 2, 92);
- print_subsidiary_data(p + 3, 47);
- }
- break;
- default:
- print_string("Unknown node type!");
- break;
- }
- p = mem[p].hh.v.RH;
+ case 0:
+ case 1:
+ case 13:
+ {
+ if (mem[p].hh.b0 == 0)
+ print_esc("h");
+ else if (mem[p].hh.b0 == 1)
+ print_esc("v");
+ else print_esc("unset");
+ print_string("box(");
+ print_scaled(mem[p + 3].cint);
+ print_char('+');
+ print_scaled(mem[p + 2].cint);
+ print_string(", shifted ");
+ print_scaled(mem[p + 1].cint);
+ if (mem[p].hh.b0 == 13)
+ {
+ if (mem[p].hh.b1 != 0)
+ {
+ print_string(" (");
+ print_int(mem[p].hh.b1 + 1);
+ print_string(" columns)");
+ }
+ if (mem[p + 6].cint != 0)
+ {
+ print_string(", stretch");
+ print_glue(mem[p + 6].cint, mem[p + 5].hh.b1, 0);
+ }
+ if (mem[p + 4].cint != 0)
+ {
+ print_string(", shrink");
+ print_glue(mem[p + 4].cint, mem[p + 5].hh.b0, 0);
+ }
+ } else {
+ g = mem[p + 6].gr;
+ if ((g != 0.0)&&(mem[p + 5].hh.b0 != 0))
+ {
+ print_string(", glue set");
+ if (mem[p + 5].hh.b0 == 2)
+ print_string("- ");
+ if (fabs(g)> 20000.0)
+ {
+ if (g > 0.0)
+ print_char('>');
+ else
+ print_string("< -");
+ print_glue(20000 * 65536L, mem[p + 5].hh.b1, 0);
+ } else print_glue(round(65536L * g), mem[p + 5].hh.b1, 0);
+ }
+ if (mem[p + 4].cint != 0)
+ {
+ print_string("shifted");
+ print_scaled(mem[p + 4].cint);
+ }
+ }
+ {
+ {
+ str_pool[pool_ptr]= 46;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 5].hh.v.RH);
+ decr(pool_ptr);
+ }
+ }
+ break;
+ case 2:
+ {
+ print_esc("rule(");
+ print_rule_dimen(mem[p + 3].cint);
+ print_char('+');
+ print_rule_dimen(mem[p + 2].cint);
+ print_string(")x");
+ print_rule_dimen(mem[p + 1].cint);
+ }
+ break;
+ case 3:
+ {
+ print_esc("insert");
+ print_int(mem[p].hh.b1);
+ print_string(",natural size ");
+ print_scaled(mem[p + 3].cint);
+ print_string("; split(");
+ print_spec(mem[p + 4].hh.v.RH, 0);
+ print_char(',');
+ print_scaled(mem[p + 2].cint);
+ print_string("(; float cost");
+ print_int(mem[p + 1].cint);
+ {
+ {
+ str_pool[pool_ptr]= 46;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 4].hh.v.LH);
+ decr(pool_ptr);
+ }
+ }
+ break;
+ case 8:
+ switch (mem[p].hh.b1)
+ {
+ case 0:
+ {
+ print_write_whatsit(1279, p); /* debug # (-1 to exit): */
+ print_char('=');
+ print_file_name(mem[p + 1].hh.v.RH, mem[p + 2].hh.v.LH, mem[p + 2].hh.v.RH);
+ }
+ break;
+ case 1:
+ {
+ print_write_whatsit(591, p); /* write */
+ print_mark(mem[p + 1].hh.v.RH);
+ }
+ break;
+ case 2:
+ print_write_whatsit(1280, p); /* closeout */
+ break;
+ case 3:
+ {
+ print_esc("special");
+ print_mark(mem[p + 1].hh.v.RH);
+ }
+ break;
+ case 4:
+ {
+ print_esc("setlanguage");
+ print_int(mem[p + 1].hh.v.RH);
+ print_string(" (hyphenmin");
+ print_int(mem[p + 1].hh.b0);
+ print_char(',');
+ print_int(mem[p + 1].hh.b1);
+ print_char(')');
+ }
+ break;
+ default:
+ print_string("whatsit");
+ break;
+ }
+ break;
+ case 10:
+ if (mem[p].hh.b1 >= 100)
+ {
+ print_esc("");
+ if (mem[p].hh.b1 == 101)
+ print_char('c');
+ else if (mem[p].hh.b1 == 102)
+ print_char('x');
+ print_string("leaders ");
+ print_spec(mem[p + 1].hh.v.LH, 0);
+ {
+ {
+ str_pool[pool_ptr]= 46;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].hh.v.RH);
+ decr(pool_ptr);
+ }
+ } else {
+ print_esc("glue");
+ if (mem[p].hh.b1 != 0)
+ {
+ print_char('(');
+ if (mem[p].hh.b1 < 98)
+ print_skip_param(mem[p].hh.b1 - 1);
+ else if (mem[p].hh.b1 == 98)
+ print_esc("nonscript");
+ else print_esc("mskip");
+ print_char(')');
+ }
+ if (mem[p].hh.b1 != 98)
+ {
+ print_char(' ');
+ if (mem[p].hh.b1 < 98)
+ print_spec(mem[p + 1].hh.v.LH, 0);
+ else
+ print_spec(mem[p + 1].hh.v.LH, 334); /* mu */
+ }
+ }
+ break;
+ case 11:
+ if (mem[p].hh.b1 != 99)
+ {
+ print_esc("kern");
+ if (mem[p].hh.b1 != 0)
+ print_char(' ');
+ print_scaled(mem[p + 1].cint);
+ if (mem[p].hh.b1 == 2)
+ print_string(" (for accent)");
+ } else {
+ print_esc("mkern");
+ print_scaled(mem[p + 1].cint);
+ print_string("mu");
+ }
+ break;
+ case 9:
+ {
+ print_esc("math");
+ if (mem[p].hh.b1 == 0)
+ print_string("on");
+ else print_string("off");
+ if (mem[p + 1].cint != 0)
+ {
+ print_string(", surrounded");
+ print_scaled(mem[p + 1].cint);
+ }
+ }
+ break;
+ case 6:
+ {
+ print_font_and_char(p + 1);
+ print_string("(ligature");
+ if (mem[p].hh.b1 > 1)
+ print_char('|');
+ font_in_short_display = mem[p + 1].hh.b0;
+ short_display(mem[p + 1].hh.v.RH);
+ if (odd(mem[p].hh.b1))
+ print_char('|');
+ print_char(')');
+ }
+ break;
+ case 12:
+ {
+ print_esc("penalty ");
+ print_int(mem[p + 1].cint);
+ }
+ break;
+ case 7:
+ {
+ print_esc("discretionary");
+ if (mem[p].hh.b1 > 0)
+ {
+ print_string(" replacing ");
+ print_int(mem[p].hh.b1);
+ }
+ {
+ {
+ str_pool[pool_ptr]= 46;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].hh.v.LH);
+ decr(pool_ptr);
+ }
+ {
+ str_pool[pool_ptr]= 124;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].hh.v.RH);
+ decr(pool_ptr);
+ }
+ break;
+ case 4:
+ {
+ print_esc("mark");
+ print_mark(mem[p + 1].cint);
+ }
+ break;
+ case 5:
+ {
+ print_esc("vadjust");
+ {
+ {
+ str_pool[pool_ptr]= 46;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].cint);
+ decr(pool_ptr);
+ }
+ }
+ break;
+ case 14:
+ print_style(mem[p].hh.b1);
+ break;
+ case 15:
+ {
+ print_esc("mathchoice");
+ {
+ str_pool[pool_ptr]= 68;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].hh.v.LH);
+ decr(pool_ptr);
+ {
+ str_pool[pool_ptr]= 84;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 1].hh.v.RH);
+ decr(pool_ptr);
+ {
+ str_pool[pool_ptr]= 83;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 2].hh.v.LH);
+ decr(pool_ptr);
+ {
+ str_pool[pool_ptr]= 115;
+ incr(pool_ptr);
+ }
+ show_node_list(mem[p + 2].hh.v.RH);
+ decr(pool_ptr);
+ }
+ break;
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ case 24:
+ case 27:
+ case 26:
+ case 29:
+ case 28:
+ case 30:
+ case 31:
+ {
+ switch (mem[p].hh.b0)
+ {
+ case 16:
+ print_esc("mathord");
+ break;
+ case 17:
+ print_esc("mathop");
+ break;
+ case 18:
+ print_esc("mathbin");
+ break;
+ case 19:
+ print_esc("mathrel");
+ break;
+ case 20:
+ print_esc("mathopen");
+ break;
+ case 21:
+ print_esc("mathclose");
+ break;
+ case 22:
+ print_esc("mathpunct");
+ break;
+ case 23:
+ print_esc("mathinner");
+ break;
+ case 27:
+ print_esc("overline");
+ break;
+ case 26:
+ print_esc("underline");
+ break;
+ case 29:
+ print_esc("vcenter");
+ break;
+ case 24:
+ {
+ print_esc("radical");
+ print_delimiter(p + 4);
+ }
+ break;
+ case 28:
+ {
+ print_esc("accent");
+ print_fam_and_char(p + 4);
+ }
+ break;
+ case 30:
+ {
+ print_esc("left");
+ print_delimiter(p + 1);
+ }
+ break;
+ case 31:
+ {
+ print_esc("right");
+ print_delimiter(p + 1);
+ }
+ break;
+ }
+ if (mem[p].hh.b1 != 0)
+ if (mem[p].hh.b1 == 1)
+ print_esc("limits");
+ else print_esc("nolimits");
+ if (mem[p].hh.b0 < 30)
+ print_subsidiary_data(p + 1, 46);
+ print_subsidiary_data(p + 2, 94);
+ print_subsidiary_data(p + 3, 95);
+ }
+ break;
+ case 25:
+ {
+ print_esc("fraction");
+ if (mem[p + 1].cint == 1073741824L) /* 2^30 */
+ print_string("= default");
+ else print_scaled(mem[p + 1].cint);
+ if ((mem[p + 4].qqqq.b0 != 0) || (mem[p + 4].qqqq.b1 != 0) ||
+ (mem[p + 4].qqqq.b2 != 0) || (mem[p + 4].qqqq.b3 != 0))
+ {
+ print_string(", left");
+ print_delimiter(p + 4);
+ }
+ if ((mem[p + 5].qqqq.b0 != 0) || (mem[p + 5].qqqq.b1 != 0) ||
+ (mem[p + 5].qqqq.b2 != 0)||(mem[p + 5].qqqq.b3 != 0))
+ {
+ print_string(", right");
+ print_delimiter(p + 5);
+ }
+ print_subsidiary_data(p + 2, 92);
+ print_subsidiary_data(p + 3, 47);
+ }
+ break;
+ default:
+ print_string("Unknown node type!");
+ break;
+ }
+ p = mem[p].hh.v.RH;
}
}
-
/* NOTE: 262143L should be empty_flag */
print_string(" (\\output routine)");
if(p == 0)
{
- if(mem_top - 2 != page_tail)
+ if(page_head != page_tail)
{
print_nl("### current page:");
if(output_active)
print_string(" (held over for next output)");
- show_box(mem[mem_top - 2].hh.v.RH);
+ show_box(mem[page_head].hh.v.RH);
if(page_contents > 0)
{
print_nl("total height ");
print_scaled(t);
if(mem[r].hh.b0 == 1)
{
- q = mem_top - 2;
+ q = page_head;
t = 0;
do {
q = mem[q].hh.v.RH;
}
}
/* if link(contrib_head)<>null then l.4393 */
- if(mem[mem_top - 1].hh.v.RH != 0)
+ if(mem[contrib_head].hh.v.RH != 0)
print_nl(" (\\output routine)");
}
show_box(mem[nest[p].head_field].hh.v.RH);
if(long_state >= 113)
long_state = long_state - 2;
do {
- mem[mem_top - 3].hh.v.RH = 0; /* repeat link(temp_head):=null; */
+ mem[temp_head].hh.v.RH = 0; /* repeat link(temp_head):=null; */
if((mem[r].hh.v.LH > 3583)||(mem[r].hh.v.LH < 3328))
s = 0; /* s:=null l.7984 */
else {
matchchr = mem[r].hh.v.LH - 3328;
s = mem[r].hh.v.RH;
r = s;
- p = mem_top - 3;
+ p = temp_head;
m = 0;
}
lab22: get_token ();
"My plan is to forget the whole thing and hope for the best.");
back_error ();
}
- pstack[n]= mem[mem_top - 3].hh.v.RH;
+ pstack[n]= mem[temp_head].hh.v.RH;
align_state = align_state - unbalance;
{
register integer for_end;
"My plan is to forget the whole thing and hope for the best.");
back_error ();
}
- pstack[n]= mem[mem_top - 3].hh.v.RH;
+ pstack[n]= mem[temp_head].hh.v.RH;
align_state = align_state - unbalance;
{
register integer for_end;
goto lab22;
lab40: if(s != 0)
{
- if((m == 1)&&(mem[p].hh.v.LH < 768)&&(p != mem_top - 3
+ if((m == 1)&&(mem[p].hh.v.LH < 768)&&(p != temp_head
))
{
mem[rbraceptr].hh.v.RH = 0; /* rbraceptr may be used without ... */
decr(dyn_used);
#endif /* STAT */
}
- p = mem[mem_top - 3].hh.v.RH;
+ p = mem[temp_head].hh.v.RH;
pstack[n]= mem[p].hh.v.RH;
{
mem[p].hh.v.RH = avail;
#endif /* STAT */
}
}
- else pstack[n]= mem[mem_top - 3].hh.v.RH;
+ else pstack[n]= mem[temp_head].hh.v.RH;
incr(n);
if(eqtb[(hash_size + 3193)].cint > 0)
{
cur_cmd = mem[cur_align + 5].hh.v.LH;
mem[cur_align + 5].hh.v.LH = cur_chr;
if(cur_cmd == 63)
- begin_token_list(mem_top - 10, 2);
+ begin_token_list(omit_template, 2);
else begin_token_list(mem[cur_align + 2].cint, 2);
align_state = 1000000L;
goto lab20;
}
#endif
}
- p = mem_top - 3;
+ p = temp_head;
mem[p].hh.v.RH = 0; /* link(p):=null l.9135 */
k = b;
while(k < pool_ptr){
scan_something_internal(5, false);
if(cur_val_level >= 4)
{
- p = mem_top - 3;
+ p = temp_head;
mem[p].hh.v.RH = 0;
if(cur_val_level == 4)
{
}
void ins_the_toks (void)
{
- mem[mem_top - 12].hh.v.RH = the_toks ();
- begin_token_list(mem[mem_top - 3].hh.v.RH, 4);
+ mem[lig_trick].hh.v.RH = the_toks ();
+ begin_token_list(mem[temp_head].hh.v.RH, 4);
}
void conv_toks (void)
{
break;
}
selector = old_setting;
- mem[mem_top - 12].hh.v.RH = str_toks(b);
- begin_token_list(mem[mem_top - 3].hh.v.RH, 4);
+ mem[lig_trick].hh.v.RH = str_toks(b);
+ begin_token_list(mem[temp_head].hh.v.RH, 4);
}
halfword scan_toks_(bool macrodef, bool xpand)
{/* 40 30 31 32 */ register halfword Result;
q = the_toks ();
/* if link(temp_head)<>null then l.9376 */
- if(mem[mem_top - 3].hh.v.RH != 0)
+ if(mem[temp_head].hh.v.RH != 0)
{
- mem[p].hh.v.RH = mem[mem_top - 3].hh.v.RH;
+ mem[p].hh.v.RH = mem[temp_head].hh.v.RH;
p = q;
}
}
break;
case 6 :
{
- mem[mem_top - 12]= mem[p + 1];
- mem[mem_top - 12].hh.v.RH = mem[p].hh.v.RH;
- p = mem_top - 12;
+ mem[lig_trick]= mem[p + 1];
+ mem[lig_trick].hh.v.RH = mem[p].hh.v.RH;
+ p = lig_trick;
goto lab21;
}
break;
break;
case 6 :
{
- mem[mem_top - 12]= mem[p + 1];
- mem[mem_top - 12].hh.v.RH = mem[p].hh.v.RH;
- p = mem_top - 12;
+ mem[lig_trick]= mem[p + 1];
+ mem[lig_trick].hh.v.RH = mem[p].hh.v.RH;
+ p = lig_trick;
goto lab21;
}
break;
cur_style = s;
mlist_penalties = false;
mlist_to_hlist ();
- q = mem[mem_top - 3].hh.v.RH;
+ q = mem[temp_head].hh.v.RH;
cur_style = savestyle;
{
if(cur_style < 4)
cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
.hh.v.RH]].cint, 18);
}
- p = hpack(mem[mem_top - 3].hh.v.RH, 0, 1);
+ p = hpack(mem[temp_head].hh.v.RH, 0, 1);
}
break;
default:
}
if(rtype == 18)
mem[r].hh.b0 = 16;
- p = mem_top - 3;
+ p = temp_head;
mem[p].hh.v.RH = 0;
q = mlist;
rtype = 0;
p = get_node(5);
mem[p].hh.v.RH = align_ptr;
mem[p].hh.v.LH = cur_align;
- mem[p + 1].hh.v.LH = mem[mem_top - 8].hh.v.RH;
+ mem[p + 1].hh.v.LH = mem[align_head].hh.v.RH;
mem[p + 1].hh.v.RH = cur_span;
mem[p + 2].cint = cur_loop;
mem[p + 3].cint = align_state;
align_state = mem[p + 3].cint;
cur_loop = mem[p + 2].cint;
cur_span = mem[p + 1].hh.v.RH;
- mem[mem_top - 8].hh.v.RH = mem[p + 1].hh.v.LH;
+ mem[align_head].hh.v.RH = mem[p + 1].hh.v.LH;
cur_align = mem[p].hh.v.LH;
align_ptr = mem[p].hh.v.RH;
free_node(p, 5);
/* long to short ... */
mode = - (integer) mode;
scan_spec(6, false);
- mem[mem_top - 8].hh.v.RH = 0;
- cur_align = mem_top - 8;
+ mem[align_head].hh.v.RH = 0;
+ cur_align = align_head;
cur_loop = 0;
scanner_status = 4;
warning_index = savecsptr;
cur_align = mem[cur_align].hh.v.RH;
if(cur_cmd == 5)
goto lab30;
- p = mem_top - 4;
+ p = hold_head;
mem[p].hh.v.RH = 0;
while(true){
get_preamble_token();
if(cur_cmd == 6)
goto lab31;
if((cur_cmd <= 5)&&(cur_cmd >= 4)&&(align_state == -1000000L))
- if((p == mem_top - 4)&&(cur_loop == 0)&&(cur_cmd == 4))
+ if((p == hold_head)&&(cur_loop == 0)&&(cur_cmd == 4))
cur_loop = cur_align;
else {
print_err("Missing # inserted in alignment preamble");
back_error ();
goto lab31;
}
- else if((cur_cmd != 10)||(p != mem_top - 4))
+ else if((cur_cmd != 10)||(p != hold_head))
{
mem[p].hh.v.RH = get_avail ();
p = mem[p].hh.v.RH;
lab31:;
mem[cur_align].hh.v.RH = new_null_box ();
cur_align = mem[cur_align].hh.v.RH;
- mem[cur_align].hh.v.LH = mem_top - 9;
+ mem[cur_align].hh.v.LH = end_span;
mem[cur_align + 1].cint = -1073741824L; /* - 2^30 */
- mem[cur_align + 3].cint = mem[mem_top - 4].hh.v.RH;
- p = mem_top - 4;
+ mem[cur_align + 3].cint = mem[hold_head].hh.v.RH;
+ p = hold_head;
mem[p].hh.v.RH = 0;
while(true){
lab22:
/* mem[p].hh.v.LH = (hash_size + 4614); */
/* mem[p].hh.v.LH = (hash_size + 4095 + 519); */
mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 519); /* 96/Jan/10 */
- mem[cur_align + 2].cint = mem[mem_top - 4].hh.v.RH;
+ mem[cur_align + 2].cint = mem[hold_head].hh.v.RH;
}
lab30: scanner_status = 0;
new_save_level(6);
space_factor = 0;
else cur_list.aux_field.cint = 0;
{
- mem[tail].hh.v.RH = new_glue(mem[mem[mem_top - 8]
+ mem[tail].hh.v.RH = new_glue(mem[mem[align_head]
.hh.v.RH + 1].hh.v.LH);
tail = mem[tail].hh.v.RH;
}
mem[tail].hh.b1 = 12;
- cur_align = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
+ cur_align = mem[mem[align_head].hh.v.RH].hh.v.RH;
cur_tail = cur_head;
init_span(cur_align);
}
if(nest[nest_ptr - 1].mode_field == 203)
o = eqtb[(hash_size + 3745)].cint;
else o = 0;
- q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
+ q = mem[mem[align_head].hh.v.RH].hh.v.RH;
do {
flush_list(mem[q + 3].cint);
flush_list(mem[q + 2].cint);
mem[r + 1].hh.v.LH = 0;
}
}
- if(mem[q].hh.v.LH != mem_top - 9)
+ if(mem[q].hh.v.LH != end_span)
{
t = mem[q + 1].cint + mem[mem[mem[q].hh.v.RH + 1].hh
.v.LH + 1].cint;
r = mem[q].hh.v.LH;
- s = mem_top - 9;
+ s = end_span;
mem[s].hh.v.LH = p;
n = 1;
do {
free_node(r, 2);
}
r = u;
- } while(!(r == mem_top - 9));
+ } while(!(r == end_span));
}
mem[q].hh.b0 = 13;
mem[q].hh.b1 = 0;
{
rulesave = eqtb[(hash_size + 3746)].cint;
eqtb[(hash_size + 3746)].cint = 0;
- p = hpack(mem[mem_top - 8].hh.v.RH, save_stack[save_ptr + 1].cint
+ p = hpack(mem[align_head].hh.v.RH, save_stack[save_ptr + 1].cint
, save_stack[save_ptr + 0].cint);
eqtb[(hash_size + 3746)].cint = rulesave;
}
else {
- q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
+ q = mem[mem[align_head].hh.v.RH].hh.v.RH;
do {
mem[q + 3].cint = mem[q + 1].cint;
mem[q + 1].cint = 0;
q = mem[mem[q].hh.v.RH].hh.v.RH;
} while(!(q == 0));
- p = vpackage(mem[mem_top - 8].hh.v.RH, save_stack[save_ptr + 1]
+ p = vpackage(mem[align_head].hh.v.RH, save_stack[save_ptr + 1]
.cint, save_stack[save_ptr + 0].cint, 1073741823L); /* 2^30 - 1 */
- q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
+ q = mem[mem[align_head].hh.v.RH].hh.v.RH;
do {
mem[q + 1].cint = mem[q + 3].cint;
mem[q + 3].cint = 0;
n = mem[r].hh.b1;
t = mem[s + 1].cint;
w = t;
- u = mem_top - 4;
+ u = hold_head;
while(n > 0){
decr(n);
mem[r].hh.b0 = 1;
}
mem[r + 4].cint = 0;
- if(u != mem_top - 4)
+ if(u != hold_head)
{
mem[u].hh.v.RH = mem[r].hh.v.RH;
- mem[r].hh.v.RH = mem[mem_top - 4].hh.v.RH;
+ mem[r].hh.v.RH = mem[hold_head].hh.v.RH;
r = u;
}
r = mem[mem[r].hh.v.RH].hh.v.RH;
/* compiler optimization does not refresh `mem' loaded in registers ? */
mem[q].hh.v.RH = new_null_box ();
p = mem[q].hh.v.RH;
- mem[p].hh.v.LH = mem_top - 9;
+ mem[p].hh.v.LH = end_span;
mem[p + 1].cint = -1073741824L; /* - 2^30 */
cur_loop = mem[cur_loop].hh.v.RH;
- q = mem_top - 4;
+ q = hold_head;
r = mem[cur_loop + 3].cint;
while(r != 0){
r = mem[r].hh.v.RH;
}
mem[q].hh.v.RH = 0;
- mem[p + 3].cint = mem[mem_top - 4].hh.v.RH;
- q = mem_top - 4;
+ mem[p + 3].cint = mem[hold_head].hh.v.RH;
+ q = hold_head;
r = mem[cur_loop + 2].cint;
while(r != 0){
r = mem[r].hh.v.RH;
}
mem[q].hh.v.RH = 0;
- mem[p + 2].cint = mem[mem_top - 4].hh.v.RH;
+ mem[p + 2].cint = mem[hold_head].hh.v.RH;
cur_loop = mem[cur_loop].hh.v.RH;
mem[p].hh.v.RH = new_glue(mem[cur_loop + 1].hh.v.LH);
}
goto lab10;
else pi = -10000;
nobreakyet = true;
- prevr = mem_top - 7;
+ prevr = active;
oldl = 0;
cur_active_width[1]= active_width[1];
cur_active_width[2]= active_width[2];
if(l > oldl)
{
if((minimum_demerits < 1073741823L)&& /* 2^30 - 1 */
- ((oldl != easyline)||(r == mem_top - 7)))
+ ((oldl != easyline)||(r == active)))
{
if(nobreakyet)
{
mem[prevr + 6].cint = mem[prevr + 6].cint - cur_active_width
[6]+ break_width[6];
}
- else if(prevr == mem_top - 7)
+ else if(prevr == active)
{
active_width[1]= break_width[1];
active_width[2]= break_width[2];
}
while(fitclass++ < for_end); }
minimum_demerits = 1073741823L; /* 2^30 - 1 */
- if(r != mem_top - 7)
+ if(r != active)
{
q = get_node(7);
mem[q].hh.v.RH = r;
prevr = q;
}
}
- if(r == mem_top - 7)
+ if(r == active)
goto lab10;
if(l > easyline)
{
if((b > 10000)||(pi == -10000))
{
if(final_pass &&(minimum_demerits == 1073741823L)&& /* 2^30 - 1 */
- (mem[r].hh.v.RH == mem_top - 7)&&(prevr == mem_top - 7))
+ (mem[r].hh.v.RH == active)&&(prevr == active))
artificialdemerits = true;
else if(b > threshold)
goto lab60;
goto lab22;
lab60: mem[prevr].hh.v.RH = mem[r].hh.v.RH;
free_node(r, 3);
- if(prevr == mem_top - 7)
+ if(prevr == active)
{
- r = mem[mem_top - 7].hh.v.RH;
+ r = mem[active].hh.v.RH;
if(mem[r].hh.b0 == 2)
{
active_width[1]= active_width[1]+ mem[r + 1].cint;
cur_active_width[4]= active_width[4];
cur_active_width[5]= active_width[5];
cur_active_width[6]= active_width[6];
- mem[mem_top - 7].hh.v.RH = mem[r].hh.v.RH;
+ mem[active].hh.v.RH = mem[r].hh.v.RH;
free_node(r, 7);
}
}
else if(mem[prevr].hh.b0 == 2)
{
r = mem[prevr].hh.v.RH;
- if(r == mem_top - 7)
+ if(r == active)
{
cur_active_width[1]= cur_active_width[1]- mem[prevr + 1]
.cint;
.cint;
cur_active_width[6]= cur_active_width[6]- mem[prevr + 6]
.cint;
- mem[prevprevr].hh.v.RH = mem_top - 7; /* prevprevr may be used ... */
+ mem[prevprevr].hh.v.RH = active; /* prevprevr may be used ... */
free_node(prevr, 7);
prevr = prevprevr;
}
}
else {
- q = mem_top - 3;
+ q = temp_head;
while(mem[q].hh.v.RH != 0)q = mem[q].hh.v.RH;
}
r = new_param_glue(8);
lab30:;
r = mem[q].hh.v.RH;
mem[q].hh.v.RH = 0;
- q = mem[mem_top - 3].hh.v.RH;
- mem[mem_top - 3].hh.v.RH = r;
+ q = mem[temp_head].hh.v.RH;
+ mem[temp_head].hh.v.RH = r;
if(eqtb[(hash_size + 789)].hh.v.RH != 0)
{
r = new_param_glue(7);
curwidth = mem[eqtb[(hash_size + 1312)].hh.v.RH + 2 * curline].cint;
curindent = mem[eqtb[(hash_size + 1312)].hh.v.RH + 2 * curline - 1].cint;
}
- adjust_tail = mem_top - 5;
+ adjust_tail = adjust_head;
just_box = hpack(q, curwidth, 0);
mem[just_box + 4].cint = curindent;
append_to_vlist(just_box);
/* if adjust_head<>adjust_tail then l.17346 */
- if(mem_top - 5 != adjust_tail)
+ if(adjust_head != adjust_tail)
{
- mem[tail].hh.v.RH = mem[mem_top - 5].hh.v.RH;
+ mem[tail].hh.v.RH = mem[adjust_head].hh.v.RH;
tail = adjust_tail;
}
adjust_tail = 0; /* adjust_tail:=null */
if(cur_p != 0)
if(! postdiscbreak)
{
- r = mem_top - 3;
+ r = temp_head;
while(true){
q = mem[r].hh.v.RH;
if(q == mem[cur_p + 1].hh.v.RH)
goto lab31;
r = q;
}
- lab31: if(r != mem_top - 3)
+ lab31: if(r != temp_head)
{
mem[r].hh.v.RH = 0;
- flush_node_list(mem[mem_top - 3].hh.v.RH);
- mem[mem_top - 3].hh.v.RH = q;
+ flush_node_list(mem[temp_head].hh.v.RH);
+ mem[temp_head].hh.v.RH = q;
}
}
} while(!(cur_p == 0));
- if((curline != best_line)||(mem[mem_top - 3].hh.v.RH != 0)) {
+ if((curline != best_line)||(mem[temp_head].hh.v.RH != 0)) {
confusion(933); /* disc2 */
return; // abort_flag set
}
scaled w;
font_index k;
hyphen_passed = 0; /* paragraph 907 ? */
- t = mem_top - 4;
+ t = hold_head;
w = 0;
- mem[mem_top - 4].hh.v.RH = 0;
+ mem[hold_head].hh.v.RH = 0;
cur_l = hu[j];
cur_q = t;
if(j == 0)
j = reconstitute(j, hn, bchar, hyf_char)+ 1;
if(hyphen_passed == 0)
{
- mem[s].hh.v.RH = mem[mem_top - 4].hh.v.RH;
+ mem[s].hh.v.RH = mem[hold_head].hh.v.RH;
/* while(mem[s].hh.v.RH > 0)*/ /* 94/Mar/22 */
while(mem[s].hh.v.RH != 0) /* l.17903 */
s = mem[s].hh.v.RH;
{
l = j;
hyphen_passed = j - 1;
- mem[mem_top - 4].hh.v.RH = 0; /* link(hold_head):=null; */
+ mem[hold_head].hh.v.RH = 0; /* link(hold_head):=null; */
}
}
if(hyphen_passed > 0)
do {
r = get_node(2);
- mem[r].hh.v.RH = mem[mem_top - 4].hh.v.RH;
+ mem[r].hh.v.RH = mem[hold_head].hh.v.RH;
mem[r].hh.b0 = 7;
majortail = r;
rcount = 0;
/* begin l:=reconstitute(l,i,font_bchar[hf],non_char)+1; l.17948 */
l = reconstitute(l, i, font_bchar[hf], 256)+ 1;
/* if link(hold_head)>null then l.17949 */
-/* if(mem[mem_top - 4].hh.v.RH > 0)*/ /* 94/Mar/22 */
- if(mem[mem_top - 4].hh.v.RH != 0) /* BUG FIX ??? */
+/* if(mem[hold_head].hh.v.RH > 0)*/ /* 94/Mar/22 */
+ if(mem[hold_head].hh.v.RH != 0) /* BUG FIX ??? */
{
if(minortail == 0)/* if minor_tail=null then */
- mem[r + 1].hh.v.LH = mem[mem_top - 4].hh.v.RH;
- else mem[minortail].hh.v.RH = mem[mem_top - 4].hh.v.RH;
- minortail = mem[mem_top - 4].hh.v.RH;
+ mem[r + 1].hh.v.LH = mem[hold_head].hh.v.RH;
+ else mem[minortail].hh.v.RH = mem[hold_head].hh.v.RH;
+ minortail = mem[hold_head].hh.v.RH;
/* while link(minor_tail)>null do minor_tail:=link(minor_tail); l.17953 */
/* while(mem[minortail].hh.v.RH > 0)*/ /* 94/Mar/22 */
while(mem[minortail].hh.v.RH != 0) /* BUG FIX */
cloc = 0;
}
/* if link(hold_head)>null then l. l.17973 */
-/* if(mem[mem_top - 4].hh.v.RH > 0) */ /* 94/Mar/22 ??? */
- if(mem[mem_top - 4].hh.v.RH != 0) /* BUG FIX */
+/* if(mem[hold_head].hh.v.RH > 0) */ /* 94/Mar/22 ??? */
+ if(mem[hold_head].hh.v.RH != 0) /* BUG FIX */
{
if(minortail == 0)/* begin if minor_tail=null then */
- mem[r + 1].hh.v.RH = mem[mem_top - 4].hh.v.RH;
- else mem[minortail].hh.v.RH = mem[mem_top - 4].hh.v.RH;
- minortail = mem[mem_top - 4].hh.v.RH;
+ mem[r + 1].hh.v.RH = mem[hold_head].hh.v.RH;
+ else mem[minortail].hh.v.RH = mem[hold_head].hh.v.RH;
+ minortail = mem[hold_head].hh.v.RH;
/* while link(minor_tail)>null do minor_tail:=link(minor_tail); l.17977 */
/* while(mem[minortail].hh.v.RH > 0)*/ /* 94/Mar/22 */
while(mem[minortail].hh.v.RH != 0) /* ??? */
while(l > j){
j = reconstitute(j, hn, bchar, 256)+ 1;
- mem[majortail].hh.v.RH = mem[mem_top - 4].hh.v.RH;
+ mem[majortail].hh.v.RH = mem[hold_head].hh.v.RH;
/* while link(major_tail)>null do advance_major_tail; l.17987 */
/* while(mem[majortail].hh.v.RH > 0){ */ /* 94/Mar/22 */
while(mem[majortail].hh.v.RH != 0){ /* ??? */
}
s = majortail;
hyphen_passed = j - 1;
- mem[mem_top - 4].hh.v.RH = 0; /* link(hold_head):=null; */
+ mem[hold_head].hh.v.RH = 0; /* link(hold_head):=null; */
} while(!(! odd(hyf[j - 1])));
} while(!(j > hn));
mem[s].hh.v.RH = q;
{register halfword Result;
halfword prevp;
halfword q;
- prevp = mem_top - 3;
- mem[mem_top - 3].hh.v.RH = p;
+ prevp = temp_head;
+ mem[temp_head].hh.v.RH = p;
/* while p<>null do l.18803 */
while(p != 0)switch(mem[p].hh.b0)
{case 0 :
}
break;
}
- Result = mem[mem_top - 3].hh.v.RH;
+ Result = mem[temp_head].hh.v.RH;
return Result;
}
halfword vert_break_(halfword p, scaled h, scaled d)
r = mem[r].hh.v.RH;
}
}
- q = mem_top - 4;
+ q = hold_head;
mem[q].hh.v.RH = 0;
- prevp = mem_top - 2;
+ prevp = page_head;
p = mem[prevp].hh.v.RH;
while(p != best_page_break){
eqtb[(hash_size + 792)].hh.v.RH = savesplittopskip;
if(p != 0) /* if p<>null then l.19730 */
{
- if(mem[mem_top - 1].hh.v.RH == 0)/* if link(contrib_head)=null then */
+ if(mem[contrib_head].hh.v.RH == 0)/* if link(contrib_head)=null then */
if(nest_ptr == 0)
tail = page_tail;
else nest[0].tail_field = page_tail;
- mem[page_tail].hh.v.RH = mem[mem_top - 1].hh.v.RH;
- mem[mem_top - 1].hh.v.RH = p;
+ mem[page_tail].hh.v.RH = mem[contrib_head].hh.v.RH;
+ mem[contrib_head].hh.v.RH = p;
mem[prevp].hh.v.RH = 0; /* link(prev_p):=null; */
}
savevbadness = eqtb[(hash_size + 3190)].cint;
eqtb[(hash_size + 3190)].cint = 10000;
savevfuzz = eqtb[(hash_size + 3739)].cint;
eqtb[(hash_size + 3739)].cint = 1073741823L; /* 2^30 - 1 */
- eqtb[(hash_size + 1833)].hh.v.RH = vpackage(mem[mem_top - 2].hh.v.RH,
+ eqtb[(hash_size + 1833)].hh.v.RH = vpackage(mem[page_head].hh.v.RH,
best_size, 0, page_max_depth);
eqtb[(hash_size + 3190)].cint = savevbadness;
eqtb[(hash_size + 3739)].cint = savevfuzz;
if(last_glue != empty_flag)
delete_glue_ref(last_glue);
page_contents = 0;
- page_tail = mem_top - 2;
- mem[mem_top - 2].hh.v.RH = 0;
+ page_tail = page_head;
+ mem[page_head].hh.v.RH = 0;
/* last_glue = 262143L; */
last_glue = empty_flag;
last_penalty = 0;
last_kern = 0;
page_so_far[7]= 0;
page_max_depth = 0;
- if(q != mem_top - 4)
+ if(q != hold_head)
{
- mem[mem_top - 2].hh.v.RH = mem[mem_top - 4].hh.v.RH;
+ mem[page_head].hh.v.RH = mem[hold_head].hh.v.RH;
page_tail = q;
}
r = mem[mem_top].hh.v.RH;
return;
}
{
- if(mem[mem_top - 2].hh.v.RH != 0)
+ if(mem[page_head].hh.v.RH != 0)
{
- if(mem[mem_top - 1].hh.v.RH == 0)
+ if(mem[contrib_head].hh.v.RH == 0)
if(nest_ptr == 0)
tail = page_tail;
else nest[0].tail_field = page_tail;
- else mem[page_tail].hh.v.RH = mem[mem_top - 1].hh.v.RH;
- mem[mem_top - 1].hh.v.RH = mem[mem_top - 2].hh.v.RH;
- mem[mem_top - 2].hh.v.RH = 0;
- page_tail = mem_top - 2;
+ else mem[page_tail].hh.v.RH = mem[contrib_head].hh.v.RH;
+ mem[contrib_head].hh.v.RH = mem[page_head].hh.v.RH;
+ mem[page_head].hh.v.RH = 0;
+ page_tail = page_head;
}
ship_out(eqtb[(hash_size + 1833)].hh.v.RH);
eqtb[(hash_size + 1833)].hh.v.RH = 0;
scaled delta, h, w;
/* begin if (link(contrib_head)=null)or output_active then return; l.19351 */
- if((mem[mem_top - 1].hh.v.RH == 0)|| output_active)
+ if((mem[contrib_head].hh.v.RH == 0)|| output_active)
return;
do {
- lab22: p = mem[mem_top - 1].hh.v.RH;
+ lab22: p = mem[contrib_head].hh.v.RH;
/* if(last_glue != 262143L) */
if(last_glue != empty_flag)
delete_glue_ref(last_glue);
else
mem[temp_ptr + 1].cint = 0;
mem[q].hh.v.RH = p;
- mem[mem_top - 1].hh.v.RH = q;
+ mem[contrib_head].hh.v.RH = q;
goto lab22;
}
else {
}
mem[page_tail].hh.v.RH = p;
page_tail = p;
- mem[mem_top - 1].hh.v.RH = mem[p].hh.v.RH;
+ mem[contrib_head].hh.v.RH = mem[p].hh.v.RH;
mem[p].hh.v.RH = 0;
goto lab30;
- lab31: mem[mem_top - 1].hh.v.RH = mem[p].hh.v.RH;
+ lab31: mem[contrib_head].hh.v.RH = mem[p].hh.v.RH;
mem[p].hh.v.RH = 0;
flush_node_list(p);
lab30:;
- } while(!(mem[mem_top - 1].hh.v.RH == 0));
+ } while(!(mem[contrib_head].hh.v.RH == 0));
if(nest_ptr == 0)
- tail = mem_top - 1;
- else nest[0].tail_field = mem_top - 1;
+ tail = contrib_head;
+ else nest[0].tail_field = contrib_head;
}
/* sec 1043 */
void app_space (void)
register bool Result;
if(privileged ())
{
- if((mem_top - 2 == page_tail) && (head == cur_list.tail_field) && (dead_cycles == 0))
+ if((page_head == page_tail) && (head == cur_list.tail_field) && (dead_cycles == 0))
{
Result = true;
return(Result);
back_input ();
p = get_avail ();
- mem[mem_top - 3].hh.v.RH = p;
+ mem[temp_head].hh.v.RH = p;
print_err("Missing ");
switch(cur_group)
{case 14 :
break;
}
print_string(" inserted");
- begin_token_list(mem[mem_top - 3].hh.v.RH, 4);
+ begin_token_list(mem[temp_head].hh.v.RH, 4);
help5("I've inserted something that you may have forgotten.",
"(See the <inserted text> above.)",
"With luck, this will get me unwedged. But if you",
append_to_vlist(cur_box);
if(adjust_tail != 0)
{
- if(mem_top - 5 != adjust_tail)
+ if(adjust_head != adjust_tail)
{
- mem[tail].hh.v.RH = mem[mem_top - 5].hh
+ mem[tail].hh.v.RH = mem[adjust_head].hh
.v.RH;
tail = adjust_tail;
}
break;
case 6 :
{
- mem[mem_top - 12]= mem[p + 1];
- mem[mem_top - 12].hh.v.RH = mem[p].hh.v.RH;
- p = mem_top - 12;
+ mem[lig_trick]= mem[p + 1];
+ mem[lig_trick].hh.v.RH = mem[p].hh.v.RH;
+ p = lig_trick;
goto lab21;
}
break;
{
if(c >= 3)
{
- scan_delimiter(mem_top - 12, false);
- scan_delimiter(mem_top - 12, false);
+ scan_delimiter(lig_trick, false);
+ scan_delimiter(lig_trick, false);
}
if(c % 3 == 0)
scan_dimen(false, false, false);
{
if(cur_group == 15)
{
- scan_delimiter(mem_top - 12, false);
+ scan_delimiter(lig_trick, false);
print_err("Extra ");
print_esc("right");
help1("I'm ignoring a \\right that had no matching \\left.");
cur_style = 2;
mlist_penalties = false;
mlist_to_hlist ();
- a = hpack(mem[mem_top - 3].hh.v.RH, 0, 1);
+ a = hpack(mem[temp_head].hh.v.RH, 0, 1);
unsave ();
decr(save_ptr);
if(save_stack[save_ptr + 0].cint == 1)
cur_style = 2;
mlist_penalties =(mode > 0);
mlist_to_hlist ();
- mem[tail].hh.v.RH = mem[mem_top - 3].hh.v.RH;
+ mem[tail].hh.v.RH = mem[temp_head].hh.v.RH;
while(mem[tail].hh.v.RH != 0)tail =
mem[tail].hh.v.RH;
{
cur_style = 0;
mlist_penalties = false;
mlist_to_hlist ();
- p = mem[mem_top - 3].hh.v.RH;
- adjust_tail = mem_top - 5;
+ p = mem[temp_head].hh.v.RH;
+ adjust_tail = adjust_head;
b = hpack(p, 0, 1);
p = mem[b + 5].hh.v.RH;
t = adjust_tail;
append_to_vlist(a);
g2 = 0;
}
- if(t != mem_top - 5)
+ if(t != adjust_head)
{
- mem[tail].hh.v.RH = mem[mem_top - 5].hh.v.RH;
+ mem[tail].hh.v.RH = mem[adjust_head].hh.v.RH;
tail = t;
}
{
char c;
str_number s;
c = cur_chr;
- mem[mem_top - 12].hh.v.RH = scan_toks(false, true);
+ mem[lig_trick].hh.v.RH = scan_toks(false, true);
old_setting = selector;
selector = 21;
token_show(def_ref);
if(interaction == 3)
;
print_nl(" > "); /* */
- token_show(mem_top - 3);
- flush_list(mem[mem_top - 3].hh.v.RH);
+ token_show(temp_head);
+ flush_list(mem[temp_head].hh.v.RH);
goto lab50;
}
break;
break;
case 3 :
{
- adjust_tail = mem_top - 5;
+ adjust_tail = adjust_head;
package(0);
}
break;
mem[page_tail].hh.v.RH = mem[head].hh.v.RH;
page_tail = tail;
}
- if(mem[mem_top - 2].hh.v.RH != 0)
+ if(mem[page_head].hh.v.RH != 0)
{
- if(mem[mem_top - 1].hh.v.RH == 0)
+ if(mem[contrib_head].hh.v.RH == 0)
nest[0].tail_field = page_tail;
- mem[page_tail].hh.v.RH = mem[mem_top - 1].hh.v.RH;
- mem[mem_top - 1].hh.v.RH = mem[mem_top - 2].hh.v.RH;
- mem[mem_top - 2].hh.v.RH = 0;
- page_tail = mem_top - 2;
+ mem[page_tail].hh.v.RH = mem[contrib_head].hh.v.RH;
+ mem[contrib_head].hh.v.RH = mem[page_head].hh.v.RH;
+ mem[page_head].hh.v.RH = 0;
+ page_tail = page_head;
}
pop_nest ();
build_page ();
integer k;
if (closed_already++) {
- show_line("CLOSEDFILESANDTERMINATED ALREADY ", 0);
+ show_line("close_files_and_terminated already ", 0);
return; // sanity check
}
- if (trace_flag) show_line("\nCLOSEFILESANDTERMINATE ", 0);
+ if (trace_flag) show_line("\nclose_files_and_terminate ", 0);
// close all open files
{
register integer for_end;
/* if tracing_stats>0 then @<Output statistics about this job@>; */
/* if(eqtb[(hash_size + 3194)].cint > 0) */
if(eqtb[(hash_size + 3194)].cint > 0 ||
-/* trace_flag != 0) *//* 93/Nov/30 - bkph */
verbose_flag != 0) /* 93/Nov/30 - bkph */
if(log_opened) {
/* used to output paragraph breaking statistics here */
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
if(dvi_limit == half_buf)writedvi(half_buf, dvi_buf_size - 1);
if(dvi_ptr > 0)writedvi(0, dvi_ptr - 1);
- print_nl("Output written on "); /* */
- if (full_file_name_flag && dvi_file_name != NULL)
- print_char_string((unsigned char *)dvi_file_name);
- else slow_print(output_file_name);
+ print_nl("Output written on ");
+ if (full_file_name_flag && dvi_file_name != NULL)
+ print_char_string((unsigned char *) dvi_file_name);
+ else
+ slow_print(output_file_name);
print_string(" (");
print_int(total_pages);
print_string(" page");
- if(total_pages != 1) print_char(115); /* s */
+ if (total_pages != 1) print_char('s');
print_string(", ");
print_int(dvi_offset + dvi_ptr);
- print_string("bytes).");
+ print_string(" bytes).");
b_close(dvi_file);
}
if(log_opened) {
- (void) putc ('\n', log_file);
+ (void) putc ('\n', log_file);
(void) a_close(log_file);
selector = selector - 2;
if(selector == 17) {
- print_nl("Transcript written on "); /* */
- if (full_file_name_flag && log_file_name != NULL)
- print_char_string((unsigned char *)log_file_name);
- else slow_print(texmf_log_name);
- print_char(46); /* . */
+ print_nl("Transcript written on ");
+ if (full_file_name_flag && log_file_name != NULL)
+ print_char_string((unsigned char *) log_file_name);
+ else
+ slow_print(texmf_log_name);
+ print_char('.');
}
}
print_ln ();
- if((edit_name_start != 0)&&(interaction > 0)) {
+ if ((edit_name_start != 0) && (interaction > 0)) {
call_edit(str_pool, edit_name_start, edit_name_length, edit_line);
}
} /* end of close_files_and_terminate */
{/* 888 10 */
integer k, l, m, n;
while(true){
-
;
print_nl(" debug # (-1 to exit):"); /* */
#ifndef _WINDOWS
zzzac[mem_max - mem_bot + 1];
#endif
-EXTERN halfword wasmemend, waslomax, washimin;
+EXTERN halfword was_mem_end, was_lo_max, was_hi_min;
EXTERN bool panicking;
#endif /* DEBUG */
#define float_cost(a) mem[a + 1].cint
#define ins_ptr(a) info(a + 4)
#define split_top_ptr(a) link(a + 4)
+/* sec 0162 */
+#define contrib_head mem_top - 1
+#define page_head mem_top - 2
+#define temp_head mem_top - 3
+#define hold_head mem_top - 4
+#define adjust_head mem_top - 5
+#define active mem_top - 7
+#define align_head mem_top - 8
+#define end_span mem_top - 9
+#define omit_template mem_top - 10
+#define null_list mem_top - 11
+#define lig_trick mem_top - 12
+/* sec 0207 */
+#define escape 0
+#define relax 0
+#define left_brace 1
+#define right_brace 2
+#define math_shift 3
+#define tab_mark 4
+#define car_ret 5
+#define out_param 5
+#define mac_param 6
+#define sup_mark 7
+#define sub_mark 8
+#define ignore 9
+#define endv 9
+#define spacer 10
+#define letter 11
+#define other_char 12
+#define active_char 13
+#define par_end 13
+#define match 13
+#define comment 14
+#define end_match 14
+#define stop 14
+#define invalid_char 15
+#define delim_num 15
+#define max_char_code 15
+/* sec 0208 */
+#define char_num 16
+#define math_char_num 17
+#define mark 18
+#define xray 19
+#define make_box 20
+#define hmove 21
+#define vmove 22
+#define un_hbox 23
+#define un_vbox 24
+#define remove_item 25
+#define hskip 26
+#define vskip 27
+#define mskip 28
+#define kern 29
+#define mkern 30
+#define leader_ship 31
+#define halign 32
+#define valign 33
+#define no_align 34
+#define vrule 35
+#define hrule 36
+#define insert 37
+#define vadjust 38
+#define ignore_spaces 39
+#define after_assignment 40
+#define after_group 41
+#define break_penalty 42
+#define start_par 43
+#define ital_corr 44
+#define accent 45
+#define math_accent 46
+#define discretionary 47
+#define eq_no 48
+#define left_right 49
+#define math_comp 50
+#define limit_switch 51
+#define above 52
+#define math_style 53
+#define math_choice 54
+#define non_script 55
+#define vcenter 56
+#define case_shift 57
+#define message 58
+#define extension 59
+#define in_stream 60
+#define begin_group 61
+#define end_group 62
+#define omit 63
+#define ex_space 64
+#define no_boundary 65
+#define radical 66
+#define end_cs_name 67
+#define min_internal 68
+#define char_given 68
+#define math_given 69
+#define last_item 70
+#define max_non_prefixed_command 70
+/* sec 0209 */
+#define toks_register 71
+#define assign_toks 72
+#define assign_int 73
+#define assign_dimen 74
+#define assign_glue 75
+#define assign_mu_glue 76
+#define assign_font_dimen 77
+#define assign_font_int 78
+#define set_aux 79
+#define set_prev_graf 80
+#define set_page_dimen 81
+#define set_page_int 82
+#define set_box_dimen 83
+#define set_shape 84
+#define def_code 85
+#define def_family 86
+#define set_font 87
+#define def_font 88
+#define tex_register 89
+#define max_internal 89
+#define advance 90
+#define multiply 91
+#define divide 92
+#define prefix 93
+#define let 94
+#define shorthand_def 95
+#define read_to_cs 96
+#define def 97
+#define set_box 98
+#define hyph_data 99
+#define set_interaction 100
+#define max_command 100
+/* sec 0210 */
+#define undefined_cs max_command + 1
+#define expand_after max_command + 2
+#define no_expand max_command + 3
+#define input max_command + 4
+#define if_test max_command + 5
+#define fi_or_else max_command + 6
+#define cs_name max_command + 7
+#define convert max_command + 8
+#define the max_command + 9
+#define top_bot_mark max_command + 10
+#define call max_command + 11
+#define long_call max_command + 12
+#define outer_call max_command + 13
+#define long_outer_call max_command + 14
+#define end_template max_command + 15
+#define dont_expand max_command + 16
+#define glue_ref max_command + 17
+#define shape_ref max_command + 18
+#define box_ref max_command + 19
+#define data max_command + 20
/* sec 0212 */
#define ignore_depth -65536000L
/* sec 0213 */
OSDN Git Service
