diff options
Diffstat (limited to 'crates/typst-library/src/routines.rs')
| -rw-r--r-- | crates/typst-library/src/routines.rs | 368 |
1 files changed, 368 insertions, 0 deletions
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs new file mode 100644 index 00000000..6b78b7fb --- /dev/null +++ b/crates/typst-library/src/routines.rs @@ -0,0 +1,368 @@ +#![allow(unused)] + +use std::hash::{Hash, Hasher}; +use std::num::NonZeroUsize; + +use comemo::{Tracked, TrackedMut}; +use typst_syntax::Span; +use typst_utils::LazyHash; + +use crate::diag::SourceResult; +use crate::engine::{Engine, Route, Sink, Traced}; +use crate::foundations::{ + Args, Cast, Closure, Content, Context, Func, Packed, Scope, StyleChain, StyleVec, + Styles, Value, +}; +use crate::introspection::{Introspector, Locator, SplitLocator}; +use crate::layout::{ + Abs, BoxElem, ColumnsElem, Fragment, Frame, GridElem, InlineItem, MoveElem, PadElem, + Region, Regions, Rel, RepeatElem, RotateElem, ScaleElem, Size, SkewElem, StackElem, +}; +use crate::math::EquationElem; +use crate::model::{Document, DocumentInfo, EnumElem, ListElem, TableElem}; +use crate::visualize::{ + CircleElem, EllipseElem, ImageElem, LineElem, PathElem, PolygonElem, RectElem, + SquareElem, +}; +use crate::World; + +/// Defines the `Routines` struct. +macro_rules! routines { + ($( + $(#[$attr:meta])* + fn $name:ident $(<$($time:lifetime),*>)? ($($args:tt)*) -> $ret:ty + )*) => { + /// Defines implementation of various Typst compiler routines as a table + /// of function pointers. + /// + /// This is essentially dynamic linking and done to allow for crate + /// splitting. + pub struct Routines { + $( + $(#[$attr])* + pub $name: $(for<$($time),*>)? fn ($($args)*) -> $ret + ),* + } + + impl Hash for Routines { + fn hash<H: Hasher>(&self, _: &mut H) {} + } + }; +} + +routines! { + /// Evaluates a string as code and return the resulting value. + fn eval_string( + routines: &Routines, + world: Tracked<dyn World + '_>, + string: &str, + span: Span, + mode: EvalMode, + scope: Scope, + ) -> SourceResult<Value> + + /// Call the closure in the context with the arguments. + fn eval_closure( + func: &Func, + closure: &LazyHash<Closure>, + routines: &Routines, + world: Tracked<dyn World + '_>, + introspector: Tracked<Introspector>, + traced: Tracked<Traced>, + sink: TrackedMut<Sink>, + route: Tracked<Route>, + context: Tracked<Context>, + args: Args, + ) -> SourceResult<Value> + + /// Realizes content into a flat list of well-known, styled items. + fn realize<'a>( + kind: RealizationKind, + engine: &mut Engine, + locator: &mut SplitLocator, + arenas: &'a Arenas, + content: &'a Content, + styles: StyleChain<'a>, + ) -> SourceResult<Vec<Pair<'a>>> + + /// Layout content into a document. + fn layout_document( + engine: &mut Engine, + content: &Content, + styles: StyleChain, + ) -> SourceResult<Document> + + /// Lays out content into multiple regions. + fn layout_fragment( + engine: &mut Engine, + content: &Content, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out content into a single region, producing a single frame. + fn layout_frame( + engine: &mut Engine, + content: &Content, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out inline content. + fn layout_inline( + engine: &mut Engine, + children: &StyleVec, + locator: Locator, + styles: StyleChain, + consecutive: bool, + region: Size, + expand: bool, + ) -> SourceResult<Fragment> + + /// Lays out a [`BoxElem`]. + fn layout_box( + elem: &Packed<BoxElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Size, + ) -> SourceResult<Frame> + + /// Lays out a [`ListElem`]. + fn layout_list( + elem: &Packed<ListElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out an [`EnumElem`]. + fn layout_enum( + elem: &Packed<EnumElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`GridElem`]. + fn layout_grid( + elem: &Packed<GridElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`TableElem`]. + fn layout_table( + elem: &Packed<TableElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`StackElem`]. + fn layout_stack( + elem: &Packed<StackElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`ColumnsElem`]. + fn layout_columns( + elem: &Packed<ColumnsElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`MoveElem`]. + fn layout_move( + elem: &Packed<MoveElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`RotateElem`]. + fn layout_rotate( + elem: &Packed<RotateElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`ScaleElem`]. + fn layout_scale( + elem: &Packed<ScaleElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`SkewElem`]. + fn layout_skew( + elem: &Packed<SkewElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`RepeatElem`]. + fn layout_repeat( + elem: &Packed<RepeatElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`PadElem`]. + fn layout_pad( + elem: &Packed<PadElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> + + /// Lays out a [`LineElem`]. + fn layout_line( + elem: &Packed<LineElem>, + _: &mut Engine, + _: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`PathElem`]. + fn layout_path( + elem: &Packed<PathElem>, + _: &mut Engine, + _: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`PolygonElem`]. + fn layout_polygon( + elem: &Packed<PolygonElem>, + _: &mut Engine, + _: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`RectElem`]. + fn layout_rect( + elem: &Packed<RectElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`SquareElem`]. + fn layout_square( + elem: &Packed<SquareElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`EllipseElem`]. + fn layout_ellipse( + elem: &Packed<EllipseElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out a [`CircleElem`]. + fn layout_circle( + elem: &Packed<CircleElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out an [`ImageElem`]. + fn layout_image( + elem: &Packed<ImageElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Region, + ) -> SourceResult<Frame> + + /// Lays out an [`EquationElem`] in a paragraph. + fn layout_equation_inline( + elem: &Packed<EquationElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + region: Size, + ) -> SourceResult<Vec<InlineItem>> + + /// Lays out an [`EquationElem`] in a flow. + fn layout_equation_block( + elem: &Packed<EquationElem>, + engine: &mut Engine, + locator: Locator, + styles: StyleChain, + regions: Regions, + ) -> SourceResult<Fragment> +} + +/// In which mode to evaluate a string. +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)] +pub enum EvalMode { + /// Evaluate as code, as after a hash. + Code, + /// Evaluate as markup, like in a Typst file. + Markup, + /// Evaluate as math, as in an equation. + Math, +} + +/// Defines what kind of realization we are performing. +pub enum RealizationKind<'a> { + /// This the root realization for the document. Requires a mutable reference + /// to document metadata that will be filled from `set document` rules. + Root(&'a mut DocumentInfo), + /// A nested realization in a container (e.g. a `block`). + Container, + /// A realization within math. + Math, +} + +/// Temporary storage arenas for lifetime extension during realization. +/// +/// Must be kept live while the content returned from realization is processed. +#[derive(Default)] +pub struct Arenas { + /// A typed arena for owned content. + pub content: typed_arena::Arena<Content>, + /// A typed arena for owned styles. + pub styles: typed_arena::Arena<Styles>, + /// An untyped arena for everything that is `Copy`. + pub bump: bumpalo::Bump, +} + +/// A pair of content and a style chain that applies to it. +pub type Pair<'a> = (&'a Content, StyleChain<'a>); |