reparser 0.1.11

regex parser
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139


use crate::*;
use Re::*;
grammar(g: &mut usize);

pub Re: Re = {
  Alt
}

#[inline]
Digits: Bset = {
  r"\\d"  => Bset::range('0','9'),
  r"\\D"  => !Bset::range('0','9'),
}

#[inline]
Letters: Bset = {
  r"\\w"  =>   Bset::range('a','z') | Bset::range('A','Z') |  Bset::range('0','9') | Bset::fromchar('_'),
  r"\\W"  => !(Bset::range('a','z') | Bset::range('A','Z') |  Bset::range('0','9') | Bset::fromchar('_')),
}

#[inline]
Space: Bset = {
  r"\\s"  =>  Bset::str(" \t\n"),
  r"\\S"  => !Bset::str(" \t\n"),
}

#[inline]
Class: Bset = {
  Letters,
  Digits,
  Space,
}

#[inline]
Charsetchar: Bset = {
  Char0  => Bset::fromchar(<>),
  <l:Char0> r"\-" <r:Char0> => Bset::range(l,r),
  Class,
}

#[inline]
Charsetchar2: Bset = {
  Charsetchar,
  r"!"  => Bset::fromchar('!'),
  r"\(" => Bset::fromchar('('),
  r"\)" => Bset::fromchar(')'),
  r"\+" => Bset::fromchar('+'),
  r"\." => Bset::fromchar('.'),
  r"\?" => Bset::fromchar('?'),
  r"\{" => Bset::fromchar('{'),
  r"\}" => Bset::fromchar('}'),
}

#[inline]
ChsersetArray: Bset = {
  <mut v: Charsetchar2+> => {
    //let mut u = r.map(|c| Bset::fromchar(c)).unwrap_or_default();
    v.into_iter().fold(Bset(0,0), |u,v| u|v)
  }
}

#[inline]
Charset: Re = {
  r"\["   <ChsersetArray> r"\]"  => Set(<>),
  r"\["   <ChsersetArray> r"-\]" => Set(<> | Bset::fromchar('-')),
  r"\[\^" <ChsersetArray> r"\]"  => Set(!<>),
  r"\[\^" <ChsersetArray> r"-\]" => Set(!(<>| Bset::fromchar('-'))),
}

#[inline]
Char0: char = {
  r"[^\^\$\[\]\(\)\{\}!\-\*\+&?|.\\]" => <>.as_bytes()[0] as char,
  r"\\n" =>  '\n',
  r"\\[^ndDwWsS]" => <>.as_bytes()[1] as char,
}

#[inline]
Char: char = {
  Char0,
  r"\-"   => '-',
}


Group: usize = {
  r"\(" => {
    *g+=1; *g
  }
}

// /*
//   ^ => (.*\n)?
//   $ => (\n.*)?
// */


#[inline]
Atom: Re = {
  r"\^"  => binop(ALT, Kle(box NON), binop(CAT, Kle(box ALP), Set(Bset::fromchar('\n')))),
  r"\$"  => binop(ALT, Kle(box NON), binop(CAT, Set(Bset::fromchar('\n')), Kle(box ALP))),
  //r"[$]"  => binop(ALT, Kle(box NON), binop(CAT, Set(Bset::fromchar('\n')), Kle(box ALP))),
  Class   => Set(<>),
  Char    => Set(Bset::fromchar(<>)),
  Charset,
  r"\."   => Set(Bset::brange(0,255)),
  r"\(" r"\?:" <Alt> r"\)",
  <i:Group><x:Alt> r"\)" => {
    Cap(box x, CG(i))
  }
}

Post: Re = {
  Atom,
  <Post> r"!"  => unop(NOT, <>),
  <Post> r"\*" => unop(KLE, <>),
  <Post> r"\+" => unop(PLS, <>),
  //<Post> r"\+" => binop(CAT, unop(KLE, <>.clone()), <>.clone()),
  <Post> r"\?" => binop(ALT, Kle(box NON), <>),
}

Cat: Re = {
  Post,
  <l:Cat> <r:Post> => binop(CAT,l,r),
}

And: Re = {
  Cat,
  <l:And> r"\&" <r:Cat> => unop(NOT, binop(ALT,unop(NOT, l),unop(NOT, r))),
}

Alt: Re = {
  And,
  <l:Alt> r"\|" <r:And> => binop(ALT,l,r),
}

match {
  "" => {},
  _
}