|
0
|
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("julia", function(config, parserConf) {
|
|
|
15 function wordRegexp(words, end, pre) {
|
|
|
16 if (typeof pre === "undefined") { pre = ""; }
|
|
|
17 if (typeof end === "undefined") { end = "\\b"; }
|
|
|
18 return new RegExp("^" + pre + "((" + words.join(")|(") + "))" + end);
|
|
|
19 }
|
|
|
20
|
|
|
21 var octChar = "\\\\[0-7]{1,3}";
|
|
|
22 var hexChar = "\\\\x[A-Fa-f0-9]{1,2}";
|
|
|
23 var sChar = "\\\\[abefnrtv0%?'\"\\\\]";
|
|
|
24 var uChar = "([^\\u0027\\u005C\\uD800-\\uDFFF]|[\\uD800-\\uDFFF][\\uDC00-\\uDFFF])";
|
|
|
25
|
|
|
26 var asciiOperatorsList = [
|
|
|
27 "[<>]:", "[<>=]=", "<<=?", ">>>?=?", "=>", "--?>", "<--[->]?", "\\/\\/",
|
|
|
28 "\\.{2,3}", "[\\.\\\\%*+\\-<>!\\/^|&]=?", "\\?", "\\$", "~", ":"
|
|
|
29 ];
|
|
|
30 var operators = parserConf.operators || wordRegexp([
|
|
|
31 "[<>]:", "[<>=]=", "[!=]==", "<<=?", ">>>?=?", "=>?", "--?>", "<--[->]?", "\\/\\/",
|
|
|
32 "[\\\\%*+\\-<>!\\/^|&\\u00F7\\u22BB]=?", "\\?", "\\$", "~", ":",
|
|
|
33 "\\u00D7", "\\u2208", "\\u2209", "\\u220B", "\\u220C", "\\u2218",
|
|
|
34 "\\u221A", "\\u221B", "\\u2229", "\\u222A", "\\u2260", "\\u2264",
|
|
|
35 "\\u2265", "\\u2286", "\\u2288", "\\u228A", "\\u22C5",
|
|
|
36 "\\b(in|isa)\\b(?!\.?\\()"
|
|
|
37 ], "");
|
|
|
38 var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
|
|
|
39 var identifiers = parserConf.identifiers ||
|
|
|
40 /^[_A-Za-z\u00A1-\u2217\u2219-\uFFFF][\w\u00A1-\u2217\u2219-\uFFFF]*!*/;
|
|
|
41
|
|
|
42 var chars = wordRegexp([octChar, hexChar, sChar, uChar], "'");
|
|
|
43
|
|
|
44 var openersList = ["begin", "function", "type", "struct", "immutable", "let",
|
|
|
45 "macro", "for", "while", "quote", "if", "else", "elseif", "try",
|
|
|
46 "finally", "catch", "do"];
|
|
|
47
|
|
|
48 var closersList = ["end", "else", "elseif", "catch", "finally"];
|
|
|
49
|
|
|
50 var keywordsList = ["if", "else", "elseif", "while", "for", "begin", "let",
|
|
|
51 "end", "do", "try", "catch", "finally", "return", "break", "continue",
|
|
|
52 "global", "local", "const", "export", "import", "importall", "using",
|
|
|
53 "function", "where", "macro", "module", "baremodule", "struct", "type",
|
|
|
54 "mutable", "immutable", "quote", "typealias", "abstract", "primitive",
|
|
|
55 "bitstype"];
|
|
|
56
|
|
|
57 var builtinsList = ["true", "false", "nothing", "NaN", "Inf"];
|
|
|
58
|
|
|
59 CodeMirror.registerHelper("hintWords", "julia", keywordsList.concat(builtinsList));
|
|
|
60
|
|
|
61 var openers = wordRegexp(openersList);
|
|
|
62 var closers = wordRegexp(closersList);
|
|
|
63 var keywords = wordRegexp(keywordsList);
|
|
|
64 var builtins = wordRegexp(builtinsList);
|
|
|
65
|
|
|
66 var macro = /^@[_A-Za-z\u00A1-\uFFFF][\w\u00A1-\uFFFF]*!*/;
|
|
|
67 var symbol = /^:[_A-Za-z\u00A1-\uFFFF][\w\u00A1-\uFFFF]*!*/;
|
|
|
68 var stringPrefixes = /^(`|([_A-Za-z\u00A1-\uFFFF]*"("")?))/;
|
|
|
69
|
|
|
70 var macroOperators = wordRegexp(asciiOperatorsList, "", "@");
|
|
|
71 var symbolOperators = wordRegexp(asciiOperatorsList, "", ":");
|
|
|
72
|
|
|
73 function inArray(state) {
|
|
|
74 return (state.nestedArrays > 0);
|
|
|
75 }
|
|
|
76
|
|
|
77 function inGenerator(state) {
|
|
|
78 return (state.nestedGenerators > 0);
|
|
|
79 }
|
|
|
80
|
|
|
81 function currentScope(state, n) {
|
|
|
82 if (typeof(n) === "undefined") { n = 0; }
|
|
|
83 if (state.scopes.length <= n) {
|
|
|
84 return null;
|
|
|
85 }
|
|
|
86 return state.scopes[state.scopes.length - (n + 1)];
|
|
|
87 }
|
|
|
88
|
|
|
89 // tokenizers
|
|
|
90 function tokenBase(stream, state) {
|
|
|
91 // Handle multiline comments
|
|
|
92 if (stream.match('#=', false)) {
|
|
|
93 state.tokenize = tokenComment;
|
|
|
94 return state.tokenize(stream, state);
|
|
|
95 }
|
|
|
96
|
|
|
97 // Handle scope changes
|
|
|
98 var leavingExpr = state.leavingExpr;
|
|
|
99 if (stream.sol()) {
|
|
|
100 leavingExpr = false;
|
|
|
101 }
|
|
|
102 state.leavingExpr = false;
|
|
|
103
|
|
|
104 if (leavingExpr) {
|
|
|
105 if (stream.match(/^'+/)) {
|
|
|
106 return "operator";
|
|
|
107 }
|
|
|
108 }
|
|
|
109
|
|
|
110 if (stream.match(/\.{4,}/)) {
|
|
|
111 return "error";
|
|
|
112 } else if (stream.match(/\.{1,3}/)) {
|
|
|
113 return "operator";
|
|
|
114 }
|
|
|
115
|
|
|
116 if (stream.eatSpace()) {
|
|
|
117 return null;
|
|
|
118 }
|
|
|
119
|
|
|
120 var ch = stream.peek();
|
|
|
121
|
|
|
122 // Handle single line comments
|
|
|
123 if (ch === '#') {
|
|
|
124 stream.skipToEnd();
|
|
|
125 return "comment";
|
|
|
126 }
|
|
|
127
|
|
|
128 if (ch === '[') {
|
|
|
129 state.scopes.push('[');
|
|
|
130 state.nestedArrays++;
|
|
|
131 }
|
|
|
132
|
|
|
133 if (ch === '(') {
|
|
|
134 state.scopes.push('(');
|
|
|
135 state.nestedGenerators++;
|
|
|
136 }
|
|
|
137
|
|
|
138 if (inArray(state) && ch === ']') {
|
|
|
139 while (state.scopes.length && currentScope(state) !== "[") { state.scopes.pop(); }
|
|
|
140 state.scopes.pop();
|
|
|
141 state.nestedArrays--;
|
|
|
142 state.leavingExpr = true;
|
|
|
143 }
|
|
|
144
|
|
|
145 if (inGenerator(state) && ch === ')') {
|
|
|
146 while (state.scopes.length && currentScope(state) !== "(") { state.scopes.pop(); }
|
|
|
147 state.scopes.pop();
|
|
|
148 state.nestedGenerators--;
|
|
|
149 state.leavingExpr = true;
|
|
|
150 }
|
|
|
151
|
|
|
152 if (inArray(state)) {
|
|
|
153 if (state.lastToken == "end" && stream.match(':')) {
|
|
|
154 return "operator";
|
|
|
155 }
|
|
|
156 if (stream.match('end')) {
|
|
|
157 return "number";
|
|
|
158 }
|
|
|
159 }
|
|
|
160
|
|
|
161 var match;
|
|
|
162 if (match = stream.match(openers, false)) {
|
|
|
163 state.scopes.push(match[0]);
|
|
|
164 }
|
|
|
165
|
|
|
166 if (stream.match(closers, false)) {
|
|
|
167 state.scopes.pop();
|
|
|
168 }
|
|
|
169
|
|
|
170 // Handle type annotations
|
|
|
171 if (stream.match(/^::(?![:\$])/)) {
|
|
|
172 state.tokenize = tokenAnnotation;
|
|
|
173 return state.tokenize(stream, state);
|
|
|
174 }
|
|
|
175
|
|
|
176 // Handle symbols
|
|
|
177 if (!leavingExpr && (stream.match(symbol) || stream.match(symbolOperators))) {
|
|
|
178 return "builtin";
|
|
|
179 }
|
|
|
180
|
|
|
181 // Handle parametric types
|
|
|
182 //if (stream.match(/^{[^}]*}(?=\()/)) {
|
|
|
183 // return "builtin";
|
|
|
184 //}
|
|
|
185
|
|
|
186 // Handle operators and Delimiters
|
|
|
187 if (stream.match(operators)) {
|
|
|
188 return "operator";
|
|
|
189 }
|
|
|
190
|
|
|
191 // Handle Number Literals
|
|
|
192 if (stream.match(/^\.?\d/, false)) {
|
|
|
193 var imMatcher = RegExp(/^im\b/);
|
|
|
194 var numberLiteral = false;
|
|
|
195 if (stream.match(/^0x\.[0-9a-f_]+p[\+\-]?[_\d]+/i)) { numberLiteral = true; }
|
|
|
196 // Integers
|
|
|
197 if (stream.match(/^0x[0-9a-f_]+/i)) { numberLiteral = true; } // Hex
|
|
|
198 if (stream.match(/^0b[01_]+/i)) { numberLiteral = true; } // Binary
|
|
|
199 if (stream.match(/^0o[0-7_]+/i)) { numberLiteral = true; } // Octal
|
|
|
200 // Floats
|
|
|
201 if (stream.match(/^(?:(?:\d[_\d]*)?\.(?!\.)(?:\d[_\d]*)?|\d[_\d]*\.(?!\.)(?:\d[_\d]*))?([Eef][\+\-]?[_\d]+)?/i)) { numberLiteral = true; }
|
|
|
202 if (stream.match(/^\d[_\d]*(e[\+\-]?\d+)?/i)) { numberLiteral = true; } // Decimal
|
|
|
203 if (numberLiteral) {
|
|
|
204 // Integer literals may be "long"
|
|
|
205 stream.match(imMatcher);
|
|
|
206 state.leavingExpr = true;
|
|
|
207 return "number";
|
|
|
208 }
|
|
|
209 }
|
|
|
210
|
|
|
211 // Handle Chars
|
|
|
212 if (stream.match('\'')) {
|
|
|
213 state.tokenize = tokenChar;
|
|
|
214 return state.tokenize(stream, state);
|
|
|
215 }
|
|
|
216
|
|
|
217 // Handle Strings
|
|
|
218 if (stream.match(stringPrefixes)) {
|
|
|
219 state.tokenize = tokenStringFactory(stream.current());
|
|
|
220 return state.tokenize(stream, state);
|
|
|
221 }
|
|
|
222
|
|
|
223 if (stream.match(macro) || stream.match(macroOperators)) {
|
|
|
224 return "meta";
|
|
|
225 }
|
|
|
226
|
|
|
227 if (stream.match(delimiters)) {
|
|
|
228 return null;
|
|
|
229 }
|
|
|
230
|
|
|
231 if (stream.match(keywords)) {
|
|
|
232 return "keyword";
|
|
|
233 }
|
|
|
234
|
|
|
235 if (stream.match(builtins)) {
|
|
|
236 return "builtin";
|
|
|
237 }
|
|
|
238
|
|
|
239 var isDefinition = state.isDefinition || state.lastToken == "function" ||
|
|
|
240 state.lastToken == "macro" || state.lastToken == "type" ||
|
|
|
241 state.lastToken == "struct" || state.lastToken == "immutable";
|
|
|
242
|
|
|
243 if (stream.match(identifiers)) {
|
|
|
244 if (isDefinition) {
|
|
|
245 if (stream.peek() === '.') {
|
|
|
246 state.isDefinition = true;
|
|
|
247 return "variable";
|
|
|
248 }
|
|
|
249 state.isDefinition = false;
|
|
|
250 return "def";
|
|
|
251 }
|
|
|
252 state.leavingExpr = true;
|
|
|
253 return "variable";
|
|
|
254 }
|
|
|
255
|
|
|
256 // Handle non-detected items
|
|
|
257 stream.next();
|
|
|
258 return "error";
|
|
|
259 }
|
|
|
260
|
|
|
261 function tokenAnnotation(stream, state) {
|
|
|
262 stream.match(/.*?(?=[,;{}()=\s]|$)/);
|
|
|
263 if (stream.match('{')) {
|
|
|
264 state.nestedParameters++;
|
|
|
265 } else if (stream.match('}') && state.nestedParameters > 0) {
|
|
|
266 state.nestedParameters--;
|
|
|
267 }
|
|
|
268 if (state.nestedParameters > 0) {
|
|
|
269 stream.match(/.*?(?={|})/) || stream.next();
|
|
|
270 } else if (state.nestedParameters == 0) {
|
|
|
271 state.tokenize = tokenBase;
|
|
|
272 }
|
|
|
273 return "builtin";
|
|
|
274 }
|
|
|
275
|
|
|
276 function tokenComment(stream, state) {
|
|
|
277 if (stream.match('#=')) {
|
|
|
278 state.nestedComments++;
|
|
|
279 }
|
|
|
280 if (!stream.match(/.*?(?=(#=|=#))/)) {
|
|
|
281 stream.skipToEnd();
|
|
|
282 }
|
|
|
283 if (stream.match('=#')) {
|
|
|
284 state.nestedComments--;
|
|
|
285 if (state.nestedComments == 0)
|
|
|
286 state.tokenize = tokenBase;
|
|
|
287 }
|
|
|
288 return "comment";
|
|
|
289 }
|
|
|
290
|
|
|
291 function tokenChar(stream, state) {
|
|
|
292 var isChar = false, match;
|
|
|
293 if (stream.match(chars)) {
|
|
|
294 isChar = true;
|
|
|
295 } else if (match = stream.match(/\\u([a-f0-9]{1,4})(?=')/i)) {
|
|
|
296 var value = parseInt(match[1], 16);
|
|
|
297 if (value <= 55295 || value >= 57344) { // (U+0,U+D7FF), (U+E000,U+FFFF)
|
|
|
298 isChar = true;
|
|
|
299 stream.next();
|
|
|
300 }
|
|
|
301 } else if (match = stream.match(/\\U([A-Fa-f0-9]{5,8})(?=')/)) {
|
|
|
302 var value = parseInt(match[1], 16);
|
|
|
303 if (value <= 1114111) { // U+10FFFF
|
|
|
304 isChar = true;
|
|
|
305 stream.next();
|
|
|
306 }
|
|
|
307 }
|
|
|
308 if (isChar) {
|
|
|
309 state.leavingExpr = true;
|
|
|
310 state.tokenize = tokenBase;
|
|
|
311 return "string";
|
|
|
312 }
|
|
|
313 if (!stream.match(/^[^']+(?=')/)) { stream.skipToEnd(); }
|
|
|
314 if (stream.match('\'')) { state.tokenize = tokenBase; }
|
|
|
315 return "error";
|
|
|
316 }
|
|
|
317
|
|
|
318 function tokenStringFactory(delimiter) {
|
|
|
319 if (delimiter.substr(-3) === '"""') {
|
|
|
320 delimiter = '"""';
|
|
|
321 } else if (delimiter.substr(-1) === '"') {
|
|
|
322 delimiter = '"';
|
|
|
323 }
|
|
|
324 function tokenString(stream, state) {
|
|
|
325 if (stream.eat('\\')) {
|
|
|
326 stream.next();
|
|
|
327 } else if (stream.match(delimiter)) {
|
|
|
328 state.tokenize = tokenBase;
|
|
|
329 state.leavingExpr = true;
|
|
|
330 return "string";
|
|
|
331 } else {
|
|
|
332 stream.eat(/[`"]/);
|
|
|
333 }
|
|
|
334 stream.eatWhile(/[^\\`"]/);
|
|
|
335 return "string";
|
|
|
336 }
|
|
|
337 return tokenString;
|
|
|
338 }
|
|
|
339
|
|
|
340 var external = {
|
|
|
341 startState: function() {
|
|
|
342 return {
|
|
|
343 tokenize: tokenBase,
|
|
|
344 scopes: [],
|
|
|
345 lastToken: null,
|
|
|
346 leavingExpr: false,
|
|
|
347 isDefinition: false,
|
|
|
348 nestedArrays: 0,
|
|
|
349 nestedComments: 0,
|
|
|
350 nestedGenerators: 0,
|
|
|
351 nestedParameters: 0,
|
|
|
352 firstParenPos: -1
|
|
|
353 };
|
|
|
354 },
|
|
|
355
|
|
|
356 token: function(stream, state) {
|
|
|
357 var style = state.tokenize(stream, state);
|
|
|
358 var current = stream.current();
|
|
|
359
|
|
|
360 if (current && style) {
|
|
|
361 state.lastToken = current;
|
|
|
362 }
|
|
|
363
|
|
|
364 return style;
|
|
|
365 },
|
|
|
366
|
|
|
367 indent: function(state, textAfter) {
|
|
|
368 var delta = 0;
|
|
|
369 if ( textAfter === ']' || textAfter === ')' || /^end\b/.test(textAfter) ||
|
|
|
370 /^else/.test(textAfter) || /^catch\b/.test(textAfter) || /^elseif\b/.test(textAfter) ||
|
|
|
371 /^finally/.test(textAfter) ) {
|
|
|
372 delta = -1;
|
|
|
373 }
|
|
|
374 return (state.scopes.length + delta) * config.indentUnit;
|
|
|
375 },
|
|
|
376
|
|
|
377 electricInput: /\b(end|else|catch|finally)\b/,
|
|
|
378 blockCommentStart: "#=",
|
|
|
379 blockCommentEnd: "=#",
|
|
|
380 lineComment: "#",
|
|
|
381 closeBrackets: "()[]{}\"\"",
|
|
|
382 fold: "indent"
|
|
|
383 };
|
|
|
384 return external;
|
|
|
385 });
|
|
|
386
|
|
|
387
|
|
|
388 CodeMirror.defineMIME("text/x-julia", "julia");
|
|
|
389
|
|
|
390 });
|
