1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 | (function(mod) {
|
19 | if (typeof exports == "object" && typeof module == "object")
|
20 | mod(require("../../lib/codemirror"));
|
21 | else if (typeof define == "function" && define.amd)
|
22 | define(["../../lib/codemirror"], mod);
|
23 | else
|
24 | mod(CodeMirror);
|
25 | })(function(CodeMirror) {
|
26 | "use strict";
|
27 |
|
28 | CodeMirror.defineMIME("text/x-erlang", "erlang");
|
29 |
|
30 | CodeMirror.defineMode("erlang", function(cmCfg) {
|
31 | "use strict";
|
32 |
|
33 |
|
34 |
|
35 |
|
36 | var typeWords = [
|
37 | "-type", "-spec", "-export_type", "-opaque"];
|
38 |
|
39 | var keywordWords = [
|
40 | "after","begin","catch","case","cond","end","fun","if",
|
41 | "let","of","query","receive","try","when"];
|
42 |
|
43 | var separatorRE = /[\->,;]/;
|
44 | var separatorWords = [
|
45 | "->",";",","];
|
46 |
|
47 | var operatorAtomWords = [
|
48 | "and","andalso","band","bnot","bor","bsl","bsr","bxor",
|
49 | "div","not","or","orelse","rem","xor"];
|
50 |
|
51 | var operatorSymbolRE = /[\+\-\*\/<>=\|:!]/;
|
52 | var operatorSymbolWords = [
|
53 | "=","+","-","*","/",">",">=","<","=<","=:=","==","=/=","/=","||","<-","!"];
|
54 |
|
55 | var openParenRE = /[<\(\[\{]/;
|
56 | var openParenWords = [
|
57 | "<<","(","[","{"];
|
58 |
|
59 | var closeParenRE = /[>\)\]\}]/;
|
60 | var closeParenWords = [
|
61 | "}","]",")",">>"];
|
62 |
|
63 | var guardWords = [
|
64 | "is_atom","is_binary","is_bitstring","is_boolean","is_float",
|
65 | "is_function","is_integer","is_list","is_number","is_pid",
|
66 | "is_port","is_record","is_reference","is_tuple",
|
67 | "atom","binary","bitstring","boolean","function","integer","list",
|
68 | "number","pid","port","record","reference","tuple"];
|
69 |
|
70 | var bifWords = [
|
71 | "abs","adler32","adler32_combine","alive","apply","atom_to_binary",
|
72 | "atom_to_list","binary_to_atom","binary_to_existing_atom",
|
73 | "binary_to_list","binary_to_term","bit_size","bitstring_to_list",
|
74 | "byte_size","check_process_code","contact_binary","crc32",
|
75 | "crc32_combine","date","decode_packet","delete_module",
|
76 | "disconnect_node","element","erase","exit","float","float_to_list",
|
77 | "garbage_collect","get","get_keys","group_leader","halt","hd",
|
78 | "integer_to_list","internal_bif","iolist_size","iolist_to_binary",
|
79 | "is_alive","is_atom","is_binary","is_bitstring","is_boolean",
|
80 | "is_float","is_function","is_integer","is_list","is_number","is_pid",
|
81 | "is_port","is_process_alive","is_record","is_reference","is_tuple",
|
82 | "length","link","list_to_atom","list_to_binary","list_to_bitstring",
|
83 | "list_to_existing_atom","list_to_float","list_to_integer",
|
84 | "list_to_pid","list_to_tuple","load_module","make_ref","module_loaded",
|
85 | "monitor_node","node","node_link","node_unlink","nodes","notalive",
|
86 | "now","open_port","pid_to_list","port_close","port_command",
|
87 | "port_connect","port_control","pre_loaded","process_flag",
|
88 | "process_info","processes","purge_module","put","register",
|
89 | "registered","round","self","setelement","size","spawn","spawn_link",
|
90 | "spawn_monitor","spawn_opt","split_binary","statistics",
|
91 | "term_to_binary","time","throw","tl","trunc","tuple_size",
|
92 | "tuple_to_list","unlink","unregister","whereis"];
|
93 |
|
94 |
|
95 |
|
96 | var anumRE = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/;
|
97 | var escapesRE =
|
98 | /[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;
|
99 |
|
100 |
|
101 |
|
102 |
|
103 | function tokenizer(stream,state) {
|
104 |
|
105 | if (state.in_string) {
|
106 | state.in_string = (!doubleQuote(stream));
|
107 | return rval(state,stream,"string");
|
108 | }
|
109 |
|
110 |
|
111 | if (state.in_atom) {
|
112 | state.in_atom = (!singleQuote(stream));
|
113 | return rval(state,stream,"atom");
|
114 | }
|
115 |
|
116 |
|
117 | if (stream.eatSpace()) {
|
118 | return rval(state,stream,"whitespace");
|
119 | }
|
120 |
|
121 |
|
122 | if (!peekToken(state) &&
|
123 | stream.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/)) {
|
124 | if (is_member(stream.current(),typeWords)) {
|
125 | return rval(state,stream,"type");
|
126 | }else{
|
127 | return rval(state,stream,"attribute");
|
128 | }
|
129 | }
|
130 |
|
131 | var ch = stream.next();
|
132 |
|
133 |
|
134 | if (ch == '%') {
|
135 | stream.skipToEnd();
|
136 | return rval(state,stream,"comment");
|
137 | }
|
138 |
|
139 |
|
140 | if (ch == ":") {
|
141 | return rval(state,stream,"colon");
|
142 | }
|
143 |
|
144 |
|
145 | if (ch == '?') {
|
146 | stream.eatSpace();
|
147 | stream.eatWhile(anumRE);
|
148 | return rval(state,stream,"macro");
|
149 | }
|
150 |
|
151 |
|
152 | if (ch == "#") {
|
153 | stream.eatSpace();
|
154 | stream.eatWhile(anumRE);
|
155 | return rval(state,stream,"record");
|
156 | }
|
157 |
|
158 |
|
159 | if (ch == "$") {
|
160 | if (stream.next() == "\\" && !stream.match(escapesRE)) {
|
161 | return rval(state,stream,"error");
|
162 | }
|
163 | return rval(state,stream,"number");
|
164 | }
|
165 |
|
166 |
|
167 | if (ch == ".") {
|
168 | return rval(state,stream,"dot");
|
169 | }
|
170 |
|
171 |
|
172 | if (ch == '\'') {
|
173 | if (!(state.in_atom = (!singleQuote(stream)))) {
|
174 | if (stream.match(/\s*\/\s*[0-9]/,false)) {
|
175 | stream.match(/\s*\/\s*[0-9]/,true);
|
176 | return rval(state,stream,"fun");
|
177 | }
|
178 | if (stream.match(/\s*\(/,false) || stream.match(/\s*:/,false)) {
|
179 | return rval(state,stream,"function");
|
180 | }
|
181 | }
|
182 | return rval(state,stream,"atom");
|
183 | }
|
184 |
|
185 |
|
186 | if (ch == '"') {
|
187 | state.in_string = (!doubleQuote(stream));
|
188 | return rval(state,stream,"string");
|
189 | }
|
190 |
|
191 |
|
192 | if (/[A-Z_Ø-ÞÀ-Ö]/.test(ch)) {
|
193 | stream.eatWhile(anumRE);
|
194 | return rval(state,stream,"variable");
|
195 | }
|
196 |
|
197 |
|
198 | if (/[a-z_ß-öø-ÿ]/.test(ch)) {
|
199 | stream.eatWhile(anumRE);
|
200 |
|
201 | if (stream.match(/\s*\/\s*[0-9]/,false)) {
|
202 | stream.match(/\s*\/\s*[0-9]/,true);
|
203 | return rval(state,stream,"fun");
|
204 | }
|
205 |
|
206 | var w = stream.current();
|
207 |
|
208 | if (is_member(w,keywordWords)) {
|
209 | return rval(state,stream,"keyword");
|
210 | }else if (is_member(w,operatorAtomWords)) {
|
211 | return rval(state,stream,"operator");
|
212 | }else if (stream.match(/\s*\(/,false)) {
|
213 |
|
214 | if (is_member(w,bifWords) &&
|
215 | ((peekToken(state).token != ":") ||
|
216 | (peekToken(state,2).token == "erlang"))) {
|
217 | return rval(state,stream,"builtin");
|
218 | }else if (is_member(w,guardWords)) {
|
219 | return rval(state,stream,"guard");
|
220 | }else{
|
221 | return rval(state,stream,"function");
|
222 | }
|
223 | }else if (lookahead(stream) == ":") {
|
224 | if (w == "erlang") {
|
225 | return rval(state,stream,"builtin");
|
226 | } else {
|
227 | return rval(state,stream,"function");
|
228 | }
|
229 | }else if (is_member(w,["true","false"])) {
|
230 | return rval(state,stream,"boolean");
|
231 | }else{
|
232 | return rval(state,stream,"atom");
|
233 | }
|
234 | }
|
235 |
|
236 |
|
237 | var digitRE = /[0-9]/;
|
238 | var radixRE = /[0-9a-zA-Z]/;
|
239 | if (digitRE.test(ch)) {
|
240 | stream.eatWhile(digitRE);
|
241 | if (stream.eat('#')) {
|
242 | if (!stream.eatWhile(radixRE)) {
|
243 | stream.backUp(1);
|
244 | }
|
245 | } else if (stream.eat('.')) {
|
246 | if (!stream.eatWhile(digitRE)) {
|
247 | stream.backUp(1);
|
248 | } else {
|
249 | if (stream.eat(/[eE]/)) {
|
250 | if (stream.eat(/[-+]/)) {
|
251 | if (!stream.eatWhile(digitRE)) {
|
252 | stream.backUp(2);
|
253 | }
|
254 | } else {
|
255 | if (!stream.eatWhile(digitRE)) {
|
256 | stream.backUp(1);
|
257 | }
|
258 | }
|
259 | }
|
260 | }
|
261 | }
|
262 | return rval(state,stream,"number");
|
263 | }
|
264 |
|
265 |
|
266 | if (nongreedy(stream,openParenRE,openParenWords)) {
|
267 | return rval(state,stream,"open_paren");
|
268 | }
|
269 |
|
270 |
|
271 | if (nongreedy(stream,closeParenRE,closeParenWords)) {
|
272 | return rval(state,stream,"close_paren");
|
273 | }
|
274 |
|
275 |
|
276 | if (greedy(stream,separatorRE,separatorWords)) {
|
277 | return rval(state,stream,"separator");
|
278 | }
|
279 |
|
280 |
|
281 | if (greedy(stream,operatorSymbolRE,operatorSymbolWords)) {
|
282 | return rval(state,stream,"operator");
|
283 | }
|
284 |
|
285 | return rval(state,stream,null);
|
286 | }
|
287 |
|
288 |
|
289 |
|
290 | function nongreedy(stream,re,words) {
|
291 | if (stream.current().length == 1 && re.test(stream.current())) {
|
292 | stream.backUp(1);
|
293 | while (re.test(stream.peek())) {
|
294 | stream.next();
|
295 | if (is_member(stream.current(),words)) {
|
296 | return true;
|
297 | }
|
298 | }
|
299 | stream.backUp(stream.current().length-1);
|
300 | }
|
301 | return false;
|
302 | }
|
303 |
|
304 | function greedy(stream,re,words) {
|
305 | if (stream.current().length == 1 && re.test(stream.current())) {
|
306 | while (re.test(stream.peek())) {
|
307 | stream.next();
|
308 | }
|
309 | while (0 < stream.current().length) {
|
310 | if (is_member(stream.current(),words)) {
|
311 | return true;
|
312 | }else{
|
313 | stream.backUp(1);
|
314 | }
|
315 | }
|
316 | stream.next();
|
317 | }
|
318 | return false;
|
319 | }
|
320 |
|
321 | function doubleQuote(stream) {
|
322 | return quote(stream, '"', '\\');
|
323 | }
|
324 |
|
325 | function singleQuote(stream) {
|
326 | return quote(stream,'\'','\\');
|
327 | }
|
328 |
|
329 | function quote(stream,quoteChar,escapeChar) {
|
330 | while (!stream.eol()) {
|
331 | var ch = stream.next();
|
332 | if (ch == quoteChar) {
|
333 | return true;
|
334 | }else if (ch == escapeChar) {
|
335 | stream.next();
|
336 | }
|
337 | }
|
338 | return false;
|
339 | }
|
340 |
|
341 | function lookahead(stream) {
|
342 | var m = stream.match(/([\n\s]+|%[^\n]*\n)*(.)/,false);
|
343 | return m ? m.pop() : "";
|
344 | }
|
345 |
|
346 | function is_member(element,list) {
|
347 | return (-1 < list.indexOf(element));
|
348 | }
|
349 |
|
350 | function rval(state,stream,type) {
|
351 |
|
352 |
|
353 | pushToken(state,realToken(type,stream));
|
354 |
|
355 |
|
356 |
|
357 | switch (type) {
|
358 | case "atom": return "atom";
|
359 | case "attribute": return "attribute";
|
360 | case "boolean": return "atom";
|
361 | case "builtin": return "builtin";
|
362 | case "close_paren": return null;
|
363 | case "colon": return null;
|
364 | case "comment": return "comment";
|
365 | case "dot": return null;
|
366 | case "error": return "error";
|
367 | case "fun": return "meta";
|
368 | case "function": return "tag";
|
369 | case "guard": return "property";
|
370 | case "keyword": return "keyword";
|
371 | case "macro": return "variable-2";
|
372 | case "number": return "number";
|
373 | case "open_paren": return null;
|
374 | case "operator": return "operator";
|
375 | case "record": return "bracket";
|
376 | case "separator": return null;
|
377 | case "string": return "string";
|
378 | case "type": return "def";
|
379 | case "variable": return "variable";
|
380 | default: return null;
|
381 | }
|
382 | }
|
383 |
|
384 | function aToken(tok,col,ind,typ) {
|
385 | return {token: tok,
|
386 | column: col,
|
387 | indent: ind,
|
388 | type: typ};
|
389 | }
|
390 |
|
391 | function realToken(type,stream) {
|
392 | return aToken(stream.current(),
|
393 | stream.column(),
|
394 | stream.indentation(),
|
395 | type);
|
396 | }
|
397 |
|
398 | function fakeToken(type) {
|
399 | return aToken(type,0,0,type);
|
400 | }
|
401 |
|
402 | function peekToken(state,depth) {
|
403 | var len = state.tokenStack.length;
|
404 | var dep = (depth ? depth : 1);
|
405 |
|
406 | if (len < dep) {
|
407 | return false;
|
408 | }else{
|
409 | return state.tokenStack[len-dep];
|
410 | }
|
411 | }
|
412 |
|
413 | function pushToken(state,token) {
|
414 |
|
415 | if (!(token.type == "comment" || token.type == "whitespace")) {
|
416 | state.tokenStack = maybe_drop_pre(state.tokenStack,token);
|
417 | state.tokenStack = maybe_drop_post(state.tokenStack);
|
418 | }
|
419 | }
|
420 |
|
421 | function maybe_drop_pre(s,token) {
|
422 | var last = s.length-1;
|
423 |
|
424 | if (0 < last && s[last].type === "record" && token.type === "dot") {
|
425 | s.pop();
|
426 | }else if (0 < last && s[last].type === "group") {
|
427 | s.pop();
|
428 | s.push(token);
|
429 | }else{
|
430 | s.push(token);
|
431 | }
|
432 | return s;
|
433 | }
|
434 |
|
435 | function maybe_drop_post(s) {
|
436 | if (!s.length) return s
|
437 | var last = s.length-1;
|
438 |
|
439 | if (s[last].type === "dot") {
|
440 | return [];
|
441 | }
|
442 | if (last > 1 && s[last].type === "fun" && s[last-1].token === "fun") {
|
443 | return s.slice(0,last-1);
|
444 | }
|
445 | switch (s[last].token) {
|
446 | case "}": return d(s,{g:["{"]});
|
447 | case "]": return d(s,{i:["["]});
|
448 | case ")": return d(s,{i:["("]});
|
449 | case ">>": return d(s,{i:["<<"]});
|
450 | case "end": return d(s,{i:["begin","case","fun","if","receive","try"]});
|
451 | case ",": return d(s,{e:["begin","try","when","->",
|
452 | ",","(","[","{","<<"]});
|
453 | case "->": return d(s,{r:["when"],
|
454 | m:["try","if","case","receive"]});
|
455 | case ";": return d(s,{E:["case","fun","if","receive","try","when"]});
|
456 | case "catch":return d(s,{e:["try"]});
|
457 | case "of": return d(s,{e:["case"]});
|
458 | case "after":return d(s,{e:["receive","try"]});
|
459 | default: return s;
|
460 | }
|
461 | }
|
462 |
|
463 | function d(stack,tt) {
|
464 |
|
465 |
|
466 |
|
467 |
|
468 |
|
469 |
|
470 |
|
471 |
|
472 |
|
473 |
|
474 |
|
475 |
|
476 |
|
477 |
|
478 |
|
479 |
|
480 | for (var type in tt) {
|
481 | var len = stack.length-1;
|
482 | var tokens = tt[type];
|
483 | for (var i = len-1; -1 < i ; i--) {
|
484 | if (is_member(stack[i].token,tokens)) {
|
485 | var ss = stack.slice(0,i);
|
486 | switch (type) {
|
487 | case "m": return ss.concat(stack[i]).concat(stack[len]);
|
488 | case "r": return ss.concat(stack[len]);
|
489 | case "i": return ss;
|
490 | case "g": return ss.concat(fakeToken("group"));
|
491 | case "E": return ss.concat(stack[i]);
|
492 | case "e": return ss.concat(stack[i]);
|
493 | }
|
494 | }
|
495 | }
|
496 | }
|
497 | return (type == "E" ? [] : stack);
|
498 | }
|
499 |
|
500 |
|
501 |
|
502 |
|
503 | function indenter(state,textAfter) {
|
504 | var t;
|
505 | var unit = cmCfg.indentUnit;
|
506 | var wordAfter = wordafter(textAfter);
|
507 | var currT = peekToken(state,1);
|
508 | var prevT = peekToken(state,2);
|
509 |
|
510 | if (state.in_string || state.in_atom) {
|
511 | return CodeMirror.Pass;
|
512 | }else if (!prevT) {
|
513 | return 0;
|
514 | }else if (currT.token == "when") {
|
515 | return currT.column+unit;
|
516 | }else if (wordAfter === "when" && prevT.type === "function") {
|
517 | return prevT.indent+unit;
|
518 | }else if (wordAfter === "(" && currT.token === "fun") {
|
519 | return currT.column+3;
|
520 | }else if (wordAfter === "catch" && (t = getToken(state,["try"]))) {
|
521 | return t.column;
|
522 | }else if (is_member(wordAfter,["end","after","of"])) {
|
523 | t = getToken(state,["begin","case","fun","if","receive","try"]);
|
524 | return t ? t.column : CodeMirror.Pass;
|
525 | }else if (is_member(wordAfter,closeParenWords)) {
|
526 | t = getToken(state,openParenWords);
|
527 | return t ? t.column : CodeMirror.Pass;
|
528 | }else if (is_member(currT.token,[",","|","||"]) ||
|
529 | is_member(wordAfter,[",","|","||"])) {
|
530 | t = postcommaToken(state);
|
531 | return t ? t.column+t.token.length : unit;
|
532 | }else if (currT.token == "->") {
|
533 | if (is_member(prevT.token, ["receive","case","if","try"])) {
|
534 | return prevT.column+unit+unit;
|
535 | }else{
|
536 | return prevT.column+unit;
|
537 | }
|
538 | }else if (is_member(currT.token,openParenWords)) {
|
539 | return currT.column+currT.token.length;
|
540 | }else{
|
541 | t = defaultToken(state);
|
542 | return truthy(t) ? t.column+unit : 0;
|
543 | }
|
544 | }
|
545 |
|
546 | function wordafter(str) {
|
547 | var m = str.match(/,|[a-z]+|\}|\]|\)|>>|\|+|\(/);
|
548 |
|
549 | return truthy(m) && (m.index === 0) ? m[0] : "";
|
550 | }
|
551 |
|
552 | function postcommaToken(state) {
|
553 | var objs = state.tokenStack.slice(0,-1);
|
554 | var i = getTokenIndex(objs,"type",["open_paren"]);
|
555 |
|
556 | return truthy(objs[i]) ? objs[i] : false;
|
557 | }
|
558 |
|
559 | function defaultToken(state) {
|
560 | var objs = state.tokenStack;
|
561 | var stop = getTokenIndex(objs,"type",["open_paren","separator","keyword"]);
|
562 | var oper = getTokenIndex(objs,"type",["operator"]);
|
563 |
|
564 | if (truthy(stop) && truthy(oper) && stop < oper) {
|
565 | return objs[stop+1];
|
566 | } else if (truthy(stop)) {
|
567 | return objs[stop];
|
568 | } else {
|
569 | return false;
|
570 | }
|
571 | }
|
572 |
|
573 | function getToken(state,tokens) {
|
574 | var objs = state.tokenStack;
|
575 | var i = getTokenIndex(objs,"token",tokens);
|
576 |
|
577 | return truthy(objs[i]) ? objs[i] : false;
|
578 | }
|
579 |
|
580 | function getTokenIndex(objs,propname,propvals) {
|
581 |
|
582 | for (var i = objs.length-1; -1 < i ; i--) {
|
583 | if (is_member(objs[i][propname],propvals)) {
|
584 | return i;
|
585 | }
|
586 | }
|
587 | return false;
|
588 | }
|
589 |
|
590 | function truthy(x) {
|
591 | return (x !== false) && (x != null);
|
592 | }
|
593 |
|
594 |
|
595 |
|
596 |
|
597 | return {
|
598 | startState:
|
599 | function() {
|
600 | return {tokenStack: [],
|
601 | in_string: false,
|
602 | in_atom: false};
|
603 | },
|
604 |
|
605 | token:
|
606 | function(stream, state) {
|
607 | return tokenizer(stream, state);
|
608 | },
|
609 |
|
610 | indent:
|
611 | function(state, textAfter) {
|
612 | return indenter(state,textAfter);
|
613 | },
|
614 |
|
615 | lineComment: "%"
|
616 | };
|
617 | });
|
618 |
|
619 | });
|