使用解析器组合器解析带有转义字符的字符串？

Question

我正在尝试使用Rust中的combine库来解析字符串。我要解析的真实数据看起来像这样：

A79,216,0,4,2,2,N,"US\"PS"

所以在数据的末尾有一个带引号的字符串，但该字符串也包含转义字符。我无法弄清如何解析这些转义字符并将其放置在其他引号之间。

extern crate parser_combinators;

use self::parser_combinators::*;

fn main() {
    let s = r#""HE\"LLO""#;
    let data = many(satisfy(|c| c != '"')); // Fails on escaped " obviously
    let mut str_parser = between(satisfy(|c| c == '"'), satisfy(|c| c == '"'), data);
    let result : Result<(String, &str), ParseError> = str_parser.parse(s);
    match result {
        Ok((value, _)) => println!("{:?}", value),
        Err(err) => println!("{}", err),
    }
}

//=> "HE\\"

上面的代码可以成功解析该字符串，但显然在中间的转义字符上会失败，最终输出"HE\\"。

我想修改上面的代码，使其输出"HE\\\"LLO"。

我该如何做到这一点？

- Fredrik

---

"\"HE\\\"LLO\"" 可能更好地写成 r#""HE\"LLO""#。 - Chris Morgan

@ChrisMorgan 啊，原来是这样做相当于' '，我更新了例子。 - Fredrik

Rust使用类似C♯的原始字符串，允许r"..."、r#"..."#、r##"..."##等格式。 - Chris Morgan

Answer 1

我有一个大部分功能正常的JSON解析器，作为解析器组合子的基准，可以解析这种转义字符。下面附有它的链接和稍微简化的版本。

fn json_char(input: State<&str>) -> ParseResult<char, &str> {
    let (c, input) = try!(satisfy(|c| c != '"').parse_state(input));
    let mut back_slash_char = satisfy(|c| "\"\\nrt".chars().find(|x| *x == c).is_some()).map(|c| {
        match c {
            '"' => '"',
            '\\' => '\\',
            'n' => '\n',
            'r' => '\r',
            't' => '\t',
            c => c//Should never happen
        }
    });
    match c {
        '\\' => input.combine(|input| back_slash_char.parse_state(input)),
        _    => Ok((c, input))
    }
}

json_char

由于此解析器可能会消耗1或2个字符，因此不能仅使用原始组合器，因此我们需要引入一个函数，该函数可以根据解析的字符进行分支。

- Mar

Answer 2

我遇到了同样的问题，最终得出了以下解决方案：

    (
        char('"'),
        many1::<Vec<char>, _>(choice((
            escaped_character(),
            satisfy(|c| c != '"'),
        ))),
        char('"')
    )

换句话说，一个字符串由"分隔，后面跟着许多转义字符或任何不是闭合"的字符，并以闭合"结束。

这是我如何使用它的完整示例：

pub enum Operand {
    String { value: String },
}

fn escaped_character<I>() -> impl Parser<Input = I, Output = char>
    where
        I: Stream<Item = char>,
        I::Error: ParseError<I::Item, I::Range, I::Position>,
{
    (
        char('\\'),
        any(),
    ).and_then(|(_, x)| match x {
        '0' => Ok('\0'),
        'n' => Ok('\n'),
        '\\' => Ok('\\'),
        '"' => Ok('"'),
        _ => Err(StreamErrorFor::<I>::unexpected_message(format!("Invalid escape sequence \\{}", x)))
    })
}

#[test]
fn parse_escaped_character() {
    let expected = Ok(('\n', " foo"));
    assert_eq!(expected, escaped_character().easy_parse("\\n foo"))
}

fn string_operand<I>() -> impl Parser<Input = I, Output = Operand>
    where
        I: Stream<Item = char>,
        I::Error: ParseError<I::Item, I::Range, I::Position>,
{
    (
        char('"'),
        many1::<Vec<char>, _>(choice((
            escaped_character(),
            satisfy(|c| c != '"'),
        ))),
        char('"')
    )
        .map(|(_,value,_)| Operand::String { value: value.into_iter().collect() })
}

#[test]
fn parse_string_operand() {
    let expected = Ok((Operand::String { value: "foo \" bar \n baz \0".into() }, ""));
    assert_eq!(expected, string_operand().easy_parse(r#""foo \" bar \n baz \0""#))
}

- fresskoma