#define print_char(s) print_char_((ASCII_code) (s))
void print_(integer);
#define print(s) print_((integer) (s))
-void print_string_(const char * s);
-#define print_string(s) print_string_((const char *) s)
+void prints_(const char * s);
+#define prints(s) prints_((const char *) s)
void slow_print_(integer);
#define slow_print(s) slow_print_((integer) (s))
void print_nl(const char *);
{
print_err("You can't use `");
print_esc("long");
- print_string("' or `");
+ prints("' or `");
print_esc("outer");
- print_string("' with `");
+ prints("' with `");
print_cmd_chr(cur_cmd, cur_chr);
print_char('\'');
help1("I'll pretend you didn't say \\long or \\outer here.");
print_int(cur_val);
if (p < del_code_base)
- print_string("), should be in the range 0..");
+ prints("), should be in the range 0..");
else
- print_string("), should be at most ");
+ prints("), should be at most ");
print_int(n);
help1("I'm going to use 0 instead of that illegal code value.");
while (open_parens > 0)
{
- print_string(" )");
+ prints(" )");
decr(open_parens);
}
{
print_nl("(");
print_esc("end occurred ");
- print_string("inside a group at level ");
+ prints("inside a group at level ");
print_int(cur_level - 1);
print_char(')');
}
{
print_nl("(");
print_esc("end occurred ");
- print_string("when ");
+ prints("when ");
print_cmd_chr('i', cur_if);
if (if_line != 0)
{
- print_string("on line ");
+ prints("on line ");
print_int(if_line);
}
- print_string(" was incomplete)");
+ prints(" was incomplete)");
if_line = mem[cond_ptr + 1].cint;
cur_if = subtype(cond_ptr);
temp_ptr = cond_ptr;
}
#ifdef ALLOCATEMAIN
-/* add a block of variable size node space below mem_bot */
+/* add a block of variable size node space below mem_bot(0) */
void add_variable_space(int size)
{
halfword p;
for (k = 0; k <= 255; k++)
{
- if (((k < ' ') || (k > '~')))
+ if ( (k < ' ') || (k > '~') )
{
append_char('^');
append_char('^');
if (k < 64)
append_char(k + 64);
+ else if (k < 128)
+ append_char(k - 64);
else
- if (k < 128)
- append_char(k - 64);
- else
- {
- append_lc_hex(k / 16);
- append_lc_hex(k % 16);
- }
+ {
+ append_lc_hex(k / 16);
+ append_lc_hex(k % 16);
+ }
}
else
append_char(k);
return true;
}
-#endif /* INITEX */
+#endif
#ifdef INITEX
/* sec 0131 */
pool_pointer k;
small_number j;
/* small_number l; */
- int l; /* 95/Jan/7 */
+ int l;
if (s < 256)
cur_val = s + single_base;
cur_val = id_lookup(0, l);
flush_string();
-
-#ifdef SHORTHASH
- if (s > 65535L)
- puts("ERROR: hash entry too large\n");
-#endif
-
text(cur_val) = s;
}
}
selector = new_string;
- print_string(" (format=");
+ prints(" (format=");
print(job_name);
print_char(' ');
print_int(year);
print_ln();
print_int(str_ptr);
- print_string(" strings of total length ");
+ prints(" strings of total length ");
print_int(pool_ptr);
sort_avail();
dump_int(dyn_used);
print_ln();
print_int(x);
- print_string(" memory locations dumped; current usage is ");
+ prints(" memory locations dumped; current usage is ");
print_int(var_used);
print_char('&');
print_int(dyn_used);
dump_int(cs_count);
print_ln();
print_int(cs_count);
- print_string(" multiletter control sequences");
+ prints(" multiletter control sequences");
dump_int(fmem_ptr);
if (font_size[k] != font_dsize[k])
{
- print_string(" at ");
+ prints(" at ");
print_scaled(font_size[k]);
- print_string("pt");
+ prints("pt");
}
}
}
print_ln();
print_int(fmem_ptr - 7);
- print_string(" words of font info for ");
+ prints(" words of font info for ");
print_int(font_ptr - 0);
- print_string(" preloaded font");
+ prints(" preloaded font");
if (font_ptr != 1)
print_char('s');
print_ln();
print_int(hyph_count);
- print_string(" hyphenation exception");
+ prints(" hyphenation exception");
if (hyph_count != 1)
print_char('s');
print_nl("Hyphenation trie of length ");
print_int(trie_max);
- print_string(" has ");
+ prints(" has ");
print_int(trie_op_ptr);
- print_string(" op");
+ prints(" op");
if (trie_op_ptr != 1)
print_char('s');
- print_string(" out of ");
+ prints(" out of ");
print_int(trie_op_size);
for (k = 255; k >= 0; k--)
{
print_nl(" ");
print_int(trie_used[k]);
- print_string(" for language ");
+ prints(" for language ");
print_int(k);
dump_int(k);
dump_int(trie_used[k]);
}
}
/* string version print. */
-void print_string_ (const char *s)
+void prints_ (const char *s)
{
while (*s > 0)
print_char(*s++);
((file_offset > 0) && (selector >= log_only)))
print_ln();
- print_string(s);
+ prints(s);
}
/* sec 0063 */
void print_esc (const char * s)
if (c < 256)
print(c);
- print_string(s);
+ prints(s);
}
/* sec 0064 */
void print_the_digs_ (eight_bits k)
do
{
decr(help_ptr);
- print_string(help_line[help_ptr]);
+ prints(help_line[help_ptr]);
print_ln();
}
while (!(help_ptr == 0));
{
error_count = 0;
interaction = 0 + c - 81; /* Q = 0, R = 1, S = 2, T = 3 */
- print_string("OK, entering ");
+ prints("OK, entering ");
switch (c)
{
break;
}
- print_string("...");
+ prints("...");
print_ln();
update_terminal();
return;
} /* end of switch analysing response character */
{
- print_string("Type <return> to proceed, S to scroll future error messages,");
+ prints("Type <return> to proceed, S to scroll future error messages,");
print_nl("R to run without stopping, Q to run quietly,");
print_nl("I to insert something, ");
if (base_ptr > 0)
- print_string("E to edit your file,");
+ prints("E to edit your file,");
if (deletions_allowed)
print_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
{
normalize_selector();
print_err("TeX capacity exceeded, sorry [");
- print_string(s);
+ prints(s);
print_char('=');
print_int(n);
print_char(']');
if (history < error_message_issued)
{
print_err("This can't happen (");
- print_string(s);
+ prints(s);
print_char(')');
help1("I'm broken. Please show this to someone who can fix can fix");
}
/* sec 0091 */
void int_error_ (integer n)
{
- print_string(" (");
+ prints(" (");
print_int(n);
print_char(')');
error();
break;
case end_match:
- print_string("->");
+ prints("->");
break;
default:
switch (scanner_status)
{
case defining:
- print_string("definition");
+ prints("definition");
p = def_ref;
break;
case matching:
- print_string("argument");
+ prints("argument");
p = temp_head;
break;
case aligning:
- print_string("preamble");
+ prints("preamble");
p = hold_head;
break;
case absorbing:
- print_string("text");
+ prints("text");
p = def_ref;
break;
}
return 0;
}
- add_variable_space (block_size); /* now to be found in itex.c */
- goto restart; /* go try get_node again */
+ add_variable_space (block_size);
+ goto restart; /* go try get_node again */
found:
link(r) = 0;
case mark_node:
case adjust_node:
case unset_node:
- print_string("[]");
+ prints("[]");
break;
case rule_node:
print_char('|');
print_scaled(d);
if ((order < normal) || (order > filll))
- print_string("foul");
+ prints("foul");
else if (order > 0)
{
- print_string("fil");
+ prints("fil");
while (order > 1)
{
}
}
else if (*s != '\0')
- print_string(s);
+ prints(s);
}
/* sec 0178 */
void print_spec_(integer p, char * s)
print_scaled(width(p));
if (*s != '\0')
- print_string(s);
+ prints(s);
if (stretch(p) != 0)
{
- print_string("plus");
+ prints("plus");
print_glue(stretch(p), stretch_order(p), s);
}
if (shrink(p) != 0)
{
- print_string("minus");
+ prints("minus");
print_glue(shrink(p), shrink_order(p), s);
}
}
if ((pool_ptr - str_start[str_ptr]) >= depth_threshold)
{
if (math_type(p) != 0)
- print_string(" []");
+ prints(" []");
}
else
{
{
print_ln();
print_current_string();
- print_string("{}");
+ prints("{}");
}
else
show_info();
print_esc("scriptscriptstyle");
break;
default:
- print_string("Unknown style!");
+ prints("Unknown style!");
break;
}
}
break;
default:
- print_string("[unknown glue parameter!]");
+ prints("[unknown glue parameter!]");
break;
}
}
if (cur_length > depth_threshold)
{
if (p != 0) /* fixed 94/Mar/23 BUG FIX NOTE: still not fixed in 3.14159 ! */
- print_string(" []");
+ prints(" []");
return;
}
if (p > mem_end)
{
- print_string("Bad link, display aborted.");
+ prints("Bad link, display aborted.");
return;
}
if (n > breadth_max)
{
- print_string("etc.");
+ prints("etc.");
return;
}
print_esc("v");
else print_esc("unset");
- print_string("box(");
+ prints("box(");
print_scaled(height(p));
print_char('+');
print_scaled(depth(p));
- print_string(")x");
+ prints(")x");
print_scaled(width(p));
if (type(p) == unset_node)
{
if (span_count(p) != 0)
{
- print_string(" (");
+ prints(" (");
print_int(span_count(p) + 1);
- print_string(" columns)");
+ prints(" columns)");
}
if (glue_stretch(p) != 0)
{
- print_string(", stretch ");
+ prints(", stretch ");
print_glue(glue_stretch(p), glue_order(p), "");
}
if (glue_shrink(p) != 0)
{
- print_string(", shrink ");
+ prints(", shrink ");
print_glue(glue_shrink(p), glue_sign(p), "");
}
}
if ((g != 0.0) && (glue_sign(p) != 0))
{
- print_string(", glue set ");
+ prints(", glue set ");
if (glue_sign(p) == shrinking)
- print_string("- ");
+ prints("- ");
if (fabs(g)> 20000.0)
{
if (g > 0.0)
print_char('>');
else
- print_string("< -");
+ prints("< -");
print_glue(20000 * unity, glue_order(p), "");
}
if (shift_amount(p) != 0)
{
- print_string(", shifted ");
+ prints(", shifted ");
print_scaled(shift_amount(p));
}
}
print_rule_dimen(height(p));
print_char('+');
print_rule_dimen(depth(p));
- print_string(")x");
+ prints(")x");
print_rule_dimen(width(p));
}
break;
{
print_esc("insert");
print_int(subtype(p));
- print_string(", natural size ");
+ prints(", natural size ");
print_scaled(height(p));
- print_string("; split(");
+ prints("; split(");
print_spec(split_top_ptr(p), "");
print_char(',');
print_scaled(depth(p));
- print_string("); float cost ");
+ prints("); float cost ");
print_int(float_cost(p));
{
{
{
print_esc("setlanguage");
print_int(what_lang(p));
- print_string(" (hyphenmin ");
+ prints(" (hyphenmin ");
print_int(what_lhm(p));
print_char(',');
print_int(what_rhm(p));
break;
default:
- print_string("whatsit?");
+ prints("whatsit?");
break;
}
break;
else if (subtype(p) == x_leaders)
print_char('x');
- print_string("leaders ");
+ prints("leaders ");
print_spec(glue_ptr(p), "");
{
print_scaled(width(p));
if (subtype(p) == acc_kern)
- print_string(" (for accent)");
+ prints(" (for accent)");
}
else
{
print_esc("mkern");
print_scaled(width(p));
- print_string("mu");
+ prints("mu");
}
break;
print_esc("math");
if (subtype(p) == before)
- print_string("on");
+ prints("on");
else
- print_string("off");
+ prints("off");
if (width(p) != 0)
{
- print_string(", surrounded ");
+ prints(", surrounded ");
print_scaled(width(p));
}
}
case ligature_node:
{
print_font_and_char(lig_char(p));
- print_string("(ligature ");
+ prints("(ligature ");
if (subtype(p) > 1)
print_char('|');
if (replace_count(p) > 0)
{
- print_string(" replacing ");
+ prints(" replacing ");
print_int(replace_count(p));
}
print_esc("fraction, thickness ");
if (thickness(p) == 1073741824L) /* 2^30 */
- print_string("= default");
+ prints("= default");
else
print_scaled(thickness(p));
if ((small_fam(left_delimiter(p)) != 0) || (small_char(left_delimiter(p)) != 0) ||
(large_fam(left_delimiter(p)) != 0) || (large_char(left_delimiter(p)) != 0))
{
- print_string(", left-delimiter ");
+ prints(", left-delimiter ");
print_delimiter(left_delimiter(p));
}
if ((small_fam(right_delimiter(p)) != 0) || (small_char(right_delimiter(p)) != 0) ||
(large_fam(right_delimiter(p)) != 0) || (large_char(right_delimiter(p)) != 0))
{
- print_string(", right-delimiter ");
+ prints(", right-delimiter ");
print_delimiter(right_delimiter(p));
}
break;
default:
- print_string("Unknown node type!");
+ prints("Unknown node type!");
break;
}
p = link(p);
switch (m / (max_command + 1))
{
case 0:
- print_string("vertical");
+ prints("vertical");
break;
case 1:
- print_string("horizontal");
+ prints("horizontal");
break;
case 2:
- print_string("display math");
+ prints("display math");
break;
}
}
else
{
if (m == 0)
- print_string("no");
+ prints("no");
else
{
switch ((- (integer) m) / (max_command + 1))
{
case 0:
- print_string("internal vertical");
+ prints("internal vertical");
break;
case 1:
- print_string("restricted horizontal");
+ prints("restricted horizontal");
break;
case 2:
- print_string("math");
+ prints("math");
break;
}
}
}
- print_string(" mode");
+ prints(" mode");
}
/* sec 0216 */
void push_nest (void)
a = nest[p].aux_field;
print_nl("### ");
print_mode(m);
- print_string(" entered at line ");
+ prints(" entered at line ");
print_int(abs(nest[p].ml_field));
if (m == hmode)
{
if (nest[p].pg_field != 040600000)
{
- print_string(" (language");
+ prints(" (language");
print_int(nest[p].pg_field % 65536L);
- print_string(":hyphenmin");
+ prints(":hyphenmin");
print_int(nest[p].pg_field / 4194304L);
print_char(',');
print_int((nest[p].pg_field / 65536L) % 64);
}
if (nest[p].ml_field < 0)
- print_string(" (\\output routine)");
+ prints(" (\\output routine)");
if (p == 0)
{
print_nl("### current page:");
if (output_active)
- print_string(" (held over for next output)");
+ prints(" (held over for next output)");
show_box(link(page_head));
print_esc("insert");
t = subtype(r);
print_int(t);
- print_string(" adds ");
+ prints(" adds ");
if (count(t) == 1000)
t = height(r);
}
while (!(q == broken_ins(r)));
- print_string(", #");
+ prints(", #");
print_int(t);
- print_string(" might split");
+ prints(" might split");
}
r = link(r);
}
print_nl("prevdepth ");
if (a.cint <= ignore_depth)
- print_string("ignored");
+ prints("ignored");
else
print_scaled(a.cint);
if (nest[p].pg_field != 0)
{
- print_string(", prevgraf ");
+ prints(", prevgraf ");
print_int(nest[p].pg_field);
- print_string(" line");
+ prints(" line");
if (nest[p].pg_field != 1)
print_char('s');
{
if (a.hh.rh > 0)
{
- print_string(", current language ");
+ prints(", current language ");
print_int(a.hh.rh);
}
}
case 2:
if (a.cint != 0)
{
- print_string("this will be denominator of:");
+ prints("this will be denominator of:");
show_box(a.cint);
}
break;
break;
default:
- print_string("[unknown integer parameter!]");
+ prints("[unknown integer parameter!]");
break;
}
}
break;
default:
- print_string("[unknown dimen parameter!]");
+ prints("[unknown dimen parameter!]");
break;
}
}
print_esc("span");
else
{
- print_string("alignment tab character ");
+ prints("alignment tab character ");
print(chr_code);
}
break;
break;
case set_font:
- print_string("select font ");
+ prints("select font ");
slow_print(font_name[chr_code]);
if (font_size[chr_code] != font_dsize[chr_code])
{
- print_string(" at ");
+ prints(" at ");
print_scaled(font_size[chr_code]);
- print_string("pt");
+ prints("pt");
}
break;
break;
case undefined_cs:
- print_string("undefined");
+ prints("undefined");
break;
case call:
- print_string("macro");
+ prints("macro");
break;
case long_call:
break;
default:
- print_string("[unknown extension!]");
+ prints("[unknown extension!]");
break;
}
break;
default:
- print_string("[unknown command code!]");
+ prints("[unknown command code!]");
break;
}
}
print_char('=');
if (equiv(n) == 0)
- print_string("void");
+ prints("void");
else
{
depth_threshold = 0;
else if (n < cat_code_base)
{
if (n == cur_font_loc)
- print_string("current font");
+ prints("current font");
else if (n < math_font_base + 16)
{
print_esc("textfont");
print_char('=');
print_scaled(eqtb[n].cint);
- print_string("pt");
+ prints("pt");
}
else
print_char('?');
{
begin_diagnostic();
print_char('{');
- print_string(s);
+ prints(s);
print_char(' ');
show_eqtb(p);
print_char('}');
{
print_err("Incompatible magnification (");
print_int(mag);
- print_string(");");
+ prints(");");
print_nl(" the previous value will be retained");
help2("I can handle only one magnification ratio per job. So I've",
"reverted to the magnification you used earlier on this run.");
if (mode != shown_mode)
{
print_mode(mode);
- print_string(": ");
+ prints(": ");
shown_mode = mode;
}
print_char('(');
print_int(line);
- print_string(") :");
+ prints(") :");
}
else
{
}
else
{
- print_string("...");
+ prints("...");
p = l + first_count - half_error_line + 3;
n = half_error_line;
}
print_char(trick_buf[q % error_line]);
if (m + n > error_line)
- print_string("...");
+ prints("...");
incr(nn);
}
break;
}
- print_string("->");
+ prints("->");
token_show(p);
end_diagnostic(false);
}
print_err("Forbidden control sequence found");
}
- print_string(" while scanning ");
+ prints(" while scanning ");
p = get_avail();
switch (scanner_status)
{
case defining:
- print_string("definition");
+ prints("definition");
info(p) = right_brace_token + '}';
break;
case matching:
- print_string("use");
+ prints("use");
info(p) = par_token;
long_state = outer_call;
break;
case aligning:
- print_string("preamble");
+ prints("preamble");
info(p) = right_brace_token + '}';
q = p;
p = get_avail();
break;
case absorbing:
- print_string("text");
+ prints("text");
info(p) = right_brace_token + '}';
break;
}
ins_list(p);
- print_string(" of ");
+ prints(" of ");
sprint_cs(warning_index);
help4("I suspect you have forgotten a `}', causing me",
"to read past where you wanted me to stop.",
{
print_err("Incomplete ");
print_cmd_chr(if_test, cur_if);
- print_string("; all text was ignored after line ");
+ prints("; all text was ignored after line ");
print_int(skip_line);
help3("A forbidden control sequence occurred in skipped text.",
"This kind of error happens when you say `\\if...' and forget",
{
print_err("Use of ");
sprint_cs(warning_index);
- print_string(" doesn't match its definition");
+ prints(" doesn't match its definition");
help4("If you say, e.g., `\\def\\a1{...}', then you must always",
"put `1' after `\\a', since control sequence names are",
"made up of letters only. The macro here has not been",
runaway();
print_err("Paragraph ended before ");
sprint_cs(warning_index);
- print_string("was complete");
+ prints("was complete");
help3("I suspect you've forgotten a `}', causing me to apply this",
"control sequence to too much text. How can we recover?",
"My plan is to forget the whole thing and hope for the best.");
runaway();
print_err("Paragraph ended before ");
sprint_cs(warning_index);
- print_string(" was complete");
+ prints(" was complete");
help3("I suspect you've forgotten a `}', causing me to apply this",
"control sequence to too much text. How can we recover?",
"My plan is to forget the whole thing and hope for the best.");
back_input();
print_err("Argument of ");
sprint_cs(warning_index);
- print_string(" has an extra }");
+ prints(" has an extra }");
help6("I've run across a `}' that doesn't seem to match anything.",
"For example, `\\def\\a#1{...}' and `\\a}' would produce",
"this error. If you simply proceed now, the `\\par' that",
//print_nl(match_chr);
print_nl(""); print(match_chr);
print_int(n);
- print_string("<-");
+ prints("<-");
show_token_list(pstack[n - 1], 0, 1000);
end_diagnostic(false);
}
{
print_err("Missing ");
print_esc("endcsname");
- print_string(" inserted");
+ prints(" inserted");
help2("The control sequence marked <to be read again> should",
"not appear between \\csname and \\endcsname.");
back_error();
{
print_err("Font ");
print_esc(""); print(font_id_text(f));
- print_string(" has only ");
+ prints(" has only ");
print_int(font_params[f]);
- print_string(" fontdimen parameters");
+ prints(" fontdimen parameters");
help2("To increase the number of font parameters, you must",
"use \\fontdimen immediately after the \\font is loaded.");
error();
{
print_err("You can't use `");
print_cmd_chr(cur_cmd, cur_chr);
- print_string("' after ");
+ prints("' after ");
print_esc("the");
help1("I'm forgetting what you said and using zero instead.");
error();
if (cur_order == filll)
{
print_err("Illegal unit of measure (");
- print_string("replaced by filll)");
+ prints("replaced by filll)");
help1("I dddon't go any higher than filll.");
error();
}
else
{
print_err("Illegal unit of measure (");
- print_string("mu inserted)");
+ prints("mu inserted)");
help4("The unit of measurement in math glue must be mu.",
"To recover gracefully from this error, it's best to",
"delete the erroneous units; e.g., type `2' to delete",
else
{
print_err("Illegal unit of measure (");
- print_string("pt inserted)");
+ prints("pt inserted)");
help6("Dimensions can be in units of em, ex, in, pt, pc,",
"cm, mm, dd, cc, bp, or sp; but yours is a new one!",
"I'll assume that you meant to say pt, for printer's points.",
case dimen_val:
{
print_scaled(cur_val);
- print_string("pt");
+ prints("pt");
}
break;
case glue_val:
if (font_size[cur_val] != font_dsize[cur_val])
{
- print_string(" at ");
+ prints(" at ");
print_scaled(font_size[cur_val]);
- print_string("pt");
+ prints("pt");
}
break;
if (tracing_commands > 1)
{
begin_diagnostic();
- print_string("{case ");
+ prints("{case ");
print_int(n);
print_char('}');
end_diagnostic(false);
begin_diagnostic();
if (b)
- print_string("{true}");
+ prints("{true}");
else
- print_string("{false}");
+ prints("{false}");
end_diagnostic(false);
}
print_err("I can't write on file `");
print_file_name(cur_name, cur_area, cur_ext);
- print_string("'.");
+ prints("'.");
if (e == 785) /* .tex */
show_context();
print_nl("Please type another ");
- print_string(s);
+ prints(s);
if (interaction < 2)
{
if (format_ident > 0)
slow_print(format_ident);
- print_string(" ");
+ prints(" ");
if (civilize_flag)
print_int(year);
if (s >= 0)
{
- print_string(" at ");
+ prints(" at ");
print_scaled(s);
- print_string("pt");
+ prints("pt");
}
else if (s != -1000)
{
- print_string(" scaled ");
+ prints(" scaled ");
print_int(- (integer) s);
}
- print_string(" not loaded: Not enough room left");
+ prints(" not loaded: Not enough room left");
help4("I'm afraid I won't be able to make use of this font,",
"because my memory for character-size data is too small.",
"If you're really stuck, ask a wizard to enlarge me.",
if (s >= 0)
{
- print_string(" at ");
+ prints(" at ");
print_scaled(s);
- print_string("pt");
+ prints("pt");
}
else if (s != -1000)
{
- print_string("scaled");
+ prints("scaled");
print_int(- (integer) s);
}
if (file_opened)
- print_string(" not loadable: Bad metric (TFM) file");
+ prints(" not loadable: Bad metric (TFM) file");
else
- print_string(" not loadable: Metric (TFM) file not found");
+ prints(" not loadable: Metric (TFM) file not found");
help5("I wasn't able to read the size data for this font,",
"so I will ignore the font specification.",
if (show_missing) /* add ! before 94/June/10 */
{
print_nl("! ");
- print_string("Missing character: there is no ");
+ prints("Missing character: there is no ");
}
else
print_nl("Missing character: there is no ");
print_char(')');
}
- print_string(" in font ");
+ prints(" in font ");
slow_print(font_name[f]);
print_char('!');
{
print_nl("");
print_ln();
- print_string("Completed box being shipped out");
+ prints("Completed box being shipped out");
}
if (term_offset > max_print_line - 9)
dvi_four(mag);
old_setting = selector;
selector = new_string;
- print_string(" TeX output ");
+ prints(" TeX output ");
print_int(year);
print_char('.');
print_two(month);
#ifdef STAT
if (tracing_stats > 1)
{
- print_string(" after: ");
+ prints(" after: ");
print_int(var_used);
print_char('&');
print_int(dyn_used);
- print_string("; still utouched: ");
+ prints("; still utouched: ");
print_int(hi_mem_min - lo_mem_max - 1);
print_ln();
}
else
print_nl("Loose");
- print_string(" \\hbox (badness ");
+ prints(" \\hbox (badness ");
print_int(last_badness);
if (last_badness > 100) /* Y&Y TeX */
print_ln();
print_nl("Overfull \\hbox (");
print_scaled(- (integer) x - total_shrink[normal]);
- print_string("pt too wide");
+ prints("pt too wide");
overfull_hbox++;
common_ending:
if (output_active)
- print_string(") has occurred while \\output is active");
+ prints(") has occurred while \\output is active");
else
{
if (pack_begin_line != 0)
{
if (pack_begin_line > 0)
- print_string(") in paragraph at lines ");
+ prints(") in paragraph at lines ");
else
- print_string(") in alignment at lines ");
+ prints(") in alignment at lines ");
print_int(abs(pack_begin_line));
- print_string("--");
+ prints("--");
}
else
- print_string(") detected at line ");
+ prints(") detected at line ");
print_int(line);
}
else
print_nl("Loose");
- print_string(" \\vbox (badness ");
+ prints(" \\vbox (badness ");
print_int(last_badness);
if (last_badness > 100)
print_ln();
print_nl("Overfull \\vbox (");
print_scaled(- (integer) x - total_shrink[0]);
- print_string("pt too high");
+ prints("pt too high");
overfull_vbox++; /* 1996/Feb/9 */
common_ending:
if (output_active)
- print_string(") has occurred while \\output is active");
+ prints(") has occurred while \\output is active");
else
{
if (pack_begin_line != 0)
{
- print_string(") in alignment at lines ");
+ prints(") in alignment at lines ");
print_int(abs(pack_begin_line));
- print_string("--");
+ prints("--");
}
else
- print_string(") detected at line ");
+ prints(") detected at line ");
print_int(line);
print_ln();
print_size(cur_size);
print_char(' ');
print_int(fam(a));
- print_string(" is undefined (character ");
+ prints(" is undefined (character ");
print(cur_c);
print_char(')');
help4("Somewhere in the math formula just ended, you used the",
{
print_err("Improper ");
print_esc("halign");
- print_string(" inside $$'s");
+ prints(" inside $$'s");
help3("Displays can use special alignments (like \\eqalignno)",
"only if nothing but the alignment itself is between $$'s.",
"So I've deleted the formulas that preceded this alignment.");
{
print_nl("@@");
print_int(serial(passive));
- print_string(": line ");
+ prints(": line ");
print_int(line_number(q) - 1);
print_char('.');
print_int(fit_class);
if (break_type == hyphenated)
print_char('-');
- print_string(" t=");
+ prints(" t=");
print_int(total_demerits(q));
- print_string(" -> @@");
+ prints(" -> @@");
if (prev_break(passive) == 0)
print_char('0');
print_esc("math");
}
- print_string(" via @@");
+ prints(" via @@");
if (break_node(r) == 0)
print_char('0');
else
print_int(serial(break_node(r)));
- print_string(" b=");
+ prints(" b=");
if (b > inf_bad)
print_char('*');
else
print_int(b);
- print_string(" p=");
+ prints(" p=");
print_int(pi);
- print_string(" d=");
+ prints(" d=");
if (artificial_demerits)
print_char('*');
{
print_err("Improper ");
print_esc("hyphenation");
- print_string(" will be flushed");
+ prints(" will be flushed");
help2("Hyphenation exceptions must contain only letters",
"and hyphens. But continue; I'll forgive and forget.");
error();
{
print_err("");
print_esc("vsplit");
- print_string(" needs a ");
+ prints(" needs a ");
print_esc("vbox");
help2("The box you are trying to split is an \\hbox.",
"I can't split such a box, so I'll leave it alone.");
if (page_so_far[2] != 0)
{
- print_string(" plus ");
+ prints(" plus ");
print_scaled(page_so_far[2]);
- print_string("");
+ prints("");
}
if (page_so_far[3] != 0)
{
- print_string(" plus ");
+ prints(" plus ");
print_scaled(page_so_far[3]);
- print_string("fil");
+ prints("fil");
}
if (page_so_far[4] != 0)
{
- print_string(" plus ");
+ prints(" plus ");
print_scaled(page_so_far[4]);
- print_string("fill");
+ prints("fill");
}
if (page_so_far[5] != 0)
{
- print_string(" plus ");
+ prints(" plus ");
print_scaled(page_so_far[5]);
- print_string("filll");
+ prints("filll");
}
if (page_so_far[6] != 0)
{
- print_string(" minus ");
+ prints(" minus ");
print_scaled(page_so_far[6]);
}
}
begin_diagnostic();
print_nl("%% goal height=");
print_scaled(page_goal);
- print_string(", max depth=");
+ prints(", max depth=");
print_scaled(page_max_depth);
end_diagnostic(false);
}
{
print_err("");
print_esc("box");
- print_string("255 is not void");
+ prints("255 is not void");
help2("You shouldn't use \\box255 except in \\output routines.",
"Proceed, and I'll discard its present contents.");
box_error(255);
{
print_err("Output loop---");
print_int(dead_cycles);
- print_string(" consecutive dead cycles");
+ prints(" consecutive dead cycles");
help3("I've concluded that your \\output is awry; it never does",
"\\ship_out, so I'm shipping \box255 out myself. Next ",
"increase \\maxdeadcycles if you want me to be more patient!");
begin_diagnostic();
print_nl("% split");
print_int(n);
- print_string(" to");
+ prints(" to");
print_scaled(w);
print_char(',');
print_scaled(best_height_plus_depth);
- print_string(" p=");
+ prints(" p=");
if (q == 0)
print_int(eject_penalty);
{
begin_diagnostic();
print_nl("%");
- print_string(" t=");
+ prints(" t=");
print_totals();
- print_string(" g=");
+ prints(" g=");
print_scaled(page_goal);
- print_string(" b=");
+ prints(" b=");
if (b == awful_bad) /* 2^30 - 1 */
print_char('*');
else
print_int(b);
- print_string(" p=");
+ prints(" p=");
print_int(pi);
- print_string(" c=");
+ prints(" c=");
if (c == awful_bad) /* 2^30 - 1 */
print_char('*');
{
print_err("You can't use `");
print_cmd_chr(cur_cmd, cur_chr);
- print_string("' in ");
+ prints("' in ");
print_mode(mode);
}
/* sec 1050 */
break;
}
- print_string(" inserted");
+ prints(" inserted");
ins_list(link(temp_head));
help5("I've inserted something that you may have forgotten.",
"(See the <inserted text> above.)",
{
print_err("You can't use `");
print_esc("hrule");
- print_string("' here except with leaders");
+ prints("' here except with leaders");
help2("To put a horizontal rule in an hbox or an alignment,",
"you should use \\leaders or \\hrulefill (see The TeXbook).");
error();
{
print_err("Please use ");
print_esc("mathaccent");
- print_string(" for accents in math mode");
+ prints(" for accents in math mode");
help2("I'm changing \\accent to \\mathaccent here; wish me luck.",
"(Accents are not the same in formulas as they are in text.)");
error();
{
print_err("You can't use `");
print_cmd_chr(cur_cmd, cur_chr);
- print_string("' after ");
+ prints("' after ");
print_cmd_chr(q, 0);
help1("I'm forgetting what you said and not changing anything.");
error();
{
old_setting = selector;
selector = new_string;
- print_string("FONT");
+ prints("FONT");
print(u - active_base);
selector = old_setting;
str_room(1);
{
print_err("Improper `at' size (");
print_scaled(s);
- print_string("pt), replaced by 10pt");
+ prints("pt), replaced by 10pt");
help2("I can only handle fonts at positive sizes that are",
"less than 2048pt, so I've changed what you said to 10pt.");
error();
equiv(u) = f;
eqtb[font_id_base + f] = eqtb[u];
-
-#ifdef SHORTHASH
- if (t > 65535L)
- {
- sprintf(log_line, "ERROR: %s too large %d\n", "hash_used", t);
- show_line(log_line, 1);
- }
-#endif
font_id_text(f) = t;
}
/* sec 1265 */
print_char('=');
if (box(cur_val) == 0)
- print_string("void");
+ prints("void");
else
show_box(box(cur_val));
}
if (tracing_online <= 0)
{
selector = term_only;
- print_string(" (see the transcript file)");
+ prints(" (see the transcript file)");
selector = term_and_log;
}
cur_tok = cs_token_flag + frozen_cr;
print_err("Missing ");
print_esc("cr");
- print_string("inserted");
+ prints("inserted");
help1("I'm guessing that you meant to end an alignment here.");
ins_error();
}
print_nl("Output written on ");
if (full_file_name_flag && dvi_file_name != NULL)
- print_string(dvi_file_name);
+ prints(dvi_file_name);
else
slow_print(output_file_name);
- print_string(" (");
+ prints(" (");
print_int(total_pages);
- print_string(" page");
+ prints(" page");
if (total_pages != 1)
print_char('s');
- print_string(", ");
+ prints(", ");
print_int(dvi_offset + dvi_ptr);
- print_string(" bytes).");
+ prints(" bytes).");
b_close(dvi_file);
}
}
print_nl("Transcript written on ");
if (full_file_name_flag && log_file_name != NULL)
- print_string(log_file_name);
+ prints(log_file_name);
else
slow_print(texmf_log_name);
}
inline void prompt_input(const char * s)
{
- print_string(s);
+ prints(s);
term_input();
}
inline void set_cur_lang(void)
if (interaction == error_stop_mode);
print_nl("! ");
- print_string(s);
+ prints(s);
}
/* sec 0079 */
inline void tex_help (unsigned int n, ...)
#define chr_cmd(s) \
do \
{ \
- print_string(s); \
+ prints(s); \
print(chr_code); \
} \
while (0)
OSDN Git Service
