ratex-parser 0.1.1

LaTeX parser for RaTeX
Documentation 
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

use std::collections::HashMap;

use crate::error::ParseResult;
use crate::functions::{define_function_full, ArgType, FunctionContext, FunctionSpec};
use crate::parse_node::{Mode, ParseNode};

static NON_STRETCHY: &[&str] = &[
    "\\acute", "\\grave", "\\ddot", "\\tilde", "\\bar", "\\breve",
    "\\check", "\\hat", "\\vec", "\\dot", "\\mathring",
];

pub fn register(map: &mut HashMap<&'static str, FunctionSpec>) {
    // Math-mode accents
    define_function_full(
        map,
        &[
            "\\acute", "\\grave", "\\ddot", "\\tilde", "\\bar", "\\breve",
            "\\check", "\\hat", "\\vec", "\\dot", "\\mathring", "\\widecheck",
            "\\widehat", "\\widetilde", "\\overrightarrow", "\\overleftarrow",
            "\\Overrightarrow", "\\overleftrightarrow", "\\overgroup",
            "\\overlinesegment", "\\overleftharpoon", "\\overrightharpoon",
        ],
        "accent",
        1, 0, None,
        false, false, true, false, false,
        handle_accent,
    );

    // Text-mode accents
    define_function_full(
        map,
        &[
            "\\'", "\\`", "\\^", "\\~", "\\=", "\\u", "\\.", "\\\"",
            "\\c", "\\r", "\\H", "\\v", "\\textcircled",
        ],
        "accent",
        1, 0,
        Some(vec![ArgType::Primitive]),
        false,
        true,  // allowed_in_text
        true,  // allowed_in_math
        false, false,
        handle_text_accent,
    );

    // Under-accents
    define_function_full(
        map,
        &[
            "\\underleftarrow", "\\underrightarrow", "\\underleftrightarrow",
            "\\undergroup", "\\underlinesegment", "\\utilde",
        ],
        "accentUnder",
        1, 0, None,
        false, false, true, false, false,
        handle_accent_under,
    );
}

fn handle_accent(
    ctx: &mut FunctionContext,
    args: Vec<ParseNode>,
    _opt_args: Vec<Option<ParseNode>>,
) -> ParseResult<ParseNode> {
    let base = ParseNode::normalize_argument(args.into_iter().next().unwrap());
    let func_name = &ctx.func_name;
    let is_stretchy = !NON_STRETCHY.contains(&func_name.as_str());
    let is_shifty = !is_stretchy
        || func_name == "\\widehat"
        || func_name == "\\widetilde"
        || func_name == "\\widecheck";

    Ok(ParseNode::Accent {
        mode: ctx.parser.mode,
        label: func_name.clone(),
        is_stretchy: Some(is_stretchy),
        is_shifty: Some(is_shifty),
        base: Box::new(base),
        loc: None,
    })
}

fn handle_text_accent(
    ctx: &mut FunctionContext,
    args: Vec<ParseNode>,
    _opt_args: Vec<Option<ParseNode>>,
) -> ParseResult<ParseNode> {
    let base = args.into_iter().next().unwrap();
    // Text accents always produce text-mode nodes, even in math mode
    let mode = Mode::Text;

    Ok(ParseNode::Accent {
        mode,
        label: ctx.func_name.clone(),
        is_stretchy: Some(false),
        is_shifty: Some(true),
        base: Box::new(base),
        loc: None,
    })
}

fn handle_accent_under(
    ctx: &mut FunctionContext,
    args: Vec<ParseNode>,
    _opt_args: Vec<Option<ParseNode>>,
) -> ParseResult<ParseNode> {
    let base = args.into_iter().next().unwrap();

    Ok(ParseNode::AccentUnder {
        mode: ctx.parser.mode,
        label: ctx.func_name.clone(),
        is_stretchy: Some(true),
        is_shifty: Some(false),
        base: Box::new(base),
        loc: None,
    })
}