#![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 newchoice(&mut self) -> EngineFlow<halfword> {
let mut Result: halfword = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(3 as i32)?;
(*mem.offset(p as isize)).hh.u.B0 = 15 as i16;
(*mem.offset(p as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH = -(268435455 as i64)
as halfword;
(*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
(*mem.offset((p as i32 + 2 as i32) as isize)).hh.v.LH = -(268435455 as i64)
as halfword;
(*mem.offset((p as i32 + 2 as i32) as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
Result = p;
return Ok(Result);
}
pub(crate) unsafe fn newdisc(&mut self) -> EngineFlow<halfword> {
let mut Result: halfword = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(2 as i32)?;
(*mem.offset(p as isize)).hh.u.B0 = 7 as i16;
(*mem.offset(p as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.LH = -(268435455 as i64)
as halfword;
(*mem.offset((p as i32 + 1 as i32) as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
Result = p;
return Ok(Result);
}
pub(crate) unsafe fn newhyphexceptions(&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 n: i16 = 0;
let mut j: i16 = 0;
let mut h: hyphpointer = 0;
let mut k: strnumber = 0;
let mut p: halfword = 0;
let mut q: halfword = 0;
let mut s: strnumber = 0;
let mut u: poolpointer = 0;
let mut v: poolpointer = 0;
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
if (*eqtb.offset(7892314 as i64 as isize)).u.CINT <= 0 as i32 {
self.state.curlang = 0 as eightbits;
} else if (*eqtb.offset(7892314 as i64 as isize)).u.CINT > 255 as i32 {
self.state.curlang = 0 as eightbits;
} else {
self.state.curlang = (*eqtb.offset(7892314 as i64 as isize)).u.CINT
as eightbits;
}
if self.state.trienotready != 0 {
self.state.hyphindex = 0 as i32 as triepointer;
} else if *self
.state
.trietrc
.offset((self.state.hyphstart as i32 + self.state.curlang as i32) as isize)
as i32 != self.state.curlang as i32
{
self.state.hyphindex = 0 as i32 as triepointer;
} else {
self.state.hyphindex = *self
.state
.trietrl
.offset(
(self.state.hyphstart as i32 + self.state.curlang as i32) as isize,
);
}
n = 0 as i16;
p = -(268435455 as i64) as halfword;
's_79: loop {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
loop {
match self.state.curcmd as i32 {
11 | 12 | 68 => {
if self.state.curchr == 45 as i32 {
if (n as i32)
< (&mut *(self as *mut PortableTexEngine<'_>))
.maxhyphenatablelength()
{
q = (&mut *(self as *mut PortableTexEngine<'_>))
.getavail()?;
(*mem.offset(q as isize)).hh.v.RH = p;
(*mem.offset(q as isize)).hh.v.LH = n as halfword;
p = q;
}
} else {
if self.state.hyphindex == 0 as i32
|| self.state.curchr > 255 as i32
{
self.state.hc[0 as i32 as usize] = (*eqtb
.offset(
(2321704 as i64 + self.state.curchr as i64) as isize,
))
.hh
.v
.RH as integer;
} else if *self
.state
.trietrc
.offset(
(self.state.hyphindex as halfword + self.state.curchr)
as isize,
) as i32 != self.state.curchr
{
self.state.hc[0 as i32 as usize] = 0 as i32 as integer;
} else {
self.state.hc[0 as i32 as usize] = *self
.state
.trietro
.offset(
(self.state.hyphindex as halfword + self.state.curchr)
as isize,
) as integer;
}
if self.state.hc[0 as i32 as usize] == 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(66381 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66382 as i64
as strnumber;
self.state.helpline[0 as i32 as usize] = 66383 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
} else if (n as i32)
< (&mut *(self as *mut PortableTexEngine<'_>))
.maxhyphenatablelength()
{
n += 1;
if (self.state.hc[0 as i32 as usize] as i64) < 65536 as i64
{
self.state.hc[n as usize] = self
.state
.hc[0 as i32 as usize];
} else {
self.state.hc[n as usize] = ((self
.state
.hc[0 as i32 as usize] as i64 - 65536 as i64) / 1024 as i64
+ 55296 as i64) as integer;
n += 1;
self.state.hc[n as usize] = ((self
.state
.hc[0 as i32 as usize] % 1024 as i32) as i64 + 56320 as i64)
as integer;
}
}
}
continue 's_79;
}
16 => {
(&mut *(self as *mut PortableTexEngine<'_>)).scancharnum()?;
self.state.curchr = self.state.curval as halfword;
self.state.curcmd = 68 as eightbits;
}
10 | 2 => {
if n as i32 > 1 as i32 {
current_block = 5141539773904409130;
break;
} else {
current_block = 6540614962658479183;
break;
}
}
_ => {
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(66029 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(66377 as i64 as strnumber);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprint(66378 as i64 as integer);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66379 as i64
as strnumber;
self.state.helpline[0 as i32 as usize] = 66380 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
continue 's_79;
}
}
}
match current_block {
5141539773904409130 => {
n += 1;
self.state.hc[n as usize] = self.state.curlang as integer;
if self.state.poolptr as i32 + n as i32 > self.state.poolsize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(
65539 as i64 as strnumber,
self.state.poolsize as poolpointer - self.state.initpoolptr,
)?
{};
}
h = 0 as hyphpointer;
let mut for_end: integer = 0;
j = 1 as i16;
for_end = n as integer;
if j as i32 <= for_end {
loop {
h = ((h as i32 + h as i32 + self.state.hc[j as usize])
% 607 as i32) as hyphpointer;
if self.state.hc[j as usize] as i64 > 65535 as i64 {
*self.state.strpool.offset(self.state.poolptr as isize) = ((self
.state
.hc[j as usize] as i64 - 65536 as i64) / 1024 as i64
+ 55296 as i64) as packedUTF16code;
self.state.poolptr += 1;
*self.state.strpool.offset(self.state.poolptr as isize) = ((self
.state
.hc[j as usize] % 1024 as i32) as i64 + 56320 as i64)
as packedUTF16code;
self.state.poolptr += 1;
} else {
*self.state.strpool.offset(self.state.poolptr as isize) = self
.state
.hc[j as usize] as packedUTF16code;
self.state.poolptr += 1;
}
let fresh66 = j;
j = j + 1;
if !((fresh66 as i32) < for_end) {
break;
}
}
}
s = (&mut *(self as *mut PortableTexEngine<'_>)).makestring()?;
if self.state.hyphnext <= 607 as i32 {
while self.state.hyphnext > 0 as i32
&& *self
.state
.hyphword
.offset((self.state.hyphnext as i32 - 1 as i32) as isize)
> 0 as i32
{
self.state.hyphnext -= 1;
}
}
if self.state.hyphcount == self.state.hyphsize
|| self.state.hyphnext == 0 as i32
{
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(66384 as i64 as strnumber, self.state.hyphsize)?
{};
}
self.state.hyphcount += 1;
while *self.state.hyphword.offset(h as isize) != 0 as i32 {
k = *self.state.hyphword.offset(h as isize);
if !((&mut *(self as *mut PortableTexEngine<'_>)).zlength(k)
!= (&mut *(self as *mut PortableTexEngine<'_>)).zlength(s))
{
u = *self
.state
.strstart
.offset((k as i64 - 65536 as i64) as isize);
v = *self
.state
.strstart
.offset((s as i64 - 65536 as i64) as isize);
loop {
if *self.state.strpool.offset(u as isize) as i32
!= *self.state.strpool.offset(v as isize) as i32
{
current_block = 15587532755333643506;
break;
}
u += 1;
v += 1;
if u
== *self
.state
.strstart
.offset(
((k as i32 + 1 as i32) as i64 - 65536 as i64) as isize,
)
{
current_block = 8464383504555462953;
break;
}
}
match current_block {
15587532755333643506 => {}
_ => {
self.state.strptr -= 1;
self.state.poolptr = *self
.state
.strstart
.offset((self.state.strptr as i64 - 65536 as i64) as isize);
s = *self.state.hyphword.offset(h as isize);
self.state.hyphcount -= 1;
break;
}
}
}
if *self.state.hyphlink.offset(h as isize) as i32 == 0 as i32 {
*self.state.hyphlink.offset(h as isize) = self.state.hyphnext
as hyphpointer;
if self.state.hyphnext >= self.state.hyphsize {
self.state.hyphnext = 607 as i32 as integer;
}
if self.state.hyphnext > 607 as i32 {
self.state.hyphnext += 1;
}
}
h = (*self.state.hyphlink.offset(h as isize) as i32 - 1 as i32)
as hyphpointer;
}
*self.state.hyphword.offset(h as isize) = s;
*self.state.hyphlist.offset(h as isize) = p;
}
_ => {}
}
if self.state.curcmd as i32 == 2 as i32 {
return Ok(());
}
n = 0 as i16;
p = -(268435455 as i64) as halfword;
}
}
pub(crate) unsafe fn newinteraction(&mut self) {
(&mut *(self as *mut PortableTexEngine<'_>)).println();
self.state.interaction = self.state.curchr as eightbits;
if self.state.interaction as i32 == 0 as i32 {
self.state.resource_search_state.make_tex_discard_errors = 1 as i32 as boolean;
} else {
self.state.resource_search_state.make_tex_discard_errors = 0 as i32 as boolean;
}
if self.state.interaction as i32 == 0 as i32 {
self.state.selector = 16 as eightbits;
} else {
self.state.selector = 17 as eightbits;
}
if self.state.logopened != 0 {
self.state.selector =
(self.state.selector as i32 + 2 as i32) as eightbits;
}
}
pub(crate) unsafe fn newnoad(&mut self) -> EngineFlow<halfword> {
let mut Result: halfword = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(4 as i32)?;
(*mem.offset(p as isize)).hh.u.B0 = 16 as i16;
(*mem.offset(p as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).hh = self.state.emptyfield;
(*mem.offset((p as i32 + 3 as i32) as isize)).hh = self.state.emptyfield;
(*mem.offset((p as i32 + 2 as i32) as isize)).hh = self.state.emptyfield;
Result = p;
return Ok(Result);
}
pub(crate) unsafe fn newnullbox(&mut self) -> EngineFlow<halfword> {
let mut Result: halfword = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(7 as i32)?;
(*mem.offset(p as isize)).hh.u.B0 = 0 as i16;
(*mem.offset(p as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((p as i32 + 4 as i32) as isize)).u.CINT = 0 as i32 as integer;
(*mem.offset((p as i32 + 5 as i32) as isize)).hh.v.RH = -(268435455 as i64)
as halfword;
(*mem.offset((p as i32 + 5 as i32) as isize)).hh.u.B0 = 0 as i16;
(*mem.offset((p as i32 + 5 as i32) as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 6 as i32) as isize)).gr = 0.0f64 as glueratio;
Result = p;
return Ok(Result);
}
pub(crate) unsafe fn newpatterns(&mut self) -> EngineFlow<()> {
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
if self.format_initialization {
let list = (*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH;
if list != TEX_NULL {
(&mut *(self as *mut PortableTexEngine<'_>)).zflushnodelist(list)?;
}
(*mem.offset(self.state.curlist.headfield as isize)).hh.v.RH = TEX_NULL;
self.state.curlist.tailfield = self.state.curlist.headfield;
}
let eqtb = self.state.zeqtb.as_mut_ptr();
let mut k: i16 = 0;
let mut l: i16 = 0;
let mut digitsensed: boolean = 0;
let mut v: trieopcode = 0;
let mut p: triepointer = 0;
let mut q: triepointer = 0;
let mut firstchild: boolean = 0;
let mut c: UTF16code = 0;
if self.state.trienotready != 0 {
if (*eqtb.offset(7892314 as i64 as isize)).u.CINT <= 0 as i32 {
self.state.curlang = 0 as eightbits;
} else if (*eqtb.offset(7892314 as i64 as isize)).u.CINT > 255 as i32 {
self.state.curlang = 0 as eightbits;
} else {
self.state.curlang = (*eqtb.offset(7892314 as i64 as isize)).u.CINT
as eightbits;
}
(&mut *(self as *mut PortableTexEngine<'_>)).scanleftbrace()?;
k = 0 as i16;
self.state.hyf[0 as i32 as usize] = 0 as eightbits;
digitsensed = false_0 as boolean;
loop {
(&mut *(self as *mut PortableTexEngine<'_>)).getxtoken()?;
match self.state.curcmd as i32 {
11 | 12 => {
if digitsensed != 0 || self.state.curchr < 48 as i32
|| self.state.curchr > 57 as i32
{
if self.state.curchr == 46 as i32 {
self.state.curchr = 0 as i32 as halfword;
} else {
self.state.curchr = (*eqtb
.offset(
(2321704 as i64 + self.state.curchr as i64) as isize,
))
.hh
.v
.RH;
if self.state.curchr == 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(66393 as i64 as integer);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66392 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
}
}
if self.state.curchr > self.state.maxhyphchar {
self.state.maxhyphchar = self.state.curchr as integer;
}
if (k as i32)
< (&mut *(self as *mut PortableTexEngine<'_>))
.maxhyphenatablelength()
{
k += 1;
self.state.hc[k as usize] = self.state.curchr as integer;
self.state.hyf[k as usize] = 0 as eightbits;
digitsensed = false_0 as boolean;
}
} else if (k as i32)
< (&mut *(self as *mut PortableTexEngine<'_>))
.maxhyphenatablelength()
{
self.state.hyf[k as usize] = (self.state.curchr as i32
- 48 as i32) as eightbits;
digitsensed = true_0 as boolean;
}
}
10 | 2 => {
if k as i32 > 0 as i32 {
if self.state.hc[1 as i32 as usize] == 0 as i32 {
self.state.hyf[0 as i32 as usize] = 0 as eightbits;
}
if self.state.hc[k as usize] == 0 as i32 {
self.state.hyf[k as usize] = 0 as eightbits;
}
l = k;
v = mintrieop as trieopcode;
loop {
if self.state.hyf[l as usize] as i32 != 0 as i32 {
v = (&mut *(self as *mut PortableTexEngine<'_>))
.znewtrieop(
(k as i32 - l as i32) as smallnumber,
self.state.hyf[l as usize] as smallnumber,
v,
)?;
}
if !(l as i32 > 0 as i32) {
break;
}
l -= 1;
}
q = 0 as i32 as triepointer;
self.state.hc[0 as i32 as usize] = self.state.curlang
as integer;
while l as i32 <= k as i32 {
c = self.state.hc[l as usize] as UTF16code;
l += 1;
p = *self.state.triel.offset(q as isize);
firstchild = true_0 as boolean;
while p > 0 as i32
&& c as i32 > *self.state.triec.offset(p as isize) as i32
{
q = p;
p = *self.state.trier.offset(q as isize);
firstchild = false_0 as boolean;
}
if p == 0 as i32
|| (c as i32) < *self.state.triec.offset(p as isize) as i32
{
if self.state.trieptr == self.state.triesize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(66387 as i64 as strnumber, self.state.triesize)?
{};
}
self.state.trieptr += 1;
*self.state.trier.offset(self.state.trieptr as isize) = p;
p = self.state.trieptr;
*self.state.triel.offset(p as isize) = 0 as i32
as triepointer;
if firstchild != 0 {
*self.state.triel.offset(q as isize) = p;
} else {
*self.state.trier.offset(q as isize) = p;
}
*self.state.triec.offset(p as isize) = c as packedUTF16code;
*self.state.trieo.offset(p as isize) = mintrieop
as trieopcode;
}
q = p;
}
if *self.state.trieo.offset(q as isize) as i32 != mintrieop {
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(66394 as i64 as integer);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66392 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
}
*self.state.trieo.offset(q as isize) = v;
}
if self.state.curcmd as i32 == 2 as i32 {
break;
}
k = 0 as i16;
self.state.hyf[0 as i32 as usize] = 0 as eightbits;
digitsensed = false_0 as boolean;
}
_ => {
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(66389 as i64 as strnumber);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66392 as i64
as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
}
}
}
if (*eqtb.offset(7892333 as i64 as isize)).u.CINT > 0 as i32 {
c = self.state.curlang as UTF16code;
firstchild = false_0 as boolean;
p = 0 as i32 as triepointer;
loop {
q = p;
p = *self.state.trier.offset(q as isize);
if p == 0 as i32
|| c as i32 <= *self.state.triec.offset(p as isize) as i32
{
break;
}
}
if p == 0 as i32
|| (c as i32) < *self.state.triec.offset(p as isize) as i32
{
if self.state.trieptr == self.state.triesize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(66387 as i64 as strnumber, self.state.triesize)?
{};
}
self.state.trieptr += 1;
*self.state.trier.offset(self.state.trieptr as isize) = p;
p = self.state.trieptr;
*self.state.triel.offset(p as isize) = 0 as i32 as triepointer;
if firstchild != 0 {
*self.state.triel.offset(q as isize) = p;
} else {
*self.state.trier.offset(q as isize) = p;
}
*self.state.triec.offset(p as isize) = c as packedUTF16code;
*self.state.trieo.offset(p as isize) = mintrieop as trieopcode;
}
q = p;
p = *self.state.triel.offset(q as isize);
firstchild = true_0 as boolean;
let mut for_end: integer = 0;
c = 0 as UTF16code;
for_end = 255 as i32 as integer;
if c as i32 <= for_end {
loop {
if (*eqtb.offset((2321704 as i64 + c as i64) as isize)).hh.v.RH
> 0 as i32 || c as i32 == 255 as i32 && firstchild != 0
{
if p == 0 as i32 {
if self.state.trieptr == self.state.triesize {
match (&mut *(self as *mut PortableTexEngine<'_>))
.zoverflow(66387 as i64 as strnumber, self.state.triesize)?
{};
}
self.state.trieptr += 1;
*self.state.trier.offset(self.state.trieptr as isize) = p;
p = self.state.trieptr;
*self.state.triel.offset(p as isize) = 0 as i32
as triepointer;
if firstchild != 0 {
*self.state.triel.offset(q as isize) = p;
} else {
*self.state.trier.offset(q as isize) = p;
}
*self.state.triec.offset(p as isize) = c as packedUTF16code;
*self.state.trieo.offset(p as isize) = mintrieop
as trieopcode;
} else {
*self.state.triec.offset(p as isize) = c as packedUTF16code;
}
*self.state.trieo.offset(p as isize) = (*eqtb
.offset((2321704 as i64 + c as i64) as isize))
.hh
.v
.RH as trieopcode;
q = p;
p = *self.state.trier.offset(q as isize);
firstchild = false_0 as boolean;
}
let fresh61 = c;
c = c.wrapping_add(1);
if !((fresh61 as i32) < for_end) {
break;
}
}
}
if firstchild != 0 {
*self.state.triel.offset(q as isize) = 0 as i32 as triepointer;
} else {
*self.state.trier.offset(q as isize) = 0 as i32 as triepointer;
}
}
} 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(66388 as i64 as integer);
(&mut *(self as *mut PortableTexEngine<'_>))
.zprintesc(66389 as i64 as strnumber);
self.state.helpptr = 1 as eightbits;
self.state.helpline[0 as i32 as usize] = 66390 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
(*mem.offset((self.state.memtop as i32 - 12 as i32) as isize)).hh.v.RH = (&mut *(self
as *mut PortableTexEngine<'_>))
.zscantoks(0 as i32, 0 as i32)?;
(&mut *(self as *mut PortableTexEngine<'_>)).zflushlist(self.state.defref);
};
Ok(())
}
pub(crate) unsafe fn newrandoms(&mut self) {
let mut k: eightbits = 0;
let mut x: integer = 0;
let mut for_end: integer = 0;
k = 0 as eightbits;
for_end = 23 as i32 as integer;
if k as i32 <= for_end {
loop {
x = self.state.randoms[k as usize]
- self.state.randoms[(k as i32 + 31 as i32) as usize];
if x < 0 as i32 {
x = (x as i64 + 268435456 as i64) as integer;
}
self.state.randoms[k as usize] = x;
let fresh41 = k;
k = k.wrapping_add(1);
if !((fresh41 as i32) < for_end) {
break;
}
}
}
let mut for_end_0: integer = 0;
k = 24 as eightbits;
for_end_0 = 54 as i32 as integer;
if k as i32 <= for_end_0 {
loop {
x = self.state.randoms[k as usize]
- self.state.randoms[(k as i32 - 24 as i32) as usize];
if x < 0 as i32 {
x = (x as i64 + 268435456 as i64) as integer;
}
self.state.randoms[k as usize] = x;
let fresh42 = k;
k = k.wrapping_add(1);
if !((fresh42 as i32) < for_end_0) {
break;
}
}
}
self.state.jrandom = 54 as eightbits;
}
pub(crate) unsafe fn newrule(&mut self) -> EngineFlow<halfword> {
let mut Result: halfword = 0;
let mut mem: *mut memoryword = self.state.zmem.as_mut_ptr();
let mut p: halfword = 0;
p = (&mut *(self as *mut PortableTexEngine<'_>)).zgetnode(4 as i32)?;
(*mem.offset(p as isize)).hh.u.B0 = 2 as i16;
(*mem.offset(p as isize)).hh.u.B1 = 0 as i16;
(*mem.offset((p as i32 + 1 as i32) as isize)).u.CINT = -(1073741824 as i64)
as integer;
(*mem.offset((p as i32 + 2 as i32) as isize)).u.CINT = -(1073741824 as i64)
as integer;
(*mem.offset((p as i32 + 3 as i32) as isize)).u.CINT = -(1073741824 as i64)
as integer;
Result = p;
return Ok(Result);
}
pub(crate) unsafe fn noalignerror(&mut self) -> EngineFlow<()> {
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<'_>))
.zprintesc(65848 as i64 as strnumber);
self.state.helpptr = 2 as eightbits;
self.state.helpline[1 as i32 as usize] = 66557 as i64 as strnumber;
self.state.helpline[0 as i32 as usize] = 66558 as i64 as strnumber;
(&mut *(self as *mut PortableTexEngine<'_>)).error()?;
Ok(())
}
pub(crate) unsafe fn normalizeselector(&mut self) -> EngineFlow<()> {
if self.state.logopened != 0 {
self.state.selector = 19 as eightbits;
} else {
self.state.selector = 17 as eightbits;
}
if self.state.jobname == 0 as i32 {
Self::boundary_open_log_file(self as *mut PortableTexEngine<'_>)?;
}
Ok(
if self.state.interaction as i32 == 0 as i32 {
self.state.selector = self.state.selector.wrapping_sub(1);
},
)
}
pub(crate) unsafe fn normalparagraph(&mut self) -> EngineFlow<()> {
let eqtb = self.state.zeqtb.as_mut_ptr();
if (*eqtb.offset(7892283 as i64 as isize)).u.CINT != 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zeqworddefine(7892283 as i64 as halfword, 0 as i32)?;
}
if (*eqtb.offset(9006736 as i64 as isize)).u.CINT != 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zeqworddefine(9006736 as i64 as halfword, 0 as i32)?;
}
if (*eqtb.offset(7892305 as i64 as isize)).u.CINT != 1 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>))
.zeqworddefine(7892305 as i64 as halfword, 1 as i32)?;
}
if (*eqtb.offset(1206295 as i64 as isize)).hh.v.RH as i64 != -(268435455 as i64)
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zeqdefine(
1206295 as i64 as halfword,
121 as i32 as quarterword,
-(268435455 as i64) as halfword,
)?;
}
Ok(
if (*eqtb.offset(1206563 as i64 as isize)).hh.v.RH as i64
!= -(268435455 as i64)
{
(&mut *(self as *mut PortableTexEngine<'_>))
.zeqdefine(
1206563 as i64 as halfword,
121 as i32 as quarterword,
-(268435455 as i64) as halfword,
)?;
},
)
}
pub(crate) unsafe fn normrand(&mut self) -> EngineFlow<integer> {
let mut Result: integer = 0;
let mut x: integer = 0;
let mut u: integer = 0;
let mut l_0: integer = 0;
loop {
loop {
if self.state.jrandom as i32 == 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).newrandoms();
} else {
self.state.jrandom = self.state.jrandom.wrapping_sub(1);
}
x = (&mut *(self as *mut PortableTexEngine<'_>))
.ztakefrac(
112429 as i64 as integer,
(self.state.randoms[self.state.jrandom as usize] as i64
- 134217728 as i64) as integer,
);
if self.state.jrandom as i32 == 0 as i32 {
(&mut *(self as *mut PortableTexEngine<'_>)).newrandoms();
} else {
self.state.jrandom = self.state.jrandom.wrapping_sub(1);
}
u = self.state.randoms[self.state.jrandom as usize];
if (if x >= 0 as i32 { x } else { -x }) < u {
break;
}
}
x = (&mut *(self as *mut PortableTexEngine<'_>)).zmakefrac(x, u);
l_0 = (139548960 as i64
- (&mut *(self as *mut PortableTexEngine<'_>)).zmlog(u)? as i64)
as integer;
if (&mut *(self as *mut PortableTexEngine<'_>))
.zabvscd(1024 as i32, l_0, x, x) >= 0 as i32
{
break;
}
}
Result = x;
return Ok(Result);
}
}