Skip to main content

read_fonts/generated/
generated_maxp.rs

1// THIS FILE IS AUTOGENERATED.
2// Any changes to this file will be overwritten.
3// For more information about how codegen works, see font-codegen/README.md
4
5#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Maxp<'a> {
9    fn min_byte_range(&self) -> Range<usize> {
10        0..self.num_glyphs_byte_range().end
11    }
12    fn min_table_bytes(&self) -> &'a [u8] {
13        let range = self.min_byte_range();
14        self.offset_data().as_bytes().get(range).unwrap_or_default()
15    }
16}
17
18impl TopLevelTable for Maxp<'_> {
19    /// `maxp`
20    const TAG: Tag = Tag::new(b"maxp");
21}
22
23impl ReadArgs for Maxp<'_> {
24    type Args = ();
25}
26
27impl<'a> FontRead<'a> for Maxp<'a> {
28    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
29        #[allow(clippy::absurd_extreme_comparisons)]
30        if data.len() < Self::MIN_SIZE {
31            return Err(ReadError::OutOfBounds);
32        }
33        let Some(data) = TableDataRef::new(data.as_bytes()) else {
34            return Err(ReadError::OutOfBounds);
35        };
36        Ok(Self { data })
37    }
38}
39
40/// The fields at the start of the table, which are read directly.
41#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
42#[repr(C, packed)]
43#[doc(hidden)]
44pub struct MaxpFixedHeader {
45    pub version: BigEndian<Version16Dot16>,
46    pub num_glyphs: BigEndian<u16>,
47}
48
49#[allow(clippy::absurd_extreme_comparisons)]
50const _: () = assert!(std::mem::size_of::<MaxpFixedHeader>() <= Maxp::MIN_SIZE);
51
52/// [`maxp`](https://docs.microsoft.com/en-us/typography/opentype/spec/maxp)
53#[derive(Clone)]
54pub struct Maxp<'a> {
55    data: TableDataRef<'a, MaxpFixedHeader>,
56}
57
58#[allow(clippy::needless_lifetimes)]
59impl<'a> Maxp<'a> {
60    pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
61    basic_table_impls!(impl_the_methods);
62
63    /// The version: 0x00005000 for version 0.5, 0x00010000 for version 1.0.
64    pub fn version(&self) -> Version16Dot16 {
65        self.data.header().version.get()
66    }
67
68    /// The number of glyphs in the font.
69    pub fn num_glyphs(&self) -> u16 {
70        self.data.header().num_glyphs.get()
71    }
72
73    /// Maximum points in a non-composite glyph.
74    pub fn max_points(&self) -> Option<u16> {
75        let range = self.max_points_byte_range();
76        (!range.is_empty())
77            .then(|| self.offset_data().read_at(range.start).ok())
78            .flatten()
79    }
80
81    /// Maximum contours in a non-composite glyph.
82    pub fn max_contours(&self) -> Option<u16> {
83        let range = self.max_contours_byte_range();
84        (!range.is_empty())
85            .then(|| self.offset_data().read_at(range.start).ok())
86            .flatten()
87    }
88
89    /// Maximum points in a composite glyph.
90    pub fn max_composite_points(&self) -> Option<u16> {
91        let range = self.max_composite_points_byte_range();
92        (!range.is_empty())
93            .then(|| self.offset_data().read_at(range.start).ok())
94            .flatten()
95    }
96
97    /// Maximum contours in a composite glyph.
98    pub fn max_composite_contours(&self) -> Option<u16> {
99        let range = self.max_composite_contours_byte_range();
100        (!range.is_empty())
101            .then(|| self.offset_data().read_at(range.start).ok())
102            .flatten()
103    }
104
105    /// 1 if instructions do not use the twilight zone (Z0), or 2 if
106    /// instructions do use Z0; should be set to 2 in most cases.
107    pub fn max_zones(&self) -> Option<u16> {
108        let range = self.max_zones_byte_range();
109        (!range.is_empty())
110            .then(|| self.offset_data().read_at(range.start).ok())
111            .flatten()
112    }
113
114    /// Maximum points used in Z0.
115    pub fn max_twilight_points(&self) -> Option<u16> {
116        let range = self.max_twilight_points_byte_range();
117        (!range.is_empty())
118            .then(|| self.offset_data().read_at(range.start).ok())
119            .flatten()
120    }
121
122    /// Number of Storage Area locations.
123    pub fn max_storage(&self) -> Option<u16> {
124        let range = self.max_storage_byte_range();
125        (!range.is_empty())
126            .then(|| self.offset_data().read_at(range.start).ok())
127            .flatten()
128    }
129
130    /// Number of FDEFs, equal to the highest function number + 1.
131    pub fn max_function_defs(&self) -> Option<u16> {
132        let range = self.max_function_defs_byte_range();
133        (!range.is_empty())
134            .then(|| self.offset_data().read_at(range.start).ok())
135            .flatten()
136    }
137
138    /// Number of IDEFs.
139    pub fn max_instruction_defs(&self) -> Option<u16> {
140        let range = self.max_instruction_defs_byte_range();
141        (!range.is_empty())
142            .then(|| self.offset_data().read_at(range.start).ok())
143            .flatten()
144    }
145
146    /// Maximum stack depth across Font Program ('fpgm' table), CVT
147    /// Program ('prep' table) and all glyph instructions (in the
148    /// 'glyf' table).
149    pub fn max_stack_elements(&self) -> Option<u16> {
150        let range = self.max_stack_elements_byte_range();
151        (!range.is_empty())
152            .then(|| self.offset_data().read_at(range.start).ok())
153            .flatten()
154    }
155
156    /// Maximum byte count for glyph instructions.
157    pub fn max_size_of_instructions(&self) -> Option<u16> {
158        let range = self.max_size_of_instructions_byte_range();
159        (!range.is_empty())
160            .then(|| self.offset_data().read_at(range.start).ok())
161            .flatten()
162    }
163
164    /// Maximum number of components referenced at “top level” for
165    /// any composite glyph.
166    pub fn max_component_elements(&self) -> Option<u16> {
167        let range = self.max_component_elements_byte_range();
168        (!range.is_empty())
169            .then(|| self.offset_data().read_at(range.start).ok())
170            .flatten()
171    }
172
173    /// Maximum levels of recursion; 1 for simple components.
174    pub fn max_component_depth(&self) -> Option<u16> {
175        let range = self.max_component_depth_byte_range();
176        (!range.is_empty())
177            .then(|| self.offset_data().read_at(range.start).ok())
178            .flatten()
179    }
180
181    pub fn version_byte_range(&self) -> Range<usize> {
182        let start = 0;
183        let end = start + Version16Dot16::RAW_BYTE_LEN;
184        start..end
185    }
186
187    pub fn num_glyphs_byte_range(&self) -> Range<usize> {
188        let start = self.version_byte_range().end;
189        let end = start + u16::RAW_BYTE_LEN;
190        start..end
191    }
192
193    pub fn max_points_byte_range(&self) -> Range<usize> {
194        let start = self.num_glyphs_byte_range().end;
195        let end = if self.version().compatible((1u16, 0u16)) {
196            start + u16::RAW_BYTE_LEN
197        } else {
198            start
199        };
200        start..end
201    }
202
203    pub fn max_contours_byte_range(&self) -> Range<usize> {
204        let start = self.max_points_byte_range().end;
205        let end = if self.version().compatible((1u16, 0u16)) {
206            start + u16::RAW_BYTE_LEN
207        } else {
208            start
209        };
210        start..end
211    }
212
213    pub fn max_composite_points_byte_range(&self) -> Range<usize> {
214        let start = self.max_contours_byte_range().end;
215        let end = if self.version().compatible((1u16, 0u16)) {
216            start + u16::RAW_BYTE_LEN
217        } else {
218            start
219        };
220        start..end
221    }
222
223    pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
224        let start = self.max_composite_points_byte_range().end;
225        let end = if self.version().compatible((1u16, 0u16)) {
226            start + u16::RAW_BYTE_LEN
227        } else {
228            start
229        };
230        start..end
231    }
232
233    pub fn max_zones_byte_range(&self) -> Range<usize> {
234        let start = self.max_composite_contours_byte_range().end;
235        let end = if self.version().compatible((1u16, 0u16)) {
236            start + u16::RAW_BYTE_LEN
237        } else {
238            start
239        };
240        start..end
241    }
242
243    pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
244        let start = self.max_zones_byte_range().end;
245        let end = if self.version().compatible((1u16, 0u16)) {
246            start + u16::RAW_BYTE_LEN
247        } else {
248            start
249        };
250        start..end
251    }
252
253    pub fn max_storage_byte_range(&self) -> Range<usize> {
254        let start = self.max_twilight_points_byte_range().end;
255        let end = if self.version().compatible((1u16, 0u16)) {
256            start + u16::RAW_BYTE_LEN
257        } else {
258            start
259        };
260        start..end
261    }
262
263    pub fn max_function_defs_byte_range(&self) -> Range<usize> {
264        let start = self.max_storage_byte_range().end;
265        let end = if self.version().compatible((1u16, 0u16)) {
266            start + u16::RAW_BYTE_LEN
267        } else {
268            start
269        };
270        start..end
271    }
272
273    pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
274        let start = self.max_function_defs_byte_range().end;
275        let end = if self.version().compatible((1u16, 0u16)) {
276            start + u16::RAW_BYTE_LEN
277        } else {
278            start
279        };
280        start..end
281    }
282
283    pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
284        let start = self.max_instruction_defs_byte_range().end;
285        let end = if self.version().compatible((1u16, 0u16)) {
286            start + u16::RAW_BYTE_LEN
287        } else {
288            start
289        };
290        start..end
291    }
292
293    pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
294        let start = self.max_stack_elements_byte_range().end;
295        let end = if self.version().compatible((1u16, 0u16)) {
296            start + u16::RAW_BYTE_LEN
297        } else {
298            start
299        };
300        start..end
301    }
302
303    pub fn max_component_elements_byte_range(&self) -> Range<usize> {
304        let start = self.max_size_of_instructions_byte_range().end;
305        let end = if self.version().compatible((1u16, 0u16)) {
306            start + u16::RAW_BYTE_LEN
307        } else {
308            start
309        };
310        start..end
311    }
312
313    pub fn max_component_depth_byte_range(&self) -> Range<usize> {
314        let start = self.max_component_elements_byte_range().end;
315        let end = if self.version().compatible((1u16, 0u16)) {
316            start + u16::RAW_BYTE_LEN
317        } else {
318            start
319        };
320        start..end
321    }
322}
323
324const _: () = assert!(FontData::default_data_long_enough(Maxp::MIN_SIZE));
325
326impl Default for Maxp<'_> {
327    fn default() -> Self {
328        Self {
329            data: TableDataRef::new(FontData::default_table_data().as_bytes())
330                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
331        }
332    }
333}
334
335impl<'a> MinByteRange<'a> for MaxpExtended<'a> {
336    fn min_byte_range(&self) -> Range<usize> {
337        0..self.num_glyphs_byte_range().end
338    }
339    fn min_table_bytes(&self) -> &'a [u8] {
340        let range = self.min_byte_range();
341        self.offset_data().as_bytes().get(range).unwrap_or_default()
342    }
343}
344
345impl TopLevelTable for MaxpExtended<'_> {
346    /// `MAXP`
347    const TAG: Tag = Tag::new(b"MAXP");
348}
349
350impl ReadArgs for MaxpExtended<'_> {
351    type Args = ();
352}
353
354impl<'a> FontRead<'a> for MaxpExtended<'a> {
355    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
356        #[allow(clippy::absurd_extreme_comparisons)]
357        if data.len() < Self::MIN_SIZE {
358            return Err(ReadError::OutOfBounds);
359        }
360        let Some(data) = TableDataRef::new(data.as_bytes()) else {
361            return Err(ReadError::OutOfBounds);
362        };
363        Ok(Self { data })
364    }
365}
366
367/// The fields at the start of the table, which are read directly.
368#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
369#[repr(C, packed)]
370#[doc(hidden)]
371pub struct MaxpExtendedFixedHeader {
372    pub version: BigEndian<Version16Dot16>,
373    pub num_glyphs: BigEndian<Uint24>,
374}
375
376#[allow(clippy::absurd_extreme_comparisons)]
377const _: () = assert!(std::mem::size_of::<MaxpExtendedFixedHeader>() <= MaxpExtended::MIN_SIZE);
378
379/// MAXP maximum profile table (ISO/IEC 14496-22:2026, 5.1.12).
380#[derive(Clone)]
381pub struct MaxpExtended<'a> {
382    data: TableDataRef<'a, MaxpExtendedFixedHeader>,
383}
384
385#[allow(clippy::needless_lifetimes)]
386impl<'a> MaxpExtended<'a> {
387    pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + Uint24::RAW_BYTE_LEN);
388    basic_table_impls!(impl_the_methods);
389
390    pub fn version(&self) -> Version16Dot16 {
391        self.data.header().version.get()
392    }
393
394    /// The number of glyphs in the font.
395    pub fn num_glyphs(&self) -> Uint24 {
396        self.data.header().num_glyphs.get()
397    }
398
399    /// Maximum points in a non-composite glyph.
400    pub fn max_points(&self) -> Option<u16> {
401        let range = self.max_points_byte_range();
402        (!range.is_empty())
403            .then(|| self.offset_data().read_at(range.start).ok())
404            .flatten()
405    }
406
407    /// Maximum contours in a non-composite glyph.
408    pub fn max_contours(&self) -> Option<u16> {
409        let range = self.max_contours_byte_range();
410        (!range.is_empty())
411            .then(|| self.offset_data().read_at(range.start).ok())
412            .flatten()
413    }
414
415    /// Maximum points in a composite glyph.
416    pub fn max_composite_points(&self) -> Option<u16> {
417        let range = self.max_composite_points_byte_range();
418        (!range.is_empty())
419            .then(|| self.offset_data().read_at(range.start).ok())
420            .flatten()
421    }
422
423    /// Maximum contours in a composite glyph.
424    pub fn max_composite_contours(&self) -> Option<u16> {
425        let range = self.max_composite_contours_byte_range();
426        (!range.is_empty())
427            .then(|| self.offset_data().read_at(range.start).ok())
428            .flatten()
429    }
430
431    /// Number of zones used by instructions.
432    pub fn max_zones(&self) -> Option<u16> {
433        let range = self.max_zones_byte_range();
434        (!range.is_empty())
435            .then(|| self.offset_data().read_at(range.start).ok())
436            .flatten()
437    }
438
439    /// Maximum points in the twilight zone.
440    pub fn max_twilight_points(&self) -> Option<u16> {
441        let range = self.max_twilight_points_byte_range();
442        (!range.is_empty())
443            .then(|| self.offset_data().read_at(range.start).ok())
444            .flatten()
445    }
446
447    /// Number of storage locations.
448    pub fn max_storage(&self) -> Option<u16> {
449        let range = self.max_storage_byte_range();
450        (!range.is_empty())
451            .then(|| self.offset_data().read_at(range.start).ok())
452            .flatten()
453    }
454
455    /// Number of function definitions.
456    pub fn max_function_defs(&self) -> Option<u16> {
457        let range = self.max_function_defs_byte_range();
458        (!range.is_empty())
459            .then(|| self.offset_data().read_at(range.start).ok())
460            .flatten()
461    }
462
463    /// Number of instruction definitions.
464    pub fn max_instruction_defs(&self) -> Option<u16> {
465        let range = self.max_instruction_defs_byte_range();
466        (!range.is_empty())
467            .then(|| self.offset_data().read_at(range.start).ok())
468            .flatten()
469    }
470
471    /// Maximum interpreter stack depth.
472    pub fn max_stack_elements(&self) -> Option<u16> {
473        let range = self.max_stack_elements_byte_range();
474        (!range.is_empty())
475            .then(|| self.offset_data().read_at(range.start).ok())
476            .flatten()
477    }
478
479    /// Maximum glyph instruction byte count.
480    pub fn max_size_of_instructions(&self) -> Option<u16> {
481        let range = self.max_size_of_instructions_byte_range();
482        (!range.is_empty())
483            .then(|| self.offset_data().read_at(range.start).ok())
484            .flatten()
485    }
486
487    /// Maximum top-level component count.
488    pub fn max_component_elements(&self) -> Option<u16> {
489        let range = self.max_component_elements_byte_range();
490        (!range.is_empty())
491            .then(|| self.offset_data().read_at(range.start).ok())
492            .flatten()
493    }
494
495    /// Maximum component recursion depth.
496    pub fn max_component_depth(&self) -> Option<u16> {
497        let range = self.max_component_depth_byte_range();
498        (!range.is_empty())
499            .then(|| self.offset_data().read_at(range.start).ok())
500            .flatten()
501    }
502
503    pub fn version_byte_range(&self) -> Range<usize> {
504        let start = 0;
505        let end = start + Version16Dot16::RAW_BYTE_LEN;
506        start..end
507    }
508
509    pub fn num_glyphs_byte_range(&self) -> Range<usize> {
510        let start = self.version_byte_range().end;
511        let end = start + Uint24::RAW_BYTE_LEN;
512        start..end
513    }
514
515    pub fn max_points_byte_range(&self) -> Range<usize> {
516        let start = self.num_glyphs_byte_range().end;
517        let end = if self.version().compatible((1u16, 0u16)) {
518            start + u16::RAW_BYTE_LEN
519        } else {
520            start
521        };
522        start..end
523    }
524
525    pub fn max_contours_byte_range(&self) -> Range<usize> {
526        let start = self.max_points_byte_range().end;
527        let end = if self.version().compatible((1u16, 0u16)) {
528            start + u16::RAW_BYTE_LEN
529        } else {
530            start
531        };
532        start..end
533    }
534
535    pub fn max_composite_points_byte_range(&self) -> Range<usize> {
536        let start = self.max_contours_byte_range().end;
537        let end = if self.version().compatible((1u16, 0u16)) {
538            start + u16::RAW_BYTE_LEN
539        } else {
540            start
541        };
542        start..end
543    }
544
545    pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
546        let start = self.max_composite_points_byte_range().end;
547        let end = if self.version().compatible((1u16, 0u16)) {
548            start + u16::RAW_BYTE_LEN
549        } else {
550            start
551        };
552        start..end
553    }
554
555    pub fn max_zones_byte_range(&self) -> Range<usize> {
556        let start = self.max_composite_contours_byte_range().end;
557        let end = if self.version().compatible((1u16, 0u16)) {
558            start + u16::RAW_BYTE_LEN
559        } else {
560            start
561        };
562        start..end
563    }
564
565    pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
566        let start = self.max_zones_byte_range().end;
567        let end = if self.version().compatible((1u16, 0u16)) {
568            start + u16::RAW_BYTE_LEN
569        } else {
570            start
571        };
572        start..end
573    }
574
575    pub fn max_storage_byte_range(&self) -> Range<usize> {
576        let start = self.max_twilight_points_byte_range().end;
577        let end = if self.version().compatible((1u16, 0u16)) {
578            start + u16::RAW_BYTE_LEN
579        } else {
580            start
581        };
582        start..end
583    }
584
585    pub fn max_function_defs_byte_range(&self) -> Range<usize> {
586        let start = self.max_storage_byte_range().end;
587        let end = if self.version().compatible((1u16, 0u16)) {
588            start + u16::RAW_BYTE_LEN
589        } else {
590            start
591        };
592        start..end
593    }
594
595    pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
596        let start = self.max_function_defs_byte_range().end;
597        let end = if self.version().compatible((1u16, 0u16)) {
598            start + u16::RAW_BYTE_LEN
599        } else {
600            start
601        };
602        start..end
603    }
604
605    pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
606        let start = self.max_instruction_defs_byte_range().end;
607        let end = if self.version().compatible((1u16, 0u16)) {
608            start + u16::RAW_BYTE_LEN
609        } else {
610            start
611        };
612        start..end
613    }
614
615    pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
616        let start = self.max_stack_elements_byte_range().end;
617        let end = if self.version().compatible((1u16, 0u16)) {
618            start + u16::RAW_BYTE_LEN
619        } else {
620            start
621        };
622        start..end
623    }
624
625    pub fn max_component_elements_byte_range(&self) -> Range<usize> {
626        let start = self.max_size_of_instructions_byte_range().end;
627        let end = if self.version().compatible((1u16, 0u16)) {
628            start + u16::RAW_BYTE_LEN
629        } else {
630            start
631        };
632        start..end
633    }
634
635    pub fn max_component_depth_byte_range(&self) -> Range<usize> {
636        let start = self.max_component_elements_byte_range().end;
637        let end = if self.version().compatible((1u16, 0u16)) {
638            start + u16::RAW_BYTE_LEN
639        } else {
640            start
641        };
642        start..end
643    }
644}
645
646const _: () = assert!(FontData::default_data_long_enough(MaxpExtended::MIN_SIZE));
647
648impl Default for MaxpExtended<'_> {
649    fn default() -> Self {
650        Self {
651            data: TableDataRef::new(FontData::default_table_data().as_bytes())
652                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
653        }
654    }
655}