mirror of https://github.com/shadowfacts/type.git
620 lines
18 KiB
JavaScript
620 lines
18 KiB
JavaScript
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
|
|
|
/*jshint unused:true, eqnull:true, curly:true, bitwise:true */
|
|
/*jshint undef:true, latedef:true, trailing:true */
|
|
/*global CodeMirror:true */
|
|
|
|
// erlang mode.
|
|
// tokenizer -> token types -> CodeMirror styles
|
|
// tokenizer maintains a parse stack
|
|
// indenter uses the parse stack
|
|
|
|
// TODO indenter:
|
|
// bit syntax
|
|
// old guard/bif/conversion clashes (e.g. "float/1")
|
|
// type/spec/opaque
|
|
|
|
(function(mod) {
|
|
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|
mod(require("../../lib/codemirror"));
|
|
else if (typeof define == "function" && define.amd) // AMD
|
|
define(["../../lib/codemirror"], mod);
|
|
else // Plain browser env
|
|
mod(CodeMirror);
|
|
})(function(CodeMirror) {
|
|
"use strict";
|
|
|
|
CodeMirror.defineMIME("text/x-erlang", "erlang");
|
|
|
|
CodeMirror.defineMode("erlang", function(cmCfg) {
|
|
"use strict";
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// constants
|
|
|
|
var typeWords = [
|
|
"-type", "-spec", "-export_type", "-opaque"];
|
|
|
|
var keywordWords = [
|
|
"after","begin","catch","case","cond","end","fun","if",
|
|
"let","of","query","receive","try","when"];
|
|
|
|
var separatorRE = /[\->,;]/;
|
|
var separatorWords = [
|
|
"->",";",","];
|
|
|
|
var operatorAtomWords = [
|
|
"and","andalso","band","bnot","bor","bsl","bsr","bxor",
|
|
"div","not","or","orelse","rem","xor"];
|
|
|
|
var operatorSymbolRE = /[\+\-\*\/<>=\|:!]/;
|
|
var operatorSymbolWords = [
|
|
"=","+","-","*","/",">",">=","<","=<","=:=","==","=/=","/=","||","<-","!"];
|
|
|
|
var openParenRE = /[<\(\[\{]/;
|
|
var openParenWords = [
|
|
"<<","(","[","{"];
|
|
|
|
var closeParenRE = /[>\)\]\}]/;
|
|
var closeParenWords = [
|
|
"}","]",")",">>"];
|
|
|
|
var guardWords = [
|
|
"is_atom","is_binary","is_bitstring","is_boolean","is_float",
|
|
"is_function","is_integer","is_list","is_number","is_pid",
|
|
"is_port","is_record","is_reference","is_tuple",
|
|
"atom","binary","bitstring","boolean","function","integer","list",
|
|
"number","pid","port","record","reference","tuple"];
|
|
|
|
var bifWords = [
|
|
"abs","adler32","adler32_combine","alive","apply","atom_to_binary",
|
|
"atom_to_list","binary_to_atom","binary_to_existing_atom",
|
|
"binary_to_list","binary_to_term","bit_size","bitstring_to_list",
|
|
"byte_size","check_process_code","contact_binary","crc32",
|
|
"crc32_combine","date","decode_packet","delete_module",
|
|
"disconnect_node","element","erase","exit","float","float_to_list",
|
|
"garbage_collect","get","get_keys","group_leader","halt","hd",
|
|
"integer_to_list","internal_bif","iolist_size","iolist_to_binary",
|
|
"is_alive","is_atom","is_binary","is_bitstring","is_boolean",
|
|
"is_float","is_function","is_integer","is_list","is_number","is_pid",
|
|
"is_port","is_process_alive","is_record","is_reference","is_tuple",
|
|
"length","link","list_to_atom","list_to_binary","list_to_bitstring",
|
|
"list_to_existing_atom","list_to_float","list_to_integer",
|
|
"list_to_pid","list_to_tuple","load_module","make_ref","module_loaded",
|
|
"monitor_node","node","node_link","node_unlink","nodes","notalive",
|
|
"now","open_port","pid_to_list","port_close","port_command",
|
|
"port_connect","port_control","pre_loaded","process_flag",
|
|
"process_info","processes","purge_module","put","register",
|
|
"registered","round","self","setelement","size","spawn","spawn_link",
|
|
"spawn_monitor","spawn_opt","split_binary","statistics",
|
|
"term_to_binary","time","throw","tl","trunc","tuple_size",
|
|
"tuple_to_list","unlink","unregister","whereis"];
|
|
|
|
// upper case: [A-Z] [Ø-Þ] [À-Ö]
|
|
// lower case: [a-z] [ß-ö] [ø-ÿ]
|
|
var anumRE = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/;
|
|
var escapesRE =
|
|
/[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// tokenizer
|
|
|
|
function tokenizer(stream,state) {
|
|
// in multi-line string
|
|
if (state.in_string) {
|
|
state.in_string = (!doubleQuote(stream));
|
|
return rval(state,stream,"string");
|
|
}
|
|
|
|
// in multi-line atom
|
|
if (state.in_atom) {
|
|
state.in_atom = (!singleQuote(stream));
|
|
return rval(state,stream,"atom");
|
|
}
|
|
|
|
// whitespace
|
|
if (stream.eatSpace()) {
|
|
return rval(state,stream,"whitespace");
|
|
}
|
|
|
|
// attributes and type specs
|
|
if (!peekToken(state) &&
|
|
stream.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/)) {
|
|
if (is_member(stream.current(),typeWords)) {
|
|
return rval(state,stream,"type");
|
|
}else{
|
|
return rval(state,stream,"attribute");
|
|
}
|
|
}
|
|
|
|
var ch = stream.next();
|
|
|
|
// comment
|
|
if (ch == '%') {
|
|
stream.skipToEnd();
|
|
return rval(state,stream,"comment");
|
|
}
|
|
|
|
// colon
|
|
if (ch == ":") {
|
|
return rval(state,stream,"colon");
|
|
}
|
|
|
|
// macro
|
|
if (ch == '?') {
|
|
stream.eatSpace();
|
|
stream.eatWhile(anumRE);
|
|
return rval(state,stream,"macro");
|
|
}
|
|
|
|
// record
|
|
if (ch == "#") {
|
|
stream.eatSpace();
|
|
stream.eatWhile(anumRE);
|
|
return rval(state,stream,"record");
|
|
}
|
|
|
|
// dollar escape
|
|
if (ch == "$") {
|
|
if (stream.next() == "\\" && !stream.match(escapesRE)) {
|
|
return rval(state,stream,"error");
|
|
}
|
|
return rval(state,stream,"number");
|
|
}
|
|
|
|
// dot
|
|
if (ch == ".") {
|
|
return rval(state,stream,"dot");
|
|
}
|
|
|
|
// quoted atom
|
|
if (ch == '\'') {
|
|
if (!(state.in_atom = (!singleQuote(stream)))) {
|
|
if (stream.match(/\s*\/\s*[0-9]/,false)) {
|
|
stream.match(/\s*\/\s*[0-9]/,true);
|
|
return rval(state,stream,"fun"); // 'f'/0 style fun
|
|
}
|
|
if (stream.match(/\s*\(/,false) || stream.match(/\s*:/,false)) {
|
|
return rval(state,stream,"function");
|
|
}
|
|
}
|
|
return rval(state,stream,"atom");
|
|
}
|
|
|
|
// string
|
|
if (ch == '"') {
|
|
state.in_string = (!doubleQuote(stream));
|
|
return rval(state,stream,"string");
|
|
}
|
|
|
|
// variable
|
|
if (/[A-Z_Ø-ÞÀ-Ö]/.test(ch)) {
|
|
stream.eatWhile(anumRE);
|
|
return rval(state,stream,"variable");
|
|
}
|
|
|
|
// atom/keyword/BIF/function
|
|
if (/[a-z_ß-öø-ÿ]/.test(ch)) {
|
|
stream.eatWhile(anumRE);
|
|
|
|
if (stream.match(/\s*\/\s*[0-9]/,false)) {
|
|
stream.match(/\s*\/\s*[0-9]/,true);
|
|
return rval(state,stream,"fun"); // f/0 style fun
|
|
}
|
|
|
|
var w = stream.current();
|
|
|
|
if (is_member(w,keywordWords)) {
|
|
return rval(state,stream,"keyword");
|
|
}else if (is_member(w,operatorAtomWords)) {
|
|
return rval(state,stream,"operator");
|
|
}else if (stream.match(/\s*\(/,false)) {
|
|
// 'put' and 'erlang:put' are bifs, 'foo:put' is not
|
|
if (is_member(w,bifWords) &&
|
|
((peekToken(state).token != ":") ||
|
|
(peekToken(state,2).token == "erlang"))) {
|
|
return rval(state,stream,"builtin");
|
|
}else if (is_member(w,guardWords)) {
|
|
return rval(state,stream,"guard");
|
|
}else{
|
|
return rval(state,stream,"function");
|
|
}
|
|
}else if (lookahead(stream) == ":") {
|
|
if (w == "erlang") {
|
|
return rval(state,stream,"builtin");
|
|
} else {
|
|
return rval(state,stream,"function");
|
|
}
|
|
}else if (is_member(w,["true","false"])) {
|
|
return rval(state,stream,"boolean");
|
|
}else{
|
|
return rval(state,stream,"atom");
|
|
}
|
|
}
|
|
|
|
// number
|
|
var digitRE = /[0-9]/;
|
|
var radixRE = /[0-9a-zA-Z]/; // 36#zZ style int
|
|
if (digitRE.test(ch)) {
|
|
stream.eatWhile(digitRE);
|
|
if (stream.eat('#')) { // 36#aZ style integer
|
|
if (!stream.eatWhile(radixRE)) {
|
|
stream.backUp(1); //"36#" - syntax error
|
|
}
|
|
} else if (stream.eat('.')) { // float
|
|
if (!stream.eatWhile(digitRE)) {
|
|
stream.backUp(1); // "3." - probably end of function
|
|
} else {
|
|
if (stream.eat(/[eE]/)) { // float with exponent
|
|
if (stream.eat(/[-+]/)) {
|
|
if (!stream.eatWhile(digitRE)) {
|
|
stream.backUp(2); // "2e-" - syntax error
|
|
}
|
|
} else {
|
|
if (!stream.eatWhile(digitRE)) {
|
|
stream.backUp(1); // "2e" - syntax error
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rval(state,stream,"number"); // normal integer
|
|
}
|
|
|
|
// open parens
|
|
if (nongreedy(stream,openParenRE,openParenWords)) {
|
|
return rval(state,stream,"open_paren");
|
|
}
|
|
|
|
// close parens
|
|
if (nongreedy(stream,closeParenRE,closeParenWords)) {
|
|
return rval(state,stream,"close_paren");
|
|
}
|
|
|
|
// separators
|
|
if (greedy(stream,separatorRE,separatorWords)) {
|
|
return rval(state,stream,"separator");
|
|
}
|
|
|
|
// operators
|
|
if (greedy(stream,operatorSymbolRE,operatorSymbolWords)) {
|
|
return rval(state,stream,"operator");
|
|
}
|
|
|
|
return rval(state,stream,null);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// utilities
|
|
function nongreedy(stream,re,words) {
|
|
if (stream.current().length == 1 && re.test(stream.current())) {
|
|
stream.backUp(1);
|
|
while (re.test(stream.peek())) {
|
|
stream.next();
|
|
if (is_member(stream.current(),words)) {
|
|
return true;
|
|
}
|
|
}
|
|
stream.backUp(stream.current().length-1);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function greedy(stream,re,words) {
|
|
if (stream.current().length == 1 && re.test(stream.current())) {
|
|
while (re.test(stream.peek())) {
|
|
stream.next();
|
|
}
|
|
while (0 < stream.current().length) {
|
|
if (is_member(stream.current(),words)) {
|
|
return true;
|
|
}else{
|
|
stream.backUp(1);
|
|
}
|
|
}
|
|
stream.next();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function doubleQuote(stream) {
|
|
return quote(stream, '"', '\\');
|
|
}
|
|
|
|
function singleQuote(stream) {
|
|
return quote(stream,'\'','\\');
|
|
}
|
|
|
|
function quote(stream,quoteChar,escapeChar) {
|
|
while (!stream.eol()) {
|
|
var ch = stream.next();
|
|
if (ch == quoteChar) {
|
|
return true;
|
|
}else if (ch == escapeChar) {
|
|
stream.next();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function lookahead(stream) {
|
|
var m = stream.match(/([\n\s]+|%[^\n]*\n)*(.)/,false);
|
|
return m ? m.pop() : "";
|
|
}
|
|
|
|
function is_member(element,list) {
|
|
return (-1 < list.indexOf(element));
|
|
}
|
|
|
|
function rval(state,stream,type) {
|
|
|
|
// parse stack
|
|
pushToken(state,realToken(type,stream));
|
|
|
|
// map erlang token type to CodeMirror style class
|
|
// erlang -> CodeMirror tag
|
|
switch (type) {
|
|
case "atom": return "atom";
|
|
case "attribute": return "attribute";
|
|
case "boolean": return "atom";
|
|
case "builtin": return "builtin";
|
|
case "close_paren": return null;
|
|
case "colon": return null;
|
|
case "comment": return "comment";
|
|
case "dot": return null;
|
|
case "error": return "error";
|
|
case "fun": return "meta";
|
|
case "function": return "tag";
|
|
case "guard": return "property";
|
|
case "keyword": return "keyword";
|
|
case "macro": return "variable-2";
|
|
case "number": return "number";
|
|
case "open_paren": return null;
|
|
case "operator": return "operator";
|
|
case "record": return "bracket";
|
|
case "separator": return null;
|
|
case "string": return "string";
|
|
case "type": return "def";
|
|
case "variable": return "variable";
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
function aToken(tok,col,ind,typ) {
|
|
return {token: tok,
|
|
column: col,
|
|
indent: ind,
|
|
type: typ};
|
|
}
|
|
|
|
function realToken(type,stream) {
|
|
return aToken(stream.current(),
|
|
stream.column(),
|
|
stream.indentation(),
|
|
type);
|
|
}
|
|
|
|
function fakeToken(type) {
|
|
return aToken(type,0,0,type);
|
|
}
|
|
|
|
function peekToken(state,depth) {
|
|
var len = state.tokenStack.length;
|
|
var dep = (depth ? depth : 1);
|
|
|
|
if (len < dep) {
|
|
return false;
|
|
}else{
|
|
return state.tokenStack[len-dep];
|
|
}
|
|
}
|
|
|
|
function pushToken(state,token) {
|
|
|
|
if (!(token.type == "comment" || token.type == "whitespace")) {
|
|
state.tokenStack = maybe_drop_pre(state.tokenStack,token);
|
|
state.tokenStack = maybe_drop_post(state.tokenStack);
|
|
}
|
|
}
|
|
|
|
function maybe_drop_pre(s,token) {
|
|
var last = s.length-1;
|
|
|
|
if (0 < last && s[last].type === "record" && token.type === "dot") {
|
|
s.pop();
|
|
}else if (0 < last && s[last].type === "group") {
|
|
s.pop();
|
|
s.push(token);
|
|
}else{
|
|
s.push(token);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
function maybe_drop_post(s) {
|
|
if (!s.length) return s
|
|
var last = s.length-1;
|
|
|
|
if (s[last].type === "dot") {
|
|
return [];
|
|
}
|
|
if (last > 1 && s[last].type === "fun" && s[last-1].token === "fun") {
|
|
return s.slice(0,last-1);
|
|
}
|
|
switch (s[last].token) {
|
|
case "}": return d(s,{g:["{"]});
|
|
case "]": return d(s,{i:["["]});
|
|
case ")": return d(s,{i:["("]});
|
|
case ">>": return d(s,{i:["<<"]});
|
|
case "end": return d(s,{i:["begin","case","fun","if","receive","try"]});
|
|
case ",": return d(s,{e:["begin","try","when","->",
|
|
",","(","[","{","<<"]});
|
|
case "->": return d(s,{r:["when"],
|
|
m:["try","if","case","receive"]});
|
|
case ";": return d(s,{E:["case","fun","if","receive","try","when"]});
|
|
case "catch":return d(s,{e:["try"]});
|
|
case "of": return d(s,{e:["case"]});
|
|
case "after":return d(s,{e:["receive","try"]});
|
|
default: return s;
|
|
}
|
|
}
|
|
|
|
function d(stack,tt) {
|
|
// stack is a stack of Token objects.
|
|
// tt is an object; {type:tokens}
|
|
// type is a char, tokens is a list of token strings.
|
|
// The function returns (possibly truncated) stack.
|
|
// It will descend the stack, looking for a Token such that Token.token
|
|
// is a member of tokens. If it does not find that, it will normally (but
|
|
// see "E" below) return stack. If it does find a match, it will remove
|
|
// all the Tokens between the top and the matched Token.
|
|
// If type is "m", that is all it does.
|
|
// If type is "i", it will also remove the matched Token and the top Token.
|
|
// If type is "g", like "i", but add a fake "group" token at the top.
|
|
// If type is "r", it will remove the matched Token, but not the top Token.
|
|
// If type is "e", it will keep the matched Token but not the top Token.
|
|
// If type is "E", it behaves as for type "e", except if there is no match,
|
|
// in which case it will return an empty stack.
|
|
|
|
for (var type in tt) {
|
|
var len = stack.length-1;
|
|
var tokens = tt[type];
|
|
for (var i = len-1; -1 < i ; i--) {
|
|
if (is_member(stack[i].token,tokens)) {
|
|
var ss = stack.slice(0,i);
|
|
switch (type) {
|
|
case "m": return ss.concat(stack[i]).concat(stack[len]);
|
|
case "r": return ss.concat(stack[len]);
|
|
case "i": return ss;
|
|
case "g": return ss.concat(fakeToken("group"));
|
|
case "E": return ss.concat(stack[i]);
|
|
case "e": return ss.concat(stack[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (type == "E" ? [] : stack);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// indenter
|
|
|
|
function indenter(state,textAfter) {
|
|
var t;
|
|
var unit = cmCfg.indentUnit;
|
|
var wordAfter = wordafter(textAfter);
|
|
var currT = peekToken(state,1);
|
|
var prevT = peekToken(state,2);
|
|
|
|
if (state.in_string || state.in_atom) {
|
|
return CodeMirror.Pass;
|
|
}else if (!prevT) {
|
|
return 0;
|
|
}else if (currT.token == "when") {
|
|
return currT.column+unit;
|
|
}else if (wordAfter === "when" && prevT.type === "function") {
|
|
return prevT.indent+unit;
|
|
}else if (wordAfter === "(" && currT.token === "fun") {
|
|
return currT.column+3;
|
|
}else if (wordAfter === "catch" && (t = getToken(state,["try"]))) {
|
|
return t.column;
|
|
}else if (is_member(wordAfter,["end","after","of"])) {
|
|
t = getToken(state,["begin","case","fun","if","receive","try"]);
|
|
return t ? t.column : CodeMirror.Pass;
|
|
}else if (is_member(wordAfter,closeParenWords)) {
|
|
t = getToken(state,openParenWords);
|
|
return t ? t.column : CodeMirror.Pass;
|
|
}else if (is_member(currT.token,[",","|","||"]) ||
|
|
is_member(wordAfter,[",","|","||"])) {
|
|
t = postcommaToken(state);
|
|
return t ? t.column+t.token.length : unit;
|
|
}else if (currT.token == "->") {
|
|
if (is_member(prevT.token, ["receive","case","if","try"])) {
|
|
return prevT.column+unit+unit;
|
|
}else{
|
|
return prevT.column+unit;
|
|
}
|
|
}else if (is_member(currT.token,openParenWords)) {
|
|
return currT.column+currT.token.length;
|
|
}else{
|
|
t = defaultToken(state);
|
|
return truthy(t) ? t.column+unit : 0;
|
|
}
|
|
}
|
|
|
|
function wordafter(str) {
|
|
var m = str.match(/,|[a-z]+|\}|\]|\)|>>|\|+|\(/);
|
|
|
|
return truthy(m) && (m.index === 0) ? m[0] : "";
|
|
}
|
|
|
|
function postcommaToken(state) {
|
|
var objs = state.tokenStack.slice(0,-1);
|
|
var i = getTokenIndex(objs,"type",["open_paren"]);
|
|
|
|
return truthy(objs[i]) ? objs[i] : false;
|
|
}
|
|
|
|
function defaultToken(state) {
|
|
var objs = state.tokenStack;
|
|
var stop = getTokenIndex(objs,"type",["open_paren","separator","keyword"]);
|
|
var oper = getTokenIndex(objs,"type",["operator"]);
|
|
|
|
if (truthy(stop) && truthy(oper) && stop < oper) {
|
|
return objs[stop+1];
|
|
} else if (truthy(stop)) {
|
|
return objs[stop];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function getToken(state,tokens) {
|
|
var objs = state.tokenStack;
|
|
var i = getTokenIndex(objs,"token",tokens);
|
|
|
|
return truthy(objs[i]) ? objs[i] : false;
|
|
}
|
|
|
|
function getTokenIndex(objs,propname,propvals) {
|
|
|
|
for (var i = objs.length-1; -1 < i ; i--) {
|
|
if (is_member(objs[i][propname],propvals)) {
|
|
return i;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function truthy(x) {
|
|
return (x !== false) && (x != null);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// this object defines the mode
|
|
|
|
return {
|
|
startState:
|
|
function() {
|
|
return {tokenStack: [],
|
|
in_string: false,
|
|
in_atom: false};
|
|
},
|
|
|
|
token:
|
|
function(stream, state) {
|
|
return tokenizer(stream, state);
|
|
},
|
|
|
|
indent:
|
|
function(state, textAfter) {
|
|
return indenter(state,textAfter);
|
|
},
|
|
|
|
lineComment: "%"
|
|
};
|
|
});
|
|
|
|
});
|