mirror of https://github.com/gogits/gogs.git
Richard Mahn
9 years ago
395 changed files with 50808 additions and 852 deletions
@ -1,4 +1,9 @@
|
||||
Please, make sure you are targeting the `develop` branch! |
||||
The pull request will be closed without any reasons if it does not satisfy any of following requirements: |
||||
|
||||
More instructions about contributing with Gogs code can be found here: |
||||
1. Please make sure you are targeting the `develop` branch. |
||||
2. Please read contributing guidelines: |
||||
https://github.com/gogits/gogs/wiki/Contributing-Code |
||||
3. Please describe what your pull request does and which issue you're targeting |
||||
4. ... if it is not related to any particular issues, explain why we should not reject your pull request. |
||||
|
||||
**You MUST delete above content including this line before posting; too lazy to take this action considered invalid pull request.** |
||||
|
||||
@ -0,0 +1,8 @@
|
||||
*.txt text |
||||
*.js text |
||||
*.html text |
||||
*.md text |
||||
*.json text |
||||
*.yml text |
||||
*.css text |
||||
*.svg text |
||||
@ -0,0 +1,8 @@
|
||||
/node_modules |
||||
/npm-debug.log |
||||
/test*.html |
||||
.tern-* |
||||
*~ |
||||
*.swp |
||||
.idea |
||||
*.iml |
||||
@ -0,0 +1,10 @@
|
||||
/node_modules |
||||
/demo |
||||
/doc |
||||
/test |
||||
/test*.html |
||||
/index.html |
||||
/mode/*/*test.js |
||||
/mode/*/*.html |
||||
/mode/index.html |
||||
.* |
||||
@ -0,0 +1,4 @@
|
||||
language: node_js |
||||
node_js: |
||||
- stable |
||||
sudo: false |
||||
@ -0,0 +1,64 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"), "cjs"); |
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror"], function(CM) { mod(CM, "amd"); }); |
||||
else // Plain browser env
|
||||
mod(CodeMirror, "plain"); |
||||
})(function(CodeMirror, env) { |
||||
if (!CodeMirror.modeURL) CodeMirror.modeURL = "../mode/%N/%N.js"; |
||||
|
||||
var loading = {}; |
||||
function splitCallback(cont, n) { |
||||
var countDown = n; |
||||
return function() { if (--countDown == 0) cont(); }; |
||||
} |
||||
function ensureDeps(mode, cont) { |
||||
var deps = CodeMirror.modes[mode].dependencies; |
||||
if (!deps) return cont(); |
||||
var missing = []; |
||||
for (var i = 0; i < deps.length; ++i) { |
||||
if (!CodeMirror.modes.hasOwnProperty(deps[i])) |
||||
missing.push(deps[i]); |
||||
} |
||||
if (!missing.length) return cont(); |
||||
var split = splitCallback(cont, missing.length); |
||||
for (var i = 0; i < missing.length; ++i) |
||||
CodeMirror.requireMode(missing[i], split); |
||||
} |
||||
|
||||
CodeMirror.requireMode = function(mode, cont) { |
||||
if (typeof mode != "string") mode = mode.name; |
||||
if (CodeMirror.modes.hasOwnProperty(mode)) return ensureDeps(mode, cont); |
||||
if (loading.hasOwnProperty(mode)) return loading[mode].push(cont); |
||||
|
||||
var file = CodeMirror.modeURL.replace(/%N/g, mode); |
||||
if (env == "plain") { |
||||
var script = document.createElement("script"); |
||||
script.src = file; |
||||
var others = document.getElementsByTagName("script")[0]; |
||||
var list = loading[mode] = [cont]; |
||||
CodeMirror.on(script, "load", function() { |
||||
ensureDeps(mode, function() { |
||||
for (var i = 0; i < list.length; ++i) list[i](); |
||||
}); |
||||
}); |
||||
others.parentNode.insertBefore(script, others); |
||||
} else if (env == "cjs") { |
||||
require(file); |
||||
cont(); |
||||
} else if (env == "amd") { |
||||
requirejs([file], cont); |
||||
} |
||||
}; |
||||
|
||||
CodeMirror.autoLoadMode = function(instance, mode) { |
||||
if (!CodeMirror.modes.hasOwnProperty(mode)) |
||||
CodeMirror.requireMode(mode, function() { |
||||
instance.setOption("mode", instance.getOption("mode")); |
||||
}); |
||||
}; |
||||
}); |
||||
@ -0,0 +1,123 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.multiplexingMode = function(outer /*, others */) { |
||||
// Others should be {open, close, mode [, delimStyle] [, innerStyle]} objects
|
||||
var others = Array.prototype.slice.call(arguments, 1); |
||||
|
||||
function indexOf(string, pattern, from, returnEnd) { |
||||
if (typeof pattern == "string") { |
||||
var found = string.indexOf(pattern, from); |
||||
return returnEnd && found > -1 ? found + pattern.length : found; |
||||
} |
||||
var m = pattern.exec(from ? string.slice(from) : string); |
||||
return m ? m.index + from + (returnEnd ? m[0].length : 0) : -1; |
||||
} |
||||
|
||||
return { |
||||
startState: function() { |
||||
return { |
||||
outer: CodeMirror.startState(outer), |
||||
innerActive: null, |
||||
inner: null |
||||
}; |
||||
}, |
||||
|
||||
copyState: function(state) { |
||||
return { |
||||
outer: CodeMirror.copyState(outer, state.outer), |
||||
innerActive: state.innerActive, |
||||
inner: state.innerActive && CodeMirror.copyState(state.innerActive.mode, state.inner) |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
if (!state.innerActive) { |
||||
var cutOff = Infinity, oldContent = stream.string; |
||||
for (var i = 0; i < others.length; ++i) { |
||||
var other = others[i]; |
||||
var found = indexOf(oldContent, other.open, stream.pos); |
||||
if (found == stream.pos) { |
||||
if (!other.parseDelimiters) stream.match(other.open); |
||||
state.innerActive = other; |
||||
state.inner = CodeMirror.startState(other.mode, outer.indent ? outer.indent(state.outer, "") : 0); |
||||
return other.delimStyle && (other.delimStyle + " " + other.delimStyle + "-open"); |
||||
} else if (found != -1 && found < cutOff) { |
||||
cutOff = found; |
||||
} |
||||
} |
||||
if (cutOff != Infinity) stream.string = oldContent.slice(0, cutOff); |
||||
var outerToken = outer.token(stream, state.outer); |
||||
if (cutOff != Infinity) stream.string = oldContent; |
||||
return outerToken; |
||||
} else { |
||||
var curInner = state.innerActive, oldContent = stream.string; |
||||
if (!curInner.close && stream.sol()) { |
||||
state.innerActive = state.inner = null; |
||||
return this.token(stream, state); |
||||
} |
||||
var found = curInner.close ? indexOf(oldContent, curInner.close, stream.pos, curInner.parseDelimiters) : -1; |
||||
if (found == stream.pos && !curInner.parseDelimiters) { |
||||
stream.match(curInner.close); |
||||
state.innerActive = state.inner = null; |
||||
return curInner.delimStyle && (curInner.delimStyle + " " + curInner.delimStyle + "-close"); |
||||
} |
||||
if (found > -1) stream.string = oldContent.slice(0, found); |
||||
var innerToken = curInner.mode.token(stream, state.inner); |
||||
if (found > -1) stream.string = oldContent; |
||||
|
||||
if (found == stream.pos && curInner.parseDelimiters) |
||||
state.innerActive = state.inner = null; |
||||
|
||||
if (curInner.innerStyle) { |
||||
if (innerToken) innerToken = innerToken + " " + curInner.innerStyle; |
||||
else innerToken = curInner.innerStyle; |
||||
} |
||||
|
||||
return innerToken; |
||||
} |
||||
}, |
||||
|
||||
indent: function(state, textAfter) { |
||||
var mode = state.innerActive ? state.innerActive.mode : outer; |
||||
if (!mode.indent) return CodeMirror.Pass; |
||||
return mode.indent(state.innerActive ? state.inner : state.outer, textAfter); |
||||
}, |
||||
|
||||
blankLine: function(state) { |
||||
var mode = state.innerActive ? state.innerActive.mode : outer; |
||||
if (mode.blankLine) { |
||||
mode.blankLine(state.innerActive ? state.inner : state.outer); |
||||
} |
||||
if (!state.innerActive) { |
||||
for (var i = 0; i < others.length; ++i) { |
||||
var other = others[i]; |
||||
if (other.open === "\n") { |
||||
state.innerActive = other; |
||||
state.inner = CodeMirror.startState(other.mode, mode.indent ? mode.indent(state.outer, "") : 0); |
||||
} |
||||
} |
||||
} else if (state.innerActive.close === "\n") { |
||||
state.innerActive = state.inner = null; |
||||
} |
||||
}, |
||||
|
||||
electricChars: outer.electricChars, |
||||
|
||||
innerMode: function(state) { |
||||
return state.inner ? {state: state.inner, mode: state.innerActive.mode} : {state: state.outer, mode: outer}; |
||||
} |
||||
}; |
||||
}; |
||||
|
||||
}); |
||||
@ -0,0 +1,33 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
CodeMirror.defineMode("markdown_with_stex", function(){ |
||||
var inner = CodeMirror.getMode({}, "stex"); |
||||
var outer = CodeMirror.getMode({}, "markdown"); |
||||
|
||||
var innerOptions = { |
||||
open: '$', |
||||
close: '$', |
||||
mode: inner, |
||||
delimStyle: 'delim', |
||||
innerStyle: 'inner' |
||||
}; |
||||
|
||||
return CodeMirror.multiplexingMode(outer, innerOptions); |
||||
}); |
||||
|
||||
var mode = CodeMirror.getMode({}, "markdown_with_stex"); |
||||
|
||||
function MT(name) { |
||||
test.mode( |
||||
name, |
||||
mode, |
||||
Array.prototype.slice.call(arguments, 1), |
||||
'multiplexing'); |
||||
} |
||||
|
||||
MT( |
||||
"stexInsideMarkdown", |
||||
"[strong **Equation:**] [delim&delim-open $][inner&tag \\pi][delim&delim-close $]"); |
||||
})(); |
||||
@ -0,0 +1,85 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
// Utility function that allows modes to be combined. The mode given
|
||||
// as the base argument takes care of most of the normal mode
|
||||
// functionality, but a second (typically simple) mode is used, which
|
||||
// can override the style of text. Both modes get to parse all of the
|
||||
// text, but when both assign a non-null style to a piece of code, the
|
||||
// overlay wins, unless the combine argument was true and not overridden,
|
||||
// or state.overlay.combineTokens was true, in which case the styles are
|
||||
// combined.
|
||||
|
||||
(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.overlayMode = function(base, overlay, combine) { |
||||
return { |
||||
startState: function() { |
||||
return { |
||||
base: CodeMirror.startState(base), |
||||
overlay: CodeMirror.startState(overlay), |
||||
basePos: 0, baseCur: null, |
||||
overlayPos: 0, overlayCur: null, |
||||
streamSeen: null |
||||
}; |
||||
}, |
||||
copyState: function(state) { |
||||
return { |
||||
base: CodeMirror.copyState(base, state.base), |
||||
overlay: CodeMirror.copyState(overlay, state.overlay), |
||||
basePos: state.basePos, baseCur: null, |
||||
overlayPos: state.overlayPos, overlayCur: null |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
if (stream != state.streamSeen || |
||||
Math.min(state.basePos, state.overlayPos) < stream.start) { |
||||
state.streamSeen = stream; |
||||
state.basePos = state.overlayPos = stream.start; |
||||
} |
||||
|
||||
if (stream.start == state.basePos) { |
||||
state.baseCur = base.token(stream, state.base); |
||||
state.basePos = stream.pos; |
||||
} |
||||
if (stream.start == state.overlayPos) { |
||||
stream.pos = stream.start; |
||||
state.overlayCur = overlay.token(stream, state.overlay); |
||||
state.overlayPos = stream.pos; |
||||
} |
||||
stream.pos = Math.min(state.basePos, state.overlayPos); |
||||
|
||||
// state.overlay.combineTokens always takes precedence over combine,
|
||||
// unless set to null
|
||||
if (state.overlayCur == null) return state.baseCur; |
||||
else if (state.baseCur != null && |
||||
state.overlay.combineTokens || |
||||
combine && state.overlay.combineTokens == null) |
||||
return state.baseCur + " " + state.overlayCur; |
||||
else return state.overlayCur; |
||||
}, |
||||
|
||||
indent: base.indent && function(state, textAfter) { |
||||
return base.indent(state.base, textAfter); |
||||
}, |
||||
electricChars: base.electricChars, |
||||
|
||||
innerMode: function(state) { return {state: state.base, mode: base}; }, |
||||
|
||||
blankLine: function(state) { |
||||
if (base.blankLine) base.blankLine(state.base); |
||||
if (overlay.blankLine) overlay.blankLine(state.overlay); |
||||
} |
||||
}; |
||||
}; |
||||
|
||||
}); |
||||
@ -0,0 +1,213 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineSimpleMode = function(name, states) { |
||||
CodeMirror.defineMode(name, function(config) { |
||||
return CodeMirror.simpleMode(config, states); |
||||
}); |
||||
}; |
||||
|
||||
CodeMirror.simpleMode = function(config, states) { |
||||
ensureState(states, "start"); |
||||
var states_ = {}, meta = states.meta || {}, hasIndentation = false; |
||||
for (var state in states) if (state != meta && states.hasOwnProperty(state)) { |
||||
var list = states_[state] = [], orig = states[state]; |
||||
for (var i = 0; i < orig.length; i++) { |
||||
var data = orig[i]; |
||||
list.push(new Rule(data, states)); |
||||
if (data.indent || data.dedent) hasIndentation = true; |
||||
} |
||||
} |
||||
var mode = { |
||||
startState: function() { |
||||
return {state: "start", pending: null, |
||||
local: null, localState: null, |
||||
indent: hasIndentation ? [] : null}; |
||||
}, |
||||
copyState: function(state) { |
||||
var s = {state: state.state, pending: state.pending, |
||||
local: state.local, localState: null, |
||||
indent: state.indent && state.indent.slice(0)}; |
||||
if (state.localState) |
||||
s.localState = CodeMirror.copyState(state.local.mode, state.localState); |
||||
if (state.stack) |
||||
s.stack = state.stack.slice(0); |
||||
for (var pers = state.persistentStates; pers; pers = pers.next) |
||||
s.persistentStates = {mode: pers.mode, |
||||
spec: pers.spec, |
||||
state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state), |
||||
next: s.persistentStates}; |
||||
return s; |
||||
}, |
||||
token: tokenFunction(states_, config), |
||||
innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; }, |
||||
indent: indentFunction(states_, meta) |
||||
}; |
||||
if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop)) |
||||
mode[prop] = meta[prop]; |
||||
return mode; |
||||
}; |
||||
|
||||
function ensureState(states, name) { |
||||
if (!states.hasOwnProperty(name)) |
||||
throw new Error("Undefined state " + name + " in simple mode"); |
||||
} |
||||
|
||||
function toRegex(val, caret) { |
||||
if (!val) return /(?:)/; |
||||
var flags = ""; |
||||
if (val instanceof RegExp) { |
||||
if (val.ignoreCase) flags = "i"; |
||||
val = val.source; |
||||
} else { |
||||
val = String(val); |
||||
} |
||||
return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags); |
||||
} |
||||
|
||||
function asToken(val) { |
||||
if (!val) return null; |
||||
if (typeof val == "string") return val.replace(/\./g, " "); |
||||
var result = []; |
||||
for (var i = 0; i < val.length; i++) |
||||
result.push(val[i] && val[i].replace(/\./g, " ")); |
||||
return result; |
||||
} |
||||
|
||||
function Rule(data, states) { |
||||
if (data.next || data.push) ensureState(states, data.next || data.push); |
||||
this.regex = toRegex(data.regex); |
||||
this.token = asToken(data.token); |
||||
this.data = data; |
||||
} |
||||
|
||||
function tokenFunction(states, config) { |
||||
return function(stream, state) { |
||||
if (state.pending) { |
||||
var pend = state.pending.shift(); |
||||
if (state.pending.length == 0) state.pending = null; |
||||
stream.pos += pend.text.length; |
||||
return pend.token; |
||||
} |
||||
|
||||
if (state.local) { |
||||
if (state.local.end && stream.match(state.local.end)) { |
||||
var tok = state.local.endToken || null; |
||||
state.local = state.localState = null; |
||||
return tok; |
||||
} else { |
||||
var tok = state.local.mode.token(stream, state.localState), m; |
||||
if (state.local.endScan && (m = state.local.endScan.exec(stream.current()))) |
||||
stream.pos = stream.start + m.index; |
||||
return tok; |
||||
} |
||||
} |
||||
|
||||
var curState = states[state.state]; |
||||
for (var i = 0; i < curState.length; i++) { |
||||
var rule = curState[i]; |
||||
var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex); |
||||
if (matches) { |
||||
if (rule.data.next) { |
||||
state.state = rule.data.next; |
||||
} else if (rule.data.push) { |
||||
(state.stack || (state.stack = [])).push(state.state); |
||||
state.state = rule.data.push; |
||||
} else if (rule.data.pop && state.stack && state.stack.length) { |
||||
state.state = state.stack.pop(); |
||||
} |
||||
|
||||
if (rule.data.mode) |
||||
enterLocalMode(config, state, rule.data.mode, rule.token); |
||||
if (rule.data.indent) |
||||
state.indent.push(stream.indentation() + config.indentUnit); |
||||
if (rule.data.dedent) |
||||
state.indent.pop(); |
||||
if (matches.length > 2) { |
||||
state.pending = []; |
||||
for (var j = 2; j < matches.length; j++) |
||||
if (matches[j]) |
||||
state.pending.push({text: matches[j], token: rule.token[j - 1]}); |
||||
stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0)); |
||||
return rule.token[0]; |
||||
} else if (rule.token && rule.token.join) { |
||||
return rule.token[0]; |
||||
} else { |
||||
return rule.token; |
||||
} |
||||
} |
||||
} |
||||
stream.next(); |
||||
return null; |
||||
}; |
||||
} |
||||
|
||||
function cmp(a, b) { |
||||
if (a === b) return true; |
||||
if (!a || typeof a != "object" || !b || typeof b != "object") return false; |
||||
var props = 0; |
||||
for (var prop in a) if (a.hasOwnProperty(prop)) { |
||||
if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false; |
||||
props++; |
||||
} |
||||
for (var prop in b) if (b.hasOwnProperty(prop)) props--; |
||||
return props == 0; |
||||
} |
||||
|
||||
function enterLocalMode(config, state, spec, token) { |
||||
var pers; |
||||
if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next) |
||||
if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p; |
||||
var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec); |
||||
var lState = pers ? pers.state : CodeMirror.startState(mode); |
||||
if (spec.persistent && !pers) |
||||
state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates}; |
||||
|
||||
state.localState = lState; |
||||
state.local = {mode: mode, |
||||
end: spec.end && toRegex(spec.end), |
||||
endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false), |
||||
endToken: token && token.join ? token[token.length - 1] : token}; |
||||
} |
||||
|
||||
function indexOf(val, arr) { |
||||
for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true; |
||||
} |
||||
|
||||
function indentFunction(states, meta) { |
||||
return function(state, textAfter, line) { |
||||
if (state.local && state.local.mode.indent) |
||||
return state.local.mode.indent(state.localState, textAfter, line); |
||||
if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1) |
||||
return CodeMirror.Pass; |
||||
|
||||
var pos = state.indent.length - 1, rules = states[state.state]; |
||||
scan: for (;;) { |
||||
for (var i = 0; i < rules.length; i++) { |
||||
var rule = rules[i]; |
||||
if (rule.data.dedent && rule.data.dedentIfLineStart !== false) { |
||||
var m = rule.regex.exec(textAfter); |
||||
if (m && m[0]) { |
||||
pos--; |
||||
if (rule.next || rule.push) rules = states[rule.next || rule.push]; |
||||
textAfter = textAfter.slice(m[0].length); |
||||
continue scan; |
||||
} |
||||
} |
||||
} |
||||
break; |
||||
} |
||||
return pos < 0 ? 0 : state.indent[pos]; |
||||
}; |
||||
} |
||||
}); |
||||
@ -0,0 +1,174 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("apl", function() { |
||||
var builtInOps = { |
||||
".": "innerProduct", |
||||
"\\": "scan", |
||||
"/": "reduce", |
||||
"⌿": "reduce1Axis", |
||||
"⍀": "scan1Axis", |
||||
"¨": "each", |
||||
"⍣": "power" |
||||
}; |
||||
var builtInFuncs = { |
||||
"+": ["conjugate", "add"], |
||||
"−": ["negate", "subtract"], |
||||
"×": ["signOf", "multiply"], |
||||
"÷": ["reciprocal", "divide"], |
||||
"⌈": ["ceiling", "greaterOf"], |
||||
"⌊": ["floor", "lesserOf"], |
||||
"∣": ["absolute", "residue"], |
||||
"⍳": ["indexGenerate", "indexOf"], |
||||
"?": ["roll", "deal"], |
||||
"⋆": ["exponentiate", "toThePowerOf"], |
||||
"⍟": ["naturalLog", "logToTheBase"], |
||||
"○": ["piTimes", "circularFuncs"], |
||||
"!": ["factorial", "binomial"], |
||||
"⌹": ["matrixInverse", "matrixDivide"], |
||||
"<": [null, "lessThan"], |
||||
"≤": [null, "lessThanOrEqual"], |
||||
"=": [null, "equals"], |
||||
">": [null, "greaterThan"], |
||||
"≥": [null, "greaterThanOrEqual"], |
||||
"≠": [null, "notEqual"], |
||||
"≡": ["depth", "match"], |
||||
"≢": [null, "notMatch"], |
||||
"∈": ["enlist", "membership"], |
||||
"⍷": [null, "find"], |
||||
"∪": ["unique", "union"], |
||||
"∩": [null, "intersection"], |
||||
"∼": ["not", "without"], |
||||
"∨": [null, "or"], |
||||
"∧": [null, "and"], |
||||
"⍱": [null, "nor"], |
||||
"⍲": [null, "nand"], |
||||
"⍴": ["shapeOf", "reshape"], |
||||
",": ["ravel", "catenate"], |
||||
"⍪": [null, "firstAxisCatenate"], |
||||
"⌽": ["reverse", "rotate"], |
||||
"⊖": ["axis1Reverse", "axis1Rotate"], |
||||
"⍉": ["transpose", null], |
||||
"↑": ["first", "take"], |
||||
"↓": [null, "drop"], |
||||
"⊂": ["enclose", "partitionWithAxis"], |
||||
"⊃": ["diclose", "pick"], |
||||
"⌷": [null, "index"], |
||||
"⍋": ["gradeUp", null], |
||||
"⍒": ["gradeDown", null], |
||||
"⊤": ["encode", null], |
||||
"⊥": ["decode", null], |
||||
"⍕": ["format", "formatByExample"], |
||||
"⍎": ["execute", null], |
||||
"⊣": ["stop", "left"], |
||||
"⊢": ["pass", "right"] |
||||
}; |
||||
|
||||
var isOperator = /[\.\/⌿⍀¨⍣]/; |
||||
var isNiladic = /⍬/; |
||||
var isFunction = /[\+−×÷⌈⌊∣⍳\?⋆⍟○!⌹<≤=>≥≠≡≢∈⍷∪∩∼∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢]/; |
||||
var isArrow = /←/; |
||||
var isComment = /[⍝#].*$/; |
||||
|
||||
var stringEater = function(type) { |
||||
var prev; |
||||
prev = false; |
||||
return function(c) { |
||||
prev = c; |
||||
if (c === type) { |
||||
return prev === "\\"; |
||||
} |
||||
return true; |
||||
}; |
||||
}; |
||||
return { |
||||
startState: function() { |
||||
return { |
||||
prev: false, |
||||
func: false, |
||||
op: false, |
||||
string: false, |
||||
escape: false |
||||
}; |
||||
}, |
||||
token: function(stream, state) { |
||||
var ch, funcName; |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
ch = stream.next(); |
||||
if (ch === '"' || ch === "'") { |
||||
stream.eatWhile(stringEater(ch)); |
||||
stream.next(); |
||||
state.prev = true; |
||||
return "string"; |
||||
} |
||||
if (/[\[{\(]/.test(ch)) { |
||||
state.prev = false; |
||||
return null; |
||||
} |
||||
if (/[\]}\)]/.test(ch)) { |
||||
state.prev = true; |
||||
return null; |
||||
} |
||||
if (isNiladic.test(ch)) { |
||||
state.prev = false; |
||||
return "niladic"; |
||||
} |
||||
if (/[¯\d]/.test(ch)) { |
||||
if (state.func) { |
||||
state.func = false; |
||||
state.prev = false; |
||||
} else { |
||||
state.prev = true; |
||||
} |
||||
stream.eatWhile(/[\w\.]/); |
||||
return "number"; |
||||
} |
||||
if (isOperator.test(ch)) { |
||||
return "operator apl-" + builtInOps[ch]; |
||||
} |
||||
if (isArrow.test(ch)) { |
||||
return "apl-arrow"; |
||||
} |
||||
if (isFunction.test(ch)) { |
||||
funcName = "apl-"; |
||||
if (builtInFuncs[ch] != null) { |
||||
if (state.prev) { |
||||
funcName += builtInFuncs[ch][1]; |
||||
} else { |
||||
funcName += builtInFuncs[ch][0]; |
||||
} |
||||
} |
||||
state.func = true; |
||||
state.prev = false; |
||||
return "function " + funcName; |
||||
} |
||||
if (isComment.test(ch)) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
if (ch === "∘" && stream.peek() === ".") { |
||||
stream.next(); |
||||
return "function jot-dot"; |
||||
} |
||||
stream.eatWhile(/[\w\$_]/); |
||||
state.prev = true; |
||||
return "keyword"; |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/apl", "apl"); |
||||
|
||||
}); |
||||
@ -0,0 +1,72 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: APL mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="./apl.js"></script> |
||||
<style> |
||||
.CodeMirror { border: 2px inset #dee; } |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">APL</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>APL mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
⍝ Conway's game of life |
||||
|
||||
⍝ This example was inspired by the impressive demo at |
||||
⍝ http://www.youtube.com/watch?v=a9xAKttWgP4 |
||||
|
||||
⍝ Create a matrix: |
||||
⍝ 0 1 1 |
||||
⍝ 1 1 0 |
||||
⍝ 0 1 0 |
||||
creature ← (3 3 ⍴ ⍳ 9) ∈ 1 2 3 4 7 ⍝ Original creature from demo |
||||
creature ← (3 3 ⍴ ⍳ 9) ∈ 1 3 6 7 8 ⍝ Glider |
||||
|
||||
⍝ Place the creature on a larger board, near the centre |
||||
board ← ¯1 ⊖ ¯2 ⌽ 5 7 ↑ creature |
||||
|
||||
⍝ A function to move from one generation to the next |
||||
life ← {∨/ 1 ⍵ ∧ 3 4 = ⊂+/ +⌿ 1 0 ¯1 ∘.⊖ 1 0 ¯1 ⌽¨ ⊂⍵} |
||||
|
||||
⍝ Compute n-th generation and format it as a |
||||
⍝ character matrix |
||||
gen ← {' #'[(life ⍣ ⍵) board]} |
||||
|
||||
⍝ Show first three generations |
||||
(gen 1) (gen 2) (gen 3) |
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/apl" |
||||
}); |
||||
</script> |
||||
|
||||
<p>Simple mode that tries to handle APL as well as it can.</p> |
||||
<p>It attempts to label functions/operators based upon |
||||
monadic/dyadic usage (but this is far from fully fleshed out). |
||||
This means there are meaningful classnames so hover states can |
||||
have popups etc.</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/apl</code> (APL code)</p> |
||||
</article> |
||||
@ -0,0 +1,73 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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"; |
||||
|
||||
function errorIfNotEmpty(stream) { |
||||
var nonWS = stream.match(/^\s*\S/); |
||||
stream.skipToEnd(); |
||||
return nonWS ? "error" : null; |
||||
} |
||||
|
||||
CodeMirror.defineMode("asciiarmor", function() { |
||||
return { |
||||
token: function(stream, state) { |
||||
var m; |
||||
if (state.state == "top") { |
||||
if (stream.sol() && (m = stream.match(/^-----BEGIN (.*)?-----\s*$/))) { |
||||
state.state = "headers"; |
||||
state.type = m[1]; |
||||
return "tag"; |
||||
} |
||||
return errorIfNotEmpty(stream); |
||||
} else if (state.state == "headers") { |
||||
if (stream.sol() && stream.match(/^\w+:/)) { |
||||
state.state = "header"; |
||||
return "atom"; |
||||
} else { |
||||
var result = errorIfNotEmpty(stream); |
||||
if (result) state.state = "body"; |
||||
return result; |
||||
} |
||||
} else if (state.state == "header") { |
||||
stream.skipToEnd(); |
||||
state.state = "headers"; |
||||
return "string"; |
||||
} else if (state.state == "body") { |
||||
if (stream.sol() && (m = stream.match(/^-----END (.*)?-----\s*$/))) { |
||||
if (m[1] != state.type) return "error"; |
||||
state.state = "end"; |
||||
return "tag"; |
||||
} else { |
||||
if (stream.eatWhile(/[A-Za-z0-9+\/=]/)) { |
||||
return null; |
||||
} else { |
||||
stream.next(); |
||||
return "error"; |
||||
} |
||||
} |
||||
} else if (state.state == "end") { |
||||
return errorIfNotEmpty(stream); |
||||
} |
||||
}, |
||||
blankLine: function(state) { |
||||
if (state.state == "headers") state.state = "body"; |
||||
}, |
||||
startState: function() { |
||||
return {state: "top", type: null}; |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("application/pgp", "asciiarmor"); |
||||
CodeMirror.defineMIME("application/pgp-keys", "asciiarmor"); |
||||
CodeMirror.defineMIME("application/pgp-signature", "asciiarmor"); |
||||
}); |
||||
@ -0,0 +1,46 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: ASCII Armor (PGP) mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="asciiarmor.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">ASCII Armor</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>ASCII Armor (PGP) mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
-----BEGIN PGP MESSAGE----- |
||||
Version: OpenPrivacy 0.99 |
||||
|
||||
yDgBO22WxBHv7O8X7O/jygAEzol56iUKiXmV+XmpCtmpqQUKiQrFqclFqUDBovzS |
||||
vBSFjNSiVHsuAA== |
||||
=njUN |
||||
-----END PGP MESSAGE----- |
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true |
||||
}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types |
||||
defined:</strong> <code>application/pgp</code>, <code>application/pgp-keys</code>, <code>application/pgp-signature</code></p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,204 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("asn.1", function(config, parserConfig) { |
||||
var indentUnit = config.indentUnit, |
||||
keywords = parserConfig.keywords || {}, |
||||
cmipVerbs = parserConfig.cmipVerbs || {}, |
||||
compareTypes = parserConfig.compareTypes || {}, |
||||
status = parserConfig.status || {}, |
||||
tags = parserConfig.tags || {}, |
||||
storage = parserConfig.storage || {}, |
||||
modifier = parserConfig.modifier || {}, |
||||
accessTypes = parserConfig.accessTypes|| {}, |
||||
multiLineStrings = parserConfig.multiLineStrings, |
||||
indentStatements = parserConfig.indentStatements !== false; |
||||
var isOperatorChar = /[\|\^]/; |
||||
var curPunc; |
||||
|
||||
function tokenBase(stream, state) { |
||||
var ch = stream.next(); |
||||
if (ch == '"' || ch == "'") { |
||||
state.tokenize = tokenString(ch); |
||||
return state.tokenize(stream, state); |
||||
} |
||||
if (/[\[\]\(\){}:=,;]/.test(ch)) { |
||||
curPunc = ch; |
||||
return "punctuation"; |
||||
} |
||||
if (ch == "-"){ |
||||
if (stream.eat("-")) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
} |
||||
if (/\d/.test(ch)) { |
||||
stream.eatWhile(/[\w\.]/); |
||||
return "number"; |
||||
} |
||||
if (isOperatorChar.test(ch)) { |
||||
stream.eatWhile(isOperatorChar); |
||||
return "operator"; |
||||
} |
||||
|
||||
stream.eatWhile(/[\w\-]/); |
||||
var cur = stream.current(); |
||||
if (keywords.propertyIsEnumerable(cur)) return "keyword"; |
||||
if (cmipVerbs.propertyIsEnumerable(cur)) return "variable cmipVerbs"; |
||||
if (compareTypes.propertyIsEnumerable(cur)) return "atom compareTypes"; |
||||
if (status.propertyIsEnumerable(cur)) return "comment status"; |
||||
if (tags.propertyIsEnumerable(cur)) return "variable-3 tags"; |
||||
if (storage.propertyIsEnumerable(cur)) return "builtin storage"; |
||||
if (modifier.propertyIsEnumerable(cur)) return "string-2 modifier"; |
||||
if (accessTypes.propertyIsEnumerable(cur)) return "atom accessTypes"; |
||||
|
||||
return "variable"; |
||||
} |
||||
|
||||
function tokenString(quote) { |
||||
return function(stream, state) { |
||||
var escaped = false, next, end = false; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == quote && !escaped){ |
||||
var afterNext = stream.peek(); |
||||
//look if the character if the quote is like the B in '10100010'B
|
||||
if (afterNext){ |
||||
afterNext = afterNext.toLowerCase(); |
||||
if(afterNext == "b" || afterNext == "h" || afterNext == "o") |
||||
stream.next(); |
||||
} |
||||
end = true; break; |
||||
} |
||||
escaped = !escaped && next == "\\"; |
||||
} |
||||
if (end || !(escaped || multiLineStrings)) |
||||
state.tokenize = null; |
||||
return "string"; |
||||
}; |
||||
} |
||||
|
||||
function Context(indented, column, type, align, prev) { |
||||
this.indented = indented; |
||||
this.column = column; |
||||
this.type = type; |
||||
this.align = align; |
||||
this.prev = prev; |
||||
} |
||||
function pushContext(state, col, type) { |
||||
var indent = state.indented; |
||||
if (state.context && state.context.type == "statement") |
||||
indent = state.context.indented; |
||||
return state.context = new Context(indent, col, type, null, state.context); |
||||
} |
||||
function popContext(state) { |
||||
var t = state.context.type; |
||||
if (t == ")" || t == "]" || t == "}") |
||||
state.indented = state.context.indented; |
||||
return state.context = state.context.prev; |
||||
} |
||||
|
||||
//Interface
|
||||
return { |
||||
startState: function(basecolumn) { |
||||
return { |
||||
tokenize: null, |
||||
context: new Context((basecolumn || 0) - indentUnit, 0, "top", false), |
||||
indented: 0, |
||||
startOfLine: true |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
var ctx = state.context; |
||||
if (stream.sol()) { |
||||
if (ctx.align == null) ctx.align = false; |
||||
state.indented = stream.indentation(); |
||||
state.startOfLine = true; |
||||
} |
||||
if (stream.eatSpace()) return null; |
||||
curPunc = null; |
||||
var style = (state.tokenize || tokenBase)(stream, state); |
||||
if (style == "comment") return style; |
||||
if (ctx.align == null) ctx.align = true; |
||||
|
||||
if ((curPunc == ";" || curPunc == ":" || curPunc == ",") |
||||
&& ctx.type == "statement"){ |
||||
popContext(state); |
||||
} |
||||
else if (curPunc == "{") pushContext(state, stream.column(), "}"); |
||||
else if (curPunc == "[") pushContext(state, stream.column(), "]"); |
||||
else if (curPunc == "(") pushContext(state, stream.column(), ")"); |
||||
else if (curPunc == "}") { |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
if (ctx.type == "}") ctx = popContext(state); |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
} |
||||
else if (curPunc == ctx.type) popContext(state); |
||||
else if (indentStatements && (((ctx.type == "}" || ctx.type == "top") |
||||
&& curPunc != ';') || (ctx.type == "statement" |
||||
&& curPunc == "newstatement"))) |
||||
pushContext(state, stream.column(), "statement"); |
||||
|
||||
state.startOfLine = false; |
||||
return style; |
||||
}, |
||||
|
||||
electricChars: "{}", |
||||
lineComment: "--", |
||||
fold: "brace" |
||||
}; |
||||
}); |
||||
|
||||
function words(str) { |
||||
var obj = {}, words = str.split(" "); |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
|
||||
CodeMirror.defineMIME("text/x-ttcn-asn", { |
||||
name: "asn.1", |
||||
keywords: words("DEFINITIONS OBJECTS IF DERIVED INFORMATION ACTION" + |
||||
" REPLY ANY NAMED CHARACTERIZED BEHAVIOUR REGISTERED" + |
||||
" WITH AS IDENTIFIED CONSTRAINED BY PRESENT BEGIN" + |
||||
" IMPORTS FROM UNITS SYNTAX MIN-ACCESS MAX-ACCESS" + |
||||
" MINACCESS MAXACCESS REVISION STATUS DESCRIPTION" + |
||||
" SEQUENCE SET COMPONENTS OF CHOICE DistinguishedName" + |
||||
" ENUMERATED SIZE MODULE END INDEX AUGMENTS EXTENSIBILITY" + |
||||
" IMPLIED EXPORTS"), |
||||
cmipVerbs: words("ACTIONS ADD GET NOTIFICATIONS REPLACE REMOVE"), |
||||
compareTypes: words("OPTIONAL DEFAULT MANAGED MODULE-TYPE MODULE_IDENTITY" + |
||||
" MODULE-COMPLIANCE OBJECT-TYPE OBJECT-IDENTITY" + |
||||
" OBJECT-COMPLIANCE MODE CONFIRMED CONDITIONAL" + |
||||
" SUBORDINATE SUPERIOR CLASS TRUE FALSE NULL" + |
||||
" TEXTUAL-CONVENTION"), |
||||
status: words("current deprecated mandatory obsolete"), |
||||
tags: words("APPLICATION AUTOMATIC EXPLICIT IMPLICIT PRIVATE TAGS" + |
||||
" UNIVERSAL"), |
||||
storage: words("BOOLEAN INTEGER OBJECT IDENTIFIER BIT OCTET STRING" + |
||||
" UTCTime InterfaceIndex IANAifType CMIP-Attribute" + |
||||
" REAL PACKAGE PACKAGES IpAddress PhysAddress" + |
||||
" NetworkAddress BITS BMPString TimeStamp TimeTicks" + |
||||
" TruthValue RowStatus DisplayString GeneralString" + |
||||
" GraphicString IA5String NumericString" + |
||||
" PrintableString SnmpAdminAtring TeletexString" + |
||||
" UTF8String VideotexString VisibleString StringStore" + |
||||
" ISO646String T61String UniversalString Unsigned32" + |
||||
" Integer32 Gauge Gauge32 Counter Counter32 Counter64"), |
||||
modifier: words("ATTRIBUTE ATTRIBUTES MANDATORY-GROUP MANDATORY-GROUPS" + |
||||
" GROUP GROUPS ELEMENTS EQUALITY ORDERING SUBSTRINGS" + |
||||
" DEFINED"), |
||||
accessTypes: words("not-accessible accessible-for-notify read-only" + |
||||
" read-create read-write"), |
||||
multiLineStrings: true |
||||
}); |
||||
}); |
||||
@ -0,0 +1,77 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: ASN.1 mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="asn.1.js"></script> |
||||
<style type="text/css"> |
||||
.CodeMirror { |
||||
border-top: 1px solid black; |
||||
border-bottom: 1px solid black; |
||||
} |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1> |
||||
<img id=logo src="../../doc/logo.png"> |
||||
</a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="http://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One">ASN.1</a> |
||||
</ul> |
||||
</div> |
||||
<article> |
||||
<h2>ASN.1 example</h2> |
||||
<div> |
||||
<textarea id="ttcn-asn-code"> |
||||
-- |
||||
-- Sample ASN.1 Code |
||||
-- |
||||
MyModule DEFINITIONS ::= |
||||
BEGIN |
||||
|
||||
MyTypes ::= SEQUENCE { |
||||
myObjectId OBJECT IDENTIFIER, |
||||
mySeqOf SEQUENCE OF MyInt, |
||||
myBitString BIT STRING { |
||||
muxToken(0), |
||||
modemToken(1) |
||||
} |
||||
} |
||||
|
||||
MyInt ::= INTEGER (0..65535) |
||||
|
||||
END |
||||
</textarea> |
||||
</div> |
||||
|
||||
<script> |
||||
var ttcnEditor = CodeMirror.fromTextArea(document.getElementById("ttcn-asn-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-ttcn-asn" |
||||
}); |
||||
ttcnEditor.setSize(400, 400); |
||||
var mac = CodeMirror.keyMap.default == CodeMirror.keyMap.macDefault; |
||||
CodeMirror.keyMap.default[(mac ? "Cmd" : "Ctrl") + "-Space"] = "autocomplete"; |
||||
</script> |
||||
<br/> |
||||
<p><strong>Language:</strong> Abstract Syntax Notation One |
||||
(<a href="http://www.itu.int/en/ITU-T/asn1/Pages/introduction.aspx">ASN.1</a>) |
||||
</p> |
||||
<p><strong>MIME types defined:</strong> <code>text/x-ttcn-asn</code></p> |
||||
|
||||
<br/> |
||||
<p>The development of this mode has been sponsored by <a href="http://www.ericsson.com/">Ericsson |
||||
</a>.</p> |
||||
<p>Coded by Asmelash Tsegay Gebretsadkan </p> |
||||
</article> |
||||
|
||||
@ -0,0 +1,196 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
/* |
||||
* ===================================================================================== |
||||
* |
||||
* Filename: mode/asterisk/asterisk.js |
||||
* |
||||
* Description: CodeMirror mode for Asterisk dialplan |
||||
* |
||||
* Created: 05/17/2012 09:20:25 PM |
||||
* Revision: none |
||||
* |
||||
* Author: Stas Kobzar (stas@modulis.ca), |
||||
* Company: Modulis.ca Inc. |
||||
* |
||||
* ===================================================================================== |
||||
*/ |
||||
|
||||
(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.defineMode("asterisk", function() { |
||||
var atoms = ["exten", "same", "include","ignorepat","switch"], |
||||
dpcmd = ["#include","#exec"], |
||||
apps = [ |
||||
"addqueuemember","adsiprog","aelsub","agentlogin","agentmonitoroutgoing","agi", |
||||
"alarmreceiver","amd","answer","authenticate","background","backgrounddetect", |
||||
"bridge","busy","callcompletioncancel","callcompletionrequest","celgenuserevent", |
||||
"changemonitor","chanisavail","channelredirect","chanspy","clearhash","confbridge", |
||||
"congestion","continuewhile","controlplayback","dahdiacceptr2call","dahdibarge", |
||||
"dahdiras","dahdiscan","dahdisendcallreroutingfacility","dahdisendkeypadfacility", |
||||
"datetime","dbdel","dbdeltree","deadagi","dial","dictate","directory","disa", |
||||
"dumpchan","eagi","echo","endwhile","exec","execif","execiftime","exitwhile","extenspy", |
||||
"externalivr","festival","flash","followme","forkcdr","getcpeid","gosub","gosubif", |
||||
"goto","gotoif","gotoiftime","hangup","iax2provision","ices","importvar","incomplete", |
||||
"ivrdemo","jabberjoin","jabberleave","jabbersend","jabbersendgroup","jabberstatus", |
||||
"jack","log","macro","macroexclusive","macroexit","macroif","mailboxexists","meetme", |
||||
"meetmeadmin","meetmechanneladmin","meetmecount","milliwatt","minivmaccmess","minivmdelete", |
||||
"minivmgreet","minivmmwi","minivmnotify","minivmrecord","mixmonitor","monitor","morsecode", |
||||
"mp3player","mset","musiconhold","nbscat","nocdr","noop","odbc","odbc","odbcfinish", |
||||
"originate","ospauth","ospfinish","osplookup","ospnext","page","park","parkandannounce", |
||||
"parkedcall","pausemonitor","pausequeuemember","pickup","pickupchan","playback","playtones", |
||||
"privacymanager","proceeding","progress","queue","queuelog","raiseexception","read","readexten", |
||||
"readfile","receivefax","receivefax","receivefax","record","removequeuemember", |
||||
"resetcdr","retrydial","return","ringing","sayalpha","saycountedadj","saycountednoun", |
||||
"saycountpl","saydigits","saynumber","sayphonetic","sayunixtime","senddtmf","sendfax", |
||||
"sendfax","sendfax","sendimage","sendtext","sendurl","set","setamaflags", |
||||
"setcallerpres","setmusiconhold","sipaddheader","sipdtmfmode","sipremoveheader","skel", |
||||
"slastation","slatrunk","sms","softhangup","speechactivategrammar","speechbackground", |
||||
"speechcreate","speechdeactivategrammar","speechdestroy","speechloadgrammar","speechprocessingsound", |
||||
"speechstart","speechunloadgrammar","stackpop","startmusiconhold","stopmixmonitor","stopmonitor", |
||||
"stopmusiconhold","stopplaytones","system","testclient","testserver","transfer","tryexec", |
||||
"trysystem","unpausemonitor","unpausequeuemember","userevent","verbose","vmauthenticate", |
||||
"vmsayname","voicemail","voicemailmain","wait","waitexten","waitfornoise","waitforring", |
||||
"waitforsilence","waitmusiconhold","waituntil","while","zapateller" |
||||
]; |
||||
|
||||
function basicToken(stream,state){ |
||||
var cur = ''; |
||||
var ch = stream.next(); |
||||
// comment
|
||||
if(ch == ";") { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
// context
|
||||
if(ch == '[') { |
||||
stream.skipTo(']'); |
||||
stream.eat(']'); |
||||
return "header"; |
||||
} |
||||
// string
|
||||
if(ch == '"') { |
||||
stream.skipTo('"'); |
||||
return "string"; |
||||
} |
||||
if(ch == "'") { |
||||
stream.skipTo("'"); |
||||
return "string-2"; |
||||
} |
||||
// dialplan commands
|
||||
if(ch == '#') { |
||||
stream.eatWhile(/\w/); |
||||
cur = stream.current(); |
||||
if(dpcmd.indexOf(cur) !== -1) { |
||||
stream.skipToEnd(); |
||||
return "strong"; |
||||
} |
||||
} |
||||
// application args
|
||||
if(ch == '$'){ |
||||
var ch1 = stream.peek(); |
||||
if(ch1 == '{'){ |
||||
stream.skipTo('}'); |
||||
stream.eat('}'); |
||||
return "variable-3"; |
||||
} |
||||
} |
||||
// extension
|
||||
stream.eatWhile(/\w/); |
||||
cur = stream.current(); |
||||
if(atoms.indexOf(cur) !== -1) { |
||||
state.extenStart = true; |
||||
switch(cur) { |
||||
case 'same': state.extenSame = true; break; |
||||
case 'include': |
||||
case 'switch': |
||||
case 'ignorepat': |
||||
state.extenInclude = true;break; |
||||
default:break; |
||||
} |
||||
return "atom"; |
||||
} |
||||
} |
||||
|
||||
return { |
||||
startState: function() { |
||||
return { |
||||
extenStart: false, |
||||
extenSame: false, |
||||
extenInclude: false, |
||||
extenExten: false, |
||||
extenPriority: false, |
||||
extenApplication: false |
||||
}; |
||||
}, |
||||
token: function(stream, state) { |
||||
|
||||
var cur = ''; |
||||
if(stream.eatSpace()) return null; |
||||
// extension started
|
||||
if(state.extenStart){ |
||||
stream.eatWhile(/[^\s]/); |
||||
cur = stream.current(); |
||||
if(/^=>?$/.test(cur)){ |
||||
state.extenExten = true; |
||||
state.extenStart = false; |
||||
return "strong"; |
||||
} else { |
||||
state.extenStart = false; |
||||
stream.skipToEnd(); |
||||
return "error"; |
||||
} |
||||
} else if(state.extenExten) { |
||||
// set exten and priority
|
||||
state.extenExten = false; |
||||
state.extenPriority = true; |
||||
stream.eatWhile(/[^,]/); |
||||
if(state.extenInclude) { |
||||
stream.skipToEnd(); |
||||
state.extenPriority = false; |
||||
state.extenInclude = false; |
||||
} |
||||
if(state.extenSame) { |
||||
state.extenPriority = false; |
||||
state.extenSame = false; |
||||
state.extenApplication = true; |
||||
} |
||||
return "tag"; |
||||
} else if(state.extenPriority) { |
||||
state.extenPriority = false; |
||||
state.extenApplication = true; |
||||
stream.next(); // get comma
|
||||
if(state.extenSame) return null; |
||||
stream.eatWhile(/[^,]/); |
||||
return "number"; |
||||
} else if(state.extenApplication) { |
||||
stream.eatWhile(/,/); |
||||
cur = stream.current(); |
||||
if(cur === ',') return null; |
||||
stream.eatWhile(/\w/); |
||||
cur = stream.current().toLowerCase(); |
||||
state.extenApplication = false; |
||||
if(apps.indexOf(cur) !== -1){ |
||||
return "def strong"; |
||||
} |
||||
} else{ |
||||
return basicToken(stream,state); |
||||
} |
||||
|
||||
return null; |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-asterisk", "asterisk"); |
||||
|
||||
}); |
||||
@ -0,0 +1,154 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Asterisk dialplan mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="asterisk.js"></script> |
||||
<style> |
||||
.CodeMirror {border: 1px solid #999;} |
||||
.cm-s-default span.cm-arrow { color: red; } |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Asterisk dialplan</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Asterisk dialplan mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
; extensions.conf - the Asterisk dial plan |
||||
; |
||||
|
||||
[general] |
||||
; |
||||
; If static is set to no, or omitted, then the pbx_config will rewrite |
||||
; this file when extensions are modified. Remember that all comments |
||||
; made in the file will be lost when that happens. |
||||
static=yes |
||||
|
||||
#include "/etc/asterisk/additional_general.conf |
||||
|
||||
[iaxprovider] |
||||
switch => IAX2/user:[key]@myserver/mycontext |
||||
|
||||
[dynamic] |
||||
#exec /usr/bin/dynamic-peers.pl |
||||
|
||||
[trunkint] |
||||
; |
||||
; International long distance through trunk |
||||
; |
||||
exten => _9011.,1,Macro(dundi-e164,${EXTEN:4}) |
||||
exten => _9011.,n,Dial(${GLOBAL(TRUNK)}/${FILTER(0-9,${EXTEN:${GLOBAL(TRUNKMSD)}})}) |
||||
|
||||
[local] |
||||
; |
||||
; Master context for local, toll-free, and iaxtel calls only |
||||
; |
||||
ignorepat => 9 |
||||
include => default |
||||
|
||||
[demo] |
||||
include => stdexten |
||||
; |
||||
; We start with what to do when a call first comes in. |
||||
; |
||||
exten => s,1,Wait(1) ; Wait a second, just for fun |
||||
same => n,Answer ; Answer the line |
||||
same => n,Set(TIMEOUT(digit)=5) ; Set Digit Timeout to 5 seconds |
||||
same => n,Set(TIMEOUT(response)=10) ; Set Response Timeout to 10 seconds |
||||
same => n(restart),BackGround(demo-congrats) ; Play a congratulatory message |
||||
same => n(instruct),BackGround(demo-instruct) ; Play some instructions |
||||
same => n,WaitExten ; Wait for an extension to be dialed. |
||||
|
||||
exten => 2,1,BackGround(demo-moreinfo) ; Give some more information. |
||||
exten => 2,n,Goto(s,instruct) |
||||
|
||||
exten => 3,1,Set(LANGUAGE()=fr) ; Set language to french |
||||
exten => 3,n,Goto(s,restart) ; Start with the congratulations |
||||
|
||||
exten => 1000,1,Goto(default,s,1) |
||||
; |
||||
; We also create an example user, 1234, who is on the console and has |
||||
; voicemail, etc. |
||||
; |
||||
exten => 1234,1,Playback(transfer,skip) ; "Please hold while..." |
||||
; (but skip if channel is not up) |
||||
exten => 1234,n,Gosub(${EXTEN},stdexten(${GLOBAL(CONSOLE)})) |
||||
exten => 1234,n,Goto(default,s,1) ; exited Voicemail |
||||
|
||||
exten => 1235,1,Voicemail(1234,u) ; Right to voicemail |
||||
|
||||
exten => 1236,1,Dial(Console/dsp) ; Ring forever |
||||
exten => 1236,n,Voicemail(1234,b) ; Unless busy |
||||
|
||||
; |
||||
; # for when they're done with the demo |
||||
; |
||||
exten => #,1,Playback(demo-thanks) ; "Thanks for trying the demo" |
||||
exten => #,n,Hangup ; Hang them up. |
||||
|
||||
; |
||||
; A timeout and "invalid extension rule" |
||||
; |
||||
exten => t,1,Goto(#,1) ; If they take too long, give up |
||||
exten => i,1,Playback(invalid) ; "That's not valid, try again" |
||||
|
||||
; |
||||
; Create an extension, 500, for dialing the |
||||
; Asterisk demo. |
||||
; |
||||
exten => 500,1,Playback(demo-abouttotry); Let them know what's going on |
||||
exten => 500,n,Dial(IAX2/guest@pbx.digium.com/s@default) ; Call the Asterisk demo |
||||
exten => 500,n,Playback(demo-nogo) ; Couldn't connect to the demo site |
||||
exten => 500,n,Goto(s,6) ; Return to the start over message. |
||||
|
||||
; |
||||
; Create an extension, 600, for evaluating echo latency. |
||||
; |
||||
exten => 600,1,Playback(demo-echotest) ; Let them know what's going on |
||||
exten => 600,n,Echo ; Do the echo test |
||||
exten => 600,n,Playback(demo-echodone) ; Let them know it's over |
||||
exten => 600,n,Goto(s,6) ; Start over |
||||
|
||||
; |
||||
; You can use the Macro Page to intercom a individual user |
||||
exten => 76245,1,Macro(page,SIP/Grandstream1) |
||||
; or if your peernames are the same as extensions |
||||
exten => _7XXX,1,Macro(page,SIP/${EXTEN}) |
||||
; |
||||
; |
||||
; System Wide Page at extension 7999 |
||||
; |
||||
exten => 7999,1,Set(TIMEOUT(absolute)=60) |
||||
exten => 7999,2,Page(Local/Grandstream1@page&Local/Xlite1@page&Local/1234@page/n,d) |
||||
|
||||
; Give voicemail at extension 8500 |
||||
; |
||||
exten => 8500,1,VoicemailMain |
||||
exten => 8500,n,Goto(s,6) |
||||
|
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
mode: "text/x-asterisk", |
||||
matchBrackets: true, |
||||
lineNumber: true |
||||
}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-asterisk</code>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,85 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
// Brainfuck mode created by Michael Kaminsky https://github.com/mkaminsky11
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") |
||||
mod(require("../../lib/codemirror")) |
||||
else if (typeof define == "function" && define.amd) |
||||
define(["../../lib/codemirror"], mod) |
||||
else |
||||
mod(CodeMirror) |
||||
})(function(CodeMirror) { |
||||
"use strict" |
||||
var reserve = "><+-.,[]".split(""); |
||||
/* |
||||
comments can be either: |
||||
placed behind lines |
||||
|
||||
+++ this is a comment |
||||
|
||||
where reserved characters cannot be used |
||||
or in a loop |
||||
[ |
||||
this is ok to use [ ] and stuff |
||||
] |
||||
or preceded by # |
||||
*/ |
||||
CodeMirror.defineMode("brainfuck", function() { |
||||
return { |
||||
startState: function() { |
||||
return { |
||||
commentLine: false, |
||||
left: 0, |
||||
right: 0, |
||||
commentLoop: false |
||||
} |
||||
}, |
||||
token: function(stream, state) { |
||||
if (stream.eatSpace()) return null |
||||
if(stream.sol()){ |
||||
state.commentLine = false; |
||||
} |
||||
var ch = stream.next().toString(); |
||||
if(reserve.indexOf(ch) !== -1){ |
||||
if(state.commentLine === true){ |
||||
if(stream.eol()){ |
||||
state.commentLine = false; |
||||
} |
||||
return "comment"; |
||||
} |
||||
if(ch === "]" || ch === "["){ |
||||
if(ch === "["){ |
||||
state.left++; |
||||
} |
||||
else{ |
||||
state.right++; |
||||
} |
||||
return "bracket"; |
||||
} |
||||
else if(ch === "+" || ch === "-"){ |
||||
return "keyword"; |
||||
} |
||||
else if(ch === "<" || ch === ">"){ |
||||
return "atom"; |
||||
} |
||||
else if(ch === "." || ch === ","){ |
||||
return "def"; |
||||
} |
||||
} |
||||
else{ |
||||
state.commentLine = true; |
||||
if(stream.eol()){ |
||||
state.commentLine = false; |
||||
} |
||||
return "comment"; |
||||
} |
||||
if(stream.eol()){ |
||||
state.commentLine = false; |
||||
} |
||||
} |
||||
}; |
||||
}); |
||||
CodeMirror.defineMIME("text/x-brainfuck","brainfuck") |
||||
}); |
||||
@ -0,0 +1,85 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Brainfuck mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="./brainfuck.js"></script> |
||||
<style> |
||||
.CodeMirror { border: 2px inset #dee; } |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#"></a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Brainfuck mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
[ This program prints "Hello World!" and a newline to the screen, its |
||||
length is 106 active command characters [it is not the shortest.] |
||||
|
||||
This loop is a "comment loop", it's a simple way of adding a comment |
||||
to a BF program such that you don't have to worry about any command |
||||
characters. Any ".", ",", "+", "-", "<" and ">" characters are simply |
||||
ignored, the "[" and "]" characters just have to be balanced. |
||||
] |
||||
+++++ +++ Set Cell #0 to 8 |
||||
[ |
||||
>++++ Add 4 to Cell #1; this will always set Cell #1 to 4 |
||||
[ as the cell will be cleared by the loop |
||||
>++ Add 2 to Cell #2 |
||||
>+++ Add 3 to Cell #3 |
||||
>+++ Add 3 to Cell #4 |
||||
>+ Add 1 to Cell #5 |
||||
<<<<- Decrement the loop counter in Cell #1 |
||||
] Loop till Cell #1 is zero; number of iterations is 4 |
||||
>+ Add 1 to Cell #2 |
||||
>+ Add 1 to Cell #3 |
||||
>- Subtract 1 from Cell #4 |
||||
>>+ Add 1 to Cell #6 |
||||
[<] Move back to the first zero cell you find; this will |
||||
be Cell #1 which was cleared by the previous loop |
||||
<- Decrement the loop Counter in Cell #0 |
||||
] Loop till Cell #0 is zero; number of iterations is 8 |
||||
|
||||
The result of this is: |
||||
Cell No : 0 1 2 3 4 5 6 |
||||
Contents: 0 0 72 104 88 32 8 |
||||
Pointer : ^ |
||||
|
||||
>>. Cell #2 has value 72 which is 'H' |
||||
>---. Subtract 3 from Cell #3 to get 101 which is 'e' |
||||
+++++++..+++. Likewise for 'llo' from Cell #3 |
||||
>>. Cell #5 is 32 for the space |
||||
<-. Subtract 1 from Cell #4 for 87 to give a 'W' |
||||
<. Cell #3 was set to 'o' from the end of 'Hello' |
||||
+++.------.--------. Cell #3 for 'rl' and 'd' |
||||
>>+. Add 1 to Cell #5 gives us an exclamation point |
||||
>++. And finally a newline from Cell #6 |
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-brainfuck" |
||||
}); |
||||
</script> |
||||
|
||||
<p>A mode for Brainfuck</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-brainfuck</code></p> |
||||
</article> |
||||
@ -0,0 +1,786 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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"; |
||||
|
||||
function Context(indented, column, type, info, align, prev) { |
||||
this.indented = indented; |
||||
this.column = column; |
||||
this.type = type; |
||||
this.info = info; |
||||
this.align = align; |
||||
this.prev = prev; |
||||
} |
||||
function pushContext(state, col, type, info) { |
||||
var indent = state.indented; |
||||
if (state.context && state.context.type != "statement" && type != "statement") |
||||
indent = state.context.indented; |
||||
return state.context = new Context(indent, col, type, info, null, state.context); |
||||
} |
||||
function popContext(state) { |
||||
var t = state.context.type; |
||||
if (t == ")" || t == "]" || t == "}") |
||||
state.indented = state.context.indented; |
||||
return state.context = state.context.prev; |
||||
} |
||||
|
||||
function typeBefore(stream, state, pos) { |
||||
if (state.prevToken == "variable" || state.prevToken == "variable-3") return true; |
||||
if (/\S(?:[^- ]>|[*\]])\s*$|\*$/.test(stream.string.slice(0, pos))) return true; |
||||
if (state.typeAtEndOfLine && stream.column() == stream.indentation()) return true; |
||||
} |
||||
|
||||
function isTopScope(context) { |
||||
for (;;) { |
||||
if (!context || context.type == "top") return true; |
||||
if (context.type == "}" && context.prev.info != "namespace") return false; |
||||
context = context.prev; |
||||
} |
||||
} |
||||
|
||||
CodeMirror.defineMode("clike", function(config, parserConfig) { |
||||
var indentUnit = config.indentUnit, |
||||
statementIndentUnit = parserConfig.statementIndentUnit || indentUnit, |
||||
dontAlignCalls = parserConfig.dontAlignCalls, |
||||
keywords = parserConfig.keywords || {}, |
||||
types = parserConfig.types || {}, |
||||
builtin = parserConfig.builtin || {}, |
||||
blockKeywords = parserConfig.blockKeywords || {}, |
||||
defKeywords = parserConfig.defKeywords || {}, |
||||
atoms = parserConfig.atoms || {}, |
||||
hooks = parserConfig.hooks || {}, |
||||
multiLineStrings = parserConfig.multiLineStrings, |
||||
indentStatements = parserConfig.indentStatements !== false, |
||||
indentSwitch = parserConfig.indentSwitch !== false, |
||||
namespaceSeparator = parserConfig.namespaceSeparator, |
||||
isPunctuationChar = parserConfig.isPunctuationChar || /[\[\]{}\(\),;\:\.]/, |
||||
numberStart = parserConfig.numberStart || /[\d\.]/, |
||||
number = parserConfig.number || /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i, |
||||
isOperatorChar = parserConfig.isOperatorChar || /[+\-*&%=<>!?|\/]/, |
||||
endStatement = parserConfig.endStatement || /^[;:,]$/; |
||||
|
||||
var curPunc, isDefKeyword; |
||||
|
||||
function tokenBase(stream, state) { |
||||
var ch = stream.next(); |
||||
if (hooks[ch]) { |
||||
var result = hooks[ch](stream, state); |
||||
if (result !== false) return result; |
||||
} |
||||
if (ch == '"' || ch == "'") { |
||||
state.tokenize = tokenString(ch); |
||||
return state.tokenize(stream, state); |
||||
} |
||||
if (isPunctuationChar.test(ch)) { |
||||
curPunc = ch; |
||||
return null; |
||||
} |
||||
if (numberStart.test(ch)) { |
||||
stream.backUp(1) |
||||
if (stream.match(number)) return "number" |
||||
stream.next() |
||||
} |
||||
if (ch == "/") { |
||||
if (stream.eat("*")) { |
||||
state.tokenize = tokenComment; |
||||
return tokenComment(stream, state); |
||||
} |
||||
if (stream.eat("/")) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
} |
||||
if (isOperatorChar.test(ch)) { |
||||
while (!stream.match(/^\/[\/*]/, false) && stream.eat(isOperatorChar)) {} |
||||
return "operator"; |
||||
} |
||||
stream.eatWhile(/[\w\$_\xa1-\uffff]/); |
||||
if (namespaceSeparator) while (stream.match(namespaceSeparator)) |
||||
stream.eatWhile(/[\w\$_\xa1-\uffff]/); |
||||
|
||||
var cur = stream.current(); |
||||
if (contains(keywords, cur)) { |
||||
if (contains(blockKeywords, cur)) curPunc = "newstatement"; |
||||
if (contains(defKeywords, cur)) isDefKeyword = true; |
||||
return "keyword"; |
||||
} |
||||
if (contains(types, cur)) return "variable-3"; |
||||
if (contains(builtin, cur)) { |
||||
if (contains(blockKeywords, cur)) curPunc = "newstatement"; |
||||
return "builtin"; |
||||
} |
||||
if (contains(atoms, cur)) return "atom"; |
||||
return "variable"; |
||||
} |
||||
|
||||
function tokenString(quote) { |
||||
return function(stream, state) { |
||||
var escaped = false, next, end = false; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == quote && !escaped) {end = true; break;} |
||||
escaped = !escaped && next == "\\"; |
||||
} |
||||
if (end || !(escaped || multiLineStrings)) |
||||
state.tokenize = null; |
||||
return "string"; |
||||
}; |
||||
} |
||||
|
||||
function tokenComment(stream, state) { |
||||
var maybeEnd = false, ch; |
||||
while (ch = stream.next()) { |
||||
if (ch == "/" && maybeEnd) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
maybeEnd = (ch == "*"); |
||||
} |
||||
return "comment"; |
||||
} |
||||
|
||||
function maybeEOL(stream, state) { |
||||
if (parserConfig.typeFirstDefinitions && stream.eol() && isTopScope(state.context)) |
||||
state.typeAtEndOfLine = typeBefore(stream, state, stream.pos) |
||||
} |
||||
|
||||
// Interface
|
||||
|
||||
return { |
||||
startState: function(basecolumn) { |
||||
return { |
||||
tokenize: null, |
||||
context: new Context((basecolumn || 0) - indentUnit, 0, "top", null, false), |
||||
indented: 0, |
||||
startOfLine: true, |
||||
prevToken: null |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
var ctx = state.context; |
||||
if (stream.sol()) { |
||||
if (ctx.align == null) ctx.align = false; |
||||
state.indented = stream.indentation(); |
||||
state.startOfLine = true; |
||||
} |
||||
if (stream.eatSpace()) { maybeEOL(stream, state); return null; } |
||||
curPunc = isDefKeyword = null; |
||||
var style = (state.tokenize || tokenBase)(stream, state); |
||||
if (style == "comment" || style == "meta") return style; |
||||
if (ctx.align == null) ctx.align = true; |
||||
|
||||
if (endStatement.test(curPunc)) while (state.context.type == "statement") popContext(state); |
||||
else if (curPunc == "{") pushContext(state, stream.column(), "}"); |
||||
else if (curPunc == "[") pushContext(state, stream.column(), "]"); |
||||
else if (curPunc == "(") pushContext(state, stream.column(), ")"); |
||||
else if (curPunc == "}") { |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
if (ctx.type == "}") ctx = popContext(state); |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
} |
||||
else if (curPunc == ctx.type) popContext(state); |
||||
else if (indentStatements && |
||||
(((ctx.type == "}" || ctx.type == "top") && curPunc != ";") || |
||||
(ctx.type == "statement" && curPunc == "newstatement"))) { |
||||
pushContext(state, stream.column(), "statement", stream.current()); |
||||
} |
||||
|
||||
if (style == "variable" && |
||||
((state.prevToken == "def" || |
||||
(parserConfig.typeFirstDefinitions && typeBefore(stream, state, stream.start) && |
||||
isTopScope(state.context) && stream.match(/^\s*\(/, false))))) |
||||
style = "def"; |
||||
|
||||
if (hooks.token) { |
||||
var result = hooks.token(stream, state, style); |
||||
if (result !== undefined) style = result; |
||||
} |
||||
|
||||
if (style == "def" && parserConfig.styleDefs === false) style = "variable"; |
||||
|
||||
state.startOfLine = false; |
||||
state.prevToken = isDefKeyword ? "def" : style || curPunc; |
||||
maybeEOL(stream, state); |
||||
return style; |
||||
}, |
||||
|
||||
indent: function(state, textAfter) { |
||||
if (state.tokenize != tokenBase && state.tokenize != null || state.typeAtEndOfLine) return CodeMirror.Pass; |
||||
var ctx = state.context, firstChar = textAfter && textAfter.charAt(0); |
||||
if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev; |
||||
if (parserConfig.dontIndentStatements) |
||||
while (ctx.type == "statement" && parserConfig.dontIndentStatements.test(ctx.info)) |
||||
ctx = ctx.prev |
||||
if (hooks.indent) { |
||||
var hook = hooks.indent(state, ctx, textAfter); |
||||
if (typeof hook == "number") return hook |
||||
} |
||||
var closing = firstChar == ctx.type; |
||||
var switchBlock = ctx.prev && ctx.prev.info == "switch"; |
||||
if (parserConfig.allmanIndentation && /[{(]/.test(firstChar)) { |
||||
while (ctx.type != "top" && ctx.type != "}") ctx = ctx.prev |
||||
return ctx.indented |
||||
} |
||||
if (ctx.type == "statement") |
||||
return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit); |
||||
if (ctx.align && (!dontAlignCalls || ctx.type != ")")) |
||||
return ctx.column + (closing ? 0 : 1); |
||||
if (ctx.type == ")" && !closing) |
||||
return ctx.indented + statementIndentUnit; |
||||
|
||||
return ctx.indented + (closing ? 0 : indentUnit) + |
||||
(!closing && switchBlock && !/^(?:case|default)\b/.test(textAfter) ? indentUnit : 0); |
||||
}, |
||||
|
||||
electricInput: indentSwitch ? /^\s*(?:case .*?:|default:|\{\}?|\})$/ : /^\s*[{}]$/, |
||||
blockCommentStart: "/*", |
||||
blockCommentEnd: "*/", |
||||
lineComment: "//", |
||||
fold: "brace" |
||||
}; |
||||
}); |
||||
|
||||
function words(str) { |
||||
var obj = {}, words = str.split(" "); |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
function contains(words, word) { |
||||
if (typeof words === "function") { |
||||
return words(word); |
||||
} else { |
||||
return words.propertyIsEnumerable(word); |
||||
} |
||||
} |
||||
var cKeywords = "auto if break case register continue return default do sizeof " + |
||||
"static else struct switch extern typedef union for goto while enum const volatile"; |
||||
var cTypes = "int long char short double float unsigned signed void size_t ptrdiff_t"; |
||||
|
||||
function cppHook(stream, state) { |
||||
if (!state.startOfLine) return false |
||||
for (var ch, next = null; ch = stream.peek();) { |
||||
if (ch == "\\" && stream.match(/^.$/)) { |
||||
next = cppHook |
||||
break |
||||
} else if (ch == "/" && stream.match(/^\/[\/\*]/, false)) { |
||||
break |
||||
} |
||||
stream.next() |
||||
} |
||||
state.tokenize = next |
||||
return "meta" |
||||
} |
||||
|
||||
function pointerHook(_stream, state) { |
||||
if (state.prevToken == "variable-3") return "variable-3"; |
||||
return false; |
||||
} |
||||
|
||||
function cpp14Literal(stream) { |
||||
stream.eatWhile(/[\w\.']/); |
||||
return "number"; |
||||
} |
||||
|
||||
function cpp11StringHook(stream, state) { |
||||
stream.backUp(1); |
||||
// Raw strings.
|
||||
if (stream.match(/(R|u8R|uR|UR|LR)/)) { |
||||
var match = stream.match(/"([^\s\\()]{0,16})\(/); |
||||
if (!match) { |
||||
return false; |
||||
} |
||||
state.cpp11RawStringDelim = match[1]; |
||||
state.tokenize = tokenRawString; |
||||
return tokenRawString(stream, state); |
||||
} |
||||
// Unicode strings/chars.
|
||||
if (stream.match(/(u8|u|U|L)/)) { |
||||
if (stream.match(/["']/, /* eat */ false)) { |
||||
return "string"; |
||||
} |
||||
return false; |
||||
} |
||||
// Ignore this hook.
|
||||
stream.next(); |
||||
return false; |
||||
} |
||||
|
||||
function cppLooksLikeConstructor(word) { |
||||
var lastTwo = /(\w+)::(\w+)$/.exec(word); |
||||
return lastTwo && lastTwo[1] == lastTwo[2]; |
||||
} |
||||
|
||||
// C#-style strings where "" escapes a quote.
|
||||
function tokenAtString(stream, state) { |
||||
var next; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == '"' && !stream.eat('"')) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
} |
||||
return "string"; |
||||
} |
||||
|
||||
// C++11 raw string literal is <prefix>"<delim>( anything )<delim>", where
|
||||
// <delim> can be a string up to 16 characters long.
|
||||
function tokenRawString(stream, state) { |
||||
// Escape characters that have special regex meanings.
|
||||
var delim = state.cpp11RawStringDelim.replace(/[^\w\s]/g, '\\$&'); |
||||
var match = stream.match(new RegExp(".*?\\)" + delim + '"')); |
||||
if (match) |
||||
state.tokenize = null; |
||||
else |
||||
stream.skipToEnd(); |
||||
return "string"; |
||||
} |
||||
|
||||
function def(mimes, mode) { |
||||
if (typeof mimes == "string") mimes = [mimes]; |
||||
var words = []; |
||||
function add(obj) { |
||||
if (obj) for (var prop in obj) if (obj.hasOwnProperty(prop)) |
||||
words.push(prop); |
||||
} |
||||
add(mode.keywords); |
||||
add(mode.types); |
||||
add(mode.builtin); |
||||
add(mode.atoms); |
||||
if (words.length) { |
||||
mode.helperType = mimes[0]; |
||||
CodeMirror.registerHelper("hintWords", mimes[0], words); |
||||
} |
||||
|
||||
for (var i = 0; i < mimes.length; ++i) |
||||
CodeMirror.defineMIME(mimes[i], mode); |
||||
} |
||||
|
||||
def(["text/x-csrc", "text/x-c", "text/x-chdr"], { |
||||
name: "clike", |
||||
keywords: words(cKeywords), |
||||
types: words(cTypes + " bool _Complex _Bool float_t double_t intptr_t intmax_t " + |
||||
"int8_t int16_t int32_t int64_t uintptr_t uintmax_t uint8_t uint16_t " + |
||||
"uint32_t uint64_t"), |
||||
blockKeywords: words("case do else for if switch while struct"), |
||||
defKeywords: words("struct"), |
||||
typeFirstDefinitions: true, |
||||
atoms: words("null true false"), |
||||
hooks: {"#": cppHook, "*": pointerHook}, |
||||
modeProps: {fold: ["brace", "include"]} |
||||
}); |
||||
|
||||
def(["text/x-c++src", "text/x-c++hdr"], { |
||||
name: "clike", |
||||
keywords: words(cKeywords + " asm dynamic_cast namespace reinterpret_cast try explicit new " + |
||||
"static_cast typeid catch operator template typename class friend private " + |
||||
"this using const_cast inline public throw virtual delete mutable protected " + |
||||
"alignas alignof constexpr decltype nullptr noexcept thread_local final " + |
||||
"static_assert override"), |
||||
types: words(cTypes + " bool wchar_t"), |
||||
blockKeywords: words("catch class do else finally for if struct switch try while"), |
||||
defKeywords: words("class namespace struct enum union"), |
||||
typeFirstDefinitions: true, |
||||
atoms: words("true false null"), |
||||
dontIndentStatements: /^template$/, |
||||
hooks: { |
||||
"#": cppHook, |
||||
"*": pointerHook, |
||||
"u": cpp11StringHook, |
||||
"U": cpp11StringHook, |
||||
"L": cpp11StringHook, |
||||
"R": cpp11StringHook, |
||||
"0": cpp14Literal, |
||||
"1": cpp14Literal, |
||||
"2": cpp14Literal, |
||||
"3": cpp14Literal, |
||||
"4": cpp14Literal, |
||||
"5": cpp14Literal, |
||||
"6": cpp14Literal, |
||||
"7": cpp14Literal, |
||||
"8": cpp14Literal, |
||||
"9": cpp14Literal, |
||||
token: function(stream, state, style) { |
||||
if (style == "variable" && stream.peek() == "(" && |
||||
(state.prevToken == ";" || state.prevToken == null || |
||||
state.prevToken == "}") && |
||||
cppLooksLikeConstructor(stream.current())) |
||||
return "def"; |
||||
} |
||||
}, |
||||
namespaceSeparator: "::", |
||||
modeProps: {fold: ["brace", "include"]} |
||||
}); |
||||
|
||||
def("text/x-java", { |
||||
name: "clike", |
||||
keywords: words("abstract assert break case catch class const continue default " + |
||||
"do else enum extends final finally float for goto if implements import " + |
||||
"instanceof interface native new package private protected public " + |
||||
"return static strictfp super switch synchronized this throw throws transient " + |
||||
"try volatile while"), |
||||
types: words("byte short int long float double boolean char void Boolean Byte Character Double Float " + |
||||
"Integer Long Number Object Short String StringBuffer StringBuilder Void"), |
||||
blockKeywords: words("catch class do else finally for if switch try while"), |
||||
defKeywords: words("class interface package enum"), |
||||
typeFirstDefinitions: true, |
||||
atoms: words("true false null"), |
||||
endStatement: /^[;:]$/, |
||||
number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i, |
||||
hooks: { |
||||
"@": function(stream) { |
||||
stream.eatWhile(/[\w\$_]/); |
||||
return "meta"; |
||||
} |
||||
}, |
||||
modeProps: {fold: ["brace", "import"]} |
||||
}); |
||||
|
||||
def("text/x-csharp", { |
||||
name: "clike", |
||||
keywords: words("abstract as async await base break case catch checked class const continue" + |
||||
" default delegate do else enum event explicit extern finally fixed for" + |
||||
" foreach goto if implicit in interface internal is lock namespace new" + |
||||
" operator out override params private protected public readonly ref return sealed" + |
||||
" sizeof stackalloc static struct switch this throw try typeof unchecked" + |
||||
" unsafe using virtual void volatile while add alias ascending descending dynamic from get" + |
||||
" global group into join let orderby partial remove select set value var yield"), |
||||
types: words("Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func" + |
||||
" Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32" + |
||||
" UInt64 bool byte char decimal double short int long object" + |
||||
" sbyte float string ushort uint ulong"), |
||||
blockKeywords: words("catch class do else finally for foreach if struct switch try while"), |
||||
defKeywords: words("class interface namespace struct var"), |
||||
typeFirstDefinitions: true, |
||||
atoms: words("true false null"), |
||||
hooks: { |
||||
"@": function(stream, state) { |
||||
if (stream.eat('"')) { |
||||
state.tokenize = tokenAtString; |
||||
return tokenAtString(stream, state); |
||||
} |
||||
stream.eatWhile(/[\w\$_]/); |
||||
return "meta"; |
||||
} |
||||
} |
||||
}); |
||||
|
||||
function tokenTripleString(stream, state) { |
||||
var escaped = false; |
||||
while (!stream.eol()) { |
||||
if (!escaped && stream.match('"""')) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
escaped = stream.next() == "\\" && !escaped; |
||||
} |
||||
return "string"; |
||||
} |
||||
|
||||
def("text/x-scala", { |
||||
name: "clike", |
||||
keywords: words( |
||||
|
||||
/* scala */ |
||||
"abstract case catch class def do else extends final finally for forSome if " + |
||||
"implicit import lazy match new null object override package private protected return " + |
||||
"sealed super this throw trait try type val var while with yield _ : = => <- <: " + |
||||
"<% >: # @ " + |
||||
|
||||
/* package scala */ |
||||
"assert assume require print println printf readLine readBoolean readByte readShort " + |
||||
"readChar readInt readLong readFloat readDouble " + |
||||
|
||||
":: #:: " |
||||
), |
||||
types: words( |
||||
"AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either " + |
||||
"Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable " + |
||||
"Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering " + |
||||
"Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder " + |
||||
"StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector " + |
||||
|
||||
/* package java.lang */ |
||||
"Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " + |
||||
"Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " + |
||||
"Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " + |
||||
"StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void" |
||||
), |
||||
multiLineStrings: true, |
||||
blockKeywords: words("catch class do else finally for forSome if match switch try while"), |
||||
defKeywords: words("class def object package trait type val var"), |
||||
atoms: words("true false null"), |
||||
indentStatements: false, |
||||
indentSwitch: false, |
||||
hooks: { |
||||
"@": function(stream) { |
||||
stream.eatWhile(/[\w\$_]/); |
||||
return "meta"; |
||||
}, |
||||
'"': function(stream, state) { |
||||
if (!stream.match('""')) return false; |
||||
state.tokenize = tokenTripleString; |
||||
return state.tokenize(stream, state); |
||||
}, |
||||
"'": function(stream) { |
||||
stream.eatWhile(/[\w\$_\xa1-\uffff]/); |
||||
return "atom"; |
||||
}, |
||||
"=": function(stream, state) { |
||||
var cx = state.context |
||||
if (cx.type == "}" && cx.align && stream.eat(">")) { |
||||
state.context = new Context(cx.indented, cx.column, cx.type, cx.info, null, cx.prev) |
||||
return "operator" |
||||
} else { |
||||
return false |
||||
} |
||||
} |
||||
}, |
||||
modeProps: {closeBrackets: {triples: '"'}} |
||||
}); |
||||
|
||||
function tokenKotlinString(tripleString){ |
||||
return function (stream, state) { |
||||
var escaped = false, next, end = false; |
||||
while (!stream.eol()) { |
||||
if (!tripleString && !escaped && stream.match('"') ) {end = true; break;} |
||||
if (tripleString && stream.match('"""')) {end = true; break;} |
||||
next = stream.next(); |
||||
if(!escaped && next == "$" && stream.match('{')) |
||||
stream.skipTo("}"); |
||||
escaped = !escaped && next == "\\" && !tripleString; |
||||
} |
||||
if (end || !tripleString) |
||||
state.tokenize = null; |
||||
return "string"; |
||||
} |
||||
} |
||||
|
||||
def("text/x-kotlin", { |
||||
name: "clike", |
||||
keywords: words( |
||||
/*keywords*/ |
||||
"package as typealias class interface this super val " + |
||||
"var fun for is in This throw return " + |
||||
"break continue object if else while do try when !in !is as? " + |
||||
|
||||
/*soft keywords*/ |
||||
"file import where by get set abstract enum open inner override private public internal " + |
||||
"protected catch finally out final vararg reified dynamic companion constructor init " + |
||||
"sealed field property receiver param sparam lateinit data inline noinline tailrec " + |
||||
"external annotation crossinline const operator infix" |
||||
), |
||||
types: words( |
||||
/* package java.lang */ |
||||
"Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " + |
||||
"Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " + |
||||
"Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " + |
||||
"StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void" |
||||
), |
||||
intendSwitch: false, |
||||
indentStatements: false, |
||||
multiLineStrings: true, |
||||
blockKeywords: words("catch class do else finally for if where try while enum"), |
||||
defKeywords: words("class val var object package interface fun"), |
||||
atoms: words("true false null this"), |
||||
hooks: { |
||||
'"': function(stream, state) { |
||||
state.tokenize = tokenKotlinString(stream.match('""')); |
||||
return state.tokenize(stream, state); |
||||
} |
||||
}, |
||||
modeProps: {closeBrackets: {triples: '"'}} |
||||
}); |
||||
|
||||
def(["x-shader/x-vertex", "x-shader/x-fragment"], { |
||||
name: "clike", |
||||
keywords: words("sampler1D sampler2D sampler3D samplerCube " + |
||||
"sampler1DShadow sampler2DShadow " + |
||||
"const attribute uniform varying " + |
||||
"break continue discard return " + |
||||
"for while do if else struct " + |
||||
"in out inout"), |
||||
types: words("float int bool void " + |
||||
"vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 " + |
||||
"mat2 mat3 mat4"), |
||||
blockKeywords: words("for while do if else struct"), |
||||
builtin: words("radians degrees sin cos tan asin acos atan " + |
||||
"pow exp log exp2 sqrt inversesqrt " + |
||||
"abs sign floor ceil fract mod min max clamp mix step smoothstep " + |
||||
"length distance dot cross normalize ftransform faceforward " + |
||||
"reflect refract matrixCompMult " + |
||||
"lessThan lessThanEqual greaterThan greaterThanEqual " + |
||||
"equal notEqual any all not " + |
||||
"texture1D texture1DProj texture1DLod texture1DProjLod " + |
||||
"texture2D texture2DProj texture2DLod texture2DProjLod " + |
||||
"texture3D texture3DProj texture3DLod texture3DProjLod " + |
||||
"textureCube textureCubeLod " + |
||||
"shadow1D shadow2D shadow1DProj shadow2DProj " + |
||||
"shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod " + |
||||
"dFdx dFdy fwidth " + |
||||
"noise1 noise2 noise3 noise4"), |
||||
atoms: words("true false " + |
||||
"gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex " + |
||||
"gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 " + |
||||
"gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 " + |
||||
"gl_FogCoord gl_PointCoord " + |
||||
"gl_Position gl_PointSize gl_ClipVertex " + |
||||
"gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor " + |
||||
"gl_TexCoord gl_FogFragCoord " + |
||||
"gl_FragCoord gl_FrontFacing " + |
||||
"gl_FragData gl_FragDepth " + |
||||
"gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix " + |
||||
"gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse " + |
||||
"gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse " + |
||||
"gl_TexureMatrixTranspose gl_ModelViewMatrixInverseTranspose " + |
||||
"gl_ProjectionMatrixInverseTranspose " + |
||||
"gl_ModelViewProjectionMatrixInverseTranspose " + |
||||
"gl_TextureMatrixInverseTranspose " + |
||||
"gl_NormalScale gl_DepthRange gl_ClipPlane " + |
||||
"gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel " + |
||||
"gl_FrontLightModelProduct gl_BackLightModelProduct " + |
||||
"gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ " + |
||||
"gl_FogParameters " + |
||||
"gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords " + |
||||
"gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats " + |
||||
"gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits " + |
||||
"gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits " + |
||||
"gl_MaxDrawBuffers"), |
||||
indentSwitch: false, |
||||
hooks: {"#": cppHook}, |
||||
modeProps: {fold: ["brace", "include"]} |
||||
}); |
||||
|
||||
def("text/x-nesc", { |
||||
name: "clike", |
||||
keywords: words(cKeywords + "as atomic async call command component components configuration event generic " + |
||||
"implementation includes interface module new norace nx_struct nx_union post provides " + |
||||
"signal task uses abstract extends"), |
||||
types: words(cTypes), |
||||
blockKeywords: words("case do else for if switch while struct"), |
||||
atoms: words("null true false"), |
||||
hooks: {"#": cppHook}, |
||||
modeProps: {fold: ["brace", "include"]} |
||||
}); |
||||
|
||||
def("text/x-objectivec", { |
||||
name: "clike", |
||||
keywords: words(cKeywords + "inline restrict _Bool _Complex _Imaginary BOOL Class bycopy byref id IMP in " + |
||||
"inout nil oneway out Protocol SEL self super atomic nonatomic retain copy readwrite readonly"), |
||||
types: words(cTypes), |
||||
atoms: words("YES NO NULL NILL ON OFF true false"), |
||||
hooks: { |
||||
"@": function(stream) { |
||||
stream.eatWhile(/[\w\$]/); |
||||
return "keyword"; |
||||
}, |
||||
"#": cppHook, |
||||
indent: function(_state, ctx, textAfter) { |
||||
if (ctx.type == "statement" && /^@\w/.test(textAfter)) return ctx.indented |
||||
} |
||||
}, |
||||
modeProps: {fold: "brace"} |
||||
}); |
||||
|
||||
def("text/x-squirrel", { |
||||
name: "clike", |
||||
keywords: words("base break clone continue const default delete enum extends function in class" + |
||||
" foreach local resume return this throw typeof yield constructor instanceof static"), |
||||
types: words(cTypes), |
||||
blockKeywords: words("case catch class else for foreach if switch try while"), |
||||
defKeywords: words("function local class"), |
||||
typeFirstDefinitions: true, |
||||
atoms: words("true false null"), |
||||
hooks: {"#": cppHook}, |
||||
modeProps: {fold: ["brace", "include"]} |
||||
}); |
||||
|
||||
// Ceylon Strings need to deal with interpolation
|
||||
var stringTokenizer = null; |
||||
function tokenCeylonString(type) { |
||||
return function(stream, state) { |
||||
var escaped = false, next, end = false; |
||||
while (!stream.eol()) { |
||||
if (!escaped && stream.match('"') && |
||||
(type == "single" || stream.match('""'))) { |
||||
end = true; |
||||
break; |
||||
} |
||||
if (!escaped && stream.match('``')) { |
||||
stringTokenizer = tokenCeylonString(type); |
||||
end = true; |
||||
break; |
||||
} |
||||
next = stream.next(); |
||||
escaped = type == "single" && !escaped && next == "\\"; |
||||
} |
||||
if (end) |
||||
state.tokenize = null; |
||||
return "string"; |
||||
} |
||||
} |
||||
|
||||
def("text/x-ceylon", { |
||||
name: "clike", |
||||
keywords: words("abstracts alias assembly assert assign break case catch class continue dynamic else" + |
||||
" exists extends finally for function given if import in interface is let module new" + |
||||
" nonempty object of out outer package return satisfies super switch then this throw" + |
||||
" try value void while"), |
||||
types: function(word) { |
||||
// In Ceylon all identifiers that start with an uppercase are types
|
||||
var first = word.charAt(0); |
||||
return (first === first.toUpperCase() && first !== first.toLowerCase()); |
||||
}, |
||||
blockKeywords: words("case catch class dynamic else finally for function if interface module new object switch try while"), |
||||
defKeywords: words("class dynamic function interface module object package value"), |
||||
builtin: words("abstract actual aliased annotation by default deprecated doc final formal late license" + |
||||
" native optional sealed see serializable shared suppressWarnings tagged throws variable"), |
||||
isPunctuationChar: /[\[\]{}\(\),;\:\.`]/, |
||||
isOperatorChar: /[+\-*&%=<>!?|^~:\/]/, |
||||
numberStart: /[\d#$]/, |
||||
number: /^(?:#[\da-fA-F_]+|\$[01_]+|[\d_]+[kMGTPmunpf]?|[\d_]+\.[\d_]+(?:[eE][-+]?\d+|[kMGTPmunpf]|)|)/i, |
||||
multiLineStrings: true, |
||||
typeFirstDefinitions: true, |
||||
atoms: words("true false null larger smaller equal empty finished"), |
||||
indentSwitch: false, |
||||
styleDefs: false, |
||||
hooks: { |
||||
"@": function(stream) { |
||||
stream.eatWhile(/[\w\$_]/); |
||||
return "meta"; |
||||
}, |
||||
'"': function(stream, state) { |
||||
state.tokenize = tokenCeylonString(stream.match('""') ? "triple" : "single"); |
||||
return state.tokenize(stream, state); |
||||
}, |
||||
'`': function(stream, state) { |
||||
if (!stringTokenizer || !stream.match('`')) return false; |
||||
state.tokenize = stringTokenizer; |
||||
stringTokenizer = null; |
||||
return state.tokenize(stream, state); |
||||
}, |
||||
"'": function(stream) { |
||||
stream.eatWhile(/[\w\$_\xa1-\uffff]/); |
||||
return "atom"; |
||||
}, |
||||
token: function(_stream, state, style) { |
||||
if ((style == "variable" || style == "variable-3") && |
||||
state.prevToken == ".") { |
||||
return "variable-2"; |
||||
} |
||||
} |
||||
}, |
||||
modeProps: { |
||||
fold: ["brace", "import"], |
||||
closeBrackets: {triples: '"'} |
||||
} |
||||
}); |
||||
|
||||
}); |
||||
@ -0,0 +1,360 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: C-like mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<link rel="stylesheet" href="../../addon/hint/show-hint.css"> |
||||
<script src="../../addon/hint/show-hint.js"></script> |
||||
<script src="clike.js"></script> |
||||
<style>.CodeMirror {border: 2px inset #dee;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">C-like</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>C-like mode</h2> |
||||
|
||||
<div><textarea id="c-code"> |
||||
/* C demo code */ |
||||
|
||||
#include <zmq.h> |
||||
#include <pthread.h> |
||||
#include <semaphore.h> |
||||
#include <time.h> |
||||
#include <stdio.h> |
||||
#include <fcntl.h> |
||||
#include <malloc.h> |
||||
|
||||
typedef struct { |
||||
void* arg_socket; |
||||
zmq_msg_t* arg_msg; |
||||
char* arg_string; |
||||
unsigned long arg_len; |
||||
int arg_int, arg_command; |
||||
|
||||
int signal_fd; |
||||
int pad; |
||||
void* context; |
||||
sem_t sem; |
||||
} acl_zmq_context; |
||||
|
||||
#define p(X) (context->arg_##X) |
||||
|
||||
void* zmq_thread(void* context_pointer) { |
||||
acl_zmq_context* context = (acl_zmq_context*)context_pointer; |
||||
char ok = 'K', err = 'X'; |
||||
int res; |
||||
|
||||
while (1) { |
||||
while ((res = sem_wait(&context->sem)) == EINTR); |
||||
if (res) {write(context->signal_fd, &err, 1); goto cleanup;} |
||||
switch(p(command)) { |
||||
case 0: goto cleanup; |
||||
case 1: p(socket) = zmq_socket(context->context, p(int)); break; |
||||
case 2: p(int) = zmq_close(p(socket)); break; |
||||
case 3: p(int) = zmq_bind(p(socket), p(string)); break; |
||||
case 4: p(int) = zmq_connect(p(socket), p(string)); break; |
||||
case 5: p(int) = zmq_getsockopt(p(socket), p(int), (void*)p(string), &p(len)); break; |
||||
case 6: p(int) = zmq_setsockopt(p(socket), p(int), (void*)p(string), p(len)); break; |
||||
case 7: p(int) = zmq_send(p(socket), p(msg), p(int)); break; |
||||
case 8: p(int) = zmq_recv(p(socket), p(msg), p(int)); break; |
||||
case 9: p(int) = zmq_poll(p(socket), p(int), p(len)); break; |
||||
} |
||||
p(command) = errno; |
||||
write(context->signal_fd, &ok, 1); |
||||
} |
||||
cleanup: |
||||
close(context->signal_fd); |
||||
free(context_pointer); |
||||
return 0; |
||||
} |
||||
|
||||
void* zmq_thread_init(void* zmq_context, int signal_fd) { |
||||
acl_zmq_context* context = malloc(sizeof(acl_zmq_context)); |
||||
pthread_t thread; |
||||
|
||||
context->context = zmq_context; |
||||
context->signal_fd = signal_fd; |
||||
sem_init(&context->sem, 1, 0); |
||||
pthread_create(&thread, 0, &zmq_thread, context); |
||||
pthread_detach(thread); |
||||
return context; |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>C++ example</h2> |
||||
|
||||
<div><textarea id="cpp-code"> |
||||
#include <iostream> |
||||
#include "mystuff/util.h" |
||||
|
||||
namespace { |
||||
enum Enum { |
||||
VAL1, VAL2, VAL3 |
||||
}; |
||||
|
||||
char32_t unicode_string = U"\U0010FFFF"; |
||||
string raw_string = R"delim(anything |
||||
you |
||||
want)delim"; |
||||
|
||||
int Helper(const MyType& param) { |
||||
return 0; |
||||
} |
||||
} // namespace |
||||
|
||||
class ForwardDec; |
||||
|
||||
template <class T, class V> |
||||
class Class : public BaseClass { |
||||
const MyType<T, V> member_; |
||||
|
||||
public: |
||||
const MyType<T, V>& Method() const { |
||||
return member_; |
||||
} |
||||
|
||||
void Method2(MyType<T, V>* value); |
||||
} |
||||
|
||||
template <class T, class V> |
||||
void Class::Method2(MyType<T, V>* value) { |
||||
std::out << 1 >> method(); |
||||
value->Method3(member_); |
||||
member_ = value; |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>Objective-C example</h2> |
||||
|
||||
<div><textarea id="objectivec-code"> |
||||
/* |
||||
This is a longer comment |
||||
That spans two lines |
||||
*/ |
||||
|
||||
#import <Test/Test.h> |
||||
@implementation YourAppDelegate |
||||
|
||||
// This is a one-line comment |
||||
|
||||
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{ |
||||
char myString[] = "This is a C character array"; |
||||
int test = 5; |
||||
return YES; |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>Java example</h2> |
||||
|
||||
<div><textarea id="java-code"> |
||||
import com.demo.util.MyType; |
||||
import com.demo.util.MyInterface; |
||||
|
||||
public enum Enum { |
||||
VAL1, VAL2, VAL3 |
||||
} |
||||
|
||||
public class Class<T, V> implements MyInterface { |
||||
public static final MyType<T, V> member; |
||||
|
||||
private class InnerClass { |
||||
public int zero() { |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
@Override |
||||
public MyType method() { |
||||
return member; |
||||
} |
||||
|
||||
public void method2(MyType<T, V> value) { |
||||
method(); |
||||
value.method3(); |
||||
member = value; |
||||
} |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>Scala example</h2> |
||||
|
||||
<div><textarea id="scala-code"> |
||||
object FilterTest extends App { |
||||
def filter(xs: List[Int], threshold: Int) = { |
||||
def process(ys: List[Int]): List[Int] = |
||||
if (ys.isEmpty) ys |
||||
else if (ys.head < threshold) ys.head :: process(ys.tail) |
||||
else process(ys.tail) |
||||
process(xs) |
||||
} |
||||
println(filter(List(1, 9, 2, 8, 3, 7, 4), 5)) |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>Kotlin mode</h2> |
||||
|
||||
<div><textarea id="kotlin-code"> |
||||
package org.wasabi.http |
||||
|
||||
import java.util.concurrent.Executors |
||||
import java.net.InetSocketAddress |
||||
import org.wasabi.app.AppConfiguration |
||||
import io.netty.bootstrap.ServerBootstrap |
||||
import io.netty.channel.nio.NioEventLoopGroup |
||||
import io.netty.channel.socket.nio.NioServerSocketChannel |
||||
import org.wasabi.app.AppServer |
||||
|
||||
public class HttpServer(private val appServer: AppServer) { |
||||
|
||||
val bootstrap: ServerBootstrap |
||||
val primaryGroup: NioEventLoopGroup |
||||
val workerGroup: NioEventLoopGroup |
||||
|
||||
init { |
||||
// Define worker groups |
||||
primaryGroup = NioEventLoopGroup() |
||||
workerGroup = NioEventLoopGroup() |
||||
|
||||
// Initialize bootstrap of server |
||||
bootstrap = ServerBootstrap() |
||||
|
||||
bootstrap.group(primaryGroup, workerGroup) |
||||
bootstrap.channel(javaClass<NioServerSocketChannel>()) |
||||
bootstrap.childHandler(NettyPipelineInitializer(appServer)) |
||||
} |
||||
|
||||
public fun start(wait: Boolean = true) { |
||||
val channel = bootstrap.bind(appServer.configuration.port)?.sync()?.channel() |
||||
|
||||
if (wait) { |
||||
channel?.closeFuture()?.sync() |
||||
} |
||||
} |
||||
|
||||
public fun stop() { |
||||
// Shutdown all event loops |
||||
primaryGroup.shutdownGracefully() |
||||
workerGroup.shutdownGracefully() |
||||
|
||||
// Wait till all threads are terminated |
||||
primaryGroup.terminationFuture().sync() |
||||
workerGroup.terminationFuture().sync() |
||||
} |
||||
} |
||||
</textarea></div> |
||||
|
||||
<h2>Ceylon mode</h2> |
||||
|
||||
<div><textarea id="ceylon-code"> |
||||
"Produces the [[stream|Iterable]] that results from repeated |
||||
application of the given [[function|next]] to the given |
||||
[[first]] element of the stream, until the function first |
||||
returns [[finished]]. If the given function never returns |
||||
`finished`, the resulting stream is infinite. |
||||
|
||||
For example: |
||||
|
||||
loop(0)(2.plus).takeWhile(10.largerThan) |
||||
|
||||
produces the stream `{ 0, 2, 4, 6, 8 }`." |
||||
tagged("Streams") |
||||
shared {Element+} loop<Element>( |
||||
"The first element of the resulting stream." |
||||
Element first)( |
||||
"The function that produces the next element of the |
||||
stream, given the current element. The function may |
||||
return [[finished]] to indicate the end of the |
||||
stream." |
||||
Element|Finished next(Element element)) |
||||
=> let (start = first) |
||||
object satisfies {Element+} { |
||||
first => start; |
||||
empty => false; |
||||
function nextElement(Element element) |
||||
=> next(element); |
||||
iterator() |
||||
=> object satisfies Iterator<Element> { |
||||
variable Element|Finished current = start; |
||||
shared actual Element|Finished next() { |
||||
if (!is Finished result = current) { |
||||
current = nextElement(result); |
||||
return result; |
||||
} |
||||
else { |
||||
return finished; |
||||
} |
||||
} |
||||
}; |
||||
}; |
||||
</textarea></div> |
||||
|
||||
<script> |
||||
var cEditor = CodeMirror.fromTextArea(document.getElementById("c-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-csrc" |
||||
}); |
||||
var cppEditor = CodeMirror.fromTextArea(document.getElementById("cpp-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-c++src" |
||||
}); |
||||
var javaEditor = CodeMirror.fromTextArea(document.getElementById("java-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-java" |
||||
}); |
||||
var objectivecEditor = CodeMirror.fromTextArea(document.getElementById("objectivec-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-objectivec" |
||||
}); |
||||
var scalaEditor = CodeMirror.fromTextArea(document.getElementById("scala-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-scala" |
||||
}); |
||||
var kotlinEditor = CodeMirror.fromTextArea(document.getElementById("kotlin-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-kotlin" |
||||
}); |
||||
var ceylonEditor = CodeMirror.fromTextArea(document.getElementById("ceylon-code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-ceylon" |
||||
}); |
||||
var mac = CodeMirror.keyMap.default == CodeMirror.keyMap.macDefault; |
||||
CodeMirror.keyMap.default[(mac ? "Cmd" : "Ctrl") + "-Space"] = "autocomplete"; |
||||
</script> |
||||
|
||||
<p>Simple mode that tries to handle C-like languages as well as it |
||||
can. Takes two configuration parameters: <code>keywords</code>, an |
||||
object whose property names are the keywords in the language, |
||||
and <code>useCPP</code>, which determines whether C preprocessor |
||||
directives are recognized.</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-csrc</code> |
||||
(C), <code>text/x-c++src</code> (C++), <code>text/x-java</code> |
||||
(Java), <code>text/x-csharp</code> (C#), |
||||
<code>text/x-objectivec</code> (Objective-C), |
||||
<code>text/x-scala</code> (Scala), <code>text/x-vertex</code> |
||||
<code>x-shader/x-fragment</code> (shader programs), |
||||
<code>text/x-squirrel</code> (Squirrel) and |
||||
<code>text/x-ceylon</code> (Ceylon)</p> |
||||
</article> |
||||
@ -0,0 +1,767 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Scala mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<link rel="stylesheet" href="../../theme/ambiance.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="clike.js"></script> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Scala</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Scala mode</h2> |
||||
<form> |
||||
<textarea id="code" name="code"> |
||||
|
||||
/* __ *\ |
||||
** ________ ___ / / ___ Scala API ** |
||||
** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** |
||||
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** |
||||
** /____/\___/_/ |_/____/_/ | | ** |
||||
** |/ ** |
||||
\* */ |
||||
|
||||
package scala.collection |
||||
|
||||
import generic._ |
||||
import mutable.{ Builder, ListBuffer } |
||||
import annotation.{tailrec, migration, bridge} |
||||
import annotation.unchecked.{ uncheckedVariance => uV } |
||||
import parallel.ParIterable |
||||
|
||||
/** A template trait for traversable collections of type `Traversable[A]`. |
||||
* |
||||
* $traversableInfo |
||||
* @define mutability |
||||
* @define traversableInfo |
||||
* This is a base trait of all kinds of $mutability Scala collections. It |
||||
* implements the behavior common to all collections, in terms of a method |
||||
* `foreach` with signature: |
||||
* {{{ |
||||
* def foreach[U](f: Elem => U): Unit |
||||
* }}} |
||||
* Collection classes mixing in this trait provide a concrete |
||||
* `foreach` method which traverses all the |
||||
* elements contained in the collection, applying a given function to each. |
||||
* They also need to provide a method `newBuilder` |
||||
* which creates a builder for collections of the same kind. |
||||
* |
||||
* A traversable class might or might not have two properties: strictness |
||||
* and orderedness. Neither is represented as a type. |
||||
* |
||||
* The instances of a strict collection class have all their elements |
||||
* computed before they can be used as values. By contrast, instances of |
||||
* a non-strict collection class may defer computation of some of their |
||||
* elements until after the instance is available as a value. |
||||
* A typical example of a non-strict collection class is a |
||||
* <a href="../immutable/Stream.html" target="ContentFrame"> |
||||
* `scala.collection.immutable.Stream`</a>. |
||||
* A more general class of examples are `TraversableViews`. |
||||
* |
||||
* If a collection is an instance of an ordered collection class, traversing |
||||
* its elements with `foreach` will always visit elements in the |
||||
* same order, even for different runs of the program. If the class is not |
||||
* ordered, `foreach` can visit elements in different orders for |
||||
* different runs (but it will keep the same order in the same run).' |
||||
* |
||||
* A typical example of a collection class which is not ordered is a |
||||
* `HashMap` of objects. The traversal order for hash maps will |
||||
* depend on the hash codes of its elements, and these hash codes might |
||||
* differ from one run to the next. By contrast, a `LinkedHashMap` |
||||
* is ordered because it's `foreach` method visits elements in the |
||||
* order they were inserted into the `HashMap`. |
||||
* |
||||
* @author Martin Odersky |
||||
* @version 2.8 |
||||
* @since 2.8 |
||||
* @tparam A the element type of the collection |
||||
* @tparam Repr the type of the actual collection containing the elements. |
||||
* |
||||
* @define Coll Traversable |
||||
* @define coll traversable collection |
||||
*/ |
||||
trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr] |
||||
with FilterMonadic[A, Repr] |
||||
with TraversableOnce[A] |
||||
with GenTraversableLike[A, Repr] |
||||
with Parallelizable[A, ParIterable[A]] |
||||
{ |
||||
self => |
||||
|
||||
import Traversable.breaks._ |
||||
|
||||
/** The type implementing this traversable */ |
||||
protected type Self = Repr |
||||
|
||||
/** The collection of type $coll underlying this `TraversableLike` object. |
||||
* By default this is implemented as the `TraversableLike` object itself, |
||||
* but this can be overridden. |
||||
*/ |
||||
def repr: Repr = this.asInstanceOf[Repr] |
||||
|
||||
/** The underlying collection seen as an instance of `$Coll`. |
||||
* By default this is implemented as the current collection object itself, |
||||
* but this can be overridden. |
||||
*/ |
||||
protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]] |
||||
|
||||
/** A conversion from collections of type `Repr` to `$Coll` objects. |
||||
* By default this is implemented as just a cast, but this can be overridden. |
||||
*/ |
||||
protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]] |
||||
|
||||
/** Creates a new builder for this collection type. |
||||
*/ |
||||
protected[this] def newBuilder: Builder[A, Repr] |
||||
|
||||
protected[this] def parCombiner = ParIterable.newCombiner[A] |
||||
|
||||
/** Applies a function `f` to all elements of this $coll. |
||||
* |
||||
* Note: this method underlies the implementation of most other bulk operations. |
||||
* It's important to implement this method in an efficient way. |
||||
* |
||||
* |
||||
* @param f the function that is applied for its side-effect to every element. |
||||
* The result of function `f` is discarded. |
||||
* |
||||
* @tparam U the type parameter describing the result of function `f`. |
||||
* This result will always be ignored. Typically `U` is `Unit`, |
||||
* but this is not necessary. |
||||
* |
||||
* @usecase def foreach(f: A => Unit): Unit |
||||
*/ |
||||
def foreach[U](f: A => U): Unit |
||||
|
||||
/** Tests whether this $coll is empty. |
||||
* |
||||
* @return `true` if the $coll contain no elements, `false` otherwise. |
||||
*/ |
||||
def isEmpty: Boolean = { |
||||
var result = true |
||||
breakable { |
||||
for (x <- this) { |
||||
result = false |
||||
break |
||||
} |
||||
} |
||||
result |
||||
} |
||||
|
||||
/** Tests whether this $coll is known to have a finite size. |
||||
* All strict collections are known to have finite size. For a non-strict collection |
||||
* such as `Stream`, the predicate returns `true` if all elements have been computed. |
||||
* It returns `false` if the stream is not yet evaluated to the end. |
||||
* |
||||
* Note: many collection methods will not work on collections of infinite sizes. |
||||
* |
||||
* @return `true` if this collection is known to have finite size, `false` otherwise. |
||||
*/ |
||||
def hasDefiniteSize = true |
||||
|
||||
def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size) |
||||
b ++= thisCollection |
||||
b ++= that.seq |
||||
b.result |
||||
} |
||||
|
||||
@bridge |
||||
def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = |
||||
++(that: GenTraversableOnce[B])(bf) |
||||
|
||||
/** Concatenates this $coll with the elements of a traversable collection. |
||||
* It differs from ++ in that the right operand determines the type of the |
||||
* resulting collection rather than the left one. |
||||
* |
||||
* @param that the traversable to append. |
||||
* @tparam B the element type of the returned collection. |
||||
* @tparam That $thatinfo |
||||
* @param bf $bfinfo |
||||
* @return a new collection of type `That` which contains all elements |
||||
* of this $coll followed by all elements of `that`. |
||||
* |
||||
* @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B] |
||||
* |
||||
* @return a new $coll which contains all elements of this $coll |
||||
* followed by all elements of `that`. |
||||
*/ |
||||
def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size) |
||||
b ++= that |
||||
b ++= thisCollection |
||||
b.result |
||||
} |
||||
|
||||
/** This overload exists because: for the implementation of ++: we should reuse |
||||
* that of ++ because many collections override it with more efficient versions. |
||||
* Since TraversableOnce has no '++' method, we have to implement that directly, |
||||
* but Traversable and down can use the overload. |
||||
*/ |
||||
def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = |
||||
(that ++ seq)(breakOut) |
||||
|
||||
def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
b.sizeHint(this) |
||||
for (x <- this) b += f(x) |
||||
b.result |
||||
} |
||||
|
||||
def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
for (x <- this) b ++= f(x).seq |
||||
b.result |
||||
} |
||||
|
||||
/** Selects all elements of this $coll which satisfy a predicate. |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return a new $coll consisting of all elements of this $coll that satisfy the given |
||||
* predicate `p`. The order of the elements is preserved. |
||||
*/ |
||||
def filter(p: A => Boolean): Repr = { |
||||
val b = newBuilder |
||||
for (x <- this) |
||||
if (p(x)) b += x |
||||
b.result |
||||
} |
||||
|
||||
/** Selects all elements of this $coll which do not satisfy a predicate. |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return a new $coll consisting of all elements of this $coll that do not satisfy the given |
||||
* predicate `p`. The order of the elements is preserved. |
||||
*/ |
||||
def filterNot(p: A => Boolean): Repr = filter(!p(_)) |
||||
|
||||
def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
for (x <- this) if (pf.isDefinedAt(x)) b += pf(x) |
||||
b.result |
||||
} |
||||
|
||||
/** Builds a new collection by applying an option-valued function to all |
||||
* elements of this $coll on which the function is defined. |
||||
* |
||||
* @param f the option-valued function which filters and maps the $coll. |
||||
* @tparam B the element type of the returned collection. |
||||
* @tparam That $thatinfo |
||||
* @param bf $bfinfo |
||||
* @return a new collection of type `That` resulting from applying the option-valued function |
||||
* `f` to each element and collecting all defined results. |
||||
* The order of the elements is preserved. |
||||
* |
||||
* @usecase def filterMap[B](f: A => Option[B]): $Coll[B] |
||||
* |
||||
* @param pf the partial function which filters and maps the $coll. |
||||
* @return a new $coll resulting from applying the given option-valued function |
||||
* `f` to each element and collecting all defined results. |
||||
* The order of the elements is preserved. |
||||
def filterMap[B, That](f: A => Option[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
for (x <- this) |
||||
f(x) match { |
||||
case Some(y) => b += y |
||||
case _ => |
||||
} |
||||
b.result |
||||
} |
||||
*/ |
||||
|
||||
/** Partitions this $coll in two ${coll}s according to a predicate. |
||||
* |
||||
* @param p the predicate on which to partition. |
||||
* @return a pair of ${coll}s: the first $coll consists of all elements that |
||||
* satisfy the predicate `p` and the second $coll consists of all elements |
||||
* that don't. The relative order of the elements in the resulting ${coll}s |
||||
* is the same as in the original $coll. |
||||
*/ |
||||
def partition(p: A => Boolean): (Repr, Repr) = { |
||||
val l, r = newBuilder |
||||
for (x <- this) (if (p(x)) l else r) += x |
||||
(l.result, r.result) |
||||
} |
||||
|
||||
def groupBy[K](f: A => K): immutable.Map[K, Repr] = { |
||||
val m = mutable.Map.empty[K, Builder[A, Repr]] |
||||
for (elem <- this) { |
||||
val key = f(elem) |
||||
val bldr = m.getOrElseUpdate(key, newBuilder) |
||||
bldr += elem |
||||
} |
||||
val b = immutable.Map.newBuilder[K, Repr] |
||||
for ((k, v) <- m) |
||||
b += ((k, v.result)) |
||||
|
||||
b.result |
||||
} |
||||
|
||||
/** Tests whether a predicate holds for all elements of this $coll. |
||||
* |
||||
* $mayNotTerminateInf |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return `true` if the given predicate `p` holds for all elements |
||||
* of this $coll, otherwise `false`. |
||||
*/ |
||||
def forall(p: A => Boolean): Boolean = { |
||||
var result = true |
||||
breakable { |
||||
for (x <- this) |
||||
if (!p(x)) { result = false; break } |
||||
} |
||||
result |
||||
} |
||||
|
||||
/** Tests whether a predicate holds for some of the elements of this $coll. |
||||
* |
||||
* $mayNotTerminateInf |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return `true` if the given predicate `p` holds for some of the |
||||
* elements of this $coll, otherwise `false`. |
||||
*/ |
||||
def exists(p: A => Boolean): Boolean = { |
||||
var result = false |
||||
breakable { |
||||
for (x <- this) |
||||
if (p(x)) { result = true; break } |
||||
} |
||||
result |
||||
} |
||||
|
||||
/** Finds the first element of the $coll satisfying a predicate, if any. |
||||
* |
||||
* $mayNotTerminateInf |
||||
* $orderDependent |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return an option value containing the first element in the $coll |
||||
* that satisfies `p`, or `None` if none exists. |
||||
*/ |
||||
def find(p: A => Boolean): Option[A] = { |
||||
var result: Option[A] = None |
||||
breakable { |
||||
for (x <- this) |
||||
if (p(x)) { result = Some(x); break } |
||||
} |
||||
result |
||||
} |
||||
|
||||
def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That = scanLeft(z)(op) |
||||
|
||||
def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
b.sizeHint(this, 1) |
||||
var acc = z |
||||
b += acc |
||||
for (x <- this) { acc = op(acc, x); b += acc } |
||||
b.result |
||||
} |
||||
|
||||
@migration(2, 9, |
||||
"This scanRight definition has changed in 2.9.\n" + |
||||
"The previous behavior can be reproduced with scanRight.reverse." |
||||
) |
||||
def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
var scanned = List(z) |
||||
var acc = z |
||||
for (x <- reversed) { |
||||
acc = op(x, acc) |
||||
scanned ::= acc |
||||
} |
||||
val b = bf(repr) |
||||
for (elem <- scanned) b += elem |
||||
b.result |
||||
} |
||||
|
||||
/** Selects the first element of this $coll. |
||||
* $orderDependent |
||||
* @return the first element of this $coll. |
||||
* @throws `NoSuchElementException` if the $coll is empty. |
||||
*/ |
||||
def head: A = { |
||||
var result: () => A = () => throw new NoSuchElementException |
||||
breakable { |
||||
for (x <- this) { |
||||
result = () => x |
||||
break |
||||
} |
||||
} |
||||
result() |
||||
} |
||||
|
||||
/** Optionally selects the first element. |
||||
* $orderDependent |
||||
* @return the first element of this $coll if it is nonempty, `None` if it is empty. |
||||
*/ |
||||
def headOption: Option[A] = if (isEmpty) None else Some(head) |
||||
|
||||
/** Selects all elements except the first. |
||||
* $orderDependent |
||||
* @return a $coll consisting of all elements of this $coll |
||||
* except the first one. |
||||
* @throws `UnsupportedOperationException` if the $coll is empty. |
||||
*/ |
||||
override def tail: Repr = { |
||||
if (isEmpty) throw new UnsupportedOperationException("empty.tail") |
||||
drop(1) |
||||
} |
||||
|
||||
/** Selects the last element. |
||||
* $orderDependent |
||||
* @return The last element of this $coll. |
||||
* @throws NoSuchElementException If the $coll is empty. |
||||
*/ |
||||
def last: A = { |
||||
var lst = head |
||||
for (x <- this) |
||||
lst = x |
||||
lst |
||||
} |
||||
|
||||
/** Optionally selects the last element. |
||||
* $orderDependent |
||||
* @return the last element of this $coll$ if it is nonempty, `None` if it is empty. |
||||
*/ |
||||
def lastOption: Option[A] = if (isEmpty) None else Some(last) |
||||
|
||||
/** Selects all elements except the last. |
||||
* $orderDependent |
||||
* @return a $coll consisting of all elements of this $coll |
||||
* except the last one. |
||||
* @throws `UnsupportedOperationException` if the $coll is empty. |
||||
*/ |
||||
def init: Repr = { |
||||
if (isEmpty) throw new UnsupportedOperationException("empty.init") |
||||
var lst = head |
||||
var follow = false |
||||
val b = newBuilder |
||||
b.sizeHint(this, -1) |
||||
for (x <- this.seq) { |
||||
if (follow) b += lst |
||||
else follow = true |
||||
lst = x |
||||
} |
||||
b.result |
||||
} |
||||
|
||||
def take(n: Int): Repr = slice(0, n) |
||||
|
||||
def drop(n: Int): Repr = |
||||
if (n <= 0) { |
||||
val b = newBuilder |
||||
b.sizeHint(this) |
||||
b ++= thisCollection result |
||||
} |
||||
else sliceWithKnownDelta(n, Int.MaxValue, -n) |
||||
|
||||
def slice(from: Int, until: Int): Repr = sliceWithKnownBound(math.max(from, 0), until) |
||||
|
||||
// Precondition: from >= 0, until > 0, builder already configured for building. |
||||
private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = { |
||||
var i = 0 |
||||
breakable { |
||||
for (x <- this.seq) { |
||||
if (i >= from) b += x |
||||
i += 1 |
||||
if (i >= until) break |
||||
} |
||||
} |
||||
b.result |
||||
} |
||||
// Precondition: from >= 0 |
||||
private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr = { |
||||
val b = newBuilder |
||||
if (until <= from) b.result |
||||
else { |
||||
b.sizeHint(this, delta) |
||||
sliceInternal(from, until, b) |
||||
} |
||||
} |
||||
// Precondition: from >= 0 |
||||
private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr = { |
||||
val b = newBuilder |
||||
if (until <= from) b.result |
||||
else { |
||||
b.sizeHintBounded(until - from, this) |
||||
sliceInternal(from, until, b) |
||||
} |
||||
} |
||||
|
||||
def takeWhile(p: A => Boolean): Repr = { |
||||
val b = newBuilder |
||||
breakable { |
||||
for (x <- this) { |
||||
if (!p(x)) break |
||||
b += x |
||||
} |
||||
} |
||||
b.result |
||||
} |
||||
|
||||
def dropWhile(p: A => Boolean): Repr = { |
||||
val b = newBuilder |
||||
var go = false |
||||
for (x <- this) { |
||||
if (!p(x)) go = true |
||||
if (go) b += x |
||||
} |
||||
b.result |
||||
} |
||||
|
||||
def span(p: A => Boolean): (Repr, Repr) = { |
||||
val l, r = newBuilder |
||||
var toLeft = true |
||||
for (x <- this) { |
||||
toLeft = toLeft && p(x) |
||||
(if (toLeft) l else r) += x |
||||
} |
||||
(l.result, r.result) |
||||
} |
||||
|
||||
def splitAt(n: Int): (Repr, Repr) = { |
||||
val l, r = newBuilder |
||||
l.sizeHintBounded(n, this) |
||||
if (n >= 0) r.sizeHint(this, -n) |
||||
var i = 0 |
||||
for (x <- this) { |
||||
(if (i < n) l else r) += x |
||||
i += 1 |
||||
} |
||||
(l.result, r.result) |
||||
} |
||||
|
||||
/** Iterates over the tails of this $coll. The first value will be this |
||||
* $coll and the final one will be an empty $coll, with the intervening |
||||
* values the results of successive applications of `tail`. |
||||
* |
||||
* @return an iterator over all the tails of this $coll |
||||
* @example `List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)` |
||||
*/ |
||||
def tails: Iterator[Repr] = iterateUntilEmpty(_.tail) |
||||
|
||||
/** Iterates over the inits of this $coll. The first value will be this |
||||
* $coll and the final one will be an empty $coll, with the intervening |
||||
* values the results of successive applications of `init`. |
||||
* |
||||
* @return an iterator over all the inits of this $coll |
||||
* @example `List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)` |
||||
*/ |
||||
def inits: Iterator[Repr] = iterateUntilEmpty(_.init) |
||||
|
||||
/** Copies elements of this $coll to an array. |
||||
* Fills the given array `xs` with at most `len` elements of |
||||
* this $coll, starting at position `start`. |
||||
* Copying will stop once either the end of the current $coll is reached, |
||||
* or the end of the array is reached, or `len` elements have been copied. |
||||
* |
||||
* $willNotTerminateInf |
||||
* |
||||
* @param xs the array to fill. |
||||
* @param start the starting index. |
||||
* @param len the maximal number of elements to copy. |
||||
* @tparam B the type of the elements of the array. |
||||
* |
||||
* |
||||
* @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit |
||||
*/ |
||||
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) { |
||||
var i = start |
||||
val end = (start + len) min xs.length |
||||
breakable { |
||||
for (x <- this) { |
||||
if (i >= end) break |
||||
xs(i) = x |
||||
i += 1 |
||||
} |
||||
} |
||||
} |
||||
|
||||
def toTraversable: Traversable[A] = thisCollection |
||||
def toIterator: Iterator[A] = toStream.iterator |
||||
def toStream: Stream[A] = toBuffer.toStream |
||||
|
||||
/** Converts this $coll to a string. |
||||
* |
||||
* @return a string representation of this collection. By default this |
||||
* string consists of the `stringPrefix` of this $coll, |
||||
* followed by all elements separated by commas and enclosed in parentheses. |
||||
*/ |
||||
override def toString = mkString(stringPrefix + "(", ", ", ")") |
||||
|
||||
/** Defines the prefix of this object's `toString` representation. |
||||
* |
||||
* @return a string representation which starts the result of `toString` |
||||
* applied to this $coll. By default the string prefix is the |
||||
* simple name of the collection class $coll. |
||||
*/ |
||||
def stringPrefix : String = { |
||||
var string = repr.asInstanceOf[AnyRef].getClass.getName |
||||
val idx1 = string.lastIndexOf('.' : Int) |
||||
if (idx1 != -1) string = string.substring(idx1 + 1) |
||||
val idx2 = string.indexOf('$') |
||||
if (idx2 != -1) string = string.substring(0, idx2) |
||||
string |
||||
} |
||||
|
||||
/** Creates a non-strict view of this $coll. |
||||
* |
||||
* @return a non-strict view of this $coll. |
||||
*/ |
||||
def view = new TraversableView[A, Repr] { |
||||
protected lazy val underlying = self.repr |
||||
override def foreach[U](f: A => U) = self foreach f |
||||
} |
||||
|
||||
/** Creates a non-strict view of a slice of this $coll. |
||||
* |
||||
* Note: the difference between `view` and `slice` is that `view` produces |
||||
* a view of the current $coll, whereas `slice` produces a new $coll. |
||||
* |
||||
* Note: `view(from, to)` is equivalent to `view.slice(from, to)` |
||||
* $orderDependent |
||||
* |
||||
* @param from the index of the first element of the view |
||||
* @param until the index of the element following the view |
||||
* @return a non-strict view of a slice of this $coll, starting at index `from` |
||||
* and extending up to (but not including) index `until`. |
||||
*/ |
||||
def view(from: Int, until: Int): TraversableView[A, Repr] = view.slice(from, until) |
||||
|
||||
/** Creates a non-strict filter of this $coll. |
||||
* |
||||
* Note: the difference between `c filter p` and `c withFilter p` is that |
||||
* the former creates a new collection, whereas the latter only |
||||
* restricts the domain of subsequent `map`, `flatMap`, `foreach`, |
||||
* and `withFilter` operations. |
||||
* $orderDependent |
||||
* |
||||
* @param p the predicate used to test elements. |
||||
* @return an object of class `WithFilter`, which supports |
||||
* `map`, `flatMap`, `foreach`, and `withFilter` operations. |
||||
* All these operations apply to those elements of this $coll which |
||||
* satisfy the predicate `p`. |
||||
*/ |
||||
def withFilter(p: A => Boolean): FilterMonadic[A, Repr] = new WithFilter(p) |
||||
|
||||
/** A class supporting filtered operations. Instances of this class are |
||||
* returned by method `withFilter`. |
||||
*/ |
||||
class WithFilter(p: A => Boolean) extends FilterMonadic[A, Repr] { |
||||
|
||||
/** Builds a new collection by applying a function to all elements of the |
||||
* outer $coll containing this `WithFilter` instance that satisfy predicate `p`. |
||||
* |
||||
* @param f the function to apply to each element. |
||||
* @tparam B the element type of the returned collection. |
||||
* @tparam That $thatinfo |
||||
* @param bf $bfinfo |
||||
* @return a new collection of type `That` resulting from applying |
||||
* the given function `f` to each element of the outer $coll |
||||
* that satisfies predicate `p` and collecting the results. |
||||
* |
||||
* @usecase def map[B](f: A => B): $Coll[B] |
||||
* |
||||
* @return a new $coll resulting from applying the given function |
||||
* `f` to each element of the outer $coll that satisfies |
||||
* predicate `p` and collecting the results. |
||||
*/ |
||||
def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
for (x <- self) |
||||
if (p(x)) b += f(x) |
||||
b.result |
||||
} |
||||
|
||||
/** Builds a new collection by applying a function to all elements of the |
||||
* outer $coll containing this `WithFilter` instance that satisfy |
||||
* predicate `p` and concatenating the results. |
||||
* |
||||
* @param f the function to apply to each element. |
||||
* @tparam B the element type of the returned collection. |
||||
* @tparam That $thatinfo |
||||
* @param bf $bfinfo |
||||
* @return a new collection of type `That` resulting from applying |
||||
* the given collection-valued function `f` to each element |
||||
* of the outer $coll that satisfies predicate `p` and |
||||
* concatenating the results. |
||||
* |
||||
* @usecase def flatMap[B](f: A => TraversableOnce[B]): $Coll[B] |
||||
* |
||||
* @return a new $coll resulting from applying the given collection-valued function |
||||
* `f` to each element of the outer $coll that satisfies predicate `p` and concatenating the results. |
||||
*/ |
||||
def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { |
||||
val b = bf(repr) |
||||
for (x <- self) |
||||
if (p(x)) b ++= f(x).seq |
||||
b.result |
||||
} |
||||
|
||||
/** Applies a function `f` to all elements of the outer $coll containing |
||||
* this `WithFilter` instance that satisfy predicate `p`. |
||||
* |
||||
* @param f the function that is applied for its side-effect to every element. |
||||
* The result of function `f` is discarded. |
||||
* |
||||
* @tparam U the type parameter describing the result of function `f`. |
||||
* This result will always be ignored. Typically `U` is `Unit`, |
||||
* but this is not necessary. |
||||
* |
||||
* @usecase def foreach(f: A => Unit): Unit |
||||
*/ |
||||
def foreach[U](f: A => U): Unit = |
||||
for (x <- self) |
||||
if (p(x)) f(x) |
||||
|
||||
/** Further refines the filter for this $coll. |
||||
* |
||||
* @param q the predicate used to test elements. |
||||
* @return an object of class `WithFilter`, which supports |
||||
* `map`, `flatMap`, `foreach`, and `withFilter` operations. |
||||
* All these operations apply to those elements of this $coll which |
||||
* satisfy the predicate `q` in addition to the predicate `p`. |
||||
*/ |
||||
def withFilter(q: A => Boolean): WithFilter = |
||||
new WithFilter(x => p(x) && q(x)) |
||||
} |
||||
|
||||
// A helper for tails and inits. |
||||
private def iterateUntilEmpty(f: Traversable[A @uV] => Traversable[A @uV]): Iterator[Repr] = { |
||||
val it = Iterator.iterate(thisCollection)(f) takeWhile (x => !x.isEmpty) |
||||
it ++ Iterator(Nil) map (newBuilder ++= _ result) |
||||
} |
||||
} |
||||
|
||||
|
||||
</textarea> |
||||
</form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
theme: "ambiance", |
||||
mode: "text/x-scala" |
||||
}); |
||||
</script> |
||||
</article> |
||||
@ -0,0 +1,55 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-c"); |
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } |
||||
|
||||
MT("indent", |
||||
"[variable-3 void] [def foo]([variable-3 void*] [variable a], [variable-3 int] [variable b]) {", |
||||
" [variable-3 int] [variable c] [operator =] [variable b] [operator +]", |
||||
" [number 1];", |
||||
" [keyword return] [operator *][variable a];", |
||||
"}"); |
||||
|
||||
MT("indent_switch", |
||||
"[keyword switch] ([variable x]) {", |
||||
" [keyword case] [number 10]:", |
||||
" [keyword return] [number 20];", |
||||
" [keyword default]:", |
||||
" [variable printf]([string \"foo %c\"], [variable x]);", |
||||
"}"); |
||||
|
||||
MT("def", |
||||
"[variable-3 void] [def foo]() {}", |
||||
"[keyword struct] [def bar]{}", |
||||
"[variable-3 int] [variable-3 *][def baz]() {}"); |
||||
|
||||
MT("def_new_line", |
||||
"::[variable std]::[variable SomeTerribleType][operator <][variable T][operator >]", |
||||
"[def SomeLongMethodNameThatDoesntFitIntoOneLine]([keyword const] [variable MyType][operator &] [variable param]) {}") |
||||
|
||||
MT("double_block", |
||||
"[keyword for] (;;)", |
||||
" [keyword for] (;;)", |
||||
" [variable x][operator ++];", |
||||
"[keyword return];"); |
||||
|
||||
MT("preprocessor", |
||||
"[meta #define FOO 3]", |
||||
"[variable-3 int] [variable foo];", |
||||
"[meta #define BAR\\]", |
||||
"[meta 4]", |
||||
"[variable-3 unsigned] [variable-3 int] [variable bar] [operator =] [number 8];", |
||||
"[meta #include <baz> ][comment // comment]") |
||||
|
||||
|
||||
var mode_cpp = CodeMirror.getMode({indentUnit: 2}, "text/x-c++src"); |
||||
function MTCPP(name) { test.mode(name, mode_cpp, Array.prototype.slice.call(arguments, 1)); } |
||||
|
||||
MTCPP("cpp14_literal", |
||||
"[number 10'000];", |
||||
"[number 0b10'000];", |
||||
"[number 0x10'000];", |
||||
"[string '100000'];"); |
||||
})(); |
||||
@ -0,0 +1,306 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
/** |
||||
* Author: Hans Engel |
||||
* Branched from CodeMirror's Scheme mode (by Koh Zi Han, based on implementation by Koh Zi Chun) |
||||
*/ |
||||
|
||||
(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.defineMode("clojure", function (options) { |
||||
var BUILTIN = "builtin", COMMENT = "comment", STRING = "string", CHARACTER = "string-2", |
||||
ATOM = "atom", NUMBER = "number", BRACKET = "bracket", KEYWORD = "keyword", VAR = "variable"; |
||||
var INDENT_WORD_SKIP = options.indentUnit || 2; |
||||
var NORMAL_INDENT_UNIT = options.indentUnit || 2; |
||||
|
||||
function makeKeywords(str) { |
||||
var obj = {}, words = str.split(" "); |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
|
||||
var atoms = makeKeywords("true false nil"); |
||||
|
||||
var keywords = makeKeywords( |
||||
"defn defn- def def- defonce defmulti defmethod defmacro defstruct deftype defprotocol defrecord defproject deftest " + |
||||
"slice defalias defhinted defmacro- defn-memo defnk defnk defonce- defunbound defunbound- defvar defvar- let letfn " + |
||||
"do case cond condp for loop recur when when-not when-let when-first if if-let if-not . .. -> ->> doto and or dosync " + |
||||
"doseq dotimes dorun doall load import unimport ns in-ns refer try catch finally throw with-open with-local-vars " + |
||||
"binding gen-class gen-and-load-class gen-and-save-class handler-case handle"); |
||||
|
||||
var builtins = makeKeywords( |
||||
"* *' *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* " + |
||||
"*compile-path* *compiler-options* *data-readers* *e *err* *file* *flush-on-newline* *fn-loader* *in* " + |
||||
"*math-context* *ns* *out* *print-dup* *print-length* *print-level* *print-meta* *print-readably* *read-eval* " + |
||||
"*source-path* *unchecked-math* *use-context-classloader* *verbose-defrecords* *warn-on-reflection* + +' - -' -> " + |
||||
"->> ->ArrayChunk ->Vec ->VecNode ->VecSeq -cache-protocol-fn -reset-methods .. / < <= = == > >= EMPTY-NODE accessor " + |
||||
"aclone add-classpath add-watch agent agent-error agent-errors aget alength alias all-ns alter alter-meta! " + |
||||
"alter-var-root amap ancestors and apply areduce array-map aset aset-boolean aset-byte aset-char aset-double " + |
||||
"aset-float aset-int aset-long aset-short assert assoc assoc! assoc-in associative? atom await await-for await1 " + |
||||
"bases bean bigdec bigint biginteger binding bit-and bit-and-not bit-clear bit-flip bit-not bit-or bit-set " + |
||||
"bit-shift-left bit-shift-right bit-test bit-xor boolean boolean-array booleans bound-fn bound-fn* bound? butlast " + |
||||
"byte byte-array bytes case cat cast char char-array char-escape-string char-name-string char? chars chunk chunk-append " + |
||||
"chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? class class? clear-agent-errors " + |
||||
"clojure-version coll? comment commute comp comparator compare compare-and-set! compile complement completing concat cond condp " + |
||||
"conj conj! cons constantly construct-proxy contains? count counted? create-ns create-struct cycle dec dec' decimal? " + |
||||
"declare dedupe default-data-readers definline definterface defmacro defmethod defmulti defn defn- defonce defprotocol " + |
||||
"defrecord defstruct deftype delay delay? deliver denominator deref derive descendants destructure disj disj! dissoc " + |
||||
"dissoc! distinct distinct? doall dorun doseq dosync dotimes doto double double-array doubles drop drop-last " + |
||||
"drop-while eduction empty empty? ensure enumeration-seq error-handler error-mode eval even? every-pred every? ex-data ex-info " + |
||||
"extend extend-protocol extend-type extenders extends? false? ffirst file-seq filter filterv find find-keyword " + |
||||
"find-ns find-protocol-impl find-protocol-method find-var first flatten float float-array float? floats flush fn fn? " + |
||||
"fnext fnil for force format frequencies future future-call future-cancel future-cancelled? future-done? future? " + |
||||
"gen-class gen-interface gensym get get-in get-method get-proxy-class get-thread-bindings get-validator group-by hash " + |
||||
"hash-combine hash-map hash-set identical? identity if-let if-not ifn? import in-ns inc inc' init-proxy instance? " + |
||||
"int int-array integer? interleave intern interpose into into-array ints io! isa? iterate iterator-seq juxt keep " + |
||||
"keep-indexed key keys keyword keyword? last lazy-cat lazy-seq let letfn line-seq list list* list? load load-file " + |
||||
"load-reader load-string loaded-libs locking long long-array longs loop macroexpand macroexpand-1 make-array " + |
||||
"make-hierarchy map map-indexed map? mapcat mapv max max-key memfn memoize merge merge-with meta method-sig methods " + |
||||
"min min-key mod munge name namespace namespace-munge neg? newline next nfirst nil? nnext not not-any? not-empty " + |
||||
"not-every? not= ns ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ns-refers ns-resolve ns-unalias " + |
||||
"ns-unmap nth nthnext nthrest num number? numerator object-array odd? or parents partial partition partition-all " + |
||||
"partition-by pcalls peek persistent! pmap pop pop! pop-thread-bindings pos? pr pr-str prefer-method prefers " + |
||||
"primitives-classnames print print-ctor print-dup print-method print-simple print-str printf println println-str " + |
||||
"prn prn-str promise proxy proxy-call-with-super proxy-mappings proxy-name proxy-super push-thread-bindings pvalues " + |
||||
"quot rand rand-int rand-nth random-sample range ratio? rational? rationalize re-find re-groups re-matcher re-matches re-pattern " + |
||||
"re-seq read read-line read-string realized? reduce reduce-kv reductions ref ref-history-count ref-max-history " + |
||||
"ref-min-history ref-set refer refer-clojure reify release-pending-sends rem remove remove-all-methods " + |
||||
"remove-method remove-ns remove-watch repeat repeatedly replace replicate require reset! reset-meta! resolve rest " + |
||||
"restart-agent resultset-seq reverse reversible? rseq rsubseq satisfies? second select-keys send send-off seq seq? " + |
||||
"seque sequence sequential? set set-error-handler! set-error-mode! set-validator! set? short short-array shorts " + |
||||
"shuffle shutdown-agents slurp some some-fn sort sort-by sorted-map sorted-map-by sorted-set sorted-set-by sorted? " + |
||||
"special-symbol? spit split-at split-with str string? struct struct-map subs subseq subvec supers swap! symbol " + |
||||
"symbol? sync take take-last take-nth take-while test the-ns thread-bound? time to-array to-array-2d trampoline transduce " + |
||||
"transient tree-seq true? type unchecked-add unchecked-add-int unchecked-byte unchecked-char unchecked-dec " + |
||||
"unchecked-dec-int unchecked-divide-int unchecked-double unchecked-float unchecked-inc unchecked-inc-int " + |
||||
"unchecked-int unchecked-long unchecked-multiply unchecked-multiply-int unchecked-negate unchecked-negate-int "+ |
||||
"unchecked-remainder-int unchecked-short unchecked-subtract unchecked-subtract-int underive unquote " + |
||||
"unquote-splicing update update-in update-proxy use val vals var-get var-set var? vary-meta vec vector vector-of " + |
||||
"vector? volatile! volatile? vreset! vswap! when when-first when-let when-not while with-bindings with-bindings* with-in-str with-loading-context " + |
||||
"with-local-vars with-meta with-open with-out-str with-precision with-redefs with-redefs-fn xml-seq zero? zipmap " + |
||||
"*default-data-reader-fn* as-> cond-> cond->> reduced reduced? send-via set-agent-send-executor! " + |
||||
"set-agent-send-off-executor! some-> some->>"); |
||||
|
||||
var indentKeys = makeKeywords( |
||||
// Built-ins
|
||||
"ns fn def defn defmethod bound-fn if if-not case condp when while when-not when-first do future comment doto " + |
||||
"locking proxy with-open with-precision reify deftype defrecord defprotocol extend extend-protocol extend-type " + |
||||
"try catch " + |
||||
|
||||
// Binding forms
|
||||
"let letfn binding loop for doseq dotimes when-let if-let " + |
||||
|
||||
// Data structures
|
||||
"defstruct struct-map assoc " + |
||||
|
||||
// clojure.test
|
||||
"testing deftest " + |
||||
|
||||
// contrib
|
||||
"handler-case handle dotrace deftrace"); |
||||
|
||||
var tests = { |
||||
digit: /\d/, |
||||
digit_or_colon: /[\d:]/, |
||||
hex: /[0-9a-f]/i, |
||||
sign: /[+-]/, |
||||
exponent: /e/i, |
||||
keyword_char: /[^\s\(\[\;\)\]]/, |
||||
symbol: /[\w*+!\-\._?:<>\/\xa1-\uffff]/, |
||||
block_indent: /^(?:def|with)[^\/]+$|\/(?:def|with)/ |
||||
}; |
||||
|
||||
function stateStack(indent, type, prev) { // represents a state stack object
|
||||
this.indent = indent; |
||||
this.type = type; |
||||
this.prev = prev; |
||||
} |
||||
|
||||
function pushStack(state, indent, type) { |
||||
state.indentStack = new stateStack(indent, type, state.indentStack); |
||||
} |
||||
|
||||
function popStack(state) { |
||||
state.indentStack = state.indentStack.prev; |
||||
} |
||||
|
||||
function isNumber(ch, stream){ |
||||
// hex
|
||||
if ( ch === '0' && stream.eat(/x/i) ) { |
||||
stream.eatWhile(tests.hex); |
||||
return true; |
||||
} |
||||
|
||||
// leading sign
|
||||
if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) { |
||||
stream.eat(tests.sign); |
||||
ch = stream.next(); |
||||
} |
||||
|
||||
if ( tests.digit.test(ch) ) { |
||||
stream.eat(ch); |
||||
stream.eatWhile(tests.digit); |
||||
|
||||
if ( '.' == stream.peek() ) { |
||||
stream.eat('.'); |
||||
stream.eatWhile(tests.digit); |
||||
} else if ('/' == stream.peek() ) { |
||||
stream.eat('/'); |
||||
stream.eatWhile(tests.digit); |
||||
} |
||||
|
||||
if ( stream.eat(tests.exponent) ) { |
||||
stream.eat(tests.sign); |
||||
stream.eatWhile(tests.digit); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
// Eat character that starts after backslash \
|
||||
function eatCharacter(stream) { |
||||
var first = stream.next(); |
||||
// Read special literals: backspace, newline, space, return.
|
||||
// Just read all lowercase letters.
|
||||
if (first && first.match(/[a-z]/) && stream.match(/[a-z]+/, true)) { |
||||
return; |
||||
} |
||||
// Read unicode character: \u1000 \uA0a1
|
||||
if (first === "u") { |
||||
stream.match(/[0-9a-z]{4}/i, true); |
||||
} |
||||
} |
||||
|
||||
return { |
||||
startState: function () { |
||||
return { |
||||
indentStack: null, |
||||
indentation: 0, |
||||
mode: false |
||||
}; |
||||
}, |
||||
|
||||
token: function (stream, state) { |
||||
if (state.indentStack == null && stream.sol()) { |
||||
// update indentation, but only if indentStack is empty
|
||||
state.indentation = stream.indentation(); |
||||
} |
||||
|
||||
// skip spaces
|
||||
if (state.mode != "string" && stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
var returnType = null; |
||||
|
||||
switch(state.mode){ |
||||
case "string": // multi-line string parsing mode
|
||||
var next, escaped = false; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == "\"" && !escaped) { |
||||
|
||||
state.mode = false; |
||||
break; |
||||
} |
||||
escaped = !escaped && next == "\\"; |
||||
} |
||||
returnType = STRING; // continue on in string mode
|
||||
break; |
||||
default: // default parsing mode
|
||||
var ch = stream.next(); |
||||
|
||||
if (ch == "\"") { |
||||
state.mode = "string"; |
||||
returnType = STRING; |
||||
} else if (ch == "\\") { |
||||
eatCharacter(stream); |
||||
returnType = CHARACTER; |
||||
} else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) { |
||||
returnType = ATOM; |
||||
} else if (ch == ";") { // comment
|
||||
stream.skipToEnd(); // rest of the line is a comment
|
||||
returnType = COMMENT; |
||||
} else if (isNumber(ch,stream)){ |
||||
returnType = NUMBER; |
||||
} else if (ch == "(" || ch == "[" || ch == "{" ) { |
||||
var keyWord = '', indentTemp = stream.column(), letter; |
||||
/** |
||||
Either |
||||
(indent-word .. |
||||
(non-indent-word .. |
||||
(;something else, bracket, etc. |
||||
*/ |
||||
|
||||
if (ch == "(") while ((letter = stream.eat(tests.keyword_char)) != null) { |
||||
keyWord += letter; |
||||
} |
||||
|
||||
if (keyWord.length > 0 && (indentKeys.propertyIsEnumerable(keyWord) || |
||||
tests.block_indent.test(keyWord))) { // indent-word
|
||||
pushStack(state, indentTemp + INDENT_WORD_SKIP, ch); |
||||
} else { // non-indent word
|
||||
// we continue eating the spaces
|
||||
stream.eatSpace(); |
||||
if (stream.eol() || stream.peek() == ";") { |
||||
// nothing significant after
|
||||
// we restart indentation the user defined spaces after
|
||||
pushStack(state, indentTemp + NORMAL_INDENT_UNIT, ch); |
||||
} else { |
||||
pushStack(state, indentTemp + stream.current().length, ch); // else we match
|
||||
} |
||||
} |
||||
stream.backUp(stream.current().length - 1); // undo all the eating
|
||||
|
||||
returnType = BRACKET; |
||||
} else if (ch == ")" || ch == "]" || ch == "}") { |
||||
returnType = BRACKET; |
||||
if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : (ch == "]" ? "[" :"{"))) { |
||||
popStack(state); |
||||
} |
||||
} else if ( ch == ":" ) { |
||||
stream.eatWhile(tests.symbol); |
||||
return ATOM; |
||||
} else { |
||||
stream.eatWhile(tests.symbol); |
||||
|
||||
if (keywords && keywords.propertyIsEnumerable(stream.current())) { |
||||
returnType = KEYWORD; |
||||
} else if (builtins && builtins.propertyIsEnumerable(stream.current())) { |
||||
returnType = BUILTIN; |
||||
} else if (atoms && atoms.propertyIsEnumerable(stream.current())) { |
||||
returnType = ATOM; |
||||
} else { |
||||
returnType = VAR; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return returnType; |
||||
}, |
||||
|
||||
indent: function (state) { |
||||
if (state.indentStack == null) return state.indentation; |
||||
return state.indentStack.indent; |
||||
}, |
||||
|
||||
closeBrackets: {pairs: "()[]{}\"\""}, |
||||
lineComment: ";;" |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-clojure", "clojure"); |
||||
CodeMirror.defineMIME("text/x-clojurescript", "clojure"); |
||||
CodeMirror.defineMIME("application/edn", "clojure"); |
||||
|
||||
}); |
||||
@ -0,0 +1,91 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Clojure mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="clojure.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Clojure</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Clojure mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
; Conway's Game of Life, based on the work of: |
||||
;; Laurent Petit https://gist.github.com/1200343 |
||||
;; Christophe Grand http://clj-me.cgrand.net/2011/08/19/conways-game-of-life |
||||
|
||||
(ns ^{:doc "Conway's Game of Life."} |
||||
game-of-life) |
||||
|
||||
;; Core game of life's algorithm functions |
||||
|
||||
(defn neighbours |
||||
"Given a cell's coordinates, returns the coordinates of its neighbours." |
||||
[[x y]] |
||||
(for [dx [-1 0 1] dy (if (zero? dx) [-1 1] [-1 0 1])] |
||||
[(+ dx x) (+ dy y)])) |
||||
|
||||
(defn step |
||||
"Given a set of living cells, computes the new set of living cells." |
||||
[cells] |
||||
(set (for [[cell n] (frequencies (mapcat neighbours cells)) |
||||
:when (or (= n 3) (and (= n 2) (cells cell)))] |
||||
cell))) |
||||
|
||||
;; Utility methods for displaying game on a text terminal |
||||
|
||||
(defn print-board |
||||
"Prints a board on *out*, representing a step in the game." |
||||
[board w h] |
||||
(doseq [x (range (inc w)) y (range (inc h))] |
||||
(if (= y 0) (print "\n")) |
||||
(print (if (board [x y]) "[X]" " . ")))) |
||||
|
||||
(defn display-grids |
||||
"Prints a squence of boards on *out*, representing several steps." |
||||
[grids w h] |
||||
(doseq [board grids] |
||||
(print-board board w h) |
||||
(print "\n"))) |
||||
|
||||
;; Launches an example board |
||||
|
||||
(def |
||||
^{:doc "board represents the initial set of living cells"} |
||||
board #{[2 1] [2 2] [2 3]}) |
||||
|
||||
(display-grids (take 3 (iterate step board)) 5 5) |
||||
|
||||
;; Let's play with characters |
||||
(println \1 \a \# \\ |
||||
\" \( \newline |
||||
\} \" \space |
||||
\tab \return \backspace |
||||
\u1000 \uAaAa \u9F9F) |
||||
|
||||
;; Let's play with numbers |
||||
(+ 1 -1 1/2 -1/2 -0.5 0.5) |
||||
|
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-clojure</code>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,97 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") |
||||
mod(require("../../lib/codemirror")); |
||||
else if (typeof define == "function" && define.amd) |
||||
define(["../../lib/codemirror"], mod); |
||||
else |
||||
mod(CodeMirror); |
||||
})(function(CodeMirror) { |
||||
"use strict"; |
||||
|
||||
CodeMirror.defineMode("cmake", function () { |
||||
var variable_regex = /({)?[a-zA-Z0-9_]+(})?/; |
||||
|
||||
function tokenString(stream, state) { |
||||
var current, prev, found_var = false; |
||||
while (!stream.eol() && (current = stream.next()) != state.pending) { |
||||
if (current === '$' && prev != '\\' && state.pending == '"') { |
||||
found_var = true; |
||||
break; |
||||
} |
||||
prev = current; |
||||
} |
||||
if (found_var) { |
||||
stream.backUp(1); |
||||
} |
||||
if (current == state.pending) { |
||||
state.continueString = false; |
||||
} else { |
||||
state.continueString = true; |
||||
} |
||||
return "string"; |
||||
} |
||||
|
||||
function tokenize(stream, state) { |
||||
var ch = stream.next(); |
||||
|
||||
// Have we found a variable?
|
||||
if (ch === '$') { |
||||
if (stream.match(variable_regex)) { |
||||
return 'variable-2'; |
||||
} |
||||
return 'variable'; |
||||
} |
||||
// Should we still be looking for the end of a string?
|
||||
if (state.continueString) { |
||||
// If so, go through the loop again
|
||||
stream.backUp(1); |
||||
return tokenString(stream, state); |
||||
} |
||||
// Do we just have a function on our hands?
|
||||
// In 'cmake_minimum_required (VERSION 2.8.8)', 'cmake_minimum_required' is matched
|
||||
if (stream.match(/(\s+)?\w+\(/) || stream.match(/(\s+)?\w+\ \(/)) { |
||||
stream.backUp(1); |
||||
return 'def'; |
||||
} |
||||
if (ch == "#") { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
// Have we found a string?
|
||||
if (ch == "'" || ch == '"') { |
||||
// Store the type (single or double)
|
||||
state.pending = ch; |
||||
// Perform the looping function to find the end
|
||||
return tokenString(stream, state); |
||||
} |
||||
if (ch == '(' || ch == ')') { |
||||
return 'bracket'; |
||||
} |
||||
if (ch.match(/[0-9]/)) { |
||||
return 'number'; |
||||
} |
||||
stream.eatWhile(/[\w-]/); |
||||
return null; |
||||
} |
||||
return { |
||||
startState: function () { |
||||
var state = {}; |
||||
state.inDefinition = false; |
||||
state.inInclude = false; |
||||
state.continueString = false; |
||||
state.pending = false; |
||||
return state; |
||||
}, |
||||
token: function (stream, state) { |
||||
if (stream.eatSpace()) return null; |
||||
return tokenize(stream, state); |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-cmake", "cmake"); |
||||
|
||||
}); |
||||
@ -0,0 +1,129 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: CMake mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="cmake.js"></script> |
||||
<style> |
||||
.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;} |
||||
.cm-s-default span.cm-arrow { color: red; } |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">CMake</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>CMake mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
# vim: syntax=cmake |
||||
if(NOT CMAKE_BUILD_TYPE) |
||||
# default to Release build for GCC builds |
||||
set(CMAKE_BUILD_TYPE Release CACHE STRING |
||||
"Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." |
||||
FORCE) |
||||
endif() |
||||
message(STATUS "cmake version ${CMAKE_VERSION}") |
||||
if(POLICY CMP0025) |
||||
cmake_policy(SET CMP0025 OLD) # report Apple's Clang as just Clang |
||||
endif() |
||||
if(POLICY CMP0042) |
||||
cmake_policy(SET CMP0042 NEW) # MACOSX_RPATH |
||||
endif() |
||||
|
||||
project (x265) |
||||
cmake_minimum_required (VERSION 2.8.8) # OBJECT libraries require 2.8.8 |
||||
include(CheckIncludeFiles) |
||||
include(CheckFunctionExists) |
||||
include(CheckSymbolExists) |
||||
include(CheckCXXCompilerFlag) |
||||
|
||||
# X265_BUILD must be incremented each time the public API is changed |
||||
set(X265_BUILD 48) |
||||
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in" |
||||
"${PROJECT_BINARY_DIR}/x265.def") |
||||
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in" |
||||
"${PROJECT_BINARY_DIR}/x265_config.h") |
||||
|
||||
SET(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}") |
||||
|
||||
# System architecture detection |
||||
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" SYSPROC) |
||||
set(X86_ALIASES x86 i386 i686 x86_64 amd64) |
||||
list(FIND X86_ALIASES "${SYSPROC}" X86MATCH) |
||||
if("${SYSPROC}" STREQUAL "" OR X86MATCH GREATER "-1") |
||||
message(STATUS "Detected x86 target processor") |
||||
set(X86 1) |
||||
add_definitions(-DX265_ARCH_X86=1) |
||||
if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8) |
||||
set(X64 1) |
||||
add_definitions(-DX86_64=1) |
||||
endif() |
||||
elseif(${SYSPROC} STREQUAL "armv6l") |
||||
message(STATUS "Detected ARM target processor") |
||||
set(ARM 1) |
||||
add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1) |
||||
else() |
||||
message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown") |
||||
message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}") |
||||
endif() |
||||
|
||||
if(UNIX) |
||||
list(APPEND PLATFORM_LIBS pthread) |
||||
find_library(LIBRT rt) |
||||
if(LIBRT) |
||||
list(APPEND PLATFORM_LIBS rt) |
||||
endif() |
||||
find_package(Numa) |
||||
if(NUMA_FOUND) |
||||
list(APPEND CMAKE_REQUIRED_LIBRARIES ${NUMA_LIBRARY}) |
||||
check_symbol_exists(numa_node_of_cpu numa.h NUMA_V2) |
||||
if(NUMA_V2) |
||||
add_definitions(-DHAVE_LIBNUMA) |
||||
message(STATUS "libnuma found, building with support for NUMA nodes") |
||||
list(APPEND PLATFORM_LIBS ${NUMA_LIBRARY}) |
||||
link_directories(${NUMA_LIBRARY_DIR}) |
||||
include_directories(${NUMA_INCLUDE_DIR}) |
||||
endif() |
||||
endif() |
||||
mark_as_advanced(LIBRT NUMA_FOUND) |
||||
endif(UNIX) |
||||
|
||||
if(X64 AND NOT WIN32) |
||||
option(ENABLE_PIC "Enable Position Independent Code" ON) |
||||
else() |
||||
option(ENABLE_PIC "Enable Position Independent Code" OFF) |
||||
endif(X64 AND NOT WIN32) |
||||
|
||||
# Compiler detection |
||||
if(CMAKE_GENERATOR STREQUAL "Xcode") |
||||
set(XCODE 1) |
||||
endif() |
||||
if (APPLE) |
||||
add_definitions(-DMACOS) |
||||
endif() |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
mode: "text/x-cmake", |
||||
matchBrackets: true, |
||||
indentUnit: 4 |
||||
}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-cmake</code>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,255 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
/** |
||||
* Author: Gautam Mehta |
||||
* Branched from CodeMirror's Scheme mode |
||||
*/ |
||||
(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.defineMode("cobol", function () { |
||||
var BUILTIN = "builtin", COMMENT = "comment", STRING = "string", |
||||
ATOM = "atom", NUMBER = "number", KEYWORD = "keyword", MODTAG = "header", |
||||
COBOLLINENUM = "def", PERIOD = "link"; |
||||
function makeKeywords(str) { |
||||
var obj = {}, words = str.split(" "); |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
var atoms = makeKeywords("TRUE FALSE ZEROES ZEROS ZERO SPACES SPACE LOW-VALUE LOW-VALUES "); |
||||
var keywords = makeKeywords( |
||||
"ACCEPT ACCESS ACQUIRE ADD ADDRESS " + |
||||
"ADVANCING AFTER ALIAS ALL ALPHABET " + |
||||
"ALPHABETIC ALPHABETIC-LOWER ALPHABETIC-UPPER ALPHANUMERIC ALPHANUMERIC-EDITED " + |
||||
"ALSO ALTER ALTERNATE AND ANY " + |
||||
"ARE AREA AREAS ARITHMETIC ASCENDING " + |
||||
"ASSIGN AT ATTRIBUTE AUTHOR AUTO " + |
||||
"AUTO-SKIP AUTOMATIC B-AND B-EXOR B-LESS " + |
||||
"B-NOT B-OR BACKGROUND-COLOR BACKGROUND-COLOUR BEEP " + |
||||
"BEFORE BELL BINARY BIT BITS " + |
||||
"BLANK BLINK BLOCK BOOLEAN BOTTOM " + |
||||
"BY CALL CANCEL CD CF " + |
||||
"CH CHARACTER CHARACTERS CLASS CLOCK-UNITS " + |
||||
"CLOSE COBOL CODE CODE-SET COL " + |
||||
"COLLATING COLUMN COMMA COMMIT COMMITMENT " + |
||||
"COMMON COMMUNICATION COMP COMP-0 COMP-1 " + |
||||
"COMP-2 COMP-3 COMP-4 COMP-5 COMP-6 " + |
||||
"COMP-7 COMP-8 COMP-9 COMPUTATIONAL COMPUTATIONAL-0 " + |
||||
"COMPUTATIONAL-1 COMPUTATIONAL-2 COMPUTATIONAL-3 COMPUTATIONAL-4 COMPUTATIONAL-5 " + |
||||
"COMPUTATIONAL-6 COMPUTATIONAL-7 COMPUTATIONAL-8 COMPUTATIONAL-9 COMPUTE " + |
||||
"CONFIGURATION CONNECT CONSOLE CONTAINED CONTAINS " + |
||||
"CONTENT CONTINUE CONTROL CONTROL-AREA CONTROLS " + |
||||
"CONVERTING COPY CORR CORRESPONDING COUNT " + |
||||
"CRT CRT-UNDER CURRENCY CURRENT CURSOR " + |
||||
"DATA DATE DATE-COMPILED DATE-WRITTEN DAY " + |
||||
"DAY-OF-WEEK DB DB-ACCESS-CONTROL-KEY DB-DATA-NAME DB-EXCEPTION " + |
||||
"DB-FORMAT-NAME DB-RECORD-NAME DB-SET-NAME DB-STATUS DBCS " + |
||||
"DBCS-EDITED DE DEBUG-CONTENTS DEBUG-ITEM DEBUG-LINE " + |
||||
"DEBUG-NAME DEBUG-SUB-1 DEBUG-SUB-2 DEBUG-SUB-3 DEBUGGING " + |
||||
"DECIMAL-POINT DECLARATIVES DEFAULT DELETE DELIMITED " + |
||||
"DELIMITER DEPENDING DESCENDING DESCRIBED DESTINATION " + |
||||
"DETAIL DISABLE DISCONNECT DISPLAY DISPLAY-1 " + |
||||
"DISPLAY-2 DISPLAY-3 DISPLAY-4 DISPLAY-5 DISPLAY-6 " + |
||||
"DISPLAY-7 DISPLAY-8 DISPLAY-9 DIVIDE DIVISION " + |
||||
"DOWN DROP DUPLICATE DUPLICATES DYNAMIC " + |
||||
"EBCDIC EGI EJECT ELSE EMI " + |
||||
"EMPTY EMPTY-CHECK ENABLE END END. END-ACCEPT END-ACCEPT. " + |
||||
"END-ADD END-CALL END-COMPUTE END-DELETE END-DISPLAY " + |
||||
"END-DIVIDE END-EVALUATE END-IF END-INVOKE END-MULTIPLY " + |
||||
"END-OF-PAGE END-PERFORM END-READ END-RECEIVE END-RETURN " + |
||||
"END-REWRITE END-SEARCH END-START END-STRING END-SUBTRACT " + |
||||
"END-UNSTRING END-WRITE END-XML ENTER ENTRY " + |
||||
"ENVIRONMENT EOP EQUAL EQUALS ERASE " + |
||||
"ERROR ESI EVALUATE EVERY EXCEEDS " + |
||||
"EXCEPTION EXCLUSIVE EXIT EXTEND EXTERNAL " + |
||||
"EXTERNALLY-DESCRIBED-KEY FD FETCH FILE FILE-CONTROL " + |
||||
"FILE-STREAM FILES FILLER FINAL FIND " + |
||||
"FINISH FIRST FOOTING FOR FOREGROUND-COLOR " + |
||||
"FOREGROUND-COLOUR FORMAT FREE FROM FULL " + |
||||
"FUNCTION GENERATE GET GIVING GLOBAL " + |
||||
"GO GOBACK GREATER GROUP HEADING " + |
||||
"HIGH-VALUE HIGH-VALUES HIGHLIGHT I-O I-O-CONTROL " + |
||||
"ID IDENTIFICATION IF IN INDEX " + |
||||
"INDEX-1 INDEX-2 INDEX-3 INDEX-4 INDEX-5 " + |
||||
"INDEX-6 INDEX-7 INDEX-8 INDEX-9 INDEXED " + |
||||
"INDIC INDICATE INDICATOR INDICATORS INITIAL " + |
||||
"INITIALIZE INITIATE INPUT INPUT-OUTPUT INSPECT " + |
||||
"INSTALLATION INTO INVALID INVOKE IS " + |
||||
"JUST JUSTIFIED KANJI KEEP KEY " + |
||||
"LABEL LAST LD LEADING LEFT " + |
||||
"LEFT-JUSTIFY LENGTH LENGTH-CHECK LESS LIBRARY " + |
||||
"LIKE LIMIT LIMITS LINAGE LINAGE-COUNTER " + |
||||
"LINE LINE-COUNTER LINES LINKAGE LOCAL-STORAGE " + |
||||
"LOCALE LOCALLY LOCK " + |
||||
"MEMBER MEMORY MERGE MESSAGE METACLASS " + |
||||
"MODE MODIFIED MODIFY MODULES MOVE " + |
||||
"MULTIPLE MULTIPLY NATIONAL NATIVE NEGATIVE " + |
||||
"NEXT NO NO-ECHO NONE NOT " + |
||||
"NULL NULL-KEY-MAP NULL-MAP NULLS NUMBER " + |
||||
"NUMERIC NUMERIC-EDITED OBJECT OBJECT-COMPUTER OCCURS " + |
||||
"OF OFF OMITTED ON ONLY " + |
||||
"OPEN OPTIONAL OR ORDER ORGANIZATION " + |
||||
"OTHER OUTPUT OVERFLOW OWNER PACKED-DECIMAL " + |
||||
"PADDING PAGE PAGE-COUNTER PARSE PERFORM " + |
||||
"PF PH PIC PICTURE PLUS " + |
||||
"POINTER POSITION POSITIVE PREFIX PRESENT " + |
||||
"PRINTING PRIOR PROCEDURE PROCEDURE-POINTER PROCEDURES " + |
||||
"PROCEED PROCESS PROCESSING PROGRAM PROGRAM-ID " + |
||||
"PROMPT PROTECTED PURGE QUEUE QUOTE " + |
||||
"QUOTES RANDOM RD READ READY " + |
||||
"REALM RECEIVE RECONNECT RECORD RECORD-NAME " + |
||||
"RECORDS RECURSIVE REDEFINES REEL REFERENCE " + |
||||
"REFERENCE-MONITOR REFERENCES RELATION RELATIVE RELEASE " + |
||||
"REMAINDER REMOVAL RENAMES REPEATED REPLACE " + |
||||
"REPLACING REPORT REPORTING REPORTS REPOSITORY " + |
||||
"REQUIRED RERUN RESERVE RESET RETAINING " + |
||||
"RETRIEVAL RETURN RETURN-CODE RETURNING REVERSE-VIDEO " + |
||||
"REVERSED REWIND REWRITE RF RH " + |
||||
"RIGHT RIGHT-JUSTIFY ROLLBACK ROLLING ROUNDED " + |
||||
"RUN SAME SCREEN SD SEARCH " + |
||||
"SECTION SECURE SECURITY SEGMENT SEGMENT-LIMIT " + |
||||
"SELECT SEND SENTENCE SEPARATE SEQUENCE " + |
||||
"SEQUENTIAL SET SHARED SIGN SIZE " + |
||||
"SKIP1 SKIP2 SKIP3 SORT SORT-MERGE " + |
||||
"SORT-RETURN SOURCE SOURCE-COMPUTER SPACE-FILL " + |
||||
"SPECIAL-NAMES STANDARD STANDARD-1 STANDARD-2 " + |
||||
"START STARTING STATUS STOP STORE " + |
||||
"STRING SUB-QUEUE-1 SUB-QUEUE-2 SUB-QUEUE-3 SUB-SCHEMA " + |
||||
"SUBFILE SUBSTITUTE SUBTRACT SUM SUPPRESS " + |
||||
"SYMBOLIC SYNC SYNCHRONIZED SYSIN SYSOUT " + |
||||
"TABLE TALLYING TAPE TENANT TERMINAL " + |
||||
"TERMINATE TEST TEXT THAN THEN " + |
||||
"THROUGH THRU TIME TIMES TITLE " + |
||||
"TO TOP TRAILING TRAILING-SIGN TRANSACTION " + |
||||
"TYPE TYPEDEF UNDERLINE UNEQUAL UNIT " + |
||||
"UNSTRING UNTIL UP UPDATE UPON " + |
||||
"USAGE USAGE-MODE USE USING VALID " + |
||||
"VALIDATE VALUE VALUES VARYING VLR " + |
||||
"WAIT WHEN WHEN-COMPILED WITH WITHIN " + |
||||
"WORDS WORKING-STORAGE WRITE XML XML-CODE " + |
||||
"XML-EVENT XML-NTEXT XML-TEXT ZERO ZERO-FILL " ); |
||||
|
||||
var builtins = makeKeywords("- * ** / + < <= = > >= "); |
||||
var tests = { |
||||
digit: /\d/, |
||||
digit_or_colon: /[\d:]/, |
||||
hex: /[0-9a-f]/i, |
||||
sign: /[+-]/, |
||||
exponent: /e/i, |
||||
keyword_char: /[^\s\(\[\;\)\]]/, |
||||
symbol: /[\w*+\-]/ |
||||
}; |
||||
function isNumber(ch, stream){ |
||||
// hex
|
||||
if ( ch === '0' && stream.eat(/x/i) ) { |
||||
stream.eatWhile(tests.hex); |
||||
return true; |
||||
} |
||||
// leading sign
|
||||
if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) { |
||||
stream.eat(tests.sign); |
||||
ch = stream.next(); |
||||
} |
||||
if ( tests.digit.test(ch) ) { |
||||
stream.eat(ch); |
||||
stream.eatWhile(tests.digit); |
||||
if ( '.' == stream.peek()) { |
||||
stream.eat('.'); |
||||
stream.eatWhile(tests.digit); |
||||
} |
||||
if ( stream.eat(tests.exponent) ) { |
||||
stream.eat(tests.sign); |
||||
stream.eatWhile(tests.digit); |
||||
} |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
return { |
||||
startState: function () { |
||||
return { |
||||
indentStack: null, |
||||
indentation: 0, |
||||
mode: false |
||||
}; |
||||
}, |
||||
token: function (stream, state) { |
||||
if (state.indentStack == null && stream.sol()) { |
||||
// update indentation, but only if indentStack is empty
|
||||
state.indentation = 6 ; //stream.indentation();
|
||||
} |
||||
// skip spaces
|
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
var returnType = null; |
||||
switch(state.mode){ |
||||
case "string": // multi-line string parsing mode
|
||||
var next = false; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == "\"" || next == "\'") { |
||||
state.mode = false; |
||||
break; |
||||
} |
||||
} |
||||
returnType = STRING; // continue on in string mode
|
||||
break; |
||||
default: // default parsing mode
|
||||
var ch = stream.next(); |
||||
var col = stream.column(); |
||||
if (col >= 0 && col <= 5) { |
||||
returnType = COBOLLINENUM; |
||||
} else if (col >= 72 && col <= 79) { |
||||
stream.skipToEnd(); |
||||
returnType = MODTAG; |
||||
} else if (ch == "*" && col == 6) { // comment
|
||||
stream.skipToEnd(); // rest of the line is a comment
|
||||
returnType = COMMENT; |
||||
} else if (ch == "\"" || ch == "\'") { |
||||
state.mode = "string"; |
||||
returnType = STRING; |
||||
} else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) { |
||||
returnType = ATOM; |
||||
} else if (ch == ".") { |
||||
returnType = PERIOD; |
||||
} else if (isNumber(ch,stream)){ |
||||
returnType = NUMBER; |
||||
} else { |
||||
if (stream.current().match(tests.symbol)) { |
||||
while (col < 71) { |
||||
if (stream.eat(tests.symbol) === undefined) { |
||||
break; |
||||
} else { |
||||
col++; |
||||
} |
||||
} |
||||
} |
||||
if (keywords && keywords.propertyIsEnumerable(stream.current().toUpperCase())) { |
||||
returnType = KEYWORD; |
||||
} else if (builtins && builtins.propertyIsEnumerable(stream.current().toUpperCase())) { |
||||
returnType = BUILTIN; |
||||
} else if (atoms && atoms.propertyIsEnumerable(stream.current().toUpperCase())) { |
||||
returnType = ATOM; |
||||
} else returnType = null; |
||||
} |
||||
} |
||||
return returnType; |
||||
}, |
||||
indent: function (state) { |
||||
if (state.indentStack == null) return state.indentation; |
||||
return state.indentStack.indent; |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-cobol", "cobol"); |
||||
|
||||
}); |
||||
@ -0,0 +1,210 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: COBOL mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<link rel="stylesheet" href="../../theme/neat.css"> |
||||
<link rel="stylesheet" href="../../theme/elegant.css"> |
||||
<link rel="stylesheet" href="../../theme/erlang-dark.css"> |
||||
<link rel="stylesheet" href="../../theme/night.css"> |
||||
<link rel="stylesheet" href="../../theme/monokai.css"> |
||||
<link rel="stylesheet" href="../../theme/cobalt.css"> |
||||
<link rel="stylesheet" href="../../theme/eclipse.css"> |
||||
<link rel="stylesheet" href="../../theme/rubyblue.css"> |
||||
<link rel="stylesheet" href="../../theme/lesser-dark.css"> |
||||
<link rel="stylesheet" href="../../theme/xq-dark.css"> |
||||
<link rel="stylesheet" href="../../theme/xq-light.css"> |
||||
<link rel="stylesheet" href="../../theme/ambiance.css"> |
||||
<link rel="stylesheet" href="../../theme/blackboard.css"> |
||||
<link rel="stylesheet" href="../../theme/vibrant-ink.css"> |
||||
<link rel="stylesheet" href="../../theme/solarized.css"> |
||||
<link rel="stylesheet" href="../../theme/twilight.css"> |
||||
<link rel="stylesheet" href="../../theme/midnight.css"> |
||||
<link rel="stylesheet" href="../../addon/dialog/dialog.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="cobol.js"></script> |
||||
<script src="../../addon/selection/active-line.js"></script> |
||||
<script src="../../addon/search/search.js"></script> |
||||
<script src="../../addon/dialog/dialog.js"></script> |
||||
<script src="../../addon/search/searchcursor.js"></script> |
||||
<style> |
||||
.CodeMirror { |
||||
border: 1px solid #eee; |
||||
font-size : 20px; |
||||
height : auto !important; |
||||
} |
||||
.CodeMirror-activeline-background {background: #555555 !important;} |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">COBOL</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>COBOL mode</h2> |
||||
|
||||
<p> Select Theme <select onchange="selectTheme()" id="selectTheme"> |
||||
<option>default</option> |
||||
<option>ambiance</option> |
||||
<option>blackboard</option> |
||||
<option>cobalt</option> |
||||
<option>eclipse</option> |
||||
<option>elegant</option> |
||||
<option>erlang-dark</option> |
||||
<option>lesser-dark</option> |
||||
<option>midnight</option> |
||||
<option>monokai</option> |
||||
<option>neat</option> |
||||
<option>night</option> |
||||
<option>rubyblue</option> |
||||
<option>solarized dark</option> |
||||
<option>solarized light</option> |
||||
<option selected>twilight</option> |
||||
<option>vibrant-ink</option> |
||||
<option>xq-dark</option> |
||||
<option>xq-light</option> |
||||
</select> Select Font Size <select onchange="selectFontsize()" id="selectFontSize"> |
||||
<option value="13px">13px</option> |
||||
<option value="14px">14px</option> |
||||
<option value="16px">16px</option> |
||||
<option value="18px">18px</option> |
||||
<option value="20px" selected="selected">20px</option> |
||||
<option value="24px">24px</option> |
||||
<option value="26px">26px</option> |
||||
<option value="28px">28px</option> |
||||
<option value="30px">30px</option> |
||||
<option value="32px">32px</option> |
||||
<option value="34px">34px</option> |
||||
<option value="36px">36px</option> |
||||
</select> |
||||
<label for="checkBoxReadOnly">Read-only</label> |
||||
<input type="checkbox" id="checkBoxReadOnly" onchange="selectReadOnly()"> |
||||
<label for="id_tabToIndentSpace">Insert Spaces on Tab</label> |
||||
<input type="checkbox" id="id_tabToIndentSpace" onchange="tabToIndentSpace()"> |
||||
</p> |
||||
<textarea id="code" name="code"> |
||||
---------1---------2---------3---------4---------5---------6---------7---------8 |
||||
12345678911234567892123456789312345678941234567895123456789612345678971234567898 |
||||
000010 IDENTIFICATION DIVISION. MODTGHERE |
||||
000020 PROGRAM-ID. SAMPLE. |
||||
000030 AUTHOR. TEST SAM. |
||||
000040 DATE-WRITTEN. 5 February 2013 |
||||
000041 |
||||
000042* A sample program just to show the form. |
||||
000043* The program copies its input to the output, |
||||
000044* and counts the number of records. |
||||
000045* At the end this number is printed. |
||||
000046 |
||||
000050 ENVIRONMENT DIVISION. |
||||
000060 INPUT-OUTPUT SECTION. |
||||
000070 FILE-CONTROL. |
||||
000080 SELECT STUDENT-FILE ASSIGN TO SYSIN |
||||
000090 ORGANIZATION IS LINE SEQUENTIAL. |
||||
000100 SELECT PRINT-FILE ASSIGN TO SYSOUT |
||||
000110 ORGANIZATION IS LINE SEQUENTIAL. |
||||
000120 |
||||
000130 DATA DIVISION. |
||||
000140 FILE SECTION. |
||||
000150 FD STUDENT-FILE |
||||
000160 RECORD CONTAINS 43 CHARACTERS |
||||
000170 DATA RECORD IS STUDENT-IN. |
||||
000180 01 STUDENT-IN PIC X(43). |
||||
000190 |
||||
000200 FD PRINT-FILE |
||||
000210 RECORD CONTAINS 80 CHARACTERS |
||||
000220 DATA RECORD IS PRINT-LINE. |
||||
000230 01 PRINT-LINE PIC X(80). |
||||
000240 |
||||
000250 WORKING-STORAGE SECTION. |
||||
000260 01 DATA-REMAINS-SWITCH PIC X(2) VALUE SPACES. |
||||
000261 01 RECORDS-WRITTEN PIC 99. |
||||
000270 |
||||
000280 01 DETAIL-LINE. |
||||
000290 05 FILLER PIC X(7) VALUE SPACES. |
||||
000300 05 RECORD-IMAGE PIC X(43). |
||||
000310 05 FILLER PIC X(30) VALUE SPACES. |
||||
000311 |
||||
000312 01 SUMMARY-LINE. |
||||
000313 05 FILLER PIC X(7) VALUE SPACES. |
||||
000314 05 TOTAL-READ PIC 99. |
||||
000315 05 FILLER PIC X VALUE SPACE. |
||||
000316 05 FILLER PIC X(17) |
||||
000317 VALUE 'Records were read'. |
||||
000318 05 FILLER PIC X(53) VALUE SPACES. |
||||
000319 |
||||
000320 PROCEDURE DIVISION. |
||||
000321 |
||||
000330 PREPARE-SENIOR-REPORT. |
||||
000340 OPEN INPUT STUDENT-FILE |
||||
000350 OUTPUT PRINT-FILE. |
||||
000351 MOVE ZERO TO RECORDS-WRITTEN. |
||||
000360 READ STUDENT-FILE |
||||
000370 AT END MOVE 'NO' TO DATA-REMAINS-SWITCH |
||||
000380 END-READ. |
||||
000390 PERFORM PROCESS-RECORDS |
||||
000410 UNTIL DATA-REMAINS-SWITCH = 'NO'. |
||||
000411 PERFORM PRINT-SUMMARY. |
||||
000420 CLOSE STUDENT-FILE |
||||
000430 PRINT-FILE. |
||||
000440 STOP RUN. |
||||
000450 |
||||
000460 PROCESS-RECORDS. |
||||
000470 MOVE STUDENT-IN TO RECORD-IMAGE. |
||||
000480 MOVE DETAIL-LINE TO PRINT-LINE. |
||||
000490 WRITE PRINT-LINE. |
||||
000500 ADD 1 TO RECORDS-WRITTEN. |
||||
000510 READ STUDENT-FILE |
||||
000520 AT END MOVE 'NO' TO DATA-REMAINS-SWITCH |
||||
000530 END-READ. |
||||
000540 |
||||
000550 PRINT-SUMMARY. |
||||
000560 MOVE RECORDS-WRITTEN TO TOTAL-READ. |
||||
000570 MOVE SUMMARY-LINE TO PRINT-LINE. |
||||
000571 WRITE PRINT-LINE. |
||||
000572 |
||||
000580 |
||||
</textarea> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-cobol", |
||||
theme : "twilight", |
||||
styleActiveLine: true, |
||||
showCursorWhenSelecting : true, |
||||
}); |
||||
function selectTheme() { |
||||
var themeInput = document.getElementById("selectTheme"); |
||||
var theme = themeInput.options[themeInput.selectedIndex].innerHTML; |
||||
editor.setOption("theme", theme); |
||||
} |
||||
function selectFontsize() { |
||||
var fontSizeInput = document.getElementById("selectFontSize"); |
||||
var fontSize = fontSizeInput.options[fontSizeInput.selectedIndex].innerHTML; |
||||
editor.getWrapperElement().style.fontSize = fontSize; |
||||
editor.refresh(); |
||||
} |
||||
function selectReadOnly() { |
||||
editor.setOption("readOnly", document.getElementById("checkBoxReadOnly").checked); |
||||
} |
||||
function tabToIndentSpace() { |
||||
if (document.getElementById("id_tabToIndentSpace").checked) { |
||||
editor.setOption("extraKeys", {Tab: function(cm) { cm.replaceSelection(" ", "end"); }}); |
||||
} else { |
||||
editor.setOption("extraKeys", {Tab: function(cm) { cm.replaceSelection(" ", "end"); }}); |
||||
} |
||||
} |
||||
</script> |
||||
</article> |
||||
@ -0,0 +1,355 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
/** |
||||
* Link to the project's GitHub page: |
||||
* https://github.com/pickhardt/coffeescript-codemirror-mode
|
||||
*/ |
||||
(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.defineMode("coffeescript", function(conf, parserConf) { |
||||
var ERRORCLASS = "error"; |
||||
|
||||
function wordRegexp(words) { |
||||
return new RegExp("^((" + words.join(")|(") + "))\\b"); |
||||
} |
||||
|
||||
var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/; |
||||
var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/; |
||||
var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/; |
||||
var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/; |
||||
|
||||
var wordOperators = wordRegexp(["and", "or", "not", |
||||
"is", "isnt", "in", |
||||
"instanceof", "typeof"]); |
||||
var indentKeywords = ["for", "while", "loop", "if", "unless", "else", |
||||
"switch", "try", "catch", "finally", "class"]; |
||||
var commonKeywords = ["break", "by", "continue", "debugger", "delete", |
||||
"do", "in", "of", "new", "return", "then", |
||||
"this", "@", "throw", "when", "until", "extends"]; |
||||
|
||||
var keywords = wordRegexp(indentKeywords.concat(commonKeywords)); |
||||
|
||||
indentKeywords = wordRegexp(indentKeywords); |
||||
|
||||
|
||||
var stringPrefixes = /^('{3}|\"{3}|['\"])/; |
||||
var regexPrefixes = /^(\/{3}|\/)/; |
||||
var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"]; |
||||
var constants = wordRegexp(commonConstants); |
||||
|
||||
// Tokenizers
|
||||
function tokenBase(stream, state) { |
||||
// Handle scope changes
|
||||
if (stream.sol()) { |
||||
if (state.scope.align === null) state.scope.align = false; |
||||
var scopeOffset = state.scope.offset; |
||||
if (stream.eatSpace()) { |
||||
var lineOffset = stream.indentation(); |
||||
if (lineOffset > scopeOffset && state.scope.type == "coffee") { |
||||
return "indent"; |
||||
} else if (lineOffset < scopeOffset) { |
||||
return "dedent"; |
||||
} |
||||
return null; |
||||
} else { |
||||
if (scopeOffset > 0) { |
||||
dedent(stream, state); |
||||
} |
||||
} |
||||
} |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
|
||||
var ch = stream.peek(); |
||||
|
||||
// Handle docco title comment (single line)
|
||||
if (stream.match("####")) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
|
||||
// Handle multi line comments
|
||||
if (stream.match("###")) { |
||||
state.tokenize = longComment; |
||||
return state.tokenize(stream, state); |
||||
} |
||||
|
||||
// Single line comment
|
||||
if (ch === "#") { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
|
||||
// Handle number literals
|
||||
if (stream.match(/^-?[0-9\.]/, false)) { |
||||
var floatLiteral = false; |
||||
// Floats
|
||||
if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) { |
||||
floatLiteral = true; |
||||
} |
||||
if (stream.match(/^-?\d+\.\d*/)) { |
||||
floatLiteral = true; |
||||
} |
||||
if (stream.match(/^-?\.\d+/)) { |
||||
floatLiteral = true; |
||||
} |
||||
|
||||
if (floatLiteral) { |
||||
// prevent from getting extra . on 1..
|
||||
if (stream.peek() == "."){ |
||||
stream.backUp(1); |
||||
} |
||||
return "number"; |
||||
} |
||||
// Integers
|
||||
var intLiteral = false; |
||||
// Hex
|
||||
if (stream.match(/^-?0x[0-9a-f]+/i)) { |
||||
intLiteral = true; |
||||
} |
||||
// Decimal
|
||||
if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) { |
||||
intLiteral = true; |
||||
} |
||||
// Zero by itself with no other piece of number.
|
||||
if (stream.match(/^-?0(?![\dx])/i)) { |
||||
intLiteral = true; |
||||
} |
||||
if (intLiteral) { |
||||
return "number"; |
||||
} |
||||
} |
||||
|
||||
// Handle strings
|
||||
if (stream.match(stringPrefixes)) { |
||||
state.tokenize = tokenFactory(stream.current(), false, "string"); |
||||
return state.tokenize(stream, state); |
||||
} |
||||
// Handle regex literals
|
||||
if (stream.match(regexPrefixes)) { |
||||
if (stream.current() != "/" || stream.match(/^.*\//, false)) { // prevent highlight of division
|
||||
state.tokenize = tokenFactory(stream.current(), true, "string-2"); |
||||
return state.tokenize(stream, state); |
||||
} else { |
||||
stream.backUp(1); |
||||
} |
||||
} |
||||
|
||||
|
||||
|
||||
// Handle operators and delimiters
|
||||
if (stream.match(operators) || stream.match(wordOperators)) { |
||||
return "operator"; |
||||
} |
||||
if (stream.match(delimiters)) { |
||||
return "punctuation"; |
||||
} |
||||
|
||||
if (stream.match(constants)) { |
||||
return "atom"; |
||||
} |
||||
|
||||
if (stream.match(atProp) || state.prop && stream.match(identifiers)) { |
||||
return "property"; |
||||
} |
||||
|
||||
if (stream.match(keywords)) { |
||||
return "keyword"; |
||||
} |
||||
|
||||
if (stream.match(identifiers)) { |
||||
return "variable"; |
||||
} |
||||
|
||||
// Handle non-detected items
|
||||
stream.next(); |
||||
return ERRORCLASS; |
||||
} |
||||
|
||||
function tokenFactory(delimiter, singleline, outclass) { |
||||
return function(stream, state) { |
||||
while (!stream.eol()) { |
||||
stream.eatWhile(/[^'"\/\\]/); |
||||
if (stream.eat("\\")) { |
||||
stream.next(); |
||||
if (singleline && stream.eol()) { |
||||
return outclass; |
||||
} |
||||
} else if (stream.match(delimiter)) { |
||||
state.tokenize = tokenBase; |
||||
return outclass; |
||||
} else { |
||||
stream.eat(/['"\/]/); |
||||
} |
||||
} |
||||
if (singleline) { |
||||
if (parserConf.singleLineStringErrors) { |
||||
outclass = ERRORCLASS; |
||||
} else { |
||||
state.tokenize = tokenBase; |
||||
} |
||||
} |
||||
return outclass; |
||||
}; |
||||
} |
||||
|
||||
function longComment(stream, state) { |
||||
while (!stream.eol()) { |
||||
stream.eatWhile(/[^#]/); |
||||
if (stream.match("###")) { |
||||
state.tokenize = tokenBase; |
||||
break; |
||||
} |
||||
stream.eatWhile("#"); |
||||
} |
||||
return "comment"; |
||||
} |
||||
|
||||
function indent(stream, state, type) { |
||||
type = type || "coffee"; |
||||
var offset = 0, align = false, alignOffset = null; |
||||
for (var scope = state.scope; scope; scope = scope.prev) { |
||||
if (scope.type === "coffee" || scope.type == "}") { |
||||
offset = scope.offset + conf.indentUnit; |
||||
break; |
||||
} |
||||
} |
||||
if (type !== "coffee") { |
||||
align = null; |
||||
alignOffset = stream.column() + stream.current().length; |
||||
} else if (state.scope.align) { |
||||
state.scope.align = false; |
||||
} |
||||
state.scope = { |
||||
offset: offset, |
||||
type: type, |
||||
prev: state.scope, |
||||
align: align, |
||||
alignOffset: alignOffset |
||||
}; |
||||
} |
||||
|
||||
function dedent(stream, state) { |
||||
if (!state.scope.prev) return; |
||||
if (state.scope.type === "coffee") { |
||||
var _indent = stream.indentation(); |
||||
var matched = false; |
||||
for (var scope = state.scope; scope; scope = scope.prev) { |
||||
if (_indent === scope.offset) { |
||||
matched = true; |
||||
break; |
||||
} |
||||
} |
||||
if (!matched) { |
||||
return true; |
||||
} |
||||
while (state.scope.prev && state.scope.offset !== _indent) { |
||||
state.scope = state.scope.prev; |
||||
} |
||||
return false; |
||||
} else { |
||||
state.scope = state.scope.prev; |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
function tokenLexer(stream, state) { |
||||
var style = state.tokenize(stream, state); |
||||
var current = stream.current(); |
||||
|
||||
// Handle scope changes.
|
||||
if (current === "return") { |
||||
state.dedent = true; |
||||
} |
||||
if (((current === "->" || current === "=>") && stream.eol()) |
||||
|| style === "indent") { |
||||
indent(stream, state); |
||||
} |
||||
var delimiter_index = "[({".indexOf(current); |
||||
if (delimiter_index !== -1) { |
||||
indent(stream, state, "])}".slice(delimiter_index, delimiter_index+1)); |
||||
} |
||||
if (indentKeywords.exec(current)){ |
||||
indent(stream, state); |
||||
} |
||||
if (current == "then"){ |
||||
dedent(stream, state); |
||||
} |
||||
|
||||
|
||||
if (style === "dedent") { |
||||
if (dedent(stream, state)) { |
||||
return ERRORCLASS; |
||||
} |
||||
} |
||||
delimiter_index = "])}".indexOf(current); |
||||
if (delimiter_index !== -1) { |
||||
while (state.scope.type == "coffee" && state.scope.prev) |
||||
state.scope = state.scope.prev; |
||||
if (state.scope.type == current) |
||||
state.scope = state.scope.prev; |
||||
} |
||||
if (state.dedent && stream.eol()) { |
||||
if (state.scope.type == "coffee" && state.scope.prev) |
||||
state.scope = state.scope.prev; |
||||
state.dedent = false; |
||||
} |
||||
|
||||
return style; |
||||
} |
||||
|
||||
var external = { |
||||
startState: function(basecolumn) { |
||||
return { |
||||
tokenize: tokenBase, |
||||
scope: {offset:basecolumn || 0, type:"coffee", prev: null, align: false}, |
||||
prop: false, |
||||
dedent: 0 |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
var fillAlign = state.scope.align === null && state.scope; |
||||
if (fillAlign && stream.sol()) fillAlign.align = false; |
||||
|
||||
var style = tokenLexer(stream, state); |
||||
if (style && style != "comment") { |
||||
if (fillAlign) fillAlign.align = true; |
||||
state.prop = style == "punctuation" && stream.current() == "." |
||||
} |
||||
|
||||
return style; |
||||
}, |
||||
|
||||
indent: function(state, text) { |
||||
if (state.tokenize != tokenBase) return 0; |
||||
var scope = state.scope; |
||||
var closer = text && "])}".indexOf(text.charAt(0)) > -1; |
||||
if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev; |
||||
var closes = closer && scope.type === text.charAt(0); |
||||
if (scope.align) |
||||
return scope.alignOffset - (closes ? 1 : 0); |
||||
else |
||||
return (closes ? scope.prev : scope).offset; |
||||
}, |
||||
|
||||
lineComment: "#", |
||||
fold: "indent" |
||||
}; |
||||
return external; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-coffeescript", "coffeescript"); |
||||
CodeMirror.defineMIME("text/coffeescript", "coffeescript"); |
||||
|
||||
}); |
||||
@ -0,0 +1,123 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("commonlisp", function (config) { |
||||
var specialForm = /^(block|let*|return-from|catch|load-time-value|setq|eval-when|locally|symbol-macrolet|flet|macrolet|tagbody|function|multiple-value-call|the|go|multiple-value-prog1|throw|if|progn|unwind-protect|labels|progv|let|quote)$/; |
||||
var assumeBody = /^with|^def|^do|^prog|case$|^cond$|bind$|when$|unless$/; |
||||
var numLiteral = /^(?:[+\-]?(?:\d+|\d*\.\d+)(?:[efd][+\-]?\d+)?|[+\-]?\d+(?:\/[+\-]?\d+)?|#b[+\-]?[01]+|#o[+\-]?[0-7]+|#x[+\-]?[\da-f]+)/; |
||||
var symbol = /[^\s'`,@()\[\]";]/; |
||||
var type; |
||||
|
||||
function readSym(stream) { |
||||
var ch; |
||||
while (ch = stream.next()) { |
||||
if (ch == "\\") stream.next(); |
||||
else if (!symbol.test(ch)) { stream.backUp(1); break; } |
||||
} |
||||
return stream.current(); |
||||
} |
||||
|
||||
function base(stream, state) { |
||||
if (stream.eatSpace()) {type = "ws"; return null;} |
||||
if (stream.match(numLiteral)) return "number"; |
||||
var ch = stream.next(); |
||||
if (ch == "\\") ch = stream.next(); |
||||
|
||||
if (ch == '"') return (state.tokenize = inString)(stream, state); |
||||
else if (ch == "(") { type = "open"; return "bracket"; } |
||||
else if (ch == ")" || ch == "]") { type = "close"; return "bracket"; } |
||||
else if (ch == ";") { stream.skipToEnd(); type = "ws"; return "comment"; } |
||||
else if (/['`,@]/.test(ch)) return null; |
||||
else if (ch == "|") { |
||||
if (stream.skipTo("|")) { stream.next(); return "symbol"; } |
||||
else { stream.skipToEnd(); return "error"; } |
||||
} else if (ch == "#") { |
||||
var ch = stream.next(); |
||||
if (ch == "[") { type = "open"; return "bracket"; } |
||||
else if (/[+\-=\.']/.test(ch)) return null; |
||||
else if (/\d/.test(ch) && stream.match(/^\d*#/)) return null; |
||||
else if (ch == "|") return (state.tokenize = inComment)(stream, state); |
||||
else if (ch == ":") { readSym(stream); return "meta"; } |
||||
else return "error"; |
||||
} else { |
||||
var name = readSym(stream); |
||||
if (name == ".") return null; |
||||
type = "symbol"; |
||||
if (name == "nil" || name == "t" || name.charAt(0) == ":") return "atom"; |
||||
if (state.lastType == "open" && (specialForm.test(name) || assumeBody.test(name))) return "keyword"; |
||||
if (name.charAt(0) == "&") return "variable-2"; |
||||
return "variable"; |
||||
} |
||||
} |
||||
|
||||
function inString(stream, state) { |
||||
var escaped = false, next; |
||||
while (next = stream.next()) { |
||||
if (next == '"' && !escaped) { state.tokenize = base; break; } |
||||
escaped = !escaped && next == "\\"; |
||||
} |
||||
return "string"; |
||||
} |
||||
|
||||
function inComment(stream, state) { |
||||
var next, last; |
||||
while (next = stream.next()) { |
||||
if (next == "#" && last == "|") { state.tokenize = base; break; } |
||||
last = next; |
||||
} |
||||
type = "ws"; |
||||
return "comment"; |
||||
} |
||||
|
||||
return { |
||||
startState: function () { |
||||
return {ctx: {prev: null, start: 0, indentTo: 0}, lastType: null, tokenize: base}; |
||||
}, |
||||
|
||||
token: function (stream, state) { |
||||
if (stream.sol() && typeof state.ctx.indentTo != "number") |
||||
state.ctx.indentTo = state.ctx.start + 1; |
||||
|
||||
type = null; |
||||
var style = state.tokenize(stream, state); |
||||
if (type != "ws") { |
||||
if (state.ctx.indentTo == null) { |
||||
if (type == "symbol" && assumeBody.test(stream.current())) |
||||
state.ctx.indentTo = state.ctx.start + config.indentUnit; |
||||
else |
||||
state.ctx.indentTo = "next"; |
||||
} else if (state.ctx.indentTo == "next") { |
||||
state.ctx.indentTo = stream.column(); |
||||
} |
||||
state.lastType = type; |
||||
} |
||||
if (type == "open") state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null}; |
||||
else if (type == "close") state.ctx = state.ctx.prev || state.ctx; |
||||
return style; |
||||
}, |
||||
|
||||
indent: function (state, _textAfter) { |
||||
var i = state.ctx.indentTo; |
||||
return typeof i == "number" ? i : state.ctx.start + 1; |
||||
}, |
||||
|
||||
closeBrackets: {pairs: "()[]{}\"\""}, |
||||
lineComment: ";;", |
||||
blockCommentStart: "#|", |
||||
blockCommentEnd: "|#" |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-common-lisp", "commonlisp"); |
||||
|
||||
}); |
||||
@ -0,0 +1,177 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Common Lisp mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="commonlisp.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Common Lisp</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Common Lisp mode</h2> |
||||
<form><textarea id="code" name="code">(in-package :cl-postgres) |
||||
|
||||
;; These are used to synthesize reader and writer names for integer |
||||
;; reading/writing functions when the amount of bytes and the |
||||
;; signedness is known. Both the macro that creates the functions and |
||||
;; some macros that use them create names this way. |
||||
(eval-when (:compile-toplevel :load-toplevel :execute) |
||||
(defun integer-reader-name (bytes signed) |
||||
(intern (with-standard-io-syntax |
||||
(format nil "~a~a~a~a" '#:read- (if signed "" '#:u) '#:int bytes)))) |
||||
(defun integer-writer-name (bytes signed) |
||||
(intern (with-standard-io-syntax |
||||
(format nil "~a~a~a~a" '#:write- (if signed "" '#:u) '#:int bytes))))) |
||||
|
||||
(defmacro integer-reader (bytes) |
||||
"Create a function to read integers from a binary stream." |
||||
(let ((bits (* bytes 8))) |
||||
(labels ((return-form (signed) |
||||
(if signed |
||||
`(if (logbitp ,(1- bits) result) |
||||
(dpb result (byte ,(1- bits) 0) -1) |
||||
result) |
||||
`result)) |
||||
(generate-reader (signed) |
||||
`(defun ,(integer-reader-name bytes signed) (socket) |
||||
(declare (type stream socket) |
||||
#.*optimize*) |
||||
,(if (= bytes 1) |
||||
`(let ((result (the (unsigned-byte 8) (read-byte socket)))) |
||||
(declare (type (unsigned-byte 8) result)) |
||||
,(return-form signed)) |
||||
`(let ((result 0)) |
||||
(declare (type (unsigned-byte ,bits) result)) |
||||
,@(loop :for byte :from (1- bytes) :downto 0 |
||||
:collect `(setf (ldb (byte 8 ,(* 8 byte)) result) |
||||
(the (unsigned-byte 8) (read-byte socket)))) |
||||
,(return-form signed)))))) |
||||
`(progn |
||||
;; This causes weird errors on SBCL in some circumstances. Disabled for now. |
||||
;; (declaim (inline ,(integer-reader-name bytes t) |
||||
;; ,(integer-reader-name bytes nil))) |
||||
(declaim (ftype (function (t) (signed-byte ,bits)) |
||||
,(integer-reader-name bytes t))) |
||||
,(generate-reader t) |
||||
(declaim (ftype (function (t) (unsigned-byte ,bits)) |
||||
,(integer-reader-name bytes nil))) |
||||
,(generate-reader nil))))) |
||||
|
||||
(defmacro integer-writer (bytes) |
||||
"Create a function to write integers to a binary stream." |
||||
(let ((bits (* 8 bytes))) |
||||
`(progn |
||||
(declaim (inline ,(integer-writer-name bytes t) |
||||
,(integer-writer-name bytes nil))) |
||||
(defun ,(integer-writer-name bytes nil) (socket value) |
||||
(declare (type stream socket) |
||||
(type (unsigned-byte ,bits) value) |
||||
#.*optimize*) |
||||
,@(if (= bytes 1) |
||||
`((write-byte value socket)) |
||||
(loop :for byte :from (1- bytes) :downto 0 |
||||
:collect `(write-byte (ldb (byte 8 ,(* byte 8)) value) |
||||
socket))) |
||||
(values)) |
||||
(defun ,(integer-writer-name bytes t) (socket value) |
||||
(declare (type stream socket) |
||||
(type (signed-byte ,bits) value) |
||||
#.*optimize*) |
||||
,@(if (= bytes 1) |
||||
`((write-byte (ldb (byte 8 0) value) socket)) |
||||
(loop :for byte :from (1- bytes) :downto 0 |
||||
:collect `(write-byte (ldb (byte 8 ,(* byte 8)) value) |
||||
socket))) |
||||
(values))))) |
||||
|
||||
;; All the instances of the above that we need. |
||||
|
||||
(integer-reader 1) |
||||
(integer-reader 2) |
||||
(integer-reader 4) |
||||
(integer-reader 8) |
||||
|
||||
(integer-writer 1) |
||||
(integer-writer 2) |
||||
(integer-writer 4) |
||||
|
||||
(defun write-bytes (socket bytes) |
||||
"Write a byte-array to a stream." |
||||
(declare (type stream socket) |
||||
(type (simple-array (unsigned-byte 8)) bytes) |
||||
#.*optimize*) |
||||
(write-sequence bytes socket)) |
||||
|
||||
(defun write-str (socket string) |
||||
"Write a null-terminated string to a stream \(encoding it when UTF-8 |
||||
support is enabled.)." |
||||
(declare (type stream socket) |
||||
(type string string) |
||||
#.*optimize*) |
||||
(enc-write-string string socket) |
||||
(write-uint1 socket 0)) |
||||
|
||||
(declaim (ftype (function (t unsigned-byte) |
||||
(simple-array (unsigned-byte 8) (*))) |
||||
read-bytes)) |
||||
(defun read-bytes (socket length) |
||||
"Read a byte array of the given length from a stream." |
||||
(declare (type stream socket) |
||||
(type fixnum length) |
||||
#.*optimize*) |
||||
(let ((result (make-array length :element-type '(unsigned-byte 8)))) |
||||
(read-sequence result socket) |
||||
result)) |
||||
|
||||
(declaim (ftype (function (t) string) read-str)) |
||||
(defun read-str (socket) |
||||
"Read a null-terminated string from a stream. Takes care of encoding |
||||
when UTF-8 support is enabled." |
||||
(declare (type stream socket) |
||||
#.*optimize*) |
||||
(enc-read-string socket :null-terminated t)) |
||||
|
||||
(defun skip-bytes (socket length) |
||||
"Skip a given number of bytes in a binary stream." |
||||
(declare (type stream socket) |
||||
(type (unsigned-byte 32) length) |
||||
#.*optimize*) |
||||
(dotimes (i length) |
||||
(read-byte socket))) |
||||
|
||||
(defun skip-str (socket) |
||||
"Skip a null-terminated string." |
||||
(declare (type stream socket) |
||||
#.*optimize*) |
||||
(loop :for char :of-type fixnum = (read-byte socket) |
||||
:until (zerop char))) |
||||
|
||||
(defun ensure-socket-is-closed (socket &key abort) |
||||
(when (open-stream-p socket) |
||||
(handler-case |
||||
(close socket :abort abort) |
||||
(error (error) |
||||
(warn "Ignoring the error which happened while trying to close PostgreSQL socket: ~A" error))))) |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {lineNumbers: true}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-common-lisp</code>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,391 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("crystal", function(config) { |
||||
function wordRegExp(words, end) { |
||||
return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b")); |
||||
} |
||||
|
||||
function chain(tokenize, stream, state) { |
||||
state.tokenize.push(tokenize); |
||||
return tokenize(stream, state); |
||||
} |
||||
|
||||
var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/; |
||||
var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/; |
||||
var indexingOperators = /^(?:\[\][?=]?)/; |
||||
var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/; |
||||
var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/; |
||||
var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/; |
||||
var keywords = wordRegExp([ |
||||
"abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do", |
||||
"else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if", "ifdef", |
||||
"include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof", |
||||
"private", "protected", "rescue", "return", "require", "sizeof", "struct", |
||||
"super", "then", "type", "typeof", "union", "unless", "until", "when", "while", "with", |
||||
"yield", "__DIR__", "__FILE__", "__LINE__" |
||||
]); |
||||
var atomWords = wordRegExp(["true", "false", "nil", "self"]); |
||||
var indentKeywordsArray = [ |
||||
"def", "fun", "macro", |
||||
"class", "module", "struct", "lib", "enum", "union", |
||||
"if", "unless", "case", "while", "until", "begin", "then", |
||||
"do", |
||||
"for", "ifdef" |
||||
]; |
||||
var indentKeywords = wordRegExp(indentKeywordsArray); |
||||
var dedentKeywordsArray = [ |
||||
"end", |
||||
"else", "elsif", |
||||
"rescue", "ensure" |
||||
]; |
||||
var dedentKeywords = wordRegExp(dedentKeywordsArray); |
||||
var dedentPunctualsArray = ["\\)", "\\}", "\\]"]; |
||||
var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$"); |
||||
var nextTokenizer = { |
||||
"def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef, |
||||
"class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType, |
||||
"lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType |
||||
}; |
||||
var matching = {"[": "]", "{": "}", "(": ")", "<": ">"}; |
||||
|
||||
function tokenBase(stream, state) { |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
|
||||
// Macros
|
||||
if (state.lastToken != "\\" && stream.match("{%", false)) { |
||||
return chain(tokenMacro("%", "%"), stream, state); |
||||
} |
||||
|
||||
if (state.lastToken != "\\" && stream.match("{{", false)) { |
||||
return chain(tokenMacro("{", "}"), stream, state); |
||||
} |
||||
|
||||
// Comments
|
||||
if (stream.peek() == "#") { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
|
||||
// Variables and keywords
|
||||
var matched; |
||||
if (stream.match(idents)) { |
||||
stream.eat(/[?!]/); |
||||
|
||||
matched = stream.current(); |
||||
if (stream.eat(":")) { |
||||
return "atom"; |
||||
} else if (state.lastToken == ".") { |
||||
return "property"; |
||||
} else if (keywords.test(matched)) { |
||||
if (state.lastToken != "abstract" && indentKeywords.test(matched)) { |
||||
if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0)) { |
||||
state.blocks.push(matched); |
||||
state.currentIndent += 1; |
||||
} |
||||
} else if (dedentKeywords.test(matched)) { |
||||
state.blocks.pop(); |
||||
state.currentIndent -= 1; |
||||
} |
||||
|
||||
if (nextTokenizer.hasOwnProperty(matched)) { |
||||
state.tokenize.push(nextTokenizer[matched]); |
||||
} |
||||
|
||||
return "keyword"; |
||||
} else if (atomWords.test(matched)) { |
||||
return "atom"; |
||||
} |
||||
|
||||
return "variable"; |
||||
} |
||||
|
||||
// Class variables and instance variables
|
||||
// or attributes
|
||||
if (stream.eat("@")) { |
||||
if (stream.peek() == "[") { |
||||
return chain(tokenNest("[", "]", "meta"), stream, state); |
||||
} |
||||
|
||||
stream.eat("@"); |
||||
stream.match(idents) || stream.match(types); |
||||
return "variable-2"; |
||||
} |
||||
|
||||
// Global variables
|
||||
if (stream.eat("$")) { |
||||
stream.eat(/[0-9]+|\?/) || stream.match(idents) || stream.match(types); |
||||
return "variable-3"; |
||||
} |
||||
|
||||
// Constants and types
|
||||
if (stream.match(types)) { |
||||
return "tag"; |
||||
} |
||||
|
||||
// Symbols or ':' operator
|
||||
if (stream.eat(":")) { |
||||
if (stream.eat("\"")) { |
||||
return chain(tokenQuote("\"", "atom", false), stream, state); |
||||
} else if (stream.match(idents) || stream.match(types) || |
||||
stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) { |
||||
return "atom"; |
||||
} |
||||
stream.eat(":"); |
||||
return "operator"; |
||||
} |
||||
|
||||
// Strings
|
||||
if (stream.eat("\"")) { |
||||
return chain(tokenQuote("\"", "string", true), stream, state); |
||||
} |
||||
|
||||
// Strings or regexps or macro variables or '%' operator
|
||||
if (stream.peek() == "%") { |
||||
var style = "string"; |
||||
var embed = true; |
||||
var delim; |
||||
|
||||
if (stream.match("%r")) { |
||||
// Regexps
|
||||
style = "string-2"; |
||||
delim = stream.next(); |
||||
} else if (stream.match("%w")) { |
||||
embed = false; |
||||
delim = stream.next(); |
||||
} else { |
||||
if(delim = stream.match(/^%([^\w\s=])/)) { |
||||
delim = delim[1]; |
||||
} else if (stream.match(/^%[a-zA-Z0-9_\u009F-\uFFFF]*/)) { |
||||
// Macro variables
|
||||
return "meta"; |
||||
} else { |
||||
// '%' operator
|
||||
return "operator"; |
||||
} |
||||
} |
||||
|
||||
if (matching.hasOwnProperty(delim)) { |
||||
delim = matching[delim]; |
||||
} |
||||
return chain(tokenQuote(delim, style, embed), stream, state); |
||||
} |
||||
|
||||
// Characters
|
||||
if (stream.eat("'")) { |
||||
stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/); |
||||
stream.eat("'"); |
||||
return "atom"; |
||||
} |
||||
|
||||
// Numbers
|
||||
if (stream.eat("0")) { |
||||
if (stream.eat("x")) { |
||||
stream.match(/^[0-9a-fA-F]+/); |
||||
} else if (stream.eat("o")) { |
||||
stream.match(/^[0-7]+/); |
||||
} else if (stream.eat("b")) { |
||||
stream.match(/^[01]+/); |
||||
} |
||||
return "number"; |
||||
} |
||||
|
||||
if (stream.eat(/\d/)) { |
||||
stream.match(/^\d*(?:\.\d+)?(?:[eE][+-]?\d+)?/); |
||||
return "number"; |
||||
} |
||||
|
||||
// Operators
|
||||
if (stream.match(operators)) { |
||||
stream.eat("="); // Operators can follow assign symbol.
|
||||
return "operator"; |
||||
} |
||||
|
||||
if (stream.match(conditionalOperators) || stream.match(anotherOperators)) { |
||||
return "operator"; |
||||
} |
||||
|
||||
// Parens and braces
|
||||
if (matched = stream.match(/[({[]/, false)) { |
||||
matched = matched[0]; |
||||
return chain(tokenNest(matched, matching[matched], null), stream, state); |
||||
} |
||||
|
||||
// Escapes
|
||||
if (stream.eat("\\")) { |
||||
stream.next(); |
||||
return "meta"; |
||||
} |
||||
|
||||
stream.next(); |
||||
return null; |
||||
} |
||||
|
||||
function tokenNest(begin, end, style, started) { |
||||
return function (stream, state) { |
||||
if (!started && stream.match(begin)) { |
||||
state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true); |
||||
state.currentIndent += 1; |
||||
return style; |
||||
} |
||||
|
||||
var nextStyle = tokenBase(stream, state); |
||||
if (stream.current() === end) { |
||||
state.tokenize.pop(); |
||||
state.currentIndent -= 1; |
||||
nextStyle = style; |
||||
} |
||||
|
||||
return nextStyle; |
||||
}; |
||||
} |
||||
|
||||
function tokenMacro(begin, end, started) { |
||||
return function (stream, state) { |
||||
if (!started && stream.match("{" + begin)) { |
||||
state.currentIndent += 1; |
||||
state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true); |
||||
return "meta"; |
||||
} |
||||
|
||||
if (stream.match(end + "}")) { |
||||
state.currentIndent -= 1; |
||||
state.tokenize.pop(); |
||||
return "meta"; |
||||
} |
||||
|
||||
return tokenBase(stream, state); |
||||
}; |
||||
} |
||||
|
||||
function tokenMacroDef(stream, state) { |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
|
||||
var matched; |
||||
if (matched = stream.match(idents)) { |
||||
if (matched == "def") { |
||||
return "keyword"; |
||||
} |
||||
stream.eat(/[?!]/); |
||||
} |
||||
|
||||
state.tokenize.pop(); |
||||
return "def"; |
||||
} |
||||
|
||||
function tokenFollowIdent(stream, state) { |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
|
||||
if (stream.match(idents)) { |
||||
stream.eat(/[!?]/); |
||||
} else { |
||||
stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators); |
||||
} |
||||
state.tokenize.pop(); |
||||
return "def"; |
||||
} |
||||
|
||||
function tokenFollowType(stream, state) { |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
|
||||
stream.match(types); |
||||
state.tokenize.pop(); |
||||
return "def"; |
||||
} |
||||
|
||||
function tokenQuote(end, style, embed) { |
||||
return function (stream, state) { |
||||
var escaped = false; |
||||
|
||||
while (stream.peek()) { |
||||
if (!escaped) { |
||||
if (stream.match("{%", false)) { |
||||
state.tokenize.push(tokenMacro("%", "%")); |
||||
return style; |
||||
} |
||||
|
||||
if (stream.match("{{", false)) { |
||||
state.tokenize.push(tokenMacro("{", "}")); |
||||
return style; |
||||
} |
||||
|
||||
if (embed && stream.match("#{", false)) { |
||||
state.tokenize.push(tokenNest("#{", "}", "meta")); |
||||
return style; |
||||
} |
||||
|
||||
var ch = stream.next(); |
||||
|
||||
if (ch == end) { |
||||
state.tokenize.pop(); |
||||
return style; |
||||
} |
||||
|
||||
escaped = ch == "\\"; |
||||
} else { |
||||
stream.next(); |
||||
escaped = false; |
||||
} |
||||
} |
||||
|
||||
return style; |
||||
}; |
||||
} |
||||
|
||||
return { |
||||
startState: function () { |
||||
return { |
||||
tokenize: [tokenBase], |
||||
currentIndent: 0, |
||||
lastToken: null, |
||||
blocks: [] |
||||
}; |
||||
}, |
||||
|
||||
token: function (stream, state) { |
||||
var style = state.tokenize[state.tokenize.length - 1](stream, state); |
||||
var token = stream.current(); |
||||
|
||||
if (style && style != "comment") { |
||||
state.lastToken = token; |
||||
} |
||||
|
||||
return style; |
||||
}, |
||||
|
||||
indent: function (state, textAfter) { |
||||
textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, ""); |
||||
|
||||
if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) { |
||||
return config.indentUnit * (state.currentIndent - 1); |
||||
} |
||||
|
||||
return config.indentUnit * state.currentIndent; |
||||
}, |
||||
|
||||
fold: "indent", |
||||
electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true), |
||||
lineComment: '#' |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-crystal", "crystal"); |
||||
}); |
||||
@ -0,0 +1,119 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Crystal mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="crystal.js"></script> |
||||
<style> |
||||
.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;} |
||||
.cm-s-default span.cm-arrow { color: red; } |
||||
</style> |
||||
|
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Crystal</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Crystal mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
# Features of Crystal |
||||
# - Ruby-inspired syntax. |
||||
# - Statically type-checked but without having to specify the type of variables or method arguments. |
||||
# - Be able to call C code by writing bindings to it in Crystal. |
||||
# - Have compile-time evaluation and generation of code, to avoid boilerplate code. |
||||
# - Compile to efficient native code. |
||||
|
||||
# A very basic HTTP server |
||||
require "http/server" |
||||
|
||||
server = HTTP::Server.new(8080) do |request| |
||||
HTTP::Response.ok "text/plain", "Hello world, got #{request.path}!" |
||||
end |
||||
|
||||
puts "Listening on http://0.0.0.0:8080" |
||||
server.listen |
||||
|
||||
module Foo |
||||
def initialize(@foo); end |
||||
|
||||
abstract def abstract_method : String |
||||
|
||||
@[AlwaysInline] |
||||
def with_foofoo |
||||
with Foo.new(self) yield |
||||
end |
||||
|
||||
struct Foo |
||||
def initialize(@foo); end |
||||
|
||||
def hello_world |
||||
@foo.abstract_method |
||||
end |
||||
end |
||||
end |
||||
|
||||
class Bar |
||||
include Foo |
||||
|
||||
@@foobar = 12345 |
||||
|
||||
def initialize(@bar) |
||||
super(@bar.not_nil! + 100) |
||||
end |
||||
|
||||
macro alias_method(name, method) |
||||
def {{ name }}(*args) |
||||
{{ method }}(*args) |
||||
end |
||||
end |
||||
|
||||
def a_method |
||||
"Hello, World" |
||||
end |
||||
|
||||
alias_method abstract_method, a_method |
||||
|
||||
macro def show_instance_vars : Nil |
||||
{% for var in @type.instance_vars %} |
||||
puts "@{{ var }} = #{ @{{ var }} }" |
||||
{% end %} |
||||
nil |
||||
end |
||||
end |
||||
|
||||
class Baz < Bar; end |
||||
|
||||
lib LibC |
||||
fun c_puts = "puts"(str : Char*) : Int |
||||
end |
||||
|
||||
$baz = Baz.new(100) |
||||
$baz.show_instance_vars |
||||
$baz.with_foofoo do |
||||
LibC.c_puts hello_world |
||||
end |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
mode: "text/x-crystal", |
||||
matchBrackets: true, |
||||
indentUnit: 2 |
||||
}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-crystal</code>.</p> |
||||
</article> |
||||
@ -0,0 +1,825 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("css", function(config, parserConfig) { |
||||
var inline = parserConfig.inline |
||||
if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css"); |
||||
|
||||
var indentUnit = config.indentUnit, |
||||
tokenHooks = parserConfig.tokenHooks, |
||||
documentTypes = parserConfig.documentTypes || {}, |
||||
mediaTypes = parserConfig.mediaTypes || {}, |
||||
mediaFeatures = parserConfig.mediaFeatures || {}, |
||||
mediaValueKeywords = parserConfig.mediaValueKeywords || {}, |
||||
propertyKeywords = parserConfig.propertyKeywords || {}, |
||||
nonStandardPropertyKeywords = parserConfig.nonStandardPropertyKeywords || {}, |
||||
fontProperties = parserConfig.fontProperties || {}, |
||||
counterDescriptors = parserConfig.counterDescriptors || {}, |
||||
colorKeywords = parserConfig.colorKeywords || {}, |
||||
valueKeywords = parserConfig.valueKeywords || {}, |
||||
allowNested = parserConfig.allowNested, |
||||
supportsAtComponent = parserConfig.supportsAtComponent === true; |
||||
|
||||
var type, override; |
||||
function ret(style, tp) { type = tp; return style; } |
||||
|
||||
// Tokenizers
|
||||
|
||||
function tokenBase(stream, state) { |
||||
var ch = stream.next(); |
||||
if (tokenHooks[ch]) { |
||||
var result = tokenHooks[ch](stream, state); |
||||
if (result !== false) return result; |
||||
} |
||||
if (ch == "@") { |
||||
stream.eatWhile(/[\w\\\-]/); |
||||
return ret("def", stream.current()); |
||||
} else if (ch == "=" || (ch == "~" || ch == "|") && stream.eat("=")) { |
||||
return ret(null, "compare"); |
||||
} else if (ch == "\"" || ch == "'") { |
||||
state.tokenize = tokenString(ch); |
||||
return state.tokenize(stream, state); |
||||
} else if (ch == "#") { |
||||
stream.eatWhile(/[\w\\\-]/); |
||||
return ret("atom", "hash"); |
||||
} else if (ch == "!") { |
||||
stream.match(/^\s*\w*/); |
||||
return ret("keyword", "important"); |
||||
} else if (/\d/.test(ch) || ch == "." && stream.eat(/\d/)) { |
||||
stream.eatWhile(/[\w.%]/); |
||||
return ret("number", "unit"); |
||||
} else if (ch === "-") { |
||||
if (/[\d.]/.test(stream.peek())) { |
||||
stream.eatWhile(/[\w.%]/); |
||||
return ret("number", "unit"); |
||||
} else if (stream.match(/^-[\w\\\-]+/)) { |
||||
stream.eatWhile(/[\w\\\-]/); |
||||
if (stream.match(/^\s*:/, false)) |
||||
return ret("variable-2", "variable-definition"); |
||||
return ret("variable-2", "variable"); |
||||
} else if (stream.match(/^\w+-/)) { |
||||
return ret("meta", "meta"); |
||||
} |
||||
} else if (/[,+>*\/]/.test(ch)) { |
||||
return ret(null, "select-op"); |
||||
} else if (ch == "." && stream.match(/^-?[_a-z][_a-z0-9-]*/i)) { |
||||
return ret("qualifier", "qualifier"); |
||||
} else if (/[:;{}\[\]\(\)]/.test(ch)) { |
||||
return ret(null, ch); |
||||
} else if ((ch == "u" && stream.match(/rl(-prefix)?\(/)) || |
||||
(ch == "d" && stream.match("omain(")) || |
||||
(ch == "r" && stream.match("egexp("))) { |
||||
stream.backUp(1); |
||||
state.tokenize = tokenParenthesized; |
||||
return ret("property", "word"); |
||||
} else if (/[\w\\\-]/.test(ch)) { |
||||
stream.eatWhile(/[\w\\\-]/); |
||||
return ret("property", "word"); |
||||
} else { |
||||
return ret(null, null); |
||||
} |
||||
} |
||||
|
||||
function tokenString(quote) { |
||||
return function(stream, state) { |
||||
var escaped = false, ch; |
||||
while ((ch = stream.next()) != null) { |
||||
if (ch == quote && !escaped) { |
||||
if (quote == ")") stream.backUp(1); |
||||
break; |
||||
} |
||||
escaped = !escaped && ch == "\\"; |
||||
} |
||||
if (ch == quote || !escaped && quote != ")") state.tokenize = null; |
||||
return ret("string", "string"); |
||||
}; |
||||
} |
||||
|
||||
function tokenParenthesized(stream, state) { |
||||
stream.next(); // Must be '('
|
||||
if (!stream.match(/\s*[\"\')]/, false)) |
||||
state.tokenize = tokenString(")"); |
||||
else |
||||
state.tokenize = null; |
||||
return ret(null, "("); |
||||
} |
||||
|
||||
// Context management
|
||||
|
||||
function Context(type, indent, prev) { |
||||
this.type = type; |
||||
this.indent = indent; |
||||
this.prev = prev; |
||||
} |
||||
|
||||
function pushContext(state, stream, type, indent) { |
||||
state.context = new Context(type, stream.indentation() + (indent === false ? 0 : indentUnit), state.context); |
||||
return type; |
||||
} |
||||
|
||||
function popContext(state) { |
||||
if (state.context.prev) |
||||
state.context = state.context.prev; |
||||
return state.context.type; |
||||
} |
||||
|
||||
function pass(type, stream, state) { |
||||
return states[state.context.type](type, stream, state); |
||||
} |
||||
function popAndPass(type, stream, state, n) { |
||||
for (var i = n || 1; i > 0; i--) |
||||
state.context = state.context.prev; |
||||
return pass(type, stream, state); |
||||
} |
||||
|
||||
// Parser
|
||||
|
||||
function wordAsValue(stream) { |
||||
var word = stream.current().toLowerCase(); |
||||
if (valueKeywords.hasOwnProperty(word)) |
||||
override = "atom"; |
||||
else if (colorKeywords.hasOwnProperty(word)) |
||||
override = "keyword"; |
||||
else |
||||
override = "variable"; |
||||
} |
||||
|
||||
var states = {}; |
||||
|
||||
states.top = function(type, stream, state) { |
||||
if (type == "{") { |
||||
return pushContext(state, stream, "block"); |
||||
} else if (type == "}" && state.context.prev) { |
||||
return popContext(state); |
||||
} else if (supportsAtComponent && /@component/.test(type)) { |
||||
return pushContext(state, stream, "atComponentBlock"); |
||||
} else if (/^@(-moz-)?document$/.test(type)) { |
||||
return pushContext(state, stream, "documentTypes"); |
||||
} else if (/^@(media|supports|(-moz-)?document|import)$/.test(type)) { |
||||
return pushContext(state, stream, "atBlock"); |
||||
} else if (/^@(font-face|counter-style)/.test(type)) { |
||||
state.stateArg = type; |
||||
return "restricted_atBlock_before"; |
||||
} else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/.test(type)) { |
||||
return "keyframes"; |
||||
} else if (type && type.charAt(0) == "@") { |
||||
return pushContext(state, stream, "at"); |
||||
} else if (type == "hash") { |
||||
override = "builtin"; |
||||
} else if (type == "word") { |
||||
override = "tag"; |
||||
} else if (type == "variable-definition") { |
||||
return "maybeprop"; |
||||
} else if (type == "interpolation") { |
||||
return pushContext(state, stream, "interpolation"); |
||||
} else if (type == ":") { |
||||
return "pseudo"; |
||||
} else if (allowNested && type == "(") { |
||||
return pushContext(state, stream, "parens"); |
||||
} |
||||
return state.context.type; |
||||
}; |
||||
|
||||
states.block = function(type, stream, state) { |
||||
if (type == "word") { |
||||
var word = stream.current().toLowerCase(); |
||||
if (propertyKeywords.hasOwnProperty(word)) { |
||||
override = "property"; |
||||
return "maybeprop"; |
||||
} else if (nonStandardPropertyKeywords.hasOwnProperty(word)) { |
||||
override = "string-2"; |
||||
return "maybeprop"; |
||||
} else if (allowNested) { |
||||
override = stream.match(/^\s*:(?:\s|$)/, false) ? "property" : "tag"; |
||||
return "block"; |
||||
} else { |
||||
override += " error"; |
||||
return "maybeprop"; |
||||
} |
||||
} else if (type == "meta") { |
||||
return "block"; |
||||
} else if (!allowNested && (type == "hash" || type == "qualifier")) { |
||||
override = "error"; |
||||
return "block"; |
||||
} else { |
||||
return states.top(type, stream, state); |
||||
} |
||||
}; |
||||
|
||||
states.maybeprop = function(type, stream, state) { |
||||
if (type == ":") return pushContext(state, stream, "prop"); |
||||
return pass(type, stream, state); |
||||
}; |
||||
|
||||
states.prop = function(type, stream, state) { |
||||
if (type == ";") return popContext(state); |
||||
if (type == "{" && allowNested) return pushContext(state, stream, "propBlock"); |
||||
if (type == "}" || type == "{") return popAndPass(type, stream, state); |
||||
if (type == "(") return pushContext(state, stream, "parens"); |
||||
|
||||
if (type == "hash" && !/^#([0-9a-fA-f]{3,4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/.test(stream.current())) { |
||||
override += " error"; |
||||
} else if (type == "word") { |
||||
wordAsValue(stream); |
||||
} else if (type == "interpolation") { |
||||
return pushContext(state, stream, "interpolation"); |
||||
} |
||||
return "prop"; |
||||
}; |
||||
|
||||
states.propBlock = function(type, _stream, state) { |
||||
if (type == "}") return popContext(state); |
||||
if (type == "word") { override = "property"; return "maybeprop"; } |
||||
return state.context.type; |
||||
}; |
||||
|
||||
states.parens = function(type, stream, state) { |
||||
if (type == "{" || type == "}") return popAndPass(type, stream, state); |
||||
if (type == ")") return popContext(state); |
||||
if (type == "(") return pushContext(state, stream, "parens"); |
||||
if (type == "interpolation") return pushContext(state, stream, "interpolation"); |
||||
if (type == "word") wordAsValue(stream); |
||||
return "parens"; |
||||
}; |
||||
|
||||
states.pseudo = function(type, stream, state) { |
||||
if (type == "word") { |
||||
override = "variable-3"; |
||||
return state.context.type; |
||||
} |
||||
return pass(type, stream, state); |
||||
}; |
||||
|
||||
states.documentTypes = function(type, stream, state) { |
||||
if (type == "word" && documentTypes.hasOwnProperty(stream.current())) { |
||||
override = "tag"; |
||||
return state.context.type; |
||||
} else { |
||||
return states.atBlock(type, stream, state); |
||||
} |
||||
}; |
||||
|
||||
states.atBlock = function(type, stream, state) { |
||||
if (type == "(") return pushContext(state, stream, "atBlock_parens"); |
||||
if (type == "}" || type == ";") return popAndPass(type, stream, state); |
||||
if (type == "{") return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top"); |
||||
|
||||
if (type == "interpolation") return pushContext(state, stream, "interpolation"); |
||||
|
||||
if (type == "word") { |
||||
var word = stream.current().toLowerCase(); |
||||
if (word == "only" || word == "not" || word == "and" || word == "or") |
||||
override = "keyword"; |
||||
else if (mediaTypes.hasOwnProperty(word)) |
||||
override = "attribute"; |
||||
else if (mediaFeatures.hasOwnProperty(word)) |
||||
override = "property"; |
||||
else if (mediaValueKeywords.hasOwnProperty(word)) |
||||
override = "keyword"; |
||||
else if (propertyKeywords.hasOwnProperty(word)) |
||||
override = "property"; |
||||
else if (nonStandardPropertyKeywords.hasOwnProperty(word)) |
||||
override = "string-2"; |
||||
else if (valueKeywords.hasOwnProperty(word)) |
||||
override = "atom"; |
||||
else if (colorKeywords.hasOwnProperty(word)) |
||||
override = "keyword"; |
||||
else |
||||
override = "error"; |
||||
} |
||||
return state.context.type; |
||||
}; |
||||
|
||||
states.atComponentBlock = function(type, stream, state) { |
||||
if (type == "}") |
||||
return popAndPass(type, stream, state); |
||||
if (type == "{") |
||||
return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top", false); |
||||
if (type == "word") |
||||
override = "error"; |
||||
return state.context.type; |
||||
}; |
||||
|
||||
states.atBlock_parens = function(type, stream, state) { |
||||
if (type == ")") return popContext(state); |
||||
if (type == "{" || type == "}") return popAndPass(type, stream, state, 2); |
||||
return states.atBlock(type, stream, state); |
||||
}; |
||||
|
||||
states.restricted_atBlock_before = function(type, stream, state) { |
||||
if (type == "{") |
||||
return pushContext(state, stream, "restricted_atBlock"); |
||||
if (type == "word" && state.stateArg == "@counter-style") { |
||||
override = "variable"; |
||||
return "restricted_atBlock_before"; |
||||
} |
||||
return pass(type, stream, state); |
||||
}; |
||||
|
||||
states.restricted_atBlock = function(type, stream, state) { |
||||
if (type == "}") { |
||||
state.stateArg = null; |
||||
return popContext(state); |
||||
} |
||||
if (type == "word") { |
||||
if ((state.stateArg == "@font-face" && !fontProperties.hasOwnProperty(stream.current().toLowerCase())) || |
||||
(state.stateArg == "@counter-style" && !counterDescriptors.hasOwnProperty(stream.current().toLowerCase()))) |
||||
override = "error"; |
||||
else |
||||
override = "property"; |
||||
return "maybeprop"; |
||||
} |
||||
return "restricted_atBlock"; |
||||
}; |
||||
|
||||
states.keyframes = function(type, stream, state) { |
||||
if (type == "word") { override = "variable"; return "keyframes"; } |
||||
if (type == "{") return pushContext(state, stream, "top"); |
||||
return pass(type, stream, state); |
||||
}; |
||||
|
||||
states.at = function(type, stream, state) { |
||||
if (type == ";") return popContext(state); |
||||
if (type == "{" || type == "}") return popAndPass(type, stream, state); |
||||
if (type == "word") override = "tag"; |
||||
else if (type == "hash") override = "builtin"; |
||||
return "at"; |
||||
}; |
||||
|
||||
states.interpolation = function(type, stream, state) { |
||||
if (type == "}") return popContext(state); |
||||
if (type == "{" || type == ";") return popAndPass(type, stream, state); |
||||
if (type == "word") override = "variable"; |
||||
else if (type != "variable" && type != "(" && type != ")") override = "error"; |
||||
return "interpolation"; |
||||
}; |
||||
|
||||
return { |
||||
startState: function(base) { |
||||
return {tokenize: null, |
||||
state: inline ? "block" : "top", |
||||
stateArg: null, |
||||
context: new Context(inline ? "block" : "top", base || 0, null)}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
if (!state.tokenize && stream.eatSpace()) return null; |
||||
var style = (state.tokenize || tokenBase)(stream, state); |
||||
if (style && typeof style == "object") { |
||||
type = style[1]; |
||||
style = style[0]; |
||||
} |
||||
override = style; |
||||
state.state = states[state.state](type, stream, state); |
||||
return override; |
||||
}, |
||||
|
||||
indent: function(state, textAfter) { |
||||
var cx = state.context, ch = textAfter && textAfter.charAt(0); |
||||
var indent = cx.indent; |
||||
if (cx.type == "prop" && (ch == "}" || ch == ")")) cx = cx.prev; |
||||
if (cx.prev) { |
||||
if (ch == "}" && (cx.type == "block" || cx.type == "top" || |
||||
cx.type == "interpolation" || cx.type == "restricted_atBlock")) { |
||||
// Resume indentation from parent context.
|
||||
cx = cx.prev; |
||||
indent = cx.indent; |
||||
} else if (ch == ")" && (cx.type == "parens" || cx.type == "atBlock_parens") || |
||||
ch == "{" && (cx.type == "at" || cx.type == "atBlock")) { |
||||
// Dedent relative to current context.
|
||||
indent = Math.max(0, cx.indent - indentUnit); |
||||
cx = cx.prev; |
||||
} |
||||
} |
||||
return indent; |
||||
}, |
||||
|
||||
electricChars: "}", |
||||
blockCommentStart: "/*", |
||||
blockCommentEnd: "*/", |
||||
fold: "brace" |
||||
}; |
||||
}); |
||||
|
||||
function keySet(array) { |
||||
var keys = {}; |
||||
for (var i = 0; i < array.length; ++i) { |
||||
keys[array[i]] = true; |
||||
} |
||||
return keys; |
||||
} |
||||
|
||||
var documentTypes_ = [ |
||||
"domain", "regexp", "url", "url-prefix" |
||||
], documentTypes = keySet(documentTypes_); |
||||
|
||||
var mediaTypes_ = [ |
||||
"all", "aural", "braille", "handheld", "print", "projection", "screen", |
||||
"tty", "tv", "embossed" |
||||
], mediaTypes = keySet(mediaTypes_); |
||||
|
||||
var mediaFeatures_ = [ |
||||
"width", "min-width", "max-width", "height", "min-height", "max-height", |
||||
"device-width", "min-device-width", "max-device-width", "device-height", |
||||
"min-device-height", "max-device-height", "aspect-ratio", |
||||
"min-aspect-ratio", "max-aspect-ratio", "device-aspect-ratio", |
||||
"min-device-aspect-ratio", "max-device-aspect-ratio", "color", "min-color", |
||||
"max-color", "color-index", "min-color-index", "max-color-index", |
||||
"monochrome", "min-monochrome", "max-monochrome", "resolution", |
||||
"min-resolution", "max-resolution", "scan", "grid", "orientation", |
||||
"device-pixel-ratio", "min-device-pixel-ratio", "max-device-pixel-ratio", |
||||
"pointer", "any-pointer", "hover", "any-hover" |
||||
], mediaFeatures = keySet(mediaFeatures_); |
||||
|
||||
var mediaValueKeywords_ = [ |
||||
"landscape", "portrait", "none", "coarse", "fine", "on-demand", "hover", |
||||
"interlace", "progressive" |
||||
], mediaValueKeywords = keySet(mediaValueKeywords_); |
||||
|
||||
var propertyKeywords_ = [ |
||||
"align-content", "align-items", "align-self", "alignment-adjust", |
||||
"alignment-baseline", "anchor-point", "animation", "animation-delay", |
||||
"animation-direction", "animation-duration", "animation-fill-mode", |
||||
"animation-iteration-count", "animation-name", "animation-play-state", |
||||
"animation-timing-function", "appearance", "azimuth", "backface-visibility", |
||||
"background", "background-attachment", "background-blend-mode", "background-clip", |
||||
"background-color", "background-image", "background-origin", "background-position", |
||||
"background-repeat", "background-size", "baseline-shift", "binding", |
||||
"bleed", "bookmark-label", "bookmark-level", "bookmark-state", |
||||
"bookmark-target", "border", "border-bottom", "border-bottom-color", |
||||
"border-bottom-left-radius", "border-bottom-right-radius", |
||||
"border-bottom-style", "border-bottom-width", "border-collapse", |
||||
"border-color", "border-image", "border-image-outset", |
||||
"border-image-repeat", "border-image-slice", "border-image-source", |
||||
"border-image-width", "border-left", "border-left-color", |
||||
"border-left-style", "border-left-width", "border-radius", "border-right", |
||||
"border-right-color", "border-right-style", "border-right-width", |
||||
"border-spacing", "border-style", "border-top", "border-top-color", |
||||
"border-top-left-radius", "border-top-right-radius", "border-top-style", |
||||
"border-top-width", "border-width", "bottom", "box-decoration-break", |
||||
"box-shadow", "box-sizing", "break-after", "break-before", "break-inside", |
||||
"caption-side", "clear", "clip", "color", "color-profile", "column-count", |
||||
"column-fill", "column-gap", "column-rule", "column-rule-color", |
||||
"column-rule-style", "column-rule-width", "column-span", "column-width", |
||||
"columns", "content", "counter-increment", "counter-reset", "crop", "cue", |
||||
"cue-after", "cue-before", "cursor", "direction", "display", |
||||
"dominant-baseline", "drop-initial-after-adjust", |
||||
"drop-initial-after-align", "drop-initial-before-adjust", |
||||
"drop-initial-before-align", "drop-initial-size", "drop-initial-value", |
||||
"elevation", "empty-cells", "fit", "fit-position", "flex", "flex-basis", |
||||
"flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", |
||||
"float", "float-offset", "flow-from", "flow-into", "font", "font-feature-settings", |
||||
"font-family", "font-kerning", "font-language-override", "font-size", "font-size-adjust", |
||||
"font-stretch", "font-style", "font-synthesis", "font-variant", |
||||
"font-variant-alternates", "font-variant-caps", "font-variant-east-asian", |
||||
"font-variant-ligatures", "font-variant-numeric", "font-variant-position", |
||||
"font-weight", "grid", "grid-area", "grid-auto-columns", "grid-auto-flow", |
||||
"grid-auto-rows", "grid-column", "grid-column-end", "grid-column-gap", |
||||
"grid-column-start", "grid-gap", "grid-row", "grid-row-end", "grid-row-gap", |
||||
"grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns", |
||||
"grid-template-rows", "hanging-punctuation", "height", "hyphens", |
||||
"icon", "image-orientation", "image-rendering", "image-resolution", |
||||
"inline-box-align", "justify-content", "left", "letter-spacing", |
||||
"line-break", "line-height", "line-stacking", "line-stacking-ruby", |
||||
"line-stacking-shift", "line-stacking-strategy", "list-style", |
||||
"list-style-image", "list-style-position", "list-style-type", "margin", |
||||
"margin-bottom", "margin-left", "margin-right", "margin-top", |
||||
"marker-offset", "marks", "marquee-direction", "marquee-loop", |
||||
"marquee-play-count", "marquee-speed", "marquee-style", "max-height", |
||||
"max-width", "min-height", "min-width", "move-to", "nav-down", "nav-index", |
||||
"nav-left", "nav-right", "nav-up", "object-fit", "object-position", |
||||
"opacity", "order", "orphans", "outline", |
||||
"outline-color", "outline-offset", "outline-style", "outline-width", |
||||
"overflow", "overflow-style", "overflow-wrap", "overflow-x", "overflow-y", |
||||
"padding", "padding-bottom", "padding-left", "padding-right", "padding-top", |
||||
"page", "page-break-after", "page-break-before", "page-break-inside", |
||||
"page-policy", "pause", "pause-after", "pause-before", "perspective", |
||||
"perspective-origin", "pitch", "pitch-range", "play-during", "position", |
||||
"presentation-level", "punctuation-trim", "quotes", "region-break-after", |
||||
"region-break-before", "region-break-inside", "region-fragment", |
||||
"rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness", |
||||
"right", "rotation", "rotation-point", "ruby-align", "ruby-overhang", |
||||
"ruby-position", "ruby-span", "shape-image-threshold", "shape-inside", "shape-margin", |
||||
"shape-outside", "size", "speak", "speak-as", "speak-header", |
||||
"speak-numeral", "speak-punctuation", "speech-rate", "stress", "string-set", |
||||
"tab-size", "table-layout", "target", "target-name", "target-new", |
||||
"target-position", "text-align", "text-align-last", "text-decoration", |
||||
"text-decoration-color", "text-decoration-line", "text-decoration-skip", |
||||
"text-decoration-style", "text-emphasis", "text-emphasis-color", |
||||
"text-emphasis-position", "text-emphasis-style", "text-height", |
||||
"text-indent", "text-justify", "text-outline", "text-overflow", "text-shadow", |
||||
"text-size-adjust", "text-space-collapse", "text-transform", "text-underline-position", |
||||
"text-wrap", "top", "transform", "transform-origin", "transform-style", |
||||
"transition", "transition-delay", "transition-duration", |
||||
"transition-property", "transition-timing-function", "unicode-bidi", |
||||
"vertical-align", "visibility", "voice-balance", "voice-duration", |
||||
"voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress", |
||||
"voice-volume", "volume", "white-space", "widows", "width", "word-break", |
||||
"word-spacing", "word-wrap", "z-index", |
||||
// SVG-specific
|
||||
"clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color", |
||||
"flood-opacity", "lighting-color", "stop-color", "stop-opacity", "pointer-events", |
||||
"color-interpolation", "color-interpolation-filters", |
||||
"color-rendering", "fill", "fill-opacity", "fill-rule", "image-rendering", |
||||
"marker", "marker-end", "marker-mid", "marker-start", "shape-rendering", "stroke", |
||||
"stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", |
||||
"stroke-miterlimit", "stroke-opacity", "stroke-width", "text-rendering", |
||||
"baseline-shift", "dominant-baseline", "glyph-orientation-horizontal", |
||||
"glyph-orientation-vertical", "text-anchor", "writing-mode" |
||||
], propertyKeywords = keySet(propertyKeywords_); |
||||
|
||||
var nonStandardPropertyKeywords_ = [ |
||||
"scrollbar-arrow-color", "scrollbar-base-color", "scrollbar-dark-shadow-color", |
||||
"scrollbar-face-color", "scrollbar-highlight-color", "scrollbar-shadow-color", |
||||
"scrollbar-3d-light-color", "scrollbar-track-color", "shape-inside", |
||||
"searchfield-cancel-button", "searchfield-decoration", "searchfield-results-button", |
||||
"searchfield-results-decoration", "zoom" |
||||
], nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_); |
||||
|
||||
var fontProperties_ = [ |
||||
"font-family", "src", "unicode-range", "font-variant", "font-feature-settings", |
||||
"font-stretch", "font-weight", "font-style" |
||||
], fontProperties = keySet(fontProperties_); |
||||
|
||||
var counterDescriptors_ = [ |
||||
"additive-symbols", "fallback", "negative", "pad", "prefix", "range", |
||||
"speak-as", "suffix", "symbols", "system" |
||||
], counterDescriptors = keySet(counterDescriptors_); |
||||
|
||||
var colorKeywords_ = [ |
||||
"aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", |
||||
"bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown", |
||||
"burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue", |
||||
"cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod", |
||||
"darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen", |
||||
"darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen", |
||||
"darkslateblue", "darkslategray", "darkturquoise", "darkviolet", |
||||
"deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick", |
||||
"floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite", |
||||
"gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew", |
||||
"hotpink", "indianred", "indigo", "ivory", "khaki", "lavender", |
||||
"lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral", |
||||
"lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightpink", |
||||
"lightsalmon", "lightseagreen", "lightskyblue", "lightslategray", |
||||
"lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta", |
||||
"maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple", |
||||
"mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise", |
||||
"mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", |
||||
"navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered", |
||||
"orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred", |
||||
"papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", |
||||
"purple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown", |
||||
"salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue", |
||||
"slateblue", "slategray", "snow", "springgreen", "steelblue", "tan", |
||||
"teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white", |
||||
"whitesmoke", "yellow", "yellowgreen" |
||||
], colorKeywords = keySet(colorKeywords_); |
||||
|
||||
var valueKeywords_ = [ |
||||
"above", "absolute", "activeborder", "additive", "activecaption", "afar", |
||||
"after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate", |
||||
"always", "amharic", "amharic-abegede", "antialiased", "appworkspace", |
||||
"arabic-indic", "armenian", "asterisks", "attr", "auto", "avoid", "avoid-column", "avoid-page", |
||||
"avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary", |
||||
"bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box", |
||||
"both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel", |
||||
"buttonface", "buttonhighlight", "buttonshadow", "buttontext", "calc", "cambodian", |
||||
"capitalize", "caps-lock-indicator", "caption", "captiontext", "caret", |
||||
"cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch", |
||||
"cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote", |
||||
"col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse", |
||||
"compact", "condensed", "contain", "content", |
||||
"content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop", |
||||
"cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal", |
||||
"decimal-leading-zero", "default", "default-button", "dense", "destination-atop", |
||||
"destination-in", "destination-out", "destination-over", "devanagari", "difference", |
||||
"disc", "discard", "disclosure-closed", "disclosure-open", "document", |
||||
"dot-dash", "dot-dot-dash", |
||||
"dotted", "double", "down", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out", |
||||
"element", "ellipse", "ellipsis", "embed", "end", "ethiopic", "ethiopic-abegede", |
||||
"ethiopic-abegede-am-et", "ethiopic-abegede-gez", "ethiopic-abegede-ti-er", |
||||
"ethiopic-abegede-ti-et", "ethiopic-halehame-aa-er", |
||||
"ethiopic-halehame-aa-et", "ethiopic-halehame-am-et", |
||||
"ethiopic-halehame-gez", "ethiopic-halehame-om-et", |
||||
"ethiopic-halehame-sid-et", "ethiopic-halehame-so-et", |
||||
"ethiopic-halehame-ti-er", "ethiopic-halehame-ti-et", "ethiopic-halehame-tig", |
||||
"ethiopic-numeric", "ew-resize", "exclusion", "expanded", "extends", "extra-condensed", |
||||
"extra-expanded", "fantasy", "fast", "fill", "fixed", "flat", "flex", "flex-end", "flex-start", "footnotes", |
||||
"forwards", "from", "geometricPrecision", "georgian", "graytext", "grid", "groove", |
||||
"gujarati", "gurmukhi", "hand", "hangul", "hangul-consonant", "hard-light", "hebrew", |
||||
"help", "hidden", "hide", "higher", "highlight", "highlighttext", |
||||
"hiragana", "hiragana-iroha", "horizontal", "hsl", "hsla", "hue", "icon", "ignore", |
||||
"inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite", |
||||
"infobackground", "infotext", "inherit", "initial", "inline", "inline-axis", |
||||
"inline-block", "inline-flex", "inline-grid", "inline-table", "inset", "inside", "intrinsic", "invert", |
||||
"italic", "japanese-formal", "japanese-informal", "justify", "kannada", |
||||
"katakana", "katakana-iroha", "keep-all", "khmer", |
||||
"korean-hangul-formal", "korean-hanja-formal", "korean-hanja-informal", |
||||
"landscape", "lao", "large", "larger", "left", "level", "lighter", "lighten", |
||||
"line-through", "linear", "linear-gradient", "lines", "list-item", "listbox", "listitem", |
||||
"local", "logical", "loud", "lower", "lower-alpha", "lower-armenian", |
||||
"lower-greek", "lower-hexadecimal", "lower-latin", "lower-norwegian", |
||||
"lower-roman", "lowercase", "ltr", "luminosity", "malayalam", "match", "matrix", "matrix3d", |
||||
"media-controls-background", "media-current-time-display", |
||||
"media-fullscreen-button", "media-mute-button", "media-play-button", |
||||
"media-return-to-realtime-button", "media-rewind-button", |
||||
"media-seek-back-button", "media-seek-forward-button", "media-slider", |
||||
"media-sliderthumb", "media-time-remaining-display", "media-volume-slider", |
||||
"media-volume-slider-container", "media-volume-sliderthumb", "medium", |
||||
"menu", "menulist", "menulist-button", "menulist-text", |
||||
"menulist-textfield", "menutext", "message-box", "middle", "min-intrinsic", |
||||
"mix", "mongolian", "monospace", "move", "multiple", "multiply", "myanmar", "n-resize", |
||||
"narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop", |
||||
"no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap", |
||||
"ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "open-quote", |
||||
"optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset", |
||||
"outside", "outside-shape", "overlay", "overline", "padding", "padding-box", |
||||
"painted", "page", "paused", "persian", "perspective", "plus-darker", "plus-lighter", |
||||
"pointer", "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d", |
||||
"progress", "push-button", "radial-gradient", "radio", "read-only", |
||||
"read-write", "read-write-plaintext-only", "rectangle", "region", |
||||
"relative", "repeat", "repeating-linear-gradient", |
||||
"repeating-radial-gradient", "repeat-x", "repeat-y", "reset", "reverse", |
||||
"rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY", |
||||
"rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running", |
||||
"s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen", |
||||
"scroll", "scrollbar", "se-resize", "searchfield", |
||||
"searchfield-cancel-button", "searchfield-decoration", |
||||
"searchfield-results-button", "searchfield-results-decoration", |
||||
"semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama", |
||||
"simp-chinese-formal", "simp-chinese-informal", "single", |
||||
"skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal", |
||||
"slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow", |
||||
"small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali", |
||||
"source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "spell-out", "square", |
||||
"square-button", "start", "static", "status-bar", "stretch", "stroke", "sub", |
||||
"subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "table", |
||||
"table-caption", "table-cell", "table-column", "table-column-group", |
||||
"table-footer-group", "table-header-group", "table-row", "table-row-group", |
||||
"tamil", |
||||
"telugu", "text", "text-bottom", "text-top", "textarea", "textfield", "thai", |
||||
"thick", "thin", "threeddarkshadow", "threedface", "threedhighlight", |
||||
"threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er", |
||||
"tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top", |
||||
"trad-chinese-formal", "trad-chinese-informal", |
||||
"translate", "translate3d", "translateX", "translateY", "translateZ", |
||||
"transparent", "ultra-condensed", "ultra-expanded", "underline", "up", |
||||
"upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal", |
||||
"upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url", |
||||
"var", "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted", |
||||
"visibleStroke", "visual", "w-resize", "wait", "wave", "wider", |
||||
"window", "windowframe", "windowtext", "words", "wrap", "wrap-reverse", "x-large", "x-small", "xor", |
||||
"xx-large", "xx-small" |
||||
], valueKeywords = keySet(valueKeywords_); |
||||
|
||||
var allWords = documentTypes_.concat(mediaTypes_).concat(mediaFeatures_).concat(mediaValueKeywords_) |
||||
.concat(propertyKeywords_).concat(nonStandardPropertyKeywords_).concat(colorKeywords_) |
||||
.concat(valueKeywords_); |
||||
CodeMirror.registerHelper("hintWords", "css", allWords); |
||||
|
||||
function tokenCComment(stream, state) { |
||||
var maybeEnd = false, ch; |
||||
while ((ch = stream.next()) != null) { |
||||
if (maybeEnd && ch == "/") { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
maybeEnd = (ch == "*"); |
||||
} |
||||
return ["comment", "comment"]; |
||||
} |
||||
|
||||
CodeMirror.defineMIME("text/css", { |
||||
documentTypes: documentTypes, |
||||
mediaTypes: mediaTypes, |
||||
mediaFeatures: mediaFeatures, |
||||
mediaValueKeywords: mediaValueKeywords, |
||||
propertyKeywords: propertyKeywords, |
||||
nonStandardPropertyKeywords: nonStandardPropertyKeywords, |
||||
fontProperties: fontProperties, |
||||
counterDescriptors: counterDescriptors, |
||||
colorKeywords: colorKeywords, |
||||
valueKeywords: valueKeywords, |
||||
tokenHooks: { |
||||
"/": function(stream, state) { |
||||
if (!stream.eat("*")) return false; |
||||
state.tokenize = tokenCComment; |
||||
return tokenCComment(stream, state); |
||||
} |
||||
}, |
||||
name: "css" |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-scss", { |
||||
mediaTypes: mediaTypes, |
||||
mediaFeatures: mediaFeatures, |
||||
mediaValueKeywords: mediaValueKeywords, |
||||
propertyKeywords: propertyKeywords, |
||||
nonStandardPropertyKeywords: nonStandardPropertyKeywords, |
||||
colorKeywords: colorKeywords, |
||||
valueKeywords: valueKeywords, |
||||
fontProperties: fontProperties, |
||||
allowNested: true, |
||||
tokenHooks: { |
||||
"/": function(stream, state) { |
||||
if (stream.eat("/")) { |
||||
stream.skipToEnd(); |
||||
return ["comment", "comment"]; |
||||
} else if (stream.eat("*")) { |
||||
state.tokenize = tokenCComment; |
||||
return tokenCComment(stream, state); |
||||
} else { |
||||
return ["operator", "operator"]; |
||||
} |
||||
}, |
||||
":": function(stream) { |
||||
if (stream.match(/\s*\{/)) |
||||
return [null, "{"]; |
||||
return false; |
||||
}, |
||||
"$": function(stream) { |
||||
stream.match(/^[\w-]+/); |
||||
if (stream.match(/^\s*:/, false)) |
||||
return ["variable-2", "variable-definition"]; |
||||
return ["variable-2", "variable"]; |
||||
}, |
||||
"#": function(stream) { |
||||
if (!stream.eat("{")) return false; |
||||
return [null, "interpolation"]; |
||||
} |
||||
}, |
||||
name: "css", |
||||
helperType: "scss" |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-less", { |
||||
mediaTypes: mediaTypes, |
||||
mediaFeatures: mediaFeatures, |
||||
mediaValueKeywords: mediaValueKeywords, |
||||
propertyKeywords: propertyKeywords, |
||||
nonStandardPropertyKeywords: nonStandardPropertyKeywords, |
||||
colorKeywords: colorKeywords, |
||||
valueKeywords: valueKeywords, |
||||
fontProperties: fontProperties, |
||||
allowNested: true, |
||||
tokenHooks: { |
||||
"/": function(stream, state) { |
||||
if (stream.eat("/")) { |
||||
stream.skipToEnd(); |
||||
return ["comment", "comment"]; |
||||
} else if (stream.eat("*")) { |
||||
state.tokenize = tokenCComment; |
||||
return tokenCComment(stream, state); |
||||
} else { |
||||
return ["operator", "operator"]; |
||||
} |
||||
}, |
||||
"@": function(stream) { |
||||
if (stream.eat("{")) return [null, "interpolation"]; |
||||
if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/, false)) return false; |
||||
stream.eatWhile(/[\w\\\-]/); |
||||
if (stream.match(/^\s*:/, false)) |
||||
return ["variable-2", "variable-definition"]; |
||||
return ["variable-2", "variable"]; |
||||
}, |
||||
"&": function() { |
||||
return ["atom", "atom"]; |
||||
} |
||||
}, |
||||
name: "css", |
||||
helperType: "less" |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-gss", { |
||||
documentTypes: documentTypes, |
||||
mediaTypes: mediaTypes, |
||||
mediaFeatures: mediaFeatures, |
||||
propertyKeywords: propertyKeywords, |
||||
nonStandardPropertyKeywords: nonStandardPropertyKeywords, |
||||
fontProperties: fontProperties, |
||||
counterDescriptors: counterDescriptors, |
||||
colorKeywords: colorKeywords, |
||||
valueKeywords: valueKeywords, |
||||
supportsAtComponent: true, |
||||
tokenHooks: { |
||||
"/": function(stream, state) { |
||||
if (!stream.eat("*")) return false; |
||||
state.tokenize = tokenCComment; |
||||
return tokenCComment(stream, state); |
||||
} |
||||
}, |
||||
name: "css", |
||||
helperType: "gss" |
||||
}); |
||||
|
||||
}); |
||||
@ -0,0 +1,103 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Closure Stylesheets (GSS) mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<link rel="stylesheet" href="../../addon/hint/show-hint.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="css.js"></script> |
||||
<script src="../../addon/hint/show-hint.js"></script> |
||||
<script src="../../addon/hint/css-hint.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Closure Stylesheets (GSS)</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Closure Stylesheets (GSS) mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
/* Some example Closure Stylesheets */ |
||||
|
||||
@provide 'some.styles'; |
||||
|
||||
@require 'other.styles'; |
||||
|
||||
@component { |
||||
|
||||
@def FONT_FAMILY "Times New Roman", Georgia, Serif; |
||||
@def FONT_SIZE_NORMAL 15px; |
||||
@def FONT_NORMAL normal FONT_SIZE_NORMAL FONT_FAMILY; |
||||
|
||||
@def BG_COLOR rgb(235, 239, 249); |
||||
|
||||
@def DIALOG_BORDER_COLOR rgb(107, 144, 218); |
||||
@def DIALOG_BG_COLOR BG_COLOR; |
||||
|
||||
@def LEFT_HAND_NAV_WIDTH 180px; |
||||
@def LEFT_HAND_NAV_PADDING 3px; |
||||
|
||||
@defmixin size(WIDTH, HEIGHT) { |
||||
width: WIDTH; |
||||
height: HEIGHT; |
||||
} |
||||
|
||||
body { |
||||
background-color: BG_COLOR; |
||||
margin: 0; |
||||
padding: 3em 6em; |
||||
font: FONT_NORMAL; |
||||
color: #000; |
||||
} |
||||
|
||||
#navigation a { |
||||
font-weight: bold; |
||||
text-decoration: none !important; |
||||
} |
||||
|
||||
.dialog { |
||||
background-color: DIALOG_BG_COLOR; |
||||
border: 1px solid DIALOG_BORDER_COLOR; |
||||
} |
||||
|
||||
.content { |
||||
position: absolute; |
||||
margin-left: add(LEFT_HAND_NAV_PADDING, /* padding left */ |
||||
LEFT_HAND_NAV_WIDTH, |
||||
LEFT_HAND_NAV_PADDING); /* padding right */ |
||||
|
||||
} |
||||
|
||||
.logo { |
||||
@mixin size(150px, 55px); |
||||
background-image: url('http://www.google.com/images/logo_sm.gif'); |
||||
} |
||||
|
||||
} |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
extraKeys: {"Ctrl-Space": "autocomplete"}, |
||||
lineNumbers: true, |
||||
matchBrackets: "text/x-less", |
||||
mode: "text/x-gss" |
||||
}); |
||||
</script> |
||||
|
||||
<p>A mode for <a href="https://github.com/google/closure-stylesheets">Closure Stylesheets</a> (GSS).</p> |
||||
<p><strong>MIME type defined:</strong> <code>text/x-gss</code>.</p> |
||||
|
||||
<p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#gss_*">normal</a>, <a href="../../test/index.html#verbose,gss_*">verbose</a>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,17 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
"use strict"; |
||||
|
||||
var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-gss"); |
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "gss"); } |
||||
|
||||
MT("atComponent", |
||||
"[def @component] {", |
||||
"[tag foo] {", |
||||
" [property color]: [keyword black];", |
||||
"}", |
||||
"}"); |
||||
|
||||
})(); |
||||
@ -0,0 +1,75 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: CSS mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<link rel="stylesheet" href="../../addon/hint/show-hint.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="css.js"></script> |
||||
<script src="../../addon/hint/show-hint.js"></script> |
||||
<script src="../../addon/hint/css-hint.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">CSS</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>CSS mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
/* Some example CSS */ |
||||
|
||||
@import url("something.css"); |
||||
|
||||
body { |
||||
margin: 0; |
||||
padding: 3em 6em; |
||||
font-family: tahoma, arial, sans-serif; |
||||
color: #000; |
||||
} |
||||
|
||||
#navigation a { |
||||
font-weight: bold; |
||||
text-decoration: none !important; |
||||
} |
||||
|
||||
h1 { |
||||
font-size: 2.5em; |
||||
} |
||||
|
||||
h2 { |
||||
font-size: 1.7em; |
||||
} |
||||
|
||||
h1:before, h2:before { |
||||
content: "::"; |
||||
} |
||||
|
||||
code { |
||||
font-family: courier, monospace; |
||||
font-size: 80%; |
||||
color: #418A8A; |
||||
} |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
extraKeys: {"Ctrl-Space": "autocomplete"}, |
||||
}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/css</code>, <code>text/x-scss</code> (<a href="scss.html">demo</a>), <code>text/x-less</code> (<a href="less.html">demo</a>).</p> |
||||
|
||||
<p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#css_*">normal</a>, <a href="../../test/index.html#verbose,css_*">verbose</a>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,152 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: LESS mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="css.js"></script> |
||||
<style>.CodeMirror {border: 1px solid #ddd; line-height: 1.2;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">LESS</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>LESS mode</h2> |
||||
<form><textarea id="code" name="code">@media screen and (device-aspect-ratio: 16/9) { … } |
||||
@media screen and (device-aspect-ratio: 1280/720) { … } |
||||
@media screen and (device-aspect-ratio: 2560/1440) { … } |
||||
|
||||
html:lang(fr-be) |
||||
|
||||
tr:nth-child(2n+1) /* represents every odd row of an HTML table */ |
||||
|
||||
img:nth-of-type(2n+1) { float: right; } |
||||
img:nth-of-type(2n) { float: left; } |
||||
|
||||
body > h2:not(:first-of-type):not(:last-of-type) |
||||
|
||||
html|*:not(:link):not(:visited) |
||||
*|*:not(:hover) |
||||
p::first-line { text-transform: uppercase } |
||||
|
||||
@namespace foo url(http://www.example.com); |
||||
foo|h1 { color: blue } /* first rule */ |
||||
|
||||
span[hello="Ocean"][goodbye="Land"] |
||||
|
||||
E[foo]{ |
||||
padding:65px; |
||||
} |
||||
|
||||
input[type="search"]::-webkit-search-decoration, |
||||
input[type="search"]::-webkit-search-cancel-button { |
||||
-webkit-appearance: none; // Inner-padding issues in Chrome OSX, Safari 5 |
||||
} |
||||
button::-moz-focus-inner, |
||||
input::-moz-focus-inner { // Inner padding and border oddities in FF3/4 |
||||
padding: 0; |
||||
border: 0; |
||||
} |
||||
.btn { |
||||
// reset here as of 2.0.3 due to Recess property order |
||||
border-color: #ccc; |
||||
border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25); |
||||
} |
||||
fieldset span button, fieldset span input[type="file"] { |
||||
font-size:12px; |
||||
font-family:Arial, Helvetica, sans-serif; |
||||
} |
||||
|
||||
.rounded-corners (@radius: 5px) { |
||||
border-radius: @radius; |
||||
-webkit-border-radius: @radius; |
||||
-moz-border-radius: @radius; |
||||
} |
||||
|
||||
@import url("something.css"); |
||||
|
||||
@light-blue: hsl(190, 50%, 65%); |
||||
|
||||
#menu { |
||||
position: absolute; |
||||
width: 100%; |
||||
z-index: 3; |
||||
clear: both; |
||||
display: block; |
||||
background-color: @blue; |
||||
height: 42px; |
||||
border-top: 2px solid lighten(@alpha-blue, 20%); |
||||
border-bottom: 2px solid darken(@alpha-blue, 25%); |
||||
.box-shadow(0, 1px, 8px, 0.6); |
||||
-moz-box-shadow: 0 0 0 #000; // Because firefox sucks. |
||||
|
||||
&.docked { |
||||
background-color: hsla(210, 60%, 40%, 0.4); |
||||
} |
||||
&:hover { |
||||
background-color: @blue; |
||||
} |
||||
|
||||
#dropdown { |
||||
margin: 0 0 0 117px; |
||||
padding: 0; |
||||
padding-top: 5px; |
||||
display: none; |
||||
width: 190px; |
||||
border-top: 2px solid @medium; |
||||
color: @highlight; |
||||
border: 2px solid darken(@medium, 25%); |
||||
border-left-color: darken(@medium, 15%); |
||||
border-right-color: darken(@medium, 15%); |
||||
border-top-width: 0; |
||||
background-color: darken(@medium, 10%); |
||||
ul { |
||||
padding: 0px; |
||||
} |
||||
li { |
||||
font-size: 14px; |
||||
display: block; |
||||
text-align: left; |
||||
padding: 0; |
||||
border: 0; |
||||
a { |
||||
display: block; |
||||
padding: 0px 15px; |
||||
text-decoration: none; |
||||
color: white; |
||||
&:hover { |
||||
background-color: darken(@medium, 15%); |
||||
text-decoration: none; |
||||
} |
||||
} |
||||
} |
||||
.border-radius(5px, bottom); |
||||
.box-shadow(0, 6px, 8px, 0.5); |
||||
} |
||||
} |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers : true, |
||||
matchBrackets : true, |
||||
mode: "text/x-less" |
||||
}); |
||||
</script> |
||||
|
||||
<p>The LESS mode is a sub-mode of the <a href="index.html">CSS mode</a> (defined in <code>css.js</code>).</p> |
||||
|
||||
<p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#less_*">normal</a>, <a href="../../test/index.html#verbose,less_*">verbose</a>.</p> |
||||
</article> |
||||
@ -0,0 +1,54 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
"use strict"; |
||||
|
||||
var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-less"); |
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "less"); } |
||||
|
||||
MT("variable", |
||||
"[variable-2 @base]: [atom #f04615];", |
||||
"[qualifier .class] {", |
||||
" [property width]: [variable percentage]([number 0.5]); [comment // returns `50%`]", |
||||
" [property color]: [variable saturate]([variable-2 @base], [number 5%]);", |
||||
"}"); |
||||
|
||||
MT("amp", |
||||
"[qualifier .child], [qualifier .sibling] {", |
||||
" [qualifier .parent] [atom &] {", |
||||
" [property color]: [keyword black];", |
||||
" }", |
||||
" [atom &] + [atom &] {", |
||||
" [property color]: [keyword red];", |
||||
" }", |
||||
"}"); |
||||
|
||||
MT("mixin", |
||||
"[qualifier .mixin] ([variable dark]; [variable-2 @color]) {", |
||||
" [property color]: [atom darken]([variable-2 @color], [number 10%]);", |
||||
"}", |
||||
"[qualifier .mixin] ([variable light]; [variable-2 @color]) {", |
||||
" [property color]: [atom lighten]([variable-2 @color], [number 10%]);", |
||||
"}", |
||||
"[qualifier .mixin] ([variable-2 @_]; [variable-2 @color]) {", |
||||
" [property display]: [atom block];", |
||||
"}", |
||||
"[variable-2 @switch]: [variable light];", |
||||
"[qualifier .class] {", |
||||
" [qualifier .mixin]([variable-2 @switch]; [atom #888]);", |
||||
"}"); |
||||
|
||||
MT("nest", |
||||
"[qualifier .one] {", |
||||
" [def @media] ([property width]: [number 400px]) {", |
||||
" [property font-size]: [number 1.2em];", |
||||
" [def @media] [attribute print] [keyword and] [property color] {", |
||||
" [property color]: [keyword blue];", |
||||
" }", |
||||
" }", |
||||
"}"); |
||||
|
||||
|
||||
MT("interpolation", ".@{[variable foo]} { [property font-weight]: [atom bold]; }"); |
||||
})(); |
||||
@ -0,0 +1,157 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: SCSS mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="css.js"></script> |
||||
<style>.CodeMirror {background: #f8f8f8;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">SCSS</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>SCSS mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
/* Some example SCSS */ |
||||
|
||||
@import "compass/css3"; |
||||
$variable: #333; |
||||
|
||||
$blue: #3bbfce; |
||||
$margin: 16px; |
||||
|
||||
.content-navigation { |
||||
#nested { |
||||
background-color: black; |
||||
} |
||||
border-color: $blue; |
||||
color: |
||||
darken($blue, 9%); |
||||
} |
||||
|
||||
.border { |
||||
padding: $margin / 2; |
||||
margin: $margin / 2; |
||||
border-color: $blue; |
||||
} |
||||
|
||||
@mixin table-base { |
||||
th { |
||||
text-align: center; |
||||
font-weight: bold; |
||||
} |
||||
td, th {padding: 2px} |
||||
} |
||||
|
||||
table.hl { |
||||
margin: 2em 0; |
||||
td.ln { |
||||
text-align: right; |
||||
} |
||||
} |
||||
|
||||
li { |
||||
font: { |
||||
family: serif; |
||||
weight: bold; |
||||
size: 1.2em; |
||||
} |
||||
} |
||||
|
||||
@mixin left($dist) { |
||||
float: left; |
||||
margin-left: $dist; |
||||
} |
||||
|
||||
#data { |
||||
@include left(10px); |
||||
@include table-base; |
||||
} |
||||
|
||||
.source { |
||||
@include flow-into(target); |
||||
border: 10px solid green; |
||||
margin: 20px; |
||||
width: 200px; } |
||||
|
||||
.new-container { |
||||
@include flow-from(target); |
||||
border: 10px solid red; |
||||
margin: 20px; |
||||
width: 200px; } |
||||
|
||||
body { |
||||
margin: 0; |
||||
padding: 3em 6em; |
||||
font-family: tahoma, arial, sans-serif; |
||||
color: #000; |
||||
} |
||||
|
||||
@mixin yellow() { |
||||
background: yellow; |
||||
} |
||||
|
||||
.big { |
||||
font-size: 14px; |
||||
} |
||||
|
||||
.nested { |
||||
@include border-radius(3px); |
||||
@extend .big; |
||||
p { |
||||
background: whitesmoke; |
||||
a { |
||||
color: red; |
||||
} |
||||
} |
||||
} |
||||
|
||||
#navigation a { |
||||
font-weight: bold; |
||||
text-decoration: none !important; |
||||
} |
||||
|
||||
h1 { |
||||
font-size: 2.5em; |
||||
} |
||||
|
||||
h2 { |
||||
font-size: 1.7em; |
||||
} |
||||
|
||||
h1:before, h2:before { |
||||
content: "::"; |
||||
} |
||||
|
||||
code { |
||||
font-family: courier, monospace; |
||||
font-size: 80%; |
||||
color: #418A8A; |
||||
} |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
mode: "text/x-scss" |
||||
}); |
||||
</script> |
||||
|
||||
<p>The SCSS mode is a sub-mode of the <a href="index.html">CSS mode</a> (defined in <code>css.js</code>).</p> |
||||
|
||||
<p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#scss_*">normal</a>, <a href="../../test/index.html#verbose,scss_*">verbose</a>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,110 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-scss"); |
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "scss"); } |
||||
|
||||
MT('url_with_quotation', |
||||
"[tag foo] { [property background]:[atom url]([string test.jpg]) }"); |
||||
|
||||
MT('url_with_double_quotes', |
||||
"[tag foo] { [property background]:[atom url]([string \"test.jpg\"]) }"); |
||||
|
||||
MT('url_with_single_quotes', |
||||
"[tag foo] { [property background]:[atom url]([string \'test.jpg\']) }"); |
||||
|
||||
MT('string', |
||||
"[def @import] [string \"compass/css3\"]"); |
||||
|
||||
MT('important_keyword', |
||||
"[tag foo] { [property background]:[atom url]([string \'test.jpg\']) [keyword !important] }"); |
||||
|
||||
MT('variable', |
||||
"[variable-2 $blue]:[atom #333]"); |
||||
|
||||
MT('variable_as_attribute', |
||||
"[tag foo] { [property color]:[variable-2 $blue] }"); |
||||
|
||||
MT('numbers', |
||||
"[tag foo] { [property padding]:[number 10px] [number 10] [number 10em] [number 8in] }"); |
||||
|
||||
MT('number_percentage', |
||||
"[tag foo] { [property width]:[number 80%] }"); |
||||
|
||||
MT('selector', |
||||
"[builtin #hello][qualifier .world]{}"); |
||||
|
||||
MT('singleline_comment', |
||||
"[comment // this is a comment]"); |
||||
|
||||
MT('multiline_comment', |
||||
"[comment /*foobar*/]"); |
||||
|
||||
MT('attribute_with_hyphen', |
||||
"[tag foo] { [property font-size]:[number 10px] }"); |
||||
|
||||
MT('string_after_attribute', |
||||
"[tag foo] { [property content]:[string \"::\"] }"); |
||||
|
||||
MT('directives', |
||||
"[def @include] [qualifier .mixin]"); |
||||
|
||||
MT('basic_structure', |
||||
"[tag p] { [property background]:[keyword red]; }"); |
||||
|
||||
MT('nested_structure', |
||||
"[tag p] { [tag a] { [property color]:[keyword red]; } }"); |
||||
|
||||
MT('mixin', |
||||
"[def @mixin] [tag table-base] {}"); |
||||
|
||||
MT('number_without_semicolon', |
||||
"[tag p] {[property width]:[number 12]}", |
||||
"[tag a] {[property color]:[keyword red];}"); |
||||
|
||||
MT('atom_in_nested_block', |
||||
"[tag p] { [tag a] { [property color]:[atom #000]; } }"); |
||||
|
||||
MT('interpolation_in_property', |
||||
"[tag foo] { #{[variable-2 $hello]}:[number 2]; }"); |
||||
|
||||
MT('interpolation_in_selector', |
||||
"[tag foo]#{[variable-2 $hello]} { [property color]:[atom #000]; }"); |
||||
|
||||
MT('interpolation_error', |
||||
"[tag foo]#{[variable foo]} { [property color]:[atom #000]; }"); |
||||
|
||||
MT("divide_operator", |
||||
"[tag foo] { [property width]:[number 4] [operator /] [number 2] }"); |
||||
|
||||
MT('nested_structure_with_id_selector', |
||||
"[tag p] { [builtin #hello] { [property color]:[keyword red]; } }"); |
||||
|
||||
MT('indent_mixin', |
||||
"[def @mixin] [tag container] (", |
||||
" [variable-2 $a]: [number 10],", |
||||
" [variable-2 $b]: [number 10])", |
||||
"{}"); |
||||
|
||||
MT('indent_nested', |
||||
"[tag foo] {", |
||||
" [tag bar] {", |
||||
" }", |
||||
"}"); |
||||
|
||||
MT('indent_parentheses', |
||||
"[tag foo] {", |
||||
" [property color]: [atom darken]([variable-2 $blue],", |
||||
" [number 9%]);", |
||||
"}"); |
||||
|
||||
MT('indent_vardef', |
||||
"[variable-2 $name]:", |
||||
" [string 'val'];", |
||||
"[tag tag] {", |
||||
" [tag inner] {", |
||||
" [property margin]: [number 3px];", |
||||
" }", |
||||
"}"); |
||||
})(); |
||||
@ -0,0 +1,200 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function() { |
||||
var mode = CodeMirror.getMode({indentUnit: 2}, "css"); |
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } |
||||
|
||||
// Error, because "foobarhello" is neither a known type or property, but
|
||||
// property was expected (after "and"), and it should be in parentheses.
|
||||
MT("atMediaUnknownType", |
||||
"[def @media] [attribute screen] [keyword and] [error foobarhello] { }"); |
||||
|
||||
// Soft error, because "foobarhello" is not a known property or type.
|
||||
MT("atMediaUnknownProperty", |
||||
"[def @media] [attribute screen] [keyword and] ([error foobarhello]) { }"); |
||||
|
||||
// Make sure nesting works with media queries
|
||||
MT("atMediaMaxWidthNested", |
||||
"[def @media] [attribute screen] [keyword and] ([property max-width]: [number 25px]) { [tag foo] { } }"); |
||||
|
||||
MT("atMediaFeatureValueKeyword", |
||||
"[def @media] ([property orientation]: [keyword landscape]) { }"); |
||||
|
||||
MT("atMediaUnknownFeatureValueKeyword", |
||||
"[def @media] ([property orientation]: [error upsidedown]) { }"); |
||||
|
||||
MT("tagSelector", |
||||
"[tag foo] { }"); |
||||
|
||||
MT("classSelector", |
||||
"[qualifier .foo-bar_hello] { }"); |
||||
|
||||
MT("idSelector", |
||||
"[builtin #foo] { [error #foo] }"); |
||||
|
||||
MT("tagSelectorUnclosed", |
||||
"[tag foo] { [property margin]: [number 0] } [tag bar] { }"); |
||||
|
||||
MT("tagStringNoQuotes", |
||||
"[tag foo] { [property font-family]: [variable hello] [variable world]; }"); |
||||
|
||||
MT("tagStringDouble", |
||||
"[tag foo] { [property font-family]: [string \"hello world\"]; }"); |
||||
|
||||
MT("tagStringSingle", |
||||
"[tag foo] { [property font-family]: [string 'hello world']; }"); |
||||
|
||||
MT("tagColorKeyword", |
||||
"[tag foo] {", |
||||
" [property color]: [keyword black];", |
||||
" [property color]: [keyword navy];", |
||||
" [property color]: [keyword yellow];", |
||||
"}"); |
||||
|
||||
MT("tagColorHex3", |
||||
"[tag foo] { [property background]: [atom #fff]; }"); |
||||
|
||||
MT("tagColorHex4", |
||||
"[tag foo] { [property background]: [atom #ffff]; }"); |
||||
|
||||
MT("tagColorHex6", |
||||
"[tag foo] { [property background]: [atom #ffffff]; }"); |
||||
|
||||
MT("tagColorHex8", |
||||
"[tag foo] { [property background]: [atom #ffffffff]; }"); |
||||
|
||||
MT("tagColorHex5Invalid", |
||||
"[tag foo] { [property background]: [atom&error #fffff]; }"); |
||||
|
||||
MT("tagColorHexInvalid", |
||||
"[tag foo] { [property background]: [atom&error #ffg]; }"); |
||||
|
||||
MT("tagNegativeNumber", |
||||
"[tag foo] { [property margin]: [number -5px]; }"); |
||||
|
||||
MT("tagPositiveNumber", |
||||
"[tag foo] { [property padding]: [number 5px]; }"); |
||||
|
||||
MT("tagVendor", |
||||
"[tag foo] { [meta -foo-][property box-sizing]: [meta -foo-][atom border-box]; }"); |
||||
|
||||
MT("tagBogusProperty", |
||||
"[tag foo] { [property&error barhelloworld]: [number 0]; }"); |
||||
|
||||
MT("tagTwoProperties", |
||||
"[tag foo] { [property margin]: [number 0]; [property padding]: [number 0]; }"); |
||||
|
||||
MT("tagTwoPropertiesURL", |
||||
"[tag foo] { [property background]: [atom url]([string //example.com/foo.png]); [property padding]: [number 0]; }"); |
||||
|
||||
MT("indent_tagSelector", |
||||
"[tag strong], [tag em] {", |
||||
" [property background]: [atom rgba](", |
||||
" [number 255], [number 255], [number 0], [number .2]", |
||||
" );", |
||||
"}"); |
||||
|
||||
MT("indent_atMedia", |
||||
"[def @media] {", |
||||
" [tag foo] {", |
||||
" [property color]:", |
||||
" [keyword yellow];", |
||||
" }", |
||||
"}"); |
||||
|
||||
MT("indent_comma", |
||||
"[tag foo] {", |
||||
" [property font-family]: [variable verdana],", |
||||
" [atom sans-serif];", |
||||
"}"); |
||||
|
||||
MT("indent_parentheses", |
||||
"[tag foo]:[variable-3 before] {", |
||||
" [property background]: [atom url](", |
||||
"[string blahblah]", |
||||
"[string etc]", |
||||
"[string ]) [keyword !important];", |
||||
"}"); |
||||
|
||||
MT("font_face", |
||||
"[def @font-face] {", |
||||
" [property font-family]: [string 'myfont'];", |
||||
" [error nonsense]: [string 'abc'];", |
||||
" [property src]: [atom url]([string http://blah]),", |
||||
" [atom url]([string http://foo]);", |
||||
"}"); |
||||
|
||||
MT("empty_url", |
||||
"[def @import] [atom url]() [attribute screen];"); |
||||
|
||||
MT("parens", |
||||
"[qualifier .foo] {", |
||||
" [property background-image]: [variable fade]([atom #000], [number 20%]);", |
||||
" [property border-image]: [atom linear-gradient](", |
||||
" [atom to] [atom bottom],", |
||||
" [variable fade]([atom #000], [number 20%]) [number 0%],", |
||||
" [variable fade]([atom #000], [number 20%]) [number 100%]", |
||||
" );", |
||||
"}"); |
||||
|
||||
MT("css_variable", |
||||
":[variable-3 root] {", |
||||
" [variable-2 --main-color]: [atom #06c];", |
||||
"}", |
||||
"[tag h1][builtin #foo] {", |
||||
" [property color]: [atom var]([variable-2 --main-color]);", |
||||
"}"); |
||||
|
||||
MT("supports", |
||||
"[def @supports] ([keyword not] (([property text-align-last]: [atom justify]) [keyword or] ([meta -moz-][property text-align-last]: [atom justify])) {", |
||||
" [property text-align-last]: [atom justify];", |
||||
"}"); |
||||
|
||||
MT("document", |
||||
"[def @document] [tag url]([string http://blah]),", |
||||
" [tag url-prefix]([string https://]),", |
||||
" [tag domain]([string blah.com]),", |
||||
" [tag regexp]([string \".*blah.+\"]) {", |
||||
" [builtin #id] {", |
||||
" [property background-color]: [keyword white];", |
||||
" }", |
||||
" [tag foo] {", |
||||
" [property font-family]: [variable Verdana], [atom sans-serif];", |
||||
" }", |
||||
"}"); |
||||
|
||||
MT("document_url", |
||||
"[def @document] [tag url]([string http://blah]) { [qualifier .class] { } }"); |
||||
|
||||
MT("document_urlPrefix", |
||||
"[def @document] [tag url-prefix]([string https://]) { [builtin #id] { } }"); |
||||
|
||||
MT("document_domain", |
||||
"[def @document] [tag domain]([string blah.com]) { [tag foo] { } }"); |
||||
|
||||
MT("document_regexp", |
||||
"[def @document] [tag regexp]([string \".*blah.+\"]) { [builtin #id] { } }"); |
||||
|
||||
MT("counter-style", |
||||
"[def @counter-style] [variable binary] {", |
||||
" [property system]: [atom numeric];", |
||||
" [property symbols]: [number 0] [number 1];", |
||||
" [property suffix]: [string \".\"];", |
||||
" [property range]: [atom infinite];", |
||||
" [property speak-as]: [atom numeric];", |
||||
"}"); |
||||
|
||||
MT("counter-style-additive-symbols", |
||||
"[def @counter-style] [variable simple-roman] {", |
||||
" [property system]: [atom additive];", |
||||
" [property additive-symbols]: [number 10] [variable X], [number 5] [variable V], [number 1] [variable I];", |
||||
" [property range]: [number 1] [number 49];", |
||||
"}"); |
||||
|
||||
MT("counter-style-use", |
||||
"[tag ol][qualifier .roman] { [property list-style]: [variable simple-roman]; }"); |
||||
|
||||
MT("counter-style-symbols", |
||||
"[tag ol] { [property list-style]: [atom symbols]([atom cyclic] [string \"*\"] [string \"\\2020\"] [string \"\\2021\"] [string \"\\A7\"]); }"); |
||||
})(); |
||||
@ -0,0 +1,146 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
// By the Neo4j Team and contributors.
|
||||
// https://github.com/neo4j-contrib/CodeMirror
|
||||
|
||||
(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"; |
||||
var wordRegexp = function(words) { |
||||
return new RegExp("^(?:" + words.join("|") + ")$", "i"); |
||||
}; |
||||
|
||||
CodeMirror.defineMode("cypher", function(config) { |
||||
var tokenBase = function(stream/*, state*/) { |
||||
var ch = stream.next(); |
||||
if (ch === "\"" || ch === "'") { |
||||
stream.match(/.+?["']/); |
||||
return "string"; |
||||
} |
||||
if (/[{}\(\),\.;\[\]]/.test(ch)) { |
||||
curPunc = ch; |
||||
return "node"; |
||||
} else if (ch === "/" && stream.eat("/")) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} else if (operatorChars.test(ch)) { |
||||
stream.eatWhile(operatorChars); |
||||
return null; |
||||
} else { |
||||
stream.eatWhile(/[_\w\d]/); |
||||
if (stream.eat(":")) { |
||||
stream.eatWhile(/[\w\d_\-]/); |
||||
return "atom"; |
||||
} |
||||
var word = stream.current(); |
||||
if (funcs.test(word)) return "builtin"; |
||||
if (preds.test(word)) return "def"; |
||||
if (keywords.test(word)) return "keyword"; |
||||
return "variable"; |
||||
} |
||||
}; |
||||
var pushContext = function(state, type, col) { |
||||
return state.context = { |
||||
prev: state.context, |
||||
indent: state.indent, |
||||
col: col, |
||||
type: type |
||||
}; |
||||
}; |
||||
var popContext = function(state) { |
||||
state.indent = state.context.indent; |
||||
return state.context = state.context.prev; |
||||
}; |
||||
var indentUnit = config.indentUnit; |
||||
var curPunc; |
||||
var funcs = wordRegexp(["abs", "acos", "allShortestPaths", "asin", "atan", "atan2", "avg", "ceil", "coalesce", "collect", "cos", "cot", "count", "degrees", "e", "endnode", "exp", "extract", "filter", "floor", "haversin", "head", "id", "keys", "labels", "last", "left", "length", "log", "log10", "lower", "ltrim", "max", "min", "node", "nodes", "percentileCont", "percentileDisc", "pi", "radians", "rand", "range", "reduce", "rel", "relationship", "relationships", "replace", "reverse", "right", "round", "rtrim", "shortestPath", "sign", "sin", "size", "split", "sqrt", "startnode", "stdev", "stdevp", "str", "substring", "sum", "tail", "tan", "timestamp", "toFloat", "toInt", "toString", "trim", "type", "upper"]); |
||||
var preds = wordRegexp(["all", "and", "any", "contains", "exists", "has", "in", "none", "not", "or", "single", "xor"]); |
||||
var keywords = wordRegexp(["as", "asc", "ascending", "assert", "by", "case", "commit", "constraint", "create", "csv", "cypher", "delete", "desc", "descending", "detach", "distinct", "drop", "else", "end", "ends", "explain", "false", "fieldterminator", "foreach", "from", "headers", "in", "index", "is", "join", "limit", "load", "match", "merge", "null", "on", "optional", "order", "periodic", "profile", "remove", "return", "scan", "set", "skip", "start", "starts", "then", "true", "union", "unique", "unwind", "using", "when", "where", "with"]); |
||||
var operatorChars = /[*+\-<>=&|~%^]/; |
||||
|
||||
return { |
||||
startState: function(/*base*/) { |
||||
return { |
||||
tokenize: tokenBase, |
||||
context: null, |
||||
indent: 0, |
||||
col: 0 |
||||
}; |
||||
}, |
||||
token: function(stream, state) { |
||||
if (stream.sol()) { |
||||
if (state.context && (state.context.align == null)) { |
||||
state.context.align = false; |
||||
} |
||||
state.indent = stream.indentation(); |
||||
} |
||||
if (stream.eatSpace()) { |
||||
return null; |
||||
} |
||||
var style = state.tokenize(stream, state); |
||||
if (style !== "comment" && state.context && (state.context.align == null) && state.context.type !== "pattern") { |
||||
state.context.align = true; |
||||
} |
||||
if (curPunc === "(") { |
||||
pushContext(state, ")", stream.column()); |
||||
} else if (curPunc === "[") { |
||||
pushContext(state, "]", stream.column()); |
||||
} else if (curPunc === "{") { |
||||
pushContext(state, "}", stream.column()); |
||||
} else if (/[\]\}\)]/.test(curPunc)) { |
||||
while (state.context && state.context.type === "pattern") { |
||||
popContext(state); |
||||
} |
||||
if (state.context && curPunc === state.context.type) { |
||||
popContext(state); |
||||
} |
||||
} else if (curPunc === "." && state.context && state.context.type === "pattern") { |
||||
popContext(state); |
||||
} else if (/atom|string|variable/.test(style) && state.context) { |
||||
if (/[\}\]]/.test(state.context.type)) { |
||||
pushContext(state, "pattern", stream.column()); |
||||
} else if (state.context.type === "pattern" && !state.context.align) { |
||||
state.context.align = true; |
||||
state.context.col = stream.column(); |
||||
} |
||||
} |
||||
return style; |
||||
}, |
||||
indent: function(state, textAfter) { |
||||
var firstChar = textAfter && textAfter.charAt(0); |
||||
var context = state.context; |
||||
if (/[\]\}]/.test(firstChar)) { |
||||
while (context && context.type === "pattern") { |
||||
context = context.prev; |
||||
} |
||||
} |
||||
var closing = context && firstChar === context.type; |
||||
if (!context) return 0; |
||||
if (context.type === "keywords") return CodeMirror.commands.newlineAndIndent; |
||||
if (context.align) return context.col + (closing ? 0 : 1); |
||||
return context.indent + (closing ? 0 : indentUnit); |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.modeExtensions["cypher"] = { |
||||
autoFormatLineBreaks: function(text) { |
||||
var i, lines, reProcessedPortion; |
||||
var lines = text.split("\n"); |
||||
var reProcessedPortion = /\s+\b(return|where|order by|match|with|skip|limit|create|delete|set)\b\s/g; |
||||
for (var i = 0; i < lines.length; i++) |
||||
lines[i] = lines[i].replace(reProcessedPortion, " \n$1 ").trim(); |
||||
return lines.join("\n"); |
||||
} |
||||
}; |
||||
|
||||
CodeMirror.defineMIME("application/x-cypher-query", "cypher"); |
||||
|
||||
}); |
||||
@ -0,0 +1,63 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Cypher Mode for CodeMirror</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css" /> |
||||
<link rel="stylesheet" href="../../theme/neo.css" /> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="cypher.js"></script> |
||||
<style> |
||||
.CodeMirror { |
||||
border-top: 1px solid black; |
||||
border-bottom: 1px solid black; |
||||
} |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Cypher Mode for CodeMirror</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Cypher Mode for CodeMirror</h2> |
||||
<form> |
||||
<textarea id="code" name="code">// Cypher Mode for CodeMirror, using the neo theme |
||||
MATCH (joe { name: 'Joe' })-[:knows*2..2]-(friend_of_friend) |
||||
WHERE NOT (joe)-[:knows]-(friend_of_friend) |
||||
RETURN friend_of_friend.name, COUNT(*) |
||||
ORDER BY COUNT(*) DESC , friend_of_friend.name |
||||
</textarea> |
||||
</form> |
||||
<p><strong>MIME types defined:</strong> |
||||
<code><a href="?mime=application/x-cypher-query">application/x-cypher-query</a></code> |
||||
</p> |
||||
<script> |
||||
window.onload = function() { |
||||
var mime = 'application/x-cypher-query'; |
||||
// get mime type |
||||
if (window.location.href.indexOf('mime=') > -1) { |
||||
mime = window.location.href.substr(window.location.href.indexOf('mime=') + 5); |
||||
} |
||||
window.editor = CodeMirror.fromTextArea(document.getElementById('code'), { |
||||
mode: mime, |
||||
indentWithTabs: true, |
||||
smartIndent: true, |
||||
lineNumbers: true, |
||||
matchBrackets : true, |
||||
autofocus: true, |
||||
theme: 'neo' |
||||
}); |
||||
}; |
||||
</script> |
||||
|
||||
</article> |
||||
@ -0,0 +1,218 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("d", function(config, parserConfig) { |
||||
var indentUnit = config.indentUnit, |
||||
statementIndentUnit = parserConfig.statementIndentUnit || indentUnit, |
||||
keywords = parserConfig.keywords || {}, |
||||
builtin = parserConfig.builtin || {}, |
||||
blockKeywords = parserConfig.blockKeywords || {}, |
||||
atoms = parserConfig.atoms || {}, |
||||
hooks = parserConfig.hooks || {}, |
||||
multiLineStrings = parserConfig.multiLineStrings; |
||||
var isOperatorChar = /[+\-*&%=<>!?|\/]/; |
||||
|
||||
var curPunc; |
||||
|
||||
function tokenBase(stream, state) { |
||||
var ch = stream.next(); |
||||
if (hooks[ch]) { |
||||
var result = hooks[ch](stream, state); |
||||
if (result !== false) return result; |
||||
} |
||||
if (ch == '"' || ch == "'" || ch == "`") { |
||||
state.tokenize = tokenString(ch); |
||||
return state.tokenize(stream, state); |
||||
} |
||||
if (/[\[\]{}\(\),;\:\.]/.test(ch)) { |
||||
curPunc = ch; |
||||
return null; |
||||
} |
||||
if (/\d/.test(ch)) { |
||||
stream.eatWhile(/[\w\.]/); |
||||
return "number"; |
||||
} |
||||
if (ch == "/") { |
||||
if (stream.eat("+")) { |
||||
state.tokenize = tokenComment; |
||||
return tokenNestedComment(stream, state); |
||||
} |
||||
if (stream.eat("*")) { |
||||
state.tokenize = tokenComment; |
||||
return tokenComment(stream, state); |
||||
} |
||||
if (stream.eat("/")) { |
||||
stream.skipToEnd(); |
||||
return "comment"; |
||||
} |
||||
} |
||||
if (isOperatorChar.test(ch)) { |
||||
stream.eatWhile(isOperatorChar); |
||||
return "operator"; |
||||
} |
||||
stream.eatWhile(/[\w\$_\xa1-\uffff]/); |
||||
var cur = stream.current(); |
||||
if (keywords.propertyIsEnumerable(cur)) { |
||||
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement"; |
||||
return "keyword"; |
||||
} |
||||
if (builtin.propertyIsEnumerable(cur)) { |
||||
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement"; |
||||
return "builtin"; |
||||
} |
||||
if (atoms.propertyIsEnumerable(cur)) return "atom"; |
||||
return "variable"; |
||||
} |
||||
|
||||
function tokenString(quote) { |
||||
return function(stream, state) { |
||||
var escaped = false, next, end = false; |
||||
while ((next = stream.next()) != null) { |
||||
if (next == quote && !escaped) {end = true; break;} |
||||
escaped = !escaped && next == "\\"; |
||||
} |
||||
if (end || !(escaped || multiLineStrings)) |
||||
state.tokenize = null; |
||||
return "string"; |
||||
}; |
||||
} |
||||
|
||||
function tokenComment(stream, state) { |
||||
var maybeEnd = false, ch; |
||||
while (ch = stream.next()) { |
||||
if (ch == "/" && maybeEnd) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
maybeEnd = (ch == "*"); |
||||
} |
||||
return "comment"; |
||||
} |
||||
|
||||
function tokenNestedComment(stream, state) { |
||||
var maybeEnd = false, ch; |
||||
while (ch = stream.next()) { |
||||
if (ch == "/" && maybeEnd) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
maybeEnd = (ch == "+"); |
||||
} |
||||
return "comment"; |
||||
} |
||||
|
||||
function Context(indented, column, type, align, prev) { |
||||
this.indented = indented; |
||||
this.column = column; |
||||
this.type = type; |
||||
this.align = align; |
||||
this.prev = prev; |
||||
} |
||||
function pushContext(state, col, type) { |
||||
var indent = state.indented; |
||||
if (state.context && state.context.type == "statement") |
||||
indent = state.context.indented; |
||||
return state.context = new Context(indent, col, type, null, state.context); |
||||
} |
||||
function popContext(state) { |
||||
var t = state.context.type; |
||||
if (t == ")" || t == "]" || t == "}") |
||||
state.indented = state.context.indented; |
||||
return state.context = state.context.prev; |
||||
} |
||||
|
||||
// Interface
|
||||
|
||||
return { |
||||
startState: function(basecolumn) { |
||||
return { |
||||
tokenize: null, |
||||
context: new Context((basecolumn || 0) - indentUnit, 0, "top", false), |
||||
indented: 0, |
||||
startOfLine: true |
||||
}; |
||||
}, |
||||
|
||||
token: function(stream, state) { |
||||
var ctx = state.context; |
||||
if (stream.sol()) { |
||||
if (ctx.align == null) ctx.align = false; |
||||
state.indented = stream.indentation(); |
||||
state.startOfLine = true; |
||||
} |
||||
if (stream.eatSpace()) return null; |
||||
curPunc = null; |
||||
var style = (state.tokenize || tokenBase)(stream, state); |
||||
if (style == "comment" || style == "meta") return style; |
||||
if (ctx.align == null) ctx.align = true; |
||||
|
||||
if ((curPunc == ";" || curPunc == ":" || curPunc == ",") && ctx.type == "statement") popContext(state); |
||||
else if (curPunc == "{") pushContext(state, stream.column(), "}"); |
||||
else if (curPunc == "[") pushContext(state, stream.column(), "]"); |
||||
else if (curPunc == "(") pushContext(state, stream.column(), ")"); |
||||
else if (curPunc == "}") { |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
if (ctx.type == "}") ctx = popContext(state); |
||||
while (ctx.type == "statement") ctx = popContext(state); |
||||
} |
||||
else if (curPunc == ctx.type) popContext(state); |
||||
else if (((ctx.type == "}" || ctx.type == "top") && curPunc != ';') || (ctx.type == "statement" && curPunc == "newstatement")) |
||||
pushContext(state, stream.column(), "statement"); |
||||
state.startOfLine = false; |
||||
return style; |
||||
}, |
||||
|
||||
indent: function(state, textAfter) { |
||||
if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass; |
||||
var ctx = state.context, firstChar = textAfter && textAfter.charAt(0); |
||||
if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev; |
||||
var closing = firstChar == ctx.type; |
||||
if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit); |
||||
else if (ctx.align) return ctx.column + (closing ? 0 : 1); |
||||
else return ctx.indented + (closing ? 0 : indentUnit); |
||||
}, |
||||
|
||||
electricChars: "{}" |
||||
}; |
||||
}); |
||||
|
||||
function words(str) { |
||||
var obj = {}, words = str.split(" "); |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
|
||||
var blockKeywords = "body catch class do else enum for foreach foreach_reverse if in interface mixin " + |
||||
"out scope struct switch try union unittest version while with"; |
||||
|
||||
CodeMirror.defineMIME("text/x-d", { |
||||
name: "d", |
||||
keywords: words("abstract alias align asm assert auto break case cast cdouble cent cfloat const continue " + |
||||
"debug default delegate delete deprecated export extern final finally function goto immutable " + |
||||
"import inout invariant is lazy macro module new nothrow override package pragma private " + |
||||
"protected public pure ref return shared short static super synchronized template this " + |
||||
"throw typedef typeid typeof volatile __FILE__ __LINE__ __gshared __traits __vector __parameters " + |
||||
blockKeywords), |
||||
blockKeywords: words(blockKeywords), |
||||
builtin: words("bool byte char creal dchar double float idouble ifloat int ireal long real short ubyte " + |
||||
"ucent uint ulong ushort wchar wstring void size_t sizediff_t"), |
||||
atoms: words("exit failure success true false null"), |
||||
hooks: { |
||||
"@": function(stream, _state) { |
||||
stream.eatWhile(/[\w\$_]/); |
||||
return "meta"; |
||||
} |
||||
} |
||||
}); |
||||
|
||||
}); |
||||
@ -0,0 +1,273 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: D mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/edit/matchbrackets.js"></script> |
||||
<script src="d.js"></script> |
||||
<style>.CodeMirror {border: 2px inset #dee;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">D</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>D mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
/* D demo code // copied from phobos/sd/metastrings.d */ |
||||
// Written in the D programming language. |
||||
|
||||
/** |
||||
Templates with which to do compile-time manipulation of strings. |
||||
|
||||
Macros: |
||||
WIKI = Phobos/StdMetastrings |
||||
|
||||
Copyright: Copyright Digital Mars 2007 - 2009. |
||||
License: <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>. |
||||
Authors: $(WEB digitalmars.com, Walter Bright), |
||||
Don Clugston |
||||
Source: $(PHOBOSSRC std/_metastrings.d) |
||||
*/ |
||||
/* |
||||
Copyright Digital Mars 2007 - 2009. |
||||
Distributed under the Boost Software License, Version 1.0. |
||||
(See accompanying file LICENSE_1_0.txt or copy at |
||||
http://www.boost.org/LICENSE_1_0.txt) |
||||
*/ |
||||
module std.metastrings; |
||||
|
||||
/** |
||||
Formats constants into a string at compile time. Analogous to $(XREF |
||||
string,format). |
||||
|
||||
Parameters: |
||||
|
||||
A = tuple of constants, which can be strings, characters, or integral |
||||
values. |
||||
|
||||
Formats: |
||||
* The formats supported are %s for strings, and %% |
||||
* for the % character. |
||||
Example: |
||||
--- |
||||
import std.metastrings; |
||||
import std.stdio; |
||||
|
||||
void main() |
||||
{ |
||||
string s = Format!("Arg %s = %s", "foo", 27); |
||||
writefln(s); // "Arg foo = 27" |
||||
} |
||||
* --- |
||||
*/ |
||||
|
||||
template Format(A...) |
||||
{ |
||||
static if (A.length == 0) |
||||
enum Format = ""; |
||||
else static if (is(typeof(A[0]) : const(char)[])) |
||||
enum Format = FormatString!(A[0], A[1..$]); |
||||
else |
||||
enum Format = toStringNow!(A[0]) ~ Format!(A[1..$]); |
||||
} |
||||
|
||||
template FormatString(const(char)[] F, A...) |
||||
{ |
||||
static if (F.length == 0) |
||||
enum FormatString = Format!(A); |
||||
else static if (F.length == 1) |
||||
enum FormatString = F[0] ~ Format!(A); |
||||
else static if (F[0..2] == "%s") |
||||
enum FormatString |
||||
= toStringNow!(A[0]) ~ FormatString!(F[2..$],A[1..$]); |
||||
else static if (F[0..2] == "%%") |
||||
enum FormatString = "%" ~ FormatString!(F[2..$],A); |
||||
else |
||||
{ |
||||
static assert(F[0] != '%', "unrecognized format %" ~ F[1]); |
||||
enum FormatString = F[0] ~ FormatString!(F[1..$],A); |
||||
} |
||||
} |
||||
|
||||
unittest |
||||
{ |
||||
auto s = Format!("hel%slo", "world", -138, 'c', true); |
||||
assert(s == "helworldlo-138ctrue", "[" ~ s ~ "]"); |
||||
} |
||||
|
||||
/** |
||||
* Convert constant argument to a string. |
||||
*/ |
||||
|
||||
template toStringNow(ulong v) |
||||
{ |
||||
static if (v < 10) |
||||
enum toStringNow = "" ~ cast(char)(v + '0'); |
||||
else |
||||
enum toStringNow = toStringNow!(v / 10) ~ toStringNow!(v % 10); |
||||
} |
||||
|
||||
unittest |
||||
{ |
||||
static assert(toStringNow!(1uL << 62) == "4611686018427387904"); |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(long v) |
||||
{ |
||||
static if (v < 0) |
||||
enum toStringNow = "-" ~ toStringNow!(cast(ulong) -v); |
||||
else |
||||
enum toStringNow = toStringNow!(cast(ulong) v); |
||||
} |
||||
|
||||
unittest |
||||
{ |
||||
static assert(toStringNow!(0x100000000) == "4294967296"); |
||||
static assert(toStringNow!(-138L) == "-138"); |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(uint U) |
||||
{ |
||||
enum toStringNow = toStringNow!(cast(ulong)U); |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(int I) |
||||
{ |
||||
enum toStringNow = toStringNow!(cast(long)I); |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(bool B) |
||||
{ |
||||
enum toStringNow = B ? "true" : "false"; |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(string S) |
||||
{ |
||||
enum toStringNow = S; |
||||
} |
||||
|
||||
/// ditto |
||||
template toStringNow(char C) |
||||
{ |
||||
enum toStringNow = "" ~ C; |
||||
} |
||||
|
||||
|
||||
/******** |
||||
* Parse unsigned integer literal from the start of string s. |
||||
* returns: |
||||
* .value = the integer literal as a string, |
||||
* .rest = the string following the integer literal |
||||
* Otherwise: |
||||
* .value = null, |
||||
* .rest = s |
||||
*/ |
||||
|
||||
template parseUinteger(const(char)[] s) |
||||
{ |
||||
static if (s.length == 0) |
||||
{ |
||||
enum value = ""; |
||||
enum rest = ""; |
||||
} |
||||
else static if (s[0] >= '0' && s[0] <= '9') |
||||
{ |
||||
enum value = s[0] ~ parseUinteger!(s[1..$]).value; |
||||
enum rest = parseUinteger!(s[1..$]).rest; |
||||
} |
||||
else |
||||
{ |
||||
enum value = ""; |
||||
enum rest = s; |
||||
} |
||||
} |
||||
|
||||
/******** |
||||
Parse integer literal optionally preceded by $(D '-') from the start |
||||
of string $(D s). |
||||
|
||||
Returns: |
||||
.value = the integer literal as a string, |
||||
.rest = the string following the integer literal |
||||
|
||||
Otherwise: |
||||
.value = null, |
||||
.rest = s |
||||
*/ |
||||
|
||||
template parseInteger(const(char)[] s) |
||||
{ |
||||
static if (s.length == 0) |
||||
{ |
||||
enum value = ""; |
||||
enum rest = ""; |
||||
} |
||||
else static if (s[0] >= '0' && s[0] <= '9') |
||||
{ |
||||
enum value = s[0] ~ parseUinteger!(s[1..$]).value; |
||||
enum rest = parseUinteger!(s[1..$]).rest; |
||||
} |
||||
else static if (s.length >= 2 && |
||||
s[0] == '-' && s[1] >= '0' && s[1] <= '9') |
||||
{ |
||||
enum value = s[0..2] ~ parseUinteger!(s[2..$]).value; |
||||
enum rest = parseUinteger!(s[2..$]).rest; |
||||
} |
||||
else |
||||
{ |
||||
enum value = ""; |
||||
enum rest = s; |
||||
} |
||||
} |
||||
|
||||
unittest |
||||
{ |
||||
assert(parseUinteger!("1234abc").value == "1234"); |
||||
assert(parseUinteger!("1234abc").rest == "abc"); |
||||
assert(parseInteger!("-1234abc").value == "-1234"); |
||||
assert(parseInteger!("-1234abc").rest == "abc"); |
||||
} |
||||
|
||||
/** |
||||
Deprecated aliases held for backward compatibility. |
||||
*/ |
||||
deprecated alias toStringNow ToString; |
||||
/// Ditto |
||||
deprecated alias parseUinteger ParseUinteger; |
||||
/// Ditto |
||||
deprecated alias parseUinteger ParseInteger; |
||||
|
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
matchBrackets: true, |
||||
indentUnit: 4, |
||||
mode: "text/x-d" |
||||
}); |
||||
</script> |
||||
|
||||
<p>Simple mode that handle D-Syntax (<a href="http://www.dlang.org">DLang Homepage</a>).</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-d</code> |
||||
.</p> |
||||
</article> |
||||
@ -0,0 +1,157 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"), require("../clike/clike")); |
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror", "../clike/clike"], mod); |
||||
else // Plain browser env
|
||||
mod(CodeMirror); |
||||
})(function(CodeMirror) { |
||||
"use strict"; |
||||
|
||||
var keywords = ("this super static final const abstract class extends external factory " + |
||||
"implements get native operator set typedef with enum throw rethrow " + |
||||
"assert break case continue default in return new deferred async await " + |
||||
"try catch finally do else for if switch while import library export " + |
||||
"part of show hide is as").split(" "); |
||||
var blockKeywords = "try catch finally do else for if switch while".split(" "); |
||||
var atoms = "true false null".split(" "); |
||||
var builtins = "void bool num int double dynamic var String".split(" "); |
||||
|
||||
function set(words) { |
||||
var obj = {}; |
||||
for (var i = 0; i < words.length; ++i) obj[words[i]] = true; |
||||
return obj; |
||||
} |
||||
|
||||
function pushInterpolationStack(state) { |
||||
(state.interpolationStack || (state.interpolationStack = [])).push(state.tokenize); |
||||
} |
||||
|
||||
function popInterpolationStack(state) { |
||||
return (state.interpolationStack || (state.interpolationStack = [])).pop(); |
||||
} |
||||
|
||||
function sizeInterpolationStack(state) { |
||||
return state.interpolationStack ? state.interpolationStack.length : 0; |
||||
} |
||||
|
||||
CodeMirror.defineMIME("application/dart", { |
||||
name: "clike", |
||||
keywords: set(keywords), |
||||
blockKeywords: set(blockKeywords), |
||||
builtin: set(builtins), |
||||
atoms: set(atoms), |
||||
hooks: { |
||||
"@": function(stream) { |
||||
stream.eatWhile(/[\w\$_\.]/); |
||||
return "meta"; |
||||
}, |
||||
|
||||
// custom string handling to deal with triple-quoted strings and string interpolation
|
||||
"'": function(stream, state) { |
||||
return tokenString("'", stream, state, false); |
||||
}, |
||||
"\"": function(stream, state) { |
||||
return tokenString("\"", stream, state, false); |
||||
}, |
||||
"r": function(stream, state) { |
||||
var peek = stream.peek(); |
||||
if (peek == "'" || peek == "\"") { |
||||
return tokenString(stream.next(), stream, state, true); |
||||
} |
||||
return false; |
||||
}, |
||||
|
||||
"}": function(_stream, state) { |
||||
// "}" is end of interpolation, if interpolation stack is non-empty
|
||||
if (sizeInterpolationStack(state) > 0) { |
||||
state.tokenize = popInterpolationStack(state); |
||||
return null; |
||||
} |
||||
return false; |
||||
}, |
||||
|
||||
"/": function(stream, state) { |
||||
if (!stream.eat("*")) return false |
||||
state.tokenize = tokenNestedComment(1) |
||||
return state.tokenize(stream, state) |
||||
} |
||||
} |
||||
}); |
||||
|
||||
function tokenString(quote, stream, state, raw) { |
||||
var tripleQuoted = false; |
||||
if (stream.eat(quote)) { |
||||
if (stream.eat(quote)) tripleQuoted = true; |
||||
else return "string"; //empty string
|
||||
} |
||||
function tokenStringHelper(stream, state) { |
||||
var escaped = false; |
||||
while (!stream.eol()) { |
||||
if (!raw && !escaped && stream.peek() == "$") { |
||||
pushInterpolationStack(state); |
||||
state.tokenize = tokenInterpolation; |
||||
return "string"; |
||||
} |
||||
var next = stream.next(); |
||||
if (next == quote && !escaped && (!tripleQuoted || stream.match(quote + quote))) { |
||||
state.tokenize = null; |
||||
break; |
||||
} |
||||
escaped = !raw && !escaped && next == "\\"; |
||||
} |
||||
return "string"; |
||||
} |
||||
state.tokenize = tokenStringHelper; |
||||
return tokenStringHelper(stream, state); |
||||
} |
||||
|
||||
function tokenInterpolation(stream, state) { |
||||
stream.eat("$"); |
||||
if (stream.eat("{")) { |
||||
// let clike handle the content of ${...},
|
||||
// we take over again when "}" appears (see hooks).
|
||||
state.tokenize = null; |
||||
} else { |
||||
state.tokenize = tokenInterpolationIdentifier; |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
function tokenInterpolationIdentifier(stream, state) { |
||||
stream.eatWhile(/[\w_]/); |
||||
state.tokenize = popInterpolationStack(state); |
||||
return "variable"; |
||||
} |
||||
|
||||
function tokenNestedComment(depth) { |
||||
return function (stream, state) { |
||||
var ch |
||||
while (ch = stream.next()) { |
||||
if (ch == "*" && stream.eat("/")) { |
||||
if (depth == 1) { |
||||
state.tokenize = null |
||||
break |
||||
} else { |
||||
state.tokenize = tokenNestedComment(depth - 1) |
||||
return state.tokenize(stream, state) |
||||
} |
||||
} else if (ch == "/" && stream.eat("*")) { |
||||
state.tokenize = tokenNestedComment(depth + 1) |
||||
return state.tokenize(stream, state) |
||||
} |
||||
} |
||||
return "comment" |
||||
} |
||||
} |
||||
|
||||
CodeMirror.registerHelper("hintWords", "application/dart", keywords.concat(atoms).concat(builtins)); |
||||
|
||||
// This is needed to make loading through meta.js work.
|
||||
CodeMirror.defineMode("dart", function(conf) { |
||||
return CodeMirror.getMode(conf, "application/dart"); |
||||
}, "clike"); |
||||
}); |
||||
@ -0,0 +1,71 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Dart mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../clike/clike.js"></script> |
||||
<script src="dart.js"></script> |
||||
<style>.CodeMirror {border: 1px solid #dee;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Dart</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Dart mode</h2> |
||||
<form> |
||||
<textarea id="code" name="code"> |
||||
import 'dart:math' show Random; |
||||
|
||||
void main() { |
||||
print(new Die(n: 12).roll()); |
||||
} |
||||
|
||||
// Define a class. |
||||
class Die { |
||||
// Define a class variable. |
||||
static Random shaker = new Random(); |
||||
|
||||
// Define instance variables. |
||||
int sides, value; |
||||
|
||||
// Define a method using shorthand syntax. |
||||
String toString() => '$value'; |
||||
|
||||
// Define a constructor. |
||||
Die({int n: 6}) { |
||||
if (4 <= n && n <= 20) { |
||||
sides = n; |
||||
} else { |
||||
// Support for errors and exceptions. |
||||
throw new ArgumentError(/* */); |
||||
} |
||||
} |
||||
|
||||
// Define an instance method. |
||||
int roll() { |
||||
return value = shaker.nextInt(sides) + 1; |
||||
} |
||||
} |
||||
</textarea> |
||||
</form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
mode: "application/dart" |
||||
}); |
||||
</script> |
||||
|
||||
</article> |
||||
@ -0,0 +1,47 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(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.defineMode("diff", function() { |
||||
|
||||
var TOKEN_NAMES = { |
||||
'+': 'positive', |
||||
'-': 'negative', |
||||
'@': 'meta' |
||||
}; |
||||
|
||||
return { |
||||
token: function(stream) { |
||||
var tw_pos = stream.string.search(/[\t ]+?$/); |
||||
|
||||
if (!stream.sol() || tw_pos === 0) { |
||||
stream.skipToEnd(); |
||||
return ("error " + ( |
||||
TOKEN_NAMES[stream.string.charAt(0)] || '')).replace(/ $/, ''); |
||||
} |
||||
|
||||
var token_name = TOKEN_NAMES[stream.peek()] || stream.skipToEnd(); |
||||
|
||||
if (tw_pos === -1) { |
||||
stream.skipToEnd(); |
||||
} else { |
||||
stream.pos = tw_pos; |
||||
} |
||||
|
||||
return token_name; |
||||
} |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-diff", "diff"); |
||||
|
||||
}); |
||||
@ -0,0 +1,117 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Diff mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="diff.js"></script> |
||||
<style> |
||||
.CodeMirror {border-top: 1px solid #ddd; border-bottom: 1px solid #ddd;} |
||||
span.cm-meta {color: #a0b !important;} |
||||
span.cm-error { background-color: black; opacity: 0.4;} |
||||
span.cm-error.cm-string { background-color: red; } |
||||
span.cm-error.cm-tag { background-color: #2b2; } |
||||
</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Diff</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Diff mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
diff --git a/index.html b/index.html |
||||
index c1d9156..7764744 100644 |
||||
--- a/index.html |
||||
+++ b/index.html |
||||
@@ -95,7 +95,8 @@ StringStream.prototype = { |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
- autoMatchBrackets: true |
||||
+ autoMatchBrackets: true, |
||||
+ onGutterClick: function(x){console.log(x);} |
||||
}); |
||||
</script> |
||||
</body> |
||||
diff --git a/lib/codemirror.js b/lib/codemirror.js |
||||
index 04646a9..9a39cc7 100644 |
||||
--- a/lib/codemirror.js |
||||
+++ b/lib/codemirror.js |
||||
@@ -399,10 +399,16 @@ var CodeMirror = (function() { |
||||
} |
||||
|
||||
function onMouseDown(e) { |
||||
- var start = posFromMouse(e), last = start; |
||||
+ var start = posFromMouse(e), last = start, target = e.target(); |
||||
if (!start) return; |
||||
setCursor(start.line, start.ch, false); |
||||
if (e.button() != 1) return; |
||||
+ if (target.parentNode == gutter) { |
||||
+ if (options.onGutterClick) |
||||
+ options.onGutterClick(indexOf(gutter.childNodes, target) + showingFrom); |
||||
+ return; |
||||
+ } |
||||
+ |
||||
if (!focused) onFocus(); |
||||
|
||||
e.stop(); |
||||
@@ -808,7 +814,7 @@ var CodeMirror = (function() { |
||||
for (var i = showingFrom; i < showingTo; ++i) { |
||||
var marker = lines[i].gutterMarker; |
||||
if (marker) html.push('<div class="' + marker.style + '">' + htmlEscape(marker.text) + '</div>'); |
||||
- else html.push("<div>" + (options.lineNumbers ? i + 1 : "\u00a0") + "</div>"); |
||||
+ else html.push("<div>" + (options.lineNumbers ? i + options.firstLineNumber : "\u00a0") + "</div>"); |
||||
} |
||||
gutter.style.display = "none"; // TODO test whether this actually helps |
||||
gutter.innerHTML = html.join(""); |
||||
@@ -1371,10 +1377,8 @@ var CodeMirror = (function() { |
||||
if (option == "parser") setParser(value); |
||||
else if (option === "lineNumbers") setLineNumbers(value); |
||||
else if (option === "gutter") setGutter(value); |
||||
- else if (option === "readOnly") options.readOnly = value; |
||||
- else if (option === "indentUnit") {options.indentUnit = indentUnit = value; setParser(options.parser);} |
||||
- else if (/^(?:enterMode|tabMode|indentWithTabs|readOnly|autoMatchBrackets|undoDepth)$/.test(option)) options[option] = value; |
||||
- else throw new Error("Can't set option " + option); |
||||
+ else if (option === "indentUnit") {options.indentUnit = value; setParser(options.parser);} |
||||
+ else options[option] = value; |
||||
}, |
||||
cursorCoords: cursorCoords, |
||||
undo: operation(undo), |
||||
@@ -1402,7 +1406,8 @@ var CodeMirror = (function() { |
||||
replaceRange: operation(replaceRange), |
||||
|
||||
operation: function(f){return operation(f)();}, |
||||
- refresh: function(){updateDisplay([{from: 0, to: lines.length}]);} |
||||
+ refresh: function(){updateDisplay([{from: 0, to: lines.length}]);}, |
||||
+ getInputField: function(){return input;} |
||||
}; |
||||
return instance; |
||||
} |
||||
@@ -1420,6 +1425,7 @@ var CodeMirror = (function() { |
||||
readOnly: false, |
||||
onChange: null, |
||||
onCursorActivity: null, |
||||
+ onGutterClick: null, |
||||
autoMatchBrackets: false, |
||||
workTime: 200, |
||||
workDelay: 300, |
||||
</textarea></form> |
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {}); |
||||
</script> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-diff</code>.</p> |
||||
|
||||
</article> |
||||
@ -0,0 +1,356 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"), |
||||
require("../../addon/mode/overlay")); |
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror", "../htmlmixed/htmlmixed", |
||||
"../../addon/mode/overlay"], mod); |
||||
else // Plain browser env
|
||||
mod(CodeMirror); |
||||
})(function(CodeMirror) { |
||||
"use strict"; |
||||
|
||||
CodeMirror.defineMode("django:inner", function() { |
||||
var keywords = ["block", "endblock", "for", "endfor", "true", "false", "filter", "endfilter", |
||||
"loop", "none", "self", "super", "if", "elif", "endif", "as", "else", "import", |
||||
"with", "endwith", "without", "context", "ifequal", "endifequal", "ifnotequal", |
||||
"endifnotequal", "extends", "include", "load", "comment", "endcomment", |
||||
"empty", "url", "static", "trans", "blocktrans", "endblocktrans", "now", |
||||
"regroup", "lorem", "ifchanged", "endifchanged", "firstof", "debug", "cycle", |
||||
"csrf_token", "autoescape", "endautoescape", "spaceless", "endspaceless", |
||||
"ssi", "templatetag", "verbatim", "endverbatim", "widthratio"], |
||||
filters = ["add", "addslashes", "capfirst", "center", "cut", "date", |
||||
"default", "default_if_none", "dictsort", |
||||
"dictsortreversed", "divisibleby", "escape", "escapejs", |
||||
"filesizeformat", "first", "floatformat", "force_escape", |
||||
"get_digit", "iriencode", "join", "last", "length", |
||||
"length_is", "linebreaks", "linebreaksbr", "linenumbers", |
||||
"ljust", "lower", "make_list", "phone2numeric", "pluralize", |
||||
"pprint", "random", "removetags", "rjust", "safe", |
||||
"safeseq", "slice", "slugify", "stringformat", "striptags", |
||||
"time", "timesince", "timeuntil", "title", "truncatechars", |
||||
"truncatechars_html", "truncatewords", "truncatewords_html", |
||||
"unordered_list", "upper", "urlencode", "urlize", |
||||
"urlizetrunc", "wordcount", "wordwrap", "yesno"], |
||||
operators = ["==", "!=", "<", ">", "<=", ">="], |
||||
wordOperators = ["in", "not", "or", "and"]; |
||||
|
||||
keywords = new RegExp("^\\b(" + keywords.join("|") + ")\\b"); |
||||
filters = new RegExp("^\\b(" + filters.join("|") + ")\\b"); |
||||
operators = new RegExp("^\\b(" + operators.join("|") + ")\\b"); |
||||
wordOperators = new RegExp("^\\b(" + wordOperators.join("|") + ")\\b"); |
||||
|
||||
// We have to return "null" instead of null, in order to avoid string
|
||||
// styling as the default, when using Django templates inside HTML
|
||||
// element attributes
|
||||
function tokenBase (stream, state) { |
||||
// Attempt to identify a variable, template or comment tag respectively
|
||||
if (stream.match("{{")) { |
||||
state.tokenize = inVariable; |
||||
return "tag"; |
||||
} else if (stream.match("{%")) { |
||||
state.tokenize = inTag; |
||||
return "tag"; |
||||
} else if (stream.match("{#")) { |
||||
state.tokenize = inComment; |
||||
return "comment"; |
||||
} |
||||
|
||||
// Ignore completely any stream series that do not match the
|
||||
// Django template opening tags.
|
||||
while (stream.next() != null && !stream.match(/\{[{%#]/, false)) {} |
||||
return null; |
||||
} |
||||
|
||||
// A string can be included in either single or double quotes (this is
|
||||
// the delimiter). Mark everything as a string until the start delimiter
|
||||
// occurs again.
|
||||
function inString (delimiter, previousTokenizer) { |
||||
return function (stream, state) { |
||||
if (!state.escapeNext && stream.eat(delimiter)) { |
||||
state.tokenize = previousTokenizer; |
||||
} else { |
||||
if (state.escapeNext) { |
||||
state.escapeNext = false; |
||||
} |
||||
|
||||
var ch = stream.next(); |
||||
|
||||
// Take into account the backslash for escaping characters, such as
|
||||
// the string delimiter.
|
||||
if (ch == "\\") { |
||||
state.escapeNext = true; |
||||
} |
||||
} |
||||
|
||||
return "string"; |
||||
}; |
||||
} |
||||
|
||||
// Apply Django template variable syntax highlighting
|
||||
function inVariable (stream, state) { |
||||
// Attempt to match a dot that precedes a property
|
||||
if (state.waitDot) { |
||||
state.waitDot = false; |
||||
|
||||
if (stream.peek() != ".") { |
||||
return "null"; |
||||
} |
||||
|
||||
// Dot followed by a non-word character should be considered an error.
|
||||
if (stream.match(/\.\W+/)) { |
||||
return "error"; |
||||
} else if (stream.eat(".")) { |
||||
state.waitProperty = true; |
||||
return "null"; |
||||
} else { |
||||
throw Error ("Unexpected error while waiting for property."); |
||||
} |
||||
} |
||||
|
||||
// Attempt to match a pipe that precedes a filter
|
||||
if (state.waitPipe) { |
||||
state.waitPipe = false; |
||||
|
||||
if (stream.peek() != "|") { |
||||
return "null"; |
||||
} |
||||
|
||||
// Pipe followed by a non-word character should be considered an error.
|
||||
if (stream.match(/\.\W+/)) { |
||||
return "error"; |
||||
} else if (stream.eat("|")) { |
||||
state.waitFilter = true; |
||||
return "null"; |
||||
} else { |
||||
throw Error ("Unexpected error while waiting for filter."); |
||||
} |
||||
} |
||||
|
||||
// Highlight properties
|
||||
if (state.waitProperty) { |
||||
state.waitProperty = false; |
||||
if (stream.match(/\b(\w+)\b/)) { |
||||
state.waitDot = true; // A property can be followed by another property
|
||||
state.waitPipe = true; // A property can be followed by a filter
|
||||
return "property"; |
||||
} |
||||
} |
||||
|
||||
// Highlight filters
|
||||
if (state.waitFilter) { |
||||
state.waitFilter = false; |
||||
if (stream.match(filters)) { |
||||
return "variable-2"; |
||||
} |
||||
} |
||||
|
||||
// Ignore all white spaces
|
||||
if (stream.eatSpace()) { |
||||
state.waitProperty = false; |
||||
return "null"; |
||||
} |
||||
|
||||
// Identify numbers
|
||||
if (stream.match(/\b\d+(\.\d+)?\b/)) { |
||||
return "number"; |
||||
} |
||||
|
||||
// Identify strings
|
||||
if (stream.match("'")) { |
||||
state.tokenize = inString("'", state.tokenize); |
||||
return "string"; |
||||
} else if (stream.match('"')) { |
||||
state.tokenize = inString('"', state.tokenize); |
||||
return "string"; |
||||
} |
||||
|
||||
// Attempt to find the variable
|
||||
if (stream.match(/\b(\w+)\b/) && !state.foundVariable) { |
||||
state.waitDot = true; |
||||
state.waitPipe = true; // A property can be followed by a filter
|
||||
return "variable"; |
||||
} |
||||
|
||||
// If found closing tag reset
|
||||
if (stream.match("}}")) { |
||||
state.waitProperty = null; |
||||
state.waitFilter = null; |
||||
state.waitDot = null; |
||||
state.waitPipe = null; |
||||
state.tokenize = tokenBase; |
||||
return "tag"; |
||||
} |
||||
|
||||
// If nothing was found, advance to the next character
|
||||
stream.next(); |
||||
return "null"; |
||||
} |
||||
|
||||
function inTag (stream, state) { |
||||
// Attempt to match a dot that precedes a property
|
||||
if (state.waitDot) { |
||||
state.waitDot = false; |
||||
|
||||
if (stream.peek() != ".") { |
||||
return "null"; |
||||
} |
||||
|
||||
// Dot followed by a non-word character should be considered an error.
|
||||
if (stream.match(/\.\W+/)) { |
||||
return "error"; |
||||
} else if (stream.eat(".")) { |
||||
state.waitProperty = true; |
||||
return "null"; |
||||
} else { |
||||
throw Error ("Unexpected error while waiting for property."); |
||||
} |
||||
} |
||||
|
||||
// Attempt to match a pipe that precedes a filter
|
||||
if (state.waitPipe) { |
||||
state.waitPipe = false; |
||||
|
||||
if (stream.peek() != "|") { |
||||
return "null"; |
||||
} |
||||
|
||||
// Pipe followed by a non-word character should be considered an error.
|
||||
if (stream.match(/\.\W+/)) { |
||||
return "error"; |
||||
} else if (stream.eat("|")) { |
||||
state.waitFilter = true; |
||||
return "null"; |
||||
} else { |
||||
throw Error ("Unexpected error while waiting for filter."); |
||||
} |
||||
} |
||||
|
||||
// Highlight properties
|
||||
if (state.waitProperty) { |
||||
state.waitProperty = false; |
||||
if (stream.match(/\b(\w+)\b/)) { |
||||
state.waitDot = true; // A property can be followed by another property
|
||||
state.waitPipe = true; // A property can be followed by a filter
|
||||
return "property"; |
||||
} |
||||
} |
||||
|
||||
// Highlight filters
|
||||
if (state.waitFilter) { |
||||
state.waitFilter = false; |
||||
if (stream.match(filters)) { |
||||
return "variable-2"; |
||||
} |
||||
} |
||||
|
||||
// Ignore all white spaces
|
||||
if (stream.eatSpace()) { |
||||
state.waitProperty = false; |
||||
return "null"; |
||||
} |
||||
|
||||
// Identify numbers
|
||||
if (stream.match(/\b\d+(\.\d+)?\b/)) { |
||||
return "number"; |
||||
} |
||||
|
||||
// Identify strings
|
||||
if (stream.match("'")) { |
||||
state.tokenize = inString("'", state.tokenize); |
||||
return "string"; |
||||
} else if (stream.match('"')) { |
||||
state.tokenize = inString('"', state.tokenize); |
||||
return "string"; |
||||
} |
||||
|
||||
// Attempt to match an operator
|
||||
if (stream.match(operators)) { |
||||
return "operator"; |
||||
} |
||||
|
||||
// Attempt to match a word operator
|
||||
if (stream.match(wordOperators)) { |
||||
return "keyword"; |
||||
} |
||||
|
||||
// Attempt to match a keyword
|
||||
var keywordMatch = stream.match(keywords); |
||||
if (keywordMatch) { |
||||
if (keywordMatch[0] == "comment") { |
||||
state.blockCommentTag = true; |
||||
} |
||||
return "keyword"; |
||||
} |
||||
|
||||
// Attempt to match a variable
|
||||
if (stream.match(/\b(\w+)\b/)) { |
||||
state.waitDot = true; |
||||
state.waitPipe = true; // A property can be followed by a filter
|
||||
return "variable"; |
||||
} |
||||
|
||||
// If found closing tag reset
|
||||
if (stream.match("%}")) { |
||||
state.waitProperty = null; |
||||
state.waitFilter = null; |
||||
state.waitDot = null; |
||||
state.waitPipe = null; |
||||
// If the tag that closes is a block comment tag, we want to mark the
|
||||
// following code as comment, until the tag closes.
|
||||
if (state.blockCommentTag) { |
||||
state.blockCommentTag = false; // Release the "lock"
|
||||
state.tokenize = inBlockComment; |
||||
} else { |
||||
state.tokenize = tokenBase; |
||||
} |
||||
return "tag"; |
||||
} |
||||
|
||||
// If nothing was found, advance to the next character
|
||||
stream.next(); |
||||
return "null"; |
||||
} |
||||
|
||||
// Mark everything as comment inside the tag and the tag itself.
|
||||
function inComment (stream, state) { |
||||
if (stream.match(/^.*?#\}/)) state.tokenize = tokenBase |
||||
else stream.skipToEnd() |
||||
return "comment"; |
||||
} |
||||
|
||||
// Mark everything as a comment until the `blockcomment` tag closes.
|
||||
function inBlockComment (stream, state) { |
||||
if (stream.match(/\{%\s*endcomment\s*%\}/, false)) { |
||||
state.tokenize = inTag; |
||||
stream.match("{%"); |
||||
return "tag"; |
||||
} else { |
||||
stream.next(); |
||||
return "comment"; |
||||
} |
||||
} |
||||
|
||||
return { |
||||
startState: function () { |
||||
return {tokenize: tokenBase}; |
||||
}, |
||||
token: function (stream, state) { |
||||
return state.tokenize(stream, state); |
||||
}, |
||||
blockCommentStart: "{% comment %}", |
||||
blockCommentEnd: "{% endcomment %}" |
||||
}; |
||||
}); |
||||
|
||||
CodeMirror.defineMode("django", function(config) { |
||||
var htmlBase = CodeMirror.getMode(config, "text/html"); |
||||
var djangoInner = CodeMirror.getMode(config, "django:inner"); |
||||
return CodeMirror.overlayMode(htmlBase, djangoInner); |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-django", "django"); |
||||
}); |
||||
@ -0,0 +1,73 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Django template mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<link rel="stylesheet" href="../../theme/mdn-like.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/mode/overlay.js"></script> |
||||
<script src="../xml/xml.js"></script> |
||||
<script src="../htmlmixed/htmlmixed.js"></script> |
||||
<script src="django.js"></script> |
||||
<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Django</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Django template mode</h2> |
||||
<form><textarea id="code" name="code"> |
||||
<!doctype html> |
||||
<html> |
||||
<head> |
||||
<title>My Django web application</title> |
||||
</head> |
||||
<body> |
||||
<h1> |
||||
{{ page.title|capfirst }} |
||||
</h1> |
||||
<ul class="my-list"> |
||||
{# traverse a list of items and produce links to their views. #} |
||||
{% for item in items %} |
||||
<li> |
||||
<a href="{% url 'item_view' item.name|slugify %}"> |
||||
{{ item.name }} |
||||
</a> |
||||
</li> |
||||
{% empty %} |
||||
<li>You have no items in your list.</li> |
||||
{% endfor %} |
||||
</ul> |
||||
{% comment "this is a forgotten footer" %} |
||||
<footer></footer> |
||||
{% endcomment %} |
||||
</body> |
||||
</html> |
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
mode: "django", |
||||
indentUnit: 2, |
||||
indentWithTabs: true, |
||||
theme: "mdn-like" |
||||
}); |
||||
</script> |
||||
|
||||
<p>Mode for HTML with embedded Django template markup.</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-django</code></p> |
||||
</article> |
||||
@ -0,0 +1,79 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) { |
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"), require("../../addon/mode/simple")); |
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror", "../../addon/mode/simple"], mod); |
||||
else // Plain browser env
|
||||
mod(CodeMirror); |
||||
})(function(CodeMirror) { |
||||
"use strict"; |
||||
|
||||
// Collect all Dockerfile directives
|
||||
var instructions = ["from", "maintainer", "run", "cmd", "expose", "env", |
||||
"add", "copy", "entrypoint", "volume", "user", |
||||
"workdir", "onbuild"], |
||||
instructionRegex = "(" + instructions.join('|') + ")", |
||||
instructionOnlyLine = new RegExp(instructionRegex + "\\s*$", "i"), |
||||
instructionWithArguments = new RegExp(instructionRegex + "(\\s+)", "i"); |
||||
|
||||
CodeMirror.defineSimpleMode("dockerfile", { |
||||
start: [ |
||||
// Block comment: This is a line starting with a comment
|
||||
{ |
||||
regex: /#.*$/, |
||||
token: "comment" |
||||
}, |
||||
// Highlight an instruction without any arguments (for convenience)
|
||||
{ |
||||
regex: instructionOnlyLine, |
||||
token: "variable-2" |
||||
}, |
||||
// Highlight an instruction followed by arguments
|
||||
{ |
||||
regex: instructionWithArguments, |
||||
token: ["variable-2", null], |
||||
next: "arguments" |
||||
}, |
||||
{ |
||||
regex: /./, |
||||
token: null |
||||
} |
||||
], |
||||
arguments: [ |
||||
{ |
||||
// Line comment without instruction arguments is an error
|
||||
regex: /#.*$/, |
||||
token: "error", |
||||
next: "start" |
||||
}, |
||||
{ |
||||
regex: /[^#]+\\$/, |
||||
token: null |
||||
}, |
||||
{ |
||||
// Match everything except for the inline comment
|
||||
regex: /[^#]+/, |
||||
token: null, |
||||
next: "start" |
||||
}, |
||||
{ |
||||
regex: /$/, |
||||
token: null, |
||||
next: "start" |
||||
}, |
||||
// Fail safe return to start
|
||||
{ |
||||
token: null, |
||||
next: "start" |
||||
} |
||||
], |
||||
meta: { |
||||
lineComment: "#" |
||||
} |
||||
}); |
||||
|
||||
CodeMirror.defineMIME("text/x-dockerfile", "dockerfile"); |
||||
}); |
||||
@ -0,0 +1,73 @@
|
||||
<!doctype html> |
||||
|
||||
<title>CodeMirror: Dockerfile mode</title> |
||||
<meta charset="utf-8"/> |
||||
<link rel=stylesheet href="../../doc/docs.css"> |
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css"> |
||||
<script src="../../lib/codemirror.js"></script> |
||||
<script src="../../addon/mode/simple.js"></script> |
||||
<script src="dockerfile.js"></script> |
||||
<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style> |
||||
<div id=nav> |
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> |
||||
|
||||
<ul> |
||||
<li><a href="../../index.html">Home</a> |
||||
<li><a href="../../doc/manual.html">Manual</a> |
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a> |
||||
</ul> |
||||
<ul> |
||||
<li><a href="../index.html">Language modes</a> |
||||
<li><a class=active href="#">Dockerfile</a> |
||||
</ul> |
||||
</div> |
||||
|
||||
<article> |
||||
<h2>Dockerfile mode</h2> |
||||
<form><textarea id="code" name="code"># Install Ghost blogging platform and run development environment |
||||
# |
||||
# VERSION 1.0.0 |
||||
|
||||
FROM ubuntu:12.10 |
||||
MAINTAINER Amer Grgic "amer@livebyt.es" |
||||
WORKDIR /data/ghost |
||||
|
||||
# Install dependencies for nginx installation |
||||
RUN apt-get update |
||||
RUN apt-get install -y python g++ make software-properties-common --force-yes |
||||
RUN add-apt-repository ppa:chris-lea/node.js |
||||
RUN apt-get update |
||||
# Install unzip |
||||
RUN apt-get install -y unzip |
||||
# Install curl |
||||
RUN apt-get install -y curl |
||||
# Install nodejs & npm |
||||
RUN apt-get install -y rlwrap |
||||
RUN apt-get install -y nodejs |
||||
# Download Ghost v0.4.1 |
||||
RUN curl -L https://ghost.org/zip/ghost-latest.zip -o /tmp/ghost.zip |
||||
# Unzip Ghost zip to /data/ghost |
||||
RUN unzip -uo /tmp/ghost.zip -d /data/ghost |
||||
# Add custom config js to /data/ghost |
||||
ADD ./config.example.js /data/ghost/config.js |
||||
# Install Ghost with NPM |
||||
RUN cd /data/ghost/ && npm install --production |
||||
# Expose port 2368 |
||||
EXPOSE 2368 |
||||
# Run Ghost |
||||
CMD ["npm","start"] |
||||
</textarea></form> |
||||
|
||||
<script> |
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), { |
||||
lineNumbers: true, |
||||
mode: "dockerfile" |
||||
}); |
||||
</script> |
||||
|
||||
<p>Dockerfile syntax highlighting for CodeMirror. Depends on |
||||
the <a href="../../demo/simplemode.html">simplemode</a> addon.</p> |
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-dockerfile</code></p> |
||||
</article> |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue