1
/*
2
 * Hurl (https://hurl.dev)
3
 * Copyright (C) 2025 Orange
4
 *
5
 * Licensed under the Apache License, Version 2.0 (the "License");
6
 * you may not use this file except in compliance with the License.
7
 * You may obtain a copy of the License at
8
 *
9
 *          http://www.apache.org/licenses/LICENSE-2.0
10
 *
11
 * Unless required by applicable law or agreed to in writing, software
12
 * distributed under the License is distributed on an "AS IS" BASIS,
13
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 * See the License for the specific language governing permissions and
15
 * limitations under the License.
16
 *
17
 */
18
use crate::reader::Reader;
19

            
20
/// Represent a parser error. This type of error ca be recoverable or not and
21
/// implements conversion to recoverable / non-recoverable instance.
22
pub trait ParseError {
23
    /// Is this error recoverable or not?
24
    fn is_recoverable(&self) -> bool;
25

            
26
    /// Transforms this error to a recoverable one.
27
    fn to_recoverable(self) -> Self;
28

            
29
    /// Transforms this error to a non-recoverable one.
30
    fn to_non_recoverable(self) -> Self;
31
}
32

            
33
/// A parser func.
34
pub type ParseFunc<T, E> = fn(&mut Reader) -> Result<T, E>;
35

            
36
/// Try to consume one instances of the provided parser.
37
355680
pub fn optional<T, E>(f: ParseFunc<T, E>, reader: &mut Reader) -> Result<Option<T>, E>
38
355680
where
39
355680
    E: ParseError,
40
{
41
355680
    let start = reader.cursor();
42
355680
    match f(reader) {
43
32260
        Ok(r) => Ok(Some(r)),
44
323420
        Err(e) => {
45
323420
            if e.is_recoverable() {
46
323280
                reader.seek(start);
47
323280
                Ok(None)
48
            } else {
49
140
                Err(e)
50
            }
51
        }
52
    }
53
}
54

            
55
/// Makes an error recoverable but does not reset cursor.
56
288825
pub fn recover<T, E>(f: ParseFunc<T, E>, reader: &mut Reader) -> Result<T, E>
57
288825
where
58
288825
    E: ParseError,
59
{
60
288825
    match f(reader) {
61
96265
        Ok(r) => Ok(r),
62
192560
        Err(e) => Err(e.to_recoverable()),
63
    }
64
}
65

            
66
/// Makes an error non recoverable.
67
2895
pub fn non_recover<T, E>(f: ParseFunc<T, E>, reader: &mut Reader) -> Result<T, E>
68
2895
where
69
2895
    E: ParseError,
70
{
71
2895
    match f(reader) {
72
2765
        Ok(r) => Ok(r),
73
130
        Err(e) => Err(e.to_non_recoverable()),
74
    }
75
}
76

            
77
/// Consumes zero or more instances of the provided parser.
78
828996
pub fn zero_or_more<T, E>(f: ParseFunc<T, E>, reader: &mut Reader) -> Result<Vec<T>, E>
79
828996
where
80
828996
    E: ParseError,
81
{
82
828996
    let mut v = Vec::new();
83
    loop {
84
1073324
        let initial_state = reader.cursor();
85
1073324
        if reader.is_eof() {
86
27561
            return Ok(v);
87
        }
88

            
89
1045763
        match f(reader) {
90
244328
            Ok(r) => {
91
244328
                v.push(r);
92
            }
93
801435
            Err(e) => {
94
801435
                return if e.is_recoverable() {
95
800972
                    reader.seek(initial_state);
96
800972
                    Ok(v)
97
                } else {
98
463
                    Err(e)
99
                };
100
            }
101
        }
102
    }
103
}
104

            
105
/// Consumes one or more instances of the provided parser.
106
69410
pub fn one_or_more<T, E>(f: ParseFunc<T, E>, reader: &mut Reader) -> Result<Vec<T>, E>
107
69410
where
108
69410
    E: ParseError,
109
{
110
69410
    match f(reader) {
111
69390
        Ok(first) => {
112
69390
            let mut v = vec![first];
113
            loop {
114
69980
                let initial_state = reader.cursor();
115
69980
                match f(reader) {
116
590
                    Ok(r) => {
117
590
                        v.push(r);
118
                    }
119
69390
                    Err(e) => {
120
69390
                        return if e.is_recoverable() {
121
69390
                            reader.seek(initial_state);
122
69390
                            Ok(v)
123
                        } else {
124
                            Err(e)
125
                        };
126
                    }
127
                }
128
            }
129
        }
130
        // if zero occurrence => should fail?
131
20
        Err(e) => Err(e.to_non_recoverable()),
132
    }
133
}
134

            
135
/// Tries to apply the list of parser until one of them succeeds.
136
/// Typically, this should be recoverable
137
162146
pub fn choice<T, E>(fs: &[ParseFunc<T, E>], reader: &mut Reader) -> Result<T, E>
138
162146
where
139
162146
    E: ParseError,
140
{
141
1604418
    for (pos, f) in fs.iter().enumerate() {
142
1604418
        let start = reader.cursor();
143
1604418
        if pos == fs.len() - 1 {
144
86352
            return f(reader);
145
        }
146
1518066
        match f(reader) {
147
1442421
            Err(err) if err.is_recoverable() => {
148
1442272
                reader.seek(start);
149
1442272
                continue;
150
            }
151
75794
            x => return x,
152
        }
153
    }
154
    unreachable!("You can't call choice with an empty vector of choice")
155
}