xrust 2.0.3

Support for XPath and XSLT
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

use crate::item::Node;
use crate::parser::combinators::delimited::delimited;
use crate::parser::combinators::tag::tag;
use crate::parser::combinators::take::take_until;
use crate::parser::{ParseError, ParseInput, ParseResult, StaticState};
use crate::xmldecl::DTDDecl;
use qualname::{NamespacePrefix, NamespaceUri};

pub(crate) fn geexpander(inp: RNode) -> RNode {}

pub(crate) fn genentityexpander<N: Node, L>()
-> impl Fn(ParseInput<N>, &StaticState<L>) -> Result<(ParseInput<N>, String), ParseError> + 'static
{
    move |input| {
        let e = delimited(tag("&"), take_until(";"), tag(";"))(input);

        match e {
            Err(usize) => Err(usize),
            Ok((mut input1, entitykey)) => {
                match input1.dtd.generalentities.get(&entitykey as &str) {
                    Some(DTDDecl::GeneralEntity(_, v)) => {
                        if input1.currententitydepth >= input1.maxentitydepth {
                            //attempting to exceed expansion depth
                            Err(ParseError::EntityDepth {
                                col: input1.currentcol,
                                row: input1.currentrow,
                            })
                        } else {
                            for ch in v.chars().rev() {
                                input1.entityfeed.push(ch);
                            }
                            input1.currententitydepth += 1;
                            Ok((input1, "".to_string()))
                        }
                    }
                    None => Err(ParseError::MissingGenEntity {
                        col: input1.currentcol,
                        row: input1.currentrow,
                    }),
                    _ => Err(ParseError::Unknown {
                        col: input1.currentcol,
                        row: input1.currentrow,
                    }),
                }
            }
        }
    }
}

pub(crate) fn paramentityexpander<N: Node, L: NSResolver>()
-> impl Fn(ParseInput<N>, &StaticState<L>) -> Result<(ParseInput<N>, String), ParseError> + 'static
{
    move |input| {
        let e = delimited(tag("%"), take_until(";"), tag(";"))(input);

        match e {
            Err(err) => Err(err),
            Ok((mut input1, entitykey)) => {
                match input1.dtd.paramentities.get(&entitykey as &str) {
                    Some(DTDDecl::ParamEntity(_, v)) => {
                        if input1.currententitydepth >= input1.maxentitydepth {
                            //attempting to exceed expansion depth
                            Err(ParseError::EntityDepth {
                                col: input1.currentcol,
                                row: input1.currentrow,
                            })
                        } else {
                            for ch in v.chars().rev() {
                                input1.entityfeed.push(ch);
                            }
                            input1.currententitydepth += 1;
                            Ok((input1, "".to_string()))
                        }
                    }
                    None => Err(ParseError::MissingParamEntity {
                        col: input1.currentcol,
                        row: input1.currentrow,
                    }),
                    _ => Err(ParseError::Unknown {
                        col: input1.currentcol,
                        row: input1.currentrow,
                    }),
                }
            }
        }
    }
}