1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
//! Dynamic typesetting functions.
use std::any::Any;
use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use toddle::query::FontClass;
use crate::layout::{Layout, LayoutContext, LayoutResult, MultiLayout};
use crate::parsing::{ParseContext, ParseResult};
use crate::syntax::{FuncHeader, SyntaxTree};
/// Typesetting function types.
///
/// These types have to be able to parse tokens into themselves and store the
/// relevant information from the parsing to do their role in typesetting later.
///
/// The trait `FunctionBounds` is automatically implemented for types which can
/// be used as functions, that is they fulfill the bounds `Debug + PartialEq +
/// 'static`.
pub trait Function: FunctionBounds {
/// Parse the header and body into this function given a context.
fn parse(header: &FuncHeader, body: Option<&str>, ctx: ParseContext) -> ParseResult<Self>
where Self: Sized;
/// Layout this function given a context.
///
/// Returns optionally the resulting layout and a new context if changes to
/// the context should be made.
fn layout(&self, ctx: LayoutContext) -> LayoutResult<FuncCommands>;
}
impl PartialEq for dyn Function {
fn eq(&self, other: &dyn Function) -> bool {
self.help_eq(other)
}
}
/// A sequence of commands requested for execution by a function.
#[derive(Debug)]
pub struct FuncCommands<'a> {
pub commands: Vec<Command<'a>>,
}
impl<'a> FuncCommands<'a> {
/// Create an empty command list.
pub fn new() -> FuncCommands<'a> {
FuncCommands { commands: vec![] }
}
/// Add a command to the sequence.
pub fn add(&mut self, command: Command<'a>) {
self.commands.push(command);
}
/// Whether there are any commands in this sequence.
pub fn is_empty(&self) -> bool {
self.commands.is_empty()
}
}
impl<'a> IntoIterator for FuncCommands<'a> {
type Item = Command<'a>;
type IntoIter = std::vec::IntoIter<Command<'a>>;
fn into_iter(self) -> Self::IntoIter {
self.commands.into_iter()
}
}
/// Commands requested for execution by functions.
#[derive(Debug)]
pub enum Command<'a> {
Layout(&'a SyntaxTree),
Add(Layout),
AddMany(MultiLayout),
ToggleStyleClass(FontClass),
}
/// A helper trait that describes requirements for types that can implement
/// [`Function`].
///
/// Automatically implemented for all types which fulfill to the bounds `Debug +
/// PartialEq + 'static`. There should be no need to implement this manually.
pub trait FunctionBounds: Debug {
/// Cast self into `Any`.
fn help_cast_as_any(&self) -> &dyn Any;
/// Compare self with another function.
fn help_eq(&self, other: &dyn Function) -> bool;
}
impl<T> FunctionBounds for T
where T: Debug + PartialEq + 'static
{
fn help_cast_as_any(&self) -> &dyn Any {
self
}
fn help_eq(&self, other: &dyn Function) -> bool {
if let Some(other) = other.help_cast_as_any().downcast_ref::<Self>() {
self == other
} else {
false
}
}
}
/// A map from identifiers to functions.
pub struct Scope {
parsers: HashMap<String, Box<ParseFunc>>,
}
/// A function which parses a function invocation into a function type.
type ParseFunc = dyn Fn(&FuncHeader, Option<&str>, ParseContext) -> ParseResult<Box<dyn Function>>;
impl Scope {
/// Create a new empty scope.
pub fn new() -> Scope {
Scope {
parsers: HashMap::new(),
}
}
/// Create a new scope with the standard functions contained.
pub fn with_std() -> Scope {
crate::library::std()
}
/// Add a function type to the scope giving it a name.
pub fn add<F: Function + 'static>(&mut self, name: &str) {
self.parsers.insert(
name.to_owned(),
Box::new(|h, b, c| F::parse(h, b, c).map(|func| Box::new(func) as Box<dyn Function>)),
);
}
/// Return the parser with the given name if there is one.
pub(crate) fn get_parser(&self, name: &str) -> Option<&ParseFunc> {
self.parsers.get(name).map(|x| &**x)
}
}
impl Debug for Scope {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "Scope ")?;
write!(f, "{:?}", self.parsers.keys())
}
}
|
