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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
|
package e
import (
. "github.com/alecthomas/chroma" // nolint
"github.com/alecthomas/chroma/lexers/internal"
)
// Elixir lexer.
var Elixir = internal.Register(MustNewLazyLexer(
&Config{
Name: "Elixir",
Aliases: []string{"elixir", "ex", "exs"},
Filenames: []string{"*.ex", "*.exs"},
MimeTypes: []string{"text/x-elixir"},
},
elixirRules,
))
func elixirRules() Rules {
return Rules{
"root": {
{`\s+`, Text, nil},
{`#.*$`, CommentSingle, nil},
{`(\?)(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringChar, LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil},
{`(\?)(\\x[\da-fA-F]{1,2})`, ByGroups(LiteralStringChar, LiteralStringEscape), nil},
{`(\?)(\\[abdefnrstv])`, ByGroups(LiteralStringChar, LiteralStringEscape), nil},
{`\?\\?.`, LiteralStringChar, nil},
{`:::`, LiteralStringSymbol, nil},
{`::`, Operator, nil},
{`:(?:\.\.\.|<<>>|%\{\}|%|\{\})`, LiteralStringSymbol, nil},
{`:(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&))`, LiteralStringSymbol, nil},
{`:"`, LiteralStringSymbol, Push("string_double_atom")},
{`:'`, LiteralStringSymbol, Push("string_single_atom")},
{`((?:\.\.\.|<<>>|%\{\}|%|\{\})|(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&)))(:)(?=\s|\n)`, ByGroups(LiteralStringSymbol, Punctuation), nil},
{`(fn|do|end|after|else|rescue|catch)\b`, Keyword, nil},
{`(not|and|or|when|in)\b`, OperatorWord, nil},
{`(case|cond|for|if|unless|try|receive|raise|quote|unquote|unquote_splicing|throw|super|while)\b`, Keyword, nil},
{`(def|defp|defmodule|defprotocol|defmacro|defmacrop|defdelegate|defexception|defstruct|defimpl|defcallback)\b`, KeywordDeclaration, nil},
{`(import|require|use|alias)\b`, KeywordNamespace, nil},
{`(nil|true|false)\b`, NameConstant, nil},
{`(_|__MODULE__|__DIR__|__ENV__|__CALLER__)\b`, NamePseudo, nil},
{`@(?:\.\.\.|[a-z_]\w*[!?]?)`, NameAttribute, nil},
{`(?:\.\.\.|[a-z_]\w*[!?]?)`, Name, nil},
{`(%?)([A-Z]\w*(?:\.[A-Z]\w*)*)`, ByGroups(Punctuation, NameClass), nil},
{`\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>`, Operator, nil},
{`\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~`, Operator, nil},
{`\\\\|\<\<|\>\>|\=\>|\(|\)|\:|\;|\,|\[|\]`, Punctuation, nil},
{`&\d`, NameEntity, nil},
{`\<|\>|\+|\-|\*|\/|\!|\^|\&`, Operator, nil},
{`0b[01](_?[01])*`, LiteralNumberBin, nil},
{`0o[0-7](_?[0-7])*`, LiteralNumberOct, nil},
{`0x[\da-fA-F](_?[\dA-Fa-f])*`, LiteralNumberHex, nil},
{`\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?`, LiteralNumberFloat, nil},
{`\d(_?\d)*`, LiteralNumberInteger, nil},
{`"""\s*`, LiteralStringHeredoc, Push("heredoc_double")},
{`'''\s*$`, LiteralStringHeredoc, Push("heredoc_single")},
{`"`, LiteralStringDouble, Push("string_double")},
{`'`, LiteralStringSingle, Push("string_single")},
Include("sigils"),
{`%\{`, Punctuation, Push("map_key")},
{`\{`, Punctuation, Push("tuple")},
},
"heredoc_double": {
{`^\s*"""`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_interpol"),
},
"heredoc_single": {
{`^\s*'''`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_interpol"),
},
"heredoc_interpol": {
{`[^#\\\n]+`, LiteralStringHeredoc, nil},
Include("escapes"),
{`\\.`, LiteralStringHeredoc, nil},
{`\n+`, LiteralStringHeredoc, nil},
Include("interpol"),
},
"heredoc_no_interpol": {
{`[^\\\n]+`, LiteralStringHeredoc, nil},
{`\\.`, LiteralStringHeredoc, nil},
{`\n+`, LiteralStringHeredoc, nil},
},
"escapes": {
{`(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil},
{`(\\x[\da-fA-F]{1,2})`, LiteralStringEscape, nil},
{`(\\[abdefnrstv])`, LiteralStringEscape, nil},
},
"interpol": {
{`#\{`, LiteralStringInterpol, Push("interpol_string")},
},
"interpol_string": {
{`\}`, LiteralStringInterpol, Pop(1)},
Include("root"),
},
"map_key": {
Include("root"),
{`:`, Punctuation, Push("map_val")},
{`=>`, Punctuation, Push("map_val")},
{`\}`, Punctuation, Pop(1)},
},
"map_val": {
Include("root"),
{`,`, Punctuation, Pop(1)},
{`(?=\})`, Punctuation, Pop(1)},
},
"tuple": {
Include("root"),
{`\}`, Punctuation, Pop(1)},
},
"string_double": {
{`[^#"\\]+`, LiteralStringDouble, nil},
Include("escapes"),
{`\\.`, LiteralStringDouble, nil},
{`(")`, ByGroups(LiteralStringDouble), Pop(1)},
Include("interpol"),
},
"string_single": {
{`[^#'\\]+`, LiteralStringSingle, nil},
Include("escapes"),
{`\\.`, LiteralStringSingle, nil},
{`(')`, ByGroups(LiteralStringSingle), Pop(1)},
Include("interpol"),
},
"string_double_atom": {
{`[^#"\\]+`, LiteralStringSymbol, nil},
Include("escapes"),
{`\\.`, LiteralStringSymbol, nil},
{`(")`, ByGroups(LiteralStringSymbol), Pop(1)},
Include("interpol"),
},
"string_single_atom": {
{`[^#'\\]+`, LiteralStringSymbol, nil},
Include("escapes"),
{`\\.`, LiteralStringSymbol, nil},
{`(')`, ByGroups(LiteralStringSymbol), Pop(1)},
Include("interpol"),
},
"sigils": {
{`(~[a-z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-intp")},
{`(~[A-Z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-no-intp")},
{`(~[a-z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-intp")},
{`(~[A-Z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-no-intp")},
{`~[a-z]\{`, LiteralStringOther, Push("cb-intp")},
{`~[A-Z]\{`, LiteralStringOther, Push("cb-no-intp")},
{`~[a-z]\[`, LiteralStringOther, Push("sb-intp")},
{`~[A-Z]\[`, LiteralStringOther, Push("sb-no-intp")},
{`~[a-z]\(`, LiteralStringOther, Push("pa-intp")},
{`~[A-Z]\(`, LiteralStringOther, Push("pa-no-intp")},
{`~[a-z]<`, LiteralStringOther, Push("ab-intp")},
{`~[A-Z]<`, LiteralStringOther, Push("ab-no-intp")},
{`~[a-z]/`, LiteralStringOther, Push("slas-intp")},
{`~[A-Z]/`, LiteralStringOther, Push("slas-no-intp")},
{`~[a-z]\|`, LiteralStringOther, Push("pipe-intp")},
{`~[A-Z]\|`, LiteralStringOther, Push("pipe-no-intp")},
{`~[a-z]"`, LiteralStringOther, Push("quot-intp")},
{`~[A-Z]"`, LiteralStringOther, Push("quot-no-intp")},
{`~[a-z]'`, LiteralStringOther, Push("apos-intp")},
{`~[A-Z]'`, LiteralStringOther, Push("apos-no-intp")},
},
"triquot-end": {
{`[a-zA-Z]+`, LiteralStringOther, Pop(1)},
Default(Pop(1)),
},
"triquot-intp": {
{`^\s*"""`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_interpol"),
},
"triquot-no-intp": {
{`^\s*"""`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_no_interpol"),
},
"triapos-end": {
{`[a-zA-Z]+`, LiteralStringOther, Pop(1)},
Default(Pop(1)),
},
"triapos-intp": {
{`^\s*'''`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_interpol"),
},
"triapos-no-intp": {
{`^\s*'''`, LiteralStringHeredoc, Pop(1)},
Include("heredoc_no_interpol"),
},
"cb-intp": {
{`[^#\}\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"cb-no-intp": {
{`[^\}\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"sb-intp": {
{`[^#\]\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`\][a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"sb-no-intp": {
{`[^\]\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`\][a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"pa-intp": {
{`[^#\)\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"pa-no-intp": {
{`[^\)\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"ab-intp": {
{`[^#>\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`>[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"ab-no-intp": {
{`[^>\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`>[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"slas-intp": {
{`[^#/\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`/[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"slas-no-intp": {
{`[^/\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`/[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"pipe-intp": {
{`[^#\|\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"pipe-no-intp": {
{`[^\|\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"quot-intp": {
{`[^#"\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`"[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"quot-no-intp": {
{`[^"\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`"[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
"apos-intp": {
{`[^#'\\]+`, LiteralStringOther, nil},
Include("escapes"),
{`\\.`, LiteralStringOther, nil},
{`'[a-zA-Z]*`, LiteralStringOther, Pop(1)},
Include("interpol"),
},
"apos-no-intp": {
{`[^'\\]+`, LiteralStringOther, nil},
{`\\.`, LiteralStringOther, nil},
{`'[a-zA-Z]*`, LiteralStringOther, Pop(1)},
},
}
}
|
