#![allow(dead_code, non_camel_case_types, non_snake_case, unused_assignments, unused_mut, unused_variables)]
use crate::runtime::*;
impl<'resources> PortableTexEngine<'resources> {
pub(crate) unsafe fn filewarning(&mut self) {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut p: halfword = 0;
let mut l_0: quarterword = 0;
let mut c_0: quarterword = 0;
let mut i: integer = 0;
p = self.state.saveptr as halfword;
l_0 = self.state.curlevel;
c_0 = self.state.curgroup as quarterword;
self.state.saveptr = self.state.curboundary;
while *self.state.grpstack.offset(self.state.inopen as isize)
!= self.state.saveptr
{
self.state.curlevel = self.state.curlevel.wrapping_sub(1);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(66943 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>)).zprintgroup(1 as i32);
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(66944 as i64 as integer);
self.state.curgroup = (*self
.state
.savestack
.offset(self.state.saveptr as isize))
.hh
.u
.B1 as groupcode;
self.state.saveptr = (*self
.state
.savestack
.offset(self.state.saveptr as isize))
.hh
.v
.RH as integer;
}
self.state.saveptr = p as integer;
self.state.curlevel = l_0;
self.state.curgroup = c_0 as groupcode;
p = self.state.condptr;
l_0 = self.state.iflimit as quarterword;
c_0 = self.state.curif as quarterword;
i = self.state.ifline;
while *self.state.ifstack.offset(self.state.inopen as isize)
!= self.state.condptr
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(66943 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintcmdchr(108 as i32 as quarterword, self.state.curif as halfword);
if self.state.iflimit as i32 == 2 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(66167 as i64 as strnumber);
}
if self.state.ifline != 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66903 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(self.state.ifline);
}
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(66944 as i64 as integer);
self.state.ifline = (*mem
.offset((self.state.condptr as i32 + 1 as i32) as isize))
.u
.CINT;
self.state.curif = (*mem.offset(self.state.condptr as isize)).hh.u.B1
as smallnumber;
self.state.iflimit = (*mem.offset(self.state.condptr as isize)).hh.u.B0
as eightbits;
self.state.condptr = (*mem.offset(self.state.condptr as isize)).hh.v.RH;
}
self.state.condptr = p;
self.state.iflimit = l_0 as eightbits;
self.state.curif = c_0 as smallnumber;
self.state.ifline = i;
(&mut *(self as *mut PortableTexEngine<'_>)).println();
if (*eqtb.offset(7892329 as i64 as isize)).u.CINT > 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).showcontext();
}
if self.state.history as i32 == 0 as i32 {
self.state.history = 1 as eightbits;
}
}
pub(crate) unsafe fn finalign(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut p: halfword = 0;
let mut q: halfword = 0;
let mut r: halfword = 0;
let mut s: halfword = 0;
let mut u: halfword = 0;
let mut v: halfword = 0;
let mut t: scaled = 0;
let mut w: scaled = 0;
let mut o: scaled = 0;
let mut n: halfword = 0;
let mut rulesave: scaled = 0;
let mut auxsave: memoryword = memoryword { gr: 0. };
if self.state.curgroup as i32 != 6 as i32 {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zconfusion(66343 as i64 as strnumber)?
{};
}
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
if self.state.curgroup as i32 != 6 as i32 {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zconfusion(66344 as i64 as strnumber)?
{};
}
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
if (*self.state.nest.offset((self.state.nestptr as i32 - 1 as i32) as isize))
.modefield as i32 == 209 as i32
{
o = (*eqtb.offset(9006734 as i64 as isize)).u.CINT as scaled;
} else {
o = 0 as i32 as scaled;
}
q = (*mem
.offset(
(*mem.offset((self.state.memtop as i32 - 8 as i32) as isize)).hh.v.RH
as isize,
))
.hh
.v
.RH;
loop {
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushlist((*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT);
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushlist((*mem.offset((q as i32 + 2 as i32) as isize)).u.CINT);
p = (*mem.offset((*mem.offset(q as isize)).hh.v.RH as isize)).hh.v.RH;
if (*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT as i64
== -(1073741824 as i64)
{
(*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT = 0 as i32
as integer;
r = (*mem.offset(q as isize)).hh.v.RH;
s = (*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.LH;
if s != self.state.membot {
let ref mut fresh132 = (*mem.offset(self.state.membot as isize))
.hh
.v
.RH;
*fresh132 += 1;
(&mut *(self as *mut PortableTexEngine<'_>)).zdeleteglueref(s);
(*mem.offset((r as i32 + 1 as i32) as isize)).hh.v.LH = self
.state
.membot as halfword;
}
}
if (*mem.offset(q as isize)).hh.v.LH != self.state.memtop as i32 - 9 as i32 {
t = ((*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT
+ (*mem
.offset(
((*mem
.offset(
((*mem.offset(q as isize)).hh.v.RH as i32 + 1 as i32)
as isize,
))
.hh
.v
.LH as i32 + 1 as i32) as isize,
))
.u
.CINT) as scaled;
r = (*mem.offset(q as isize)).hh.v.LH;
s = (self.state.memtop as i32 - 9 as i32) as halfword;
(*mem.offset(s as isize)).hh.v.LH = p;
n = 1 as i32 as halfword;
loop {
(*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT = ((*mem
.offset((r as i32 + 1 as i32) as isize))
.u
.CINT as scaled - t) as integer;
u = (*mem.offset(r as isize)).hh.v.LH;
while (*mem.offset(r as isize)).hh.v.RH > n {
s = (*mem.offset(s as isize)).hh.v.LH;
n = ((*mem.offset((*mem.offset(s as isize)).hh.v.LH as isize))
.hh
.v
.RH as i32 + 1 as i32) as halfword;
}
if (*mem.offset(r as isize)).hh.v.RH < n {
(*mem.offset(r as isize)).hh.v.LH = (*mem.offset(s as isize))
.hh
.v
.LH;
(*mem.offset(s as isize)).hh.v.LH = r;
let ref mut fresh133 = (*mem.offset(r as isize)).hh.v.RH;
*fresh133 -= 1;
s = r;
} else {
if (*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT
> (*mem
.offset(
((*mem.offset(s as isize)).hh.v.LH as i32 + 1 as i32)
as isize,
))
.u
.CINT
{
(*mem
.offset(
((*mem.offset(s as isize)).hh.v.LH as i32 + 1 as i32)
as isize,
))
.u
.CINT = (*mem.offset((r as i32 + 1 as i32) as isize))
.u
.CINT;
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zfreenode(r, 2 as i32);
}
r = u;
if r == self.state.memtop as i32 - 9 as i32 {
break;
}
}
}
(*mem.offset(q as isize)).hh.u.B0 = 13 as i16;
(*mem.offset(q as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((q as i32 + 2 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((q as i32 + 5 as i32) as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((q as i32 + 5 as i32) as isize)).hh.u.B0 = 0 as i16;
(*mem.offset((q as i32 + 6 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((q as i32 + 4 as i32) as isize)).u.CINT = 0 as i32 as integer;
q = p;
if q as i64 == -(268435455 as i64) {
break;
}
}
self.state.saveptr = (self.state.saveptr as i32 - 2 as i32) as integer;
self.state.packbeginline = -self.state.curlist.mlfield;
if self.state.curlist.modefield as i32 == -(1 as i32) {
rulesave = (*eqtb.offset(9006735 as i64 as isize)).u.CINT as scaled;
(*eqtb.offset(9006735 as i64 as isize)).u.CINT = 0 as i32 as integer;
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(
(*mem.offset((self.state.memtop as i32 - 8 as i32) as isize))
.hh
.v
.RH,
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 1 as i32) as isize))
.u
.CINT,
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 0 as i32) as isize))
.u
.CINT as smallnumber,
)?;
(*eqtb.offset(9006735 as i64 as isize)).u.CINT = rulesave as integer;
} else {
q = (*mem
.offset(
(*mem.offset((self.state.memtop as i32 - 8 as i32) as isize)).hh.v.RH
as isize,
))
.hh
.v
.RH;
loop {
(*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((q as i32 + 1 as i32) as isize))
.u
.CINT;
(*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT = 0 as i32
as integer;
q = (*mem.offset((*mem.offset(q as isize)).hh.v.RH as isize)).hh.v.RH;
if q as i64 == -(268435455 as i64) {
break;
}
}
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zvpackage(
(*mem.offset((self.state.memtop as i32 - 8 as i32) as isize))
.hh
.v
.RH,
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 1 as i32) as isize))
.u
.CINT,
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 0 as i32) as isize))
.u
.CINT as smallnumber,
1073741823 as i64 as scaled,
)?;
q = (*mem
.offset(
(*mem.offset((self.state.memtop as i32 - 8 as i32) as isize)).hh.v.RH
as isize,
))
.hh
.v
.RH;
loop {
(*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((q as i32 + 3 as i32) as isize))
.u
.CINT;
(*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT = 0 as i32
as integer;
q = (*mem.offset((*mem.offset(q as isize)).hh.v.RH as isize)).hh.v.RH;
if q as i64 == -(268435455 as i64) {
break;
}
}
}
self.state.packbeginline = 0 as i32 as integer;
q = (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH;
s = self.state.curlist.headfield;
while q as i64 != -(268435455 as i64) {
if !(q >= self.state.himemmin) {
if (*mem.offset(q as isize)).hh.u.B0 as i32 == 13 as i32 {
if self.state.curlist.modefield as i32 == -(1 as i32) {
(*mem.offset(q as isize)).hh.u.B0 = 0 as i16;
(*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((p as i32 + 1 as i32) as isize))
.u
.CINT;
if (*self
.state
.nest
.offset((self.state.nestptr as i32 - 1 as i32) as isize))
.modefield as i32 == 209 as i32
{
(*mem.offset(q as isize)).hh.u.B1 = 2 as i16;
}
} else {
(*mem.offset(q as isize)).hh.u.B0 = 1 as i16;
(*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((p as i32 + 3 as i32) as isize))
.u
.CINT;
}
(*mem.offset((q as i32 + 5 as i32) as isize)).hh.u.B1 = (*mem
.offset((p as i32 + 5 as i32) as isize))
.hh
.u
.B1;
(*mem.offset((q as i32 + 5 as i32) as isize)).hh.u.B0 = (*mem
.offset((p as i32 + 5 as i32) as isize))
.hh
.u
.B0;
(*mem.offset((q as i32 + 6 as i32) as isize)).gr = (*mem
.offset((p as i32 + 6 as i32) as isize))
.gr;
(*mem.offset((q as i32 + 4 as i32) as isize)).u.CINT = o as integer;
r = (*mem
.offset(
(*mem.offset((q as i32 + 5 as i32) as isize)).hh.v.RH
as isize,
))
.hh
.v
.RH;
s = (*mem
.offset(
(*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH
as isize,
))
.hh
.v
.RH;
loop {
n = (*mem.offset(r as isize)).hh.u.B1 as halfword;
t = (*mem.offset((s as i32 + 1 as i32) as isize)).u.CINT
as scaled;
w = t;
u = (self.state.memtop as i32 - 4 as i32) as halfword;
(*mem.offset(r as isize)).hh.u.B1 = 0 as i16;
while n > 0 as i32 {
n -= 1;
s = (*mem.offset(s as isize)).hh.v.RH;
v = (*mem.offset((s as i32 + 1 as i32) as isize)).hh.v.LH;
(*mem.offset(u as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewglue(v)?;
u = (*mem.offset(u as isize)).hh.v.RH;
(*mem.offset(u as isize)).hh.u.B1 = 12 as i16;
t = (t as integer
+ (*mem.offset((v as i32 + 1 as i32) as isize)).u.CINT)
as scaled;
if (*mem.offset((p as i32 + 5 as i32) as isize)).hh.u.B0
as i32 == 1 as i32
{
if (*mem.offset(v as isize)).hh.u.B0 as i32
== (*mem.offset((p as i32 + 5 as i32) as isize)).hh.u.B1
as i32
{
t = (t as integer
+ zround(
(*mem.offset((p as i32 + 6 as i32) as isize)).gr
* (*mem.offset((v as i32 + 2 as i32) as isize)).u.CINT
as glueratio,
)) as scaled;
}
} else if (*mem.offset((p as i32 + 5 as i32) as isize))
.hh
.u
.B0 as i32 == 2 as i32
{
if (*mem.offset(v as isize)).hh.u.B1 as i32
== (*mem.offset((p as i32 + 5 as i32) as isize)).hh.u.B1
as i32
{
t = (t as integer
- zround(
(*mem.offset((p as i32 + 6 as i32) as isize)).gr
* (*mem.offset((v as i32 + 3 as i32) as isize)).u.CINT
as glueratio,
)) as scaled;
}
}
s = (*mem.offset(s as isize)).hh.v.RH;
(*mem.offset(u as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.newnullbox()?;
u = (*mem.offset(u as isize)).hh.v.RH;
t = (t as integer
+ (*mem.offset((s as i32 + 1 as i32) as isize)).u.CINT)
as scaled;
if self.state.curlist.modefield as i32 == -(1 as i32) {
(*mem.offset((u as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((s as i32 + 1 as i32) as isize))
.u
.CINT;
} else {
(*mem.offset(u as isize)).hh.u.B0 = 1 as i16;
(*mem.offset((u as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((s as i32 + 1 as i32) as isize))
.u
.CINT;
}
}
if self.state.curlist.modefield as i32 == -(1 as i32) {
(*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((q as i32 + 3 as i32) as isize))
.u
.CINT;
(*mem.offset((r as i32 + 2 as i32) as isize)).u.CINT = (*mem
.offset((q as i32 + 2 as i32) as isize))
.u
.CINT;
if t == (*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 0
as i16;
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B1 = 0
as i16;
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else if t
> (*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 1
as i16;
if (*mem.offset((r as i32 + 6 as i32) as isize)).u.CINT
== 0 as i32
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else {
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = ((t
as integer
- (*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT)
as f64
/ (*mem.offset((r as i32 + 6 as i32) as isize)).u.CINT
as f64) as glueratio;
}
} else {
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B1 = (*mem
.offset((r as i32 + 5 as i32) as isize))
.hh
.u
.B0;
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 2
as i16;
if (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
== 0 as i32
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else if (*mem.offset((r as i32 + 5 as i32) as isize))
.hh
.u
.B1 as i32 == 0 as i32
&& (*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT
as scaled - t
> (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 1.0f64
as glueratio;
} else {
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = (((*mem
.offset((r as i32 + 1 as i32) as isize))
.u
.CINT as scaled - t) as f64
/ (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
as f64) as glueratio;
}
}
(*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT = w
as integer;
(*mem.offset(r as isize)).hh.u.B0 = 0 as i16;
} else {
(*mem.offset((r as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((q as i32 + 1 as i32) as isize))
.u
.CINT;
if t == (*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 0
as i16;
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B1 = 0
as i16;
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else if t
> (*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 1
as i16;
if (*mem.offset((r as i32 + 6 as i32) as isize)).u.CINT
== 0 as i32
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else {
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = ((t
as integer
- (*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT)
as f64
/ (*mem.offset((r as i32 + 6 as i32) as isize)).u.CINT
as f64) as glueratio;
}
} else {
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B1 = (*mem
.offset((r as i32 + 5 as i32) as isize))
.hh
.u
.B0;
(*mem.offset((r as i32 + 5 as i32) as isize)).hh.u.B0 = 2
as i16;
if (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
== 0 as i32
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 0.0f64
as glueratio;
} else if (*mem.offset((r as i32 + 5 as i32) as isize))
.hh
.u
.B1 as i32 == 0 as i32
&& (*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT
as scaled - t
> (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
{
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = 1.0f64
as glueratio;
} else {
(*mem.offset((r as i32 + 6 as i32) as isize)).gr = (((*mem
.offset((r as i32 + 3 as i32) as isize))
.u
.CINT as scaled - t) as f64
/ (*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT
as f64) as glueratio;
}
}
(*mem.offset((r as i32 + 3 as i32) as isize)).u.CINT = w
as integer;
(*mem.offset(r as isize)).hh.u.B0 = 1 as i16;
}
(*mem.offset((r as i32 + 4 as i32) as isize)).u.CINT = 0 as i32
as integer;
if u != self.state.memtop as i32 - 4 as i32 {
(*mem.offset(u as isize)).hh.v.RH = (*mem.offset(r as isize))
.hh
.v
.RH;
(*mem.offset(r as isize)).hh.v.RH = (*mem
.offset((self.state.memtop as i32 - 4 as i32) as isize))
.hh
.v
.RH;
r = u;
}
r = (*mem.offset((*mem.offset(r as isize)).hh.v.RH as isize))
.hh
.v
.RH;
s = (*mem.offset((*mem.offset(s as isize)).hh.v.RH as isize))
.hh
.v
.RH;
if r as i64 == -(268435455 as i64) {
break;
}
}
} else if (*mem.offset(q as isize)).hh.u.B0 as i32 == 2 as i32 {
if (*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT as i64
== -(1073741824 as i64)
{
(*mem.offset((q as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((p as i32 + 1 as i32) as isize))
.u
.CINT;
}
if (*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT as i64
== -(1073741824 as i64)
{
(*mem.offset((q as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((p as i32 + 3 as i32) as isize))
.u
.CINT;
}
if (*mem.offset((q as i32 + 2 as i32) as isize)).u.CINT as i64
== -(1073741824 as i64)
{
(*mem.offset((q as i32 + 2 as i32) as isize)).u.CINT = (*mem
.offset((p as i32 + 2 as i32) as isize))
.u
.CINT;
}
if o != 0 as i32 {
r = (*mem.offset(q as isize)).hh.v.RH;
(*mem.offset(q as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
q = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(q, 0 as i32, 1 as i32 as smallnumber)?;
(*mem.offset((q as i32 + 4 as i32) as isize)).u.CINT = o
as integer;
(*mem.offset(q as isize)).hh.v.RH = r;
(*mem.offset(s as isize)).hh.v.RH = q;
}
}
}
s = q;
q = (*mem.offset(q as isize)).hh.v.RH;
}
(&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(p)?;
(&mut *(self as *mut PortableTexEngine<'_>)).popalignment();
auxsave = self.state.curlist.auxfield;
p = (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH;
q = self.state.curlist.tailfield;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
if self.state.curlist.modefield as i32 == 209 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).doassignments()?;
if self.state.curcmd as i32 != 3 as i32 {
if self.state.filelineerrorstylep != 0 {
(&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(65544 as i64 as strnumber);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66608 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66323 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66324 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).backerror()?;
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
if self.state.curcmd as i32 != 3 as i32 {
if self.state.filelineerrorstylep != 0 {
(&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(65544 as i64 as strnumber);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66604 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66605 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66606 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).backerror()?;
}
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushnodelist(self.state.curlist.eTeXauxfield)?;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewpenalty((*eqtb.offset(7892275 as i64 as isize)).u.CINT)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewparamglue(3 as i32 as smallnumber)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = p;
if p as i64 != -(268435455 as i64) {
self.state.curlist.tailfield = q;
}
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewpenalty((*eqtb.offset(7892276 as i64 as isize)).u.CINT)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewparamglue(4 as i32 as smallnumber)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
self.state.curlist.auxfield.u.CINT = auxsave.u.CINT;
(&mut *(self as *mut PortableTexEngine<'_>)).resumeafterdisplay()?;
} else {
self.state.curlist.auxfield = auxsave;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = p;
if p as i64 != -(268435455 as i64) {
self.state.curlist.tailfield = q;
}
if self.state.curlist.modefield as i32 == 1 as i32 {
Self::boundary_build_page(self as *mut PortableTexEngine<'_>);
}
};
Ok(())
}
pub(crate) unsafe fn fincol(&mut self) -> EngineFlow<boolean> {
let mut Result: boolean = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
let mut q: halfword = 0;
let mut r: halfword = 0;
let mut s: halfword = 0;
let mut u: halfword = 0;
let mut w: scaled = 0;
let mut o: glueord = 0;
let mut n: halfword = 0;
if self.state.curalign as i64 == -(268435455 as i64) {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zconfusion(66337 as i64 as strnumber)?
{};
}
q = (*mem.offset(self.state.curalign as isize)).hh.v.RH;
if q as i64 == -(268435455 as i64) {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zconfusion(66337 as i64 as strnumber)?
{};
}
if (self.state.alignstate as i64) < 500000 as i64 {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zfatalerror(65924 as i64 as strnumber)?
{};
}
p = (*mem.offset(q as isize)).hh.v.RH;
if p as i64 == -(268435455 as i64)
&& ((*mem.offset((self.state.curalign as i32 + 5 as i32) as isize)).hh.v.LH
as i64) < 1114114 as i64
{
if self.state.curloop as i64 != -(268435455 as i64) {
(*mem.offset(q as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.newnullbox()?;
p = (*mem.offset(q as isize)).hh.v.RH;
(*mem.offset(p as isize)).hh.v.LH = (self.state.memtop as i32 - 9 as i32)
as halfword;
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT = -(1073741824
as i64) as integer;
self.state.curloop = (*mem.offset(self.state.curloop as isize)).hh.v.RH;
q = (self.state.memtop as i32 - 4 as i32) as halfword;
r = (*mem.offset((self.state.curloop as i32 + 3 as i32) as isize)).u.CINT
as halfword;
while r as i64 != -(268435455 as i64) {
(*mem.offset(q as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.getavail()?;
q = (*mem.offset(q as isize)).hh.v.RH;
(*mem.offset(q as isize)).hh.v.LH = (*mem.offset(r as isize))
.hh
.v
.LH;
r = (*mem.offset(r as isize)).hh.v.RH;
}
(*mem.offset(q as isize)).hh.v.RH = -(268435455 as i64) as halfword;
(*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT = (*mem
.offset((self.state.memtop as i32 - 4 as i32) as isize))
.hh
.v
.RH as integer;
q = (self.state.memtop as i32 - 4 as i32) as halfword;
r = (*mem.offset((self.state.curloop as i32 + 2 as i32) as isize)).u.CINT
as halfword;
while r as i64 != -(268435455 as i64) {
(*mem.offset(q as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.getavail()?;
q = (*mem.offset(q as isize)).hh.v.RH;
(*mem.offset(q as isize)).hh.v.LH = (*mem.offset(r as isize))
.hh
.v
.LH;
r = (*mem.offset(r as isize)).hh.v.RH;
}
(*mem.offset(q as isize)).hh.v.RH = -(268435455 as i64) as halfword;
(*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT = (*mem
.offset((self.state.memtop as i32 - 4 as i32) as isize))
.hh
.v
.RH as integer;
self.state.curloop = (*mem.offset(self.state.curloop as isize)).hh.v.RH;
(*mem.offset(p as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewglue(
(*mem.offset((self.state.curloop as i32 + 1 as i32) as isize))
.hh
.v
.LH,
)?;
(*mem.offset((*mem.offset(p as isize)).hh.v.RH as isize)).hh.u.B1 = 12
as i16;
} else {
if self.state.filelineerrorstylep != 0 {
(&mut *(self as *mut PortableTexEngine<'_>)).printfileline();
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(65544 as i64 as strnumber);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66338 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(66327 as i64 as strnumber);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66339 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66340 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66341 as i64 as strnumber;
(*mem.offset((self.state.curalign as i32 + 5 as i32) as isize))
.hh
.v
.LH = 1114114 as i64 as halfword;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
}
}
if (*mem.offset((self.state.curalign as i32 + 5 as i32) as isize)).hh.v.LH as i64
!= 1114113 as i64
{
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.znewsavelevel(6 as i32 as groupcode)?;
if self.state.curlist.modefield as i32 == -(105 as i32) {
self.state.adjusttail = self.state.curtail;
self.state.preadjusttail = self.state.curpretail;
u = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
0 as i32,
1 as i32 as smallnumber,
)?;
w = (*mem.offset((u as i32 + 1 as i32) as isize)).u.CINT as scaled;
self.state.curtail = self.state.adjusttail;
self.state.adjusttail = -(268435455 as i64) as halfword;
self.state.curpretail = self.state.preadjusttail;
self.state.preadjusttail = -(268435455 as i64) as halfword;
} else {
u = (&mut *(self as *mut PortableTexEngine<'_>))
.zvpackage(
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
0 as i32,
1 as i32 as smallnumber,
0 as i32,
)?;
w = (*mem.offset((u as i32 + 3 as i32) as isize)).u.CINT as scaled;
}
n = 0 as i32 as halfword;
if self.state.curspan != self.state.curalign {
q = self.state.curspan;
loop {
n += 1;
q = (*mem.offset((*mem.offset(q as isize)).hh.v.RH as isize))
.hh
.v
.RH;
if q == self.state.curalign {
break;
}
}
if n as i64 > 65535 as i64 {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zconfusion(66342 as i64 as strnumber)?
{};
}
q = self.state.curspan;
while (*mem.offset((*mem.offset(q as isize)).hh.v.LH as isize)).hh.v.RH
< n
{
q = (*mem.offset(q as isize)).hh.v.LH;
}
if (*mem.offset((*mem.offset(q as isize)).hh.v.LH as isize)).hh.v.RH > n
{
s = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(2 as i32)?;
(*mem.offset(s as isize)).hh.v.LH = (*mem.offset(q as isize))
.hh
.v
.LH;
(*mem.offset(s as isize)).hh.v.RH = n;
(*mem.offset(q as isize)).hh.v.LH = s;
(*mem.offset((s as i32 + 1 as i32) as isize)).u.CINT = w as integer;
} else if (*mem
.offset(
((*mem.offset(q as isize)).hh.v.LH as i32 + 1 as i32) as isize,
))
.u
.CINT < w
{
(*mem
.offset(
((*mem.offset(q as isize)).hh.v.LH as i32 + 1 as i32)
as isize,
))
.u
.CINT = w as integer;
}
} else if w
> (*mem.offset((self.state.curalign as i32 + 1 as i32) as isize)).u.CINT
{
(*mem.offset((self.state.curalign as i32 + 1 as i32) as isize)).u.CINT = w
as integer;
}
(*mem.offset(u as isize)).hh.u.B0 = 13 as i16;
(*mem.offset(u as isize)).hh.u.B1 = n as i16;
if self.state.totalstretch[3 as i32 as usize] != 0 as i32 {
o = 3 as glueord;
} else if self.state.totalstretch[2 as i32 as usize] != 0 as i32 {
o = 2 as glueord;
} else if self.state.totalstretch[1 as i32 as usize] != 0 as i32 {
o = 1 as glueord;
} else {
o = 0 as glueord;
}
(*mem.offset((u as i32 + 5 as i32) as isize)).hh.u.B1 = o as i16;
(*mem.offset((u as i32 + 6 as i32) as isize)).u.CINT = self
.state
.totalstretch[o as usize] as integer;
if self.state.totalshrink[3 as i32 as usize] != 0 as i32 {
o = 3 as glueord;
} else if self.state.totalshrink[2 as i32 as usize] != 0 as i32 {
o = 2 as glueord;
} else if self.state.totalshrink[1 as i32 as usize] != 0 as i32 {
o = 1 as glueord;
} else {
o = 0 as glueord;
}
(*mem.offset((u as i32 + 5 as i32) as isize)).hh.u.B0 = o as i16;
(*mem.offset((u as i32 + 4 as i32) as isize)).u.CINT = self
.state
.totalshrink[o as usize] as integer;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = u;
self.state.curlist.tailfield = u;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewglue(
(*mem
.offset(
((*mem.offset(self.state.curalign as isize)).hh.v.RH as i32
+ 1 as i32) as isize,
))
.hh
.v
.LH,
)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1 = 12 as i16;
if (*mem.offset((self.state.curalign as i32 + 5 as i32) as isize)).hh.v.LH
as i64 >= 1114114 as i64
{
Result = true_0 as boolean;
return Ok(Result);
}
(&mut *(self as *mut PortableTexEngine<'_>)).zinitspan(p)?;
}
self.state.alignstate = 1000000 as i64 as integer;
loop {
(&mut *(self as *mut PortableTexEngine<'_>)).getxorprotected()?;
if self.state.curcmd as i32 != 10 as i32 {
break;
}
}
self.state.curalign = p;
(&mut *(self as *mut PortableTexEngine<'_>)).initcol()?;
Result = false_0 as boolean;
return Ok(Result);
}
pub(crate) unsafe fn finrow(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut p: halfword = 0;
if self.state.curlist.modefield as i32 == -(105 as i32) {
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
0 as i32,
1 as i32 as smallnumber,
)?;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
if self.state.curprehead != self.state.curpretail {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (*mem
.offset(self.state.curprehead as isize))
.hh
.v
.RH;
self.state.curlist.tailfield = self.state.curpretail;
}
(&mut *(self as *mut PortableTexEngine<'_>)).zappendtovlist(p)?;
if self.state.curhead != self.state.curtail {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (*mem
.offset(self.state.curhead as isize))
.hh
.v
.RH;
self.state.curlist.tailfield = self.state.curtail;
}
} else {
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zvpackage(
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
0 as i32,
1 as i32 as smallnumber,
1073741823 as i64 as scaled,
)?;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = p;
self.state.curlist.tailfield = p;
self.state.curlist.auxfield.hh.v.LH = 1000 as i32 as halfword;
}
(*mem.offset(p as isize)).hh.u.B0 = 13 as i16;
(*mem.offset((p as i32 + 6 as i32) as isize)).u.CINT = 0 as i32 as integer;
if (*eqtb.offset(1206303 as i64 as isize)).hh.v.RH as i64 != -(268435455 as i64)
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*eqtb.offset(1206303 as i64 as isize)).hh.v.RH,
14 as i32 as quarterword,
)?;
}
(&mut *(self as *mut PortableTexEngine<'_>)).alignpeek()?;
Ok(())
}
pub(crate) unsafe fn firmuptheline(&mut self) -> EngineFlow<()> {
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut k: integer = 0;
self.state.curinput.limitfield = self.state.last as halfword;
Ok(
if (*eqtb.offset(7892292 as i64 as isize)).u.CINT > 0 as i32 {
if self.state.interaction as i32 > 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).println();
if self.state.curinput.startfield < self.state.curinput.limitfield {
let mut for_end: integer = 0;
k = self.state.curinput.startfield as integer;
for_end = (self.state.curinput.limitfield as i32 - 1 as i32)
as integer;
if k <= for_end {
loop {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(*self.state.buffer.offset(k as isize));
let fresh31 = k;
k = k + 1;
if !(fresh31 < for_end) {
break;
}
}
}
}
self.state.first = self.state.curinput.limitfield as integer;
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65950 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>)).terminput()?;
if self.state.last > self.state.first {
let mut for_end_0: integer = 0;
k = self.state.first;
for_end_0 = (self.state.last as i32 - 1 as i32) as integer;
if k <= for_end_0 {
loop {
*self
.state
.buffer
.offset(
(k + self.state.curinput.startfield as integer
- self.state.first) as isize,
) = *self.state.buffer.offset(k as isize);
let fresh32 = k;
k = k + 1;
if !(fresh32 < for_end_0) {
break;
}
}
}
self.state.curinput.limitfield = (self.state.curinput.startfield
as integer + self.state.last - self.state.first) as halfword;
}
}
},
)
}
pub(crate) unsafe fn fixlanguage(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut l_0: UTF16code = 0;
if (*eqtb.offset(7892314 as i64 as isize)).u.CINT <= 0 as i32 {
l_0 = 0 as UTF16code;
} else if (*eqtb.offset(7892314 as i64 as isize)).u.CINT > 255 as i32 {
l_0 = 0 as UTF16code;
} else {
l_0 = (*eqtb.offset(7892314 as i64 as isize)).u.CINT as UTF16code;
}
Ok(
if l_0 as i32 != self.state.curlist.auxfield.hh.v.RH {
(&mut *(self as *mut PortableTexEngine<'_>))
.znewwhatsit(5 as i32 as smallnumber, 2 as i32 as smallnumber)?;
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.v
.RH = l_0 as halfword;
self.state.curlist.auxfield.hh.v.RH = l_0 as halfword;
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.u
.B0 = (&mut *(self as *mut PortableTexEngine<'_>))
.znormmin((*eqtb.offset(7892315 as i64 as isize)).u.CINT) as i16;
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.u
.B1 = (&mut *(self as *mut PortableTexEngine<'_>))
.znormmin((*eqtb.offset(7892316 as i64 as isize)).u.CINT) as i16;
},
)
}
pub(crate) unsafe fn flushmath(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushnodelist(
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH,
)?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushnodelist(self.state.curlist.auxfield.u.CINT)?;
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH = -(268435455
as i64) as halfword;
self.state.curlist.tailfield = self.state.curlist.headfield;
self.state.curlist.auxfield.u.CINT = -(268435455 as i64) as integer;
Ok(())
}
}