#![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 checkoutervalidity(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
let mut q: halfword = 0;
Ok(
if self.state.scannerstatus as i32 != 0 as i32 {
self.state.deletionsallowed = false_0 as boolean;
if self.state.curcs != 0 as i32 {
if self.state.curinput.statefield as i32 == 0 as i32
|| self.state.curinput.namefield < 1 as i32
|| self.state.curinput.namefield > 17 as i32
{
p = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()?;
(*mem.offset(p as isize)).hh.v.LH = (33554431 as i64
+ self.state.curcs as i64) as halfword;
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(p, 3 as i32 as quarterword)?;
}
self.state.curcmd = 10 as eightbits;
self.state.curchr = 32 as i32 as halfword;
}
if self.state.scannerstatus as i32 > 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).runaway();
if self.state.curcs == 0 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(65933 as i64 as integer);
} else {
self.state.curcs = 0 as i32 as halfword;
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(65934 as i64 as integer);
}
p = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()?;
match self.state.scannerstatus as i32 {
2 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65940 as i64 as integer);
(*mem.offset(p as isize)).hh.v.LH = 4194429 as i64
as halfword;
}
3 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65941 as i64 as integer);
(*mem.offset(p as isize)).hh.v.LH = self.state.partoken;
self.state.longstate = 116 as eightbits;
}
4 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65942 as i64 as integer);
(*mem.offset(p as isize)).hh.v.LH = 4194429 as i64
as halfword;
q = p;
p = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()?;
(*mem.offset(p as isize)).hh.v.RH = q;
(*mem.offset(p as isize)).hh.v.LH = 34749082 as i64
as halfword;
self.state.alignstate = -(1000000 as i64) as integer;
}
5 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65943 as i64 as integer);
(*mem.offset(p as isize)).hh.v.LH = 4194429 as i64
as halfword;
}
_ => {}
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(p, 5 as i32 as quarterword)?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65935 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zsprintcs(self.state.warningindex);
self.state.helpptr = 4 as eightbits;
self.state.helpline[3 as i32 as usize] = 65936 as i64 as strnumber;
self.state.helpline[2 as i32 as usize] = 65937 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 65938 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 65939 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
} 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(65927 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintcmdchr(
108 as i32 as quarterword,
self.state.curif as halfword,
);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65928 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(self.state.skipline);
self.state.helpptr = 3 as eightbits;
self.state.helpline[2 as i32 as usize] = 65929 as i64 as strnumber;
self.state.helpline[1 as i32 as usize] = 65930 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 65931 as i64 as strnumber;
if self.state.curcs != 0 as i32 {
self.state.curcs = 0 as i32 as halfword;
} else {
self.state.helpline[2 as i32 as usize] = 65932 as i64
as strnumber;
}
self.state.curtok = 34749085 as i64 as halfword;
(&mut *(self as *mut PortableTexEngine<'_>)).inserror()?;
}
self.state.deletionsallowed = true_0 as boolean;
},
)
}
pub(crate) unsafe fn clearforerrorprompt(&mut self) {
while self.state.curinput.statefield as i32 != 0 as i32
&& self.state.curinput.namefield == 0 as i32
&& self.state.inputptr > 0 as i32
&& self.state.curinput.locfield > self.state.curinput.limitfield
{
(&mut *(self as *mut PortableTexEngine<'_>)).endfilereading();
}
(&mut *(self as *mut PortableTexEngine<'_>)).println();
}
pub(crate) unsafe fn comparestrings(&mut self) -> EngineFlow<()> {
let mut current_block: u64;
let mut s1: strnumber = 0;
let mut s2: strnumber = 0;
let mut i1: poolpointer = 0;
let mut i2: poolpointer = 0;
let mut j1: poolpointer = 0;
let mut j2: poolpointer = 0;
let mut savecurcs: halfword = 0;
savecurcs = self.state.curcs;
(&mut *(self as *mut PortableTexEngine<'_>)).zscantoks(0 as i32, 1 as i32)?
!= 0 as i32;
s1 = (&mut *(self as *mut PortableTexEngine<'_>))
.ztokenstostring(self.state.defref)?;
(&mut *(self as *mut PortableTexEngine<'_>)).zdeletetokenref(self.state.defref);
self.state.curcs = savecurcs;
(&mut *(self as *mut PortableTexEngine<'_>)).zscantoks(0 as i32, 1 as i32)?
!= 0 as i32;
s2 = (&mut *(self as *mut PortableTexEngine<'_>))
.ztokenstostring(self.state.defref)?;
(&mut *(self as *mut PortableTexEngine<'_>)).zdeletetokenref(self.state.defref);
i1 = *self.state.strstart.offset((s1 as i64 - 65536 as i64) as isize);
j1 = *self
.state
.strstart
.offset(((s1 as i32 + 1 as i32) as i64 - 65536 as i64) as isize);
i2 = *self.state.strstart.offset((s2 as i64 - 65536 as i64) as isize);
j2 = *self
.state
.strstart
.offset(((s2 as i32 + 1 as i32) as i64 - 65536 as i64) as isize);
loop {
if !(i1 < j1 && i2 < j2) {
current_block = 15904375183555213903;
break;
}
if (*self.state.strpool.offset(i1 as isize) as i32)
< *self.state.strpool.offset(i2 as isize) as i32
{
self.state.curval = -(1 as i32) as integer;
current_block = 14100365350643794593;
break;
} else if *self.state.strpool.offset(i1 as isize) as i32
> *self.state.strpool.offset(i2 as isize) as i32
{
self.state.curval = 1 as i32 as integer;
current_block = 14100365350643794593;
break;
} else {
i1 += 1;
i2 += 1;
}
}
match current_block {
15904375183555213903 => {
if i1 == j1 && i2 == j2 {
self.state.curval = 0 as i32 as integer;
} else if i1 < j1 {
self.state.curval = 1 as i32 as integer;
} else {
self.state.curval = -(1 as i32) as integer;
}
}
_ => {}
}
(&mut *(self as *mut PortableTexEngine<'_>)).zflushstr(s2);
(&mut *(self as *mut PortableTexEngine<'_>)).zflushstr(s1);
self.state.curvallevel = 0 as eightbits;
Ok(())
}
pub(crate) unsafe fn conditional(&mut self) -> EngineFlow<()> {
let mut current_block: u64;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut b: boolean = 0;
let mut e: boolean = 0;
let mut r: eightbits = 0;
let mut m: integer = 0;
let mut n: integer = 0;
let mut p: halfword = 0;
let mut q: halfword = 0;
let mut savescannerstatus: smallnumber = 0;
let mut savecondptr: halfword = 0;
let mut thisif: smallnumber = 0;
let mut isunless: boolean = 0;
if (*eqtb.offset(7892327 as i64 as isize)).u.CINT > 0 as i32 {
if (*eqtb.offset(7892300 as i64 as isize)).u.CINT <= 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).showcurcmdchr();
}
}
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(2 as i32)?;
(*mem.offset(p as isize)).hh.v.RH = self.state.condptr;
(*mem.offset(p as isize)).hh.u.B0 = self.state.iflimit as i16;
(*mem.offset(p as isize)).hh.u.B1 = self.state.curif as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT = self.state.ifline;
self.state.condptr = p;
self.state.curif = self.state.curchr as smallnumber;
self.state.iflimit = 1 as eightbits;
self.state.ifline = self.state.line;
savecondptr = self.state.condptr;
isunless = (self.state.curchr >= 32 as i32) as i32 as boolean;
thisif = (self.state.curchr as i32 % 32 as i32) as smallnumber;
match thisif as i32 {
0 | 1 => {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
if self.state.curcmd as i32 == 0 as i32 {
if self.state.curchr as i64 == 1114113 as i64 {
self.state.curcmd = 13 as eightbits;
self.state.curchr = (self.state.curtok as i64 - 33554432 as i64)
as halfword;
}
}
if self.state.curcmd as i32 > 13 as i32
|| self.state.curchr as i64 > 1114111 as i64
{
m = 0 as i32 as integer;
n = 1114112 as i64 as integer;
} else {
m = self.state.curcmd as integer;
n = self.state.curchr as integer;
}
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
if self.state.curcmd as i32 == 0 as i32 {
if self.state.curchr as i64 == 1114113 as i64 {
self.state.curcmd = 13 as eightbits;
self.state.curchr = (self.state.curtok as i64 - 33554432 as i64)
as halfword;
}
}
if self.state.curcmd as i32 > 13 as i32
|| self.state.curchr as i64 > 1114111 as i64
{
self.state.curcmd = 0 as eightbits;
self.state.curchr = 1114112 as i64 as halfword;
}
if thisif as i32 == 0 as i32 {
b = (n == self.state.curchr) as i32 as boolean;
} else {
b = (m == self.state.curcmd as i32) as i32 as boolean;
}
current_block = 12153365054289215322;
}
2 | 3 => {
if thisif as i32 == 2 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen(0 as i32, 0 as i32, 0 as i32)?;
}
n = self.state.curval;
loop {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
if self.state.curcmd as i32 != 10 as i32 {
break;
}
}
if self.state.curtok as i64 >= 25165884 as i64
&& self.state.curtok as i64 <= 25165886 as i64
{
r = (self.state.curtok as i64 - 25165824 as i64) as eightbits;
} 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(66172 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintcmdchr(108 as i32 as quarterword, thisif as halfword);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66173 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).backerror()?;
r = 61 as eightbits;
}
if thisif as i32 == 2 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zscandimen(0 as i32, 0 as i32, 0 as i32)?;
}
match r as i32 {
60 => {
b = (n < self.state.curval) as i32 as boolean;
}
61 => {
b = (n == self.state.curval) as i32 as boolean;
}
62 => {
b = (n > self.state.curval) as i32 as boolean;
}
_ => {}
}
current_block = 12153365054289215322;
}
4 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
b = (self.state.curval as i32 & 1 as i32) as boolean;
current_block = 12153365054289215322;
}
5 => {
b = ((if self.state.curlist.modefield as integer >= 0 as i32 {
self.state.curlist.modefield as integer
} else {
-(self.state.curlist.modefield as i32)
}) == 1 as i32) as i32 as boolean;
current_block = 12153365054289215322;
}
6 => {
b = ((if self.state.curlist.modefield as integer >= 0 as i32 {
self.state.curlist.modefield as integer
} else {
-(self.state.curlist.modefield as i32)
}) == 105 as i32) as i32 as boolean;
current_block = 12153365054289215322;
}
7 => {
b = ((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) as i32 as boolean;
current_block = 12153365054289215322;
}
8 => {
b = ((self.state.curlist.modefield as i32) < 0 as i32) as i32 as boolean;
current_block = 12153365054289215322;
}
9 | 10 | 11 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanregisternum()?;
if self.state.curval < 256 as i32 {
p = (*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) {
p = -(268435455 as i64) as halfword;
} else {
p = (*mem.offset((self.state.curptr as i32 + 1 as i32) as isize))
.hh
.v
.RH;
}
}
if thisif as i32 == 9 as i32 {
b = (p as i64 == -(268435455 as i64)) as i32 as boolean;
} else if p as i64 == -(268435455 as i64) {
b = false_0 as boolean;
} else if thisif as i32 == 10 as i32 {
b = ((*mem.offset(p as isize)).hh.u.B0 as i32 == 0 as i32) as i32
as boolean;
} else {
b = ((*mem.offset(p as isize)).hh.u.B0 as i32 == 1 as i32) as i32
as boolean;
}
current_block = 12153365054289215322;
}
12 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
self.state.scannerstatus = 0 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>)).getnext()?;
n = self.state.curcs as integer;
p = self.state.curcmd as halfword;
q = self.state.curchr;
(&mut *(self as *mut PortableTexEngine<'_>)).getnext()?;
if self.state.curcmd as i32 != p {
b = false_0 as boolean;
} else if (self.state.curcmd as i32) < 114 as i32 {
b = (self.state.curchr == q) as i32 as boolean;
} else {
p = (*mem.offset(self.state.curchr as isize)).hh.v.RH;
q = (*mem.offset((*eqtb.offset(n as isize)).hh.v.RH as isize))
.hh
.v
.RH;
if p == q {
b = true_0 as boolean;
} else {
while p as i64 != -(268435455 as i64)
&& q as i64 != -(268435455 as i64)
{
if (*mem.offset(p as isize)).hh.v.LH
!= (*mem.offset(q as isize)).hh.v.LH
{
p = -(268435455 as i64) as halfword;
} else {
p = (*mem.offset(p as isize)).hh.v.RH;
q = (*mem.offset(q as isize)).hh.v.RH;
}
}
b = (p as i64 == -(268435455 as i64)
&& q as i64 == -(268435455 as i64)) as i32 as boolean;
}
}
self.state.scannerstatus = savescannerstatus as eightbits;
current_block = 12153365054289215322;
}
13 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfourbitintor18()?;
if self.state.curval == 18 as i32 {
b = (self.state.shellenabledp == 0) as i32 as boolean;
} else {
b = (self.state.readopen[self.state.curval as usize] as i32
== 2 as i32) as i32 as boolean;
}
current_block = 12153365054289215322;
}
14 => {
b = true_0 as boolean;
current_block = 12153365054289215322;
}
15 => {
b = false_0 as boolean;
current_block = 12153365054289215322;
}
17 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
self.state.scannerstatus = 0 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>)).getnext()?;
b = (self.state.curcmd as i32 != 104 as i32) as i32 as boolean;
self.state.scannerstatus = savescannerstatus as eightbits;
current_block = 12153365054289215322;
}
18 => {
n = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()? as integer;
p = n as halfword;
e = self.state.isincsname;
self.state.isincsname = true_0 as boolean;
loop {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
if self.state.curcs == 0 as i32 {
q = (&mut *(self as *mut PortableTexEngine<'_>)).getavail()?;
(*mem.offset(p as isize)).hh.v.RH = q;
(*mem.offset(q as isize)).hh.v.LH = self.state.curtok;
p = q;
}
if self.state.curcs != 0 as i32 {
break;
}
}
if self.state.curcmd as i32 != 67 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(65958 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(65818 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65959 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 65960 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 65961 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).backerror()?;
}
m = self.state.first;
p = (*mem.offset(n as isize)).hh.v.RH;
while p as i64 != -(268435455 as i64) {
if m >= self.state.maxbufstack {
self.state.maxbufstack = (m as i32 + 1 as i32) as integer;
if self.state.maxbufstack == self.state.bufsize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(65538 as i64 as strnumber, self.state.bufsize)?
{};
}
}
*self.state.buffer.offset(m as isize) = ((*mem.offset(p as isize))
.hh
.v
.LH as i64 % 2097152 as i64) as UnicodeScalar;
m += 1;
p = (*mem.offset(p as isize)).hh.v.RH;
}
if m > self.state.first as i32 + 1 as i32 {
self.state.curcs = (&mut *(self as *mut PortableTexEngine<'_>))
.zidlookup(self.state.first, m - self.state.first)?;
} else if m == self.state.first {
self.state.curcs = 1179649 as i64 as halfword;
} else {
self.state.curcs = (1114113 as i64
+ *self.state.buffer.offset(self.state.first as isize) as i64)
as halfword;
}
(&mut *(self as *mut PortableTexEngine<'_>)).zflushlist(n);
b = ((*eqtb.offset(self.state.curcs as isize)).hh.u.B0 as i32
!= 104 as i32) as i32 as boolean;
self.state.isincsname = e;
current_block = 12153365054289215322;
}
20 => {
b = self.state.isincsname;
current_block = 12153365054289215322;
}
19 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
n = self.state.curval;
(&mut *(self as *mut PortableTexEngine<'_>)).scanusvnum()?;
if *self.state.fontarea.offset(n as isize) as i64 == 65535 as i64
|| *self.state.fontarea.offset(n as isize) as i64 == 65534 as i64
{
b = (Self::map_char_to_glyph(
self as *mut PortableTexEngine<'_>,
n,
self.state.curval,
) > 0 as i32) as i32 as boolean;
} else if *self.state.fontbc.offset(n as isize) as i32
<= self.state.curval
&& *self.state.fontec.offset(n as isize) as i32 >= self.state.curval
{
b = (((*self
.state
.fontinfo
.offset(
(*self.state.charbase.offset(n as isize)
+ (&mut *(self as *mut PortableTexEngine<'_>))
.zeffectivechar(
1 as i32,
n,
self.state.curval as quarterword,
)) as isize,
))
.v
.QQQQ
.u
.B0) as i32 as i32 > 0 as i32) as i32 as boolean;
} else {
b = false_0 as boolean;
}
current_block = 12153365054289215322;
}
16 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
n = self.state.curval;
if (*eqtb.offset(7892300 as i64 as isize)).u.CINT > 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).begindiagnostic();
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66174 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>)).zprintint(n);
(&mut *(self as *mut PortableTexEngine<'_>)).zprintchar(125 as i32);
(&mut *(self as *mut PortableTexEngine<'_>))
.zenddiagnostic(0 as i32);
}
loop {
if !(n != 0 as i32) {
current_block = 9813323123434505723;
break;
}
(&mut *(self as *mut PortableTexEngine<'_>)).passtext()?;
if self.state.condptr == savecondptr {
if !(self.state.curchr == 4 as i32) {
current_block = 8312596395636614680;
break;
}
n -= 1;
} else if self.state.curchr == 2 as i32 {
if *self.state.ifstack.offset(self.state.inopen as isize)
== self.state.condptr
{
(&mut *(self as *mut PortableTexEngine<'_>)).ifwarning();
}
p = self.state.condptr;
self.state.ifline = (*mem.offset((p as i32 + 1 as i32) as isize))
.u
.CINT;
self.state.curif = (*mem.offset(p as isize)).hh.u.B1
as smallnumber;
self.state.iflimit = (*mem.offset(p as isize)).hh.u.B0
as eightbits;
self.state.condptr = (*mem.offset(p as isize)).hh.v.RH;
(&mut *(self as *mut PortableTexEngine<'_>))
.zfreenode(p, 2 as i32);
}
}
match current_block {
8312596395636614680 => {}
_ => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zchangeiflimit(4 as i32 as smallnumber, savecondptr)?;
return Ok(());
}
}
}
21 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
self.state.scannerstatus = 0 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>)).getnext()?;
self.state.scannerstatus = savescannerstatus as eightbits;
if (self.state.curcs as i64) < 1179650 as i64 {
m = (&mut *(self as *mut PortableTexEngine<'_>))
.zprimlookup(
(self.state.curcs as i64 - 1114113 as i64) as strnumber,
)? as integer;
} else {
m = (&mut *(self as *mut PortableTexEngine<'_>))
.zprimlookup(
(*self.state.hash.offset(self.state.curcs as isize)).v.RH,
)? as integer;
}
b = (self.state.curcmd as i32 != 104 as i32 && m != 0 as i32
&& self.state.curcmd as i32
== (*eqtb.offset((1194662 as i64 + m as i64) as isize)).hh.u.B0
as i32
&& self.state.curchr
== (*eqtb.offset((1194662 as i64 + m as i64) as isize)).hh.v.RH)
as i32 as boolean;
current_block = 12153365054289215322;
}
_ => {
current_block = 12153365054289215322;
}
}
match current_block {
12153365054289215322 => {
if isunless != 0 {
b = (b == 0) as i32 as boolean;
}
if (*eqtb.offset(7892300 as i64 as isize)).u.CINT > 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).begindiagnostic();
if b != 0 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66170 as i64 as integer);
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66171 as i64 as integer);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zenddiagnostic(0 as i32);
}
if b != 0 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zchangeiflimit(3 as i32 as smallnumber, savecondptr)?;
return Ok(());
}
loop {
(&mut *(self as *mut PortableTexEngine<'_>)).passtext()?;
if self.state.condptr == savecondptr {
if self.state.curchr != 4 as i32 {
break;
}
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(66168 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(66166 as i64 as strnumber);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66169 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
} else if self.state.curchr == 2 as i32 {
if *self.state.ifstack.offset(self.state.inopen as isize)
== self.state.condptr
{
(&mut *(self as *mut PortableTexEngine<'_>)).ifwarning();
}
p = self.state.condptr;
self.state.ifline = (*mem.offset((p as i32 + 1 as i32) as isize))
.u
.CINT;
self.state.curif = (*mem.offset(p as isize)).hh.u.B1
as smallnumber;
self.state.iflimit = (*mem.offset(p as isize)).hh.u.B0
as eightbits;
self.state.condptr = (*mem.offset(p as isize)).hh.v.RH;
(&mut *(self as *mut PortableTexEngine<'_>))
.zfreenode(p, 2 as i32);
}
}
}
_ => {}
}
if self.state.curchr == 2 as i32 {
if *self.state.ifstack.offset(self.state.inopen as isize)
== self.state.condptr
{
(&mut *(self as *mut PortableTexEngine<'_>)).ifwarning();
}
p = self.state.condptr;
self.state.ifline = (*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT;
self.state.curif = (*mem.offset(p as isize)).hh.u.B1 as smallnumber;
self.state.iflimit = (*mem.offset(p as isize)).hh.u.B0 as eightbits;
self.state.condptr = (*mem.offset(p as isize)).hh.v.RH;
(&mut *(self as *mut PortableTexEngine<'_>)).zfreenode(p, 2 as i32);
} else {
self.state.iflimit = 2 as eightbits;
};
Ok(())
}
pub(crate) unsafe fn convtoks(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut oldsetting_0: eightbits = 0;
let mut savewarningindex: halfword = 0;
let mut savedefref: halfword = 0;
let mut boolvar: boolean = 0;
let mut s: strnumber = 0;
let mut u: strnumber = 0;
let mut j: integer = 0;
let mut c_0: smallnumber = 0;
let mut savescannerstatus: smallnumber = 0;
let mut b: poolpointer = 0;
let mut fnt: integer = 0;
let mut arg1: integer = 0;
let mut arg2: integer = 0;
let mut fontnamestr: strnumber = 0;
let mut i: smallnumber = 0;
let mut quotechar: UTF16code = 0;
let mut cat: smallnumber = 0;
let mut savedchr: UnicodeScalar = 0;
let mut p: halfword = 0;
let mut q: halfword = 0;
cat = 0 as smallnumber;
c_0 = self.state.curchr as smallnumber;
match c_0 as i32 {
0 | 1 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
}
2 | 3 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
self.state.scannerstatus = 0 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>)).gettoken()?;
self.state.scannerstatus = savescannerstatus as eightbits;
}
4 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
}
6 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanpdfexttoks()?;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset(self.state.defref as isize)).hh.v.RH,
5 as i32 as quarterword,
)?;
(*mem.offset(self.state.defref as isize)).hh.v.RH = self.state.avail;
self.state.avail = self.state.defref;
self.state.dynused -= 1;
self.state.defref = savedefref;
if u != 0 as i32 {
self.state.strptr -= 1;
}
return Ok(());
}
16 | 17 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanregisternum()?;
if self.state.curval < 256 as i32 {
p = (*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) {
p = -(268435455 as i64) as halfword;
} else {
p = (*mem.offset((self.state.curptr as i32 + 1 as i32) as isize))
.hh
.v
.RH;
}
}
if p as i64 == -(268435455 as i64)
|| (*mem.offset(p as isize)).hh.u.B0 as i32 != 0 as i32
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zpdferror(
66116 as i64 as strnumber,
66117 as i64 as strnumber,
)?;
}
}
22 => {
b = self.state.poolptr;
getcreationdate();
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtoks(b)?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
5 as i32 as quarterword,
)?;
return Ok(());
}
23 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanpdfexttoks()?;
if self.state.selector as i32 == 21 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zpdferror(
66118 as i64 as strnumber,
66119 as i64 as strnumber,
)?;
}
oldsetting_0 = self.state.selector;
self.state.selector = 21 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>))
.zshowtokenlist(
(*mem.offset(self.state.defref as isize)).hh.v.RH,
-(268435455 as i64) as integer,
self.state.poolsize as poolpointer - self.state.poolptr,
);
self.state.selector = oldsetting_0;
s = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zdeletetokenref(self.state.defref);
self.state.defref = savedefref;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
b = self.state.poolptr;
getfilemoddate(s as integer);
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtoks(b)?;
if s == self.state.strptr as i32 - 1 as i32 {
self.state.strptr -= 1;
self.state.poolptr = *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
5 as i32 as quarterword,
)?;
if u != 0 as i32 {
self.state.strptr -= 1;
}
return Ok(());
}
24 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanpdfexttoks()?;
if self.state.selector as i32 == 21 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zpdferror(
66118 as i64 as strnumber,
66119 as i64 as strnumber,
)?;
}
oldsetting_0 = self.state.selector;
self.state.selector = 21 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>))
.zshowtokenlist(
(*mem.offset(self.state.defref as isize)).hh.v.RH,
-(268435455 as i64) as integer,
self.state.poolsize as poolpointer - self.state.poolptr,
);
self.state.selector = oldsetting_0;
s = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zdeletetokenref(self.state.defref);
self.state.defref = savedefref;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
b = self.state.poolptr;
Self::boundary_get_file_size(
self as *mut PortableTexEngine<'_>,
s as integer,
);
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtoks(b)?;
if s == self.state.strptr as i32 - 1 as i32 {
self.state.strptr -= 1;
self.state.poolptr = *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
5 as i32 as quarterword,
)?;
if u != 0 as i32 {
self.state.strptr -= 1;
}
return Ok(());
}
25 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
boolvar = (&mut *(self as *mut PortableTexEngine<'_>))
.zscankeyword(66120 as i64 as strnumber)?;
(&mut *(self as *mut PortableTexEngine<'_>)).scanpdfexttoks()?;
if self.state.selector as i32 == 21 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zpdferror(
66118 as i64 as strnumber,
66119 as i64 as strnumber,
)?;
}
oldsetting_0 = self.state.selector;
self.state.selector = 21 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>))
.zshowtokenlist(
(*mem.offset(self.state.defref as isize)).hh.v.RH,
-(268435455 as i64) as integer,
self.state.poolsize as poolpointer - self.state.poolptr,
);
self.state.selector = oldsetting_0;
s = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zdeletetokenref(self.state.defref);
self.state.defref = savedefref;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
b = self.state.poolptr;
getmd5sum(s as integer, boolvar as i32);
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtoks(b)?;
if s == self.state.strptr as i32 - 1 as i32 {
self.state.strptr -= 1;
self.state.poolptr = *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
5 as i32 as quarterword,
)?;
if u != 0 as i32 {
self.state.strptr -= 1;
}
return Ok(());
}
26 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
self.state.curval = 0 as i32 as integer;
if (&mut *(self as *mut PortableTexEngine<'_>))
.zscankeyword(66121 as i64 as strnumber)? != 0
{
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if self.state.curval < 0 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(66122 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66123 as i64
as strnumber;
self.state.helpline[0 as i32 as usize] = 66005 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>))
.zinterror(self.state.curval)?;
self.state.curval = 0 as i32 as integer;
}
}
i = self.state.curval as smallnumber;
self.state.curval = 0 as i32 as integer;
if (&mut *(self as *mut PortableTexEngine<'_>))
.zscankeyword(66124 as i64 as strnumber)? != 0
{
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if self.state.curval < 0 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(66125 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66126 as i64
as strnumber;
self.state.helpline[0 as i32 as usize] = 66005 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>))
.zinterror(self.state.curval)?;
self.state.curval = 0 as i32 as integer;
}
}
j = self.state.curval;
(&mut *(self as *mut PortableTexEngine<'_>)).scanpdfexttoks()?;
if self.state.selector as i32 == 21 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zpdferror(
66118 as i64 as strnumber,
66119 as i64 as strnumber,
)?;
}
oldsetting_0 = self.state.selector;
self.state.selector = 21 as eightbits;
(&mut *(self as *mut PortableTexEngine<'_>))
.zshowtokenlist(
(*mem.offset(self.state.defref as isize)).hh.v.RH,
-(268435455 as i64) as integer,
self.state.poolsize as poolpointer - self.state.poolptr,
);
self.state.selector = oldsetting_0;
s = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zdeletetokenref(self.state.defref);
self.state.defref = savedefref;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
b = self.state.poolptr;
getfiledump(s as integer, i as i32, j as i32);
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtoks(b)?;
if s == self.state.strptr as i32 - 1 as i32 {
self.state.strptr -= 1;
self.state.poolptr = *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize))
.hh
.v
.RH,
5 as i32 as quarterword,
)?;
if u != 0 as i32 {
self.state.strptr -= 1;
}
return Ok(());
}
18 => {
savescannerstatus = self.state.scannerstatus as smallnumber;
savewarningindex = self.state.warningindex;
savedefref = self.state.defref;
if *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize)
< self.state.poolptr
{
u = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
} else {
u = 0 as i32 as strnumber;
}
(&mut *(self as *mut PortableTexEngine<'_>)).comparestrings()?;
self.state.defref = savedefref;
self.state.warningindex = savewarningindex;
self.state.scannerstatus = savescannerstatus as eightbits;
if u != 0 as i32 {
self.state.strptr -= 1;
}
}
38 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanusvnum()?;
}
39 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanusvnum()?;
savedchr = self.state.curval as UnicodeScalar;
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
if self.state.curval < 1 as i32 || self.state.curval > 13 as i32
|| self.state.curval == 5 as i32 || self.state.curval == 9 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(66127 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(self.state.curval);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66128 as i64 as integer);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66129 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
cat = 12 as smallnumber;
} else {
cat = self.state.curval as smallnumber;
}
self.state.curval = savedchr as integer;
}
34 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
fnt = self.state.curval;
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64 {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
arg1 = self.state.curval;
arg2 = 0 as i32 as integer;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.znotaatfonterror(111 as i32, c_0 as integer, fnt)?;
}
}
35 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
fnt = self.state.curval;
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64
|| *self.state.fontarea.offset(fnt as isize) as i64 == 65534 as i64
&& usingGraphite(
*self.state.fontlayoutengine.offset(fnt as isize)
as FontHandle,
) != 0
{
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
arg1 = self.state.curval;
arg2 = 0 as i32 as integer;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.znotaatgrfonterror(111 as i32, c_0 as integer, fnt)?;
}
}
36 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
fnt = self.state.curval;
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64
|| *self.state.fontarea.offset(fnt as isize) as i64 == 65534 as i64
&& usingGraphite(
*self.state.fontlayoutengine.offset(fnt as isize)
as FontHandle,
) != 0
{
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
arg1 = self.state.curval;
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
arg2 = self.state.curval;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.znotaatgrfonterror(111 as i32, c_0 as integer, fnt)?;
}
}
37 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanfontident()?;
fnt = self.state.curval;
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64
|| *self.state.fontarea.offset(fnt as isize) as i64 == 65534 as i64
{
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
arg1 = self.state.curval;
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.znotnativefonterror(111 as i32, c_0 as integer, fnt)?;
}
}
40 => {
if self.state.jobname == 0 as i32 {
Self::boundary_open_log_file(self as *mut PortableTexEngine<'_>)?;
}
}
29 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scanint()?;
}
5 | 33 | 30 | _ => {}
}
oldsetting_0 = self.state.selector;
self.state.selector = 21 as eightbits;
b = self.state.poolptr;
match c_0 as i32 {
0 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(self.state.curval);
}
1 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintromanint(self.state.curval);
}
2 => {
if self.state.curcs != 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zsprintcs(self.state.curcs);
} else {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintchar(self.state.curchr);
}
}
3 => {
(&mut *(self as *mut PortableTexEngine<'_>)).printmeaning();
}
4 => {
fontnamestr = *self.state.fontname.offset(self.state.curval as isize);
if *self.state.fontarea.offset(self.state.curval as isize) as i64
== 65535 as i64
|| *self.state.fontarea.offset(self.state.curval as isize) as i64
== 65534 as i64
{
quotechar = 34 as UTF16code;
let mut for_end: integer = 0;
i = 0 as smallnumber;
for_end = ((&mut *(self as *mut PortableTexEngine<'_>))
.zlength(fontnamestr) as i32 - 1 as i32) as integer;
if i as i32 <= for_end {
loop {
if *self
.state
.strpool
.offset(
(*self
.state
.strstart
.offset((fontnamestr as i64 - 65536 as i64) as isize) as i32
+ i as i32) as isize,
) as i32 == 34 as i32
{
quotechar = 39 as UTF16code;
}
let fresh79 = i;
i = i + 1;
if !((fresh79 as i32) < for_end) {
break;
}
}
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintchar(quotechar as integer);
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(fontnamestr);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintchar(quotechar as integer);
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(fontnamestr);
}
if *self.state.fontsize.offset(self.state.curval as isize)
!= *self.state.fontdsize.offset(self.state.curval as isize)
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66130 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintscaled(
*self.state.fontsize.offset(self.state.curval as isize),
);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65697 as i64 as integer);
}
}
5 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65536 as i64 as integer);
}
16 => {
p = (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH;
while p as i64 != -(268435455 as i64)
&& (!(p >= self.state.himemmin)
&& ((*mem.offset(p as isize)).hh.u.B0 as i32 == 3 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 4 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 5 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 12 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 7 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH
as i64 == -(268435455 as i64)
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.RH
as i64 == -(268435455 as i64)
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 0 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 9 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 11 as i32
&& ((*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
|| (*mem.offset(p as isize)).hh.u.B1 as i32 == 0 as i32)
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 10 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH
== self.state.membot
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 0 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH
as i64 == -(268435455 as i64))
|| !(p >= self.state.himemmin)
&& (*mem.offset(p as isize)).hh.u.B0 as i32 == 10 as i32
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 8 as i32)
{
p = (*mem.offset(p as isize)).hh.v.RH;
}
if p as i64 != -(268435455 as i64) && !(p >= self.state.himemmin)
&& (*mem.offset(p as isize)).hh.u.B0 as i32 == 40 as i32
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 0 as i32
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintscaled(
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT,
);
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(48 as i32);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65697 as i64 as integer);
}
17 => {
q = (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH;
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zprevrightmost(q, -(268435455 as i64) as halfword);
while p as i64 != -(268435455 as i64)
&& (!(p >= self.state.himemmin)
&& ((*mem.offset(p as isize)).hh.u.B0 as i32 == 3 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 4 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 5 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 12 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 7 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH
as i64 == -(268435455 as i64)
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.RH
as i64 == -(268435455 as i64)
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 0 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 9 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 11 as i32
&& ((*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
|| (*mem.offset(p as isize)).hh.u.B1 as i32 == 0 as i32)
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 10 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH
== self.state.membot
|| (*mem.offset(p as isize)).hh.u.B0 as i32 == 0 as i32
&& (*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT
== 0 as i32
&& (*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH
as i64 == -(268435455 as i64))
|| !(p >= self.state.himemmin)
&& (*mem.offset(p as isize)).hh.u.B0 as i32 == 10 as i32
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 9 as i32)
{
p = (&mut *(self as *mut PortableTexEngine<'_>))
.zprevrightmost(q, p);
}
if p as i64 != -(268435455 as i64) && !(p >= self.state.himemmin)
&& (*mem.offset(p as isize)).hh.u.B0 as i32 == 40 as i32
&& (*mem.offset(p as isize)).hh.u.B1 as i32 == 1 as i32
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintscaled(
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT,
);
} else {
(&mut *(self as *mut PortableTexEngine<'_>)).zprint(48 as i32);
}
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65697 as i64 as integer);
}
18 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(self.state.curval);
}
29 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint(
(&mut *(self as *mut PortableTexEngine<'_>))
.zunifrand(self.state.curval),
);
}
30 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintint((&mut *(self as *mut PortableTexEngine<'_>)).normrand()?);
}
38 | 39 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintchar(self.state.curval);
}
33 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(65537 as i64 as integer);
}
34 => {
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64 {
aatprintfontname(
c_0 as i32,
*self.state.fontlayoutengine.offset(fnt as isize)
as CFDictionaryRef,
arg1 as i32,
arg2 as i32,
);
}
}
35 | 36 => {
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64 {
aatprintfontname(
c_0 as i32,
*self.state.fontlayoutengine.offset(fnt as isize)
as CFDictionaryRef,
arg1 as i32,
arg2 as i32,
);
} else if *self.state.fontarea.offset(fnt as isize) as i64
== 65534 as i64
&& usingGraphite(
*self.state.fontlayoutengine.offset(fnt as isize) as FontHandle,
) != 0
{
grprintfontname(
c_0 as integer,
*self.state.fontlayoutengine.offset(fnt as isize) as *mut (),
arg1,
arg2,
);
}
}
37 => {
if *self.state.fontarea.offset(fnt as isize) as i64 == 65535 as i64
|| *self.state.fontarea.offset(fnt as isize) as i64 == 65534 as i64
{
printglyphname(fnt, arg1);
}
}
40 => {
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintfilename(self.state.jobname, 0 as i32, 0 as i32);
}
_ => {}
}
self.state.selector = oldsetting_0;
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zstrtokscat(b, cat)?;
(&mut *(self as *mut PortableTexEngine<'_>))
.zbegintokenlist(
(*mem.offset((self.state.memtop as i32 - 3 as i32) as isize)).hh.v.RH,
5 as i32 as quarterword,
)?;
Ok(())
}
pub(crate) unsafe fn cserror(&mut self) -> EngineFlow<()> {
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(66168 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(65818 as i64 as strnumber);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66561 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
Ok(())
}
}