void tex::unpackage ()
{
int c;
ptr p;
c = cur_chr;
scan_eight_bit_int();
p = box(cur_val);
if (p == null)
return;
if (abs(mode) == MMODE
|| abs(mode) == VMODE && type(p) != VLIST_NODE
|| abs(mode) == HMODE && type(p) != HLIST_NODE) {
print_err("Incompatible list can't be unboxed");
help_pandora();
error();
return;
}
if (c == COPY_CODE) {
link(tail) = copy_node_list(list_ptr(p));
} else {
link(tail) = list_ptr(p);
box(cur_val) = null;
free_node(p, BOX_NODE_SIZE);
}
while (link(tail) != null)
tail = link(tail);
}
ptr tex::vsplit(int n, scal h)
{
ptr p;
ptr q;
ptr v;
v = box(n);
if (split_first_mark != null) {
delete_token_ref(split_first_mark);
split_first_mark = null;
delete_token_ref(split_bot_mark);
split_bot_mark = null;
}
if (v == null)
return null;
if (type(v) != VLIST_NODE) {
print_err(null_str);
print_esc("vsplit");
print(" needs a ");
print_esc("vbox");
help_vsplit_vbox();
error();
return null;
}
q = vert_break(list_ptr(v), h, split_max_depth);
p = list_ptr(v);
if (p == q) {
list_ptr(v) = null;
} else {
loop {
if (type(p) == MARK_NODE) {
if (split_first_mark == null) {
split_first_mark = mark_ptr(p);
split_bot_mark = split_first_mark;
token_ref_count(split_first_mark) += 2;
} else {
delete_token_ref(split_bot_mark);
split_bot_mark = mark_ptr(p);
add_token_ref(split_bot_mark);
}
}
if (link(p) == q) {
link(p) = null;
break;
}
p = link(p);
}
}
q = prune_page_top(q);
p = list_ptr(v);
free_node(v, BOX_NODE_SIZE);
if (q == null) {
box(n) = null;
} else {
box(n) = vpack(q, 0, ADDITIONAL);
}
return (vpackage(p, h, EXACTLY, split_max_depth));
}
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));
}
void add(const T& begin_node, const T& end_node) // add arc
{
if(begin_node == end_node)
{
return;
}
size_t aId = 0;
size_t bId = 0;
node_ptr aTestResult = is_node(begin_node);
if(aTestResult.get()->is_null())
{
node_ptr pNode = node_ptr(new node<T>(begin_node));
aId = pNode->id;
pNode->null = false;
this->storage.push_back(pNode);
adjectedListsVec.push_back(list_ptr(new std::list<T>));
}
else
{
aId = aTestResult->id;
}
node_ptr bTestResult = is_node(end_node);
if(bTestResult.get()->is_null())
{
node_ptr pNode = node_ptr(new node<T>(end_node));
bId = pNode->id;
pNode->null = false;
this->storage.push_back(pNode);
adjectedListsVec.push_back(list_ptr(new std::list<T>));
}
else
{
bId = bTestResult->id;
}
adjectedListsVec[aId]->push_back(bId);
adjectedListsVec[aId]->unique();
adjectedListsVec[bId]->push_back(aId);
adjectedListsVec[bId]->unique();
assert(this->storage.size() == adjectedListsVec.size());
}
void WRarglst(list_t a)
{ int n = 1;
if (!a) dbg_printf("0 args\n");
while (a)
{ const char* c = (const char*)list_ptr(a);
dbg_printf("arg %d: '%s'\n", n, c ? c : "NULL");
a = a->next;
n++;
}
}
list_t list_prepend(list_t *plist,void *ptr)
{ register list_t list;
list = list_alloc(fileline);
if (list)
{ list_next(list) = *plist;
list_ptr(list) = ptr;
list->count = 1;
*plist = list;
}
return list;
}
tex::box_t::box_t()
{
type(this) = HLIST_NODE;
subtype(this) = MIN_QUARTERWORD;
box_width(this) = 0;
box_depth(this) = 0;
box_height(this) = 0;
shift_amount(this) = 0;
list_ptr(this) = 0;
glue_sign(this) = NORMAL;
glue_order(this) = NORMAL;
glue_set(this) = 0.0;
}
void *list_subtract(list_t *plist,void *ptr)
{ list_t list;
while ((list = *plist) != 0)
{
if (list_ptr(list) == ptr)
{
if (--list->count == 0)
{ *plist = list_next(list);
list->next = list_freelist;
list_freelist = list;
}
return ptr;
}
else
plist = &(list_next(list));
}
return NULL; /* it wasn't in the list */
}
bool tex::insert_box(ptr p)
{
bool wait;
ptr q, r, t;
int n;
q = link(page_ins_head);
while (subtype(q) != subtype(p))
q = link(q);
if (best_ins_ptr(q) == null)
return TRUE;
wait = FALSE;
r = last_ins_ptr(q);
link(r) = ins_ptr(p);
if (best_ins_ptr(q) == p) {
if (type(q) == SPLIT_UP
&& broken_ins(q) == p
&& broken_ptr(q) != null) {
while (link(r) != broken_ptr(q))
r = link(r);
link(r) = null;
split_top_skip = split_top_ptr(p);
ins_ptr(p) = prune_page_top(broken_ptr(q));
if (ins_ptr(p) != null) {
t = vpack(ins_ptr(p), 0, ADDITIONAL);
ins_height(p) = box_height(t) + box_depth(t);
free_node(t, BOX_NODE_SIZE);
wait = TRUE;
}
}
best_ins_ptr(q) = null;
n = subtype(q);
t = list_ptr(box(n));
free_node(box(n), BOX_NODE_SIZE);
box(n) = vpack(t, 0, ADDITIONAL);
} else {
while (link(r) != null)
r = link(r);
last_ins_ptr(q) = r;
}
return wait;
}
list_t list_append(list_t *plist,void *ptr)
#endif
{ register list_t list;
while (*plist)
plist = &(list_next(*plist)); /* find end of list */
#if MEM_DEBUG
list = list_alloc(file,line);
#else
list = list_alloc();
#endif
if (list)
{ *plist = list;
list_next(list) = 0;
list_ptr(list) = ptr;
list->count = 1;
}
return list;
}
void list_free(list_t *plist,list_free_fp freeptr)
{ list_t list,listnext;
list = *plist;
*plist = 0; /* block any circular reference bugs */
while (list && --list->count == 0)
{ listnext = list_next(list);
if (freeptr)
(*freeptr)(list_ptr(list));
#if DEBUG
memset(list,0,sizeof(*list));
#endif
#if 1
list->next = list_freelist;
list_freelist = list;
#else
list_delete(list);
nlist--;
#endif
list = listnext;
}
}
void tex::show_box1(ptr p)
{
if (tex::type(p) == HLIST_NODE)
print_esc("h");
else if (tex::type(p) == VLIST_NODE)
print_esc("v");
else print_esc("unset");
print("box(");
print_scaled(box_height(p));
print("+") ;
print_scaled(box_depth(p));
print(")x") ;
print_scaled(box_width(p));
if (tex::type(p) == UNSET_NODE) {
if (unset_span_count(p) != MIN_QUARTERWORD) {
print(" (");
print_int(unset_span_count(p)+1);
print(" columns)");
}
if (unset_stretch(p) != 0) {
print(", stretch ");
print_glue(unset_stretch(p), glue_order(p), null_str);
}
if (unset_shrink(p) != 0) {
print(", shrink ");
print_glue(unset_shrink(p), glue_sign(p), null_str);
}
} else {
show_glue_set(p);
if (shift_amount(p) != 0) {
print(", shifted ");
print_scaled(shift_amount(p));
}
}
node_list_display(list_ptr(p));
}
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;
}
}
std::string XWindowManager::GetStringProperty(Window window_id, Atom atom) const
{
Atom type;
int result, format;
unsigned long n_items, bytes_after;
char *val = nullptr;
result = XGetWindowProperty(screen->dpy(), window_id, atom, 0L, 65536, False,
AnyPropertyType, &type, &format, &n_items,
&bytes_after, reinterpret_cast<unsigned char **>(&val));
if (result != Success)
{
LOG_DEBUG(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< " for window " << window_id;
return std::string();
}
if (!val || n_items == 0)
{
LOG_DEBUG(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< " for window " << window_id << ": empty value";
return std::string();
}
std::unique_ptr<char[], int(*)(void*)> string(val, XFree);
if (format != 8)
{
LOG_ERROR(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< " for window " << window_id << ": invalid format " << format;
return std::string();
}
if (type != XA_STRING && type != atom::XA_COMPOUND_TEXT && type != Atoms::utf8String)
{
LOG_ERROR(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< " for window " << window_id << ": invalid string type: "
<< gdk_x11_get_xatom_name(type);
return std::string();
}
if (type == atom::XA_COMPOUND_TEXT || (type == XA_STRING && !g_utf8_validate(val, n_items, nullptr)))
{
// In case we have compound text, we need to convert it to utf-8
XTextProperty text_property;
text_property.value = reinterpret_cast<unsigned char*>(val);
text_property.encoding = type;
text_property.format = format;
text_property.nitems = n_items;
char **list = nullptr;
int count = 0;
result = XmbTextPropertyToTextList(screen->dpy(), &text_property, &list, &count);
if (result != Success || count == 0)
{
LOG_WARN(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< "for window " << window_id << " properly: impossible to convert to current locale";
return std::string(val, n_items);
}
std::unique_ptr<char*[], void(*)(char**)> list_ptr(list, XFreeStringList);
if (count != 1)
{
LOG_WARN(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
<< "for window " << window_id << " properly: invalid number of parsed values";
}
return list_ptr[0];
}
return std::string(val, n_items);
}
void pdf_vlist_out (void)
{
scaled left_edge;
scaled top_edge;
scaled save_h, save_v;
pointer this_box;
// glue_ord g_order;
int g_order;
// char g_sign;
int g_sign;
pointer p;
integer save_loc;
pointer leader_box;
scaled leader_ht;
scaled lx;
boolean outer_doing_leaders;
scaled edge;
real glue_temp;
real cur_glue;
scaled cur_g;
cur_g = 0;
cur_glue = 0.0;
this_box = temp_ptr;
g_order = glue_order(this_box);
g_sign = glue_sign(this_box);
p = list_ptr(this_box);
incr(cur_s);
if (cur_s > max_push)
max_push = cur_s;
save_loc = dvi_offset + dvi_ptr;
left_edge = cur_h;
cur_v = cur_v - height(this_box);
top_edge = cur_v;
while (p != 0)
{
if (is_char_node(p))
{
confusion("vlistout");
return;
}
else
{
switch (type(p))
{
case hlist_node:
case vlist_node:
if (list_ptr(p) == 0)
cur_v = cur_v + height(p) + depth(p);
else
{
cur_v = cur_v + height(p);
pdf_synch_v();
save_h = dvi_h;
save_v = dvi_v;
cur_h = left_edge + shift_amount(p);
temp_ptr = p;
if (type(p) == vlist_node)
pdf_vlist_out();
else
pdf_hlist_out();
dvi_h = save_h;
dvi_v = save_v;
cur_v = save_v + depth(p);
cur_h = left_edge;
}
break;
case rule_node:
{
rule_ht = height(p);
rule_dp = depth(p);
rule_wd = width(p);
goto fin_rule;
}
break;
case whatsit_node:
out_what(p);
break;
case glue_node:
{
g = glue_ptr(p);
rule_ht = width(g) - cur_g;
if (g_sign != normal)
{
if (g_sign == stretching)
{
if (stretch_order(g) == g_order)
{
cur_glue = cur_glue + stretch(g);
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);
vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
rule_ht = rule_ht + cur_g;
if (subtype(p) >= a_leaders)
{
leader_box = leader_ptr(p);
if (type(leader_box) == rule_node)
{
rule_wd = width(leader_box);
rule_dp = 0;
goto fin_rule;
}
leader_ht = height(leader_box) + depth(leader_box);
if ((leader_ht > 0) && (rule_ht > 0))
{
rule_ht = rule_ht + 10;
edge = cur_v + rule_ht;
lx = 0;
if (subtype(p) == a_leaders)
{
save_v = cur_v;
cur_v = top_edge + leader_ht * ((cur_v - top_edge) / leader_ht);
if (cur_v < save_v)
cur_v = cur_v + leader_ht;
}
else
{
lq = rule_ht / leader_ht;
lr = rule_ht % leader_ht;
if (subtype(p) == c_leaders)
cur_v = cur_v + (lr / 2);
else
{
lx = (2 * lr + lq + 1) / (2 * lq + 2);
cur_v = cur_v + ((lr - (lq - 1) * lx) / 2);
}
}
while (cur_v + leader_ht <= edge)
{
cur_h = left_edge + shift_amount(leader_box);
pdf_synch_h();
save_h = dvi_h;
cur_v = cur_v + height(leader_box);
pdf_synch_v();
save_v = dvi_v;
temp_ptr = leader_box;
outer_doing_leaders = doing_leaders;
doing_leaders = true;
if (type(leader_box) == vlist_node)
pdf_vlist_out();
else
pdf_hlist_out();
doing_leaders = outer_doing_leaders;
dvi_v = save_v;
dvi_h = save_h;
cur_h = left_edge;
cur_v = save_v - height(leader_box) + leader_ht + lx;
}
cur_v = edge - 10;
goto next_p;
}
}
goto move_past;
}
break;
case kern_node:
cur_v = cur_v + width(p);
break;
default:
break;
}
goto next_p;
fin_rule:
if (is_running(rule_wd))
rule_wd = width(this_box);
rule_ht = rule_ht + rule_dp;
cur_v = cur_v + rule_ht;
if ((rule_ht > 0) && (rule_wd > 0))
{
pdf_synch_h();
pdf_synch_v();
pdf_dev_set_rule(dvi_h, -dvi_v, rule_wd, rule_ht);
}
goto next_p;
move_past:
cur_v = cur_v + rule_ht;
}
next_p:
p = link(p);
}
prune_movements(save_loc);
decr(cur_s);
}
void pdf_hlist_out (void)
{
scaled base_line;
scaled left_edge;
scaled save_h, save_v;
pointer this_box;
// glue_ord g_order;
int g_order;
// char g_sign;
int g_sign;
pointer p;
integer save_loc;
pointer leader_box;
scaled leader_wd;
scaled lx;
boolean outer_doing_leaders;
scaled edge;
real glue_temp;
real cur_glue;
scaled cur_g;
cur_g = 0;
cur_glue = 0.0;
this_box = temp_ptr;
g_order = glue_order(this_box);
g_sign = glue_sign(this_box);
p = list_ptr(this_box);
incr(cur_s);
if (cur_s > max_push)
max_push = cur_s;
save_loc = dvi_offset + dvi_ptr;
base_line = cur_v;
left_edge = cur_h;
while (p != 0)
reswitch:
if (is_char_node(p))
{
pdf_synch_h();
pdf_synch_v();
do
{
f = font(p);
c = character(p);
if (f != dvi_f)
{
if (!font_used[f])
{
font_used[f] = true;
font_id[f] = pdf_get_font_id(f);
}
dvi_f = f;
}
pdf_out_char(dvi_f, c);
cur_h = cur_h + char_width(f, char_info(f, c));
p = link(p);
} while (!(!is_char_node(p)));
dvi_h = cur_h;
}
else
{
switch (type(p))
{
case hlist_node:
case vlist_node:
if (list_ptr(p) == 0)
cur_h = cur_h + width(p);
else
{
save_h = dvi_h;
save_v = dvi_v;
cur_v = base_line + shift_amount(p);
temp_ptr = p;
edge = cur_h;
if (type(p) == vlist_node)
pdf_vlist_out();
else
pdf_hlist_out();
dvi_h = save_h;
dvi_v = save_v;
cur_h = edge + width(p);
cur_v = base_line;
}
break;
case rule_node:
{
rule_ht = height(p);
rule_dp = depth(p);
rule_wd = width(p);
goto fin_rule;
}
break;
case whatsit_node:
out_what(p);
break;
case glue_node:
{
g = glue_ptr(p);
rule_wd = width(g) - cur_g;
if (g_sign != normal)
{
if (g_sign == stretching)
{
if (stretch_order(g) == g_order)
{
cur_glue = cur_glue + stretch(g);
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);
vet_glue(glue_set(this_box) * cur_glue);
cur_g = round(glue_temp);
}
}
rule_wd = rule_wd + cur_g;
if (subtype(p) >= a_leaders)
{
leader_box = leader_ptr(p);
if (type(leader_box) == rule_node)
{
rule_ht = height(leader_box);
rule_dp = depth(leader_box);
goto fin_rule;
}
leader_wd = width(leader_box);
if ((leader_wd > 0) && (rule_wd > 0))
{
rule_wd = rule_wd + 10;
edge = cur_h + rule_wd;
lx = 0;
if (subtype(p) == a_leaders)
{
save_h = cur_h;
cur_h = left_edge + leader_wd * ((cur_h - left_edge) / leader_wd);
if (cur_h < save_h)
cur_h = cur_h + leader_wd;
}
else
{
lq = rule_wd / leader_wd;
lr = rule_wd % leader_wd;
if (subtype(p) == c_leaders)
cur_h = cur_h + (lr / 2);
else
{
lx = (2 * lr + lq + 1) / (2 * lq + 2);
cur_h = cur_h + ((lr - (lq - 1)* lx) / 2);
}
}
while (cur_h + leader_wd <= edge)
{
cur_v = base_line + shift_amount(leader_box);
pdf_synch_v();
save_v = dvi_v;
pdf_synch_h();
save_h = dvi_h;
temp_ptr = leader_box;
outer_doing_leaders = doing_leaders;
doing_leaders = true;
if (type(leader_box) == vlist_node)
pdf_vlist_out();
else
pdf_hlist_out();
doing_leaders = outer_doing_leaders;
dvi_v = save_v;
dvi_h = save_h;
cur_v = base_line;
cur_h = save_h + leader_wd + lx;
}
cur_h = edge - 10;
goto next_p;
}
}
goto move_past;
}
break;
case kern_node:
case math_node:
cur_h = cur_h + width(p);
break;
case ligature_node:
{
mem[lig_trick] = mem[lig_char(p)];
link(lig_trick) = link(p);
p = lig_trick;
goto reswitch;
}
break;
default:
break;
}
goto next_p;
fin_rule:
if (is_running(rule_ht))
rule_ht = height(this_box);
if (is_running(rule_dp))
rule_dp = depth(this_box);
rule_ht = rule_ht + rule_dp;
if ((rule_ht > 0) && (rule_wd > 0))
{
pdf_synch_h();
cur_v = base_line + rule_dp;
pdf_synch_v();
pdf_dev_set_rule(dvi_h, -dvi_v, rule_wd, rule_ht);
cur_v = base_line;
dvi_h = dvi_h + rule_wd;
}
move_past:
cur_h = cur_h + rule_wd;
next_p:
p = link(p);
}
prune_movements(save_loc);
decr(cur_s);
}
/// create empty list
///
var var::new_list() { return var(list_ptr(new list_t)); }
void tex::flush_node_list(ptr p)
{
ptr q;
while (p != null) {
q = link(p);
if (is_char_node(p)) {
free_avail(p);
} else {
switch (type(p))
{
case HLIST_NODE:
case VLIST_NODE:
case UNSET_NODE:
flush_node_list(list_ptr(p));
free_node(p, BOX_NODE_SIZE);
goto done;
case RULE_NODE:
free_node(p, RULE_NODE_SIZE);
goto done;
case INS_NODE:
flush_node_list(ins_ptr(p));
delete_glue_ref(split_top_ptr(p));
free_node(p, INS_NODE_SIZE);
goto done;
case WHATSIT_NODE:
free_whatsit(p);
goto done;
case GLUE_NODE:
fast_delete_glue_ref(glue_ptr(p));
if (leader_ptr(p) != null)
flush_node_list(leader_ptr(p));
break;
case KERN_NODE:
case MATH_NODE:
case PENALTY_NODE:
break;
case LIGATURE_NODE:
flush_node_list(lig_ptr(p));
break;
case MARK_NODE:
delete_token_ref(mark_ptr(p));
break;
case DISC_NODE:
flush_node_list(pre_break(p));
flush_node_list(post_break(p));
break;
case ADJUST_NODE:
flush_node_list(adjust_ptr(p));
break;
case STYLE_NODE:
free_node(p, STYLE_NODE_SIZE);
goto done;
case CHOICE_NODE:
flush_node_list(display_mlist(p));
flush_node_list(text_mlist(p));
flush_node_list(script_mlist(p));
flush_node_list(script_script_mlist(p));
free_node(p, STYLE_NODE_SIZE);
goto done;
case ORD_NOAD:
case OP_NOAD:
case BIN_NOAD:
case REL_NOAD:
case OPEN_NOAD:
case CLOSE_NOAD:
case PUNCT_NOAD:
case INNER_NOAD:
case RADICAL_NOAD:
case OVER_NOAD:
case UNDER_NOAD:
case VCENTER_NOAD:
case ACCENT_NOAD:
if (math_type(nucleus(p)) >= SUB_BOX)
flush_node_list(math_link(nucleus(p)));
if (math_type(supscr(p)) >= SUB_BOX)
flush_node_list(math_link(supscr(p)));
if (math_type(subscr(p)) >= SUB_BOX)
flush_node_list(math_link(subscr(p)));
if (type(p) == RADICAL_NOAD)
free_node(p, RADICAL_NOAD_SIZE);
else if (type(p) == ACCENT_NOAD)
free_node(p, ACCENT_NOAD_SIZE);
else free_node(p, NOAD_SIZE);
goto done;
case LEFT_NOAD:
case RIGHT_NOAD:
free_node(p, NOAD_SIZE);
goto done;
case FRACTION_NOAD:
flush_node_list(math_link(numerator(p)));
flush_node_list(math_link(denominator(p)));
free_node(p, FRACTION_NOAD_SIZE);
goto done;
default:
confusion("flushing");
break;
}
free_node(p, SMALL_NODE_SIZE);
done:;
}
p = q;
}
}
ptr tex::copy_node_list(ptr p)
{
ptr h;
ptr q;
ptr r=0;
h = q = new_avail();
while (p != null) {
if (is_char_node(p)) {
r = new_avail();
font(r) = font(p);
character(r) = character(p);
} else {
switch (type(p))
{
case HLIST_NODE:
case VLIST_NODE:
case UNSET_NODE:
r = tex::new_node(BOX_NODE_SIZE);
memcpy((void *)r, (void *)p, BOX_NODE_SIZE);
list_ptr(r) = copy_node_list(list_ptr(p));
break;
case RULE_NODE:
r = tex::new_node(RULE_NODE_SIZE);
memcpy((void *)r, (void *)p, RULE_NODE_SIZE);
break;
case INS_NODE:
r = tex::new_node(INS_NODE_SIZE);
memcpy((void *)r, (void *)p, INS_NODE_SIZE);
add_glue_ref(split_top_ptr(p));
ins_ptr(r) = copy_node_list(ins_ptr(p));
break;
case WHATSIT_NODE:
r = copy_whatsit(p);
break;
case GLUE_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
add_glue_ref(glue_ptr(p));
glue_ptr(r) = glue_ptr(p);
leader_ptr(r) = copy_node_list(leader_ptr(p));
break;
case KERN_NODE:
case MATH_NODE:
case PENALTY_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
break;
case LIGATURE_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
lig_ptr(r) = copy_node_list(lig_ptr(p));
break;
case DISC_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
pre_break(r) = copy_node_list(pre_break(p));
post_break(r) = copy_node_list(post_break(p));
break;
case MARK_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
add_token_ref(mark_ptr(p));
break;
case ADJUST_NODE:
r = tex::new_node(SMALL_NODE_SIZE);
memcpy((void *)r, (void *)p, SMALL_NODE_SIZE);
adjust_ptr(r) = copy_node_list(adjust_ptr(p));
break;
default:
confusion("copying");
break;
}
}
q = link(q) = r;
p = link(p);
}
link(q) = null;
q = link(h);
free_avail(h);
return q;
}
void tex::init_math ()
{
fnt f;
int m, n;
ptr p, q;
scal d, l, s, v, w;
get_token();
if (cur_cmd == MATH_SHIFT && mode > 0) {
if (head == tail) {
pop_nest();
w = -MAX_DIMEN;
} else {
line_break(display_widow_penalty);
v = shift_amount(just_box) + 2 * quad(cur_font);
w = -MAX_DIMEN;
p = list_ptr(just_box);
while (p != null) {
reswitch:
if (is_char_node(p)) {
f = font(p);
d = char_width(f,
char_info(f, character(p)));
goto found;
}
switch (type(p))
{
case HLIST_NODE:
case VLIST_NODE:
case RULE_NODE:
d = box_width(p);
goto found;
case LIGATURE_NODE:
p = make_char_from_lig(p);
goto reswitch;
case KERN_NODE:
d = kern_width(p);
break;
case MATH_NODE:
d = box_width(p);
break;
case GLUE_NODE:
q = glue_ptr(p);
d = box_width(q);
if (glue_sign(just_box) ==
STRETCHING) {
if (glue_order(just_box) ==
stretch_order(q)
&& stretch(q) != 0)
v = MAX_DIMEN;
} else if (glue_sign(just_box) ==
SHRINKING) {
if (glue_order(just_box) ==
shrink_order(q)
&& shrink(q) != 0)
v = MAX_DIMEN;
}
if (subtype(p) >= A_LEADERS)
goto found;
break;
case WHATSIT_NODE:
d = 0;
break;
default:
d = 0;
break;
}
if (v < MAX_DIMEN)
v += d;
goto not_found;
found:
if (v < MAX_DIMEN) {
v += d;
w = v;
} else {
w = MAX_DIMEN;
break;
}
not_found:
p = link(p);
}
}
if (par_shape_ptr == null) {
if (hang_indent != 0
&& (hang_after >= 0
&& prev_graf + 2 > hang_after
|| prev_graf + 1 < -hang_after)) {
l = hsize - abs(hang_indent);
s = (hang_indent > 0) ? hang_indent : 0;
} else {
l = hsize;
s = 0;
}
} else {
n = info(par_shape_ptr);
if (prev_graf + 2 >= n)
m = n;
else m = prev_graf + 2;
l = par_shape_width(m);
s = par_shape_indent(m);
}
push_math(MATH_SHIFT_GROUP);
mode = MMODE;
reg_define(int_reg[CUR_FAM_CODE], INT_REG, -1);
reg_define(dimen_reg[PRE_DISPLAY_SIZE_CODE], DIMEN_REG, w);
reg_define(dimen_reg[DISPLAY_WIDTH_CODE], DIMEN_REG, l);
reg_define(dimen_reg[DISPLAY_INDENT_CODE], DIMEN_REG, s);
if (every_display != null)
begin_token_list(every_display, EVERY_DISPLAY_TEXT);
if (nest_ptr == nest + 1)
build_page();
} else {
back_input();
push_math(MATH_SHIFT_GROUP);
reg_define(int_reg[CUR_FAM_CODE], INT_REG, -1);
if (every_math != null)
begin_token_list(every_math, EVERY_MATH_TEXT);
}
}
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();
}
}
