scaled_whd scan_alt_rule(void)
{
boolean loop;
scaled_whd alt_rule;
alt_rule.wd = null_flag;
alt_rule.ht = null_flag;
alt_rule.dp = null_flag;
do {
loop = false;
if (scan_keyword("width")) {
scan_normal_dimen();
alt_rule.wd = cur_val;
loop = true;
} else if (scan_keyword("height")) {
scan_normal_dimen();
alt_rule.ht = cur_val;
loop = true;
} else if (scan_keyword("depth")) {
scan_normal_dimen();
alt_rule.dp = cur_val;
loop = true;
}
} while (loop);
return alt_rule;
}
void tex::math_fraction ()
{
int c;
mcell garbage;
c = cur_chr;
if (incompleat_noad != null) {
if (c >= DELIMITED_CODE) {
scan_delimiter((ptr)&garbage, FALSE);
scan_delimiter((ptr)&garbage, FALSE);
}
if (c % DELIMITED_CODE == ABOVE_CODE)
scan_normal_dimen();
print_err("Ambiguous; you need another { and }");
help_fraction();
error();
} else {
incompleat_noad = new_node(FRACTION_NOAD_SIZE);
type(incompleat_noad) = FRACTION_NOAD;
subtype(incompleat_noad) = NORMAL;
math_type(numerator(incompleat_noad)) = SUB_MLIST;
math_link(numerator(incompleat_noad)) = link(head);
mzero(denominator(incompleat_noad));
mzero(left_delimiter(incompleat_noad));
mzero(right_delimiter(incompleat_noad));
link(head) = null;
tail = head;
if (c >= DELIMITED_CODE) {
scan_delimiter(left_delimiter(incompleat_noad), FALSE);
scan_delimiter(right_delimiter(incompleat_noad), FALSE);
}
switch (c % DELIMITED_CODE)
{
case ABOVE_CODE:
scan_normal_dimen();
thickness(incompleat_noad) = cur_val;
break;
case OVER_CODE:
thickness(incompleat_noad) = DEFAULT_CODE;
break;
case ATOP_CODE:
thickness(incompleat_noad) = 0;
break;
}
}
}
void tex::conditional ()
{
bool b=false;
sym s;
int m, n;
ptr p, q, r;
int this_if;
ptr save_cond_ptr;
int save_scanner_status;
push_cond();
save_cond_ptr = cond_ptr;
this_if = cur_chr;
switch (this_if) {
case IF_CHAR_CODE:
case IF_CAT_CODE:
#define get_x_token_or_active_char() {get_x_token(); \
if (cur_cmd == RELAX && cur_chr == NO_EXPAND_FLAG) { \
cur_cmd = ACTIVE_CHAR; \
cur_chr = tok2sym(cur_tok) - active_base[0]; }}
get_x_token_or_active_char();
if (cur_cmd > ACTIVE_CHAR || cur_chr > 255) {
m = RELAX;
n = 256;
}
else {
m = cur_cmd;
n = cur_chr;
}
get_x_token_or_active_char();
if (cur_cmd > ACTIVE_CHAR || cur_chr > 255) {
cur_cmd = RELAX;
cur_chr = 256;
}
if (this_if == IF_CHAR_CODE) {
b = n == cur_chr;
} else {
b = m == cur_cmd;
}
break;
case IF_INT_CODE:
case IF_DIM_CODE:
if (this_if == IF_INT_CODE) {
scan_int();
} else {
scan_normal_dimen();
}
n = cur_val;
get_nbx_token();
if (cur_tok >= OTHER_TOKEN + '<'
&& cur_tok <= OTHER_TOKEN + '>') {
r = cur_tok - OTHER_TOKEN;
} else {
print_err("Missing = inserted for ");
print_cmd_chr(IF_TEST, this_if);
help_relation();
back_error();
r = '=';
}
if (this_if == IF_INT_CODE) {
scan_int();
} else {
scan_normal_dimen();
}
switch (r) {
case '<': b = n < cur_val; break;
case '=': b = n == cur_val; break;
case '>': b = n > cur_val; break;
}
break;
case IF_ODD_CODE:
scan_int();
b = odd(cur_val);
break;
case IF_VMODE_CODE:
b = abs(mode) == VMODE;
break;
case IF_HMODE_CODE:
b = abs(mode) == HMODE;
break;
case IF_MMODE_CODE:
b = abs(mode) == MMODE;
break;
case IF_INNER_CODE:
b = mode < 0;
break;
case IF_VOID_CODE:
case IF_HBOX_CODE:
case IF_VBOX_CODE:
scan_eight_bit_int();
p = box(cur_val);
if (this_if == IF_VOID_CODE) {
b = p == null;
} else if (p == null) {
b = FALSE;
} else if (this_if == IF_HBOX_CODE) {
b = type(p) == HLIST_NODE;
} else {
b = type(p) == VLIST_NODE;
}
break;
case IFX_CODE:
save_scanner_status = scanner_status;
scanner_status = NORMAL;
get_next();
s = cur_cs;
p = cur_cmd;
q = cur_chr;
get_next();
if (cur_cmd != p) {
b = FALSE;
} else if (cur_cmd < CALL) {
b = cur_chr == q;
} else {
p = token_link(cur_chr);
q = token_link(equiv(s));
if (p == q) {
b = TRUE;
} else {
while (p != null && q != null) {
if (token(p) != token(q)) {
p = null;
} else {
p = token_link(p);
q = token_link(q);
}
}
b = p == null && q == null;
}
}
scanner_status = save_scanner_status;
break;
case IF_EOF_CODE:
scan_four_bit_int();
b = read_open[cur_val] == CLOSED;
break;
case IF_TRUE_CODE:
b = TRUE;
break;
case IF_FALSE_CODE:
b = FALSE;
break;
case IF_CASE_CODE:
scan_int();
n = cur_val;
if (tracing_commands > 1) {
begin_diagnostic();
print("{case ");
print_int(n);
print("}");
end_diagnostic(FALSE);
}
while (n != 0) {
pass_text();
if (cond_ptr == save_cond_ptr) {
if (cur_chr == OR_CODE) {
decr(n);
} else {
goto common_end;
}
} else if (cur_chr == FI_CODE) {
pop_cond();
}
}
change_if_limit(OR_CODE, save_cond_ptr);
return;
default:
break;
}
if (tracing_commands > 1) {
begin_diagnostic();
print(b ? "{true}" : "{false}");
end_diagnostic(FALSE);
}
if (b) {
change_if_limit(ELSE_CODE, save_cond_ptr);
return;
}
loop {
pass_text();
if (cond_ptr == save_cond_ptr) {
if (cur_chr != OR_CODE)
goto common_end;
print_err("Extra ");
print_esc("or");
help_or();
error();
} else if (cur_chr == FI_CODE) {
pop_cond();
}
}
common_end:
if (cur_chr == FI_CODE) {
pop_cond();
} else {
if_limit = FI_CODE;
}
}
void tex::begin_box(int box_context)
{
int k, m, n;
ptr p=0, q;
switch (cur_chr)
{
case BOX_CODE:
scan_eight_bit_int();
cur_box = box(cur_val);
box(cur_val) = null;
break;
case COPY_CODE:
scan_eight_bit_int();
cur_box = copy_node_list(box(cur_val));
break;
case LAST_BOX_CODE:
cur_box = null;
if (abs(mode) == MMODE) {
you_cant();
help_lastbox_m();
error();
} else if (mode == VMODE && head == tail) {
you_cant();
help_lastbox_v();
error();
} else if (type(tail) == HLIST_NODE
|| type(tail) == VLIST_NODE) {
for (q = head; q != tail; q = link(p)) {
p = q;
if (type(q) == DISC_NODE) {
m = 1;
while (m <= replace_count(q)) {
p = link(p);
incr(m);
}
if (p == tail) {
break;
}
}
}
cur_box = tail;
shift_amount(cur_box) = 0;
tail = p;
link(p) = null;
}
break;
case VSPLIT_CODE:
scan_eight_bit_int();
n = cur_val;
if (!scan_keyword("to")) {
print_err("Missing `to' inserted");
help_vsplit();
error();
}
scan_normal_dimen();
cur_box = vsplit(n, cur_val);
break;
default:
k = cur_chr - VTOP_CODE;
saved(0) = box_context;
if (k == HMODE) {
if (box_context < BOX_FLAG && abs(mode) == VMODE) {
scan_spec(ADJUSTED_HBOX_GROUP, TRUE);
} else {
scan_spec(HBOX_GROUP, TRUE);
}
} else {
if (k == VMODE) {
scan_spec(VBOX_GROUP, TRUE);
} else {
scan_spec(VTOP_GROUP, TRUE);
k = VMODE;
}
normal_paragraph();
}
push_nest();
mode = -k;
if (k == VMODE) {
prev_depth = IGNORE_DEPTH;
if (every_vbox != null)
begin_token_list(every_vbox, EVERY_VBOX_TEXT);
} else {
space_factor = 1000;
if (every_hbox != null)
begin_token_list(every_hbox, EVERY_HBOX_TEXT);
}
return;
}
box_end(box_context);
}
void tex::main_control()
{
if (every_job != null)
begin_token_list(every_job, EVERY_JOB_TEXT);
big_switch:
get_x_token();
reswitch:
if (tracing_commands > 0)
show_cur_cmd_chr();
switch(abs(mode) + cur_cmd) {
hmode(LETTER):
hmode(OTHER_CHAR):
hmode(CHAR_GIVEN):
goto main_loop;
hmode(CHAR_NUM):
scan_char_num();
cur_chr = cur_val;
goto main_loop;
hmode(NO_BOUNDARY):
get_x_token();
if (cur_cmd == LETTER || cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN || cur_cmd == CHAR_NUM) {
cancel_boundary = TRUE;
}
goto reswitch;
hmode(SPACER):
if (space_factor == 1000) {
goto append_normal_space;
}
else {
app_space();
}
break;
hmode(EX_SPACE):
mmode(EX_SPACE):
goto append_normal_space;
any_mode(RELAX):
vmode(SPACER):
mmode(SPACER):
mmode(NO_BOUNDARY):
break;
any_mode(IGNORE_SPACES):
get_nbx_token();
goto reswitch;
vmode(STOP):
if (its_all_over())
return;
break;
any_mode(LAST_ITEM):
any_mode(MAC_PARAM):
non_math(EQ_NO):
vmode(VMOVE):
hmode(HMOVE):
mmode(HMOVE):
vmode(VADJUST):
vmode(ITAL_CORR):
report_illegal_case();
break;
non_math(SUP_MARK):
non_math(SUB_MARK):
non_math(MATH_CHAR_NUM):
non_math(MATH_GIVEN):
non_math(MATH_COMP):
non_math(DELIM_NUM):
non_math(LEFT_RIGHT):
non_math(ABOVE):
non_math(RADICAL):
non_math(MATH_STYLE):
non_math(MATH_CHOICE):
non_math(VCENTER):
non_math(NON_SCRIPT):
non_math(MKERN):
non_math(LIMIT_SWITCH):
non_math(MSKIP):
non_math(MATH_ACCENT):
mmode(ENDV):
mmode(PAR_END):
mmode(STOP):
mmode(VSKIP):
mmode(UN_VBOX):
mmode(VALIGN):
mmode(HRULE):
insert_dollar_sign();
break;
vmode(HRULE):
hmode(VRULE):
mmode(VRULE):
tail_append(scan_rule_spec());
if (abs(mode) == VMODE)
prev_depth = IGNORE_DEPTH;
else if (abs(mode) == HMODE)
space_factor = 1000;
break;
vmode(VSKIP):
hmode(HSKIP):
mmode(HSKIP):
mmode(MSKIP):
append_glue();
break;
any_mode(KERN):
mmode(MKERN):
append_kern();
break;
non_math(LEFT_BRACE):
new_save_level(SIMPLE_GROUP);
break;
any_mode(BEGIN_GROUP):
new_save_level(SEMI_SIMPLE_GROUP);
break;
any_mode(END_GROUP):
if (cur_group == SEMI_SIMPLE_GROUP) {
unsave();
} else {
off_save();
}
break;
any_mode(RIGHT_BRACE):
handle_right_brace();
break;
vmode(HMOVE):
hmode(VMOVE):
mmode(VMOVE): {
int t;
t = cur_chr;
scan_normal_dimen();
if (t == 0) {
scan_box(cur_val);
} else {
scan_box(-cur_val);
}
break;
}
any_mode(LEADER_SHIP):
scan_box(LEADER_FLAG + cur_chr - A_LEADERS);
break;
any_mode(MAKE_BOX):
begin_box(0);
break;
vmode(START_PAR):
new_graf(cur_chr > 0);
break;
vmode(LETTER):
vmode(OTHER_CHAR):
vmode(CHAR_NUM):
vmode(CHAR_GIVEN):
vmode(MATH_SHIFT):
vmode(UN_HBOX):
vmode(VRULE):
vmode(ACCENT):
vmode(DISCRETIONARY):
vmode(HSKIP):
vmode(VALIGN):
vmode(EX_SPACE):
vmode(NO_BOUNDARY):
back_input();
new_graf(TRUE);
break;
hmode(START_PAR):
mmode(START_PAR):
indent_in_hmode();
break;
vmode(PAR_END):
normal_paragraph();
if (mode > 0)
build_page();
break;
hmode(PAR_END):
if (align_state < 0)
off_save();
end_graf();
if (mode == VMODE)
build_page();
break;
hmode(STOP):
hmode(VSKIP):
hmode(HRULE):
hmode(UN_VBOX):
hmode(HALIGN):
head_for_vmode();
break;
any_mode(INSERT):
hmode(VADJUST):
mmode(VADJUST):
begin_insert_or_adjust();
break;
any_mode(MARK):
make_mark();
break;
any_mode(BREAK_PENALTY):
append_penalty();
break;
any_mode(REMOVE_ITEM):
delete_last();
break;
vmode(UN_VBOX):
hmode(UN_HBOX):
mmode(UN_HBOX):
unpackage();
break;
hmode(ITAL_CORR):
append_italic_correction();
break;
mmode(ITAL_CORR):
tail_append(new_kern(0));
break;
hmode(DISCRETIONARY):
mmode(DISCRETIONARY):
append_discretionary();
break;
hmode(ACCENT):
make_accent();
break;
any_mode(CAR_RET):
any_mode(TAB_MARK):
align_error();
break;
any_mode(NO_ALIGN):
no_align_error();
break;
any_mode(OMIT):
omit_error();
break;
vmode(HALIGN):
hmode(VALIGN):
init_align();
break;
mmode(HALIGN):
if (privileged()) {
if (cur_group == MATH_SHIFT_GROUP) {
init_align();
} else {
off_save();
}
}
break;
vmode(ENDV):
hmode(ENDV):
do_endv();
break;
any_mode(END_CS_NAME):
cs_error();
break;
hmode(MATH_SHIFT):
init_math();
break;
mmode(EQ_NO):
if (privileged()) {
if (cur_group == MATH_SHIFT_GROUP) {
start_eq_no();
} else {
off_save();
}
}
break;
mmode(LEFT_BRACE):
tail_append(new_noad());
back_input();
scan_math(nucleus(tail));
break;
mmode(LETTER):
mmode(OTHER_CHAR):
mmode(CHAR_GIVEN):
if (cur_chr < 256)
set_math_char(math_code(cur_chr));
else set_math_char(cur_chr);
break;
mmode(CHAR_NUM):
scan_char_num();
cur_chr = cur_val;
if (cur_chr < 256)
set_math_char(math_code(cur_chr));
else set_math_char(cur_chr);
break;
mmode(MATH_CHAR_NUM):
scan_fifteen_bit_int();
set_math_char(cur_val);
break;
mmode(MATH_GIVEN):
set_math_char(cur_chr);
break;
mmode(DELIM_NUM):
scan_twenty_seven_bit_int();
set_math_char(cur_val / 010000);
break;
mmode(MATH_COMP):
tail_append(new_noad());
type(tail) = cur_chr;
scan_math(nucleus(tail));
break;
mmode(LIMIT_SWITCH):
math_limit_switch();
break;
mmode(RADICAL):
math_radical();
break;
mmode(ACCENT):
mmode(MATH_ACCENT):
math_ac();
break;
mmode(VCENTER):
scan_spec(VCENTER_GROUP, FALSE);
normal_paragraph();
push_nest();
mode = -VMODE;
prev_depth = IGNORE_DEPTH;
if (every_vbox != null)
begin_token_list(every_vbox, EVERY_VBOX_TEXT);
break;
mmode(MATH_STYLE):
tail_append(new_style(cur_chr));
break;
mmode(NON_SCRIPT):
tail_append(new_glue(zero_glue));
subtype(tail) = COND_MATH_GLUE;
break;
mmode(MATH_CHOICE):
append_choices();
break;
mmode(SUB_MARK):
mmode(SUP_MARK):
sub_sup();
break;
mmode(ABOVE):
math_fraction();
break;
mmode(LEFT_RIGHT):
math_left_right();
break;
mmode(MATH_SHIFT):
if (cur_group == MATH_SHIFT_GROUP) {
after_math();
} else {
off_save();
}
break;
any_mode(AFTER_ASSIGNMENT):
get_token();
after_token = cur_tok;
break;
any_mode(AFTER_GROUP):
get_token();
save_for_after(cur_tok);
break;
any_mode(IN_STREAM):
clopen_stream();
break;
any_mode(MESSAGE):
issue_message();
break;
any_mode(CASE_SHIFT):
shift_case();
break;
any_mode(XRAY):
show_whatever();
break;
any_mode(EXTENSION):
do_extension();
break;
default:
prefixed_command();
break;
}
goto big_switch;
#define adjust_space_factor() \
{ \
main_s = sf_code(cur_chr); \
if (main_s == 1000) { \
space_factor = 1000; \
} else if (main_s < 1000) { \
if (main_s > 0) { \
space_factor = main_s; \
} \
} else if (space_factor < 1000) { \
space_factor = 1000; \
} else { \
space_factor = main_s; \
} \
}
main_loop:
adjust_space_factor();
main_f = cur_font;
bchar = font_bchar(main_f);
false_bchar = font_false_bchar(main_f);
if (mode > 0 && language != clang)
fix_language();
fast_new_avail(lig_stack);
font(lig_stack) = main_f;
character(lig_stack) = cur_l = cur_chr;
cur_q = tail;
if (cancel_boundary) {
cancel_boundary = FALSE;
main_k = NON_ADDRESS;
} else {
main_k = bchar_label(main_f);
}
if (main_k == NON_ADDRESS)
goto main_loop_move_2;
cur_r = cur_l;
cur_l = NON_CHAR;
goto main_lig_loop_1;
#define pack_lig(RT_HIT) \
{ \
main_p = new_ligature(main_f, cur_l, link(cur_q)); \
if (lft_hit) { \
subtype(main_p) = 2; \
lft_hit = FALSE; \
} \
if (RT_HIT && lig_stack == null) { \
incr(subtype(main_p)); \
rt_hit = FALSE; \
} \
tail = link(cur_q) = main_p; \
ligature_present = FALSE; \
}
#define wrapup(RT_HIT) \
{ \
if (cur_l < NON_CHAR) { \
if (character(tail) == hyphen_char(main_f) \
&& link(cur_q) != null) \
ins_disc = TRUE; \
if (ligature_present) \
pack_lig(RT_HIT); \
if (ins_disc) { \
ins_disc = FALSE; \
if (mode > 0) \
tail_append(new_disc()); \
} \
} \
}
main_loop_wrapup:
wrapup(rt_hit);
main_loop_move:
if (lig_stack == null)
goto reswitch;
cur_q = tail;
cur_l = cur_r;
main_loop_move_1:
if (!is_char_node(lig_stack))
goto main_loop_move_lig;
main_loop_move_2:
if (cur_chr < font_bc(main_f) || cur_chr > font_ec(main_f)) {
char_warning(main_f, cur_chr);
free_avail(lig_stack);
goto big_switch;
}
main_i = char_info(main_f, cur_l);
if (!char_exists(main_i)) {
char_warning(main_f, cur_chr);
free_avail(lig_stack);
goto big_switch;
}
tail_append(lig_stack);
main_loop_lookahead:
get_next();
if (cur_cmd == LETTER
|| cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN) {
goto main_loop_lookahead_1;
}
x_token();
if (cur_cmd == LETTER
|| cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN) {
goto main_loop_lookahead_1;
}
if (cur_cmd == CHAR_NUM) {
scan_char_num();
cur_chr = cur_val;
goto main_loop_lookahead_1;
}
if (cur_cmd == NO_BOUNDARY) {
bchar = NON_CHAR;
}
cur_r = bchar;
lig_stack = null;
goto main_lig_loop;
main_loop_lookahead_1:
adjust_space_factor();
fast_new_avail(lig_stack);
font(lig_stack) = main_f;
character(lig_stack) = cur_r = cur_chr;
if (cur_r == false_bchar) {
cur_r = NON_CHAR;
}
main_lig_loop:
if (char_tag(main_i) != LIG_TAG) {
goto main_loop_wrapup;
}
main_k = lig_kern_start(main_f, main_i);
main_j = *main_k;
if (skip_byte(main_j) <= STOP_FLAG) {
goto main_lig_loop_2;
}
main_k = lig_kern_restart(main_f, main_j);
main_lig_loop_1:
main_j = *main_k;
main_lig_loop_2:
if (next_char(main_j) == cur_r
&& skip_byte(main_j) <= STOP_FLAG) {
if (op_byte(main_j) >= KERN_FLAG) {
wrapup(rt_hit);
tail_append(new_kern(char_kern(main_f, main_j)));
goto main_loop_move;
}
if (cur_l == NON_CHAR) {
lft_hit = TRUE;
} else if (lig_stack == null) {
rt_hit = TRUE;
}
if(interrupted) throw std::logic_error("interrupted");
switch (op_byte(main_j))
{
case 1: case 5:
cur_l = rem_byte(main_j);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
break;
case 2: case 6:
cur_r = rem_byte(main_j);
if (lig_stack == null) {
lig_stack = new_lig_item(cur_r);
bchar = NON_CHAR;
} else if (is_char_node(lig_stack)) {
main_p = lig_stack;
lig_stack = new_lig_item(cur_r);
lig_ptr(lig_stack) = main_p;
} else {
character(lig_stack) = cur_r;
}
break;
case 3:
cur_r = rem_byte(main_j);
main_p = lig_stack;
lig_stack = new_lig_item(cur_r);
link(lig_stack) = main_p;
break;
case 7: case 11:
wrapup(FALSE);
cur_q = tail;
cur_l = rem_byte(main_j);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
break;
default:
cur_l = rem_byte(main_j);
ligature_present = TRUE;
if (lig_stack == null) {
goto main_loop_wrapup;
} else {
goto main_loop_move_1;
}
break;
}
if (op_byte(main_j) > 4 && op_byte(main_j) != 7)
goto main_loop_wrapup;
if (cur_l < NON_CHAR)
goto main_lig_loop;
main_k = bchar_label(main_f);
goto main_lig_loop_1;
}
if (skip_byte(main_j) == 0) {
incr(main_k);
} else {
if (skip_byte(main_j) >= STOP_FLAG)
goto main_loop_wrapup;
main_k += skip_byte(main_j) + 1;
}
goto main_lig_loop_1;
main_loop_move_lig:
main_p = lig_ptr(lig_stack);
if (main_p != null) {
tail_append(main_p);
}
main_t = lig_stack;
lig_stack = link(main_t);
free_node(main_t, SMALL_NODE_SIZE);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
if (lig_stack == null) {
if (main_p != null) {
goto main_loop_lookahead;
} else {
cur_r = bchar;
}
} else {
cur_r = character(lig_stack);
}
goto main_lig_loop;
append_normal_space:
if (space_skip == zero_glue) {
main_p = font_glue(cur_font);
if (main_p == null)
main_p = find_font_glue(cur_font);
main_t = new_glue(main_p);
} else {
main_t = new_param_glue(SPACE_SKIP_CODE);
}
tail_append(main_t);
goto big_switch;
}
