#![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 aftermath(&mut self) -> EngineFlow<()> {
Self::sandbox_close_math(self as *mut PortableTexEngine<'_>)?;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut l_0: boolean = 0;
let mut danger: boolean = 0;
let mut m: integer = 0;
let mut p: halfword = 0;
let mut a: halfword = 0;
let mut b: halfword = 0;
let mut w: scaled = 0;
let mut z: scaled = 0;
let mut e: scaled = 0;
let mut q: scaled = 0;
let mut d: scaled = 0;
let mut s: scaled = 0;
let mut g1: smallnumber = 0;
let mut g2: smallnumber = 0;
let mut r: halfword = 0;
let mut t: halfword = 0;
let mut pret: halfword = 0;
let mut j: halfword = 0;
danger = false_0 as boolean;
if self.state.curlist.modefield as i32 == 209 as i32 {
j = self.state.curlist.eTeXauxfield;
}
if *self
.state
.fontparams
.offset((*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize) < 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize) as i64
== 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset((*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize)
as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize)
< 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize)
< 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
{
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(66596 as i64 as integer);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66597 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66598 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66599 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(&mut *(self as *mut PortableTexEngine<'_>)).flushmath()?;
danger = true_0 as boolean;
} else if *self
.state
.fontparams
.offset((*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize) < 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize) as i64
== 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset((*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize)
as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize)
< 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize)
< 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
{
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(66600 as i64 as integer);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66601 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66602 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66603 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(&mut *(self as *mut PortableTexEngine<'_>)).flushmath()?;
danger = true_0 as boolean;
}
m = self.state.curlist.modefield as integer;
l_0 = false_0 as boolean;
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zfinmlist(-(268435455 as i64) as halfword)?;
if self.state.curlist.modefield as i32 == -m {
(&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()?;
}
self.state.curmlist = p;
self.state.curstyle = 2 as smallnumber;
self.state.mlistpenalties = false_0 as boolean;
(&mut *(self as *mut PortableTexEngine<'_>)).mlisttohlist()?;
a = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
0 as i32,
1 as i32 as smallnumber,
)?;
(*mem.offset(a as isize)).hh.u.B1 = 2 as i16;
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
self.state.saveptr -= 1;
if (*self
.state
.savestack
.offset((self.state.saveptr as i32 + 0 as i32) as isize))
.u
.CINT == 1 as i32
{
l_0 = true_0 as boolean;
}
danger = false_0 as boolean;
if self.state.curlist.modefield as i32 == 209 as i32 {
j = self.state.curlist.eTeXauxfield;
}
if *self
.state
.fontparams
.offset((*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize)
< 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1206826 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize)
< 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207082 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize)
< 22 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207338 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
{
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(66596 as i64 as integer);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66597 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66598 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66599 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(&mut *(self as *mut PortableTexEngine<'_>)).flushmath()?;
danger = true_0 as boolean;
} else if *self
.state
.fontparams
.offset((*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize)
< 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1206827 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize)
< 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207083 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
|| *self
.state
.fontparams
.offset((*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize)
< 13 as i32
&& !(*self
.state
.fontarea
.offset((*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize)
as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self
.state
.fontlayoutengine
.offset(
(*eqtb.offset(1207339 as i64 as isize)).hh.v.RH as isize,
) as FontHandle,
) != 0)
{
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(66600 as i64 as integer);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66601 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66602 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66603 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(&mut *(self as *mut PortableTexEngine<'_>)).flushmath()?;
danger = true_0 as boolean;
}
m = self.state.curlist.modefield as integer;
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zfinmlist(-(268435455 as i64) as halfword)?;
} else {
a = -(268435455 as i64) as halfword;
}
if m < 0 as i32 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewmath(
(*eqtb.offset(9006720 as i64 as isize)).u.CINT,
0 as i32 as smallnumber,
)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
self.state.curmlist = p;
self.state.curstyle = 2 as smallnumber;
self.state.mlistpenalties = (self.state.curlist.modefield as i32 > 0 as i32)
as i32 as boolean;
(&mut *(self as *mut PortableTexEngine<'_>)).mlisttohlist()?;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (*mem
.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH;
while (*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH as i64
!= -(268435455 as i64)
{
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<'_>))
.znewmath(
(*eqtb.offset(9006720 as i64 as isize)).u.CINT,
1 as i32 as smallnumber,
)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
self.state.curlist.auxfield.hh.v.LH = 1000 as i32 as halfword;
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
} else {
if a as i64 == -(268435455 as i64) {
(&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()?;
}
}
self.state.curmlist = p;
self.state.curstyle = 0 as smallnumber;
self.state.mlistpenalties = false_0 as boolean;
(&mut *(self as *mut PortableTexEngine<'_>)).mlisttohlist()?;
p = (*mem.offset((self.state.memtop as i32 - 3 as i32) as isize)).hh.v.RH;
self.state.adjusttail = (self.state.memtop as i32 - 5 as i32) as halfword;
self.state.preadjusttail = (self.state.memtop as i32 - 14 as i32)
as halfword;
b = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(p, 0 as i32, 1 as i32 as smallnumber)?;
p = (*mem.offset((b as i32 + 5 as i32) as isize)).hh.v.RH;
t = self.state.adjusttail;
self.state.adjusttail = -(268435455 as i64) as halfword;
pret = self.state.preadjusttail;
self.state.preadjusttail = -(268435455 as i64) as halfword;
w = (*mem.offset((b as i32 + 1 as i32) as isize)).u.CINT as scaled;
z = (*eqtb.offset(9006733 as i64 as isize)).u.CINT as scaled;
s = (*eqtb.offset(9006734 as i64 as isize)).u.CINT as scaled;
if (*eqtb.offset(7892330 as i64 as isize)).u.CINT < 0 as i32 {
s = -s - z;
}
if a as i64 == -(268435455 as i64) || danger != 0 {
e = 0 as i32 as scaled;
q = 0 as i32 as scaled;
} else {
e = (*mem.offset((a as i32 + 1 as i32) as isize)).u.CINT as scaled;
q = e + (&mut *(self as *mut PortableTexEngine<'_>)).zmathquad(0 as i32);
}
if w + q > z {
if e != 0 as i32
&& (w - self.state.totalshrink[0 as i32 as usize] + q <= z
|| self.state.totalshrink[1 as i32 as usize] != 0 as i32
|| self.state.totalshrink[2 as i32 as usize] != 0 as i32
|| self.state.totalshrink[3 as i32 as usize] != 0 as i32)
{
(&mut *(self as *mut PortableTexEngine<'_>)).zfreenode(b, 7 as i32);
b = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(p, z - q, 0 as i32 as smallnumber)?;
} else {
e = 0 as i32 as scaled;
if w > z {
(&mut *(self as *mut PortableTexEngine<'_>))
.zfreenode(b, 7 as i32);
b = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(p, z, 0 as i32 as smallnumber)?;
}
}
w = (*mem.offset((b as i32 + 1 as i32) as isize)).u.CINT as scaled;
}
(*mem.offset(b as isize)).hh.u.B1 = 2 as i16;
d = (&mut *(self as *mut PortableTexEngine<'_>)).zhalf(z - w) as scaled;
if e > 0 as i32 && d < 2 as scaled * e {
d = (&mut *(self as *mut PortableTexEngine<'_>)).zhalf(z - w - e)
as scaled;
if p as i64 != -(268435455 as i64) {
if !(p >= self.state.himemmin) {
if (*mem.offset(p as isize)).hh.u.B0 as i32 == 10 as i32 {
d = 0 as i32 as scaled;
}
}
}
}
(*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;
if d + s <= (*eqtb.offset(9006732 as i64 as isize)).u.CINT || l_0 != 0 {
g1 = 3 as smallnumber;
g2 = 4 as smallnumber;
} else {
g1 = 5 as smallnumber;
g2 = 6 as smallnumber;
}
if l_0 != 0 && e == 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zappdisplay(j, a, 0 as i32)?;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewpenalty(10000 as i32)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
} else {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewparamglue(g1)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
}
if e != 0 as i32 {
r = (&mut *(self as *mut PortableTexEngine<'_>))
.znewkern(z - w - e - d)?;
if l_0 != 0 {
(*mem.offset(a as isize)).hh.v.RH = r;
(*mem.offset(r as isize)).hh.v.RH = b;
b = a;
d = 0 as i32 as scaled;
} else {
(*mem.offset(b as isize)).hh.v.RH = r;
(*mem.offset(r as isize)).hh.v.RH = a;
}
b = (&mut *(self as *mut PortableTexEngine<'_>))
.zhpack(b, 0 as i32, 1 as i32 as smallnumber)?;
}
(&mut *(self as *mut PortableTexEngine<'_>)).zappdisplay(j, b, d)?;
if a as i64 != -(268435455 as i64) && e == 0 as i32 && l_0 == 0 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewpenalty(10000 as i32)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
(&mut *(self as *mut PortableTexEngine<'_>))
.zappdisplay(
j,
a,
z as integer
- (*mem.offset((a as i32 + 1 as i32) as isize)).u.CINT,
)?;
g2 = 0 as smallnumber;
}
if t != self.state.memtop as i32 - 5 as i32 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (*mem
.offset((self.state.memtop as i32 - 5 as i32) as isize))
.hh
.v
.RH;
self.state.curlist.tailfield = t;
}
if pret != self.state.memtop as i32 - 14 as i32 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (*mem
.offset((self.state.memtop as i32 - 14 as i32) as isize))
.hh
.v
.RH;
self.state.curlist.tailfield = pret;
}
(*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;
if g2 as i32 > 0 as i32 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewparamglue(g2)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
}
(&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(j)?;
(&mut *(self as *mut PortableTexEngine<'_>)).resumeafterdisplay()?;
};
Ok(())
}
pub(crate) unsafe fn alignerror(&mut self) -> EngineFlow<()> {
if (if self.state.alignstate >= 0 as i32 {
self.state.alignstate
} else {
-self.state.alignstate
}) > 2 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(66549 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintcmdchr(self.state.curcmd as quarterword, self.state.curchr);
if self.state.curtok as i64 == 8388646 as i64 {
self.state.helpptr = 6 as eightbits;
self.state.helpline[5 as i32 as usize] = 66550 as i64 as strnumber;
self.state.helpline[4 as i32 as usize] = 66551 as i64 as strnumber;
self.state.helpline[3 as i32 as usize] = 66552 as i64 as strnumber;
self.state.helpline[2 as i32 as usize] = 66553 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66554 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66555 as i64 as strnumber;
} else {
self.state.helpptr = 5 as eightbits;
self.state.helpline[4 as i32 as usize] = 66550 as i64 as strnumber;
self.state.helpline[3 as i32 as usize] = 66556 as i64 as strnumber;
self.state.helpline[2 as i32 as usize] = 66553 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66554 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66555 as i64 as strnumber;
}
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
if self.state.alignstate < 0 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(65990 as i64 as integer);
self.state.alignstate += 1;
self.state.curtok = 2097275 as i64 as halfword;
} 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(66545 as i64 as integer);
self.state.alignstate -= 1;
self.state.curtok = 4194429 as i64 as halfword;
}
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 66546 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 66547 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66548 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).inserror()?;
};
Ok(())
}
pub(crate) unsafe fn alignpeek(&mut self) -> EngineFlow<()> {
Ok(
loop {
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;
}
}
if self.state.curcmd as i32 == 34 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.znewsavelevel(7 as i32 as groupcode)?;
if self.state.curlist.modefield as i32 == -(1 as i32) {
(&mut *(self as *mut PortableTexEngine<'_>)).normalparagraph()?;
}
break;
} else if self.state.curcmd as i32 == 2 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).finalign()?;
break;
} else {
if self.state.curcmd as i32 == 5 as i32
&& self.state.curchr as i64 == 1114115 as i64
{
continue;
}
(&mut *(self as *mut PortableTexEngine<'_>)).initrow()?;
(&mut *(self as *mut PortableTexEngine<'_>)).initcol()?;
break;
}
},
)
}
pub(crate) unsafe fn alteraux(&mut self) -> EngineFlow<()> {
let mut c_0: halfword = 0;
if self.state.curchr
!= (if self.state.curlist.modefield as integer >= 0 as i32 {
self.state.curlist.modefield as integer
} else {
-(self.state.curlist.modefield as i32)
})
{
(&mut *(self as *mut PortableTexEngine<'_>)).reportillegalcase()?;
} else {
c_0 = self.state.curchr;
(&mut *(self as *mut PortableTexEngine<'_>)).scanoptionalequals()?;
if c_0 == 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen(0 as i32, 0 as i32, 0 as i32)?;
self.state.curlist.auxfield.u.CINT = self.state.curval;
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if self.state.curval <= 0 as i32 || self.state.curval > 32767 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(66669 as i64 as integer);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66670 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>))
.zinterror(self.state.curval)?;
} else {
self.state.curlist.auxfield.hh.v.LH = self.state.curval as halfword;
}
}
};
Ok(())
}
pub(crate) unsafe fn alterboxdimen(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut c_0: smallnumber = 0;
let mut b: halfword = 0;
c_0 = self.state.curchr as smallnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).scanregisternum()?;
if self.state.curval < 256 as i32 {
b = (*eqtb.offset((1206567 as i64 + self.state.curval as i64) as isize))
.hh
.v
.RH;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zfindsaelement(4 as i32 as smallnumber, self.state.curval, 0 as i32)?;
if self.state.curptr as i64 == -(268435455 as i64) {
b = -(268435455 as i64) as halfword;
} else {
b = (*mem.offset((self.state.curptr as i32 + 1 as i32) as isize))
.hh
.v
.RH;
}
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanoptionalequals()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen(0 as i32, 0 as i32, 0 as i32)?;
Ok(
if b as i64 != -(268435455 as i64) {
(*mem.offset((b as i32 + c_0 as i32) as isize)).u.CINT = self
.state
.curval;
},
)
}
pub(crate) unsafe fn alterinteger(&mut self) -> EngineFlow<()> {
let mut c_0: smallnumber = 0;
c_0 = self.state.curchr as smallnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).scanoptionalequals()?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if c_0 as i32 == 0 as i32 {
self.state.deadcycles = self.state.curval;
} else if c_0 as i32 == 2 as i32 {
if self.state.curval < 0 as i32 || self.state.curval > 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(66907 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66908 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66909 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>))
.zinterror(self.state.curval)?;
} else {
self.state.curchr = self.state.curval as halfword;
(&mut *(self as *mut PortableTexEngine<'_>)).newinteraction();
}
} else {
self.state.insertpenalties = self.state.curval;
};
Ok(())
}
pub(crate) unsafe fn alterpagesofar(&mut self) -> EngineFlow<()> {
let mut c_0: eightbits = 0;
c_0 = self.state.curchr as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>)).scanoptionalequals()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen(0 as i32, 0 as i32, 0 as i32)?;
self.state.pagesofar[c_0 as usize] = self.state.curval as scaled;
Ok(())
}
pub(crate) unsafe fn alterprevgraf(&mut self) -> EngineFlow<()> {
let mut p: integer = 0;
*self.state.nest.offset(self.state.nestptr as isize) = self.state.curlist;
p = self.state.nestptr;
while (if (*self.state.nest.offset(p as isize)).modefield as integer >= 0 as i32
{
(*self.state.nest.offset(p as isize)).modefield as integer
} else {
-((*self.state.nest.offset(p as isize)).modefield as i32)
}) != 1 as i32
{
p -= 1;
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanoptionalequals()?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if self.state.curval < 0 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(66391 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(65854 as i64 as strnumber);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66671 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).zinterror(self.state.curval)?;
} else {
(*self.state.nest.offset(p as isize)).pgfield = self.state.curval;
self.state.curlist = *self.state.nest.offset(self.state.nestptr as isize);
};
Ok(())
}
pub(crate) unsafe fn appendchoices(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.newchoice()?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
self.state.saveptr += 1;
(*self.state.savestack.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT = 0 as i32 as integer;
(&mut *(self as *mut PortableTexEngine<'_>)).zpushmath(13 as i32 as groupcode)?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
Ok(())
}
pub(crate) unsafe fn appenddiscretionary(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut c_0: integer = 0;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.newdisc()?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
if self.state.curchr == 1 as i32 {
c_0 = *self
.state
.hyphenchar
.offset((*eqtb.offset(1206823 as i64 as isize)).hh.v.RH as isize);
if c_0 >= 0 as i32 {
if c_0 as i64 <= 65535 as i64 {
(*mem
.offset(
(self.state.curlist.tailfield as i32 + 1 as i32) as isize,
))
.hh
.v
.LH = (&mut *(self as *mut PortableTexEngine<'_>))
.znewcharacter(
(*eqtb.offset(1206823 as i64 as isize)).hh.v.RH,
c_0 as UTF16code,
)?;
}
}
} else {
self.state.saveptr += 1;
(*self
.state
.savestack
.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT = 0 as i32 as integer;
(&mut *(self as *mut PortableTexEngine<'_>))
.znewsavelevel(10 as i32 as groupcode)?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
(&mut *(self as *mut PortableTexEngine<'_>)).pushnest()?;
self.state.curlist.modefield = -(105 as i32) as i16;
self.state.curlist.auxfield.hh.v.LH = 1000 as i32 as halfword;
};
Ok(())
}
pub(crate) unsafe fn appendglue(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut s: smallnumber = 0;
s = self.state.curchr as smallnumber;
match s as i32 {
0 => {
self.state.curval = (self.state.membot as i32 + 4 as i32) as integer;
}
1 => {
self.state.curval = (self.state.membot as i32 + 8 as i32) as integer;
}
2 => {
self.state.curval = (self.state.membot as i32 + 12 as i32) as integer;
}
3 => {
self.state.curval = (self.state.membot as i32 + 16 as i32) as integer;
}
4 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zscanglue(2 as i32 as smallnumber)?;
}
5 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zscanglue(3 as i32 as smallnumber)?;
}
_ => {}
}
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewglue(self.state.curval)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
Ok(
if s as i32 >= 4 as i32 {
let ref mut fresh159 = (*mem.offset(self.state.curval as isize)).hh.v.RH;
*fresh159 -= 1;
if s as i32 > 4 as i32 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1 = 99
as i16;
}
},
)
}
pub(crate) unsafe fn appenditaliccorrection(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
let mut f_0: internalfontnumber = 0;
Ok(
if self.state.curlist.tailfield != self.state.curlist.headfield {
if self.state.curlist.tailfield >= self.state.himemmin {
p = self.state.curlist.tailfield;
} else if (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B0
as i32 == 6 as i32
{
p = (self.state.curlist.tailfield as i32 + 1 as i32) as halfword;
} else if (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B0
as i32 == 8 as i32
{
if (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1
as i32 >= 40 as i32
&& (*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1
as i32 <= 41 as i32
{
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewkern(
Self::native_word_italic_correction(
self as *mut PortableTexEngine<'resources>,
mem.offset(self.state.curlist.tailfield as isize)
as *mut memoryword as *mut (),
) as scaled,
)?;
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 = 1
as i16;
} else if (*mem.offset(self.state.curlist.tailfield as isize))
.hh
.u
.B1 as i32 == 42 as i32
{
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewkern(
Self::native_glyph_italic_correction(
self as *mut PortableTexEngine<'resources>,
mem.offset(self.state.curlist.tailfield as isize)
as *mut memoryword as *mut (),
) as scaled,
)?;
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 = 1
as i16;
}
return Ok(());
} else {
return Ok(());
}
f_0 = (*mem.offset(p as isize)).hh.u.B0 as internalfontnumber;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewkern(
(*self
.state
.fontinfo
.offset(
(*self.state.italicbase.offset(f_0 as isize) as i32
+ ((*self
.state
.fontinfo
.offset(
(*self.state.charbase.offset(f_0 as isize)
+ (&mut *(self as *mut PortableTexEngine<'_>))
.zeffectivechar(
1 as i32,
f_0,
(*mem.offset(p as isize)).hh.u.B1 as quarterword,
)) as isize,
))
.v
.QQQQ
.u
.B2) as i32 as i32 / 4 as i32) 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.u.B1 = 1 as i16;
},
)
}
pub(crate) unsafe fn appendkern(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut s: quarterword = 0;
s = self.state.curchr as quarterword;
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen((s as i32 == 99 as i32) as i32, 0 as i32, 0 as i32)?;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewkern(self.state.curval)?;
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 = s as i16;
Ok(())
}
pub(crate) unsafe fn appendpenalty(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.znewpenalty(self.state.curval)?;
self.state.curlist.tailfield = (*mem
.offset(self.state.curlist.tailfield as isize))
.hh
.v
.RH;
Ok(
if self.state.curlist.modefield as i32 == 1 as i32 {
Self::boundary_build_page(self as *mut PortableTexEngine<'_>);
},
)
}
pub(crate) unsafe fn appendsrcspecial(&mut self) -> EngineFlow<()> {
Self::record_stripped_source_special(self as *mut PortableTexEngine<'_>);
Ok(())
}
pub(crate) unsafe fn appspace(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut q: halfword = 0;
if self.state.curlist.auxfield.hh.v.LH >= 2000 as i32
&& (*eqtb.offset(1205777 as i64 as isize)).hh.v.RH != self.state.membot
{
q = (&mut *(self as *mut PortableTexEngine<'_>))
.znewparamglue(13 as i32 as smallnumber)?;
} else {
if (*eqtb.offset(1205776 as i64 as isize)).hh.v.RH != self.state.membot {
self.state.mainp = (*eqtb.offset(1205776 as i64 as isize)).hh.v.RH;
} else {
self.state.mainp = *self
.state
.fontglue
.offset((*eqtb.offset(1206823 as i64 as isize)).hh.v.RH as isize);
if self.state.mainp as i64 == -(268435455 as i64) {
self.state.mainp = (&mut *(self as *mut PortableTexEngine<'_>))
.znewspec(self.state.membot)?;
self.state.maink = (*self
.state
.parambase
.offset((*eqtb.offset(1206823 as i64 as isize)).hh.v.RH as isize)
as i32 + 2 as i32) as fontindex;
(*mem.offset((self.state.mainp as i32 + 1 as i32) as isize))
.u
.CINT = (*self.state.fontinfo.offset(self.state.maink as isize))
.u
.CINT;
(*mem.offset((self.state.mainp as i32 + 2 as i32) as isize))
.u
.CINT = (*self
.state
.fontinfo
.offset((self.state.maink as i32 + 1 as i32) as isize))
.u
.CINT;
(*mem.offset((self.state.mainp as i32 + 3 as i32) as isize))
.u
.CINT = (*self
.state
.fontinfo
.offset((self.state.maink as i32 + 2 as i32) as isize))
.u
.CINT;
*self
.state
.fontglue
.offset(
(*eqtb.offset(1206823 as i64 as isize)).hh.v.RH as isize,
) = self.state.mainp;
}
}
self.state.mainp = (&mut *(self as *mut PortableTexEngine<'_>))
.znewspec(self.state.mainp)?;
if self.state.curlist.auxfield.hh.v.LH >= 2000 as i32 {
(*mem.offset((self.state.mainp as i32 + 1 as i32) as isize)).u.CINT = (*mem
.offset((self.state.mainp as i32 + 1 as i32) as isize))
.u
.CINT
+ (*self
.state
.fontinfo
.offset(
(7 as integer
+ *self
.state
.parambase
.offset(
(*eqtb.offset(1206823 as i64 as isize)).hh.v.RH as isize,
)) as isize,
))
.u
.CINT;
}
(*mem.offset((self.state.mainp as i32 + 2 as i32) as isize)).u.CINT = (&mut *(self
as *mut PortableTexEngine<'_>))
.zxnoverd(
(*mem.offset((self.state.mainp as i32 + 2 as i32) as isize)).u.CINT,
self.state.curlist.auxfield.hh.v.LH,
1000 as i32,
) as integer;
(*mem.offset((self.state.mainp as i32 + 3 as i32) as isize)).u.CINT = (&mut *(self
as *mut PortableTexEngine<'_>))
.zxnoverd(
(*mem.offset((self.state.mainp as i32 + 3 as i32) as isize)).u.CINT,
1000 as i32,
self.state.curlist.auxfield.hh.v.LH,
) as integer;
q = (&mut *(self as *mut PortableTexEngine<'_>)).znewglue(self.state.mainp)?;
(*mem.offset(self.state.mainp as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
}
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = q;
self.state.curlist.tailfield = q;
Ok(())
}
}