xml-syntax-reader 0.1.0

Low-level, callback-based, streaming XML tokenizer
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
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

/// Which quote character delimited the attribute value.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QuoteStyle {
    Double,
    Single,
}

/// Sub-state within DOCTYPE content scanning.
///
/// Tracks whether the scanner is inside a comment, PI, or quoted string
/// so that `[`, `]`, and `>` inside those constructs are not misinterpreted
/// as structural delimiters.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DoctypeSubState {
    /// Normal scanning - `[`, `]`, `>` are structural.
    Normal,
    /// Saw `<` - checking for `!` (comment) or `?` (PI).
    AfterLt,
    /// Saw `<!` - checking for `-`.
    AfterLtBang,
    /// Saw `<!-` - expecting `-` to enter comment.
    AfterLtBangDash,
    /// Inside `<!-- ... -->`, tracking consecutive dashes for exit.
    Comment { dash_count: u8 },
    /// Inside `<? ... ?>`, tracking whether last byte was `?`.
    PI { saw_qmark: bool },
    /// Inside a double-quoted string.
    DoubleQuoted,
    /// Inside a single-quoted string.
    SingleQuoted,
}

/// Parser state: tracks which XML construct we are currently inside.
///
/// The `usize` fields store buffer-relative positions (not absolute stream offsets).
/// They are converted to absolute offsets when emitting events.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ParserState {
    /// Between markup. Scanning for `<` or `&` in text content.
    Content,

    /// Saw `<`, determining what kind of markup follows.
    AfterLt,

    /// Inside a start tag, reading the tag name.
    /// `name_start` is the buffer position of the first name character.
    StartTagName { name_start: usize },

    /// After the tag name in a start tag, before attributes or `>`.
    StartTagPostName,

    /// Reading an attribute name.
    /// `name_start` is the buffer position of the first name character.
    AttrName { name_start: usize },

    /// After attribute name, expecting `=`.
    AfterAttrName,

    /// After `=`, expecting a quote character.
    BeforeAttrValue,

    /// Inside a quoted attribute value.
    /// Position tracking uses `content_start` on Reader.
    /// `quote` records which delimiter character opened the value.
    AttrValue { quote: QuoteStyle },

    /// Entity reference inside an attribute value: after `&`, scanning for `;`.
    /// `name_start` is the buffer position of the first character after `&`.
    /// `quote` records which AttrValue state to return to after `;`.
    AttrEntityRef { name_start: usize, quote: QuoteStyle },

    /// Character reference inside an attribute value: after `&#`, scanning for `;`.
    /// `value_start` is the buffer position of the first character after `&#`.
    /// `quote` records which AttrValue state to return to after `;`.
    AttrCharRef { value_start: usize, quote: QuoteStyle },

    /// Inside `</`, reading the end tag name.
    /// `name_start` is the buffer position of the first name character.
    EndTagName { name_start: usize },

    /// After end tag name, expecting `>`.
    EndTagPostName,

    /// Saw `/` in a start tag, expecting `>` to complete `/>`.
    /// Used when `/` appears at the end of a buffer and `>` is in the next chunk.
    StartTagGotSlash,

    // --- Phase 2 states (comments, PIs, CDATA, DOCTYPE, references) ---

    /// After `<!`, need to determine comment, CDATA, or DOCTYPE.
    AfterLtBang,

    /// After `<!-`, expecting second `-` to start a comment.
    AfterLtBangDash,

    /// Comment content: scanning for `-->`.
    /// `dash_count` tracks consecutive dashes at the scanning position.
    CommentContent { dash_count: u8 },

    /// After `<![`, matching `CDATA[`.
    /// `matched` is how many characters of "CDATA[" have been matched so far.
    AfterLtBangBracket { matched: u8 },

    /// CDATA content: scanning for `]]>`.
    /// `bracket_count` tracks consecutive `]` at the scanning position.
    CdataContent { bracket_count: u8 },

    /// After `<!D`, matching `OCTYPE`.
    /// `matched` is how many characters of "OCTYPE" have been matched.
    AfterLtBangD { matched: u8 },

    /// After `<!DOCTYPE `, reading the root element name.
    /// `name_start` is the buffer position of the first name character.
    DoctypeName { name_start: usize },

    /// DOCTYPE content: scanning for `>` with balanced `[`/`]`.
    /// `depth` tracks bracket nesting depth.
    /// `sub` tracks comment/PI/quote context to avoid misinterpreting delimiters.
    DoctypeContent { depth: u32, sub: DoctypeSubState },

    /// Processing instruction: reading target name after `<?`.
    /// `name_start` is the buffer position of the first name character.
    PITarget { name_start: usize },

    /// Processing instruction content: scanning for `?>`.
    /// `saw_qmark` is true if the last character seen was `?`.
    PIContent { saw_qmark: bool },

    /// Entity reference in text content: after `&`, scanning for `;`.
    /// `name_start` is the buffer position of the first character after `&`.
    EntityRef { name_start: usize },

    /// Character reference: after `&#`, scanning for `;`.
    /// `value_start` is the buffer position of the first character after `&#` or `&#x`.
    CharRef { value_start: usize },
}

impl ParserState {
    /// Adjust all buffer-relative positions after the caller shifts the buffer
    /// by `consumed` bytes. Only states with `usize` position fields need updating.
    pub fn adjust_positions(&mut self, consumed: usize) {
        match self {
            ParserState::StartTagName { name_start } => *name_start -= consumed,
            ParserState::AttrName { name_start } => *name_start -= consumed,
            ParserState::AttrEntityRef { name_start, .. } => *name_start -= consumed,
            ParserState::AttrCharRef { value_start, .. } => *value_start -= consumed,
            ParserState::EndTagName { name_start } => *name_start -= consumed,
            ParserState::DoctypeName { name_start } if *name_start < usize::MAX - 1 => *name_start -= consumed,
            ParserState::PITarget { name_start } => *name_start -= consumed,
            ParserState::EntityRef { name_start } => *name_start -= consumed,
            ParserState::CharRef { value_start } => *value_start -= consumed,
            // States without buffer-relative positions:
            ParserState::Content
            | ParserState::AfterLt
            | ParserState::StartTagPostName
            | ParserState::StartTagGotSlash
            | ParserState::AfterAttrName
            | ParserState::BeforeAttrValue
            | ParserState::AttrValue { .. }
            | ParserState::EndTagPostName
            | ParserState::AfterLtBang
            | ParserState::AfterLtBangDash
            | ParserState::CommentContent { .. }
            | ParserState::AfterLtBangBracket { .. }
            | ParserState::CdataContent { .. }
            | ParserState::AfterLtBangD { .. }
            | ParserState::DoctypeName { .. }
            | ParserState::DoctypeContent { .. }
            | ParserState::PIContent { .. } => {}
        }
    }
}