lexgen: 一个功能齐全的词法分析器生成器，实现为过程宏

lexer! {
    // First line specifies name of the lexer and the token type returned by
    // semantic actions
    Lexer -> Token;

    // Regular expressions can be named with `let` syntax
    let init = ['a'-'z'];
    let subseq = $init | ['A'-'Z' '0'-'9' '-' '_'];

    // Rule sets have names. Each rule set is compiled to a separate DFA.
    // Switching between rule sets is done explicitly in semantic actions.
    rule Init {
        // Rules without a right-hand side for skipping whitespace,
        // comments, etc.
        [' ' '\t' '\n']+,

        // Rule for matching identifiers
        $init $subseq* => |lexer| {
            let token = Token::Id(lexer.match_().to_owned());
            lexer.return_(token)
        },
    }
}

// The token type
#[derive(Debug, PartialEq, Eq)]
enum Token {
    // An identifier
    Id(String),
}

// Generated lexers are initialized with a `&str` for the input
let mut lexer = Lexer::new(" abc123Q-t  z9_9");

// Lexers implement `Iterator<Item=Result<(Loc, T, Loc), LexerError>>`,
// where `T` is the token type specified in the lexer definition (`Token` in
// this case), and `Loc`s indicate line, column, and byte indices of
// beginning and end of the lexemes.
assert_eq!(
    lexer.next(),
    Some(Ok((
        Loc { line: 0, col: 1, byte_idx: 1 },
        Token::Id("abc123Q-t".to_owned()),
        Loc { line: 0, col: 10, byte_idx: 10 }
    )))
);
assert_eq!(
    lexer.next(),
    Some(Ok((
        Loc { line: 0, col: 12, byte_idx: 12 },
        Token::Id("z9_9".to_owned()),
        Loc { line: 0, col: 16, byte_idx: 16 }
    )))
);
assert_eq!(lexer.next(), None);

另请参阅

• 测试中的简单词法分析器定义
• 完整的Lua 5.1词法分析器
• 使用lexgen和LALRPOP的示例
• OCaml简单版本的词法分析器
• Rust词法分析器

动机

实现词法分析通常是（与解析一起）实现语言中最枯燥的部分。词法分析生成器使这变得更加容易，但在Rust中现有的词法分析生成器缺少实际使用中的基本功能，并且/或者需要构建时的预处理步骤。

lexgen的目标是拥有一个功能齐全且易于使用的词法分析器生成器。

用法

lexgen不需要构建步骤。在您的Cargo.toml中将相同版本的lexgen和lexgen_util添加为依赖项。

词法分析器语法

lexgen词法分析器以生成的词法分析器结构的名称开头，可选的用户状态部分，以及令牌类型（语义动作返回的值类型）。示例

lexer! {
    Lexer(LexerState) -> Token;
    ...
}

这里生成的词法分析器类型将被命名为Lexer。用户状态类型是LexerState（此类型应由用户定义）。令牌类型是Token。

在词法分析器名称、用户状态和令牌类型之后，我们定义规则

rule Init {
    ...
}

rule SomeOtherRule {
    ...
}

第一个规则集将定义词法分析器的初始状态，需要命名为Init。

在rule块的主体中，我们定义该词法状态的规则。规则的语法为：<regex> => <语义动作>,。正则表达式的语法描述如下。语义动作是任何具有类型fn(LexerHandle) -> LexerAction的Rust代码，其中LexerHandle和LexerAction是源自词法器名称（例如，我们示例中的Lexer）生成的名称。下面将详细介绍这些类型。

可以使用let <name> = <regex>;语法为正则表达式命名。例如

let init = ['a'-'z'];
let subseq = $init | ['A'-'Z' '0'-'9' '-' '_'];

// Named regexes can be used with the `$` prefix
$init $subseq* => |lexer| { ... }

如果您不需要规则集，可以省略rule Init { ... }部分，并将所有规则放在顶层。

总之

• 第一行形式为<词法器名称>(<用户状态类型类型>) -> <令牌类型名称>。对于无状态的词法器，可以省略(<用户状态类型类型>)部分。

• 接下来是规则集。应该至少有一个名为Init的规则集，这是初始状态的名字。

• 可以在顶层或在rule中添加let绑定。

lexer! {
    // `usize` in parenthesis is the user state type, `usize` after the arrow
    // is the token type
    Lexer(usize) -> usize;

    rule Init {
        $$ascii_whitespace,                             // line 7

        '[' => |lexer| {
            *lexer.state() = 0;                         // line 10
            lexer.switch(LexerRule::Count)              // line 11
        },
    }

    rule Count {
        '=' => |lexer| {
            *lexer.state() += 1;                        // line 17
            lexer.continue_()                           // line 18
        },

        '[' => |lexer| {
            let n = *lexer.state();
            lexer.switch_and_return(LexerRule::Init, n) // line 23
        },
    }
}

let mut lexer = Lexer::new("[[ [=[ [==[");
assert_eq!(
    lexer.next(),
    Some(Ok((
        Loc { line: 0, col: 0, byte_idx: 0 },
        0,
        Loc { line: 0, col: 2, byte_idx: 2 },
    )))
);
assert_eq!(
    lexer.next(),
    Some(Ok((
        Loc { line: 0, col: 3, byte_idx: 3 },
        1,
        Loc { line: 0, col: 6, byte_idx: 6 },
    )))
);
assert_eq!(
    lexer.next(),
    Some(Ok((
        Loc { line: 0, col: 7, byte_idx: 7 },
        2,
        Loc { line: 0, col: 11, byte_idx: 11 },
    )))
);
assert_eq!(lexer.next(), None);