mirror of
https://github.com/renbaoshuo/S2OJ.git
synced 2024-11-30 07:06:20 +00:00
96d4a3ecf7
Due to historical reasons, the code is in subfolder "1". With SVN removal, we place the code back and remove the annoying "1" folder.
623 lines
19 KiB
JavaScript
623 lines
19 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 (is_member(w,operatorAtomWords)) {
|
|
return rval(state,stream,"operator");
|
|
}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 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) {
|
|
var last = s.length-1;
|
|
|
|
if (s[last].type === "dot") {
|
|
return [];
|
|
}
|
|
if (s[last].type === "fun" && s[last-1].token === "fun") {
|
|
return s.slice(0,last-1);
|
|
}
|
|
switch (s[s.length-1].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: "%"
|
|
};
|
|
});
|
|
|
|
});
|