nom如何区分负号和负数？答案

【问题标题】：How to distinguish between minus sign and negative number in nom?nom如何区分负号和负数？
【发布时间】：2019-08-20 14:07:50
【问题描述】：

使用解析器生成器nom，我如何编写一个解析器来提取术语1-2 和1*-2 中减号的差异？

在第一个示例中，我期望令牌 1、- 和 2。在第二个中，“减号”表示负数。预期的令牌是1、* 和-2。不是1、*、- 和2。

如何使用用户定义的状态（例如 expect_literal: bool）使 nom 有状态？

【问题讨论】：

这不是一个特定于 nom 的问题，它只是一个纯粹的概念解析/语法问题。此外，这是一个非常常见的解析问题；在提出这个问题之前，您似乎没有进行适当的研究。
我 99% 确定该州不需要解决这个问题。
另见How to parse an arithmetic string expression with negative numbers and minus signs?; Evaluate code, differentiating between minus and negative?; How to differentiate '-' operator from a negative number for a tokenizer; How Compiler distinguishes minus and negative number during parser process
请以minimal reproducible example 的形式提供创建解析器的最佳尝试，并附上具体的实现问题。
nom 不是解析器，也不是解析器生成器。 nom 是一个以解析器组合器方式轻松制作解析器的库。您如何标记完全取决于您，链接的问题正是您要问的问题。

标签： rust parser-generator nom

【解决方案1】：

我目前找到的最佳解决方案是使用nom_locate，其跨度定义为

use nom_locate::LocatedSpanEx;

#[derive(Clone, PartialEq, Debug)]
struct LexState {
    pub accept_literal: bool,
}

type Span<'a> = LocatedSpanEx<&'a str, LexState>;

然后你可以通过修改状态

fn set_accept_literal(
    value: bool,
    code: IResult<Span, TokenPayload>,
) -> IResult<Span, TokenPayload> {
    match code {
        Ok(mut span) => {
            span.0.extra.accept_literal = value;
            Ok(span)
        }
        _ => code,
    }
}

TokenPayload 是一个枚举，代表我的令牌内容。

现在你可以编写运算符解析器了：

fn mathematical_operators(code: Span) -> IResult<Span, TokenPayload> {
    set_accept_literal(
        true,
        alt((
            map(tag("*"), |_| TokenPayload::Multiply),
            map(tag("/"), |_| TokenPayload::Divide),
            map(tag("+"), |_| TokenPayload::Add),
            map(tag("-"), |_| TokenPayload::Subtract),
            map(tag("%"), |_| TokenPayload::Remainder),
        ))(code),
    )
}

而整数解析器为：

fn parse_integer(code: Span) -> IResult<Span, TokenPayload> {
    let chars = "1234567890";
    // Sign ?
    let (code, sign) = opt(tag("-"))(code)?;
    let sign = sign.is_some();
    if sign && !code.extra.accept_literal {
        return Err(nom::Err::Error((code, ErrorKind::IsNot)));
    }
    let (code, slice) = take_while(move |c| chars.contains(c))(code)?;
    match slice.fragment.parse::<i32>() {
        Ok(value) => set_accept_literal(
            false,
            Ok((code, TokenPayload::Int32(if sign { -value } else { value }))),
        ),
        Err(_) => Err(nom::Err::Error((code, ErrorKind::Tag))),
    }
}

这可能不会赢得选美比赛，但它确实有效。剩下的部分应该是微不足道的。

【讨论】：