1 | (function (Prism) {
|
2 |
|
3 |
|
4 |
|
5 | function simple_form(name) {
|
6 | return new RegExp('(\\()' + name + '(?=[\\s\\)])');
|
7 | }
|
8 |
|
9 | function primitive(pattern) {
|
10 | return new RegExp('([\\s([])' + pattern + '(?=[\\s)])');
|
11 | }
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | var symbol = '[-+*/_~!@$%^=<>{}\\w]+';
|
18 |
|
19 | var marker = '&' + symbol;
|
20 |
|
21 | var par = '(\\()';
|
22 | var endpar = '(?=\\))';
|
23 |
|
24 | var space = '(?=\\s)';
|
25 |
|
26 | var language = {
|
27 |
|
28 |
|
29 | heading: {
|
30 | pattern: /;;;.*/,
|
31 | alias: ['comment', 'title']
|
32 | },
|
33 | comment: /;.*/,
|
34 | string: {
|
35 | pattern: /"(?:[^"\\]*|\\.)*"/,
|
36 | greedy: true,
|
37 | inside: {
|
38 | argument: /[-A-Z]+(?=[.,\s])/,
|
39 | symbol: new RegExp('`' + symbol + "'")
|
40 | }
|
41 | },
|
42 | 'quoted-symbol': {
|
43 | pattern: new RegExp("#?'" + symbol),
|
44 | alias: ['variable', 'symbol']
|
45 | },
|
46 | 'lisp-property': {
|
47 | pattern: new RegExp(':' + symbol),
|
48 | alias: 'property'
|
49 | },
|
50 | splice: {
|
51 | pattern: new RegExp(',@?' + symbol),
|
52 | alias: ['symbol', 'variable']
|
53 | },
|
54 | keyword: [
|
55 | {
|
56 | pattern: new RegExp(
|
57 | par +
|
58 | '(?:(?:lexical-)?let\\*?|(?:cl-)?letf|if|when|while|unless|cons|cl-loop|and|or|not|cond|setq|error|message|null|require|provide|use-package)' +
|
59 | space
|
60 | ),
|
61 | lookbehind: true
|
62 | },
|
63 | {
|
64 | pattern: new RegExp(
|
65 | par + '(?:for|do|collect|return|finally|append|concat|in|by)' + space
|
66 | ),
|
67 | lookbehind: true
|
68 | },
|
69 | ],
|
70 | declare: {
|
71 | pattern: simple_form('declare'),
|
72 | lookbehind: true,
|
73 | alias: 'keyword'
|
74 | },
|
75 | interactive: {
|
76 | pattern: simple_form('interactive'),
|
77 | lookbehind: true,
|
78 | alias: 'keyword'
|
79 | },
|
80 | boolean: {
|
81 | pattern: primitive('(?:t|nil)'),
|
82 | lookbehind: true
|
83 | },
|
84 | number: {
|
85 | pattern: primitive('[-+]?\\d+(?:\\.\\d*)?'),
|
86 | lookbehind: true
|
87 | },
|
88 | defvar: {
|
89 | pattern: new RegExp(par + 'def(?:var|const|custom|group)\\s+' + symbol),
|
90 | lookbehind: true,
|
91 | inside: {
|
92 | keyword: /^def[a-z]+/,
|
93 | variable: new RegExp(symbol)
|
94 | }
|
95 | },
|
96 | defun: {
|
97 | pattern: new RegExp(
|
98 | par +
|
99 | '(?:cl-)?(?:defun\\*?|defmacro)\\s+' +
|
100 | symbol +
|
101 | '\\s+\\([\\s\\S]*?\\)'
|
102 | ),
|
103 | lookbehind: true,
|
104 | inside: {
|
105 | keyword: /^(?:cl-)?def\S+/,
|
106 |
|
107 |
|
108 | arguments: null,
|
109 | function: {
|
110 | pattern: new RegExp('(^\\s)' + symbol),
|
111 | lookbehind: true
|
112 | },
|
113 | punctuation: /[()]/
|
114 | }
|
115 | },
|
116 | lambda: {
|
117 | pattern: new RegExp(par + 'lambda\\s+\\((?:&?' + symbol + '\\s*)*\\)'),
|
118 | lookbehind: true,
|
119 | inside: {
|
120 | keyword: /^lambda/,
|
121 |
|
122 |
|
123 | arguments: null,
|
124 | punctuation: /[()]/
|
125 | }
|
126 | },
|
127 | car: {
|
128 | pattern: new RegExp(par + symbol),
|
129 | lookbehind: true
|
130 | },
|
131 | punctuation: [
|
132 |
|
133 | /(['`,]?\(|[)\[\]])/,
|
134 |
|
135 | {
|
136 | pattern: /(\s)\.(?=\s)/,
|
137 | lookbehind: true
|
138 | },
|
139 | ]
|
140 | };
|
141 |
|
142 | var arg = {
|
143 | 'lisp-marker': new RegExp(marker),
|
144 | rest: {
|
145 | argument: {
|
146 | pattern: new RegExp(symbol),
|
147 | alias: 'variable'
|
148 | },
|
149 | varform: {
|
150 | pattern: new RegExp(par + symbol + '\\s+\\S[\\s\\S]*' + endpar),
|
151 | lookbehind: true,
|
152 | inside: {
|
153 | string: language.string,
|
154 | boolean: language.boolean,
|
155 | number: language.number,
|
156 | symbol: language.symbol,
|
157 | punctuation: /[()]/
|
158 | }
|
159 | }
|
160 | }
|
161 | };
|
162 |
|
163 | var forms = '\\S+(?:\\s+\\S+)*';
|
164 |
|
165 | var arglist = {
|
166 | pattern: new RegExp(par + '[\\s\\S]*' + endpar),
|
167 | lookbehind: true,
|
168 | inside: {
|
169 | 'rest-vars': {
|
170 | pattern: new RegExp('&(?:rest|body)\\s+' + forms),
|
171 | inside: arg
|
172 | },
|
173 | 'other-marker-vars': {
|
174 | pattern: new RegExp('&(?:optional|aux)\\s+' + forms),
|
175 | inside: arg
|
176 | },
|
177 | keys: {
|
178 | pattern: new RegExp('&key\\s+' + forms + '(?:\\s+&allow-other-keys)?'),
|
179 | inside: arg
|
180 | },
|
181 | argument: {
|
182 | pattern: new RegExp(symbol),
|
183 | alias: 'variable'
|
184 | },
|
185 | punctuation: /[()]/
|
186 | }
|
187 | };
|
188 |
|
189 | language['lambda'].inside.arguments = arglist;
|
190 | language['defun'].inside.arguments = Prism.util.clone(arglist);
|
191 | language['defun'].inside.arguments.inside.sublist = arglist;
|
192 |
|
193 | Prism.languages.lisp = language;
|
194 | Prism.languages.elisp = language;
|
195 | Prism.languages.emacs = language;
|
196 | Prism.languages['emacs-lisp'] = language;
|
197 | }(Prism)); |
\ | No newline at end of file |