Mercurial
comparison .cms/lib/codemirror/mode/mllike/mllike.js @ 0:78edf6b517a0 draft
24.10
author | Coffee CMS <info@coffee-cms.ru> |
---|---|
date | Fri, 11 Oct 2024 22:40:23 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:78edf6b517a0 |
---|---|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE | |
3 | |
4 (function(mod) { | |
5 if (typeof exports == "object" && typeof module == "object") // CommonJS | |
6 mod(require("../../lib/codemirror")); | |
7 else if (typeof define == "function" && define.amd) // AMD | |
8 define(["../../lib/codemirror"], mod); | |
9 else // Plain browser env | |
10 mod(CodeMirror); | |
11 })(function(CodeMirror) { | |
12 "use strict"; | |
13 | |
14 CodeMirror.defineMode('mllike', function(_config, parserConfig) { | |
15 var words = { | |
16 'as': 'keyword', | |
17 'do': 'keyword', | |
18 'else': 'keyword', | |
19 'end': 'keyword', | |
20 'exception': 'keyword', | |
21 'fun': 'keyword', | |
22 'functor': 'keyword', | |
23 'if': 'keyword', | |
24 'in': 'keyword', | |
25 'include': 'keyword', | |
26 'let': 'keyword', | |
27 'of': 'keyword', | |
28 'open': 'keyword', | |
29 'rec': 'keyword', | |
30 'struct': 'keyword', | |
31 'then': 'keyword', | |
32 'type': 'keyword', | |
33 'val': 'keyword', | |
34 'while': 'keyword', | |
35 'with': 'keyword' | |
36 }; | |
37 | |
38 var extraWords = parserConfig.extraWords || {}; | |
39 for (var prop in extraWords) { | |
40 if (extraWords.hasOwnProperty(prop)) { | |
41 words[prop] = parserConfig.extraWords[prop]; | |
42 } | |
43 } | |
44 var hintWords = []; | |
45 for (var k in words) { hintWords.push(k); } | |
46 CodeMirror.registerHelper("hintWords", "mllike", hintWords); | |
47 | |
48 function tokenBase(stream, state) { | |
49 var ch = stream.next(); | |
50 | |
51 if (ch === '"') { | |
52 state.tokenize = tokenString; | |
53 return state.tokenize(stream, state); | |
54 } | |
55 if (ch === '{') { | |
56 if (stream.eat('|')) { | |
57 state.longString = true; | |
58 state.tokenize = tokenLongString; | |
59 return state.tokenize(stream, state); | |
60 } | |
61 } | |
62 if (ch === '(') { | |
63 if (stream.match(/^\*(?!\))/)) { | |
64 state.commentLevel++; | |
65 state.tokenize = tokenComment; | |
66 return state.tokenize(stream, state); | |
67 } | |
68 } | |
69 if (ch === '~' || ch === '?') { | |
70 stream.eatWhile(/\w/); | |
71 return 'variable-2'; | |
72 } | |
73 if (ch === '`') { | |
74 stream.eatWhile(/\w/); | |
75 return 'quote'; | |
76 } | |
77 if (ch === '/' && parserConfig.slashComments && stream.eat('/')) { | |
78 stream.skipToEnd(); | |
79 return 'comment'; | |
80 } | |
81 if (/\d/.test(ch)) { | |
82 if (ch === '0' && stream.eat(/[bB]/)) { | |
83 stream.eatWhile(/[01]/); | |
84 } if (ch === '0' && stream.eat(/[xX]/)) { | |
85 stream.eatWhile(/[0-9a-fA-F]/) | |
86 } if (ch === '0' && stream.eat(/[oO]/)) { | |
87 stream.eatWhile(/[0-7]/); | |
88 } else { | |
89 stream.eatWhile(/[\d_]/); | |
90 if (stream.eat('.')) { | |
91 stream.eatWhile(/[\d]/); | |
92 } | |
93 if (stream.eat(/[eE]/)) { | |
94 stream.eatWhile(/[\d\-+]/); | |
95 } | |
96 } | |
97 return 'number'; | |
98 } | |
99 if ( /[+\-*&%=<>!?|@\.~:]/.test(ch)) { | |
100 return 'operator'; | |
101 } | |
102 if (/[\w\xa1-\uffff]/.test(ch)) { | |
103 stream.eatWhile(/[\w\xa1-\uffff]/); | |
104 var cur = stream.current(); | |
105 return words.hasOwnProperty(cur) ? words[cur] : 'variable'; | |
106 } | |
107 return null | |
108 } | |
109 | |
110 function tokenString(stream, state) { | |
111 var next, end = false, escaped = false; | |
112 while ((next = stream.next()) != null) { | |
113 if (next === '"' && !escaped) { | |
114 end = true; | |
115 break; | |
116 } | |
117 escaped = !escaped && next === '\\'; | |
118 } | |
119 if (end && !escaped) { | |
120 state.tokenize = tokenBase; | |
121 } | |
122 return 'string'; | |
123 }; | |
124 | |
125 function tokenComment(stream, state) { | |
126 var prev, next; | |
127 while(state.commentLevel > 0 && (next = stream.next()) != null) { | |
128 if (prev === '(' && next === '*') state.commentLevel++; | |
129 if (prev === '*' && next === ')') state.commentLevel--; | |
130 prev = next; | |
131 } | |
132 if (state.commentLevel <= 0) { | |
133 state.tokenize = tokenBase; | |
134 } | |
135 return 'comment'; | |
136 } | |
137 | |
138 function tokenLongString(stream, state) { | |
139 var prev, next; | |
140 while (state.longString && (next = stream.next()) != null) { | |
141 if (prev === '|' && next === '}') state.longString = false; | |
142 prev = next; | |
143 } | |
144 if (!state.longString) { | |
145 state.tokenize = tokenBase; | |
146 } | |
147 return 'string'; | |
148 } | |
149 | |
150 return { | |
151 startState: function() {return {tokenize: tokenBase, commentLevel: 0, longString: false};}, | |
152 token: function(stream, state) { | |
153 if (stream.eatSpace()) return null; | |
154 return state.tokenize(stream, state); | |
155 }, | |
156 | |
157 blockCommentStart: "(*", | |
158 blockCommentEnd: "*)", | |
159 lineComment: parserConfig.slashComments ? "//" : null | |
160 }; | |
161 }); | |
162 | |
163 CodeMirror.defineMIME('text/x-ocaml', { | |
164 name: 'mllike', | |
165 extraWords: { | |
166 'and': 'keyword', | |
167 'assert': 'keyword', | |
168 'begin': 'keyword', | |
169 'class': 'keyword', | |
170 'constraint': 'keyword', | |
171 'done': 'keyword', | |
172 'downto': 'keyword', | |
173 'external': 'keyword', | |
174 'function': 'keyword', | |
175 'initializer': 'keyword', | |
176 'lazy': 'keyword', | |
177 'match': 'keyword', | |
178 'method': 'keyword', | |
179 'module': 'keyword', | |
180 'mutable': 'keyword', | |
181 'new': 'keyword', | |
182 'nonrec': 'keyword', | |
183 'object': 'keyword', | |
184 'private': 'keyword', | |
185 'sig': 'keyword', | |
186 'to': 'keyword', | |
187 'try': 'keyword', | |
188 'value': 'keyword', | |
189 'virtual': 'keyword', | |
190 'when': 'keyword', | |
191 | |
192 // builtins | |
193 'raise': 'builtin', | |
194 'failwith': 'builtin', | |
195 'true': 'builtin', | |
196 'false': 'builtin', | |
197 | |
198 // Pervasives builtins | |
199 'asr': 'builtin', | |
200 'land': 'builtin', | |
201 'lor': 'builtin', | |
202 'lsl': 'builtin', | |
203 'lsr': 'builtin', | |
204 'lxor': 'builtin', | |
205 'mod': 'builtin', | |
206 'or': 'builtin', | |
207 | |
208 // More Pervasives | |
209 'raise_notrace': 'builtin', | |
210 'trace': 'builtin', | |
211 'exit': 'builtin', | |
212 'print_string': 'builtin', | |
213 'print_endline': 'builtin', | |
214 | |
215 'int': 'type', | |
216 'float': 'type', | |
217 'bool': 'type', | |
218 'char': 'type', | |
219 'string': 'type', | |
220 'unit': 'type', | |
221 | |
222 // Modules | |
223 'List': 'builtin' | |
224 } | |
225 }); | |
226 | |
227 CodeMirror.defineMIME('text/x-fsharp', { | |
228 name: 'mllike', | |
229 extraWords: { | |
230 'abstract': 'keyword', | |
231 'assert': 'keyword', | |
232 'base': 'keyword', | |
233 'begin': 'keyword', | |
234 'class': 'keyword', | |
235 'default': 'keyword', | |
236 'delegate': 'keyword', | |
237 'do!': 'keyword', | |
238 'done': 'keyword', | |
239 'downcast': 'keyword', | |
240 'downto': 'keyword', | |
241 'elif': 'keyword', | |
242 'extern': 'keyword', | |
243 'finally': 'keyword', | |
244 'for': 'keyword', | |
245 'function': 'keyword', | |
246 'global': 'keyword', | |
247 'inherit': 'keyword', | |
248 'inline': 'keyword', | |
249 'interface': 'keyword', | |
250 'internal': 'keyword', | |
251 'lazy': 'keyword', | |
252 'let!': 'keyword', | |
253 'match': 'keyword', | |
254 'member': 'keyword', | |
255 'module': 'keyword', | |
256 'mutable': 'keyword', | |
257 'namespace': 'keyword', | |
258 'new': 'keyword', | |
259 'null': 'keyword', | |
260 'override': 'keyword', | |
261 'private': 'keyword', | |
262 'public': 'keyword', | |
263 'return!': 'keyword', | |
264 'return': 'keyword', | |
265 'select': 'keyword', | |
266 'static': 'keyword', | |
267 'to': 'keyword', | |
268 'try': 'keyword', | |
269 'upcast': 'keyword', | |
270 'use!': 'keyword', | |
271 'use': 'keyword', | |
272 'void': 'keyword', | |
273 'when': 'keyword', | |
274 'yield!': 'keyword', | |
275 'yield': 'keyword', | |
276 | |
277 // Reserved words | |
278 'atomic': 'keyword', | |
279 'break': 'keyword', | |
280 'checked': 'keyword', | |
281 'component': 'keyword', | |
282 'const': 'keyword', | |
283 'constraint': 'keyword', | |
284 'constructor': 'keyword', | |
285 'continue': 'keyword', | |
286 'eager': 'keyword', | |
287 'event': 'keyword', | |
288 'external': 'keyword', | |
289 'fixed': 'keyword', | |
290 'method': 'keyword', | |
291 'mixin': 'keyword', | |
292 'object': 'keyword', | |
293 'parallel': 'keyword', | |
294 'process': 'keyword', | |
295 'protected': 'keyword', | |
296 'pure': 'keyword', | |
297 'sealed': 'keyword', | |
298 'tailcall': 'keyword', | |
299 'trait': 'keyword', | |
300 'virtual': 'keyword', | |
301 'volatile': 'keyword', | |
302 | |
303 // builtins | |
304 'List': 'builtin', | |
305 'Seq': 'builtin', | |
306 'Map': 'builtin', | |
307 'Set': 'builtin', | |
308 'Option': 'builtin', | |
309 'int': 'builtin', | |
310 'string': 'builtin', | |
311 'not': 'builtin', | |
312 'true': 'builtin', | |
313 'false': 'builtin', | |
314 | |
315 'raise': 'builtin', | |
316 'failwith': 'builtin' | |
317 }, | |
318 slashComments: true | |
319 }); | |
320 | |
321 | |
322 CodeMirror.defineMIME('text/x-sml', { | |
323 name: 'mllike', | |
324 extraWords: { | |
325 'abstype': 'keyword', | |
326 'and': 'keyword', | |
327 'andalso': 'keyword', | |
328 'case': 'keyword', | |
329 'datatype': 'keyword', | |
330 'fn': 'keyword', | |
331 'handle': 'keyword', | |
332 'infix': 'keyword', | |
333 'infixr': 'keyword', | |
334 'local': 'keyword', | |
335 'nonfix': 'keyword', | |
336 'op': 'keyword', | |
337 'orelse': 'keyword', | |
338 'raise': 'keyword', | |
339 'withtype': 'keyword', | |
340 'eqtype': 'keyword', | |
341 'sharing': 'keyword', | |
342 'sig': 'keyword', | |
343 'signature': 'keyword', | |
344 'structure': 'keyword', | |
345 'where': 'keyword', | |
346 'true': 'keyword', | |
347 'false': 'keyword', | |
348 | |
349 // types | |
350 'int': 'builtin', | |
351 'real': 'builtin', | |
352 'string': 'builtin', | |
353 'char': 'builtin', | |
354 'bool': 'builtin' | |
355 }, | |
356 slashComments: true | |
357 }); | |
358 | |
359 }); |