#![allow(dead_code, non_camel_case_types, non_snake_case, unused_assignments, unused_must_use, unused_mut, unused_variables)]
use crate::runtime::*;
impl<'resources> PortableTexEngine<'resources> {
pub(crate) unsafe fn backerror(&mut self) -> EngineFlow<()> {
self.state.OKtointerrupt = false_0 as boolean;
(&mut *(self as *mut PortableTexEngine<'_>)).backinput()?;
self.state.OKtointerrupt = true_0 as boolean;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
Ok(())
}
pub(crate) unsafe fn backinput(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
while self.state.curinput.locfield as i64 == -(268435455 as i64)
&& self.state.curinput.indexfield as i32 != 2 as i32
&& self.state.curinput.indexfield as i32 != 7 as i32
{
(&mut *(self as *mut PortableTexEngine<'_>)).endtokenlist()?;
}
p = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()?;
(*mem.offset(p as isize)).hh.v.LH = self.state.curtok;
Self::src_back_input_stamp(self as *mut PortableTexEngine<'_>, p);
if (self.state.curtok as i64) < 6291456 as i64 {
if (self.state.curtok as i64) < 4194304 as i64 {
self.state.alignstate -= 1;
} else {
self.state.alignstate += 1;
}
}
if self.state.inputptr > self.state.maxinstack {
self.state.maxinstack = self.state.inputptr;
if self.state.inputptr == self.state.stacksize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(65921 as i64 as strnumber, self.state.stacksize)?
{};
}
}
*self.state.inputstack.offset(self.state.inputptr as isize) = self
.state
.curinput;
self.state.inputptr += 1;
self.state.curinput.statefield = 0 as quarterword;
self.state.curinput.startfield = p;
self.state.curinput.indexfield = 3 as quarterword;
self.state.curinput.locfield = p;
Ok(())
}
pub(crate) unsafe fn begindiagnostic(&mut self) {
let eqtb = self.state.zeqtb.as_mut_ptr();
self.state.oldsetting = self.state.selector;
if (*eqtb.offset(7892293 as i64 as isize)).u.CINT <= 0 as i32
&& self.state.selector as i32 == 19 as i32
{
self.state.selector = self.state.selector.wrapping_sub(1);
if self.state.history as i32 == 0 as i32 {
self.state.history = 1 as eightbits;
}
}
}
pub(crate) unsafe fn beginfilereading(&mut self) -> EngineFlow<()> {
if self.state.inopen == self.state.maxinopen {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(65925 as i64 as strnumber, self.state.maxinopen)?
{};
}
if self.state.first == self.state.bufsize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(65538 as i64 as strnumber, self.state.bufsize)?
{};
}
self.state.inopen += 1;
if self.state.inputptr > self.state.maxinstack {
self.state.maxinstack = self.state.inputptr;
if self.state.inputptr == self.state.stacksize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(65921 as i64 as strnumber, self.state.stacksize)?
{};
}
}
*self.state.inputstack.offset(self.state.inputptr as isize) = self
.state
.curinput;
self.state.inputptr += 1;
self.state.curinput.indexfield = self.state.inopen as quarterword;
*self
.state
.sourcefilenamestack
.offset(self.state.curinput.indexfield as isize) = 0 as i32 as strnumber;
*self
.state
.fullsourcefilenamestack
.offset(self.state.curinput.indexfield as isize) = 0 as i32 as strnumber;
*self.state.eofseen.offset(self.state.curinput.indexfield as isize) = false_0
as boolean;
*self.state.grpstack.offset(self.state.curinput.indexfield as isize) = self
.state
.curboundary as savepointer;
*self.state.ifstack.offset(self.state.curinput.indexfield as isize) = self
.state
.condptr;
*self.state.linestack.offset(self.state.curinput.indexfield as isize) = self
.state
.line;
self.state.curinput.startfield = self.state.first as halfword;
self.state.curinput.statefield = 1 as quarterword;
self.state.curinput.namefield = 0 as i32 as halfword;
Ok(())
}
pub(crate) unsafe fn begininsertoradjust(&mut self) -> EngineFlow<()> {
if self.state.curcmd as i32 == 38 as i32 {
self.state.curval = 255 as i32 as integer;
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).scaneightbitint()?;
if self.state.curval == 255 as i32 {
self.state.interaction 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(66519 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(65618 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>)).zprintint(255 as i32);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66520 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
self.state.curval = 0 as i32 as integer;
}
}
(*self.state.savestack.offset((self.state.saveptr as i32 + 0 as i32) as isize))
.u
.CINT = self.state.curval;
if self.state.curcmd as i32 == 38 as i32
&& (&mut *(self as *mut PortableTexEngine<'_>))
.zscankeyword(66521 as i64 as strnumber)? != 0
{
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 1 as i32) as isize))
.u
.CINT = 1 as i32 as integer;
} else {
(*self
.state
.savestack
.offset((self.state.saveptr as i32 + 1 as i32) as isize))
.u
.CINT = 0 as i32 as integer;
}
self.state.saveptr = (self.state.saveptr as i32 + 2 as i32) as integer;
(&mut *(self as *mut PortableTexEngine<'_>))
.znewsavelevel(11 as i32 as groupcode)?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
(&mut *(self as *mut PortableTexEngine<'_>)).normalparagraph()?;
(&mut *(self as *mut PortableTexEngine<'_>)).pushnest()?;
self.state.curlist.modefield = -(1 as i32) as i16;
self.state.curlist.auxfield.u.CINT = -(65536000 as i64) as integer;
Ok(())
}
pub(crate) unsafe fn beginname(&mut self) {
self.state.areadelimiter = 0 as i32 as poolpointer;
self.state.extdelimiter = 0 as i32 as poolpointer;
self.state.quotedfilename = false_0 as boolean;
self.state.filenamequotechar = 0 as UTF16code;
}
pub(crate) unsafe fn bigopspacing1(&mut self) -> scaled {
let mut Result: scaled = 0;
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut f_0: integer = 0;
let mut rval: scaled = 0;
f_0 = (*eqtb.offset((1206827 as i64 + self.state.cursize as i64) as isize))
.hh
.v
.RH as integer;
if *self.state.fontarea.offset(f_0 as isize) as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self.state.fontlayoutengine.offset(f_0 as isize) as FontHandle,
) != 0
{
rval = Self::get_native_mathex_parameter(
self as *mut PortableTexEngine<'resources>,
f_0 as i32,
9 as i32,
) as scaled;
} else {
rval = (*self
.state
.fontinfo
.offset(
(9 as integer + *self.state.parambase.offset(f_0 as isize)) as isize,
))
.u
.CINT as scaled;
}
Result = rval;
return Result;
}
pub(crate) unsafe fn bigopspacing2(&mut self) -> scaled {
let mut Result: scaled = 0;
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut f_0: integer = 0;
let mut rval: scaled = 0;
f_0 = (*eqtb.offset((1206827 as i64 + self.state.cursize as i64) as isize))
.hh
.v
.RH as integer;
if *self.state.fontarea.offset(f_0 as isize) as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self.state.fontlayoutengine.offset(f_0 as isize) as FontHandle,
) != 0
{
rval = Self::get_native_mathex_parameter(
self as *mut PortableTexEngine<'resources>,
f_0 as i32,
10 as i32,
) as scaled;
} else {
rval = (*self
.state
.fontinfo
.offset(
(10 as integer + *self.state.parambase.offset(f_0 as isize)) as isize,
))
.u
.CINT as scaled;
}
Result = rval;
return Result;
}
pub(crate) unsafe fn bigopspacing3(&mut self) -> scaled {
let mut Result: scaled = 0;
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut f_0: integer = 0;
let mut rval: scaled = 0;
f_0 = (*eqtb.offset((1206827 as i64 + self.state.cursize as i64) as isize))
.hh
.v
.RH as integer;
if *self.state.fontarea.offset(f_0 as isize) as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self.state.fontlayoutengine.offset(f_0 as isize) as FontHandle,
) != 0
{
rval = Self::get_native_mathex_parameter(
self as *mut PortableTexEngine<'resources>,
f_0 as i32,
11 as i32,
) as scaled;
} else {
rval = (*self
.state
.fontinfo
.offset(
(11 as integer + *self.state.parambase.offset(f_0 as isize)) as isize,
))
.u
.CINT as scaled;
}
Result = rval;
return Result;
}
pub(crate) unsafe fn bigopspacing4(&mut self) -> scaled {
let mut Result: scaled = 0;
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut f_0: integer = 0;
let mut rval: scaled = 0;
f_0 = (*eqtb.offset((1206827 as i64 + self.state.cursize as i64) as isize))
.hh
.v
.RH as integer;
if *self.state.fontarea.offset(f_0 as isize) as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self.state.fontlayoutengine.offset(f_0 as isize) as FontHandle,
) != 0
{
rval = Self::get_native_mathex_parameter(
self as *mut PortableTexEngine<'resources>,
f_0 as i32,
12 as i32,
) as scaled;
} else {
rval = (*self
.state
.fontinfo
.offset(
(12 as integer + *self.state.parambase.offset(f_0 as isize)) as isize,
))
.u
.CINT as scaled;
}
Result = rval;
return Result;
}
pub(crate) unsafe fn bigopspacing5(&mut self) -> scaled {
let mut Result: scaled = 0;
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut f_0: integer = 0;
let mut rval: scaled = 0;
f_0 = (*eqtb.offset((1206827 as i64 + self.state.cursize as i64) as isize))
.hh
.v
.RH as integer;
if *self.state.fontarea.offset(f_0 as isize) as i64 == 65534 as i64
&& Self::is_opentype_math_font(
self as *mut PortableTexEngine<'_>,
*self.state.fontlayoutengine.offset(f_0 as isize) as FontHandle,
) != 0
{
rval = Self::get_native_mathex_parameter(
self as *mut PortableTexEngine<'resources>,
f_0 as i32,
13 as i32,
) as scaled;
} else {
rval = (*self
.state
.fontinfo
.offset(
(13 as integer + *self.state.parambase.offset(f_0 as isize)) as isize,
))
.u
.CINT as scaled;
}
Result = rval;
return Result;
}
pub(crate) unsafe fn buildchoices(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zfinmlist(-(268435455 as i64) as halfword)?;
match (*self
.state
.savestack
.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT
{
0 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.v
.LH = p;
}
1 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.v
.RH = p;
}
2 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 2 as i32) as isize))
.hh
.v
.LH = p;
}
3 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 2 as i32) as isize))
.hh
.v
.RH = p;
self.state.saveptr -= 1;
return Ok(());
}
_ => {}
}
let ref mut fresh170 = (*self
.state
.savestack
.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT;
*fresh170 += 1;
(&mut *(self as *mut PortableTexEngine<'_>)).zpushmath(13 as i32 as groupcode)?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
Ok(())
}
pub(crate) unsafe fn builddiscretionary(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
let mut q: halfword = 0;
let mut n: integer = 0;
(&mut *(self as *mut PortableTexEngine<'_>)).unsave()?;
q = self.state.curlist.headfield;
p = (*mem.offset(q as isize)).hh.v.RH;
n = 0 as i32 as integer;
while p as i64 != -(268435455 as i64) {
if !(p >= self.state.himemmin) {
if (*mem.offset(p as isize)).hh.u.B0 as i32 > 2 as i32 {
if (*mem.offset(p as isize)).hh.u.B0 as i32 != 11 as i32 {
if (*mem.offset(p as isize)).hh.u.B0 as i32 != 6 as i32 {
if (*mem.offset(p as isize)).hh.u.B0 as i32 != 8 as i32
|| !((*mem.offset(p as isize)).hh.u.B1 as i32 >= 40 as i32
&& (*mem.offset(p as isize)).hh.u.B1 as i32 <= 41 as i32)
&& (*mem.offset(p as isize)).hh.u.B1 as i32 != 42 as i32
{
self.state.interaction 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(66542 as i64 as integer);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66543 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.begindiagnostic();
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintnl(66544 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>)).zshowbox(p);
(&mut *(self as *mut PortableTexEngine<'_>))
.zenddiagnostic(1 as i32);
(&mut *(self as *mut PortableTexEngine<'_>))
.zflushnodelist(p)?;
(*mem.offset(q as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
break;
}
}
}
}
}
q = p;
p = (*mem.offset(q as isize)).hh.v.RH;
n += 1;
}
p = (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH;
(&mut *(self as *mut PortableTexEngine<'_>)).popnest();
match (*self
.state
.savestack
.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT
{
0 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.v
.LH = p;
}
1 => {
(*mem.offset((self.state.curlist.tailfield as i32 + 1 as i32) as isize))
.hh
.v
.RH = p;
}
2 => {
if n > 0 as i32
&& (if self.state.curlist.modefield as integer >= 0 as i32 {
self.state.curlist.modefield as integer
} else {
-(self.state.curlist.modefield as i32)
}) == 209 as i32
{
self.state.interaction 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(66536 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(65639 as i64 as strnumber);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66537 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66538 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(p)?;
n = 0 as i32 as integer;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
} else {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.v.RH = p;
}
if n as i64 <= 65535 as i64 {
(*mem.offset(self.state.curlist.tailfield as isize)).hh.u.B1 = n
as i16;
} else {
self.state.interaction 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(66539 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66540 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66541 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
}
if n > 0 as i32 {
self.state.curlist.tailfield = q;
}
self.state.saveptr -= 1;
return Ok(());
}
_ => {}
}
let ref mut fresh164 = (*self
.state
.savestack
.offset((self.state.saveptr as i32 - 1 as i32) as isize))
.u
.CINT;
*fresh164 += 1;
(&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(())
}
}