void FBSession::logout() {
if (iSessionKey.length())
{
emit sessionWillLogout(iUid);
// no need to remove cookies, they will be removed once the app quits.
// point to think about, what if user wants to log in again ??
// hmm..
// TODO: ^^
iExpirationDate = QDateTime();
iSessionKey.clear();
iSessionSecret.clear();
iUid = 0;
unsave();
emit sessionDidLogout();
}
else
{
unsave();
}
}
void tex::math_left_right ()
{
ptr p;
int t;
mcell garbage;
t = cur_chr;
if (t == RIGHT_NOAD && cur_group != MATH_LEFT_GROUP) {
if (cur_group == MATH_SHIFT_GROUP) {
scan_delimiter((ptr)&garbage, FALSE);
print_err("Extra ");
print_esc("right");
help_xtra_right();
error();
} else {
off_save();
}
} else {
p = new_noad();
type(p) = t;
scan_delimiter(delimiter(p), FALSE);
if (t == LEFT_NOAD) {
push_math(MATH_LEFT_GROUP);
tail = link(head) = p;
} else {
p = fin_mlist(p);
unsave();
tail_append(new_noad());
type(tail) = INNER_NOAD;
math_type(nucleus(tail)) = SUB_MLIST;
math_link(nucleus(tail)) = p;
}
}
}
void tex::package(int c)
{
scal d;
scal h;
ptr p;
d = box_max_depth;
unsave();
save_ptr -= 3;
if (mode == -HMODE) {
cur_box = hpack(link(head), saved(2), saved(1));
} else {
cur_box = vpackage(link(head), saved(2), saved(1), d);
if (c == VTOP_CODE) {
h = 0;
p = list_ptr(cur_box);
if (p != null && type(p) <= RULE_NODE)
h = box_height(p);
box_depth(cur_box) += box_height(cur_box) - h;
box_height(cur_box) = h;
}
}
pop_nest();
box_end(saved(0));
}
cell pp_curs_getyx(cell x) {
int cx, cy;
cell n;
if (!Running) return UNSPECIFIC;
getyx(stdscr, cy, cx);
n = make_integer(cx);
n = cons(n, NIL);
save(n);
n = cons(make_integer(cy), n);
unsave(1);
return n;
}
/*-------Environment-------*/
pointer environment_make2(VM, pointer rib, pointer env) {
pointer t;
save(vm, rib);
save(vm, env);
t = table_alloc(vm);
while (!AR_ISNIL(rib)) {
table_insert(vm, t, caar(rib), cdar(rib));
rib = cdr(rib);
}
unsave(vm, 2);
return tagged_alloc(vm, vm->s_environment, cons(t,AR_ISNIL(env)?vm->nil:rep(env)));
}
void tex::resume_after_display ()
{
if (cur_group != MATH_SHIFT_GROUP)
confusion("display");
unsave();
prev_graf += 3;
push_nest();
mode = HMODE;
space_factor = 1000;
clang = 0;
scan_optional_space();
if (nest_ptr == nest + 1)
build_page();
}
void tex::build_choices ()
{
ptr p;
unsave();
p = fin_mlist(null);
switch (saved(-1)) {
case 0: display_mlist(tail) = p; break;
case 1: text_mlist(tail) = p; break;
case 2: script_mlist(tail) = p; break;
case 3: script_script_mlist(tail) = p; decr(save_ptr); return;
}
incr(saved(-1));
scan_left_brace();
push_math(MATH_CHOICE_GROUP);
}
void tex::build_discretionary ()
{
int n;
ptr p, q;
unsave();
q = head;
p = link(q);
n = 0;
while (p != null) {
if (!is_char_node(p)
&& type(p) > RULE_NODE
&& type(p) != KERN_NODE
&& type(p) != LIGATURE_NODE) {
print_err("Improper discretionary list");
help_discretionary();
error();
flush_discretionary(p);
link(q) = null;
break;
}
q = p;
p = link(q);
incr(n);
}
p = link(head);
pop_nest();
switch (saved(-1))
{
case 0:
pre_break(tail) = p;
break;
case 1:
post_break(tail) = p;
break;
case 2:
if (n > 0 && abs(mode) == MMODE) {
print_err("Illegal math ");
print_esc("discretionary");
help_math_disc();
flush_node_list(p);
n = 0;
error();
} else {
link(tail) = p;
}
if (n <= MAX_QUARTERWORD) {
replace_count(tail) = n;
} else {
print_err("Discretionary list is too long");
help_disc();
error();
}
if (n > 0)
tail = q;
decr(save_ptr);
return;
}
incr(saved(-1));
scan_left_brace();
new_save_level(DISC_GROUP);
push_nest();
mode = -HMODE;
space_factor = 1000;
}
void tex::handle_right_brace ()
{
scal d;
int f;
ptr p;
ptr q;
switch (cur_group)
{
case SIMPLE_GROUP:
unsave();
break;
case BOTTOM_LEVEL:
print_err("Too many }'s");
help_close_group();
error();
break;
case SEMI_SIMPLE_GROUP:
case MATH_SHIFT_GROUP:
case MATH_LEFT_GROUP:
extra_right_brace();
break;
case HBOX_GROUP:
package(0);
break;
case ADJUSTED_HBOX_GROUP:
tex::adjust_tail = tex::adjust_head;
package(0);
break;
case VBOX_GROUP:
end_graf();
package(0);
break;
case VTOP_GROUP:
end_graf();
package(VTOP_CODE);
break;
case INSERT_GROUP:
end_graf();
q = split_top_skip;
add_glue_ref(q);
d = split_max_depth;
f = floating_penalty;
unsave();
decr(save_ptr);
p = vpack(link(head), 0, ADDITIONAL);
pop_nest();
if (saved(0) < 255) {
tail_append(new_node(INS_NODE_SIZE));
type(tail) = INS_NODE;
subtype(tail) = saved(0);
ins_height(tail) = box_height(p) + box_depth(p);
ins_ptr(tail) = list_ptr(p);
split_top_ptr(tail) = q;
ins_depth(tail) = d;
float_cost(tail) = f;
} else {
tail_append(new_node(SMALL_NODE_SIZE));
type(tail) = ADJUST_NODE;
subtype(tail) = 0;
adjust_ptr(tail) = list_ptr(p);
delete_glue_ref(q);
}
free_node(p, BOX_NODE_SIZE);
if (nest_ptr == nest)
build_page();
break;
case OUTPUT_GROUP:
if (loc != null
|| (token_type != OUTPUT_TEXT && token_type != BACKED_UP)) {
print_err("Unbalanced output routine");
help_output_balance();
error();
do get_token();
while (loc != null);
}
end_token_list();
end_graf();
unsave();
output_active = FALSE;
insert_penalties = 0;
if (box(255) != null) {
print_err("Output routine didn't use all of ");
print_esc("box255");
help_output();
box_error(255);
}
if (tail != head) {
link(page_tail) = link(head);
page_tail = tail;
}
if (link(page_head) != null) {
if (link(contrib_head) == null)
contrib_tail = page_tail;
link(page_tail) = link(contrib_head);
link(contrib_head) = link(page_head);
link(page_head) = null;
page_tail = page_head;
}
pop_nest();
build_page();
break;
case DISC_GROUP:
build_discretionary();
break;
case ALIGN_GROUP:
back_input();
cur_tok = sym2tok(FROZEN_CR);
print_err("Missing ");
print_esc("cr");
print(" inserted");
help_align_cr();
ins_error();
break;
case NO_ALIGN_GROUP:
end_graf();
unsave();
align_peek();
break;
case VCENTER_GROUP:
end_graf();
unsave();
save_ptr -= 2;
p = vpackage(link(head), saved(1), saved(0), MAX_DIMEN);
pop_nest();
tail_append(new_noad());
type(tail) = VCENTER_NOAD;
math_type(nucleus(tail)) = SUB_BOX;
info(nucleus(tail)) = p;
break;
case MATH_CHOICE_GROUP:
build_choices();
break;
case MATH_GROUP:
unsave();
decr(save_ptr);
math_type(saved(0)) = SUB_MLIST;
p = fin_mlist(null);
math_link(saved(0)) = p;
if (p != null) {
if (link(p) == null) {
if (type(p) == ORD_NOAD) {
if (math_type(subscr(p)) == EMPTY
&& math_type(supscr(p)) == EMPTY) {
mcopy(saved(0), nucleus(p));
free_node(p, NOAD_SIZE);
}
} else if (type(p) == ACCENT_NOAD
&& saved(0) == nucleus(tail)
&& type(tail) == ORD_NOAD) {
q = head;
while (link(q) != tail)
q = link(q);
link(q) = p;
free_node(tail, NOAD_SIZE);
tail = p;
}
}
}
break;
default:
confusion("rightbrace");
break;
}
}
void tex::after_math ()
{
ptr a;
ptr b;
scal d;
scal e;
bool l;
int m;
ptr p;
scal q;
ptr r;
scal s;
scal t;
scal w;
scal z;
int g1;
int g2;
bool danger;
danger = check_font_params();
m = mode;
l = FALSE;
p = fin_mlist(null);
if (mode == -m) {
check_dollar();
a = hpack(mlist_to_hlist(p, TEXT_STYLE, FALSE), 0, ADDITIONAL);
unsave();
decr(save_ptr);
if (saved(0) == 1)
l = TRUE;
danger = check_font_params();
m = mode;
p = fin_mlist(null);
} else {
a = null;
}
if (m < 0) {
tail_append(new_math(math_surround, BEFORE));
link(tail) = mlist_to_hlist(p, TEXT_STYLE, mode > 0);
while (link(tail) != null)
tail = link(tail);
tail_append(new_math(math_surround, AFTER));
space_factor = 1000;
unsave();
} else {
if (a == null)
check_dollar();
p = mlist_to_hlist(p, DISPLAY_STYLE, FALSE);
tex::adjust_tail = tex::adjust_head;
b = hpack(p, 0, ADDITIONAL);
p = list_ptr(b);
t = tex::adjust_tail;
tex::adjust_tail = null;
w = box_width(b);
z = display_width;
s = display_indent;
if (a == null || danger) {
e = q = 0;
} else {
e = box_width(a);
q = e + math_quad(TEXT_SIZE);
}
if (w + q > z) {
if (e != 0
&& (w - tex::total_shrink[NORMAL] + q <= z
|| tex::total_shrink[FIL] != 0
|| tex::total_shrink[FILL] != 0
|| tex::total_shrink[FILLL] != 0)) {
free_node(b, BOX_NODE_SIZE);
b = hpack(p, z - q, EXACTLY);
} else {
e = 0;
if (w > z) {
free_node(b, BOX_NODE_SIZE);
b = hpack(p, z, EXACTLY);
}
}
w = box_width(b);
}
d = half(z - w);
if (e > 0 && d < 2 * e) {
d = half(z - w - e);
if (p != null && type(p) == GLUE_NODE) {
d = 0;
}
}
tail_append(new_penalty(pre_display_penalty));
if (d + s <= pre_display_size || l) {
g1 = ABOVE_DISPLAY_SKIP_CODE;
g2 = BELOW_DISPLAY_SKIP_CODE;
} else {
g1 = ABOVE_DISPLAY_SHORT_SKIP_CODE;
g2 = BELOW_DISPLAY_SHORT_SKIP_CODE;
}
if (l && e == 0) {
shift_amount(a) = s;
append_to_vlist(a);
tail_append(new_penalty(INF_PENALTY));
} else {
tail_append(new_param_glue(g1));
}
if (e != 0) {
r = new_kern(z - w - e - d);
if (l) {
link(a) = r;
link(r) = b;
b = a;
d = 0;
} else {
link(b) = r;
link(r) = a;
}
b = hpack(b, 0, ADDITIONAL);
}
shift_amount(b) = s + d;
append_to_vlist(b);
if (a != null && e == 0 && !l) {
tail_append(new_penalty(INF_PENALTY));
shift_amount(a) = s + z - box_width(a);
append_to_vlist(a);
g2 = 0;
}
if (t != tex::adjust_head) {
link(tail) = link(tex::adjust_head);
tail = t;
}
tail_append(new_penalty(post_display_penalty));
if (g2 > 0) {
tail_append(new_param_glue(g2));
}
resume_after_display();
}
}
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;
}
