1use alloc::vec;
35use alloc::vec::Vec;
36
37use rt::fx::{cvtt, cvttd, sqrt};
38
39use crate::outline::{Outline, OLT_CUBIC, OLT_ON};
40use crate::ttf::{Tb, ERR_HDR, ERR_UNSUPPORTED};
41use crate::var;
42
43const FD_MAX: u32 = 256;
44const CS_STACK: usize = 48;
45const CS2_STACK: usize = 513; const CS2_DEFSTACK: i64 = 193; const CS2_REGIONS: usize = 512; const DICT2_STACK: usize = 513; const CS_DEPTH: u32 = 10;
50const CS_BUDGET: i32 = 200_000;
51const OPS_MAX: usize = 48; const F_INV65536: f32 = 0.000_015_258_789_062_5;
53const F_INV8M: f32 = 0.000_000_119_209_29; const F_EPS: f32 = 0.000_001;
55
56#[derive(Clone, Copy, Default)]
58struct Index {
59 count: u32,
60 offsize: u32,
61 offs: u32,
62 data: u32,
63}
64
65pub struct Cff {
66 v2: bool,
68 cid: bool, cs: Index,
70 gs: Index,
71 ls: Index,
72 fdsel: u32, nfd: u32,
74 mat: [f32; 6],
75 hasmat: bool,
76 fdls: Vec<Index>,
77 fdvs: Vec<u16>,
79 vstore: u32,
81 maxstack: u32,
83}
84
85fn c8(t: Tb, off: u32) -> i32 {
88 t.u8(off)
89}
90
91fn c16(t: Tb, off: u32) -> i32 {
92 t.u16(off)
93}
94
95fn c_off(t: Tb, off: u32, size: u32) -> i64 {
97 if off as u64 + size as u64 > t.0.len() as u64 {
98 return -1;
99 }
100 let mut v = 0u32;
101 for i in 0..size {
102 v = (v << 8) | t.0[(off + i) as usize] as u32;
103 }
104 v as i64
105}
106
107fn ix_parse(t: Tb, pos: u32, ix: &mut Index) -> i64 {
111 let count = c16(t, pos);
112 if count < 0 {
113 ix.count = 0;
114 return -1;
115 }
116 ix.count = count as u32;
117 if count == 0 {
118 ix.offsize = 1;
119 ix.offs = pos.wrapping_add(2);
120 ix.data = ix.offs;
121 return ix.offs as i64;
122 }
123 let os = c8(t, pos.wrapping_add(2));
124 if !(1..=4).contains(&os) {
125 ix.count = 0;
126 return -1;
127 }
128 let os = os as u32;
129 ix.offsize = os;
130 ix.offs = pos.wrapping_add(3);
131 ix.data = ix.offs.wrapping_add((count as u32 + 1).wrapping_mul(os));
132 let last = c_off(t, (count as u32).wrapping_mul(os).wrapping_add(ix.offs), os);
134 if last <= 0 {
135 ix.count = 0;
136 return -1;
137 }
138 let end = ix.data as u64 + last as u64 - 1;
139 if end > t.0.len() as u64 {
140 ix.count = 0;
141 return -1;
142 }
143 end as u32 as i64
144}
145
146fn ix_get(t: Tb, ix: &Index, i: u32) -> Option<(u32, u32)> {
148 if i >= ix.count {
149 return None;
150 }
151 let a = c_off(t, i.wrapping_mul(ix.offsize).wrapping_add(ix.offs), ix.offsize);
152 if a <= 0 {
153 return None;
154 }
155 let b = c_off(t, (i + 1).wrapping_mul(ix.offsize).wrapping_add(ix.offs), ix.offsize);
156 if b <= 0 || b < a {
157 return None;
158 }
159 let len = (b - a) as u64;
160 let start = ix.data as u64 + a as u64 - 1;
161 if start + len > t.0.len() as u64 {
162 return None;
163 }
164 if start as u32 as i32 >= 0 { Some((start as u32, len as u32)) } else { None }
165}
166
167fn ix2_parse(t: Tb, pos: u32, ix: &mut Index) -> i64 {
170 ix.count = 0;
171 let count = c_off(t, pos, 4);
172 if count < 0 {
173 return -1;
174 }
175 let base = pos as u64 + 4; if count == 0 {
177 ix.offsize = 1;
178 ix.offs = base as u32;
179 ix.data = base as u32;
180 return base as i64;
181 }
182 let os = c8(t, base as u32);
183 if !(1..=4).contains(&os) {
184 return -1;
185 }
186 let os = os as u64;
187 let offs = base + 1;
188 let data = offs + (count as u64 + 1) * os;
189 if data > t.len() as u64 {
190 return -1;
191 }
192 let last = c_off(t, (offs + count as u64 * os) as u32, os as u32);
193 if last <= 0 {
194 return -1;
195 }
196 let end = data + last as u64 - 1;
197 if end > t.len() as u64 {
198 return -1;
199 }
200 ix.count = count as u32;
201 ix.offsize = os as u32;
202 ix.offs = offs as u32;
203 ix.data = data as u32;
204 end as i64
205}
206
207fn dict2_walk(t: Tb, start: u32, end: u32, regions: &dyn Fn(u32) -> Option<u32>, f: &mut dyn FnMut(u32, &[f64])) -> bool {
214 let mut st: Vec<f64> = Vec::new();
215 let mut vsi = 0u32;
216 let mut p = start;
217 while p < end {
218 let b = c8(t, p);
219 if b < 0 {
220 return false;
221 }
222 let v: f64;
223 if b <= 27 {
224 p += 1;
225 let mut o = b as u32;
226 if o == 12 {
227 let b2 = c8(t, p);
228 if b2 < 0 {
229 return false;
230 }
231 p += 1;
232 o = 1200 + b2 as u32;
233 }
234 if o == 23 {
235 let Some(nv) = st.pop() else { return false };
237 let n = cvttd(nv);
238 let Some(k) = regions(vsi) else { return false };
239 if n < 0 {
240 return false;
241 }
242 let need = n as u64 * (k as u64 + 1);
243 if need > st.len() as u64 {
244 return false;
245 }
246 let keep = st.len() - need as usize + n as usize;
247 st.truncate(keep);
248 continue;
249 }
250 if o == 22 {
251 match st.last().map(|&x| cvttd(x)) {
252 Some(i) if i >= 0 => vsi = i as u32,
253 _ => {}
254 }
255 }
256 f(o, &st);
257 st.clear();
258 continue;
259 } else if b == 28 {
260 let w = c16(t, p.wrapping_add(1));
261 if w < 0 {
262 return false;
263 }
264 v = (w as u16 as i16) as f64;
265 p += 3;
266 } else if b == 29 {
267 let w = c_off(t, p.wrapping_add(1), 4);
268 if w < 0 {
269 return false;
270 }
271 v = (w as u32 as i32) as f64;
272 p += 5;
273 } else if b == 30 {
274 p += 1;
275 v = dict_real(t, &mut p);
276 } else if b == 31 || b == 255 {
277 p += 1; st.clear();
279 continue;
280 } else if b <= 246 {
281 v = (b - 139) as f64;
282 p += 1;
283 } else {
284 let b2 = c8(t, p.wrapping_add(1));
285 if b2 < 0 {
286 return false;
287 }
288 p += 2;
289 v = if b <= 250 { ((b - 247) * 256 + b2 + 108) as f64 } else { (-((b - 251) * 256 + b2 + 108)) as f64 };
290 }
291 if st.len() >= DICT2_STACK {
292 return false;
293 }
294 st.push(v);
295 }
296 true
297}
298
299fn dict2_find(t: Tb, start: u32, end: u32, op: u32, regions: &dyn Fn(u32) -> Option<u32>, ops: &mut [f64; OPS_MAX]) -> i32 {
302 let mut found = -1i32;
303 dict2_walk(t, start, end, regions, &mut |o, a| {
304 if found < 0 && o == op {
305 let a = &a[a.len().saturating_sub(OPS_MAX)..];
306 ops[..a.len()].copy_from_slice(a);
307 found = a.len() as i32;
308 }
309 });
310 found
311}
312
313fn cf2_private(t: Tb, start: u32, end: u32, vstore: u32, ix: &mut Index, ops: &mut [f64; OPS_MAX]) -> u16 {
316 ix.count = 0;
317 let n = dict2_find(t, start, end, 18, &|_| None, ops);
318 if n < 2 {
319 return 0;
320 }
321 let size = cvttd(ops[n as usize - 2]);
322 let off = cvttd(ops[n as usize - 1]);
323 if size <= 0 || off <= 0 || off as u32 >= t.len() {
324 return 0;
325 }
326 let off = off as u32;
327 let e = off.saturating_add(size as u32).min(t.len());
328 let regions = |vsi: u32| if vstore == 0 { None } else { var::ivs_region_count(t, vstore, vsi) };
329 let (mut subrs, mut vsi) = (None, 0u16);
330 dict2_walk(t, off, e, ®ions, &mut |o, a| {
331 let last = a.last().map(|&v| cvttd(v));
332 match (o, last) {
333 (19, Some(s)) if subrs.is_none() => subrs = Some(s),
334 (22, Some(v)) if (0..=0xFFFF).contains(&v) => vsi = v as u16,
335 _ => {}
336 }
337 });
338 if let Some(s) = subrs
339 && s > 0
340 && let Some(pos) = (s as u32).checked_add(off)
341 {
342 ix2_parse(t, pos, ix); }
344 vsi
345}
346
347fn dict_find(t: Tb, start: u32, end: u32, op: u32, ops: &mut [f64; OPS_MAX]) -> i32 {
352 let mut p = start;
353 let mut n = 0usize;
354 while p < end {
355 let b = c8(t, p);
356 if b < 0 {
357 return -1;
358 }
359 let v: f64;
360 if b <= 21 {
361 p += 1;
362 let mut o = b as u32;
363 if o == 12 {
364 let b2 = c8(t, p);
365 if b2 < 0 {
366 return -1;
367 }
368 p += 1;
369 o = 1200 + b2 as u32;
370 }
371 if o == op {
372 return n as i32;
373 }
374 n = 0;
375 continue;
376 } else if b == 28 {
377 let w = c16(t, p.wrapping_add(1));
378 if w < 0 {
379 return -1;
380 }
381 v = (w as u16 as i16) as f64;
382 p = p.wrapping_add(3);
383 } else if b == 29 {
384 let w = c_off(t, p.wrapping_add(1), 4);
385 if w < 0 {
386 return -1;
387 }
388 v = (w as u32 as i32) as f64;
389 p = p.wrapping_add(5);
390 } else if b == 30 {
391 p += 1;
392 v = dict_real(t, &mut p);
393 } else if b < 32 {
394 p += 1;
395 n = 0;
396 continue;
397 } else if b <= 246 {
398 v = (b - 139) as f64;
399 p += 1;
400 } else if b <= 254 {
401 let b2 = c8(t, p.wrapping_add(1));
402 if b2 < 0 {
403 return -1;
404 }
405 p = p.wrapping_add(2);
406 v = if b <= 250 {
407 ((b - 247) * 256 + b2 + 108) as f64
408 } else {
409 (-((b - 251) * 256 + b2 + 108)) as f64
410 };
411 } else {
412 p += 1;
413 n = 0;
414 continue;
415 }
416 if n < OPS_MAX {
417 ops[n] = v;
418 n += 1;
419 }
420 }
421 -1
422}
423
424fn dict_real(t: Tb, p: &mut u32) -> f64 {
426 let mut m = 0u64; let mut digits = 0i32; let mut fl = 0u32; let mut exp = 0i32;
430 'bytes: while (*p as usize) < t.0.len() {
431 let b = t.0[*p as usize] as u32;
432 *p += 1;
433 for nib in [b >> 4, b & 15] {
434 if nib <= 9 {
435 if fl & 4 != 0 {
436 if (exp as u32) < 1000 {
437 exp = exp * 10 + nib as i32;
438 }
439 } else if m >= 100_000_000_000_000_000 {
440 if fl & 2 == 0 {
441 digits -= 1; }
443 } else {
444 m = m * 10 + nib as u64;
445 if fl & 2 != 0 {
446 digits += 1;
447 }
448 }
449 continue;
450 }
451 match nib {
452 0xA => fl |= 2,
453 0xB => fl |= 4,
454 0xC => fl |= 4 | 8,
455 0xE => fl |= 1,
456 0xF => break 'bytes,
457 _ => {}
458 }
459 }
460 }
461 let mut v = m as i64 as f64;
463 if fl & 8 != 0 {
464 exp = exp.wrapping_neg();
465 }
466 let e = exp.wrapping_sub(digits);
467 if e > 0 {
468 if e as u32 > 400 {
469 return 0.0;
470 }
471 for _ in 0..e {
472 v = v * 10.0;
473 }
474 } else if e < 0 {
475 let mut c = e.wrapping_neg() as u32;
476 loop {
477 v = v / 10.0;
478 c -= 1;
479 if c == 0 {
480 break;
481 }
482 if c > 400 {
483 return 0.0;
484 }
485 }
486 }
487 if fl & 1 != 0 {
488 v = 0.0 - v;
489 }
490 v
491}
492
493fn cf_private(t: Tb, start: u32, end: u32, ix: &mut Index, ops: &mut [f64; OPS_MAX]) {
495 ix.count = 0;
496 let n = dict_find(t, start, end, 18, ops);
497 if n < 2 {
498 return;
499 }
500 let size = rt::fx::cvttd(ops[n as usize - 2]);
501 let off = rt::fx::cvttd(ops[n as usize - 1]);
502 if size <= 0 || off <= 0 || off as u32 >= t.len() {
503 return;
504 }
505 let off = off as u32;
506 let e = off.wrapping_add(size as u32).min(t.len());
507 let n = dict_find(t, off, e, 19, ops); if n < 1 {
509 return;
510 }
511 let s = rt::fx::cvttd(ops[n as usize - 1]);
512 if s <= 0 {
513 return;
514 }
515 let (pos, carry) = (s as u32).overflowing_add(off);
516 if carry {
517 return;
518 }
519 ix_parse(t, pos, ix);
520}
521
522impl Cff {
523 fn empty(v2: bool) -> Cff {
524 Cff {
525 v2,
526 cid: false,
527 cs: Index::default(),
528 gs: Index::default(),
529 ls: Index::default(),
530 fdsel: 0,
531 nfd: 0,
532 mat: [0.0; 6],
533 hasmat: false,
534 fdls: Vec::new(),
535 fdvs: Vec::new(),
536 vstore: 0,
537 maxstack: CS2_DEFSTACK as u32,
538 }
539 }
540
541 pub fn is_v2(&self) -> bool {
543 self.v2
544 }
545
546 pub fn varies(&self) -> bool {
548 self.v2 && self.vstore != 0
549 }
550
551 fn set_matrix(&mut self, m: &[f64], upem: u32) {
553 let u = upem as i32 as f64;
554 for (i, &v) in m.iter().take(6).enumerate() {
555 self.mat[i] = (v * u) as f32;
556 }
557 let abs = |v: f32| f32::from_bits(v.to_bits() & 0x7FFF_FFFF);
558 if abs(self.mat[0] - 1.0) > F_EPS || abs(self.mat[3] - 1.0) > F_EPS {
559 self.hasmat = true;
560 } else {
561 for i in [1, 2, 4, 5] {
562 if abs(self.mat[i]) > F_EPS {
563 self.hasmat = true;
564 break;
565 }
566 }
567 }
568 }
569
570 pub fn open(t: Tb, upem: u32) -> Result<Cff, i32> {
572 let mut ops = [0f64; OPS_MAX];
573 let mut c = Cff::empty(false);
574 if c8(t, 0) != 1 {
575 return Err(ERR_UNSUPPORTED);
576 }
577 let hs = c8(t, 2);
578 if hs < 0 {
579 return Err(ERR_HDR);
580 }
581 let mut top = Index::default();
583 let mut strs = Index::default();
584 let p = ix_parse(t, hs as u32, &mut top); if p < 0 {
586 return Err(ERR_HDR);
587 }
588 let p = ix_parse(t, p as u32, &mut top);
589 if p < 0 {
590 return Err(ERR_HDR);
591 }
592 let p = ix_parse(t, p as u32, &mut strs);
593 if p < 0 {
594 return Err(ERR_HDR);
595 }
596 if ix_parse(t, p as u32, &mut c.gs) < 0 {
597 return Err(ERR_HDR);
598 }
599 let Some((ds, dl)) = ix_get(t, &top, 0) else { return Err(ERR_HDR) };
600 let de = ds.wrapping_add(dl);
601 let n = dict_find(t, ds, de, 1206, &mut ops);
603 if n >= 1 && rt::fx::cvttd(ops[0]) != 2 {
604 return Err(ERR_UNSUPPORTED);
605 }
606 let n = dict_find(t, ds, de, 17, &mut ops);
608 if n < 1 {
609 return Err(ERR_HDR);
610 }
611 let o = rt::fx::cvttd(ops[n as usize - 1]);
612 if o <= 0 || ix_parse(t, o as u32, &mut c.cs) < 0 || c.cs.count == 0 {
613 return Err(ERR_HDR);
614 }
615 let n = dict_find(t, ds, de, 1207, &mut ops);
617 if n >= 6 {
618 let m = ops;
619 c.set_matrix(&m[..6], upem);
620 }
621 if dict_find(t, ds, de, 1230, &mut ops) >= 0 {
623 c.cid = true;
624 let n = dict_find(t, ds, de, 1236, &mut ops); if n < 1 {
626 return Err(ERR_HDR);
627 }
628 let o = rt::fx::cvttd(ops[n as usize - 1]);
629 if o <= 0 {
630 return Err(ERR_HDR);
631 }
632 let mut fda = Index::default();
633 if ix_parse(t, o as u32, &mut fda) < 0 {
634 return Err(ERR_HDR);
635 }
636 c.nfd = fda.count.min(FD_MAX);
637 let n = dict_find(t, ds, de, 1237, &mut ops); if n < 1 {
639 return Err(ERR_HDR);
640 }
641 let o = rt::fx::cvttd(ops[n as usize - 1]);
642 if o <= 0 || o as u32 >= t.len() {
643 return Err(ERR_HDR);
644 }
645 c.fdsel = o as u32;
646 c.fdls = vec![Index::default(); c.nfd as usize];
648 for fd in 0..c.nfd {
649 if let Some((s, l)) = ix_get(t, &fda, fd) {
650 cf_private(t, s, s.wrapping_add(l), &mut c.fdls[fd as usize], &mut ops);
651 }
652 }
653 } else {
654 cf_private(t, ds, de, &mut c.ls, &mut ops);
655 }
656 Ok(c)
657 }
658
659 pub fn open2(t: Tb, upem: u32) -> Result<Cff, i32> {
661 let mut ops = [0f64; OPS_MAX];
662 let mut c = Cff::empty(true);
663 if c8(t, 0) != 2 {
664 return Err(ERR_UNSUPPORTED);
665 }
666 let hs = c8(t, 2);
668 let tdl = c16(t, 3);
669 if hs < 5 || tdl < 0 {
670 return Err(ERR_HDR);
671 }
672 let ds = hs as u32;
673 let de = ds + tdl as u32;
674 if de > t.len() {
675 return Err(ERR_HDR);
676 }
677 let (mut cso, mut fda, mut fds, mut vst, mut maxst) = (None, None, None, None, None);
679 let mut mat: Option<[f64; 6]> = None;
680 dict2_walk(t, ds, de, &|_| None, &mut |op, a| {
681 let last = a.last().map(|&v| cvttd(v) as i64);
682 let slot = match op {
683 17 => &mut cso,
684 1236 => &mut fda,
685 1237 => &mut fds,
686 24 => &mut vst,
687 25 => &mut maxst,
688 1207 => {
689 if mat.is_none() && a.len() >= 6 {
690 mat = Some([a[0], a[1], a[2], a[3], a[4], a[5]]);
691 }
692 return;
693 }
694 _ => return,
695 };
696 if slot.is_none() {
697 *slot = last;
698 }
699 });
700 let len = t.len() as i64;
701 let pos = |o: Option<i64>| o.filter(|&o| o > 0 && o < len).map(|o| o as u32);
702 if ix2_parse(t, de, &mut c.gs) < 0 {
704 return Err(ERR_HDR);
705 }
706 match pos(cso) {
707 Some(o) if ix2_parse(t, o, &mut c.cs) >= 0 && c.cs.count != 0 => {}
708 _ => return Err(ERR_HDR),
709 }
710 if let Some(m) = mat {
711 c.set_matrix(&m, upem);
712 }
713 c.maxstack = maxst.unwrap_or(CS2_DEFSTACK).clamp(CS2_DEFSTACK, CS2_STACK as i64) as u32;
714 if let Some(o) = pos(vst)
716 && o as u64 + 2 < t.len() as u64
717 {
718 c.vstore = o + 2;
719 }
720 let mut fdix = Index::default();
722 match pos(fda) {
723 Some(o) if ix2_parse(t, o, &mut fdix) >= 0 && fdix.count != 0 => {}
724 _ => return Err(ERR_HDR),
725 }
726 c.cid = true;
727 c.nfd = fdix.count.min(FD_MAX);
728 c.fdsel = pos(fds).unwrap_or(0);
729 c.fdls = vec![Index::default(); c.nfd as usize];
730 c.fdvs = vec![0; c.nfd as usize];
731 for fd in 0..c.nfd as usize {
732 if let Some((s, l)) = ix_get(t, &fdix, fd as u32) {
733 c.fdvs[fd] = cf2_private(t, s, s.wrapping_add(l), c.vstore, &mut c.fdls[fd], &mut ops);
734 }
735 }
736 Ok(c)
737 }
738
739 fn fdselect(&self, t: Tb, glyph: u32) -> i32 {
741 let fs = self.fdsel;
742 if fs == 0 {
743 return 0; }
745 match c8(t, fs) {
746 0 => c8(t, fs.wrapping_add(glyph).wrapping_add(1)),
747 3 => {
748 let n = c16(t, fs.wrapping_add(1));
749 if n <= 0 {
750 return -1;
751 }
752 let (mut lo, mut hi) = (0u32, n as u32);
755 while lo < hi {
756 let mid = lo + (hi - lo) / 2;
757 let first = c16(t, mid.wrapping_mul(3).wrapping_add(fs).wrapping_add(3));
758 if first < 0 {
759 return -1;
760 }
761 if first as u32 > glyph {
762 hi = mid;
763 } else {
764 lo = mid + 1;
765 }
766 }
767 if lo == 0 {
768 return -1;
769 }
770 c8(t, (lo - 1).wrapping_mul(3).wrapping_add(fs).wrapping_add(5))
771 }
772 4 if self.v2 => {
773 let n = c_off(t, fs.wrapping_add(1), 4);
775 if n <= 0 {
776 return -1;
777 }
778 let first = |k: u64| -> i64 {
779 let at = fs as u64 + 5 + k * 6;
780 if at + 6 > t.len() as u64 { -1 } else { c_off(t, at as u32, 4) }
781 };
782 let (mut lo, mut hi) = (0u64, n as u64);
783 while lo < hi {
784 let mid = lo + (hi - lo) / 2;
785 let f = first(mid);
786 if f < 0 {
787 return -1;
788 }
789 if f as u64 > glyph as u64 {
790 hi = mid;
791 } else {
792 lo = mid + 1;
793 }
794 }
795 if lo == 0 {
796 return -1;
797 }
798 c16(t, (fs as u64 + 5 + (lo - 1) * 6 + 4) as u32)
799 }
800 _ => -1,
801 }
802 }
803
804 pub fn outline(&self, t: Tb, glyph: u32, ol: &mut Outline) -> bool {
806 self.outline_var(t, glyph, &[], ol)
807 }
808
809 pub fn outline_var(&self, t: Tb, glyph: u32, coords: &[i16], ol: &mut Outline) -> bool {
812 if glyph >= self.cs.count {
813 return true;
814 }
815 let (ls, vsi) = if self.cid {
816 let fd = self.fdselect(t, glyph);
817 if fd as u32 >= self.nfd {
818 return false;
819 }
820 (self.fdls[fd as usize], self.fdvs.get(fd as usize).copied().unwrap_or(0))
821 } else {
822 (self.ls, 0)
823 };
824 let Some((s, l)) = ix_get(t, &self.cs, glyph) else { return false };
825 let mut cs = Cs {
826 t,
827 gs: self.gs,
828 ls,
829 st: [0.0; CS2_STACK],
830 sp: 0,
831 maxst: if self.v2 { self.maxstack as usize } else { CS_STACK },
832 x: 0.0,
833 y: 0.0,
834 px: 0.0,
835 py: 0.0,
836 d: [0.0; 6],
837 nstems: 0,
838 wd: self.v2, open: false,
840 budget: CS_BUDGET,
841 trans: [0.0; 32],
842 rand: 0,
843 v2: self.v2,
844 vstore: self.vstore,
845 vsi: vsi as u32,
846 coords,
847 sc: Vec::new(),
848 nreg: None,
849 blended: false,
850 ol,
851 };
852 if cs.run(s, s.wrapping_add(l), 0) < 0 {
853 return false;
854 }
855 let ol = cs.ol;
856 ol.close();
857 if self.hasmat {
858 let m = self.mat;
860 ol.transform(0, m[0], m[1], m[2], m[3]);
861 ol.translate(0, m[4], m[5]);
862 }
863 true
864 }
865}
866
867fn cs_bias(count: u32) -> i32 {
869 if count < 1240 {
870 107
871 } else if count < 33900 {
872 1131
873 } else {
874 32768
875 }
876}
877
878fn fabs(v: f32) -> f32 {
879 f32::from_bits(v.to_bits() & 0x7FFF_FFFF)
880}
881
882fn zf(a: f32, b: f32) -> bool {
884 !(a < b || a > b)
885}
886
887struct Cs<'a, 'o> {
890 t: Tb<'a>,
891 gs: Index,
892 ls: Index,
893 st: [f32; CS2_STACK],
894 sp: usize,
895 maxst: usize, x: f32,
897 y: f32,
898 px: f32,
899 py: f32,
900 d: [f32; 6],
901 nstems: u32,
902 wd: bool,
903 open: bool,
904 budget: i32,
905 trans: [f32; 32], rand: u32,
907 v2: bool,
908 vstore: u32,
909 vsi: u32,
910 coords: &'a [i16],
911 sc: Vec<f32>,
912 nreg: Option<usize>,
913 blended: bool,
914 ol: &'o mut Outline,
915}
916
917enum Flow {
918 Clear,
919 Loop,
920 Err,
921 Ret1,
922}
923
924impl Cs<'_, '_> {
925 fn arg(&self, i: usize) -> f32 {
927 if i < self.sp { self.st[i] } else { 0.0 }
928 }
929
930 fn point(&mut self, tag: u8) {
932 if !self.open {
933 self.open = true;
935 self.ol.point(self.px, self.py, OLT_ON);
936 }
937 self.ol.point(self.x, self.y, tag);
938 }
939
940 fn line(&mut self, dx: f32, dy: f32) {
941 self.px = self.x;
942 self.py = self.y;
943 self.x = dx + self.x;
944 self.y = dy + self.y;
945 self.point(OLT_ON);
946 }
947
948 fn curve(&mut self) {
950 self.px = self.x;
951 self.py = self.y;
952 for i in 0..3 {
953 self.x = self.d[i * 2] + self.x;
954 self.y = self.d[i * 2 + 1] + self.y;
955 self.point(if i == 2 { OLT_ON } else { OLT_CUBIC });
956 }
957 }
958
959 fn d6(&mut self, i: usize) {
960 for k in 0..6 {
961 self.d[k] = self.arg(i + k);
962 }
963 }
964
965 fn curve6(&mut self, i: usize) {
966 self.d6(i);
967 self.curve();
968 }
969
970 fn width(&mut self, expected: usize) -> usize {
972 if self.wd {
973 return 0;
974 }
975 self.wd = true;
976 (self.sp > expected) as usize
977 }
978
979 fn width_even(&mut self) -> u32 {
981 if self.wd {
982 return 0;
983 }
984 self.wd = true;
985 (self.sp & 1) as u32
986 }
987
988 fn moveto_begin(&mut self) {
989 if self.open {
990 self.ol.close();
991 self.open = false;
992 }
993 }
994
995 fn moveto_end(&mut self) {
996 self.open = true;
997 self.ol.point(self.x, self.y, OLT_ON);
998 }
999
1000 fn push(&mut self, v: f32) -> Flow {
1001 if self.sp >= self.maxst {
1002 return Flow::Err;
1003 }
1004 self.st[self.sp] = v;
1005 self.sp += 1;
1006 Flow::Loop
1007 }
1008
1009 fn top(&self) -> Option<f32> {
1010 if self.sp == 0 { None } else { Some(self.st[self.sp - 1]) }
1011 }
1012
1013 fn settop(&mut self, v: f32) -> Flow {
1014 self.st[self.sp - 1] = v;
1015 Flow::Loop
1016 }
1017
1018 fn pop2(&mut self) -> Option<(f32, f32)> {
1020 if self.sp < 2 {
1021 return None;
1022 }
1023 self.sp -= 2;
1024 Some((self.st[self.sp], self.st[self.sp + 1]))
1025 }
1026
1027 fn roll(&mut self, num: i32, j: i32) {
1029 let mut r = j % num;
1030 if r < 0 {
1031 r += num;
1032 }
1033 let first = self.sp - num as usize;
1034 self.st[first..self.sp].rotate_right(r as usize);
1037 }
1038
1039 fn blend(&mut self) -> bool {
1043 let Some(nv) = self.top() else { return false };
1044 self.sp -= 1;
1045 let n = cvtt(nv);
1046 if n < 0 {
1047 return false;
1048 }
1049 let k = match self.nreg {
1050 Some(k) => k,
1051 None => {
1052 if var::ivs_scalars(self.t, self.vstore, self.vsi, self.coords, CS2_REGIONS, &mut self.sc).is_none() {
1053 return false;
1054 }
1055 self.nreg = Some(self.sc.len());
1056 self.sc.len()
1057 }
1058 };
1059 let n = n as usize;
1060 let Some(need) = n.checked_mul(k + 1) else { return false };
1061 if need > self.sp {
1062 return false;
1063 }
1064 let base = self.sp - need;
1065 for i in 0..n {
1066 let mut v = self.st[base + i];
1067 let d = base + n + i * k;
1068 for (r, &s) in self.sc[..k].iter().enumerate() {
1069 if s != 0.0 {
1070 v = v + self.st[d + r] * s;
1071 }
1072 }
1073 self.st[base + i] = v;
1074 }
1075 self.sp = base + n;
1076 self.blended = true;
1077 true
1078 }
1079
1080 fn run(&mut self, start: u32, end: u32, depth: u32) -> i32 {
1082 if depth > CS_DEPTH {
1083 return -1;
1084 }
1085 let t = self.t;
1086 let mut p = start;
1087 loop {
1088 if p >= end {
1089 return 0;
1090 }
1091 self.budget -= 1;
1092 if self.budget < 0 {
1093 return -1;
1094 }
1095 let b = t.0[p as usize] as u32;
1096 p += 1;
1097 let flow = if b >= 32 || b == 28 {
1098 let v: f32;
1100 if b == 28 {
1101 if p + 2 > end {
1102 return -1;
1103 }
1104 v = (u16::from_be_bytes([t.0[p as usize], t.0[p as usize + 1]]) as i16) as f32;
1105 p += 2;
1106 } else if b <= 246 {
1107 v = (b as i32 - 139) as f32;
1108 } else if b == 255 {
1109 if p + 4 > end {
1110 return -1;
1111 }
1112 let w = u32::from_be_bytes([
1113 t.0[p as usize],
1114 t.0[p as usize + 1],
1115 t.0[p as usize + 2],
1116 t.0[p as usize + 3],
1117 ]) as i32;
1118 p += 4;
1119 v = w as f32 * F_INV65536;
1120 } else {
1121 if p >= end {
1122 return -1;
1123 }
1124 let b2 = t.0[p as usize] as i32;
1125 p += 1;
1126 v = if b <= 250 {
1127 (((b as i32 - 247) << 8) + b2 + 108) as f32
1128 } else {
1129 (-(((b as i32 - 251) << 8) + b2 + 108)) as f32
1130 };
1131 }
1132 self.push(v)
1133 } else {
1134 match b {
1135 1 | 3 | 18 | 23 => {
1136 let n = self.width_even();
1138 self.nstems = self.nstems.wrapping_add((self.sp as u32 - n) >> 1);
1139 Flow::Clear
1140 }
1141 19 | 20 => {
1142 if self.sp != 0 {
1144 let n = self.width_even(); self.nstems = self.nstems.wrapping_add((self.sp as u32 - n) >> 1);
1146 }
1147 self.wd = true;
1148 p = p.wrapping_add(self.nstems.wrapping_add(7) >> 3);
1149 Flow::Clear
1150 }
1151 21 => {
1152 let i = self.width(2);
1154 self.moveto_begin();
1155 self.x = self.arg(i) + self.x;
1156 self.y = self.arg(i + 1) + self.y;
1157 self.moveto_end();
1158 Flow::Clear
1159 }
1160 22 => {
1161 let i = self.width(1);
1163 self.moveto_begin();
1164 self.x = self.arg(i) + self.x;
1165 self.moveto_end();
1166 Flow::Clear
1167 }
1168 4 => {
1169 let i = self.width(1);
1171 self.moveto_begin();
1172 self.y = self.arg(i) + self.y;
1173 self.moveto_end();
1174 Flow::Clear
1175 }
1176 5 => {
1177 let mut i = 0;
1179 while i + 2 <= self.sp {
1180 let (dx, dy) = (self.arg(i), self.arg(i + 1));
1181 self.line(dx, dy);
1182 i += 2;
1183 }
1184 Flow::Clear
1185 }
1186 6 | 7 => {
1187 let mut vert = b == 7;
1189 let mut i = 0;
1190 while i < self.sp {
1191 let v = self.arg(i);
1192 if vert { self.line(0.0, v) } else { self.line(v, 0.0) }
1193 vert = !vert;
1194 i += 1;
1195 }
1196 Flow::Clear
1197 }
1198 8 => {
1199 let mut i = 0;
1201 while i + 6 <= self.sp {
1202 self.curve6(i);
1203 i += 6;
1204 }
1205 Flow::Clear
1206 }
1207 24 => {
1208 let mut i = 0;
1210 while i + 8 <= self.sp {
1211 self.curve6(i);
1212 i += 6;
1213 }
1214 if i + 2 <= self.sp {
1215 let (dx, dy) = (self.arg(i), self.arg(i + 1));
1216 self.line(dx, dy);
1217 }
1218 Flow::Clear
1219 }
1220 25 => {
1221 let mut i = 0;
1223 while i + 8 <= self.sp {
1224 let (dx, dy) = (self.arg(i), self.arg(i + 1));
1225 self.line(dx, dy);
1226 i += 2;
1227 }
1228 if i + 6 <= self.sp {
1229 self.curve6(i);
1230 }
1231 Flow::Clear
1232 }
1233 27 => {
1234 let mut i = 0;
1236 self.d[1] = 0.0;
1237 if self.sp & 1 != 0 {
1238 self.d[1] = self.arg(0);
1239 i = 1;
1240 }
1241 while i + 4 <= self.sp {
1242 self.d[0] = self.arg(i);
1243 self.d[2] = self.arg(i + 1);
1244 self.d[3] = self.arg(i + 2);
1245 self.d[4] = self.arg(i + 3);
1246 self.d[5] = 0.0;
1247 self.curve();
1248 self.d[1] = 0.0;
1249 i += 4;
1250 }
1251 Flow::Clear
1252 }
1253 26 => {
1254 let mut i = 0;
1256 self.d[0] = 0.0;
1257 if self.sp & 1 != 0 {
1258 self.d[0] = self.arg(0);
1259 i = 1;
1260 }
1261 while i + 4 <= self.sp {
1262 self.d[1] = self.arg(i);
1263 self.d[2] = self.arg(i + 1);
1264 self.d[3] = self.arg(i + 2);
1265 self.d[4] = 0.0;
1266 self.d[5] = self.arg(i + 3);
1267 self.curve();
1268 self.d[0] = 0.0;
1269 i += 4;
1270 }
1271 Flow::Clear
1272 }
1273 30 | 31 => {
1274 let mut h = b == 31;
1276 let mut i = 0;
1277 while i + 4 <= self.sp {
1278 let last = (self.sp - i == 5) as usize;
1280 if h {
1281 self.d[0] = self.arg(i);
1282 self.d[1] = 0.0;
1283 self.d[2] = self.arg(i + 1);
1284 self.d[3] = self.arg(i + 2);
1285 self.d[5] = self.arg(i + 3);
1286 self.d[4] = 0.0;
1287 if last != 0 {
1288 self.d[4] = self.arg(i + 4);
1289 }
1290 } else {
1291 self.d[0] = 0.0;
1292 self.d[1] = self.arg(i);
1293 self.d[2] = self.arg(i + 1);
1294 self.d[3] = self.arg(i + 2);
1295 self.d[4] = self.arg(i + 3);
1296 self.d[5] = 0.0;
1297 if last != 0 {
1298 self.d[5] = self.arg(i + 4);
1299 }
1300 }
1301 self.curve();
1302 i += 4 + last;
1303 h = !h;
1304 }
1305 Flow::Clear
1306 }
1307 10 | 29 => {
1308 let ix = if b == 10 { self.ls } else { self.gs };
1310 if self.sp == 0 {
1311 return -1;
1312 }
1313 self.sp -= 1;
1314 let idx = cvtt(self.st[self.sp]);
1315 let i = cs_bias(ix.count).wrapping_add(idx);
1316 if i < 0 {
1317 return -1;
1318 }
1319 let Some((s, l)) = ix_get(t, &ix, i as u32) else { return -1 };
1320 let r = self.run(s, s.wrapping_add(l), depth + 1);
1321 if r < 0 {
1322 return -1;
1323 }
1324 if r != 0 {
1325 return 1; }
1327 Flow::Loop
1328 }
1329 11 => return 0, 15 if self.v2 => {
1331 let Some(v) = self.top() else { return -1 };
1333 let i = cvtt(v);
1334 if self.blended || i < 0 {
1335 return -1;
1336 }
1337 self.vsi = i as u32;
1338 self.nreg = None;
1339 Flow::Clear
1340 }
1341 16 if self.v2 => {
1342 if !self.blend() {
1343 return -1;
1344 }
1345 Flow::Loop }
1347 14 => {
1348 self.wd = true;
1350 self.moveto_begin();
1351 Flow::Ret1
1352 }
1353 12 => {
1354 if p >= end {
1355 return -1;
1356 }
1357 let e = t.0[p as usize] as u32;
1358 p += 1;
1359 self.escape(e)
1360 }
1361 _ => Flow::Clear, }
1363 };
1364 match flow {
1365 Flow::Clear => self.sp = 0,
1366 Flow::Loop => {}
1367 Flow::Err => return -1,
1368 Flow::Ret1 => return 1,
1369 }
1370 }
1371 }
1372
1373 fn escape(&mut self, e: u32) -> Flow {
1375 match e {
1376 35 => {
1377 if self.sp < 12 {
1379 return Flow::Clear;
1380 }
1381 self.d6(0);
1382 self.curve();
1383 self.d6(6);
1384 self.curve();
1385 Flow::Clear
1386 }
1387 34 => {
1388 if self.sp < 7 {
1390 return Flow::Clear;
1391 }
1392 let y0 = self.y;
1393 self.d = [self.arg(0), 0.0, self.arg(1), self.arg(2), self.arg(3), 0.0];
1394 self.curve();
1395 self.d[0] = self.arg(4);
1396 self.d[1] = 0.0;
1397 self.d[2] = self.arg(5);
1398 self.d[3] = y0 - self.y; self.d[4] = self.arg(6);
1400 self.d[5] = 0.0;
1401 self.curve();
1402 Flow::Clear
1403 }
1404 36 => {
1405 if self.sp < 9 {
1407 return Flow::Clear;
1408 }
1409 let y0 = self.y;
1410 self.d = [self.arg(0), self.arg(1), self.arg(2), self.arg(3), self.arg(4), 0.0];
1411 self.curve();
1412 self.d[0] = self.arg(5);
1413 self.d[1] = 0.0;
1414 self.d[2] = self.arg(6);
1415 self.d[3] = self.arg(7);
1416 self.d[4] = self.arg(8);
1417 self.d[5] = (y0 - self.y) - self.d[3]; self.curve();
1419 Flow::Clear
1420 }
1421 37 => {
1422 if self.sp < 11 {
1424 return Flow::Clear;
1425 }
1426 let (x0, y0) = (self.x, self.y);
1427 let (mut sx, mut sy) = (0.0f32, 0.0f32);
1428 for k in 0..5 {
1429 sx = sx + self.st[k * 2];
1430 sy = sy + self.st[k * 2 + 1];
1431 }
1432 let horiz = fabs(sx) > fabs(sy); self.d6(0);
1434 self.curve();
1435 self.d[0] = self.arg(6);
1436 self.d[1] = self.arg(7);
1437 self.d[2] = self.arg(8);
1438 self.d[3] = self.arg(9);
1439 let xx = (self.x + self.d[0]) + self.d[2];
1441 let yy = (self.y + self.d[1]) + self.d[3];
1442 let d6 = self.arg(10);
1443 if horiz {
1444 self.d[4] = d6;
1445 self.d[5] = y0 - yy;
1446 } else {
1447 self.d[5] = d6;
1448 self.d[4] = x0 - xx;
1449 }
1450 self.curve();
1451 Flow::Clear
1452 }
1453 9 => match self.top() {
1454 Some(v) => self.settop(fabs(v)),
1455 None => Flow::Err,
1456 },
1457 14 => match self.top() {
1458 Some(v) => self.settop(f32::from_bits(v.to_bits() ^ 0x8000_0000)),
1459 None => Flow::Err,
1460 },
1461 26 => match self.top() {
1462 Some(v) => self.settop(sqrt(fabs(v))),
1463 None => Flow::Err,
1464 },
1465 5 => match self.top() {
1466 Some(v) => self.settop(if zf(v, 0.0) { 1.0 } else { 0.0 }),
1467 None => Flow::Err,
1468 },
1469 10 | 11 | 24 | 12 | 3 | 4 | 15 => {
1470 let Some((a, b)) = self.pop2() else { return Flow::Err };
1471 let r = match e {
1472 10 => a + b,
1473 11 => a - b,
1474 24 => a * b,
1475 12 => {
1476 if zf(b, 0.0) {
1477 0.0
1478 } else {
1479 a / b
1480 }
1481 }
1482 3 => {
1483 if zf(a, 0.0) || zf(b, 0.0) {
1484 0.0
1485 } else {
1486 1.0
1487 }
1488 }
1489 4 => {
1490 if (a < 0.0 || a > 0.0) || (b < 0.0 || b > 0.0) {
1491 1.0
1492 } else {
1493 0.0
1494 }
1495 }
1496 _ => {
1497 if zf(a, b) {
1498 1.0
1499 } else {
1500 0.0
1501 }
1502 }
1503 };
1504 self.push(r)
1505 }
1506 18 => {
1507 if self.sp == 0 {
1509 return Flow::Err;
1510 }
1511 self.sp -= 1;
1512 Flow::Loop
1513 }
1514 27 => match self.top() {
1515 Some(v) => self.push(v),
1516 None => Flow::Err,
1517 },
1518 28 => {
1519 let Some((a, b)) = self.pop2() else { return Flow::Err };
1521 self.st[self.sp] = b;
1522 self.st[self.sp + 1] = a;
1523 self.sp += 2;
1524 Flow::Loop
1525 }
1526 29 => {
1527 let Some(v) = self.top() else { return Flow::Err };
1529 let mut i = cvtt(v);
1530 if i < 0 {
1531 i = 0;
1532 }
1533 let k = (self.sp as i32).wrapping_sub(2).wrapping_sub(i);
1534 if k < 0 {
1535 return Flow::Err;
1536 }
1537 let v = self.arg(k as usize);
1538 self.settop(v)
1539 }
1540 30 => {
1541 let Some((a, b)) = self.pop2() else { return Flow::Err };
1543 let num = cvtt(a);
1544 let j = cvtt(b);
1545 if num <= 0 {
1546 return Flow::Loop;
1547 }
1548 if num as usize > self.sp {
1549 return Flow::Err;
1550 }
1551 self.roll(num, j);
1552 Flow::Loop
1553 }
1554 20 => {
1555 let Some((a, b)) = self.pop2() else { return Flow::Err };
1557 let i = cvtt(b) as u32;
1558 if i < 32 {
1559 self.trans[i as usize] = a;
1560 }
1561 Flow::Loop
1562 }
1563 21 => {
1564 let Some(v) = self.top() else { return Flow::Err };
1566 let i = cvtt(v) as u32;
1567 if i >= 32 {
1568 return Flow::Err;
1569 }
1570 self.settop(self.trans[i as usize])
1571 }
1572 22 => {
1573 if self.sp < 4 {
1575 return Flow::Err;
1576 }
1577 self.sp -= 4;
1578 let s = self.sp;
1579 let v1 = self.st[s + 2];
1580 let v2 = self.st[s + 3];
1581 let r = if !(v1 > v2) { self.st[s] } else { self.st[s + 1] };
1582 self.push(r)
1583 }
1584 23 => {
1585 let r = self.rand.wrapping_mul(1_103_515_245).wrapping_add(12345);
1587 self.rand = r;
1588 let v = ((r >> 9) | 1) as i32 as f32 * F_INV8M; self.push(v)
1590 }
1591 _ => Flow::Clear, }
1593 }
1594}