-#ifdef _WINDOWS
- #define NOCOMM
- #define NOSOUND
- #define NODRIVERS
- #define STRICT
- #pragma warning(disable:4115) // kill rpcasync.h complaint
- #include <windows.h>
- #define MYLIBAPI __declspec(dllexport)
-#endif
+/* Copyright 2014 Clerk Ma
-#include "texwin.h"
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-#pragma warning(disable:4996)
-#pragma warning(disable:4131) // old style declarator
-#pragma warning(disable:4135) // conversion between different integral types
-#pragma warning(disable:4127) // conditional expression is constant
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
-#include <setjmp.h>
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA. */
#define EXTERN extern
#include "texd.h"
-#pragma warning(disable:4244) /* 96/Jan/10 */
-
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
/* sec 0198 */
-void show_box_(halfword p)
+void show_box_(pointer p)
{
depth_threshold = show_box_depth;
breadth_max = show_box_breadth;
#ifdef ALLOCATESTRING
if (pool_ptr + depth_threshold >= current_pool_size)
str_pool = realloc_str_pool(increment_pool_size);
+
if (pool_ptr + depth_threshold >= current_pool_size)
depth_threshold = current_pool_size - pool_ptr - 1;
#else
if (pool_ptr + depth_threshold >= pool_size)
depth_threshold = pool_size - pool_ptr - 1;
#endif
+
show_node_list(p);
print_ln();
}
/* sec 0200 */
-void delete_token_ref_(halfword p)
+void delete_token_ref_(pointer p)
{
if (token_ref_count(p) == 0)
flush_list(p);
decr(token_ref_count(p));
}
/* sec 0201 */
-void delete_glue_ref_(halfword p)
+void delete_glue_ref_(pointer p)
{
if (glue_ref_count(p) == 0)
free_node(p, glue_spec_size);
decr(glue_ref_count(p));
}
/* sec 0202 */
-void flush_node_list_(halfword p)
+void flush_node_list_(pointer p)
{
- halfword q;
- while (p != 0) { /* while p<>null */
+ pointer q;
+
+ while (is_char_node(p))
+ {
q = link(p);
if (is_char_node(p))
free_avail(p);
else
{
- switch (mem[p].hh.b0)
+ switch (type(p))
{
case hlist_node:
case vlist_node:
{
switch (subtype(p))
{
- case 0:
- free_node(p, 3);
+ case open_node:
+ free_node(p, open_node_size);
break;
- case 1:
- case 3:
+ case write_node:
+ case special_node:
{
- delete_token_ref(mem[p + 1].hh.v.RH);
- free_node(p, 2);
+ delete_token_ref(write_tokens(p));
+ free_node(p, write_node_size);
goto lab30;
}
break;
- case 2:
- case 4:
- free_node(p, 2);
+ case close_node:
+ case set_language_code:
+ free_node(p, small_node_size);
break;
default:
{
break;
case glue_node:
{
- if (mem[mem[p + 1].hh.v.LH].hh.v.RH == 0)
- free_node(mem[p + 1].hh.v.LH, 4);
+ if (mem[mem[p + 1].hh.lh].hh.rh == 0)
+ free_node(mem[p + 1].hh.lh, 4);
else
- decr(mem[mem[p + 1].hh.v.LH].hh.v.RH);
+ decr(mem[mem[p + 1].hh.lh].hh.rh);
}
if (leader_ptr(p) != 0)
case adjust_node:
flush_node_list(adjust_ptr(p));
break;
- case 14:
+ case style_node:
{
- free_node(p, 3);
+ free_node(p, style_node_size);
goto lab30;
}
break;
- case 15 :
+ case choice_node:
{
- flush_node_list(mem[p + 1].hh.v.LH);
- flush_node_list(mem[p + 1].hh.v.RH);
- flush_node_list(mem[p + 2].hh.v.LH);
- flush_node_list(mem[p + 2].hh.v.RH);
- free_node(p, 3);
+ flush_node_list(display_mlist(p));
+ flush_node_list(text_mlist(p));
+ flush_node_list(script_mlist(p));
+ flush_node_list(script_script_mlist(p));
+ free_node(p, style_node_size);
goto lab30;
}
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 ord_noad:
+ case op_noad:
+ case bin_noad:
+ case rel_noad:
+ case open_noad:
+ case close_noad:
+ case punct_noad:
+ case inner_noad:
+ case radical_noad:
+ case over_noad:
+ case under_noad:
+ case vcenter_noad:
+ case accent_noad:
{
- if (mem[p + 1].hh.v.RH >= 2)
- flush_node_list(mem[p + 1].hh.v.LH);
- if (mem[p + 2].hh.v.RH >= 2)
- flush_node_list(mem[p + 2].hh.v.LH);
- if (mem[p + 3].hh.v.RH >= 2)
- flush_node_list(mem[p + 3].hh.v.LH);
- if (mem[p].hh.b0 == 24)
- free_node(p, 5);
- else if (mem[p].hh.b0 == 28)
- free_node(p, 5);
+ if (math_type(nucleus(p)) >= sub_box)
+ flush_node_list(info(nucleus(p)));
+
+ if (math_type(supscr(p)) >= sub_box)
+ flush_node_list(info(supscr(p)));
+
+ if (math_type(subscr(p)) >= sub_box)
+ flush_node_list(info(subscr(p)));
+
+ if (type(p) == radical_noad)
+ free_node(p, radical_noad_size);
else
- free_node(p, 4);
+ {
+ if (type(p) == accent_noad)
+ free_node(p, accent_noad_size);
+ else
+ free_node(p, noad_size);
+ }
goto lab30;
}
break;
- case 30:
- case 31:
+ case left_noad:
+ case right_noad:
{
- free_node(p, 4);
+ free_node(p, noad_size);
goto lab30;
}
break;
- case 25:
+ case fraction_noad:
{
- flush_node_list(mem[p + 2].hh.v.LH);
- flush_node_list(mem[p + 3].hh.v.LH);
- free_node(p, 6);
+ flush_node_list(info(numerator(p)));
+ flush_node_list(info(denominator(p)));
+ free_node(p, fraction_noad_size);
goto lab30;
}
break;
}
break;
}
- free_node(p, 2);
+
+ free_node(p, small_node_size);
lab30:;
}
+
p = q;
}
}
/* sec 0204 */
-halfword copy_node_list_(halfword p)
+pointer copy_node_list_(pointer p)
{
- register halfword Result;
- halfword h;
- halfword q;
- halfword r;
+ pointer h;
+ pointer q;
+ pointer r;
char words;
h = get_avail();
q = h;
- while (p != 0) { /* while p<>null do l.3969 */
+
+ while (p != 0)
+ {
words = 1;
+
if ((p >= hi_mem_min))
r = get_avail();
- else switch (mem[p].hh.b0)
+ else switch (type(p))
{
case hlist_node:
case vlist_node:
case unset_node:
{
r = get_node(box_node_size);
- mem[r + 6]= mem[p + 6];
- mem[r + 5]= mem[p + 5];
- mem[r + 5].hh.v.RH = copy_node_list(mem[p + 5].hh.v.RH);
+ mem[r + 6] = mem[p + 6];
+ mem[r + 5] = mem[p + 5];
+ list_ptr(r) = copy_node_list(list_ptr(p));
words = 5;
}
break;
case rule_node:
{
- r = get_node(4);
- words = 4;
+ r = get_node(rule_node_size);
+ words = rule_node_size;
}
break;
- case 3:
+ case ins_node:
{
- r = get_node(5);
- mem[r + 4]= mem[p + 4];
- incr(mem[mem[p + 4].hh.v.RH].hh.v.RH);
- mem[r + 4].hh.v.LH = copy_node_list(mem[p + 4].hh.v.LH);
- words = 4;
+ r = get_node(ins_node_size);
+ mem[r + 4] = mem[p + 4];
+ add_glue_ref(split_top_ptr(p));
+ ins_ptr(r) = copy_node_list(ins_ptr(p));
+ words = ins_node_size - 1;
}
break;
- case 8:
- switch (mem[p].hh.b1)
+ case whatsit_node:
+ switch (subtype(p))
{
- case 0:
+ case open_node:
{
- r = get_node(3);
- words = 3;
+ r = get_node(open_node_size);
+ words = open_node_size;
}
break;
- case 1:
- case 3:
+
+ case write_node:
+ case special_node:
{
- r = get_node(2);
- incr(mem[mem[p + 1].hh.v.RH].hh.v.LH);
- words = 2;
+ r = get_node(write_node_size);
+ add_token_ref(write_tokens(p));
+ words = write_node_size;
}
break;
- case 2:
- case 4:
+
+ case close_node:
+ case language_node:
{
- r = get_node(2);
- words = 2;
+ r = get_node(small_node_size);
+ words = small_node_size;
}
break;
+
default:
{
confusion("ext2");
break;
}
break;
- case 10:
+
+ case glue_node:
{
- r = get_node(2);
- incr(mem[mem[p + 1].hh.v.LH].hh.v.RH);
- mem[r + 1].hh.v.LH = mem[p + 1].hh.v.LH;
- mem[r + 1].hh.v.RH = copy_node_list(mem[p + 1].hh.v.RH);
+ r = get_node(small_node_size);
+ add_glue_ref(glue_ptr(p));
+ glue_ptr(r) = glue_ptr(p);
+ leader_ptr(r) = copy_node_list(leader_ptr(p));
}
break;
- case 11:
- case 9:
- case 12:
+
+ case kern_node:
+ case math_node:
+ case penalty_node:
{
- r = get_node(2);
- words = 2;
+ r = get_node(small_node_size);
+ words = small_node_size;
}
break;
- case 6:
+
+ case ligature_node:
{
- r = get_node(2);
- mem[r + 1]= mem[p + 1];
- mem[r + 1].hh.v.RH = copy_node_list(mem[p + 1].hh.v.RH);
+ r = get_node(small_node_size);
+ mem[lig_char(r)] = mem[lig_char(p)];
+ lig_ptr(r) = copy_node_list(lig_ptr(p));
}
break;
- case 7:
+
+ case disc_node:
{
- r = get_node(2);
- mem[r + 1].hh.v.LH = copy_node_list(mem[p + 1].hh.v.LH);
- mem[r + 1].hh.v.RH = copy_node_list(mem[p + 1].hh.v.RH);
+ r = get_node(small_node_size);
+ pre_break(r) = copy_node_list(pre_break(p));
+ post_break(r) = copy_node_list(pre_break(p));
}
break;
- case 4:
+
+ case mark_node:
{
- r = get_node(2);
- incr(mem[mem[p + 1].cint].hh.v.LH);
- words = 2;
+ r = get_node(small_node_size);
+ add_token_ref(mark_ptr(p));
+ words = small_node_size;
}
break;
- case 5:
+
+ case adjust_node:
{
- r = get_node(2);
- mem[r + 1].cint = copy_node_list(mem[p + 1].cint);
+ r = get_node(small_node_size);
+ adjust_ptr(r) = copy_node_list(adjust_ptr(p));
}
break;
+
default:
{
confusion("copying");
}
break;
}
- while (words > 0) {
+
+ while (words > 0)
+ {
decr(words);
- mem[r + words]= mem[p + words]; /* r may be used without having ... */
+ mem[r + words] = mem[p + words]; /* r may be used without having ... */
}
- mem[q].hh.v.RH = r;
+
+ link(q) = r;
q = r;
- p = mem[p].hh.v.RH;
+ p = link(p);
}
- mem[q].hh.v.RH = 0;
- q = mem[h].hh.v.RH;
- {
- mem[h].hh.v.RH = avail;
- avail = h;
- ;
-#ifdef STAT
- decr(dyn_used);
-#endif /* STAT */
- }
- Result = q;
- return Result;
+
+ link(q) = 0;
+ q = link(h);
+ free_avail(h);
+
+ return q;
}
/* sec 0211 */
void print_mode_(integer m)
{
if (m > 0)
- switch (m /(101))
+ {
+ switch (m / (max_command + 1))
{
case 0:
print_string("vertical");
print_string("display math");
break;
}
+ }
else
+ {
if (m == 0)
+ {
print_string("no");
- else
- switch ((- (integer) m)/(101))
+ }
+ else
{
- case 0:
- print_string("internal vertical");
- break;
- case 1:
- print_string("restricted horizontal");
- break;
- case 2:
- print_string("math");
- break;
+ switch ((- (integer) m) / (max_command + 1))
+ {
+ case 0:
+ print_string("internal vertical");
+ break;
+ case 1:
+ print_string("restricted horizontal");
+ break;
+ case 2:
+ print_string("math");
+ break;
+ }
}
+ }
+
print_string(" mode");
}
/* sec 0216 */
if (nest_ptr > max_nest_stack)
{
max_nest_stack = nest_ptr;
+
#ifdef ALLOCATEINPUTSTACK
if (nest_ptr == current_nest_size)
nest = realloc_nest_stack(increment_nest_size);
- if (nest_ptr == current_nest_size) { /* check again after allocation */
+
+ if (nest_ptr == current_nest_size)
+ {
overflow("semantic nest size", current_nest_size);
return; // abort_flag set
}
#else
- if (nest_ptr == nest_size) {
- overflow("semantic nest size", nest_size); /* semantic next size - not dynamic */
+ if (nest_ptr == nest_size)
+ {
+ overflow("semantic nest size", nest_size);
return; // abort_flag set
}
#endif
}
+
nest[nest_ptr]= cur_list;
incr(nest_ptr);
head = get_avail();
memory_word a;
halfword q, r;
integer t;
- nest[nest_ptr]= cur_list;
- print_nl(" ");
- print_ln();
+
+ nest[nest_ptr] = cur_list;
+ print_nl("");
+ print_ln();
+
+ for (p = nest_ptr; p >= 0; p--)
{
- register integer for_end;
- p = nest_ptr;
- for_end = 0;
- if (p >= for_end) do
+ m = nest[p].mode_field;
+ a = nest[p].aux_field;
+ print_nl("### ");
+ print_mode(m);
+ print_string(" entered at line ");
+ print_int(abs(nest[p].ml_field));
+
+ if (m == hmode)
{
- m = nest[p].mode_field;
- a = nest[p].aux_field;
- print_nl("### ");
- print_mode(m);
- print_string(" entered at line ");
- print_int(abs(nest[p].ml_field));
- if (m == 102)
-/* ************************************************************************ */
-/* major change from 3.141 -> 3.14159 in following */
-/*.pg_field instead of .lhmfield and .rhmfield */
-/* WAS if ((nest[p].lhmfield != 2)||(nest[p].rhmfield != 3)) */
- if (nest[p].pg_field != 8585216L) /* 830000 hex ??? */
- {
- print_string(" (language");
- print_int(nest[p].pg_field % 65536L); /* last 16 bits */
-/* print_int(nest[p].pg_field & 65535L); */
- print_string(":hyphenmin");
- print_int(nest[p].pg_field / 4194304L); /* 400000 hex ??? */
-/* print_int(nest[p].pg_field >> 22); */ /* top 10 bits */
- print_char(',');
- print_int((nest[p].pg_field / 65536L)% 64);
-/* print_int((nest[p].pg_field >> 16)& 63); */ /* next 8 bits */
-/* this used to refer to .lhmfield and .rhmfield ... */
-/* ********************************************************************* */
- print_char(')');
- }
- if (nest[p].ml_field < 0)
- print_string(" (\\output routine)");
- if (p == 0)
+ if (nest[p].pg_field != 040600000)
{
- if (page_head != page_tail)
- {
- print_nl("### current page:");
- if (output_active)
- print_string(" (held over for next output)");
- show_box(mem[page_head].hh.v.RH);
- if (page_contents > 0)
- {
- print_nl("total height ");
- print_totals();
- print_nl("goal height ");
- print_scaled(page_so_far[0]);
- r = mem[mem_top].hh.v.RH;
- while (r != mem_top) {
- print_ln();
- print_esc("insert");
- t = mem[r].hh.b1;
- print_int(t);
- print_string(" adds ");
-/* 427. Tell more precisely the effective size of 1:1 insertions (DEK, 27 Feb 08) */
- if (eqtb[(hash_size + 3218) + t].cint == 1000)
- t = mem[r + 3].cint;
- else
- t = x_over_n(mem[r + 3].cint, 1000) * eqtb[(hash_size + 3218) + t].cint;
- print_scaled(t);
- if (mem[r].hh.b0 == 1)
- {
- q = page_head;
- t = 0;
- do {
- q = mem[q].hh.v.RH;
- if ((mem[q].hh.b0 == 3) && (mem[q].hh.b1 == mem[r].hh.b1))
- incr(t);
- } while (!(q == mem[r + 1].hh.v.LH));
- print_string(", #");
- print_int(t);
- print_string(" might split");
- }
- r = mem[r].hh.v.RH;
- }
- }
- }
-/* if link(contrib_head)<>null then l.4393 */
- if (mem[contrib_head].hh.v.RH != 0)
- print_nl(" (\\output routine)");
+ print_string(" (language");
+ print_int(nest[p].pg_field % 65536L);
+ print_string(":hyphenmin");
+ print_int(nest[p].pg_field / 4194304L);
+ print_char(',');
+ print_int((nest[p].pg_field / 65536L) % 64);
+ print_char(')');
}
- show_box(mem[nest[p].head_field].hh.v.RH);
- switch (abs(m)/(101))
+ }
+
+ if (nest[p].ml_field < 0)
+ {
+ print_string(" (\\output routine)");
+ }
+
+ if (p == 0)
+ {
+ if (page_head != page_tail)
{
- case 0:
+ print_nl("### current page:");
+
+ if (output_active)
+ {
+ print_string(" (held over for next output)");
+ }
+
+ show_box(link(page_head));
+
+ if (page_contents > 0)
+ {
+ print_nl("total height ");
+ print_totals();
+ print_nl(" goal height ");
+ print_scaled(page_so_far[0]);
+ r = link(page_ins_head);
+
+ while (r != mem_top)
{
- print_nl("### recent contributions:");
- if (a.cint <= ignore_depth)
- print_string("ignored");
+ print_ln();
+ print_esc("insert");
+ t = subtype(r);
+ print_int(t);
+ print_string(" adds ");
+
+ if (count(t) == 1000)
+ t = height(r);
else
- print_scaled(a.cint);
- if (nest[p].pg_field != 0)
+ t = x_over_n(height(r), 1000) * count(t);
+
+ print_scaled(t);
+
+ if (type(r) == split_up)
{
- print_string(", prevgraf ");
- print_int(nest[p].pg_field);
- print_string(" line");
- if (nest[p].pg_field != 1)
- print_char('s');
+ q = page_head;
+ t = 0;
+
+ do
+ {
+ q = link(q);
+
+ if ((type(q) == ins_node) && (subtype(q) == subtype(r)))
+ incr(t);
+ }
+ while (!(q == broken_ins(r)));
+
+ print_string(", #");
+ print_int(t);
+ print_string(" might split");
}
+ r = link(r);
}
- break;
- case 1:
+ }
+ }
+
+ if (link(contrib_head) != 0)
+ print_nl("### recent contributions:");
+ }
+
+ show_box(link(nest[p].head_field));
+
+ switch (abs(m) / (max_command + 1))
+ {
+ case 0:
+ {
+ print_nl("prevdepth ");
+
+ if (a.cint <= ignore_depth)
+ print_string("ignored");
+ else
+ print_scaled(a.cint);
+
+ if (nest[p].pg_field != 0)
{
- print_nl("spacefactor ");
- print_int(a.hh.v.LH);
- if (m > 0)
- if (a.hh.v.RH > 0)
- {
- print_string(", current language ");
- print_int(a.hh.v.RH);
- }
+ print_string(", prevgraf ");
+ print_int(nest[p].pg_field);
+ print_string(" line");
+
+ if (nest[p].pg_field != 1)
+ print_char('s');
}
- break;
- case 2:
- if (a.cint != 0)
+ }
+ break;
+
+ case 1:
+ {
+ print_nl("spacefactor ");
+ print_int(a.hh.lh);
+
+ if (m > 0)
{
- print_string("this will be denominator of:");
- show_box(a.cint);
+ if (a.hh.rh > 0)
+ {
+ print_string(", current language ");
+ print_int(a.hh.rh);
+ }
}
- break;
- }
- } while(p-- > for_end); }
+ }
+ break;
+
+ case 2:
+ if (a.cint != 0)
+ {
+ print_string("this will be denominator of:");
+ show_box(a.cint);
+ }
+ break;
+ }
+ }
}
/* sec 0237 */
void print_param_(integer n)
case pretolerance_code:
print_esc("pretolerance");
break;
+
case tolerance_code:
print_esc("tolerance");
break;
+
case line_penalty_code:
print_esc("linepenalty");
break;
+
case hyphen_penalty_code:
print_esc("hyphenpenalty");
break;
+
case ex_hyphen_penalty_code:
print_esc("exhyphenpenalty");
break;
+
case club_penalty_code:
print_esc("clubpenalty");
break;
+
case widow_penalty_code:
print_esc("widowpenalty");
break;
+
case display_widow_penalty_code:
print_esc("displaywidowpenalty");
break;
+
case broken_penalty_code:
print_esc("brokenpenalty");
break;
+
case bin_op_penalty_code:
print_esc("binoppenalty");
break;
+
case rel_penalty_code:
print_esc("relpenalty");
break;
+
case pre_display_penalty_code:
print_esc("predisplaypenalty");
break;
+
case post_display_penalty_code:
print_esc("postdisplaypenalty");
break;
+
case inter_line_penalty_code:
print_esc("interlinepenalty");
break;
+
case double_hyphen_demerits_code:
print_esc("doublehyphendemerits");
break;
+
case final_hyphen_demerits_code:
print_esc("finalhyphendemerits");
break;
+
case adj_demerits_code:
print_esc("adjdemerits");
break;
+
case mag_code:
print_esc("mag");
break;
+
case delimiter_factor_code:
print_esc("delimiterfactor");
break;
+
case looseness_code:
print_esc("looseness");
break;
+
case time_code:
print_esc("time");
break;
+
case day_code:
print_esc("day");
break;
+
case month_code:
print_esc("month");
break;
+
case year_code:
print_esc("year");
break;
+
case show_box_breadth_code:
print_esc("showboxbreadth");
break;
+
case show_box_depth_code:
print_esc("showboxdepth");
break;
+
case hbadness_code:
print_esc("hbadness");
break;
+
case vbadness_code:
print_esc("vbadness");
break;
+
case pausing_code:
print_esc("pausing");
break;
+
case tracing_online_code:
print_esc("tracingonline");
break;
+
case tracing_macros_code:
print_esc("tracingmacros");
break;
+
case tracing_stats_code:
print_esc("tracingstats");
break;
+
case tracing_paragraphs_code:
print_esc("tracingparagraphs");
break;
+
case tracing_pages_code:
print_esc("tracingpages");
break;
+
case tracing_output_code:
print_esc("tracingoutput");
break;
+
case tracing_lost_chars_code:
print_esc("tracinglostchars");
break;
+
case tracing_commands_code:
print_esc("tracingcommands");
break;
+
case tracing_restores_code:
print_esc("tracingrestores");
break;
+
case uc_hyph_code:
print_esc("uchyph");
break;
+
case output_penalty_code:
print_esc("outputpenalty");
break;
+
case max_dead_cycles_code:
print_esc("maxdeadcycles");
break;
+
case hang_after_code:
print_esc("hangafter");
break;
+
case floating_penalty_code:
print_esc("floatingpenalty");
break;
+
case global_defs_code:
print_esc("globaldefs");
break;
+
case cur_fam_code:
print_esc("fam");
break;
+
case escape_char_code:
print_esc("escapechar");
break;
+
case default_hyphen_char_code:
print_esc("defaulthyphenchar");
break;
+
case default_skew_char_code:
print_esc("defaultskewchar");
break;
+
case end_line_char_code:
print_esc("endlinechar");
break;
+
case new_line_char_code:
print_esc("newlinechar");
break;
+
+ case cur_jfam_code:
+ print_esc("jfam");
+ break;
+
+ case jchr_widow_penalty_code:
+ print_esc("jcharwidowpenalty");
+ break;
+
case language_code:
print_esc("language");
break;
+
case left_hyphen_min_code:
print_esc("lefthyphenmin");
break;
+
case right_hyphen_min_code:
print_esc("righthyphenmin");
break;
+
case holding_inserts_code:
print_esc("holdinginserts");
break;
+
case error_context_lines_code:
print_esc("errorcontextlines");
break;
+
default:
print_string("[unknown integer parameter!]");
break;
void begin_diagnostic (void)
{
old_setting = selector;
+
if ((tracing_online <= 0) && (selector == term_and_log))
{
decr(selector);
+
if (history == spotless)
history = warning_issued;
}
}
/* sec 0245 */
-void end_diagnostic_(bool blankline)
+void end_diagnostic_(boolean blankline)
{
print_nl("");
+
if (blankline)
print_ln();
+
selector = old_setting;
}
/* sec 0247 */
case par_indent_code:
print_esc("parindent");
break;
+
case math_surround_code:
print_esc("mathsurround");
break;
+
case line_skip_limit_code:
print_esc("lineskiplimit");
break;
+
case hsize_code:
print_esc("hsize");
break;
+
case vsize_code:
print_esc("vsize");
break;
+
case max_depth_code:
print_esc("maxdepth");
break;
+
case split_max_depth_code:
print_esc("splitmaxdepth");
break;
+
case box_max_depth_code:
print_esc("boxmaxdepth");
break;
+
case hfuzz_code:
print_esc("hfuzz");
break;
+
case vfuzz_code:
print_esc("vfuzz");
break;
+
case delimiter_shortfall_code:
print_esc("delimitershortfall");
break;
+
case null_delimiter_space_code:
print_esc("nulldelimiterspace");
break;
+
case script_space_code:
print_esc("scriptspace");
break;
+
case pre_display_size_code:
print_esc("predisplaysize");
break;
+
case display_width_code:
print_esc("displaywidth");
break;
+
case display_indent_code:
print_esc("displayindent");
break;
+
case overfull_rule_code:
print_esc("overfullrule");
break;
+
case hang_indent_code:
print_esc("hangindent");
break;
+
case h_offset_code:
print_esc("hoffset");
break;
+
case v_offset_code:
print_esc("voffset");
break;
+
+ case t_baseline_shift_code:
+ print_esc("tbaselineshift");
+ break;
+
+ case y_baseline_shift_code:
+ print_esc("ybaselineshift");
+ break;
+
case emergency_stretch_code:
print_esc("emergencystretch");
break;
+
default:
print_string("[unknown dimen parameter!]");
break;
}
}
/* sec 0298 */
-void print_cmd_chr_ (quarterword cmd, halfword chrcode)
+void print_cmd_chr_ (quarterword cmd, halfword chr_code)
{
switch (cmd)
{
- case 1:
+ case left_brace:
print_string("begin-group character ");
- print(chrcode);
+ print(chr_code);
break;
- case 2:
+
+ case right_brace:
print_string("end-group character ");
- print(chrcode);
+ print(chr_code);
break;
- case 3:
+
+ case math_shift:
print_string("math shift character ");
- print(chrcode);
+ print(chr_code);
break;
- case 6:
+
+ case mac_param:
print_string("macro parameter character ");
- print(chrcode);
+ print(chr_code);
break;
- case 7:
+
+ case sup_mark:
print_string("superscript character ");
- print(chrcode);
+ print(chr_code);
break;
- case 8:
+
+ case sub_mark:
print_string("subscript character ");
- print(chrcode);
+ print(chr_code);
break;
- case 9:
+
+ case endv:
print_string("end of alignment template");
break;
- case 10:
+
+ case spacer:
print_string("blank space ");
- print(chrcode);
+ print(chr_code);
break;
- case 11:
+
+ case letter:
print_string("the letter ");
- print(chrcode);
+ print(chr_code);
break;
- case 12:
+
+ case other_char:
print_string("the character ");
- print(chrcode);
+ print(chr_code);
break;
- case 75:
- case 76:
- if (chrcode < skip_base)
- print_skip_param(chrcode - glue_base);
- else if (chrcode < mu_skip_base)
+
+ case assign_glue:
+ case assign_mu_glue:
+ if (chr_code < skip_base)
{
- print_esc("skip");
- print_int(chrcode - skip_base);
+ print_skip_param(chr_code - glue_base);
}
else
{
- print_esc("muskip");
- print_int(chrcode - mu_skip_base);
+ if (chr_code < mu_skip_base)
+ {
+ print_esc("skip");
+ print_int(chr_code - skip_base);
+ }
+ else
+ {
+ print_esc("muskip");
+ print_int(chr_code - mu_skip_base);
+ }
}
break;
- case 72:
- if (chrcode >= toks_base)
+
+ case assign_toks:
+ if (chr_code >= toks_base)
{
print_esc("toks");
- print_int(chrcode - toks_base);
+ print_int(chr_code - toks_base);
}
- else switch (chrcode)
+ else
{
- case output_routine_loc:
- print_esc("output");
- break;
- case every_par_loc:
- print_esc("everypar");
- break;
- case every_math_loc:
- print_esc("everymath");
- break;
- case every_display_loc:
- print_esc("everydisplay");
- break;
- case every_hbox_loc:
- print_esc("everyhbox");
- break;
- case every_vbox_loc:
- print_esc("everyvbox");
- break;
- case every_job_loc:
- print_esc("everyjob");
- break;
- case every_cr_loc:
- print_esc("everycr");
- break;
- default:
- print_esc("errhelp");
- break;
+ switch (chr_code)
+ {
+ case output_routine_loc:
+ print_esc("output");
+ break;
+
+ case every_par_loc:
+ print_esc("everypar");
+ break;
+
+ case every_math_loc:
+ print_esc("everymath");
+ break;
+
+ case every_display_loc:
+ print_esc("everydisplay");
+ break;
+
+ case every_hbox_loc:
+ print_esc("everyhbox");
+ break;
+
+ case every_vbox_loc:
+ print_esc("everyvbox");
+ break;
+
+ case every_job_loc:
+ print_esc("everyjob");
+ break;
+
+ case every_cr_loc:
+ print_esc("everycr");
+ break;
+
+ default:
+ print_esc("errhelp");
+ break;
+ }
}
break;
- case 73:
- if (chrcode < count_base)
- print_param(chrcode - int_base);
- else {
+
+ case assign_int:
+ if (chr_code < count_base)
+ {
+ print_param(chr_code - int_base);
+ }
+ else
+ {
print_esc("count");
- print_int(chrcode - count_base);
+ print_int(chr_code - count_base);
}
break;
- case 74:
- if (chrcode < scaled_base)
- print_length_param(chrcode - dimen_base);
- else {
+
+ case assign_dimen:
+ if (chr_code < scaled_base)
+ {
+ print_length_param(chr_code - dimen_base);
+ }
+ else
+ {
print_esc("dimen");
- print_int(chrcode - scaled_base);
+ print_int(chr_code - scaled_base);
}
break;
- case 45:
+
+ case accent:
print_esc("accent");
break;
- case 90:
+
+ case advance:
print_esc("advance");
break;
- case 40:
+
+ case after_assignment:
print_esc("afterassignment");
break;
- case 41:
+
+ case after_group:
print_esc("aftergroup");
break;
- case 77:
+
+ case assign_font_dimen:
print_esc("fontdimen");
break;
- case 61:
+
+ case begin_group:
print_esc("begingroup");
break;
- case 42:
+
+ case break_penalty:
print_esc("penalty");
break;
- case 16:
+
+ case char_num:
print_esc("char");
break;
- case 107:
+
+ case cs_name:
print_esc("csname");
break;
- case 88:
+
+ case def_font:
print_esc("font");
break;
- case 15:
+
+ case delim_num:
print_esc("delimiter");
break;
- case 92:
+
+ case divide:
print_esc("divide");
break;
- case 67:
+
+ case end_cs_name:
print_esc("endcsname");
break;
- case 62:
+
+ case end_group:
print_esc("endgroup");
break;
- case 64:
+
+ case ex_space:
print_esc(" ");
break;
- case 102:
+
+ case expand_after:
print_esc("expandafter");
break;
- case 32:
+
+ case halign:
print_esc("halign");
break;
- case 36:
+
+ case hrule:
print_esc("hrule");
break;
- case 39:
+
+ case ignore_spaces:
print_esc("ignorespaces");
break;
- case 37:
+
+ case insert:
print_esc("insert");
break;
- case 44:
+
+ case ital_corr:
print_esc("/");
break;
- case 18:
+
+ case mark:
print_esc("mark");
break;
- case 46:
+
+ case math_accent:
print_esc("mathaccent");
break;
- case 17:
+
+ case math_char_num:
print_esc("mathchar");
break;
- case 54:
+
+ case math_choice:
print_esc("mathchoice");
break;
- case 91:
+
+ case multiply:
print_esc("multiply");
break;
- case 34:
+
+ case no_align:
print_esc("noalign");
break;
- case 65:
+
+ case no_boundary:
print_esc("noboundary");
break;
- case 103:
+
+ case no_expand:
print_esc("noexpand");
break;
- case 55:
+
+ case non_script:
print_esc("nonscript");
break;
- case 63:
+
+ case omit:
print_esc("omit");
break;
- case 66:
+
+ case radical:
print_esc("radical");
break;
- case 96:
+
+ case read_to_cs:
print_esc("read");
break;
- case 0:
+
+ case relax:
print_esc("relax");
break;
- case 98:
+
+ case set_box:
print_esc("setbox");
break;
- case 80:
+
+ case set_prev_graf:
print_esc("prevgraf");
break;
- case 84:
+
+ case set_shape:
print_esc("parshape");
break;
- case 109:
+
+ case the:
print_esc("the");
break;
- case 71:
+
+ case toks_register:
print_esc("toks");
break;
- case 38:
+
+ case vadjust:
print_esc("vadjust");
break;
- case 33:
+
+ case valign:
print_esc("valign");
break;
- case 56:
+
+ case vcenter:
print_esc("vcenter");
break;
- case 35:
+
+ case vrule:
print_esc("vrule");
break;
- case 13:
+
+ case par_end:
print_esc("par");
break;
- case 104:
- if (chrcode == 0)
+
+ case input:
+ if (chr_code == 0)
print_esc("input");
else
print_esc("endinput");
break;
- case 110:
- switch (chrcode)
+
+ case top_bot_mark:
+ switch (chr_code)
{
- case 1:
+ case first_mark_code:
print_esc("firstmark");
break;
- case 2:
+
+ case bot_mark_code:
print_esc("botmark");
break;
- case 3:
+
+ case split_first_mark_code:
print_esc("splitfirstmark");
break;
- case 4:
+
+ case split_bot_mark_code:
print_esc("splitbotmark");
break;
+
default:
print_esc("topmark");
break;
}
break;
- case 89:
- if (chrcode == 0)
+
+ case tex_register:
+ if (chr_code == int_val)
print_esc("count");
- else if (chrcode == 1)
+ else if (chr_code == dimen_val)
print_esc("dimen");
- else if (chrcode == 2)
+ else if (chr_code == glue_val)
print_esc("skip");
else
print_esc("muskip");
break;
- case 79:
- if (chrcode == 1)
+
+ case set_aux:
+ if (chr_code == vmode)
print_esc("prevdepth");
else
print_esc("spacefactor");
break;
- case 82:
- if (chrcode == 0)
+
+ case set_page_int:
+ if (chr_code == 0)
print_esc("deadcycles");
else
print_esc("insertpenalties");
break;
- case 83:
- if (chrcode == 1)
+
+ case set_box_dimen:
+ if (chr_code == width_offset)
print_esc("wd");
- else if (chrcode == 3)
+ else if (chr_code == height_offset)
print_esc("ht");
else
print_esc("dp");
break;
- case 70:
- switch (chrcode)
+
+ case last_item:
+ switch (chr_code)
{
- case 0:
+ case int_val:
print_esc("lastpenalty");
break;
- case 1:
+
+ case dimen_val:
print_esc("lastkern");
break;
- case 2:
+
+ case glue_val:
print_esc("lastskip");
break;
- case 3:
+
+ case input_line_no_code:
print_esc("inputlineno");
break;
+
default:
print_esc("badness");
break;
}
break;
- case 108:
- switch (chrcode)
+
+ case convert:
+ switch (chr_code)
{
- case 0:
+ case number_code:
print_esc("number");
break;
- case 1:
+
+ case roman_numeral_code:
print_esc("romannumeral");
break;
- case 2:
+
+ case string_code:
print_esc("string");
break;
- case 3:
+
+ case meaning_code:
print_esc("meaning");
break;
- case 4:
+
+ case font_name_code:
print_esc("fontname");
break;
+
default:
print_esc("jobname");
break;
}
break;
- case 105:
- switch (chrcode)
+
+ case if_test:
+ switch (chr_code)
{
- case 1:
+ case if_cat_code:
print_esc("ifcat");
break;
- case 2:
+
+ case if_int_code:
print_esc("ifnum");
break;
- case 3:
+
+ case if_dim_code:
print_esc("ifdim");
break;
- case 4:
+
+ case if_odd_code:
print_esc("ifodd");
break;
- case 5:
+
+ case if_vmode_code:
print_esc("ifvmode");
break;
- case 6:
+
+ case if_hmode_code:
print_esc("ifhmode");
break;
- case 7:
+
+ case if_mmode_code:
print_esc("ifmmode");
break;
- case 8:
+
+ case if_inner_code:
print_esc("ifinner");
break;
- case 9:
+
+ case if_void_code:
print_esc("ifvoid");
break;
- case 10:
+
+ case if_hbox_code:
print_esc("ifhbox");
break;
- case 11:
+
+ case if_vbox_code:
print_esc("ifvbox");
break;
- case 12:
+
+ case ifx_code:
print_esc("ifx");
break;
- case 13:
+
+ case if_eof_code:
print_esc("ifeof");
break;
- case 14:
+
+ case if_true_code:
print_esc("iftrue");
break;
- case 15:
+
+ case if_false_code:
print_esc("iffalse");
break;
- case 16:
+
+ case if_case_code:
print_esc("ifcase");
break;
+
default:
print_esc("if");
break;
}
break;
- case 106:
- if (chrcode == 2)
+
+ case fi_or_else:
+ if (chr_code == fi_code)
print_esc("fi");
- else if (chrcode == 4)
+ else if (chr_code == or_code)
print_esc("or");
- else print_esc("else");
+ else
+ print_esc("else");
break;
- case 4:
- if (chrcode == 256) /* pool size */ /* max_quarterword + 1 ? */
+
+ case tab_mark:
+ if (chr_code == span_code)
print_esc("span");
- else {
+ else
+ {
print_string("alignment tab character ");
- print(chrcode);
+ print(chr_code);
}
break;
- case 5:
- if (chrcode == 257) /* cr_code */
+
+ case car_ret:
+ if (chr_code == cr_code)
print_esc("cr");
- else print_esc("crcr");
+ else
+ print_esc("crcr");
break;
- case 81:
- switch (chrcode)
+
+ case set_page_dimen:
+ switch (chr_code)
{
case 0:
print_esc("pagegoal");
break;
+
case 1:
print_esc("pagetotal");
break;
+
case 2:
print_esc("pagestretch");
break;
+
case 3:
print_esc("pagefilstretch");
break;
+
case 4:
print_esc("pagefillstretch");
break;
+
case 5:
print_esc("pagefilllstretch");
break;
+
case 6:
print_esc("pageshrink");
break;
+
default:
print_esc("pagedepth");
break;
}
break;
- case 14:
- if (chrcode == 1)
+
+ case stop:
+ if (chr_code == 1)
print_esc("dump");
- else print_esc("end");
+ else
+ print_esc("end");
break;
- case 26:
- switch (chrcode)
+
+ case hskip:
+ switch (chr_code)
{
- case 4:
+ case skip_code:
print_esc("hskip");
break;
- case 0:
+
+ case fil_code:
print_esc("hfil");
break;
- case 1:
+
+ case fill_code:
print_esc("hfill");
break;
- case 2:
+
+ case ss_code:
print_esc("hss");
break;
+
default:
print_esc("hfilneg");
break;
}
break;
- case 27:
- switch (chrcode)
+
+ case vskip:
+ switch (chr_code)
{
- case 4:
+ case skip_code:
print_esc("vskip");
break;
- case 0:
+
+ case fil_code:
print_esc("vfil");
break;
- case 1:
+
+ case fill_code:
print_esc("vfill");
break;
- case 2:
+
+ case ss_code:
print_esc("vss");
break;
+
default:
print_esc("vfilneg");
break;
}
break;
- case 28:
+
+ case mskip:
print_esc("mskip");
break;
- case 29:
+
+ case kern:
print_esc("kern");
break;
- case 30:
+
+ case mkern:
print_esc("mkern");
break;
- case 21:
- if (chrcode == 1)
+
+ case hmove:
+ if (chr_code == 1)
print_esc("moveleft");
- else print_esc("moveright");
+ else
+ print_esc("moveright");
break;
- case 22:
- if (chrcode == 1)
+
+ case vmove:
+ if (chr_code == 1)
print_esc("raise");
- else print_esc("lower");
+ else
+ print_esc("lower");
break;
- case 20:
- switch (chrcode)
+
+ case make_box:
+ switch (chr_code)
{
- case 0:
+ case box_code:
print_esc("box");
break;
- case 1:
+
+ case copy_code:
print_esc("copy");
break;
- case 2:
+
+ case last_box_code:
print_esc("lastbox");
break;
- case 3:
+
+ case vsplit_code:
print_esc("vsplit");
break;
- case 4:
+
+ case vtop_code:
print_esc("vtop");
break;
- case 5:
+
+ case vtop_code + vmode:
print_esc("vbox");
break;
+
default:
print_esc("hbox");
break;
}
break;
- case 31:
- if (chrcode == 100)
+
+ case leader_ship:
+ if (chr_code == a_leaders)
print_esc("leaders");
- else if (chrcode == 101)
+ else if (chr_code == c_leaders)
print_esc("cleaders");
- else if (chrcode == 102)
+ else if (chr_code == x_leaders)
print_esc("xleaders");
- else print_esc("shipout");
+ else
+ print_esc("shipout");
break;
- case 43:
- if (chrcode == 0)
+
+ case start_par:
+ if (chr_code == 0)
print_esc("noindent");
- else print_esc("indent");
+ else
+ print_esc("indent");
break;
- case 25:
- if (chrcode == 10)
+
+ case remove_item:
+ if (chr_code == glue_node)
print_esc("unskip");
- else if (chrcode == 11)
+ else if (chr_code == kern_node)
print_esc("unkern");
- else print_esc("unpenalty");
+ else
+ print_esc("unpenalty");
break;
- case 23:
- if (chrcode == 1)
+
+ case un_hbox:
+ if (chr_code == copy_code)
print_esc("unhcopy");
- else print_esc("unhbox");
+ else
+ print_esc("unhbox");
break;
- case 24:
- if (chrcode == 1)
+
+ case un_vbox:
+ if (chr_code == copy_code)
print_esc("unvcopy");
- else print_esc("unvbox");
+ else
+ print_esc("unvbox");
break;
- case 47:
- if (chrcode == 1)
+
+ case discretionary:
+ if (chr_code == 1)
print_esc("-");
else
print_esc("discretionary");
break;
- case 48:
- if (chrcode == 1)
+
+ case eq_no:
+ if (chr_code == 1)
print_esc("leqno");
- else print_esc("eqno");
+ else
+ print_esc("eqno");
break;
- case 50:
- switch (chrcode)
+
+ case math_comp:
+ switch (chr_code)
{
- case 16:
+ case ord_noad:
print_esc("mathord");
break;
- case 17:
+
+ case op_noad:
print_esc("mathop");
break;
- case 18:
+
+ case bin_noad:
print_esc("mathbin");
break;
- case 19:
+
+ case rel_noad:
print_esc("mathrel");
break;
- case 20:
+
+ case open_noad:
print_esc("mathopen");
break;
- case 21:
+
+ case close_noad:
print_esc("mathclose");
break;
- case 22:
+
+ case punct_noad:
print_esc("mathpunct");
break;
- case 23:
+
+ case inner_noad:
print_esc("mathinner");
break;
- case 26:
+
+ case under_noad:
print_esc("underline");
break;
+
default:
print_esc("overline");
break;
}
break;
- case 51:
- if (chrcode == 1)
+
+ case limit_switch:
+ if (chr_code == limits)
print_esc("limits");
- else if (chrcode == 2)
+ else if (chr_code == no_limits)
print_esc("nolimits");
- else print_esc("displaylimits");
+ else
+ print_esc("displaylimits");
break;
- case 53:
- print_style(chrcode);
+
+ case math_style:
+ print_style(chr_code);
break;
- case 52:
- switch (chrcode)
+
+ case above:
+ switch (chr_code)
{
- case 1:
+ case over_code:
print_esc("over");
break;
- case 2:
+
+ case atop_code:
print_esc("atop");
break;
- case 3:
+
+ case delimited_code + above_code:
print_esc("abovewithdelims");
break;
- case 4:
+
+ case delimited_code + over_code:
print_esc("overwithdelims");
break;
- case 5:
+
+ case delimited_code + atop_code:
print_esc("atopwithdelims");
break;
+
default:
print_esc("above");
break;
}
break;
- case 49:
- if (chrcode == 30)
+
+ case left_right:
+ if (chr_code == left_noad)
print_esc("left");
- else print_esc("right");
+ else
+ print_esc("right");
break;
- case 93:
- if (chrcode == 1)
+
+ case prefix:
+ if (chr_code == 1)
print_esc("long");
- else if (chrcode == 2)
+ else if (chr_code == 2)
print_esc("outer");
- else print_esc("global");
+ else
+ print_esc("global");
break;
- case 97:
- if (chrcode == 0)
+
+ case def:
+ if (chr_code == 0)
print_esc("def");
- else if (chrcode == 1)
+ else if (chr_code == 1)
print_esc("gdef");
- else if (chrcode == 2)
+ else if (chr_code == 2)
print_esc("edef");
- else print_esc("xdef");
+ else
+ print_esc("xdef");
break;
- case 94:
- if (chrcode != 0)
+
+ case let:
+ if (chr_code != normal)
print_esc("futurelet");
- else print_esc("let");
+ else
+ print_esc("let");
break;
- case 95:
- switch (chrcode)
+
+ case shorthand_def:
+ switch (chr_code)
{
- case 0:
+ case char_def_code:
print_esc("chardef");
break;
- case 1:
+
+ case math_char_def_code:
print_esc("mathchardef");
break;
- case 2:
+
+ case count_def_code:
print_esc("countdef");
break;
- case 3:
+
+ case dimen_def_code:
print_esc("dimendef");
break;
- case 4:
+
+ case skip_def_code:
print_esc("skipdef");
break;
- case 5:
+
+ case mu_skip_def_code:
print_esc("muskipdef");
break;
+
default:
print_esc("toksdef");
break;
}
break;
- case 68:
+
+ case char_given:
print_esc("char");
- print_hex(chrcode);
+ print_hex(chr_code);
break;
- case 69:
+
+ case math_given:
print_esc("mathchar");
- print_hex(chrcode);
+ print_hex(chr_code);
break;
- case 85:
- if (chrcode == cat_code_base)
+
+ case def_code:
+ if (chr_code == cat_code_base)
print_esc("catcode");
- else if (chrcode == math_code_base)
+ else if (chr_code == kcat_code_base)
+ print_esc("kcatcode");
+ else if (chr_code == auto_xsp_code_base)
+ print_esc("xspcode");
+ else if (chr_code == math_code_base)
print_esc("mathcode");
- else if (chrcode == lc_code_base)
+ else if (chr_code == lc_code_base)
print_esc("lccode");
- else if (chrcode == uc_code_base)
+ else if (chr_code == uc_code_base)
print_esc("uccode");
- else if (chrcode == sf_code_base)
+ else if (chr_code == sf_code_base)
print_esc("sfcode");
- else print_esc("delcode");
+ else
+ print_esc("delcode");
break;
- case 86:
- print_size(chrcode - math_font_base);
+
+ case def_family:
+ print_size(chr_code - math_font_base);
break;
- case 99:
- if (chrcode == 1)
+
+ case hyph_data:
+ if (chr_code == 1)
print_esc("patterns");
- else print_esc("hyphenation");
+ else
+ print_esc("hyphenation");
break;
- case 78:
- if (chrcode == 0)
+
+ case assign_font_int:
+ if (chr_code == 0)
print_esc("hyphenchar");
- else print_esc("skewchar");
+ else
+ print_esc("skewchar");
break;
- case 87:
+
+ case set_font:
print_string("select font ");
- slow_print(font_name[chrcode]);
- if (font_size[chrcode] != font_dsize[chrcode])
+ slow_print(font_name[chr_code]);
+
+ if (font_size[chr_code] != font_dsize[chr_code])
{
print_string(" at ");
- print_scaled(font_size[chrcode]);
+ print_scaled(font_size[chr_code]);
print_string("pt");
}
break;
- case 100:
- switch (chrcode)
+
+ case set_interaction:
+ switch (chr_code)
{
- case 0:
+ case batch_mode:
print_esc("batchmode");
break;
- case 1:
+
+ case nonstop_mode:
print_esc("nonstopmode");
break;
- case 2:
+
+ case scroll_mode:
print_esc("scrollmode");
break;
+
default:
print_esc("errorstopmode");
break;
}
break;
- case 60:
- if (chrcode == 0)
+
+ case in_stream:
+ if (chr_code == 0)
print_esc("closein");
- else print_esc("openin");
+ else
+ print_esc("openin");
break;
- case 58:
- if (chrcode == 0)
+
+ case message:
+ if (chr_code == 0)
print_esc("message");
- else print_esc("errmessage");
+ else
+ print_esc("errmessage");
break;
- case 57:
- if (chrcode == lc_code_base)
+
+ case case_shift:
+ if (chr_code == lc_code_base)
print_esc("lowercase");
- else print_esc("uppercase");
+ else
+ print_esc("uppercase");
break;
- case 19:
- switch (chrcode)
+
+ case xray:
+ switch (chr_code)
{
- case 1:
+ case show_box_code:
print_esc("showbox");
break;
- case 2:
+
+ case show_the_code:
print_esc("showthe");
break;
- case 3:
+
+ case show_lists:
print_esc("showlists");
break;
+
+ //case show_mode:
+ // print_esc("showmode");
+ // break;
+
default:
print_esc("show");
break;
}
break;
- case 101:
+
+ case undefined_cs:
print_string("undefined");
break;
- case 111:
+
+ case call:
print_string("macro");
break;
- case 112:
+
+ case long_call:
print_esc("long macro");
break;
- case 113:
+
+ case outer_call:
print_esc("outer macro");
break;
- case 114:
+
+ case long_outer_call:
print_esc("long");
print_esc("outer macro");
break;
- case 115:
+
+ case end_template:
print_esc("outer endtemplate");
break;
- case 59:
- switch (chrcode)
+
+ case extension:
+ switch (chr_code)
{
- case 0:
+ case open_node:
print_esc("openout");
break;
- case 1:
+
+ case write_node:
print_esc("write");
break;
- case 2:
+
+ case close_node:
print_esc("closeout");
break;
- case 3:
+
+ case special_node:
print_esc("special");
break;
- case 4:
+
+ case immediate_code:
print_esc("immediate");
break;
- case 5:
+
+ case set_language_code:
print_esc("setlanguage");
break;
+
default:
print_string("[unknown extension!]");
break;
}
break;
+
default:
print_string("[unknown command code!]");
break;
print_char('?');
else if (n < glue_base)
{
- sprint_cs(n);
+ sprint_cs(n);
print_char('=');
print_cmd_chr(eq_type(n), equiv(n));
- if (eqtb[n].hh.b0 >= call)
+
+ if (eq_type(n) >= call)
{
print_char(':');
show_token_list(link(equiv(n)), 0, 32);
{
print_skip_param(n - glue_base);
print_char('=');
+
if (n < glue_base + thin_mu_skip_code)
print_spec(equiv(n), "pt");
else
{
print_esc("parshape");
print_char('=');
+
if (par_shape_ptr == 0)
print_char('0');
else
{
print_cmd_chr(assign_toks, n);
print_char('=');
+
if (equiv(n) != 0)
show_token_list(link(equiv(n)), 0, 32);
}
print_esc("toks");
print_int(n - toks_base);
print_char('=');
+
if (equiv(n) != 0)
show_token_list(link(equiv(n)), 0, 32);
}
print_esc("box");
print_int(n - box_base);
print_char('=');
+
if (equiv(n) == 0)
print_string("void");
else
print_esc("scriptscriptfont");
print_int(n - math_font_base - 32);
}
+
print_char('=');
- print_esc("");print(hash[(hash_size + hash_extra + 524) + equiv(n)].v.RH);
+ print_esc("");
+ print(hash[font_id_base + equiv(n)].rh);
}
else if (n < math_code_base)
{
- if (n < lc_code_base)
+ if (n < kcat_code_base)
{
print_esc("catcode");
print_int(n - cat_code_base);
}
+ else if (n < auto_xsp_code_base)
+ {
+ print_esc("kcatcode");
+ print_int(n - kcat_code_base);
+ }
+ else if (n < inhibit_xsp_code_base)
+ {
+ print_esc("xspcode");
+ print_int(n - auto_xsp_code_base);
+ }
+ else if (n < kinsoku_base)
+ {
+ print("(inhibitxspcode table) ");
+ print_int(n - inhibit_xsp_code_base);
+ }
+ else if (n < kansuji_base)
+ {
+ print("(kinsoku table) ");
+ print_int(n - kinsoku_base);
+ }
+ else if (n < lc_code_base)
+ {
+ print_esc("kansujichar");
+ print_int(n - kansuji_base);
+ }
else if (n < uc_code_base)
{
print_esc("lccode");
print_esc("sfcode");
print_int(n - sf_code_base);
}
+
print_char('=');
print_int(equiv(n));
}
print_esc("delcode");
print_int(n - del_code_base);
}
+
print_char('=');
print_int(eqtb[n].cint);
}
- else if (n <= eqtb_size)
+ else if (n < kinsoku_penalty_base)
{
if (n < scaled_base)
print_length_param(n - dimen_base);
print_esc("dimen");
print_int(n - scaled_base);
}
+
print_char('=');
print_scaled(eqtb[n].cint);
print_string("pt");
}
- else print_char('?');
+ else if (n <= eqtb_size)
+ print_string("kinsoku");
+ else
+ print_char('?');
}
#endif /* STAT */
-
+/* sec 0259 */
halfword id_lookup_(integer j, integer l)
{
- register halfword Result;
integer h;
integer d;
halfword p;
halfword k;
h = buffer[j];
+
for (k = j + 1; k <= j + l - 1; k++)
{
h = h + h + buffer[k];
+
while (h >= hash_prime)
h = h - hash_prime;
}
+
p = h + hash_base;
- while (true) {
+
+ while (true)
+ {
if (text(p) > 0)
if (length(text(p)) == l)
if (str_eq_buf(text(p), j))
goto lab40;
- if (hash[p].v.LH == 0) {
+
+ if (next(p) == 0)
+ {
if (no_new_control_sequence)
+ {
p = undefined_control_sequence;
+ }
else
{
if (text(p) > 0)
{
- do {
- if (hash_is_full)
+ do
{
-/* we can't expand the hash table ... */
-/* overflow("hash size", hash_size); */ /* hash size - NOT DYNAMIC */
- overflow("hash size", hash_size + hash_extra); /* 96/Jan/10 */
- return 0; // abort_flag set
+ if (hash_is_full)
+ {
+ overflow("hash size", hash_size + hash_extra); /* 96/Jan/10 */
+ return 0; // abort_flag set
+ }
+
+ decr(hash_used);
}
- decr(hash_used);
- } while (!(text(hash_used) == 0));
+ while (!(text(hash_used) == 0));
+
#ifdef SHORTHASH
- if (hash_used > 65535L)
- { /* debugging only 1996/Jan/20 */
+ if (hash_used > 65535L) /* debugging only 1996/Jan/20 */
+ {
sprintf(log_line, "ERROR: %s too large %d\n", "hash entry", hash_used);
show_line(log_line, 1);
}
#endif
- hash[p].v.LH = hash_used;
+
+ next(p) = hash_used;
p = hash_used;
- }
-#ifdef CHECKPOOL
- if (checkpool(NULL)) show_line("after hash_used\n", 0);
-#endif
- {
-#ifdef ALLOCATESTRING
- if (pool_ptr + l > current_pool_size)
- str_pool = realloc_str_pool(increment_pool_size + 1);
- if (pool_ptr + l > current_pool_size)
- { /* in case it failed 97/Mar/7 */
- overflow("pool size", current_pool_size - init_pool_ptr); /* pool size */
- return 0; // abort_flag set
- }
-#else
- if (pool_ptr + l > pool_size)
- {
- overflow("pool size", pool_size - init_pool_ptr); /* pool size - not dynamic */
- return; // abort_flag set
- }
-#endif
}
+
+ str_room(l);
d = cur_length;
- while (pool_ptr > str_start[str_ptr]) {
+
+ while (pool_ptr > str_start[str_ptr])
+ {
decr(pool_ptr);
str_pool[pool_ptr + l] = str_pool[pool_ptr];
}
-#ifdef CHECKPOOL
- if (checkpool(NULL)) show_line("after pool_ptr\n", 0);
-#endif
- for (k = j; k <= j + l - 1; k++) append_char(buffer[k]);
+
+ for (k = j; k <= j + l - 1; k++)
+ append_char(buffer[k]);
+
#ifdef SHORTHASH
{
pool_pointer tempstring = make_string();
- if (tempstring > 65535L)
- { /* cannot happen */
+
+ if (tempstring > 65535L) /* cannot happen */
+ {
sprintf(log_line, "ERROR: %s too large %d\n", "string ptr", tempstring);
show_line(log_line, 1);
}
#else
text(p) = make_string();
#endif
-#ifdef CHECKPOOL
- if (checkpool(NULL))
- show_line("after make_string\n", 0);
-#endif
+
pool_ptr = pool_ptr + d;
+
#ifdef STAT
incr(cs_count);
+
if (trace_flag)
{
str_pool[pool_ptr] = '\0';
- sprintf(log_line, " tex1 cs_count++ '%s' ", &str_pool[pool_ptr-l-d]);
+ sprintf(log_line, " tex1 cs_count++ '%s' ", &str_pool[pool_ptr - l - d]);
show_line(log_line, 0); /* debugging */
}
#endif /* STAT */
- }
-#ifdef CHECKPOOL
- if (checkpool(NULL))
- show_line("after cs_count++\n", 0);
-#endif
+ }
+
goto lab40;
- }
- p = hash[p].v.LH;
+ }
+ p = next(p);
}
-#ifdef CHECKPOOL
- if (checkpool(NULL)) show_line("before return\n", 0);
-#endif
+
lab40:
- Result = p;
- return Result;
+ return p;
}
/* sec 0274 */
void new_save_level_(group_code c)
if (save_ptr > max_save_stack)
{
max_save_stack = save_ptr;
+
#ifdef ALLOCATESAVESTACK
if (max_save_stack > current_save_size - 6)
save_stack = realloc_save_stack(increment_save_size);
- if (max_save_stack > current_save_size - 6)
- { /* check again after allocation */
+
+ if (max_save_stack > current_save_size - 6) /* check again after allocation */
+ {
overflow("save size", current_save_size);
return; // abort_flag set
}
#else
- if (max_save_stack > save_size - 6)
- { /* save size - not dynamic */
+ if (max_save_stack > save_size - 6) /* save size - not dynamic */
+ {
overflow("save size", save_size);
return; // abort_flag set
}
#endif
}
-/* save_type(save_ptr) <- level_boundary; */
- save_stack[save_ptr].hh.b0 = 3;
-/* save_stack[save_ptr].hh.b1 = cur_group; *//* keep compiler happy */
- save_stack[save_ptr].hh.b1 = (quarterword) cur_group;
-/* save_index(save_ptr):=cur_boundary; */
- save_stack[save_ptr].hh.v.RH = cur_boundary;
-/* if cur_level = max_quarterword then ... p.274 */
-/* if (cur_level == 255)*/ /* 94/Apr/4 */
+
+ save_type(save_ptr) = level_boundary;
+ save_level(save_ptr) = (quarterword) cur_group;
+ save_index(save_ptr) = cur_boundary;
+
if (cur_level == max_quarterword)
{
-/* { quit if (cur_level + 1) is too large to store in eqtb } */
-/* overflow("grouping levels", max_quarterword - min_quarterword); */
-/* overflow("grouping levels", 255); */ /* grouping levels - not dynamic */
overflow("grouping levels", max_quarterword - min_quarterword); /* 96/Oct/12 ??? */
return; // abort_flag set
}
-/* cur_boundary <- save_ptr */
+
cur_boundary = save_ptr;
incr(cur_level);
incr(save_ptr);
void eq_destroy_(memory_word w)
{
halfword q;
+
switch (eq_type_field(w))
{
case call:
case long_outer_call:
delete_token_ref(equiv_field(w));
break;
+
case glue_ref:
delete_glue_ref(equiv_field(w));
break;
+
case shape_ref:
q = equiv_field(w);
+
if (q != 0)
free_node(q, info(q) + info(q) + 1);
break;
+
case box_ref:
flush_node_list(equiv_field(w));
break;
+
default:
break;
}
if (save_ptr > max_save_stack)
{
max_save_stack = save_ptr;
+
#ifdef ALLOCATESAVESTACK
if (max_save_stack > current_save_size - 6)
save_stack = realloc_save_stack (increment_save_size);
- if (max_save_stack > current_save_size - 6)
- { /* check again after allocation */
+
+ if (max_save_stack > current_save_size - 6) /* check again after allocation */
+ {
overflow("save size", current_save_size);
return; // abort_flag set
}
#else
- if (max_save_stack > save_size - 6)
- { /* save size not dynamic */
+ if (max_save_stack > save_size - 6) /* save size not dynamic */
+ {
overflow("save size", save_size);
return; // abort_flag set
}
#endif
}
+
if (l == level_zero)
save_type(save_ptr) = restore_zero;
else
incr(save_ptr);
save_type(save_ptr) = restore_old_value;
}
+
save_level(save_ptr) = l;
save_index(save_ptr) = p;
incr(save_ptr);
eq_destroy(eqtb[p]);
else if (cur_level > level_one)
eq_save(p, eq_level(p));
+
eq_level(p) = (quarterword) cur_level; /* because cur_level padded out */
eq_type(p) = t;
equiv(p) = e;
eq_save(p, xeq_level[p]);
xeq_level[p] = (quarterword) cur_level; /* because cur_level padded out */
}
+
eqtb[p].cint = w;
}
/* sec 0279 */
if (save_ptr > max_save_stack)
{
max_save_stack = save_ptr;
+
#ifdef ALLOCATESAVESTACK
if (max_save_stack > current_save_size - 6)
save_stack = realloc_save_stack (increment_save_size);
- if (max_save_stack > current_save_size - 6)
- { /* check again after allocation */
+
+ if (max_save_stack > current_save_size - 6) /* check again after allocation */
+ {
overflow("save size", current_save_size);
return; // abort_flag set
}
#else
- if (max_save_stack > save_size - 6)
- { /* save satck - not dynamic */
+ if (max_save_stack > save_size - 6) /* save satck - not dynamic */
+ {
overflow("save size", save_size);
return; // abort_flag set
}
#endif
}
+
save_type(save_ptr) = insert_token;
save_level(save_ptr) = level_zero;
save_index(save_ptr) = t;
incr(save_ptr);
}
}
-/* restore_trace_, unsave followed in the old tex1.c */
+/* restore_trace_, unsave followed in the old tex1.c */
\ No newline at end of file
OSDN Git Service
