| 1 |
export function simpleMode(states) { |
| 2 |
ensureState(states, "start"); |
| 3 |
var states_ = {}, meta = states.languageData || {}, hasIndentation = false; |
| 4 |
for (var state in states) if (state != meta && states.hasOwnProperty(state)) { |
| 5 |
var list = states_[state] = [], orig = states[state]; |
| 6 |
for (var i = 0; i < orig.length; i++) { |
| 7 |
var data = orig[i]; |
| 8 |
list.push(new Rule(data, states)); |
| 9 |
if (data.indent || data.dedent) hasIndentation = true; |
| 10 |
} |
| 11 |
} |
| 12 |
return { |
| 13 |
name: meta.name, |
| 14 |
startState: function() { |
| 15 |
return {state: "start", pending: null, indent: hasIndentation ? [] : null}; |
| 16 |
}, |
| 17 |
copyState: function(state) { |
| 18 |
var s = {state: state.state, pending: state.pending, indent: state.indent && state.indent.slice(0)}; |
| 19 |
if (state.stack) |
| 20 |
s.stack = state.stack.slice(0); |
| 21 |
return s; |
| 22 |
}, |
| 23 |
token: tokenFunction(states_), |
| 24 |
indent: indentFunction(states_, meta), |
| 25 |
mergeTokens: meta.mergeTokens, |
| 26 |
languageData: meta |
| 27 |
} |
| 28 |
}; |
| 29 |
|
| 30 |
function ensureState(states, name) { |
| 31 |
if (!states.hasOwnProperty(name)) |
| 32 |
throw new Error("Undefined state " + name + " in simple mode"); |
| 33 |
} |
| 34 |
|
| 35 |
function toRegex(val, caret) { |
| 36 |
if (!val) return /(?:)/; |
| 37 |
var flags = ""; |
| 38 |
if (val instanceof RegExp) { |
| 39 |
if (val.ignoreCase) flags = "i"; |
| 40 |
val = val.source; |
| 41 |
} else { |
| 42 |
val = String(val); |
| 43 |
} |
| 44 |
return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags); |
| 45 |
} |
| 46 |
|
| 47 |
function asToken(val) { |
| 48 |
if (!val) return null; |
| 49 |
if (val.apply) return val |
| 50 |
if (typeof val == "string") return val.replace(/\./g, " "); |
| 51 |
var result = []; |
| 52 |
for (var i = 0; i < val.length; i++) |
| 53 |
result.push(val[i] && val[i].replace(/\./g, " ")); |
| 54 |
return result; |
| 55 |
} |
| 56 |
|
| 57 |
function Rule(data, states) { |
| 58 |
if (data.next || data.push) ensureState(states, data.next || data.push); |
| 59 |
this.regex = toRegex(data.regex); |
| 60 |
this.token = asToken(data.token); |
| 61 |
this.data = data; |
| 62 |
} |
| 63 |
|
| 64 |
function tokenFunction(states) { |
| 65 |
return function(stream, state) { |
| 66 |
if (state.pending) { |
| 67 |
var pend = state.pending.shift(); |
| 68 |
if (state.pending.length == 0) state.pending = null; |
| 69 |
stream.pos += pend.text.length; |
| 70 |
return pend.token; |
| 71 |
} |
| 72 |
|
| 73 |
var curState = states[state.state]; |
| 74 |
for (var i = 0; i < curState.length; i++) { |
| 75 |
var rule = curState[i]; |
| 76 |
var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex); |
| 77 |
if (matches) { |
| 78 |
if (rule.data.next) { |
| 79 |
state.state = rule.data.next; |
| 80 |
} else if (rule.data.push) { |
| 81 |
(state.stack || (state.stack = [])).push(state.state); |
| 82 |
state.state = rule.data.push; |
| 83 |
} else if (rule.data.pop && state.stack && state.stack.length) { |
| 84 |
state.state = state.stack.pop(); |
| 85 |
} |
| 86 |
|
| 87 |
if (rule.data.indent) |
| 88 |
state.indent.push(stream.indentation() + stream.indentUnit); |
| 89 |
if (rule.data.dedent) |
| 90 |
state.indent.pop(); |
| 91 |
var token = rule.token |
| 92 |
if (token && token.apply) token = token(matches) |
| 93 |
if (matches.length > 2 && rule.token && typeof rule.token != "string") { |
| 94 |
state.pending = []; |
| 95 |
for (var j = 2; j < matches.length; j++) |
| 96 |
if (matches[j]) |
| 97 |
state.pending.push({text: matches[j], token: rule.token[j - 1]}); |
| 98 |
stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0)); |
| 99 |
return token[0]; |
| 100 |
} else if (token && token.join) { |
| 101 |
return token[0]; |
| 102 |
} else { |
| 103 |
return token; |
| 104 |
} |
| 105 |
} |
| 106 |
} |
| 107 |
stream.next(); |
| 108 |
return null; |
| 109 |
}; |
| 110 |
} |
| 111 |
|
| 112 |
function indentFunction(states, meta) { |
| 113 |
return function(state, textAfter) { |
| 114 |
if (state.indent == null || meta.dontIndentStates && meta.dontIndentStates.indexOf(state.state) > -1) |
| 115 |
return null |
| 116 |
|
| 117 |
var pos = state.indent.length - 1, rules = states[state.state]; |
| 118 |
scan: for (;;) { |
| 119 |
for (var i = 0; i < rules.length; i++) { |
| 120 |
var rule = rules[i]; |
| 121 |
if (rule.data.dedent && rule.data.dedentIfLineStart !== false) { |
| 122 |
var m = rule.regex.exec(textAfter); |
| 123 |
if (m && m[0]) { |
| 124 |
pos--; |
| 125 |
if (rule.next || rule.push) rules = states[rule.next || rule.push]; |
| 126 |
textAfter = textAfter.slice(m[0].length); |
| 127 |
continue scan; |
| 128 |
} |
| 129 |
} |
| 130 |
} |
| 131 |
break; |
| 132 |
} |
| 133 |
return pos < 0 ? 0 : state.indent[pos]; |
| 134 |
}; |
| 135 |
} |