Edit File by line

// CodeMirror, copyright (c) by Marijn Haverbeke and others

[0] Fix | Delete

// Distributed under an MIT license: http://codemirror.net/LICENSE

[1] Fix | Delete

[2] Fix | Delete

/*jshint unused:true, eqnull:true, curly:true, bitwise:true */

[3] Fix | Delete

/*jshint undef:true, latedef:true, trailing:true */

[4] Fix | Delete

/*global CodeMirror:true */

[5] Fix | Delete

[6] Fix | Delete

// erlang mode.

[7] Fix | Delete

// tokenizer -> token types -> CodeMirror styles

[8] Fix | Delete

// tokenizer maintains a parse stack

[9] Fix | Delete

// indenter uses the parse stack

[10] Fix | Delete

[11] Fix | Delete

// TODO indenter:

[12] Fix | Delete

// bit syntax

[13] Fix | Delete

// old guard/bif/conversion clashes (e.g. "float/1")

[14] Fix | Delete

// type/spec/opaque

[15] Fix | Delete

[16] Fix | Delete

(function(mod) {

[17] Fix | Delete

if (typeof exports == "object" && typeof module == "object") // CommonJS

[18] Fix | Delete

mod(require("../../lib/codemirror"));

[19] Fix | Delete

else if (typeof define == "function" && define.amd) // AMD

[20] Fix | Delete

define(["../../lib/codemirror"], mod);

[21] Fix | Delete

else // Plain browser env

[22] Fix | Delete

mod(CodeMirror);

[23] Fix | Delete

})(function(CodeMirror) {

[24] Fix | Delete

"use strict";

[25] Fix | Delete

[26] Fix | Delete

CodeMirror.defineMIME("text/x-erlang", "erlang");

[27] Fix | Delete

[28] Fix | Delete

CodeMirror.defineMode("erlang", function(cmCfg) {

[29] Fix | Delete

"use strict";

[30] Fix | Delete

[31] Fix | Delete

/////////////////////////////////////////////////////////////////////////////

[32] Fix | Delete

// constants

[33] Fix | Delete

[34] Fix | Delete

var typeWords = [

[35] Fix | Delete

"-type", "-spec", "-export_type", "-opaque"];

[36] Fix | Delete

[37] Fix | Delete

var keywordWords = [

[38] Fix | Delete

"after","begin","catch","case","cond","end","fun","if",

[39] Fix | Delete

"let","of","query","receive","try","when"];

[40] Fix | Delete

[41] Fix | Delete

var separatorRE = /[\->,;]/;

[42] Fix | Delete

var separatorWords = [

[43] Fix | Delete

"->",";",","];

[44] Fix | Delete

[45] Fix | Delete

var operatorAtomWords = [

[46] Fix | Delete

"and","andalso","band","bnot","bor","bsl","bsr","bxor",

[47] Fix | Delete

"div","not","or","orelse","rem","xor"];

[48] Fix | Delete

[49] Fix | Delete

var operatorSymbolRE = /[\+\-\*\/<>=\|:!]/;

[50] Fix | Delete

var operatorSymbolWords = [

[51] Fix | Delete

"=","+","-","*","/",">",">=","<","=<","=:=","==","=/=","/=","||","<-","!"];

[52] Fix | Delete

[53] Fix | Delete

var openParenRE = /[<\(\[\{]/;

[54] Fix | Delete

var openParenWords = [

[55] Fix | Delete

"<<","(","[","{"];

[56] Fix | Delete

[57] Fix | Delete

var closeParenRE = /[>\)\]\}]/;

[58] Fix | Delete

var closeParenWords = [

[59] Fix | Delete

"}","]",")",">>"];

[60] Fix | Delete

[61] Fix | Delete

var guardWords = [

[62] Fix | Delete

"is_atom","is_binary","is_bitstring","is_boolean","is_float",

[63] Fix | Delete

"is_function","is_integer","is_list","is_number","is_pid",

[64] Fix | Delete

"is_port","is_record","is_reference","is_tuple",

[65] Fix | Delete

"atom","binary","bitstring","boolean","function","integer","list",

[66] Fix | Delete

"number","pid","port","record","reference","tuple"];

[67] Fix | Delete

[68] Fix | Delete

var bifWords = [

[69] Fix | Delete

"abs","adler32","adler32_combine","alive","apply","atom_to_binary",

[70] Fix | Delete

"atom_to_list","binary_to_atom","binary_to_existing_atom",

[71] Fix | Delete

"binary_to_list","binary_to_term","bit_size","bitstring_to_list",

[72] Fix | Delete

"byte_size","check_process_code","contact_binary","crc32",

[73] Fix | Delete

"crc32_combine","date","decode_packet","delete_module",

[74] Fix | Delete

"disconnect_node","element","erase","exit","float","float_to_list",

[75] Fix | Delete

"garbage_collect","get","get_keys","group_leader","halt","hd",

[76] Fix | Delete

"integer_to_list","internal_bif","iolist_size","iolist_to_binary",

[77] Fix | Delete

"is_alive","is_atom","is_binary","is_bitstring","is_boolean",

[78] Fix | Delete

"is_float","is_function","is_integer","is_list","is_number","is_pid",

[79] Fix | Delete

"is_port","is_process_alive","is_record","is_reference","is_tuple",

[80] Fix | Delete

"length","link","list_to_atom","list_to_binary","list_to_bitstring",

[81] Fix | Delete

"list_to_existing_atom","list_to_float","list_to_integer",

[82] Fix | Delete

"list_to_pid","list_to_tuple","load_module","make_ref","module_loaded",

[83] Fix | Delete

"monitor_node","node","node_link","node_unlink","nodes","notalive",

[84] Fix | Delete

"now","open_port","pid_to_list","port_close","port_command",

[85] Fix | Delete

"port_connect","port_control","pre_loaded","process_flag",

[86] Fix | Delete

"process_info","processes","purge_module","put","register",

[87] Fix | Delete

"registered","round","self","setelement","size","spawn","spawn_link",

[88] Fix | Delete

"spawn_monitor","spawn_opt","split_binary","statistics",

[89] Fix | Delete

"term_to_binary","time","throw","tl","trunc","tuple_size",

[90] Fix | Delete

"tuple_to_list","unlink","unregister","whereis"];

[91] Fix | Delete

[92] Fix | Delete

// upper case: [A-Z] [Ø-Þ] [À-Ö]

[93] Fix | Delete

// lower case: [a-z] [ß-ö] [ø-ÿ]

[94] Fix | Delete

var anumRE = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/;

[95] Fix | Delete

var escapesRE =

[96] Fix | Delete

/[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;

[97] Fix | Delete

[98] Fix | Delete

/////////////////////////////////////////////////////////////////////////////

[99] Fix | Delete

// tokenizer

[100] Fix | Delete

[101] Fix | Delete

function tokenizer(stream,state) {

[102] Fix | Delete

// in multi-line string

[103] Fix | Delete

if (state.in_string) {

[104] Fix | Delete

state.in_string = (!doubleQuote(stream));

[105] Fix | Delete

return rval(state,stream,"string");

[106] Fix | Delete

}

[107] Fix | Delete

[108] Fix | Delete

// in multi-line atom

[109] Fix | Delete

if (state.in_atom) {

[110] Fix | Delete

state.in_atom = (!singleQuote(stream));

[111] Fix | Delete

return rval(state,stream,"atom");

[112] Fix | Delete

}

[113] Fix | Delete

[114] Fix | Delete

// whitespace

[115] Fix | Delete

if (stream.eatSpace()) {

[116] Fix | Delete

return rval(state,stream,"whitespace");

[117] Fix | Delete

}

[118] Fix | Delete

[119] Fix | Delete

// attributes and type specs

[120] Fix | Delete

if (!peekToken(state) &&

[121] Fix | Delete

stream.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/)) {

[122] Fix | Delete

if (is_member(stream.current(),typeWords)) {

[123] Fix | Delete

return rval(state,stream,"type");

[124] Fix | Delete

}else{

[125] Fix | Delete

return rval(state,stream,"attribute");

[126] Fix | Delete

}

[127] Fix | Delete

}

[128] Fix | Delete

[129] Fix | Delete

var ch = stream.next();

[130] Fix | Delete

[131] Fix | Delete

// comment

[132] Fix | Delete

if (ch == '%') {

[133] Fix | Delete

stream.skipToEnd();

[134] Fix | Delete

return rval(state,stream,"comment");

[135] Fix | Delete

}

[136] Fix | Delete

[137] Fix | Delete

// colon

[138] Fix | Delete

if (ch == ":") {

[139] Fix | Delete

return rval(state,stream,"colon");

[140] Fix | Delete

}

[141] Fix | Delete

[142] Fix | Delete

// macro

[143] Fix | Delete

if (ch == '?') {

[144] Fix | Delete

stream.eatSpace();

[145] Fix | Delete

stream.eatWhile(anumRE);

[146] Fix | Delete

return rval(state,stream,"macro");

[147] Fix | Delete

}

[148] Fix | Delete

[149] Fix | Delete

// record

[150] Fix | Delete

if (ch == "#") {

[151] Fix | Delete

stream.eatSpace();

[152] Fix | Delete

stream.eatWhile(anumRE);

[153] Fix | Delete

return rval(state,stream,"record");

[154] Fix | Delete

}

[155] Fix | Delete

[156] Fix | Delete

// dollar escape

[157] Fix | Delete

if (ch == "$") {

[158] Fix | Delete

if (stream.next() == "\\" && !stream.match(escapesRE)) {

[159] Fix | Delete

return rval(state,stream,"error");

[160] Fix | Delete

}

[161] Fix | Delete

return rval(state,stream,"number");

[162] Fix | Delete

}

[163] Fix | Delete

[164] Fix | Delete

// dot

[165] Fix | Delete

if (ch == ".") {

[166] Fix | Delete

return rval(state,stream,"dot");

[167] Fix | Delete

}

[168] Fix | Delete

[169] Fix | Delete

// quoted atom

[170] Fix | Delete

if (ch == '\'') {

[171] Fix | Delete

if (!(state.in_atom = (!singleQuote(stream)))) {

[172] Fix | Delete

if (stream.match(/\s*\/\s*[0-9]/,false)) {

[173] Fix | Delete

stream.match(/\s*\/\s*[0-9]/,true);

[174] Fix | Delete

return rval(state,stream,"fun"); // 'f'/0 style fun

[175] Fix | Delete

}

[176] Fix | Delete

if (stream.match(/\s*\(/,false) || stream.match(/\s*:/,false)) {

[177] Fix | Delete

return rval(state,stream,"function");

[178] Fix | Delete

}

[179] Fix | Delete

}

[180] Fix | Delete

return rval(state,stream,"atom");

[181] Fix | Delete

}

[182] Fix | Delete

[183] Fix | Delete

// string

[184] Fix | Delete

if (ch == '"') {

[185] Fix | Delete

state.in_string = (!doubleQuote(stream));

[186] Fix | Delete

return rval(state,stream,"string");

[187] Fix | Delete

}

[188] Fix | Delete

[189] Fix | Delete

// variable

[190] Fix | Delete

if (/[A-Z_Ø-ÞÀ-Ö]/.test(ch)) {

[191] Fix | Delete

stream.eatWhile(anumRE);

[192] Fix | Delete

return rval(state,stream,"variable");

[193] Fix | Delete

}

[194] Fix | Delete

[195] Fix | Delete

// atom/keyword/BIF/function

[196] Fix | Delete

if (/[a-z_ß-öø-ÿ]/.test(ch)) {

[197] Fix | Delete

stream.eatWhile(anumRE);

[198] Fix | Delete

[199] Fix | Delete

if (stream.match(/\s*\/\s*[0-9]/,false)) {

[200] Fix | Delete

stream.match(/\s*\/\s*[0-9]/,true);

[201] Fix | Delete

return rval(state,stream,"fun"); // f/0 style fun

[202] Fix | Delete

}

[203] Fix | Delete

[204] Fix | Delete

var w = stream.current();

[205] Fix | Delete

[206] Fix | Delete

if (is_member(w,keywordWords)) {

[207] Fix | Delete

return rval(state,stream,"keyword");

[208] Fix | Delete

}else if (is_member(w,operatorAtomWords)) {

[209] Fix | Delete

return rval(state,stream,"operator");

[210] Fix | Delete

}else if (stream.match(/\s*\(/,false)) {

[211] Fix | Delete

// 'put' and 'erlang:put' are bifs, 'foo:put' is not

[212] Fix | Delete

if (is_member(w,bifWords) &&

[213] Fix | Delete

((peekToken(state).token != ":") ||

[214] Fix | Delete

(peekToken(state,2).token == "erlang"))) {

[215] Fix | Delete

return rval(state,stream,"builtin");

[216] Fix | Delete

}else if (is_member(w,guardWords)) {

[217] Fix | Delete

return rval(state,stream,"guard");

[218] Fix | Delete

}else{

[219] Fix | Delete

return rval(state,stream,"function");

[220] Fix | Delete

}

[221] Fix | Delete

}else if (lookahead(stream) == ":") {

[222] Fix | Delete

if (w == "erlang") {

[223] Fix | Delete

return rval(state,stream,"builtin");

[224] Fix | Delete

} else {

[225] Fix | Delete

return rval(state,stream,"function");

[226] Fix | Delete

}

[227] Fix | Delete

}else if (is_member(w,["true","false"])) {

[228] Fix | Delete

return rval(state,stream,"boolean");

[229] Fix | Delete

}else{

[230] Fix | Delete

return rval(state,stream,"atom");

[231] Fix | Delete

}

[232] Fix | Delete

}

[233] Fix | Delete

[234] Fix | Delete

// number

[235] Fix | Delete

var digitRE = /[0-9]/;

[236] Fix | Delete

var radixRE = /[0-9a-zA-Z]/; // 36#zZ style int

[237] Fix | Delete

if (digitRE.test(ch)) {

[238] Fix | Delete

stream.eatWhile(digitRE);

[239] Fix | Delete

if (stream.eat('#')) { // 36#aZ style integer

[240] Fix | Delete

if (!stream.eatWhile(radixRE)) {

[241] Fix | Delete

stream.backUp(1); //"36#" - syntax error

[242] Fix | Delete

}

[243] Fix | Delete

} else if (stream.eat('.')) { // float

[244] Fix | Delete

if (!stream.eatWhile(digitRE)) {

[245] Fix | Delete

stream.backUp(1); // "3." - probably end of function

[246] Fix | Delete

} else {

[247] Fix | Delete

if (stream.eat(/[eE]/)) { // float with exponent

[248] Fix | Delete

if (stream.eat(/[-+]/)) {

[249] Fix | Delete

if (!stream.eatWhile(digitRE)) {

[250] Fix | Delete

stream.backUp(2); // "2e-" - syntax error

[251] Fix | Delete

}

[252] Fix | Delete

} else {

[253] Fix | Delete

if (!stream.eatWhile(digitRE)) {

[254] Fix | Delete

stream.backUp(1); // "2e" - syntax error

[255] Fix | Delete

}

[256] Fix | Delete

}

[257] Fix | Delete

}

[258] Fix | Delete

}

[259] Fix | Delete

}

[260] Fix | Delete

return rval(state,stream,"number"); // normal integer

[261] Fix | Delete

}

[262] Fix | Delete

[263] Fix | Delete

// open parens

[264] Fix | Delete

if (nongreedy(stream,openParenRE,openParenWords)) {

[265] Fix | Delete

return rval(state,stream,"open_paren");

[266] Fix | Delete

}

[267] Fix | Delete

[268] Fix | Delete

// close parens

[269] Fix | Delete

if (nongreedy(stream,closeParenRE,closeParenWords)) {

[270] Fix | Delete

return rval(state,stream,"close_paren");

[271] Fix | Delete

}

[272] Fix | Delete

[273] Fix | Delete

// separators

[274] Fix | Delete

if (greedy(stream,separatorRE,separatorWords)) {

[275] Fix | Delete

return rval(state,stream,"separator");

[276] Fix | Delete

}

[277] Fix | Delete

[278] Fix | Delete

// operators

[279] Fix | Delete

if (greedy(stream,operatorSymbolRE,operatorSymbolWords)) {

[280] Fix | Delete

return rval(state,stream,"operator");

[281] Fix | Delete

}

[282] Fix | Delete

[283] Fix | Delete

return rval(state,stream,null);

[284] Fix | Delete

}

[285] Fix | Delete

[286] Fix | Delete

/////////////////////////////////////////////////////////////////////////////

[287] Fix | Delete

// utilities

[288] Fix | Delete

function nongreedy(stream,re,words) {

[289] Fix | Delete

if (stream.current().length == 1 && re.test(stream.current())) {

[290] Fix | Delete

stream.backUp(1);

[291] Fix | Delete

while (re.test(stream.peek())) {

[292] Fix | Delete

stream.next();

[293] Fix | Delete

if (is_member(stream.current(),words)) {

[294] Fix | Delete

return true;

[295] Fix | Delete

}

[296] Fix | Delete

}

[297] Fix | Delete

stream.backUp(stream.current().length-1);

[298] Fix | Delete

}

[299] Fix | Delete

return false;

[300] Fix | Delete

}

[301] Fix | Delete

[302] Fix | Delete

function greedy(stream,re,words) {

[303] Fix | Delete

if (stream.current().length == 1 && re.test(stream.current())) {

[304] Fix | Delete

while (re.test(stream.peek())) {

[305] Fix | Delete

stream.next();

[306] Fix | Delete

}

[307] Fix | Delete

while (0 < stream.current().length) {

[308] Fix | Delete

if (is_member(stream.current(),words)) {

[309] Fix | Delete

return true;

[310] Fix | Delete

}else{

[311] Fix | Delete

stream.backUp(1);

[312] Fix | Delete

}

[313] Fix | Delete

}

[314] Fix | Delete

stream.next();

[315] Fix | Delete

}

[316] Fix | Delete

return false;

[317] Fix | Delete

}

[318] Fix | Delete

[319] Fix | Delete

function doubleQuote(stream) {

[320] Fix | Delete

return quote(stream, '"', '\\');

[321] Fix | Delete

}

[322] Fix | Delete

[323] Fix | Delete

function singleQuote(stream) {

[324] Fix | Delete

return quote(stream,'\'','\\');

[325] Fix | Delete

}

[326] Fix | Delete

[327] Fix | Delete

function quote(stream,quoteChar,escapeChar) {

[328] Fix | Delete

while (!stream.eol()) {

[329] Fix | Delete

var ch = stream.next();

[330] Fix | Delete

if (ch == quoteChar) {

[331] Fix | Delete

return true;

[332] Fix | Delete

}else if (ch == escapeChar) {

[333] Fix | Delete

stream.next();

[334] Fix | Delete

}

[335] Fix | Delete

}

[336] Fix | Delete

return false;

[337] Fix | Delete

}

[338] Fix | Delete

[339] Fix | Delete

function lookahead(stream) {

[340] Fix | Delete

var m = stream.match(/([\n\s]+|%[^\n]*\n)*(.)/,false);

[341] Fix | Delete

return m ? m.pop() : "";

[342] Fix | Delete

}

[343] Fix | Delete

[344] Fix | Delete

function is_member(element,list) {

[345] Fix | Delete

return (-1 < list.indexOf(element));

[346] Fix | Delete

}

[347] Fix | Delete

[348] Fix | Delete

function rval(state,stream,type) {

[349] Fix | Delete

[350] Fix | Delete

// parse stack

[351] Fix | Delete

pushToken(state,realToken(type,stream));

[352] Fix | Delete

[353] Fix | Delete

// map erlang token type to CodeMirror style class

[354] Fix | Delete

// erlang -> CodeMirror tag

[355] Fix | Delete

switch (type) {

[356] Fix | Delete

case "atom": return "atom";

[357] Fix | Delete

case "attribute": return "attribute";

[358] Fix | Delete

case "boolean": return "atom";

[359] Fix | Delete

case "builtin": return "builtin";

[360] Fix | Delete

case "close_paren": return null;

[361] Fix | Delete

case "colon": return null;

[362] Fix | Delete

case "comment": return "comment";

[363] Fix | Delete

case "dot": return null;

[364] Fix | Delete

case "error": return "error";

[365] Fix | Delete

case "fun": return "meta";

[366] Fix | Delete

case "function": return "tag";

[367] Fix | Delete

case "guard": return "property";

[368] Fix | Delete

case "keyword": return "keyword";

[369] Fix | Delete

case "macro": return "variable-2";

[370] Fix | Delete

case "number": return "number";

[371] Fix | Delete

case "open_paren": return null;

[372] Fix | Delete

case "operator": return "operator";

[373] Fix | Delete

case "record": return "bracket";

[374] Fix | Delete

case "separator": return null;

[375] Fix | Delete

case "string": return "string";

[376] Fix | Delete

case "type": return "def";

[377] Fix | Delete

case "variable": return "variable";

[378] Fix | Delete

default: return null;

[379] Fix | Delete

}

[380] Fix | Delete

}

[381] Fix | Delete

[382] Fix | Delete

function aToken(tok,col,ind,typ) {

[383] Fix | Delete

return {token: tok,

[384] Fix | Delete

column: col,

[385] Fix | Delete

indent: ind,

[386] Fix | Delete

type: typ};

[387] Fix | Delete

}

[388] Fix | Delete

[389] Fix | Delete

function realToken(type,stream) {

[390] Fix | Delete

return aToken(stream.current(),

[391] Fix | Delete

stream.column(),

[392] Fix | Delete

stream.indentation(),

[393] Fix | Delete

type);

[394] Fix | Delete

}

[395] Fix | Delete

[396] Fix | Delete

function fakeToken(type) {

[397] Fix | Delete

return aToken(type,0,0,type);

[398] Fix | Delete

}

[399] Fix | Delete

[400] Fix | Delete

function peekToken(state,depth) {

[401] Fix | Delete

var len = state.tokenStack.length;

[402] Fix | Delete

var dep = (depth ? depth : 1);

[403] Fix | Delete

[404] Fix | Delete

if (len < dep) {

[405] Fix | Delete

return false;

[406] Fix | Delete

}else{

[407] Fix | Delete

return state.tokenStack[len-dep];

[408] Fix | Delete

}

[409] Fix | Delete

}

[410] Fix | Delete

[411] Fix | Delete

function pushToken(state,token) {

[412] Fix | Delete

[413] Fix | Delete

if (!(token.type == "comment" || token.type == "whitespace")) {

[414] Fix | Delete

state.tokenStack = maybe_drop_pre(state.tokenStack,token);

[415] Fix | Delete

state.tokenStack = maybe_drop_post(state.tokenStack);

[416] Fix | Delete

}

[417] Fix | Delete

}

[418] Fix | Delete

[419] Fix | Delete

function maybe_drop_pre(s,token) {

[420] Fix | Delete

var last = s.length-1;

[421] Fix | Delete

[422] Fix | Delete

if (0 < last && s[last].type === "record" && token.type === "dot") {

[423] Fix | Delete

s.pop();

[424] Fix | Delete

}else if (0 < last && s[last].type === "group") {

[425] Fix | Delete

s.pop();

[426] Fix | Delete

s.push(token);

[427] Fix | Delete

}else{

[428] Fix | Delete

s.push(token);

[429] Fix | Delete

}

[430] Fix | Delete

return s;

[431] Fix | Delete

}

[432] Fix | Delete

[433] Fix | Delete

function maybe_drop_post(s) {

[434] Fix | Delete

var last = s.length-1;

[435] Fix | Delete

[436] Fix | Delete

if (s[last].type === "dot") {

[437] Fix | Delete

return [];

[438] Fix | Delete

}

[439] Fix | Delete

if (s[last].type === "fun" && s[last-1].token === "fun") {

[440] Fix | Delete

return s.slice(0,last-1);

[441] Fix | Delete

}

[442] Fix | Delete

switch (s[s.length-1].token) {

[443] Fix | Delete

case "}": return d(s,{g:["{"]});

[444] Fix | Delete

case "]": return d(s,{i:["["]});

[445] Fix | Delete

case ")": return d(s,{i:["("]});

[446] Fix | Delete

case ">>": return d(s,{i:["<<"]});

[447] Fix | Delete

case "end": return d(s,{i:["begin","case","fun","if","receive","try"]});

[448] Fix | Delete

case ",": return d(s,{e:["begin","try","when","->",

[449] Fix | Delete

",","(","[","{","<<"]});

[450] Fix | Delete

case "->": return d(s,{r:["when"],

[451] Fix | Delete

m:["try","if","case","receive"]});

[452] Fix | Delete

case ";": return d(s,{E:["case","fun","if","receive","try","when"]});

[453] Fix | Delete

case "catch":return d(s,{e:["try"]});

[454] Fix | Delete

case "of": return d(s,{e:["case"]});

[455] Fix | Delete

case "after":return d(s,{e:["receive","try"]});

[456] Fix | Delete

default: return s;

[457] Fix | Delete

}

[458] Fix | Delete

}

[459] Fix | Delete

[460] Fix | Delete

function d(stack,tt) {

[461] Fix | Delete

// stack is a stack of Token objects.

[462] Fix | Delete

// tt is an object; {type:tokens}

[463] Fix | Delete

// type is a char, tokens is a list of token strings.

[464] Fix | Delete

// The function returns (possibly truncated) stack.

[465] Fix | Delete

// It will descend the stack, looking for a Token such that Token.token

[466] Fix | Delete

// is a member of tokens. If it does not find that, it will normally (but

[467] Fix | Delete

// see "E" below) return stack. If it does find a match, it will remove

[468] Fix | Delete

// all the Tokens between the top and the matched Token.

[469] Fix | Delete

// If type is "m", that is all it does.

[470] Fix | Delete

// If type is "i", it will also remove the matched Token and the top Token.

[471] Fix | Delete

// If type is "g", like "i", but add a fake "group" token at the top.

[472] Fix | Delete

// If type is "r", it will remove the matched Token, but not the top Token.

[473] Fix | Delete

// If type is "e", it will keep the matched Token but not the top Token.

[474] Fix | Delete

// If type is "E", it behaves as for type "e", except if there is no match,

[475] Fix | Delete

// in which case it will return an empty stack.

[476] Fix | Delete

[477] Fix | Delete

for (var type in tt) {

[478] Fix | Delete

var len = stack.length-1;

[479] Fix | Delete

var tokens = tt[type];

[480] Fix | Delete

for (var i = len-1; -1 < i ; i--) {

[481] Fix | Delete

if (is_member(stack[i].token,tokens)) {

[482] Fix | Delete

var ss = stack.slice(0,i);

[483] Fix | Delete

switch (type) {

[484] Fix | Delete

case "m": return ss.concat(stack[i]).concat(stack[len]);

[485] Fix | Delete

case "r": return ss.concat(stack[len]);

[486] Fix | Delete

case "i": return ss;

[487] Fix | Delete

case "g": return ss.concat(fakeToken("group"));

[488] Fix | Delete

case "E": return ss.concat(stack[i]);

[489] Fix | Delete

case "e": return ss.concat(stack[i]);

[490] Fix | Delete

}

[491] Fix | Delete

}

[492] Fix | Delete

}

[493] Fix | Delete

}

[494] Fix | Delete

return (type == "E" ? [] : stack);

[495] Fix | Delete

}

[496] Fix | Delete

[497] Fix | Delete

/////////////////////////////////////////////////////////////////////////////

[498] Fix | Delete

// indenter

[499] Fix | Delete