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