File: rustlexer.lpp

package info (click to toggle)
cgdb 0.8.0-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 3,468 kB
  • sloc: cpp: 12,169; ansic: 10,042; sh: 4,383; exp: 640; makefile: 197
file content (163 lines) | stat: -rw-r--r-- 7,503 bytes parent folder | download | duplicates (2)
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
%option prefix="rust_"
%option outfile="lex.yy.c"
%option noyywrap
%option nounput
%option noinput

B       [01_]
O       [0-7_]
D       [0-9_]
H       [0-9a-fA-F_]
L       [a-zA-Z_]
T       [0-9a-zA-Z_]
IDENTIFIER {L}+{T}*

%{

#include <stdio.h>
#include "tokenizer.h"
%}

%x comment
%x string_literal

%%
"bool"                  { return(TOKENIZER_TYPE); }
"isize"                 { return(TOKENIZER_TYPE); }
"usize"                 { return(TOKENIZER_TYPE); }
"char"                  { return(TOKENIZER_TYPE); }
"u8"                    { return(TOKENIZER_TYPE); }
"u16"                   { return(TOKENIZER_TYPE); }
"u32"                   { return(TOKENIZER_TYPE); }
"u64"                   { return(TOKENIZER_TYPE); }
"f32"                   { return(TOKENIZER_TYPE); }
"f64"                   { return(TOKENIZER_TYPE); }
"i8"                    { return(TOKENIZER_TYPE); }
"i16"                   { return(TOKENIZER_TYPE); }
"i32"                   { return(TOKENIZER_TYPE); }
"i64"                   { return(TOKENIZER_TYPE); }
"str"                   { return(TOKENIZER_TYPE); }
"Self"                  { return(TOKENIZER_TYPE); }
"Copy"                  { return(TOKENIZER_TYPE); }
"Display"               { return(TOKENIZER_TYPE); }
"Debug"                 { return(TOKENIZER_TYPE); }
"Send"                  { return(TOKENIZER_TYPE); }
"Sized"                 { return(TOKENIZER_TYPE); }
"Sync"                  { return(TOKENIZER_TYPE); }
"Drop"                  { return(TOKENIZER_TYPE); }
"Fn"                    { return(TOKENIZER_TYPE); }
"FnMut"                 { return(TOKENIZER_TYPE); }
"Box"                   { return(TOKENIZER_TYPE); }
"ToOwned"               { return(TOKENIZER_TYPE); }
"Clone"                 { return(TOKENIZER_TYPE); }
"PartialEq"             { return(TOKENIZER_TYPE); }
"PartialOrd"            { return(TOKENIZER_TYPE); }
"Eq"                    { return(TOKENIZER_TYPE); }
"Ord"                   { return(TOKENIZER_TYPE); }
"AsRef"                 { return(TOKENIZER_TYPE); }
"AsMut"                 { return(TOKENIZER_TYPE); }
"Into"                  { return(TOKENIZER_TYPE); }
"From"                  { return(TOKENIZER_TYPE); }
"Default"               { return(TOKENIZER_TYPE); }
"Iterator"              { return(TOKENIZER_TYPE); }
"Extend"                { return(TOKENIZER_TYPE); }
"IntoIterator"          { return(TOKENIZER_TYPE); }
"DoubleEndedIterator"   { return(TOKENIZER_TYPE); }
"ExactSizeIterator"     { return(TOKENIZER_TYPE); }
"SliceConcatExt"        { return(TOKENIZER_TYPE); }
"String"                { return(TOKENIZER_TYPE); }
"ToString"              { return(TOKENIZER_TYPE); }
"Vec"                   { return(TOKENIZER_TYPE); }
"Option"                { return(TOKENIZER_TYPE); }
"Result"                { return(TOKENIZER_TYPE); }
"Some"                  { return(TOKENIZER_TYPE); }
"None"                  { return(TOKENIZER_TYPE); }

"abstract"              { return(TOKENIZER_KEYWORD); }
"alignof"               { return(TOKENIZER_KEYWORD); }
"as"                    { return(TOKENIZER_KEYWORD); }
"become"                { return(TOKENIZER_KEYWORD); }
"box"                   { return(TOKENIZER_KEYWORD); }
"break"                 { return(TOKENIZER_KEYWORD); }
"const"                 { return(TOKENIZER_KEYWORD); }
"continue"              { return(TOKENIZER_KEYWORD); }
"crate"                 { return(TOKENIZER_KEYWORD); }
"do"                    { return(TOKENIZER_KEYWORD); }
"else"                  { return(TOKENIZER_KEYWORD); }
"enum"                  { return(TOKENIZER_KEYWORD); }
"extern"                { return(TOKENIZER_KEYWORD); }
"false"                 { return(TOKENIZER_KEYWORD); }
"final"                 { return(TOKENIZER_KEYWORD); }
"fn"                    { return(TOKENIZER_KEYWORD); }
"for"                   { return(TOKENIZER_KEYWORD); }
"if"                    { return(TOKENIZER_KEYWORD); }
"impl"                  { return(TOKENIZER_KEYWORD); }
"in"                    { return(TOKENIZER_KEYWORD); }
"let"                   { return(TOKENIZER_KEYWORD); }
"loop"                  { return(TOKENIZER_KEYWORD); }
"macro"                 { return(TOKENIZER_KEYWORD); }
"match"                 { return(TOKENIZER_KEYWORD); }
"move"                  { return(TOKENIZER_KEYWORD); }
"mut"                   { return(TOKENIZER_KEYWORD); }
"offsetof"              { return(TOKENIZER_KEYWORD); }
"override"              { return(TOKENIZER_KEYWORD); }
"priv"                  { return(TOKENIZER_KEYWORD); }
"proc"                  { return(TOKENIZER_KEYWORD); }
"pub"                   { return(TOKENIZER_KEYWORD); }
"pure"                  { return(TOKENIZER_KEYWORD); }
"ref"                   { return(TOKENIZER_KEYWORD); }
"return"                { return(TOKENIZER_KEYWORD); }
"self"                  { return(TOKENIZER_KEYWORD); }
"sizeof"                { return(TOKENIZER_KEYWORD); }
"static"                { return(TOKENIZER_KEYWORD); }
"struct"                { return(TOKENIZER_KEYWORD); }
"super"                 { return(TOKENIZER_KEYWORD); }
"trait"                 { return(TOKENIZER_KEYWORD); }
"true"                  { return(TOKENIZER_KEYWORD); }
"type"                  { return(TOKENIZER_KEYWORD); }
"typeof"                { return(TOKENIZER_KEYWORD); }
"unsafe"                { return(TOKENIZER_KEYWORD); }
"unsized"               { return(TOKENIZER_KEYWORD); }
"virtual"               { return(TOKENIZER_KEYWORD); }
"where"                 { return(TOKENIZER_KEYWORD); }
"while"                 { return(TOKENIZER_KEYWORD); }
"yield"                 { return(TOKENIZER_KEYWORD); }

"/*"                    { BEGIN(comment); return(TOKENIZER_COMMENT); }
<comment>[^*\r\n]*      { return(TOKENIZER_COMMENT); }
<comment>"*"+[^*/\r\n]* { return(TOKENIZER_COMMENT); }
<comment>\n             { return(TOKENIZER_NEWLINE); }
<comment>\r             { return(TOKENIZER_NEWLINE); }
<comment>\r\n           { return(TOKENIZER_NEWLINE); }
<comment>"*"+"/"        { BEGIN(INITIAL); return(TOKENIZER_COMMENT); }

\/\/[^\r\n]*            { return(TOKENIZER_COMMENT); }

"use"                   { return(TOKENIZER_DIRECTIVE); }
"mod"                   { return(TOKENIZER_DIRECTIVE); }
[a-z_]+!                { return(TOKENIZER_DIRECTIVE); }
#!?\[.*]                { return(TOKENIZER_DIRECTIVE); }

\"                                          { BEGIN(string_literal);    return(TOKENIZER_LITERAL); }
<string_literal>(\\[^\r\n]|[^\\"\r\n])*     { return(TOKENIZER_LITERAL); }
<string_literal>\n                          { return(TOKENIZER_NEWLINE); }
<string_literal>\r                          { return(TOKENIZER_NEWLINE); }
<string_literal>\r\n                        { return(TOKENIZER_NEWLINE); }
<string_literal>\"                          { BEGIN(INITIAL);           return(TOKENIZER_LITERAL); }

{D}{D}*([E|e][-+]?{D}+|\.{D}+([E|e][-+]?{D}+)?)? { return(TOKENIZER_LITERAL); } 
0b{B}+      { return(TOKENIZER_LITERAL); }
0o{O}+      { return(TOKENIZER_LITERAL); }
0x{H}+      { return(TOKENIZER_LITERAL); }

'.'                     { return(TOKENIZER_LITERAL); }
'\\.'                   { return(TOKENIZER_LITERAL); }

\n                            { return(TOKENIZER_NEWLINE); }
\r\n                          { return(TOKENIZER_NEWLINE); }
\r                            { return(TOKENIZER_NEWLINE); }
[ \t\v\f]                     { return(TOKENIZER_TEXT);    }
{IDENTIFIER}                  { return(TOKENIZER_TEXT);    }
.                             { return(TOKENIZER_TEXT);    }

%%