1 package e
2
3 import (
4 . "github.com/alecthomas/chroma"
5 "github.com/alecthomas/chroma/lexers/internal"
6 )
7
8
9 var Elixir = internal.Register(MustNewLazyLexer(
10 &Config{
11 Name: "Elixir",
12 Aliases: []string{"elixir", "ex", "exs"},
13 Filenames: []string{"*.ex", "*.exs"},
14 MimeTypes: []string{"text/x-elixir"},
15 },
16 elixirRules,
17 ))
18
19 func elixirRules() Rules {
20 return Rules{
21 "root": {
22 {`\s+`, Text, nil},
23 {`#.*$`, CommentSingle, nil},
24 {`(\?)(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringChar, LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil},
25 {`(\?)(\\x[\da-fA-F]{1,2})`, ByGroups(LiteralStringChar, LiteralStringEscape), nil},
26 {`(\?)(\\[abdefnrstv])`, ByGroups(LiteralStringChar, LiteralStringEscape), nil},
27 {`\?\\?.`, LiteralStringChar, nil},
28 {`:::`, LiteralStringSymbol, nil},
29 {`::`, Operator, nil},
30 {`:(?:\.\.\.|<<>>|%\{\}|%|\{\})`, LiteralStringSymbol, nil},
31 {`:(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&))`, LiteralStringSymbol, nil},
32 {`:"`, LiteralStringSymbol, Push("string_double_atom")},
33 {`:'`, LiteralStringSymbol, Push("string_single_atom")},
34 {`((?:\.\.\.|<<>>|%\{\}|%|\{\})|(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&)))(:)(?=\s|\n)`, ByGroups(LiteralStringSymbol, Punctuation), nil},
35 {`(fn|do|end|after|else|rescue|catch)\b`, Keyword, nil},
36 {`(not|and|or|when|in)\b`, OperatorWord, nil},
37 {`(case|cond|for|if|unless|try|receive|raise|quote|unquote|unquote_splicing|throw|super|while)\b`, Keyword, nil},
38 {`(def|defp|defmodule|defprotocol|defmacro|defmacrop|defdelegate|defexception|defstruct|defimpl|defcallback)\b`, KeywordDeclaration, nil},
39 {`(import|require|use|alias)\b`, KeywordNamespace, nil},
40 {`(nil|true|false)\b`, NameConstant, nil},
41 {`(_|__MODULE__|__DIR__|__ENV__|__CALLER__)\b`, NamePseudo, nil},
42 {`@(?:\.\.\.|[a-z_]\w*[!?]?)`, NameAttribute, nil},
43 {`(?:\.\.\.|[a-z_]\w*[!?]?)`, Name, nil},
44 {`(%?)([A-Z]\w*(?:\.[A-Z]\w*)*)`, ByGroups(Punctuation, NameClass), nil},
45 {`\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>`, Operator, nil},
46 {`\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~`, Operator, nil},
47 {`\\\\|\<\<|\>\>|\=\>|\(|\)|\:|\;|\,|\[|\]`, Punctuation, nil},
48 {`&\d`, NameEntity, nil},
49 {`\<|\>|\+|\-|\*|\/|\!|\^|\&`, Operator, nil},
50 {`0b[01](_?[01])*`, LiteralNumberBin, nil},
51 {`0o[0-7](_?[0-7])*`, LiteralNumberOct, nil},
52 {`0x[\da-fA-F](_?[\dA-Fa-f])*`, LiteralNumberHex, nil},
53 {`\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?`, LiteralNumberFloat, nil},
54 {`\d(_?\d)*`, LiteralNumberInteger, nil},
55 {`"""\s*`, LiteralStringHeredoc, Push("heredoc_double")},
56 {`'''\s*$`, LiteralStringHeredoc, Push("heredoc_single")},
57 {`"`, LiteralStringDouble, Push("string_double")},
58 {`'`, LiteralStringSingle, Push("string_single")},
59 Include("sigils"),
60 {`%\{`, Punctuation, Push("map_key")},
61 {`\{`, Punctuation, Push("tuple")},
62 },
63 "heredoc_double": {
64 {`^\s*"""`, LiteralStringHeredoc, Pop(1)},
65 Include("heredoc_interpol"),
66 },
67 "heredoc_single": {
68 {`^\s*'''`, LiteralStringHeredoc, Pop(1)},
69 Include("heredoc_interpol"),
70 },
71 "heredoc_interpol": {
72 {`[^#\\\n]+`, LiteralStringHeredoc, nil},
73 Include("escapes"),
74 {`\\.`, LiteralStringHeredoc, nil},
75 {`\n+`, LiteralStringHeredoc, nil},
76 Include("interpol"),
77 },
78 "heredoc_no_interpol": {
79 {`[^\\\n]+`, LiteralStringHeredoc, nil},
80 {`\\.`, LiteralStringHeredoc, nil},
81 {`\n+`, LiteralStringHeredoc, nil},
82 },
83 "escapes": {
84 {`(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil},
85 {`(\\x[\da-fA-F]{1,2})`, LiteralStringEscape, nil},
86 {`(\\[abdefnrstv])`, LiteralStringEscape, nil},
87 },
88 "interpol": {
89 {`#\{`, LiteralStringInterpol, Push("interpol_string")},
90 },
91 "interpol_string": {
92 {`\}`, LiteralStringInterpol, Pop(1)},
93 Include("root"),
94 },
95 "map_key": {
96 Include("root"),
97 {`:`, Punctuation, Push("map_val")},
98 {`=>`, Punctuation, Push("map_val")},
99 {`\}`, Punctuation, Pop(1)},
100 },
101 "map_val": {
102 Include("root"),
103 {`,`, Punctuation, Pop(1)},
104 {`(?=\})`, Punctuation, Pop(1)},
105 },
106 "tuple": {
107 Include("root"),
108 {`\}`, Punctuation, Pop(1)},
109 },
110 "string_double": {
111 {`[^#"\\]+`, LiteralStringDouble, nil},
112 Include("escapes"),
113 {`\\.`, LiteralStringDouble, nil},
114 {`(")`, ByGroups(LiteralStringDouble), Pop(1)},
115 Include("interpol"),
116 },
117 "string_single": {
118 {`[^#'\\]+`, LiteralStringSingle, nil},
119 Include("escapes"),
120 {`\\.`, LiteralStringSingle, nil},
121 {`(')`, ByGroups(LiteralStringSingle), Pop(1)},
122 Include("interpol"),
123 },
124 "string_double_atom": {
125 {`[^#"\\]+`, LiteralStringSymbol, nil},
126 Include("escapes"),
127 {`\\.`, LiteralStringSymbol, nil},
128 {`(")`, ByGroups(LiteralStringSymbol), Pop(1)},
129 Include("interpol"),
130 },
131 "string_single_atom": {
132 {`[^#'\\]+`, LiteralStringSymbol, nil},
133 Include("escapes"),
134 {`\\.`, LiteralStringSymbol, nil},
135 {`(')`, ByGroups(LiteralStringSymbol), Pop(1)},
136 Include("interpol"),
137 },
138 "sigils": {
139 {`(~[a-z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-intp")},
140 {`(~[A-Z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-no-intp")},
141 {`(~[a-z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-intp")},
142 {`(~[A-Z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-no-intp")},
143 {`~[a-z]\{`, LiteralStringOther, Push("cb-intp")},
144 {`~[A-Z]\{`, LiteralStringOther, Push("cb-no-intp")},
145 {`~[a-z]\[`, LiteralStringOther, Push("sb-intp")},
146 {`~[A-Z]\[`, LiteralStringOther, Push("sb-no-intp")},
147 {`~[a-z]\(`, LiteralStringOther, Push("pa-intp")},
148 {`~[A-Z]\(`, LiteralStringOther, Push("pa-no-intp")},
149 {`~[a-z]<`, LiteralStringOther, Push("ab-intp")},
150 {`~[A-Z]<`, LiteralStringOther, Push("ab-no-intp")},
151 {`~[a-z]/`, LiteralStringOther, Push("slas-intp")},
152 {`~[A-Z]/`, LiteralStringOther, Push("slas-no-intp")},
153 {`~[a-z]\|`, LiteralStringOther, Push("pipe-intp")},
154 {`~[A-Z]\|`, LiteralStringOther, Push("pipe-no-intp")},
155 {`~[a-z]"`, LiteralStringOther, Push("quot-intp")},
156 {`~[A-Z]"`, LiteralStringOther, Push("quot-no-intp")},
157 {`~[a-z]'`, LiteralStringOther, Push("apos-intp")},
158 {`~[A-Z]'`, LiteralStringOther, Push("apos-no-intp")},
159 },
160 "triquot-end": {
161 {`[a-zA-Z]+`, LiteralStringOther, Pop(1)},
162 Default(Pop(1)),
163 },
164 "triquot-intp": {
165 {`^\s*"""`, LiteralStringHeredoc, Pop(1)},
166 Include("heredoc_interpol"),
167 },
168 "triquot-no-intp": {
169 {`^\s*"""`, LiteralStringHeredoc, Pop(1)},
170 Include("heredoc_no_interpol"),
171 },
172 "triapos-end": {
173 {`[a-zA-Z]+`, LiteralStringOther, Pop(1)},
174 Default(Pop(1)),
175 },
176 "triapos-intp": {
177 {`^\s*'''`, LiteralStringHeredoc, Pop(1)},
178 Include("heredoc_interpol"),
179 },
180 "triapos-no-intp": {
181 {`^\s*'''`, LiteralStringHeredoc, Pop(1)},
182 Include("heredoc_no_interpol"),
183 },
184 "cb-intp": {
185 {`[^#\}\\]+`, LiteralStringOther, nil},
186 Include("escapes"),
187 {`\\.`, LiteralStringOther, nil},
188 {`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)},
189 Include("interpol"),
190 },
191 "cb-no-intp": {
192 {`[^\}\\]+`, LiteralStringOther, nil},
193 {`\\.`, LiteralStringOther, nil},
194 {`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)},
195 },
196 "sb-intp": {
197 {`[^#\]\\]+`, LiteralStringOther, nil},
198 Include("escapes"),
199 {`\\.`, LiteralStringOther, nil},
200 {`\][a-zA-Z]*`, LiteralStringOther, Pop(1)},
201 Include("interpol"),
202 },
203 "sb-no-intp": {
204 {`[^\]\\]+`, LiteralStringOther, nil},
205 {`\\.`, LiteralStringOther, nil},
206 {`\][a-zA-Z]*`, LiteralStringOther, Pop(1)},
207 },
208 "pa-intp": {
209 {`[^#\)\\]+`, LiteralStringOther, nil},
210 Include("escapes"),
211 {`\\.`, LiteralStringOther, nil},
212 {`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)},
213 Include("interpol"),
214 },
215 "pa-no-intp": {
216 {`[^\)\\]+`, LiteralStringOther, nil},
217 {`\\.`, LiteralStringOther, nil},
218 {`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)},
219 },
220 "ab-intp": {
221 {`[^#>\\]+`, LiteralStringOther, nil},
222 Include("escapes"),
223 {`\\.`, LiteralStringOther, nil},
224 {`>[a-zA-Z]*`, LiteralStringOther, Pop(1)},
225 Include("interpol"),
226 },
227 "ab-no-intp": {
228 {`[^>\\]+`, LiteralStringOther, nil},
229 {`\\.`, LiteralStringOther, nil},
230 {`>[a-zA-Z]*`, LiteralStringOther, Pop(1)},
231 },
232 "slas-intp": {
233 {`[^#/\\]+`, LiteralStringOther, nil},
234 Include("escapes"),
235 {`\\.`, LiteralStringOther, nil},
236 {`/[a-zA-Z]*`, LiteralStringOther, Pop(1)},
237 Include("interpol"),
238 },
239 "slas-no-intp": {
240 {`[^/\\]+`, LiteralStringOther, nil},
241 {`\\.`, LiteralStringOther, nil},
242 {`/[a-zA-Z]*`, LiteralStringOther, Pop(1)},
243 },
244 "pipe-intp": {
245 {`[^#\|\\]+`, LiteralStringOther, nil},
246 Include("escapes"),
247 {`\\.`, LiteralStringOther, nil},
248 {`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)},
249 Include("interpol"),
250 },
251 "pipe-no-intp": {
252 {`[^\|\\]+`, LiteralStringOther, nil},
253 {`\\.`, LiteralStringOther, nil},
254 {`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)},
255 },
256 "quot-intp": {
257 {`[^#"\\]+`, LiteralStringOther, nil},
258 Include("escapes"),
259 {`\\.`, LiteralStringOther, nil},
260 {`"[a-zA-Z]*`, LiteralStringOther, Pop(1)},
261 Include("interpol"),
262 },
263 "quot-no-intp": {
264 {`[^"\\]+`, LiteralStringOther, nil},
265 {`\\.`, LiteralStringOther, nil},
266 {`"[a-zA-Z]*`, LiteralStringOther, Pop(1)},
267 },
268 "apos-intp": {
269 {`[^#'\\]+`, LiteralStringOther, nil},
270 Include("escapes"),
271 {`\\.`, LiteralStringOther, nil},
272 {`'[a-zA-Z]*`, LiteralStringOther, Pop(1)},
273 Include("interpol"),
274 },
275 "apos-no-intp": {
276 {`[^'\\]+`, LiteralStringOther, nil},
277 {`\\.`, LiteralStringOther, nil},
278 {`'[a-zA-Z]*`, LiteralStringOther, Pop(1)},
279 },
280 }
281 }
282
View as plain text