reggy 0.0.6

friendly, resumable regular expressions for text analytics
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

use std::str::FromStr;

use crate::parser::{ParseError, lexer, ast, Error};
use lexer::Tok;
use ast::Ast;

grammar();

pub Ast: ast::Ast = {
    #[precedence(level="0")]
    Term,
    
    #[precedence(level="1")] #[assoc(side="right")]
    <t: Ast> "?" => Ast::optional(t),
    <t: Ast> "{" <n: Nat> "}" =>? {
        if let Some(n) = n {
            Ok(Ast::quantifier_exact(t, n))
        } else {
            Err(ParseError::User { error: Error::ParseError })
        }
    },
    <t: Ast> "{" <min: Nat> "," <max: Nat> "}" =>? {
        if let (Some(min), Some(max)) = (min, max) {
            Ok(Ast::quantifier_range(t, min, max))
        } else {
            Err(ParseError::User { error: Error::ParseError })
        }
    },
    #[precedence(level="2")] #[assoc(side="left")]
    <lhs: Ast> <rhs: Ast> => Ast::then(lhs, rhs),
    
    #[precedence(level="3")] #[assoc(side="left")]
    <lhs: Ast> "|" <rhs: Ast> => Ast::or(lhs, rhs),
}

Term: ast::Ast = {
    <c: "char"> => Ast::char(c),
    <"digit"> => Ast::digit(),
    <" "> => Ast::space(),
    "(" <p: Ast> ")" => p,
    "(" "!" <p: Ast> ")" => Ast::case_sensitive(p)
}

Nat: Option<u32> = <s: NatSeq> => s.as_deref().map(u32::from_str)?.ok();

NatSeq: Option<String> = {
    <c: "char"> => {
        if c.is_ascii_digit() {
            Some(String::from(c))
        } else {
            None
        }
    },
    <substr: NatSeq> <c: "char"> => {
        if let Some(mut substr) = substr {
            if c.is_ascii_digit() {
                substr.push(c);
                Some(substr)
            } else {
                None
            }
        } else {
            None
        }
    }
}

extern {
    type Location = usize;
    type Error = Error;

    enum Tok {
        "|" => lexer::Tok::Or,
        "?" => lexer::Tok::QMark,
        "(" => lexer::Tok::LParen,
        ")" => lexer::Tok::RParen,
        "{" => lexer::Tok::LCurly,
        "}" => lexer::Tok::RCurly,
        "!" => lexer::Tok::Exclam,
        "," => lexer::Tok::Comma,
        "char" => lexer::Tok::Char { c: <char>, .. },
        "digit" => lexer::Tok::Digit,
        " " => lexer::Tok::Space
    }
}