check_full_save_stack().
vet_glue().
replaced lables.
#define print_char(s) print_char_((ASCII_code) (s))
void print_(integer);
#define print(s) print_((integer) (s))
-void print_string_(unsigned char * s);
-#define print_string(s) print_string_((unsigned char *) s)
+void print_string_(const char * s);
+#define print_string(s) print_string_((const char *) s)
void slow_print_(integer);
#define slow_print(s) slow_print_((integer) (s))
void print_nl(const char *);
}
else if (type(s) == ligature_node)
if (lig_ptr(s) == 0)
- goto lab22;
+ goto continu;
else
{
q = lig_ptr(s);
hf = font(q);
}
else if ((type(s) == kern_node) && (subtype(s) == normal))
- goto lab22;
+ goto continu;
else if (type(s) == whatsit_node)
{
if (subtype(s) == language_node)
lhyf = what_lhm(s);
rhyf = what_rhm(s);
}
- goto lab22;
+ goto continu;
}
else
- goto lab31;
+ goto done1;
if (lc_code(c) != 0)
if ((lc_code(c) == (halfword) c) || (uc_hyph > 0)) /* fixed signed tyoe */
- goto lab32;
+ goto done2;
else
- goto lab31;
-lab22:
+ goto done1;
+continu:
prevs = s;
s = link(prevs);
}
-lab32:
+done2:
hyf_char = hyphen_char[hf];
if (hyf_char < 0)
- goto lab31;
+ goto done1;
if (hyf_char > 255)
- goto lab31; /* ? */
+ goto done1; /* ? */
ha = prevs;
if (lhyf + rhyf > 63)
- goto lab31;
+ goto done1;
hn = 0;
if (is_char_node(s))
{
if (font(s) != hf)
- goto lab33;
+ goto done3;
hyfbchar = character(s);
c = hyfbchar; /* unsigned char c; */
if (lc_code(c) == 0)
- goto lab33;
+ goto done3;
if (hn == 63)
- goto lab33;
+ goto done3;
hb = s;
incr(hn);
else if (type(s) == ligature_node)
{
if (font(lig_char(s)) != hf)
- goto lab33;
+ goto done3;
j = hn;
q = lig_ptr(s);
c = character(q);
if (lc_code(c) == 0)
- goto lab33;
+ goto done3;
if (j == 63)
- goto lab33;
+ goto done3;
incr(j);
hu[j] = c;
hyfbchar = font_bchar[hf];
}
else
- goto lab33;
+ goto done3;
s = link(s);
}
-lab33:;
+done3:;
if (hn < lhyf + rhyf)
- goto lab31;
+ goto done1;
while (true)
{
break;
case kern_node:
if (subtype(s) != normal)
- goto lab34;
+ goto done4;
break;
case whatsit_node:
case glue_node:
case ins_node:
case adjust_node:
case mark_node:
- goto lab34;
+ goto done4;
break;
default:
- goto lab31;
+ goto done1;
break;
}
s = link(s);
}
-lab34:;
+done4:;
hyphenate();
}
-lab31:;
+done1:;
}
}
break;
prev_p = cur_p;
cur_p = s;
- goto lab35;
+ goto done5;
}
break;
prev_p = cur_p;
cur_p = link(cur_p);
-lab35:;
+done5:;
}
if (cur_p == 0)
if (looseness == 0)
{
- goto lab30; /* normal exit */
+ goto done; /* normal exit */
}
{
if ((actual_looseness == looseness) || final_pass)
{
- goto lab30;
+ goto done;
}
}
}
}
}
-lab30:
+done:
if (best_line == 2)
single_line++;
add_token_ref(q);
define(p, call, q);
}
- goto lab30;
+ goto done;
}
}
if (is_initex)
{
new_patterns();
- goto lab30;
+ goto done;
}
#endif
print_err("Patterns can be loaded only by INITEX");
else
{
new_hyph_exceptions();
- goto lab30;
+ goto done;
}
break;
break;
}
-lab30:
+done:
if (after_token != 0)
{
cur_tok = after_token;
undump_int(x);
if (x != BEGINFMTCHECKSUM)
- goto lab_bad_fmt;
+ goto bad_fmt;
undump_int(x); /* mem_bot */
if (x != mem_bot)
- goto lab_bad_fmt;
+ goto bad_fmt;
undump_int(x); /* mem_top */
#endif
if (x != mem_top)
- goto lab_bad_fmt;
+ goto bad_fmt;
undump_int(x); /* eqtb_size */
if (x != eqtb_size)
- goto lab_bad_fmt;
+ goto bad_fmt;
undump_int(x); /* hash_prime */
if (x != hash_prime)
- goto lab_bad_fmt;
+ goto bad_fmt;
undump_int(x); /* hyphen_prime */
#endif
if (x != hyphen_prime)
- goto lab_bad_fmt;
+ goto bad_fmt;
{
undump_int(x); /* pool_size */
if (x < 0)
- goto lab_bad_fmt;
+ goto bad_fmt;
#ifdef ALLOCATESTRING
if (x > current_pool_size)
#endif
{
printf("%s%s\n", "---! Must increase the ", "string pool size");
- goto lab_bad_fmt;
+ goto bad_fmt;
}
else
pool_ptr = x;
undump_int(x); /* max_strings */
if (x < 0)
- goto lab_bad_fmt;
+ goto bad_fmt;
#ifdef ALLOCATESTRING
if (x > current_max_strings)
#endif
{
printf("%s%s\n", "---! Must increase the ", "max strings");
- goto lab_bad_fmt;
+ goto bad_fmt;
}
else
str_ptr = x;
p = q + node_size(q);
if ((p > lo_mem_max) || ((q >= rlink(q)) && (rlink(q) != rover)))
- goto lab_bad_fmt;
+ goto bad_fmt;
q = rlink(q);
}
{
/* or call add_variable_space(mem_bot - (mem_min + 1)) */
if (trace_flag)
- puts("Splicing in mem_min space in undump!\n");
+ puts("Splicing in mem_min space in undump!");
p = llink(rover);
q = mem_min + 1;
undump_int(x);
if ((x < 1) || (k + x > (eqtb_size + 1)))
- goto lab_bad_fmt;
+ goto bad_fmt;
if (undumpthings(eqtb[k], x))
return -1;
undump_int(x);
if ((x < 0) || (k + x > (eqtb_size + 1)))
- goto lab_bad_fmt;
+ goto bad_fmt;
for (j = k; j <= k + x - 1; j++)
eqtb[j] = eqtb[k - 1];
undump_int(x); /* font_mem_size */
if (x < 7)
- goto lab_bad_fmt;
+ goto bad_fmt;
#ifdef ALLOCATEFONT
if (trace_flag)
if (x > font_mem_size)
#endif
{
- puts("---! Must increase the font mem size\n");
- goto lab_bad_fmt;
+ puts("---! Must increase the font mem size");
+ goto bad_fmt;
}
else
fmem_ptr = x;
undump_int(x); /* font_max */
if (x < 0)
- goto lab_bad_fmt;
+ goto bad_fmt;
if (x > font_max)
{
- puts("---! Must increase the font max\n");
- goto lab_bad_fmt;
+ puts("---! Must increase the font max");
+ goto bad_fmt;
}
else
font_ptr = x;
undump_int(x);
if (x < 0)
- goto lab_bad_fmt;
+ goto bad_fmt;
#ifdef ALLOCATETRIES
if (!is_initex)
if (x > trie_size)
{
puts("---! Must increase the trie size\n");
- goto lab_bad_fmt;
+ goto bad_fmt;
}
else
j = x;
undump_int(x);
if (x < 0)
- goto lab_bad_fmt;
+ goto bad_fmt;
if (x > trie_op_size)
{
puts("---! Must increase the trie op size\n");
- goto lab_bad_fmt;
+ goto bad_fmt;
}
else
j = x;
undump_int(x);
if ((x != ENDFMTCHECKSUM) || feof(fmt_file))
- goto lab_bad_fmt;
+ goto bad_fmt;
return true;
-lab_bad_fmt:;
+bad_fmt:;
puts("(Fatal format file error; I'm stymied)\n");
return false;
slow_print(format_ident);
print_ln();
-
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
-
+ update_terminal();
job_name = 0;
name_in_progress = false;
log_opened = false;
}
if (trie_taken[h])
- goto lab45;
+ goto not_found;
q = trie_r[p];
while (q > 0)
{
if (trie_trl[h + trie_c[q]] == 0)
- goto lab45;
+ goto not_found;
q = trie_r[q];
}
- goto lab40;
-lab45:
+ goto found;
+not_found:
z = trie_trl[z];
}
-lab40:
+found:
trie_taken[h] = true; /* h may be used without ... */
trie_hash[p] = h;
q = p;
if (l > 0)
decr(l);
else
- goto lab31;
+ goto done1;
}
-lab31:
+done1:
q = 0;
hc[0] = cur_lang;
}
if (cur_cmd == right_brace)
- goto lab30;
+ goto done;
k = 0;
hyf[0] = 0;
break;
}
}
-lab30:;
+done:;
}
else
{
if ((equiv(j) == equiv(j + 1)) &&
(eq_type(j) == eq_type(j + 1)) &&
(eq_level(j) == eq_level(j + 1)))
- goto lab41;
+ goto found1;
incr(j);
}
l = (int_base);
- goto lab31;
-lab41:
+ goto done1;
+found1:
incr(j);
l = j;
while (j < (int_base - 1))
if ((equiv(j) != equiv(j + 1)) ||
(eq_type(j) != eq_type(j + 1)) ||
(eq_level(j) != eq_level(j + 1)))
- goto lab31;
+ goto done1;
incr(j);
}
-lab31:
+done1:
dump_int(l - k);
if (dumpthings(eqtb[k], l - k))
while (j < (eqtb_size))
{
if (eqtb[j].cint == eqtb[j + 1].cint)
- goto lab42;
+ goto found2;
incr(j);
}
l = (eqtb_size + 1);
- goto lab32;
-lab42:
+ goto done2;
+found2:
incr(j);
l = j;
while (j < (eqtb_size))
{
if (eqtb[j].cint != eqtb[j + 1].cint)
- goto lab32;
+ goto done2;
incr(j);
}
-lab32:
+done2:
dump_int(l - k);
if (dumpthings(eqtb[k], l - k))
if (trace_flag)
{
- sprintf(log_line, "Main Memory: variable node %d (%d - %d) one word %d (%d - %d)\n",
- lo_mem_max - mem_min, mem_min, lo_mem_max, mem_end - hi_mem_min, hi_mem_min, mem_end);
- show_line(log_line, 0);
+ printf("Main Memory: variable node %d (%d - %d);\n"
+ " one word %d (%d - %d)\n",
+ lo_mem_max - mem_min, mem_min, lo_mem_max,
+ mem_end - hi_mem_min, hi_mem_min, mem_end);
}
if (trace_flag)
- puts("Freeing memory again\n");
+ puts("Freeing memory again");
/* only free memory if safe ... additional check */
#ifdef ALLOCATEINI
str_pool = realloc_str_pool (increment_pool_size);
if (pool_ptr < current_pool_size)
- {
- str_pool[pool_ptr] = s;
- incr(pool_ptr);
- }
+ append_char(s);
#else
if (pool_ptr < pool_size)
- {
- str_pool[pool_ptr] = s;
- incr(pool_ptr);
- }
+ append_char(s);
#endif
break;
}
}
/* string version print. */
-void print_string_ (unsigned char *s)
+void print_string_ (const char *s)
{
while (*s > 0)
print_char(*s++);
pool_pointer j;
if ((s >= str_ptr) || (s < 256))
- {
print(s);
- }
else
{
j = str_start[s];
if (interaction == error_stop_mode)
while (true)
{
-lab22:
+continu:
clear_for_error_prompt();
prompt_input("? ");
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 */
+ goto continu;
}
break;
case 'D':
{
debug_help();
- goto lab22; /* loop again */
+ goto continu;
}
break;
#endif
"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 */
+ goto continu;
}
break;
print_string("...");
print_ln();
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+ update_terminal();
return;
}
break;
while (true)
{
fputs("**", stdout);
- fflush(stdout);
+ update_terminal();
flag = input_ln(stdin, true);
if (!flag)
if (str_pool[j] != buffer[k])
{
result = false;
- goto lab45;
+ goto not_found;
}
incr(j);
result = true;
-lab45:
+not_found:
return result;
}
/* sec 0045 */
result = false;
if (length(s) != length(t))
- goto lab45;
+ goto not_found;
j = str_start[s];
k = str_start[t];
while (j < str_start[s + 1])
{
if (str_pool[j] != str_pool[k])
- goto lab45;
+ goto not_found;
incr(j);
incr(k);
result = true;
-lab45:
+not_found:
return result;
}
/* sec 0066 */
if (!knuth_flag)
show_line("\n", 0);
- fflush(stdout);
+ update_terminal();
flag = input_ln(stdin, true);
if (!flag)
pointer q;
integer r;
integer t;
-lab20:
+restart:
p = rover;
{
node_size(p) = r - p;
rover = p;
- goto lab40;
+ goto found;
}
if (r == p)
t = llink(p);
llink(rover) = t;
rlink(t) = rover;
- goto lab40;
+ goto found;
}
node_size(p) = q - p;
link(lo_mem_max) = 0;
info(lo_mem_max) = 0;
rover = q;
- goto lab20;
+ goto restart;
}
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
}
add_variable_space (block_size); /* now to be found in itex.c */
- goto lab20; /* go try get_node again */
+ goto restart; /* go try get_node again */
-lab40:
+found:
link(r) = 0;
#ifdef STAT
{
print_nl("AVAIL list clobbered at ");
print_int(q);
- goto lab31;
+ goto done1;
}
freearr[p] = true;
q = p;
p = link(q);
}
-lab31:;
+done1:;
p = rover;
q = 0;
clobbered = false;
{
print_nl("Double-AVAIL list clobbered at ");
print_int(q);
- goto lab32;
+ goto done2;
}
for (q = p; q <= p + node_size(p) - 1; q++)
{
print_nl("Doubly free location at ");
print_int(q);
- goto lab32;
+ goto done2;
}
freearr[q]= true;
}
q = p;
p = rlink(p);
} while (!(p == rover));
-lab32:;
+done2:;
p = mem_min;
while (p <= lo_mem_max) {
if (is_empty(p))
{
flush_node_list(list_ptr(p));
free_node(p, box_node_size);
- goto lab30;
+ goto done;
}
break;
case rule_node:
{
free_node(p, rule_node_size);
- goto lab30;
+ goto done;
}
break;
case ins_node:
flush_node_list(ins_ptr(p));
delete_glue_ref(split_top_ptr(p));
free_node(p, ins_node_size);
- goto lab30;
+ goto done;
}
break;
case whatsit_node:
{
delete_token_ref(write_tokens(p));
free_node(p, write_node_size);
- goto lab30;
+ goto done;
}
break;
case close_node:
}
break;
}
- goto lab30;
+ goto done;
}
break;
case glue_node:
case style_node:
{
free_node(p, style_node_size);
- goto lab30;
+ goto done;
}
break;
case choice_node:
flush_node_list(script_mlist(p));
flush_node_list(script_script_mlist(p));
free_node(p, style_node_size);
- goto lab30;
+ goto done;
}
break;
case ord_noad:
else
free_node(p, noad_size);
}
- goto lab30;
+ goto done;
}
break;
case left_noad:
case right_noad:
{
free_node(p, noad_size);
- goto lab30;
+ goto done;
}
break;
case fraction_noad:
flush_node_list(info(numerator(p)));
flush_node_list(info(denominator(p)));
free_node(p, fraction_noad_size);
- goto lab30;
+ goto done;
}
break;
default:
}
free_node(p, small_node_size);
-lab30:;
+done:;
}
p = q;
if (text(p) > 0)
if (length(text(p)) == l)
if (str_eq_buf(text(p), j))
- goto lab40;
+ goto found;
if (next(p) == 0)
{
if (no_new_control_sequence)
- {
p = undefined_control_sequence;
- }
else
{
if (text(p) > 0)
{
if (hash_is_full)
{
- overflow("hash size", hash_size + hash_extra); /* 96/Jan/10 */
+ overflow("hash size", hash_size + hash_extra);
+ /* not dynamic ^~~~~~~~~~~~~~~~~~~~~~*/
return 0;
}
#endif
}
- goto lab40;
+ goto found;
}
+
p = next(p);
}
-lab40:
+found:
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 */
- {
- overflow("save size", current_save_size);
- return;
- }
-#else
- if (max_save_stack > save_size - 6) /* save size - not dynamic */
- {
- overflow("save size", save_size);
- return;
- }
-#endif
- }
-
+{
+ check_full_save_stack();
save_type(save_ptr) = level_boundary;
save_level(save_ptr) = (quarterword) cur_group;
save_index(save_ptr) = cur_boundary;
if (cur_level == max_quarterword)
{
- overflow("grouping levels", max_quarterword - min_quarterword); /* 96/Oct/12 ??? */
+ overflow("grouping levels", max_quarterword - min_quarterword);
return;
}
/* sec 0276 */
void eq_save_(halfword p, quarterword l)
{
- 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 */
- {
- overflow("save size", current_save_size);
- return;
- }
-#else
- if (max_save_stack > save_size - 6) /* save size not dynamic */
- {
- overflow("save size", save_size);
- return;
- }
-#endif
- }
+ check_full_save_stack();
if (l == level_zero)
save_type(save_ptr) = restore_zero;
{
if (cur_level > 1)
{
- 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 */
- {
- overflow("save size", current_save_size);
- return;
- }
-#else
- if (max_save_stack > save_size - 6) /* save satck - not dynamic */
- {
- overflow("save size", save_size);
- return;
- }
-#endif
- }
-
+ check_full_save_stack();
save_type(save_ptr) = insert_token;
save_level(save_ptr) = level_zero;
save_index(save_ptr) = t;
decr(save_ptr);
if (save_type(save_ptr) == level_boundary)
- goto lab30;
+ goto done;
p = save_index(save_ptr);
}
}
}
-lab30:
+done:
cur_group = save_level(save_ptr);
cur_boundary = save_index(save_ptr);
}
}
if (bottom_line)
- goto lab30;
+ goto done;
decr(base_ptr);
}
-lab30:
+done:
cur_input = input_stack[input_ptr];
}
/* sec 0323 */
p = temp_head;
m = 0;
}
-lab22:
+continu:
get_token();
if (cur_tok == info(r))
if (cur_tok < left_brace_limit)
decr(align_state);
- goto lab40;
+ goto found;
}
else
- goto lab22;
+ goto continu;
}
if (s != r)
"made up of letters only. The macro here has not been",
"followed by the required stuff, so I'm ignoring it.");
error();
- goto lab10;
+ goto exit;
}
else
{
{
if (u == r)
if (cur_tok != info(v))
- goto lab30;
+ goto done;
else
{
r = link(v);
- goto lab22;
+ goto continu;
}
if (info(u) != info(v))
- goto lab30;
+ goto done;
u = link(u);
v = link(v);
}
-lab30:
+done:
t = link(t);
}
while (!(t == r));
for (m = 0; m <= n; m++)
flush_list(pstack[m]);
- goto lab10;
+ goto exit;
}
if (cur_tok < right_brace_limit)
for (m = 0; m <= n; m++)
flush_list(pstack[m]);
- goto lab10;
+ goto exit;
}
if (cur_tok < right_brace_limit)
decr(unbalance);
if (unbalance == 0)
- goto lab31;
+ goto done1;
}
}
-lab31:
+done1:
rbrace_ptr = p;
store_new_token(cur_tok);
}
long_state = call;
cur_tok = par_token;
ins_error();
- goto lab22;
+ goto continu;
}
else
{
if (cur_tok == space_token)
if (info(r) <= end_match_token)
if (info(r) >= match_token)
- goto lab22;
+ goto continu;
store_new_token(cur_tok);
}
incr(m); /* m may be used without having been ... */
if (info(r) > end_match_token)
- goto lab22;
+ goto continu;
if (info(r) < match_token)
- goto lab22;
-lab40:
+ goto continu;
+found:
if (s != 0)
{
if ((m == 1) && (info(p) < right_brace_limit) && (p != temp_head))
param_ptr = param_ptr + n;
}
-lab10:
+exit:
scanner_status = save_scanner_status;
warning_index = save_warning_index;
}
/* sec 0380 */
void get_x_token (void)
{
-lab20:
+restart:
get_next();
if (cur_cmd <= max_command)
- goto lab30;
+ goto done;
if (cur_cmd >= call)
if (cur_cmd < end_template)
{
cur_cs = frozen_endv;
cur_cmd = endv;
- goto lab30;
+ goto done;
}
else
expand();
- goto lab20;
+ goto restart;
-lab30:
+done:
if (cur_cs == 0)
cur_tok = (cur_cmd * 256) + cur_chr;
else
ASCII_code c, cc;
char d;
-lab20:
+restart:
cur_cs = 0;
if (state != token_list)
{
-lab25:
+lab_switch:
if (loc <= limit)
{
cur_chr = buffer[loc];
incr(loc);
-lab21:
+reswitch:
cur_cmd = cat_code(cur_chr);
switch (state + cur_cmd)
case any_state_plus(ignore):
case skip_blanks + spacer:
case new_line + spacer:
- goto lab25;
+ goto lab_switch;
break;
case any_state_plus(escape):
cur_cs = null_cs;
else
{
-lab26:
+start_cs:
k = loc;
cur_chr = buffer[k];
cat = cat_code(cur_chr);
incr(k);
}
- goto lab26;
+ goto start_cs;
}
}
}
{
cur_cs = id_lookup(loc, k - loc);
loc = k;
- goto lab40;
+ goto found;
}
}
else
buffer[k] = buffer[k + d];
incr(k);
}
- goto lab26;
+ goto start_cs;
}
}
}
cur_cs = single_base + buffer[loc];
incr(loc);
}
-lab40:
+found:
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
{
incr(loc);
hex_to_cur_chr();
- goto lab21;
+ goto reswitch;
}
}
else
cur_chr = c - 64;
- goto lab21;
+ goto reswitch;
}
}
deletions_allowed = false;
error();
deletions_allowed = true;
- goto lab20;
+ goto restart;
}
break;
case any_state_plus(comment):
{
loc = limit + 1;
- goto lab25;
+ goto lab_switch;
}
break;
{
print_char(')');
decr(open_parens);
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+ update_terminal();
force_eof = false;
end_file_reading();
check_outer_validity();
- goto lab20;
+ goto restart;
}
if (end_line_char_inactive())
if (input_ptr > 0)
{
end_file_reading();
- goto lab20;
+ goto restart;
}
if (selector < log_only)
}
check_interrupt();
- goto lab25;
+ goto lab_switch;
}
}
else if (loc != 0)
case out_param:
{
begin_token_list(param_stack[limit + cur_chr - 1], parameter);
- goto lab20;
+ goto restart;
}
break;
else
{
end_token_list();
- goto lab20;
+ goto restart;
}
if (cur_cmd <= car_ret)
begin_token_list(v_part(cur_align), v_template);
align_state = 1000000L;
- goto lab20;
+ goto restart;
}
}
\ No newline at end of file
else if ((cur_tok <= other_A_token + 5) && (cur_tok >= other_A_token))
d = cur_tok - other_A_token;
else
- goto lab30;
+ goto done;
else
- goto lab30;
+ goto done;
vacuous = false;
cur_val = cur_val * radix + d;
get_x_token();
}
-lab30:;
+done:;
if (vacuous)
{
}
if (cur_val_level == mu_val)
- goto lab89;
+ goto attach_sign;
if (cur_val_level != int_val)
mu_error();
scan_something_internal(dimen_val, false);
if (cur_val_level == dimen_val)
- goto lab89;
+ goto attach_sign;
}
}
else
get_x_token();
if ((cur_tok > zero_token + 9) || (cur_tok < zero_token))
- goto lab31;
+ goto done1;
if (k < 17)
{
incr(k);
}
}
-lab31:
+done1:
for (kk = k; kk >= 1; kk--)
{
dig[kk - 1] = info(p);
else
incr(cur_order);
}
- goto lab88;
+ goto attach_fraction;
}
}
}
v = cur_val;
- goto lab40;
+ goto found;
}
if (mu)
- goto lab45;
+ goto not_found;
if (scan_keyword("em"))
v = quad(cur_font);
else if (scan_keyword("ex"))
v = x_height(cur_font);
else
- goto lab45;
+ goto not_found;
{
get_x_token();
back_input();
}
-lab40:
+found:
cur_val = mult_and_add(savecurval, v, xn_over_d(v, f, 65536L), 1073741823L); /* 2^30 - 1 */
- goto lab89;
+ goto attach_sign;
-lab45:
+not_found:
if (mu)
{
if (scan_keyword("mu"))
- goto lab88;
+ goto attach_fraction;
else
{
print_err("Illegal unit of measure (");
"delete the erroneous units; e.g., type `2' to delete",
"two letters. (See Chapter 27 of The TeXbook.)");
error();
- goto lab88;
+ goto attach_fraction;
}
}
}
if (scan_keyword("pt"))
- goto lab88;
+ goto attach_fraction;
if (scan_keyword("in"))
set_conversion(7227, 100);
else if (scan_keyword("H"))
set_conversion(7227, 10160);
else if (scan_keyword("sp"))
- goto lab30;
+ goto done;
else
{
print_err("Illegal unit of measure (");
"delete the erroneous units; e.g., type `2' to delete",
"two letters. (See Chapter 27 of The TeXbook.)");
error();
- goto lab32;
+ goto done2;
}
cur_val = xn_over_d(cur_val, num, denom);
f = (num * f + 65536L * tex_remainder) / denom;
cur_val = cur_val +(f / 65536L);
f = f % 65536L;
-lab32:;
-lab88:
+
+done2:
+attach_fraction:
if (cur_val >= 16384) /* 2^14 */
arith_error = true;
else
cur_val = cur_val * unity + f;
-lab30:;
+
+done:
{
get_x_token();
if (cur_cmd != spacer)
back_input();
}
-lab89:
+
+attach_sign:
if (arith_error || (abs(cur_val) >= 1073741824L)) /* 2^30 */
{
print_err("Dimension too large");
depth(q) = 0;
}
-lab21:
+reswitch:
if (scan_keyword("width"))
{
scan_dimen(false, false, false);
width(q) = cur_val;
- goto lab21;
+ goto reswitch;
}
if (scan_keyword("height"))
{
scan_dimen(false, false, false);
height(q) = cur_val;
- goto lab21;
+ goto reswitch;
}
if (scan_keyword("depth"))
{
scan_dimen(false, false, false);
depth(q) = cur_val;
- goto lab21;
+ goto reswitch;
}
return q;
get_token();
if (cur_tok < right_brace_limit)
- goto lab31;
+ goto done1;
if (cur_cmd == mac_param)
{
hashbrace = cur_tok;
store_new_token(cur_tok);
store_new_token(end_match_token);
- goto lab30;
+ goto done;
}
if (t == zero_token + 9)
store_new_token(cur_tok);
}
-lab31:
+done1:
store_new_token(end_match_token);
if (cur_cmd == right_brace)
help2("Where was the left brace? You said something like `\\def\\a}',",
"which I'm going to interpret as `\\def\\a{}'.");
error();
- goto lab40;
+ goto found;
}
-lab30:;
+done:;
}
else
{
get_next();
if (cur_cmd <= max_command)
- goto lab32;
+ goto done2;
if (cur_cmd != the)
{
}
}
}
-lab32:
+done2:
x_token();
}
else
decr(unbalance);
if (unbalance == 0)
- goto lab40;
+ goto found;
}
else if (cur_cmd == mac_param)
if (macrodef)
store_new_token(cur_tok);
}
-lab40:
+found:
scanner_status = 0;
if (hashbrace != 0)
get_token();
if (cur_tok == 0)
- goto lab30;
+ goto done;
if (align_state < 1000000L)
{
while (!(cur_tok == 0));
align_state = 1000000L;
- goto lab30;
+ goto done;
}
store_new_token(cur_tok);
}
-lab30:
+done:
end_file_reading();
}
while (!(align_state == 1000000L));
if (cur_cmd == fi_or_else)
{
if (l == 0)
- goto lab30;
+ goto done;
if (cur_chr == 2)
decr(l);
else if (cur_cmd == if_test)
incr(l);
}
-lab30:
+done:
scanner_status = save_scanner_status;
}
/* sec 0497 */
if (cur_chr == or_code)
decr(n);
else
- goto lab50;
+ goto common_ending;
else if (cur_chr == fi_code)
{
p = cond_ptr;
if (cond_ptr == savecondptr)
{
if (cur_chr != or_code)
- goto lab50;
+ goto common_ending;
print_err("Extra ");
print_esc("or");
}
}
-lab50:
+common_ending:
if (cur_chr == fi_code)
{
p = cond_ptr;
if ((cur_cmd > other_char) || (cur_chr > 255))
{
back_input();
- goto lab30;
+ goto done;
}
if (!more_name(cur_chr)) /* up to next white space */
- goto lab30;
+ goto done;
get_x_token();
}
-lab30:
+done:
end_name();
name_in_progress = false;
}
while (true)
{
if (k == last)
- goto lab30;
+ goto done;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
/* convert tilde '~' to pseudo tilde */
if (pseudo_tilde != 0 && buffer[k]== '~')
buffer[k] = pseudo_space;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
if (!more_name(buffer[k]))
- goto lab30;
+ goto done;
incr(k);
}
-lab30:
+done:
end_name();
}
begin_file_reading();
if (a_open_in(cur_file, TEXINPUTPATH))
- goto lab30;
+ goto done;
end_file_reading();
prompt_file_name("input file name", ".tex");
}
-lab30:
+done:
cur_input.name_field = a_make_name_string(cur_file);
if (job_name == 0)
max_open_parens = open_parens;
slow_print(cur_input.name_field);
-
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
-
+ update_terminal();
state = new_line;
{
if (!b_open_in(tfm_file))
{
- goto lab11;
+ goto bad_tfm;
}
file_opened = true;
read_sixteen(ec);
if ((bc > ec + 1) || (ec > 255))
- goto lab11;
+ goto bad_tfm;
if (bc > 255)
{
read_sixteen(np);
if (lf != 6 + lh + (ec - bc + 1) + nw + nh + nd + ni + nl + nk + ne + np)
- goto lab11;
+ goto bad_tfm;
if ((nw == 0) || (nh == 0) || (nd == 0) || (ni == 0))
- goto lab11;
+ goto bad_tfm;
}
lf = lf - 6 - lh;
"If you're really stuck, ask a wizard to enlarge me.",
"Or maybe try `I\\font<same font id>=<name of loaded font>'.");
error();
- goto lab30;
+ goto done;
}
f = font_ptr + 1;
{
if (lh < 2)
- goto lab11;
+ goto bad_tfm;
store_four_quarters(font_check[f]);
tfm_temp = getc(tfm_file);
z =(z * 16) + (tfm_temp / 16);
if (z < unity)
- goto lab11;
+ goto bad_tfm;
while (lh > 2)
{
store_four_quarters(font_info[k].qqqq);
if ((a >= nw) || (b / 16 >= nh) || (b % 16 >= nd) || (c / 4 >= ni))
- goto lab11;
+ goto bad_tfm;
switch (c % 4)
{
case lig_tag:
if (d >= nl)
- goto lab11;
+ goto bad_tfm;
break;
case ext_tag:
if (d >= ne)
- goto lab11;
+ goto bad_tfm;
break;
case list_tag:
{
{
if ((d < bc) || (d > ec))
- goto lab11;
+ goto bad_tfm;
}
while (d < k + bc - fmem_ptr)
qw = char_info(f, d);
if (char_tag(qw) != list_tag)
- goto lab45;
+ goto not_found;
d = rem_byte(qw);
}
if (d == k + bc - fmem_ptr)
- goto lab11;
-lab45:;
+ goto bad_tfm;
+not_found:;
}
break;
else if (a == 255)
font_info[k].cint = sw - alpha;
else
- goto lab11;
+ goto bad_tfm;
}
if (font_info[width_base[f]].cint != 0)
- goto lab11;
+ goto bad_tfm;
if (font_info[height_base[f]].cint != 0)
- goto lab11;
+ goto bad_tfm;
if (font_info[depth_base[f]].cint != 0)
- goto lab11;
+ goto bad_tfm;
if (font_info[italic_base[f]].cint != 0)
- goto lab11;
+ goto bad_tfm;
}
bch_label = 32767; /* '77777 */
if (a > 128)
{
if (256 * c + d >= nl)
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
if (a == 255)
if (k == lig_kern_base[f])
{
{
if ((b < bc) || (b > ec)) /* check-existence(b) */
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
}
qw = font_info[char_base[f] + b].qqqq;
if (!(qw.b0 > 0))
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
}
if (c < 128)
{
{
if ((d < bc) || (d > ec)) /* check-existence(d) */
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
}
qw = font_info[char_base[f] + d].qqqq;
if (!(qw.b0 > 0))
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
}
else if (256 * (c - 128) + d >= nk)
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
if (a < 128)
if (k - lig_kern_base[f] + a + 1 >= nl)
- goto lab11; /* error in TFM, abort */
+ goto bad_tfm;
}
}
font_info[k].cint = sw;
else if (a == 255)
font_info[k].cint = sw - alpha;
- else goto lab11;
+ else
+ goto bad_tfm;
}
- /* read extensible character recipes */
for (k = exten_base[f]; k <= param_base[f] - 1; k++)
{
store_four_quarters(font_info[k].qqqq);
{
{
if ((a < bc) || (a > ec))
- goto lab11;
+ goto bad_tfm;
}
qw = font_info[char_base[f] + a].qqqq;
if (!(qw.b0 > 0))
- goto lab11;
+ goto bad_tfm;
}
if (b != 0)
{
{
if ((b < bc) || (b > ec))
- goto lab11;
+ goto bad_tfm;
}
qw = font_info[char_base[f] + b].qqqq;
if (!(qw.b0 > 0))
- goto lab11;
+ goto bad_tfm;
}
if (c != 0)
{
{
if ((c < bc) || (c > ec))
- goto lab11;
+ goto bad_tfm;
}
qw = font_info[char_base[f] + c].qqqq;
if (!(qw.b0 > 0))
- goto lab11;
+ goto bad_tfm;
}
{
{
if ((d < bc) || (d > ec))
- goto lab11;
+ goto bad_tfm;
}
qw = font_info[char_base[f] + d].qqqq;
if (!(qw.b0 > 0))
- goto lab11;
+ goto bad_tfm;
}
}
font_info[param_base[f] + k - 1].cint = sw;
else if (a == 255)
font_info[param_base[f] + k - 1].cint = sw - alpha;
- else goto lab11;
+ else goto bad_tfm;
}
if (feof(tfm_file))
- goto lab11;
+ goto bad_tfm;
for (k = np + 1; k <= 7; k++)
font_info[param_base[f] + k - 1].cint = 0;
fmem_ptr = fmem_ptr + lf;
font_ptr = f;
g = f;
- goto lab30;
+ goto done;
-lab11:
+bad_tfm:
print_err("Font ");
sprint_cs(u);
print_char('=');
"e.g., type `I\\font<same font id>=<substitute font name>'.");
error();
-lab30:
+done:
if (file_opened)
b_close(tfm_file);
if (c / 100 > 0)
{
- print_char(48 + c / 100);
-/* c = c % 100; */
- c = c - (c / 100) * 100; /* ? */
- print_char(48 + c / 10);
+ print_char('0' + c / 100);
+ c = c - (c / 100) * 100;
+ print_char('0' + c / 10);
}
else
{
-/* c = c % 100; */
- c = c - (c / 100) * 100; /* ? */
- if (c / 10 > 0) print_char(48 + c / 10);
+ c = c - (c / 100) * 100;
+ if (c / 10 > 0)
+ print_char('0' + c / 10);
}
- print_char(48 + c % 10);
+ print_char('0' + c % 10);
print_char(')');
-/* print_char(32); */
}
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
+
print_string(" in font ");
slow_print(font_name[f]);
print_char('!');
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
-/* if (show_missing) show_context(); */ /* in tex2.c 94/June/10 */
+
if (show_missing)
{
if (f != 0)
show_context(); /* not if its the nullfont */
}
- if (show_missing == 0) /* show on screen 94/June/10 */
+ if (show_missing == 0)
end_diagnostic(false);
missing_characters++; /* bkph 93/Dec/16 */
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
}
}
/* sec 0582 */
if (trace_flag)
{
show_char('\n');
- sprintf(log_line, "dvi_swap %d", dvi_gone);
+ sprintf(log_line, "dvi_swap() %d", dvi_gone);
show_line(log_line, 0);
}
case z_seen + yz_OK:
case z_seen + y_OK:
if (location(p) < dvi_gone)
- goto lab45;
+ goto not_found;
else
{
k = location(p) - dvi_offset;
dvi_buf[k] = dvi_buf[k] + y1 - down1;
info(p) = y_here;
- goto lab40;
+ goto found;
}
break;
case y_seen + yz_OK:
case y_seen + z_OK:
if (location(p) < dvi_gone)
- goto lab45;
+ goto not_found;
else
{
k = location(p) - dvi_offset;
dvi_buf[k] = dvi_buf[k] + z1 - down1;
info(p) = z_here;
- goto lab40;
+ goto found;
}
break;
case none_seen + z_here:
case y_seen + z_here:
case z_seen + y_here:
- goto lab40;
+ goto found;
break;
default:
break;
}
- else switch (mstate + info(p))
- {
- case none_seen + y_here:
- mstate = y_seen;
- break;
+ else
+ switch (mstate + info(p))
+ {
+ case none_seen + y_here:
+ mstate = y_seen;
+ break;
- case none_seen + z_here:
- mstate = z_seen;
- break;
+ case none_seen + z_here:
+ mstate = z_seen;
+ break;
- case y_seen + z_here:
- case z_seen + y_here:
- goto lab45;
- break;
+ case y_seen + z_here:
+ case z_seen + y_here:
+ goto not_found;
+ break;
+
+ default:
+ break;
+ }
- default:
- break;
- }
p = link(p);
}
-lab45:
+not_found:
info(q) = yz_OK;
w = w + 256;
goto lab1;
+
lab2:
- //dvi_out(w / 256);
- dvi_out((w >> 8));
+ dvi_out(w / 256);
+
lab1:
- //dvi_out(w % 256);
- dvi_out(w & 255);
+ dvi_out(w % 256);
return;
-lab40:
+
+found:
info(q) = info(p);
if (info(q) == y_here)
while (down_ptr != 0)
{
if (location(down_ptr) < l)
- goto lab30;
+ goto done;
p = down_ptr;
down_ptr = link(p);
free_node(p, movement_node_size);
}
-lab30:
+done:
while (right_ptr != 0)
{
if (location(right_ptr) < l)
else
{
if (write_open[j])
- (void) a_close(write_file[j]);
+ a_close(write_file[j]);
if (subtype(p) == close_node)
- write_open[j]= false;
+ write_open[j]= false;
else if (j < 16)
{
cur_name = open_name(p);
pack_file_name(cur_name, cur_area, cur_ext);
- while (! a_open_out(write_file[j]))
- {
+ while (!a_open_out(write_file[j]))
prompt_file_name("output file name", ".tex");
- }
write_open[j] = true;
}
scaled save_h, save_v;
halfword this_box;
/* glue_ord g_order; */
- int g_order; /* 95/Jan/7 */
+ int g_order;
/* char g_sign; */
- int g_sign; /* 95/Jan/7 */
+ int g_sign;
halfword p;
integer save_loc;
halfword leader_box;
left_edge = cur_h;
while (p != 0)
-lab21:
+reswitch:
if (is_char_node(p))
{
synch_h();
rule_ht = height(p);
rule_dp = depth(p);
rule_wd = width(p);
- goto lab14;
+ goto fin_rule;
}
break;
if (stretch_order(g) == g_order)
{
cur_glue = cur_glue + stretch(g);
- glue_temp = glue_set(this_box) * cur_glue;
-
- if (glue_temp > 1000000000.0)
- glue_temp = 1000000000.0;
- else if (glue_temp < -1000000000.0)
- glue_temp = -1000000000.0;
-
+ vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
else if (shrink_order(g) == g_order)
{
cur_glue = cur_glue - shrink(g);
- glue_temp = glue_set(this_box) * cur_glue;
-
- if (glue_temp > 1000000000.0)
- glue_temp = 1000000000.0;
- else if (glue_temp < -1000000000.0)
- glue_temp = -1000000000.0;
-
+ vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
{
rule_ht = height(leader_box);
rule_dp = depth(leader_box);
- goto lab14;
+ goto fin_rule;
}
leader_wd = width(leader_box);
}
cur_h = edge - 10;
- goto lab15;
+ goto next_p;
}
}
- goto lab13;
+ goto move_past;
}
break;
mem[lig_trick] = mem[lig_char(p)];
link(lig_trick) = link(p);
p = lig_trick;
- goto lab21;
+ goto reswitch;
}
break;
break;
}
- goto lab15;
-lab14:
- if ((rule_ht == -1073741824L)) /* - 2^30 */
+ goto next_p;
+
+fin_rule:
+ if (is_running(rule_ht))
rule_ht = height(this_box);
- if ((rule_dp == -1073741824L)) /* - 2^30 */
+ if (is_running(rule_dp))
rule_dp = depth(this_box);
rule_ht = rule_ht + rule_dp;
cur_v = base_line;
dvi_h = dvi_h + rule_wd;
}
-lab13:
+
+move_past:
cur_h = cur_h + rule_wd;
-lab15:
+
+next_p:
p = link(p);
}
rule_ht = height(p);
rule_dp = depth(p);
rule_wd = width(p);
- goto lab14;
+ goto fin_rule;
}
break;
if (stretch_order(g) == g_order)
{
cur_glue = cur_glue + stretch(g);
- glue_temp = glue_set(this_box) * cur_glue;
-
- if (glue_temp > 1000000000.0)
- glue_temp = 1000000000.0;
- else if (glue_temp < -1000000000.0)
- glue_temp = -1000000000.0;
-
+ vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
else if (shrink_order(g) == g_order) /* BUG FIX !!! */
{
cur_glue = cur_glue - shrink(g);
- glue_temp = glue_set(this_box) * cur_glue;
-
- if (glue_temp > 1000000000.0)
- glue_temp = 1000000000.0;
- else if (glue_temp < -1000000000.0)
- glue_temp = -1000000000.0;
-
+ vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
{
rule_wd = width(leader_box);
rule_dp = 0;
- goto lab14;
+ goto fin_rule;
}
leader_ht = height(leader_box) + depth(leader_box);
}
cur_v = edge - 10;
- goto lab15;
+ goto next_p;
}
}
- goto lab13;
+ goto move_past;
}
break;
default:
break;
}
- goto lab15;
-lab14:
- if ((rule_wd == -1073741824L)) /* -2^30 */
+
+ goto next_p;
+
+fin_rule:
+ if (is_running(rule_wd))
rule_wd = width(this_box);
rule_ht = rule_ht + rule_dp;
dvi_four(rule_wd);
}
- goto lab15;
-lab13:
+ goto next_p;
+
+move_past:
cur_v = cur_v + rule_ht;
}
-lab15:
+
+next_p:
p = link(p);
}
if (k < j)
print_char('.');
}
-
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+
+ update_terminal();
if (tracing_output > 0)
{
end_diagnostic(true);
}
- goto lab30;
+ goto done;
}
if (height(p) + depth(p) + v_offset > max_v)
{
dvi_out(pre);
dvi_out(id_byte);
- dvi_four(25400000L); /* magic DVI scale factor */
- dvi_four(473628672L); /* 7227 * 65536 */
+ dvi_four(25400000L);
+ dvi_four(473628672L);
prepare_mag();
dvi_four(mag);
old_setting = selector;
incr(total_pages);
cur_s = -1;
-lab30:;
+done:;
if (tracing_output <= 0)
print_char(']');
dead_cycles = 0;
-
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+ update_terminal();
#ifdef STAT
if (tracing_stats > 1)
{
spec_code = additional;
cur_val = 0;
- goto lab40;
+ goto found;
}
scan_dimen(false, false, false);
-lab40:
+found:
if (three_codes)
{
saved(0) = s;
while (p != 0)
{
-lab21:
+reswitch:
while (is_char_node(p))
{
f = font(p);
case whatsit_node:
break;
+
case glue_node:
{
g = glue_ptr(p);
mem[lig_trick] = mem[lig_char(p)];
link(lig_trick) = link(p);
p = lig_trick;
- goto lab21;
+ goto reswitch;
}
break;
glue_sign(r) = normal;
glue_order(r) = normal;
glue_set(r) = 0.0;
- goto lab10;
+ goto exit;
}
else if (x > 0)
{
print_int(last_badness);
if (last_badness > 100) /* Y&Y TeX */
- underfull_hbox++; /* 1996/Feb/9 */
+ underfull_hbox++;
- goto lab50;
+ goto common_ending;
}
}
- goto lab10;
+ goto exit;
}
else
{
glue_sign(r) = shrinking;
if (total_shrink[o] != 0)
- glue_set(r) =(- (integer) x) / ((double) total_shrink[o]);
+ glue_set(r) = ((- (integer) x) / ((double) total_shrink[o]));
else
{
glue_sign(r) = normal;
overfull_hbox++;
- goto lab50;
+ goto common_ending;
}
}
else if (o == normal)
print_ln();
print_nl("Tight \\hbox (badness ");
print_int(last_badness);
- goto lab50;
+ goto common_ending;
}
}
- goto lab10;
+ goto exit;
}
-lab50:
+common_ending:
if (output_active)
print_string(") has occurred while \\output is active");
else
show_box(r);
end_diagnostic(true);
-lab10:
+exit:
return r;
}
/* sec 0668 */
glue_sign(r) = normal;
glue_order(r) = normal;
glue_set(r) = 0.0;
- goto lab10;
+ goto exit;
}
else if (x > 0)
{
if (last_badness > 100)
underfull_vbox++; /* 1996/Feb/9 */
- goto lab50;
+ goto common_ending;
}
}
- goto lab10;
+ goto exit;
}
else
{
overfull_vbox++; /* 1996/Feb/9 */
- goto lab50;
+ goto common_ending;
}
}
else if (o == 0)
print_ln();
print_nl("Tight \\vbox (badness ");
print_int(last_badness);
- goto lab50;
+ goto common_ending;
}
}
- goto lab10;
+ goto exit;
}
-lab50:
+common_ending:
if (output_active)
print_string(") has occurred while \\output is active");
else
show_box(r);
end_diagnostic(true);
-lab10:
+exit:
return r;
}
/* sec 0679 */
p = new_skip_param(baseline_skip_code);
width(temp_ptr) = d;
}
+
link(tail) = p;
tail = p;
}
if ((y >= font_bc[g]) && (y <= font_ec[g]))
{
-lab22:
+continu:
q = char_info(g, y);
if ((q.b0 > 0))
{
f = g;
c = y;
- goto lab40;
+ goto found;
}
hd = height_depth(q);
w = u;
if (u >= v)
- goto lab40;
+ goto found;
}
if (char_tag(q) == list_tag)
{
y = rem_byte(q);
- goto lab22;
+ goto continu;
}
}
}
}
if (large_attempt)
- goto lab40;
+ goto found;
large_attempt = true;
z = large_fam(d);
x = large_char(d);
}
-lab40:
+
+found:
if (f != null_font)
if (char_tag(q) == ext_tag)
{
case sub_box:
{
q = info(p);
- goto lab40;
+ goto found;
}
break;
default:
{
q = new_null_box();
- goto lab40;
+ goto found;
}
break;
}
cur_mu = x_over_n(math_quad(cur_size), 18);
}
-lab40:
+found:
if (is_char_node(q) || (q == 0))
x = hpack(q, 0, 1);
else if ((link(q) == 0) && (type(q) <= vlist_node) && (shift_amount(q) == 0))
if (op_byte(cur_i) >= kern_flag)
if (skip_byte(cur_i) <= stop_flag)
s = char_kern(cur_f, cur_i);
- goto lab31;
+ goto done1;
}
if (skip_byte(cur_i) >= stop_flag)
- goto lab31;
+ goto done1;
a = a + skip_byte(cur_i) + 1;
cur_i = font_info[a].qqqq;
}
}
}
-lab31:;
+done1:;
x = clean_box(nucleus(q), cramped_style(cur_style));
w = width(x);
h = height(x);
while (true)
{
if (char_tag(i) != list_tag)
- goto lab30;
+ goto done;
y = rem_byte(i);
i = char_info(f, y);
if (!(i.b0 > 0))
- goto lab30;
+ goto done;
if (char_width(f, i) > w)
- goto lab30;
+ goto done;
c = y;
}
-lab30:;
+done:;
if (h < x_height(f))
delta = h;
else
integer a;
halfword p, r;
-lab20:
+restart:
if (math_type(subscr(q)) == 0)
if (math_type(supscr(q)) == 0)
if (math_type(nucleus(q)) == math_char)
return;
math_type(nucleus(q)) = math_char;
- goto lab20;
+ goto restart;
}
if (skip_byte(cur_i) >= stop_flag)
while (q != 0)
{
-lab21:
+reswitch:
delta = 0;
switch (type(q))
case left_noad:
{
type(q) = ord_noad;
- goto lab21;
+ goto reswitch;
}
break;
type(r) = ord_noad;
if (type(q) == right_noad)
- goto lab80;
+ goto done_with_noad;
}
break;
case left_noad:
- goto lab80;
+ goto done_with_noad;
break;
case fraction_noad:
{
make_fraction(q);
- goto lab82;
+ goto check_dimensions;
}
break;
delta = make_op(q);
if (subtype(q) == limits)
- goto lab82;
+ goto check_dimensions;
}
break;
cur_mu = x_over_n(math_quad(cur_size), 18);
}
- goto lab81;
+ goto done_with_node;
}
break;
link(p) = z;
}
- goto lab81;
+ goto done_with_node;
}
break;
case whatsit_node:
case penalty_node:
case disc_node:
- goto lab81;
+ goto done_with_node;
break;
case rule_node:
if (depth(q) > max_d)
max_d = depth(q);
- goto lab81;
+ goto done_with_node;
}
break;
flush_node_list(p);
}
}
- goto lab81;
+ goto done_with_node;
}
break;
case kern_node:
{
math_kern(q, cur_mu);
- goto lab81;
+ goto done_with_node;
}
break;
new_hlist(q) = p;
if ((math_type(subscr(q)) == 0) && (math_type(supscr(q)) == 0))
- goto lab82;
+ goto check_dimensions;
make_scripts(q, delta);
-lab82:
+check_dimensions:
z = hpack(new_hlist(q), 0, 1);
if (height(z) > max_h)
max_d = depth(z);
free_node(z, box_node_size);
-lab80:
+done_with_noad:
r = q;
r_type = type(r);
-lab81:
+done_with_node:
q = link(q);
}
cur_mu = x_over_n(math_quad(cur_size), 18);
}
- goto lab83;
+ goto delete_q;
}
break;
p = q;
q = link(q);
link(p) = 0;
- goto lab30;
+ goto done;
}
break;
}
r_type = t;
-lab83:
+delete_q:
r = q;
q = link(q);
free_node(r, s);
-lab30:;
+done:;
}
}
/* sec 0772 */
/* sec 0782 */
void get_preamble_token (void)
{
-lab20:
+restart:
get_token();
while ((cur_chr == span_code) && (cur_cmd == tab_mark))
else
eq_define(glue_base + tab_skip_code, glue_ref, cur_val);
- goto lab20;
+ goto restart;
}
}
/* sec 0774 */
cur_align = link(cur_align);
if (cur_cmd == car_ret)
- goto lab30;
+ goto done;
p = hold_head;
link(p) = 0;
get_preamble_token();
if (cur_cmd == mac_param)
- goto lab31;
+ goto done1;
if ((cur_cmd <= car_ret) && (cur_cmd >= tab_mark) && (align_state == -1000000L))
if ((p == hold_head) && (cur_loop == 0) && (cur_cmd == tab_mark))
"\\halign or \\valign is being set up. In this case you had",
"none, so I've put one in; maybe that will work.");
back_error();
- goto lab31;
+ goto done1;
}
else if ((cur_cmd != spacer) || (p != hold_head))
{
}
}
-lab31:
+done1:
link(cur_align) = new_null_box();
cur_align = link(cur_align);
info(cur_align) = end_span;
while (true)
{
-lab22:
+continu:
get_preamble_token();
if ((cur_cmd <= car_ret) && (cur_cmd >= tab_mark) && (align_state == -1000000L))
- goto lab32;
+ goto done2;
if (cur_cmd == mac_param)
{
"\\halign or \\valign is being set up. In this case you had",
"more than one, so I'm ignoring all but the first.");
error();
- goto lab22;
+ goto continu;
}
link(p) = get_avail();
info(p) = cur_tok;
}
-lab32:
+done2:
link(p) = get_avail();
p = link(p);
info(p) = end_template_token;
v_part(cur_align) = link(hold_head);
}
-lab30:
+done:
scanner_status = 0;
new_save_level(align_group);
/* sec 0785 */
void align_peek (void)
{
-lab20:
+restart:
align_state = 1000000L;
do
fin_align();
}
else if ((cur_cmd == car_ret) && (cur_chr == cr_cr_code))
- goto lab20;
+ goto restart;
else
{
init_row();
if (abs(pi)>= inf_penalty)
if (pi > 0)
- goto lab10;
+ goto exit;
else
pi = eject_penalty;
while (true)
{
-lab22:
+continu:
r = link(prev_r);
if (type(r) == delta_node)
do_all_six(update_width);
prev_prev_r = prev_r;
prev_r = r;
- goto lab22;
+ goto continu;
}
{
while (s != 0)
{
if (is_char_node(s))
- goto lab30;
+ goto done;
switch (type(s))
{
case kern_node:
if (subtype(s) != explicit)
- goto lab30;
+ goto done;
else
break_width[1] = break_width[1] - width(s);
break;
default:
- goto lab30;
+ goto done;
break;
}
s = link(s);
}
-lab30:;
+done:;
}
if (type(prev_r) == delta_node)
}
if (r == active)
- goto lab10;
+ goto exit;
if (l > easyline)
{
{
b = 10000;
fit_class = very_loose_fit;
- goto lab31;
+ goto done1;
}
b = badness(shortfall, cur_active_width[2]);
fit_class = loose_fit;
else
fit_class = decent_fit;
-lab31:;
+done1:;
}
else
{
if (final_pass && (minimum_demerits == awful_bad) && (link(r) == active) && (prev_r == active))
artificial_demerits = true;
else if (b > threshold)
- goto lab60;
+ goto deactivate;
node_r_stays_active = false;
}
prev_r = r;
if (b > threshold)
- goto lab22;
+ goto continu;
node_r_stays_active = true;
}
}
if (node_r_stays_active)
- goto lab22;
-lab60:
+ goto continu;
+deactivate:
link(prev_r) = link(r);
free_node(r, active_node_size);
}
}
}
-lab10:
+exit:
;
#ifdef STAT
if (cur_p == printed_node)
glue_ptr(q) = right_skip;
subtype(q) = right_skip_code + 1;
add_glue_ref(right_skip);
- goto lab30;
+ goto done;
}
else
{
link(r) = link(q);
link(q) = r;
q = r;
-lab30:
+done:
r = link(q);
link(q) = 0;
q = link(temp_head);
q = link(r);
if (q == cur_break(cur_p))
- goto lab31;
+ goto done1;
if (is_char_node(q))
- goto lab31;
+ goto done1;
if (non_discardable(q))
- goto lab31;
+ goto done1;
if (type(q) == kern_node)
if (subtype(q) != 1)
- goto lab31;
+ goto done1;
r = q;
}
-lab31:
+done1:
if (r != temp_head)
{
link(r) = 0;
lig_stack = 0;
set_cur_r();
-lab22:
+continu:
if (cur_l == non_char)
{
k = bchar_label[hf];
if (k == non_address)
- goto lab30;
+ goto done;
else
q = font_info[k].qqqq;
}
q = char_info(hf, cur_l);
if (char_tag(q) != lig_tag)
- goto lab30;
+ goto done;
k = lig_kern_start(hf, q);
q = font_info[k].qqqq;
hyphen_passed = j;
hchar = non_char;
cur_rh = non_char;
- goto lab22; /* goto continue; */
+ goto continu;
}
else
{
cur_r = character(lig_stack);
}
else if (j == n)
- goto lab30;
+ goto done;
else
{
append_charnode_to_t(cur_r);
if (op_byte(q) > 4)
if (op_byte(q) != 7)
- goto lab30;
+ goto done;
- goto lab22;
+ goto continu;
}
w = char_kern(hf, q);
- goto lab30;
+ goto done;
}
if (q.b0 >= stop_flag)
if (cur_rh == non_char)
- goto lab30;
+ goto done;
else
{
cur_rh = non_char;
- goto lab22;
+ goto continu;
}
k = k + skip_byte(q) + 1;
q = font_info[k].qqqq;
}
-lab30:
+done:
wrap_lig(rt_hit);
if (w != 0)
cur_l = character(lig_stack);
ligature_present = true;
pop_lig_stack();
- goto lab22;
+ goto continu;
}
return j;
k = hyph_word[h];
if (k == 0)
- goto lab45;
+ goto not_found;
if (length(k) < hn)
- goto lab45;
+ goto not_found;
if (length(k) == hn)
{
do
{
if (str_pool[u] < hc[j])
- goto lab45;
+ goto not_found;
if (str_pool[u] > hc[j])
- goto lab30;
+ goto done;
incr(j);
incr(u);
}
decr(hn);
- goto lab40;
+ goto found;
}
-lab30:;
+done:;
if (h > 0)
decr(h);
else
h = hyphen_prime;
}
-lab45:
+not_found:
decr(hn);
if (trie_trc[cur_lang + 1] != cur_lang)
}
}
-lab40:
+found:
for (j = 0; j <= lhyf - 1; j++)
hyf[j] = 0;
for (j = lhyf; j <= hn - rhyf; j++)
if (odd(hyf[j]))
- goto lab41;
+ goto found1;
return;
-lab41:;
+found1:;
q = link(hb);
link(hb) = 0;
r = link(ha);
if (is_char_node(ha))
if (font(ha) != hf)
- goto lab42;
+ goto found2;
else
{
init_list = ha;
}
else if (type(ha) == ligature_node)
if (font(lig_char(ha)) != hf)
- goto lab42;
+ goto found2;
else
{
init_list = lig_ptr(ha);
if (!is_char_node(r))
if (type(r) == ligature_node)
if (subtype(r) > 1)
- goto lab42;
+ goto found2;
j = 1;
s = ha;
init_list = 0;
- goto lab50;
+ goto common_ending;
}
s = cur_p;
s = link(s);
j = 0;
- goto lab50;
-lab42:
+ goto common_ending;
+found2:
s = ha;
j = 0;
hu[0] = 256;
init_lig = false;
init_list = 0;
-lab50:
+common_ending:
flush_node_list(r);
do
if (c_loc > 0)
{
- hu[c_loc] = c; /* c may be used ... */
+ hu[c_loc] = c;
c_loc = 0;
}
while (true)
{
get_x_token();
-lab21:
+reswitch:
switch (cur_cmd)
{
case letter:
scan_char_num();
cur_chr = cur_val;
cur_cmd = char_given;
- goto lab21;
+ goto reswitch;
}
break;
k = hyph_word[h];
if (length(k) < length(s))
- goto lab40;
+ goto found;
if (length(k) > length(s))
- goto lab45;
+ goto not_found;
u = str_start[k];
v = str_start[s];
do
{
if (str_pool[u] < str_pool[v])
- goto lab40;
+ goto found;
if (str_pool[u] > str_pool[v])
- goto lab45;
+ goto not_found;
incr(u);
incr(v);
}
while (!(u == str_start[k + 1]));
-lab40:
+found:
q = hyph_list[h];
hyph_list[h] = p;
p = q;
t = hyph_word[h];
hyph_word[h] = s;
s = t;
-lab45:;
+not_found:;
if (h > 0)
decr(h);
else
{
cur_height = cur_height + prev_dp + height(p);
prev_dp = depth(p);
- goto lab45;
+ goto not_found;
}
break;
case whatsit_node:
- goto lab45;
+ goto not_found;
break;
case glue_node:
if (precedes_break(prev_p))
pi = 0;
else
- goto lab90;
+ goto update_heights;
break;
case kern_node:
if (t == glue_node)
pi = 0;
else
- goto lab90;
+ goto update_heights;
}
break;
case mark_node:
case ins_node:
- goto lab45;
+ goto not_found;
break;
default:
}
if ((b == awful_bad) || (pi <= eject_penalty))
- goto lab30;
+ goto done;
}
if ((type(p) < glue_node) || (type(p) > kern_node))
- goto lab45;
-lab90:
+ goto not_found;
+
+update_heights:
if (type(p) == kern_node)
q = p;
else
cur_height = cur_height + prev_dp + width(q);
prev_dp = 0;
-lab45:
+not_found:
if (prev_dp > d)
{
cur_height = cur_height + prev_dp - d;
p = link(prev_p);
}
-lab30:
+done:
return best_place;
}
/* sec 0977 */
if (link(p) == q)
{
link(p) = 0;
- goto lab30;
+ goto done;
}
p = link(p);
}
-lab30:;
+done:;
q = prune_page_top(q);
p = list_ptr(v);
free_node(v, box_node_size);
do
{
-lab22:
+continu:
p = link(contrib_head);
if (last_glue != max_halfword)
link(q) = p;
link(contrib_head) = q;
- goto lab22;
+ goto continu;
}
else
{
page_total = page_total + page_depth + height(p);
page_depth = depth(p);
- goto lab80;
+ goto contribute;
}
break;
case whatsit_node:
- goto lab80;
+ goto contribute;
break;
case glue_node:
if (page_contents < box_there)
- goto lab31;
+ goto done1;
else if (precedes_break(page_tail))
pi = 0;
else
- goto lab90;
+ goto update_heights;
break;
case kern_node:
if (page_contents < box_there)
- goto lab31;
+ goto done1;
else if (link(p) == 0)
return;
else if (type(link(p)) == glue_node)
pi = 0;
else
- goto lab90;
+ goto update_heights;
break;
case penalty_node:
if (page_contents < box_there)
- goto lab31;
+ goto done1;
else
pi = penalty(p);
break;
case mark_node:
- goto lab80;
+ goto contribute;
break;
case ins_node:
insert_penalties = insert_penalties + penalty(q);
}
}
- goto lab80;
+ goto contribute;
}
break;
if (output_active)
return;
- goto lab30;
+ goto done;
}
}
if ((type(p) < glue_node) || (type(p) > kern_node))
- goto lab80;
-lab90:
+ goto contribute;
+
+update_heights:
if (type(p) == kern_node)
q = p;
else
page_total = page_total + page_depth + width(q);
page_depth = 0;
-lab80:
+contribute:
if (page_depth > page_max_depth)
{
page_total = page_total + page_depth - page_max_depth;
page_tail = p;
link(contrib_head) = link(p);
link(p) = 0;
- goto lab30;
-lab31:
+ goto done;
+done1:
link(contrib_head) = link(p);
link(p) = 0;
flush_node_list(p);
-lab30:;
+done:;
}
while (!(link(contrib_head) == 0));
p = link(p);
if (p == tail)
- goto lab30;
+ goto done;
}
q = link(p);
shift_amount(cur_box) = 0;
tail = p;
link(p) = 0;
-lab30:
+done:
;
}
}
end_diagnostic(true);
flush_node_list(p);
link(q) = 0;
- goto lab30;
+ goto done;
}
q = p;
incr(n);
}
-lab30:
+done:
p = link(head);
pop_nest();
while (p != 0)
{
-lab21:
+reswitch:
if (is_char_node(p))
{
f = font(p);
d = char_width(f, char_info(f, character(p)));
- goto lab40;
+ goto found;
}
switch (type(p))
case rule_node:
{
d = width(p);
- goto lab40;
+ goto found;
}
break;
mem[lig_trick] = mem[lig_char(p)];
link(lig_trick) = link(p);
p = lig_trick;
- goto lab21;
+ goto reswitch;
}
break;
}
if (subtype(p) >= a_leaders)
- goto lab40;
+ goto found;
}
break;
if (v < max_dimen) /* - (2^30 - 1) */
v = v + d;
- goto lab45;
-lab40:
+ goto not_found;
+found:
if (v < max_dimen) /* - (2^30 - 1) */
{
v = v + d;
else
{
w = max_dimen; /* - (2^30 - 1) */
- goto lab30;
+ goto done;
}
-lab45:
+not_found:
p = link(p);
}
-lab30:;
+done:;
}
if (par_shape_ptr == 0)
{
integer c;
-lab20:
+restart:
do
{
get_x_token();
}
while (!((cur_cmd != spacer) && (cur_cmd != relax)));
-lab21:
+reswitch:
switch (cur_cmd)
{
case letter:
back_input();
}
- goto lab20;
+ goto restart;
}
}
break;
scan_char_num();
cur_chr = cur_val;
cur_cmd = char_given;
- goto lab21;
+ goto reswitch;
}
break;
/* sec 1215 */
void get_r_token (void)
{
-lab20:
+restart:
do
{
get_token();
cur_tok = cs_token_flag + frozen_protection;
ins_error();
- goto lab20;
+ goto restart;
}
}
/* sec 1229 */
{
l = cur_chr;
p = cur_cmd - assign_int;
- goto lab40;
+ goto found;
}
if (cur_cmd != tex_register)
}
}
-lab40:
+found:
if (q == tex_register)
scan_optional_equals();
else
sprintf(log_line, "SKIPPING %ld ", s);
show_line(log_line, 0);
}
- goto lab50;
+ goto common_ending;
}
}
}
sprintf(log_line, "SKIPPING %ld ", s);
show_line(log_line, 0);
}
- goto lab50;
+ goto common_ending;
}
}
}
f = read_font_info(u, cur_name, cur_area, s);
-lab50:
+common_ending:
if (trace_flag)
{
sprintf(log_line, "NEW FONT %d ", f);
print_char(' ');
slow_print(s);
-
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+ update_terminal();
}
else
{
}
print_meaning();
- goto lab50;
+ goto common_ending;
}
break;
print_nl("> ");
token_show(temp_head);
flush_list(link(temp_head));
- goto lab50;
+ goto common_ending;
}
break;
}
selector = term_and_log;
}
-lab50:
+common_ending:
if (interaction < error_stop_mode)
{
pack_buffered_name(0, loc, j - 1);
if (w_open_in(fmt_file))
- goto lab40;
+ goto found;
if (knuth_flag)
{
show_line(log_line, 1);
}
-#ifndef _WINDOWS
- fflush(stdout);
-#endif
+ update_terminal();
}
pack_buffered_name(format_default_length - 4, 1, 0);
return false;
}
-lab40:
+found:
loc = j;
return true;
#include "coerce.h"
/* sec 79 */
+extern inline void update_terminal(void);
+extern inline void check_full_save_stack(void);
extern inline void push_input(void);
extern inline void pop_input(void);
extern inline void print_err (const char * s);
#define dumpcore abort
#endif
-//#define write_dvi(a, b) \
-// if ((size_t) fwrite ((char *) &dvi_buf[a], sizeof (dvi_buf[a]), \
-// (size_t) ((size_t)(b) - (size_t)(a) + 1), dvi_file) \
-// != (size_t) ((size_t)(b) - (size_t)(a) + 1)) \
-// FATAL_PERROR ("\n! dvi file")
-
-
#ifdef COMPACTFORMAT
extern int do_dump (char *, int, int, gzFile);
extern int do_undump (char *, int, int, gzFile);
#include "texd.h"
-inline void push_input(void)
+inline void update_terminal(void)
{
- if (input_ptr > max_in_stack)
+#ifndef _WINDOWS
+ fflush(stdout);
+#endif
+}
+
+inline void check_full_save_stack(void)
+{
+ if (save_ptr > max_save_stack)
{
- max_in_stack = input_ptr;
+ max_save_stack = save_ptr;
-#ifdef ALLOCATEINPUTSTACK
- if (input_ptr == current_stack_size)
- input_stack = realloc_input_stack(increment_stack_size);
+#ifdef ALLOCATESAVESTACK
+ if (max_save_stack > current_save_size - 6)
+ save_stack = realloc_save_stack(increment_save_size);
- if (input_ptr == current_stack_size)
+ if (max_save_stack > current_save_size - 6)
{
- overflow("input stack size", current_stack_size);
+ overflow("save size", current_save_size);
return;
}
#else
- if (input_ptr == stack_size)
+ if (max_save_stack > save_size - 6)
{
- overflow("input stack size", stack_size);
+ overflow("save size", save_size);
return;
}
#endif
}
-
- input_stack[input_ptr] = cur_input;
- incr(input_ptr);
-}
-inline void pop_input(void)
-{
- decr(input_ptr);
- cur_input = input_stack[input_ptr];
-}
-inline void ensure_dvi_open(void)
-{
- if (output_file_name == 0)
- {
- if (job_name == 0)
- open_log_file();
-
- pack_job_name(".dvi");
-
- while (!b_open_out(dvi_file))
- {
- prompt_file_name("file name for output", ".dvi");
- }
-
- output_file_name = b_make_name_string(dvi_file);
- }
}
-
inline void write_dvi(size_t a, size_t b)
{
if (fwrite((char *) &dvi_buf[a], sizeof(dvi_buf[a]),
print_string(s);
term_input();
}
-inline void synch_h(void)
-{
- if (cur_h != dvi_h)
- {
- movement(cur_h - dvi_h, right1);
- dvi_h = cur_h;
- }
-}
-inline void synch_v(void)
-{
- if (cur_v != dvi_v)
- {
- movement(cur_v - dvi_v, down1);
- dvi_v = cur_v;
- }
-}
inline void set_cur_lang(void)
{
if (language <= 0)
decr(dyn_used);
#endif
}
-inline void dvi_out_(ASCII_code op)
+/* sec 0042 */
+inline void append_char (ASCII_code c)
{
- dvi_buf[dvi_ptr] = op;
- incr(dvi_ptr);
-
- if (dvi_ptr == dvi_limit)
- dvi_swap();
+ str_pool[pool_ptr] = c;
+ incr(pool_ptr);
}
-inline void succumb (void)
+/* sec 0042 */
+inline void str_room(int val)
{
- if (interaction == error_stop_mode)
- interaction = scroll_mode;
-
- if (log_opened)
- {
- error();
- }
+#ifdef ALLOCATESTRING
+ if (pool_ptr + val > current_pool_size)
+ str_pool = realloc_str_pool(increment_pool_size);
-#ifdef DEBUG
- if (interaction > 0)
- debug_help();
+ if (pool_ptr + val > current_pool_size)
+ overflow("pool size", current_pool_size - init_pool_ptr);
+#else
+ if (pool_ptr + val > pool_size)
+ overflow("pool size", pool_size - init_pool_ptr);
#endif
-
- history = error_stop_mode;
- jump_out();
}
+/* sec 0044 */
inline void flush_string (void)
{
decr(str_ptr);
pool_ptr = str_start[str_ptr];
}
-inline void append_char (ASCII_code c)
-{
- str_pool[pool_ptr] = c;
- incr(pool_ptr);
-}
+/* sec 0048 */
inline void append_lc_hex (ASCII_code c)
{
if (c < 10)
else
append_char(c - 10 + 'a');
}
+/* sec 0073 */
inline void print_err (const char * s)
{
if (interaction == error_stop_mode);
print_string(s);
}
+/* sec 0079 */
inline void tex_help (unsigned int n, ...)
{
int i;
va_end(help_arg);
}
-inline void str_room(int val)
+/* sec 0093 */
+inline void succumb (void)
{
-#ifdef ALLOCATESTRING
- if (pool_ptr + val > current_pool_size)
- str_pool = realloc_str_pool(increment_pool_size);
+ if (interaction == error_stop_mode)
+ interaction = scroll_mode;
- if (pool_ptr + val > current_pool_size)
- overflow("pool size", current_pool_size - init_pool_ptr);
-#else
- if (pool_ptr + val > pool_size)
- overflow("pool size", pool_size - init_pool_ptr);
+ if (log_opened)
+ {
+ error();
+ }
+
+#ifdef DEBUG
+ if (interaction > 0)
+ debug_help();
#endif
+
+ history = error_stop_mode;
+ jump_out();
}
+/* sec 0214 */
inline void tail_append_ (pointer val)
{
link(tail) = val;
tail = link(tail);
+}
+/* sec 0321 */
+inline void push_input(void)
+{
+ if (input_ptr > max_in_stack)
+ {
+ max_in_stack = input_ptr;
+
+#ifdef ALLOCATEINPUTSTACK
+ if (input_ptr == current_stack_size)
+ input_stack = realloc_input_stack(increment_stack_size);
+
+ if (input_ptr == current_stack_size)
+ {
+ overflow("input stack size", current_stack_size);
+ return;
+ }
+#else
+ if (input_ptr == stack_size)
+ {
+ overflow("input stack size", stack_size);
+ return;
+ }
+#endif
+ }
+
+ input_stack[input_ptr] = cur_input;
+ incr(input_ptr);
+}
+/* sec 0322 */
+inline void pop_input(void)
+{
+ decr(input_ptr);
+ cur_input = input_stack[input_ptr];
+}
+/* sec 0532 */
+inline void ensure_dvi_open(void)
+{
+ if (output_file_name == 0)
+ {
+ if (job_name == 0)
+ open_log_file();
+
+ pack_job_name(".dvi");
+
+ while (!b_open_out(dvi_file))
+ {
+ prompt_file_name("file name for output", ".dvi");
+ }
+
+ output_file_name = b_make_name_string(dvi_file);
+ }
+}
+/* sec 0598 */
+inline void dvi_out_(ASCII_code op)
+{
+ dvi_buf[dvi_ptr] = op;
+ incr(dvi_ptr);
+
+ if (dvi_ptr == dvi_limit)
+ dvi_swap();
+}
+/* sec 0616 */
+inline void synch_h(void)
+{
+ if (cur_h != dvi_h)
+ {
+ movement(cur_h - dvi_h, right1);
+ dvi_h = cur_h;
+ }
+}
+/* sec 0616 */
+inline void synch_v(void)
+{
+ if (cur_v != dvi_v)
+ {
+ movement(cur_v - dvi_v, down1);
+ dvi_v = cur_v;
+ }
}
\ No newline at end of file
#define rule_node 2
#define rule_node_size 4
#define null_flag -010000000000L
-#define is_running(a) (a = null_flag)
+#define is_running(a) (a == null_flag)
/* sec 0140 */
#define ins_node 3
#define ins_node_size 5
#define extra_space(f) param(extra_space_code, f)
/* sec 0564 */
#define read_sixteen(a) \
+do \
{ \
a = tfm_temp; \
if (a > 127) \
- goto lab11; \
+ goto bad_tfm; \
tfm_temp = getc(tfm_file); \
a = a * 256 + tfm_temp; \
- }
+ } \
+while (0)
#define store_four_quarters(val) \
+do \
{ \
tfm_temp = getc(tfm_file); \
a = tfm_temp; \
d = tfm_temp; \
qw.b3 = d; \
val = qw; \
- }
+ } \
+while (0)
/* sec 0571 */
/* sec 0585 */
#define set1 128 // c[1]
#define none_seen 0
#define y_seen 6
#define z_seen 12
+/* sec 0625 */
+#define billion 1000000000.0
+#define vet_glue(a) \
+do \
+{ \
+ glue_temp = a; \
+ if (glue_temp > billion) \
+ glue_temp = billion; \
+ else if (glue_temp < -billion)\
+ glue_temp = -billion; \
+} \
+while (0)
/* sec 0644 */
#define exactly 0
#define additional 1
#define next_break prev_break
/* sec 0908 */
#define append_charnode_to_t(a) \
+do \
{ \
link(t) = get_avail(); \
t = link(t); \
font(t) = hf; \
character(t) = (a); \
- }
+ } \
+while (0)
#define set_cur_r() \
+do \
{ \
if (j < n) \
cur_r = hu[j + 1]; \
cur_rh = hchar; \
else \
cur_rh = non_char; \
- }
+ } \
+while (0)
/* sec 0910 */
#define wrap_lig(a) \
+do \
+{ \
if (ligature_present) \
{ \
p = new_ligature(hf, cur_l, link(cur_q)); \
link(cur_q) = p; \
t = p; \
ligature_present = false; \
- }
+ } \
+} \
+while (0)
#define pop_lig_stack() \
+do \
{ \
if (lig_ptr(lig_stack) != 0) \
{ \
} \
else \
cur_r = character(lig_stack); \
- }
+ } \
+while (0)
/* sec 0914 */
#define advance_major_tail() \
+do \
{ \
major_tail = link(major_tail); \
incr(r_count); \
- }
+ } \
+while (0)
/* sec 0970 */
#define active_height active_width
#define cur_height active_height[1]
#define set_page_so_far_zero(a) page_so_far[(a)] = 0
/* sec 1034 */
#define adjust_space_factor() \
+do \
{ \
main_s = sf_code(cur_chr); \
if (main_s == 1000) \
space_factor = 1000; \
else \
space_factor = main_s; \
-}
+} \
+while (0)
/* sec 1035 */
/* -> false */
#define wrapup(a) \
+do \
{ \
if (cur_l < non_char) \
{ \
} \
} \
} \
-}
+} \
+while (0)
/* sec 1045 */
#define any_mode(a) vmode + a: case hmode + a: case mmode + a
/* sec 1046 */
undump_int(x); \
\
if ((x < (va)) || (x > (vb))) \
- goto lab_bad_fmt; \
+ goto bad_fmt; \
else \
vc = x; \
} \
OSDN Git Service
