Skip to content
GitLab
Commit 53f587bc authored by zhongyh's avatar zhongyh
Browse files

提交资源文件

parent f40087b8
Show whitespace changes
Inline Side-by-side
src/main/webapp/static/plugins/codemirror/5.48.4/mode/django/index.html 0 → 100644
View file @ 53f587bc
<!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>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dockerfile/dockerfile.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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";
var from = "from";
var fromRegex = new RegExp("^(\\s*)\\b(" + from + ")\\b", "i");
var shells = ["run", "cmd", "entrypoint", "shell"];
var shellsAsArrayRegex = new RegExp("^(\\s*)(" + shells.join('|') + ")(\\s+\\[)", "i");
var expose = "expose";
var exposeRegex = new RegExp("^(\\s*)(" + expose + ")(\\s+)", "i");
var others = [
"arg", "from", "maintainer", "label", "env",
"add", "copy", "volume", "user",
"workdir", "onbuild", "stopsignal", "healthcheck", "shell"
];
// Collect all Dockerfile directives
var instructions = [from, expose].concat(shells).concat(others),
instructionRegex = "(" + instructions.join('|') + ")",
instructionOnlyLine = new RegExp("^(\\s*)" + instructionRegex + "(\\s*)(#.*)?$", "i"),
instructionWithArguments = new RegExp("^(\\s*)" + instructionRegex + "(\\s+)", "i");
CodeMirror.defineSimpleMode("dockerfile", {
start: [
// Block comment: This is a line starting with a comment
{
regex: /^\s*#.*$/,
sol: true,
token: "comment"
},
{
regex: fromRegex,
token: [null, "keyword"],
sol: true,
next: "from"
},
// Highlight an instruction without any arguments (for convenience)
{
regex: instructionOnlyLine,
token: [null, "keyword", null, "error"],
sol: true
},
{
regex: shellsAsArrayRegex,
token: [null, "keyword", null],
sol: true,
next: "array"
},
{
regex: exposeRegex,
token: [null, "keyword", null],
sol: true,
next: "expose"
},
// Highlight an instruction followed by arguments
{
regex: instructionWithArguments,
token: [null, "keyword", null],
sol: true,
next: "arguments"
},
{
regex: /./,
token: null
}
],
from: [
{
regex: /\s*$/,
token: null,
next: "start"
},
{
// Line comment without instruction arguments is an error
regex: /(\s*)(#.*)$/,
token: [null, "error"],
next: "start"
},
{
regex: /(\s*\S+\s+)(as)/i,
token: [null, "keyword"],
next: "start"
},
// Fail safe return to start
{
token: null,
next: "start"
}
],
single: [
{
regex: /(?:[^\\']|\\.)/,
token: "string"
},
{
regex: /'/,
token: "string",
pop: true
}
],
double: [
{
regex: /(?:[^\\"]|\\.)/,
token: "string"
},
{
regex: /"/,
token: "string",
pop: true
}
],
array: [
{
regex: /\]/,
token: null,
next: "start"
},
{
regex: /"(?:[^\\"]|\\.)*"?/,
token: "string"
}
],
expose: [
{
regex: /\d+$/,
token: "number",
next: "start"
},
{
regex: /[^\d]+$/,
token: null,
next: "start"
},
{
regex: /\d+/,
token: "number"
},
{
regex: /[^\d]+/,
token: null
},
// Fail safe return to start
{
token: null,
next: "start"
}
],
arguments: [
{
regex: /^\s*#.*$/,
sol: true,
token: "comment"
},
{
regex: /"(?:[^\\"]|\\.)*"?$/,
token: "string",
next: "start"
},
{
regex: /"/,
token: "string",
push: "double"
},
{
regex: /'(?:[^\\']|\\.)*'?$/,
token: "string",
next: "start"
},
{
regex: /'/,
token: "string",
push: "single"
},
{
regex: /[^#"']+[\\`]$/,
token: null
},
{
regex: /[^#"']+$/,
token: null,
next: "start"
},
{
regex: /[^#"']+/,
token: null
},
// Fail safe return to start
{
token: null,
next: "start"
}
],
meta: {
lineComment: "#"
}
});
CodeMirror.defineMIME("text/x-dockerfile", "dockerfile");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dockerfile/index.html 0 → 100644
View file @ 53f587bc
<!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>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dockerfile/test.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
(function() {
var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-dockerfile");
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
MT("simple_nodejs_dockerfile",
"[keyword FROM] node:carbon",
"[comment # Create app directory]",
"[keyword WORKDIR] /usr/src/app",
"[comment # Install app dependencies]",
"[comment # A wildcard is used to ensure both package.json AND package-lock.json are copied]",
"[comment # where available (npm@5+)]",
"[keyword COPY] package*.json ./",
"[keyword RUN] npm install",
"[keyword COPY] . .",
"[keyword EXPOSE] [number 8080] [number 3000]",
"[keyword ENV] NODE_ENV development",
"[keyword CMD] [[ [string \"npm\"], [string \"start\"] ]]");
// Ideally the last space should not be highlighted.
MT("instruction_without_args_1",
"[keyword CMD] ");
MT("instruction_without_args_2",
"[comment # An instruction without args...]",
"[keyword ARG] [error #...is an error]");
MT("multiline",
"[keyword RUN] apt-get update && apt-get install -y \\",
" mercurial \\",
" subversion \\",
" && apt-get clean \\",
" && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*");
MT("from_comment",
" [keyword FROM] debian:stretch # I tend to use stable as that is more stable",
" [keyword FROM] debian:stretch [keyword AS] stable # I am even more stable",
" [keyword FROM] [error # this is an error]");
MT("from_as",
"[keyword FROM] golang:1.9.2-alpine3.6 [keyword AS] build",
"[keyword COPY] --from=build /bin/project /bin/project",
"[keyword ENTRYPOINT] [[ [string \"/bin/project\"] ]]",
"[keyword CMD] [[ [string \"--help\"] ]]");
MT("arg",
"[keyword ARG] VERSION=latest",
"[keyword FROM] busybox:$VERSION",
"[keyword ARG] VERSION",
"[keyword RUN] echo $VERSION > image_version");
MT("label",
"[keyword LABEL] com.example.label-with-value=[string \"foo\"]");
MT("label_multiline",
"[keyword LABEL] description=[string \"This text illustrates ]\\",
"[string that label-values can span multiple lines.\"]");
MT("maintainer",
"[keyword MAINTAINER] Foo Bar [string \"foo@bar.com\"] ",
"[keyword MAINTAINER] Bar Baz <bar@baz.com>");
MT("env",
"[keyword ENV] BUNDLE_PATH=[string \"$GEM_HOME\"] \\",
" BUNDLE_APP_CONFIG=[string \"$GEM_HOME\"]");
MT("verify_keyword",
"[keyword RUN] add-apt-repository ppa:chris-lea/node.js");
MT("scripts",
"[comment # Set an entrypoint, to automatically install node modules]",
"[keyword ENTRYPOINT] [[ [string \"/bin/bash\"], [string \"-c\"], [string \"if [[ ! -d node_modules ]]; then npm install; fi; exec \\\"${@:0}\\\";\"] ]]",
"[keyword CMD] npm start",
"[keyword RUN] npm run build && \\",
"[comment # a comment between the shell commands]",
" npm run test");
MT("strings_single",
"[keyword FROM] buildpack-deps:stretch",
"[keyword RUN] { \\",
" echo [string 'install: --no-document']; \\",
" echo [string 'update: --no-document']; \\",
" } >> /usr/local/etc/gemrc");
MT("strings_single_multiline",
"[keyword RUN] set -ex \\",
" \\",
" && buildDeps=[string ' ]\\",
"[string bison ]\\",
"[string dpkg-dev ]\\",
"[string libgdbm-dev ]\\",
"[string ruby ]\\",
"[string '] \\",
" && apt-get update");
MT("strings_single_multiline_2",
"[keyword RUN] echo [string 'say \\' ]\\",
"[string it works'] ");
MT("strings_double",
"[keyword RUN] apt-get install -y --no-install-recommends $buildDeps \\",
" \\",
" && wget -O ruby.tar.xz [string \"https://cache.ruby-lang.org/pub/ruby/${RUBY_MAJOR%-rc}/ruby-$RUBY_VERSION.tar.xz\"] \\",
" && echo [string \"$RUBY_DOWNLOAD_SHA256 *ruby.tar.xz\"] | sha256sum -c - ");
MT("strings_double_multiline",
"[keyword RUN] echo [string \"say \\\" ]\\",
"[string it works\"] ");
MT("escape",
"[comment # escape=`]",
"[keyword FROM] microsoft/windowsservercore",
"[keyword RUN] powershell.exe -Command `",
" $ErrorActionPreference = [string 'Stop']; `",
" wget https://www.python.org/ftp/python/3.5.1/python-3.5.1.exe -OutFile c:\python-3.5.1.exe ; `",
" Start-Process c:\python-3.5.1.exe -ArgumentList [string '/quiet InstallAllUsers=1 PrependPath=1'] -Wait ; `",
" Remove-Item c:\python-3.5.1.exe -Force)");
MT("escape_strings",
"[comment # escape=`]",
"[keyword FROM] python:3.6-windowsservercore [keyword AS] python",
"[keyword RUN] $env:PATH = [string 'C:\\Python;C:\\Python\\Scripts;{0}'] -f $env:PATH ; `",
// It should not consider \' as escaped.
// " Set-ItemProperty -Path [string 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment\\'] -Name Path -Value $env:PATH ;");
" Set-ItemProperty -Path [string 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment\\' -Name Path -Value $env:PATH ;]");
})();
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dtd/dtd.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
/*
DTD mode
Ported to CodeMirror by Peter Kroon <plakroon@gmail.com>
Report bugs/issues here: https://github.com/codemirror/CodeMirror/issues
GitHub: @peterkroon
*/
(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("dtd", function(config) {
var indentUnit = config.indentUnit, type;
function ret(style, tp) {type = tp; return style;}
function tokenBase(stream, state) {
var ch = stream.next();
if (ch == "<" && stream.eat("!") ) {
if (stream.eatWhile(/[\-]/)) {
state.tokenize = tokenSGMLComment;
return tokenSGMLComment(stream, state);
} else if (stream.eatWhile(/[\w]/)) return ret("keyword", "doindent");
} else if (ch == "<" && stream.eat("?")) { //xml declaration
state.tokenize = inBlock("meta", "?>");
return ret("meta", ch);
} else if (ch == "#" && stream.eatWhile(/[\w]/)) return ret("atom", "tag");
else if (ch == "|") return ret("keyword", "seperator");
else if (ch.match(/[\(\)\[\]\-\.,\+\?>]/)) return ret(null, ch);//if(ch === ">") return ret(null, "endtag"); else
else if (ch.match(/[\[\]]/)) return ret("rule", ch);
else if (ch == "\"" || ch == "'") {
state.tokenize = tokenString(ch);
return state.tokenize(stream, state);
} else if (stream.eatWhile(/[a-zA-Z\?\+\d]/)) {
var sc = stream.current();
if( sc.substr(sc.length-1,sc.length).match(/\?|\+/) !== null )stream.backUp(1);
return ret("tag", "tag");
} else if (ch == "%" || ch == "*" ) return ret("number", "number");
else {
stream.eatWhile(/[\w\\\-_%.{,]/);
return ret(null, null);
}
}
function tokenSGMLComment(stream, state) {
var dashes = 0, ch;
while ((ch = stream.next()) != null) {
if (dashes >= 2 && ch == ">") {
state.tokenize = tokenBase;
break;
}
dashes = (ch == "-") ? dashes + 1 : 0;
}
return ret("comment", "comment");
}
function tokenString(quote) {
return function(stream, state) {
var escaped = false, ch;
while ((ch = stream.next()) != null) {
if (ch == quote && !escaped) {
state.tokenize = tokenBase;
break;
}
escaped = !escaped && ch == "\\";
}
return ret("string", "tag");
};
}
function inBlock(style, terminator) {
return function(stream, state) {
while (!stream.eol()) {
if (stream.match(terminator)) {
state.tokenize = tokenBase;
break;
}
stream.next();
}
return style;
};
}
return {
startState: function(base) {
return {tokenize: tokenBase,
baseIndent: base || 0,
stack: []};
},
token: function(stream, state) {
if (stream.eatSpace()) return null;
var style = state.tokenize(stream, state);
var context = state.stack[state.stack.length-1];
if (stream.current() == "[" || type === "doindent" || type == "[") state.stack.push("rule");
else if (type === "endtag") state.stack[state.stack.length-1] = "endtag";
else if (stream.current() == "]" || type == "]" || (type == ">" && context == "rule")) state.stack.pop();
else if (type == "[") state.stack.push("[");
return style;
},
indent: function(state, textAfter) {
var n = state.stack.length;
if( textAfter.match(/\]\s+|\]/) )n=n-1;
else if(textAfter.substr(textAfter.length-1, textAfter.length) === ">"){
if(textAfter.substr(0,1) === "<") {}
else if( type == "doindent" && textAfter.length > 1 ) {}
else if( type == "doindent")n--;
else if( type == ">" && textAfter.length > 1) {}
else if( type == "tag" && textAfter !== ">") {}
else if( type == "tag" && state.stack[state.stack.length-1] == "rule")n--;
else if( type == "tag")n++;
else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule" && type === ">")n--;
else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule") {}
else if( textAfter.substr(0,1) !== "<" && textAfter.substr(0,1) === ">" )n=n-1;
else if( textAfter === ">") {}
else n=n-1;
//over rule them all
if(type == null || type == "]")n--;
}
return state.baseIndent + n * indentUnit;
},
electricChars: "]>"
};
});
CodeMirror.defineMIME("application/xml-dtd", "dtd");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dtd/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: DTD 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="dtd.js"></script>
<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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="#">DTD</a>
</ul>
</div>
<article>
<h2>DTD mode</h2>
<form><textarea id="code" name="code"><?xml version="1.0" encoding="UTF-8"?>
<!ATTLIST title
xmlns CDATA #FIXED "http://docbook.org/ns/docbook"
role CDATA #IMPLIED
%db.common.attributes;
%db.common.linking.attributes;
>
<!--
Try: http://docbook.org/xml/5.0/dtd/docbook.dtd
-->
<!DOCTYPE xsl:stylesheet
[
<!ENTITY nbsp "&amp;#160;">
<!ENTITY copy "&amp;#169;">
<!ENTITY reg "&amp;#174;">
<!ENTITY trade "&amp;#8482;">
<!ENTITY mdash "&amp;#8212;">
<!ENTITY ldquo "&amp;#8220;">
<!ENTITY rdquo "&amp;#8221;">
<!ENTITY pound "&amp;#163;">
<!ENTITY yen "&amp;#165;">
<!ENTITY euro "&amp;#8364;">
<!ENTITY mathml "http://www.w3.org/1998/Math/MathML">
]
>
<!ELEMENT title (#PCDATA|inlinemediaobject|remark|superscript|subscript|xref|link|olink|anchor|biblioref|alt|annotation|indexterm|abbrev|acronym|date|emphasis|footnote|footnoteref|foreignphrase|phrase|quote|wordasword|firstterm|glossterm|coref|trademark|productnumber|productname|database|application|hardware|citation|citerefentry|citetitle|citebiblioid|author|person|personname|org|orgname|editor|jobtitle|replaceable|package|parameter|termdef|nonterminal|systemitem|option|optional|property|inlineequation|tag|markup|token|symbol|literal|code|constant|email|uri|guiicon|guibutton|guimenuitem|guimenu|guisubmenu|guilabel|menuchoice|mousebutton|keycombo|keycap|keycode|keysym|shortcut|accel|prompt|envar|filename|command|computeroutput|userinput|function|varname|returnvalue|type|classname|exceptionname|interfacename|methodname|modifier|initializer|ooclass|ooexception|oointerface|errorcode|errortext|errorname|errortype)*>
<!ENTITY % db.common.attributes "
xml:id ID #IMPLIED
version CDATA #IMPLIED
xml:lang CDATA #IMPLIED
xml:base CDATA #IMPLIED
remap CDATA #IMPLIED
xreflabel CDATA #IMPLIED
revisionflag (changed|added|deleted|off) #IMPLIED
dir (ltr|rtl|lro|rlo) #IMPLIED
arch CDATA #IMPLIED
audience CDATA #IMPLIED
condition CDATA #IMPLIED
conformance CDATA #IMPLIED
os CDATA #IMPLIED
revision CDATA #IMPLIED
security CDATA #IMPLIED
userlevel CDATA #IMPLIED
vendor CDATA #IMPLIED
wordsize CDATA #IMPLIED
annotations CDATA #IMPLIED
"></textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
mode: {name: "dtd", alignCDATA: true},
lineNumbers: true,
lineWrapping: true
});
</script>
<p><strong>MIME types defined:</strong> <code>application/xml-dtd</code>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dylan/dylan.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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 forEach(arr, f) {
for (var i = 0; i < arr.length; i++) f(arr[i], i)
}
function some(arr, f) {
for (var i = 0; i < arr.length; i++) if (f(arr[i], i)) return true
return false
}
CodeMirror.defineMode("dylan", function(_config) {
// Words
var words = {
// Words that introduce unnamed definitions like "define interface"
unnamedDefinition: ["interface"],
// Words that introduce simple named definitions like "define library"
namedDefinition: ["module", "library", "macro",
"C-struct", "C-union",
"C-function", "C-callable-wrapper"
],
// Words that introduce type definitions like "define class".
// These are also parameterized like "define method" and are
// appended to otherParameterizedDefinitionWords
typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
// Words that introduce trickier definitions like "define method".
// These require special definitions to be added to startExpressions
otherParameterizedDefinition: ["method", "function",
"C-variable", "C-address"
],
// Words that introduce module constant definitions.
// These must also be simple definitions and are
// appended to otherSimpleDefinitionWords
constantSimpleDefinition: ["constant"],
// Words that introduce module variable definitions.
// These must also be simple definitions and are
// appended to otherSimpleDefinitionWords
variableSimpleDefinition: ["variable"],
// Other words that introduce simple definitions
// (without implicit bodies).
otherSimpleDefinition: ["generic", "domain",
"C-pointer-type",
"table"
],
// Words that begin statements with implicit bodies.
statement: ["if", "block", "begin", "method", "case",
"for", "select", "when", "unless", "until",
"while", "iterate", "profiling", "dynamic-bind"
],
// Patterns that act as separators in compound statements.
// This may include any general pattern that must be indented
// specially.
separator: ["finally", "exception", "cleanup", "else",
"elseif", "afterwards"
],
// Keywords that do not require special indentation handling,
// but which should be highlighted
other: ["above", "below", "by", "from", "handler", "in",
"instance", "let", "local", "otherwise", "slot",
"subclass", "then", "to", "keyed-by", "virtual"
],
// Condition signaling function calls
signalingCalls: ["signal", "error", "cerror",
"break", "check-type", "abort"
]
};
words["otherDefinition"] =
words["unnamedDefinition"]
.concat(words["namedDefinition"])
.concat(words["otherParameterizedDefinition"]);
words["definition"] =
words["typeParameterizedDefinition"]
.concat(words["otherDefinition"]);
words["parameterizedDefinition"] =
words["typeParameterizedDefinition"]
.concat(words["otherParameterizedDefinition"]);
words["simpleDefinition"] =
words["constantSimpleDefinition"]
.concat(words["variableSimpleDefinition"])
.concat(words["otherSimpleDefinition"]);
words["keyword"] =
words["statement"]
.concat(words["separator"])
.concat(words["other"]);
// Patterns
var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
var symbol = new RegExp("^" + symbolPattern);
var patterns = {
// Symbols with special syntax
symbolKeyword: symbolPattern + ":",
symbolClass: "<" + symbolPattern + ">",
symbolGlobal: "\\*" + symbolPattern + "\\*",
symbolConstant: "\\$" + symbolPattern
};
var patternStyles = {
symbolKeyword: "atom",
symbolClass: "tag",
symbolGlobal: "variable-2",
symbolConstant: "variable-3"
};
// Compile all patterns to regular expressions
for (var patternName in patterns)
if (patterns.hasOwnProperty(patternName))
patterns[patternName] = new RegExp("^" + patterns[patternName]);
// Names beginning "with-" and "without-" are commonly
// used as statement macro
patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
var styles = {};
styles["keyword"] = "keyword";
styles["definition"] = "def";
styles["simpleDefinition"] = "def";
styles["signalingCalls"] = "builtin";
// protected words lookup table
var wordLookup = {};
var styleLookup = {};
forEach([
"keyword",
"definition",
"simpleDefinition",
"signalingCalls"
], function(type) {
forEach(words[type], function(word) {
wordLookup[word] = type;
styleLookup[word] = styles[type];
});
});
function chain(stream, state, f) {
state.tokenize = f;
return f(stream, state);
}
function tokenBase(stream, state) {
// String
var ch = stream.peek();
if (ch == "'" || ch == '"') {
stream.next();
return chain(stream, state, tokenString(ch, "string"));
}
// Comment
else if (ch == "/") {
stream.next();
if (stream.eat("*")) {
return chain(stream, state, tokenComment);
} else if (stream.eat("/")) {
stream.skipToEnd();
return "comment";
}
stream.backUp(1);
}
// Decimal
else if (/[+\-\d\.]/.test(ch)) {
if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) ||
stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) ||
stream.match(/^[+-]?\d+/)) {
return "number";
}
}
// Hash
else if (ch == "#") {
stream.next();
// Symbol with string syntax
ch = stream.peek();
if (ch == '"') {
stream.next();
return chain(stream, state, tokenString('"', "string"));
}
// Binary number
else if (ch == "b") {
stream.next();
stream.eatWhile(/[01]/);
return "number";
}
// Hex number
else if (ch == "x") {
stream.next();
stream.eatWhile(/[\da-f]/i);
return "number";
}
// Octal number
else if (ch == "o") {
stream.next();
stream.eatWhile(/[0-7]/);
return "number";
}
// Token concatenation in macros
else if (ch == '#') {
stream.next();
return "punctuation";
}
// Sequence literals
else if ((ch == '[') || (ch == '(')) {
stream.next();
return "bracket";
// Hash symbol
} else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) {
return "atom";
} else {
stream.eatWhile(/[-a-zA-Z]/);
return "error";
}
} else if (ch == "~") {
stream.next();
ch = stream.peek();
if (ch == "=") {
stream.next();
ch = stream.peek();
if (ch == "=") {
stream.next();
return "operator";
}
return "operator";
}
return "operator";
} else if (ch == ":") {
stream.next();
ch = stream.peek();
if (ch == "=") {
stream.next();
return "operator";
} else if (ch == ":") {
stream.next();
return "punctuation";
}
} else if ("[](){}".indexOf(ch) != -1) {
stream.next();
return "bracket";
} else if (".,".indexOf(ch) != -1) {
stream.next();
return "punctuation";
} else if (stream.match("end")) {
return "keyword";
}
for (var name in patterns) {
if (patterns.hasOwnProperty(name)) {
var pattern = patterns[name];
if ((pattern instanceof Array && some(pattern, function(p) {
return stream.match(p);
})) || stream.match(pattern))
return patternStyles[name];
}
}
if (/[+\-*\/^=<>&|]/.test(ch)) {
stream.next();
return "operator";
}
if (stream.match("define")) {
return "def";
} else {
stream.eatWhile(/[\w\-]/);
// Keyword
if (wordLookup.hasOwnProperty(stream.current())) {
return styleLookup[stream.current()];
} else if (stream.current().match(symbol)) {
return "variable";
} else {
stream.next();
return "variable-2";
}
}
}
function tokenComment(stream, state) {
var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
while ((ch = stream.next())) {
if (ch == "/" && maybeEnd) {
if (nestedCount > 0) {
nestedCount--;
} else {
state.tokenize = tokenBase;
break;
}
} else if (ch == "*" && maybeNested) {
nestedCount++;
}
maybeEnd = (ch == "*");
maybeNested = (ch == "/");
}
return "comment";
}
function tokenString(quote, style) {
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) {
state.tokenize = tokenBase;
}
return style;
};
}
// Interface
return {
startState: function() {
return {
tokenize: tokenBase,
currentIndent: 0
};
},
token: function(stream, state) {
if (stream.eatSpace())
return null;
var style = state.tokenize(stream, state);
return style;
},
blockCommentStart: "/*",
blockCommentEnd: "*/"
};
});
CodeMirror.defineMIME("text/x-dylan", "dylan");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dylan/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: Dylan 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="../../addon/comment/continuecomment.js"></script>
<script src="../../addon/comment/comment.js"></script>
<script src="dylan.js"></script>
<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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="#">Dylan</a>
</ul>
</div>
<article>
<h2>Dylan mode</h2>
<div><textarea id="code" name="code">
Module: locators-internals
Synopsis: Abstract modeling of locations
Author: Andy Armstrong
Copyright: Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
All rights reserved.
License: See License.txt in this distribution for details.
Warranty: Distributed WITHOUT WARRANTY OF ANY KIND
define open generic locator-server
(locator :: <locator>) => (server :: false-or(<server-locator>));
define open generic locator-host
(locator :: <locator>) => (host :: false-or(<string>));
define open generic locator-volume
(locator :: <locator>) => (volume :: false-or(<string>));
define open generic locator-directory
(locator :: <locator>) => (directory :: false-or(<directory-locator>));
define open generic locator-relative?
(locator :: <locator>) => (relative? :: <boolean>);
define open generic locator-path
(locator :: <locator>) => (path :: <sequence>);
define open generic locator-base
(locator :: <locator>) => (base :: false-or(<string>));
define open generic locator-extension
(locator :: <locator>) => (extension :: false-or(<string>));
/// Locator classes
define open abstract class <directory-locator> (<physical-locator>)
end class <directory-locator>;
define open abstract class <file-locator> (<physical-locator>)
end class <file-locator>;
define method as
(class == <directory-locator>, string :: <string>)
=> (locator :: <directory-locator>)
as(<native-directory-locator>, string)
end method as;
define method make
(class == <directory-locator>,
#key server :: false-or(<server-locator>) = #f,
path :: <sequence> = #[],
relative? :: <boolean> = #f,
name :: false-or(<string>) = #f)
=> (locator :: <directory-locator>)
make(<native-directory-locator>,
server: server,
path: path,
relative?: relative?,
name: name)
end method make;
define method as
(class == <file-locator>, string :: <string>)
=> (locator :: <file-locator>)
as(<native-file-locator>, string)
end method as;
define method make
(class == <file-locator>,
#key directory :: false-or(<directory-locator>) = #f,
base :: false-or(<string>) = #f,
extension :: false-or(<string>) = #f,
name :: false-or(<string>) = #f)
=> (locator :: <file-locator>)
make(<native-file-locator>,
directory: directory,
base: base,
extension: extension,
name: name)
end method make;
/// Locator coercion
//---*** andrewa: This caching scheme doesn't work yet, so disable it.
define constant $cache-locators? = #f;
define constant $cache-locator-strings? = #f;
define constant $locator-to-string-cache = make(<object-table>, weak: #"key");
define constant $string-to-locator-cache = make(<string-table>, weak: #"value");
define open generic locator-as-string
(class :: subclass(<string>), locator :: <locator>)
=> (string :: <string>);
define open generic string-as-locator
(class :: subclass(<locator>), string :: <string>)
=> (locator :: <locator>);
define sealed sideways method as
(class :: subclass(<string>), locator :: <locator>)
=> (string :: <string>)
let string = element($locator-to-string-cache, locator, default: #f);
if (string)
as(class, string)
else
let string = locator-as-string(class, locator);
if ($cache-locator-strings?)
element($locator-to-string-cache, locator) := string;
else
string
end
end
end method as;
define sealed sideways method as
(class :: subclass(<locator>), string :: <string>)
=> (locator :: <locator>)
let locator = element($string-to-locator-cache, string, default: #f);
if (instance?(locator, class))
locator
else
let locator = string-as-locator(class, string);
if ($cache-locators?)
element($string-to-locator-cache, string) := locator;
else
locator
end
end
end method as;
/// Locator conditions
define class <locator-error> (<format-string-condition>, <error>)
end class <locator-error>;
define function locator-error
(format-string :: <string>, #rest format-arguments)
error(make(<locator-error>,
format-string: format-string,
format-arguments: format-arguments))
end function locator-error;
/// Useful locator protocols
define open generic locator-test
(locator :: <directory-locator>) => (test :: <function>);
define method locator-test
(locator :: <directory-locator>) => (test :: <function>)
\=
end method locator-test;
define open generic locator-might-have-links?
(locator :: <directory-locator>) => (links? :: <boolean>);
define method locator-might-have-links?
(locator :: <directory-locator>) => (links? :: singleton(#f))
#f
end method locator-might-have-links?;
define method locator-relative?
(locator :: <file-locator>) => (relative? :: <boolean>)
let directory = locator.locator-directory;
~directory | directory.locator-relative?
end method locator-relative?;
define method current-directory-locator?
(locator :: <directory-locator>) => (current-directory? :: <boolean>)
locator.locator-relative?
& locator.locator-path = #[#"self"]
end method current-directory-locator?;
define method locator-directory
(locator :: <directory-locator>) => (parent :: false-or(<directory-locator>))
let path = locator.locator-path;
unless (empty?(path))
make(object-class(locator),
server: locator.locator-server,
path: copy-sequence(path, end: path.size - 1),
relative?: locator.locator-relative?)
end
end method locator-directory;
/// Simplify locator
define open generic simplify-locator
(locator :: <physical-locator>)
=> (simplified-locator :: <physical-locator>);
define method simplify-locator
(locator :: <directory-locator>)
=> (simplified-locator :: <directory-locator>)
let path = locator.locator-path;
let relative? = locator.locator-relative?;
let resolve-parent? = ~locator.locator-might-have-links?;
let simplified-path
= simplify-path(path,
resolve-parent?: resolve-parent?,
relative?: relative?);
if (path ~= simplified-path)
make(object-class(locator),
server: locator.locator-server,
path: simplified-path,
relative?: locator.locator-relative?)
else
locator
end
end method simplify-locator;
define method simplify-locator
(locator :: <file-locator>) => (simplified-locator :: <file-locator>)
let directory = locator.locator-directory;
let simplified-directory = directory & simplify-locator(directory);
if (directory ~= simplified-directory)
make(object-class(locator),
directory: simplified-directory,
base: locator.locator-base,
extension: locator.locator-extension)
else
locator
end
end method simplify-locator;
/// Subdirectory locator
define open generic subdirectory-locator
(locator :: <directory-locator>, #rest sub-path)
=> (subdirectory :: <directory-locator>);
define method subdirectory-locator
(locator :: <directory-locator>, #rest sub-path)
=> (subdirectory :: <directory-locator>)
let old-path = locator.locator-path;
let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path);
make(object-class(locator),
server: locator.locator-server,
path: new-path,
relative?: locator.locator-relative?)
end method subdirectory-locator;
/// Relative locator
define open generic relative-locator
(locator :: <physical-locator>, from-locator :: <physical-locator>)
=> (relative-locator :: <physical-locator>);
define method relative-locator
(locator :: <directory-locator>, from-locator :: <directory-locator>)
=> (relative-locator :: <directory-locator>)
let path = locator.locator-path;
let from-path = from-locator.locator-path;
case
~locator.locator-relative? & from-locator.locator-relative? =>
locator-error
("Cannot find relative path of absolute locator %= from relative locator %=",
locator, from-locator);
locator.locator-server ~= from-locator.locator-server =>
locator;
path = from-path =>
make(object-class(locator),
path: vector(#"self"),
relative?: #t);
otherwise =>
make(object-class(locator),
path: relative-path(path, from-path, test: locator.locator-test),
relative?: #t);
end
end method relative-locator;
define method relative-locator
(locator :: <file-locator>, from-directory :: <directory-locator>)
=> (relative-locator :: <file-locator>)
let directory = locator.locator-directory;
let relative-directory = directory & relative-locator(directory, from-directory);
if (relative-directory ~= directory)
simplify-locator
(make(object-class(locator),
directory: relative-directory,
base: locator.locator-base,
extension: locator.locator-extension))
else
locator
end
end method relative-locator;
define method relative-locator
(locator :: <physical-locator>, from-locator :: <file-locator>)
=> (relative-locator :: <physical-locator>)
let from-directory = from-locator.locator-directory;
case
from-directory =>
relative-locator(locator, from-directory);
~locator.locator-relative? =>
locator-error
("Cannot find relative path of absolute locator %= from relative locator %=",
locator, from-locator);
otherwise =>
locator;
end
end method relative-locator;
/// Merge locators
define open generic merge-locators
(locator :: <physical-locator>, from-locator :: <physical-locator>)
=> (merged-locator :: <physical-locator>);
/// Merge locators
define method merge-locators
(locator :: <directory-locator>, from-locator :: <directory-locator>)
=> (merged-locator :: <directory-locator>)
if (locator.locator-relative?)
let path = concatenate(from-locator.locator-path, locator.locator-path);
simplify-locator
(make(object-class(locator),
server: from-locator.locator-server,
path: path,
relative?: from-locator.locator-relative?))
else
locator
end
end method merge-locators;
define method merge-locators
(locator :: <file-locator>, from-locator :: <directory-locator>)
=> (merged-locator :: <file-locator>)
let directory = locator.locator-directory;
let merged-directory
= if (directory)
merge-locators(directory, from-locator)
else
simplify-locator(from-locator)
end;
if (merged-directory ~= directory)
make(object-class(locator),
directory: merged-directory,
base: locator.locator-base,
extension: locator.locator-extension)
else
locator
end
end method merge-locators;
define method merge-locators
(locator :: <physical-locator>, from-locator :: <file-locator>)
=> (merged-locator :: <physical-locator>)
let from-directory = from-locator.locator-directory;
if (from-directory)
merge-locators(locator, from-directory)
else
locator
end
end method merge-locators;
/// Locator protocols
define sideways method supports-open-locator?
(locator :: <file-locator>) => (openable? :: <boolean>)
~locator.locator-relative?
end method supports-open-locator?;
define sideways method open-locator
(locator :: <file-locator>, #rest keywords, #key, #all-keys)
=> (stream :: <stream>)
apply(open-file-stream, locator, keywords)
end method open-locator;
</textarea></div>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
mode: "text/x-dylan",
lineNumbers: true,
matchBrackets: true,
continueComments: "Enter",
extraKeys: {"Ctrl-Q": "toggleComment"},
tabMode: "indent",
indentUnit: 2
});
</script>
<p><strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/dylan/test.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
(function() {
var mode = CodeMirror.getMode({indentUnit: 2}, "dylan");
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
MT('comments',
'[comment // This is a line comment]',
'[comment /* This is a block comment */]',
'[comment /* This is a multi]',
'[comment line comment]',
'[comment */]',
'[comment /* And this is a /*]',
'[comment /* nested */ comment */]');
MT('unary_operators',
'[operator -][variable a]',
'[operator -] [variable a]',
'[operator ~][variable a]',
'[operator ~] [variable a]');
MT('binary_operators',
'[variable a] [operator +] [variable b]',
'[variable a] [operator -] [variable b]',
'[variable a] [operator *] [variable b]',
'[variable a] [operator /] [variable b]',
'[variable a] [operator ^] [variable b]',
'[variable a] [operator =] [variable b]',
'[variable a] [operator ==] [variable b]',
'[variable a] [operator ~=] [variable b]',
'[variable a] [operator ~==] [variable b]',
'[variable a] [operator <] [variable b]',
'[variable a] [operator <=] [variable b]',
'[variable a] [operator >] [variable b]',
'[variable a] [operator >=] [variable b]',
'[variable a] [operator &] [variable b]',
'[variable a] [operator |] [variable b]',
'[variable a] [operator :=] [variable b]');
MT('integers',
'[number 1]',
'[number 123]',
'[number -123]',
'[number +456]',
'[number #b010]',
'[number #o073]',
'[number #xabcDEF123]');
MT('floats',
'[number .3]',
'[number -1.]',
'[number -2.335]',
'[number +3.78d1]',
'[number 3.78s-1]',
'[number -3.32e+5]');
MT('characters_and_strings',
"[string 'a']",
"[string '\\\\'']",
'[string ""]',
'[string "a"]',
'[string "abc def"]',
'[string "More escaped characters: \\\\\\\\ \\\\a \\\\b \\\\e \\\\f \\\\n \\\\r \\\\t \\\\0 ..."]');
MT('brackets',
'[bracket #[[]]]',
'[bracket #()]',
'[bracket #(][number 1][bracket )]',
'[bracket [[][number 1][punctuation ,] [number 3][bracket ]]]',
'[bracket ()]',
'[bracket {}]',
'[keyword if] [bracket (][variable foo][bracket )]',
'[bracket (][number 1][bracket )]',
'[bracket [[][number 1][bracket ]]]');
MT('hash_words',
'[punctuation ##]',
'[atom #f]', '[atom #F]',
'[atom #t]', '[atom #T]',
'[atom #all-keys]',
'[atom #include]',
'[atom #key]',
'[atom #next]',
'[atom #rest]',
'[string #"foo"]',
'[error #invalid]');
})();
src/main/webapp/static/plugins/codemirror/5.48.4/mode/ebnf/ebnf.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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("ebnf", function (config) {
var commentType = {slash: 0, parenthesis: 1};
var stateType = {comment: 0, _string: 1, characterClass: 2};
var bracesMode = null;
if (config.bracesMode)
bracesMode = CodeMirror.getMode(config, config.bracesMode);
return {
startState: function () {
return {
stringType: null,
commentType: null,
braced: 0,
lhs: true,
localState: null,
stack: [],
inDefinition: false
};
},
token: function (stream, state) {
if (!stream) return;
//check for state changes
if (state.stack.length === 0) {
//strings
if ((stream.peek() == '"') || (stream.peek() == "'")) {
state.stringType = stream.peek();
stream.next(); // Skip quote
state.stack.unshift(stateType._string);
} else if (stream.match(/^\/\*/)) { //comments starting with /*
state.stack.unshift(stateType.comment);
state.commentType = commentType.slash;
} else if (stream.match(/^\(\*/)) { //comments starting with (*
state.stack.unshift(stateType.comment);
state.commentType = commentType.parenthesis;
}
}
//return state
//stack has
switch (state.stack[0]) {
case stateType._string:
while (state.stack[0] === stateType._string && !stream.eol()) {
if (stream.peek() === state.stringType) {
stream.next(); // Skip quote
state.stack.shift(); // Clear flag
} else if (stream.peek() === "\\") {
stream.next();
stream.next();
} else {
stream.match(/^.[^\\\"\']*/);
}
}
return state.lhs ? "property string" : "string"; // Token style
case stateType.comment:
while (state.stack[0] === stateType.comment && !stream.eol()) {
if (state.commentType === commentType.slash && stream.match(/\*\//)) {
state.stack.shift(); // Clear flag
state.commentType = null;
} else if (state.commentType === commentType.parenthesis && stream.match(/\*\)/)) {
state.stack.shift(); // Clear flag
state.commentType = null;
} else {
stream.match(/^.[^\*]*/);
}
}
return "comment";
case stateType.characterClass:
while (state.stack[0] === stateType.characterClass && !stream.eol()) {
if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
state.stack.shift();
}
}
return "operator";
}
var peek = stream.peek();
if (bracesMode !== null && (state.braced || peek === "{")) {
if (state.localState === null)
state.localState = CodeMirror.startState(bracesMode);
var token = bracesMode.token(stream, state.localState),
text = stream.current();
if (!token) {
for (var i = 0; i < text.length; i++) {
if (text[i] === "{") {
if (state.braced === 0) {
token = "matchingbracket";
}
state.braced++;
} else if (text[i] === "}") {
state.braced--;
if (state.braced === 0) {
token = "matchingbracket";
}
}
}
}
return token;
}
//no stack
switch (peek) {
case "[":
stream.next();
state.stack.unshift(stateType.characterClass);
return "bracket";
case ":":
case "|":
case ";":
stream.next();
return "operator";
case "%":
if (stream.match("%%")) {
return "header";
} else if (stream.match(/[%][A-Za-z]+/)) {
return "keyword";
} else if (stream.match(/[%][}]/)) {
return "matchingbracket";
}
break;
case "/":
if (stream.match(/[\/][A-Za-z]+/)) {
return "keyword";
}
case "\\":
if (stream.match(/[\][a-z]+/)) {
return "string-2";
}
case ".":
if (stream.match(".")) {
return "atom";
}
case "*":
case "-":
case "+":
case "^":
if (stream.match(peek)) {
return "atom";
}
case "$":
if (stream.match("$$")) {
return "builtin";
} else if (stream.match(/[$][0-9]+/)) {
return "variable-3";
}
case "<":
if (stream.match(/<<[a-zA-Z_]+>>/)) {
return "builtin";
}
}
if (stream.match(/^\/\//)) {
stream.skipToEnd();
return "comment";
} else if (stream.match(/return/)) {
return "operator";
} else if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
if (stream.match(/(?=[\(.])/)) {
return "variable";
} else if (stream.match(/(?=[\s\n]*[:=])/)) {
return "def";
}
return "variable-2";
} else if (["[", "]", "(", ")"].indexOf(stream.peek()) != -1) {
stream.next();
return "bracket";
} else if (!stream.eatSpace()) {
stream.next();
}
return null;
}
};
});
CodeMirror.defineMIME("text/x-ebnf", "ebnf");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/ebnf/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<html>
<head>
<title>CodeMirror: EBNF 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="../javascript/javascript.js"></script>
<script src="ebnf.js"></script>
<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
</head>
<body>
<div id=nav>
<a href="https://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="#">EBNF Mode</a>
</ul>
</div>
<article>
<h2>EBNF Mode (bracesMode setting = "javascript")</h2>
<form><textarea id="code" name="code">
/* description: Parses end executes mathematical expressions. */
/* lexical grammar */
%lex
%%
\s+ /* skip whitespace */
[0-9]+("."[0-9]+)?\b return 'NUMBER';
"*" return '*';
"/" return '/';
"-" return '-';
"+" return '+';
"^" return '^';
"(" return '(';
")" return ')';
"PI" return 'PI';
"E" return 'E';
&lt;&lt;EOF&gt;&gt; return 'EOF';
/lex
/* operator associations and precedence */
%left '+' '-'
%left '*' '/'
%left '^'
%left UMINUS
%start expressions
%% /* language grammar */
expressions
: e EOF
{print($1); return $1;}
;
e
: e '+' e
{$$ = $1+$3;}
| e '-' e
{$$ = $1-$3;}
| e '*' e
{$$ = $1*$3;}
| e '/' e
{$$ = $1/$3;}
| e '^' e
{$$ = Math.pow($1, $3);}
| '-' e %prec UMINUS
{$$ = -$2;}
| '(' e ')'
{$$ = $2;}
| NUMBER
{$$ = Number(yytext);}
| E
{$$ = Math.E;}
| PI
{$$ = Math.PI;}
;</textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
mode: {name: "ebnf"},
lineNumbers: true,
bracesMode: 'javascript'
});
</script>
<h3>The EBNF Mode</h3>
<p> Created by <a href="https://github.com/robertleeplummerjr">Robert Plummer</a></p>
</article>
</body>
</html>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/ecl/ecl.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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("ecl", function(config) {
function words(str) {
var obj = {}, words = str.split(" ");
for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
return obj;
}
function metaHook(stream, state) {
if (!state.startOfLine) return false;
stream.skipToEnd();
return "meta";
}
var indentUnit = config.indentUnit;
var keyword = words("abs acos allnodes ascii asin asstring atan atan2 ave case choose choosen choosesets clustersize combine correlation cos cosh count covariance cron dataset dedup define denormalize distribute distributed distribution ebcdic enth error evaluate event eventextra eventname exists exp failcode failmessage fetch fromunicode getisvalid global graph group hash hash32 hash64 hashcrc hashmd5 having if index intformat isvalid iterate join keyunicode length library limit ln local log loop map matched matchlength matchposition matchtext matchunicode max merge mergejoin min nolocal nonempty normalize parse pipe power preload process project pull random range rank ranked realformat recordof regexfind regexreplace regroup rejected rollup round roundup row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt stepped stored sum table tan tanh thisnode topn tounicode transfer trim truncate typeof ungroup unicodeorder variance which workunit xmldecode xmlencode xmltext xmlunicode");
var variable = words("apply assert build buildindex evaluate fail keydiff keypatch loadxml nothor notify output parallel sequential soapcall wait");
var variable_2 = words("__compressed__ all and any as atmost before beginc++ best between case const counter csv descend encrypt end endc++ endmacro except exclusive expire export extend false few first flat from full function group header heading hole ifblock import in interface joined keep keyed last left limit load local locale lookup macro many maxcount maxlength min skew module named nocase noroot noscan nosort not of only opt or outer overwrite packed partition penalty physicallength pipe quote record relationship repeat return right scan self separator service shared skew skip sql store terminator thor threshold token transform trim true type unicodeorder unsorted validate virtual whole wild within xml xpath");
var variable_3 = words("ascii big_endian boolean data decimal ebcdic integer pattern qstring real record rule set of string token udecimal unicode unsigned varstring varunicode");
var builtin = words("checkpoint deprecated failcode failmessage failure global independent onwarning persist priority recovery stored success wait when");
var blockKeywords = words("catch class do else finally for if switch try while");
var atoms = words("true false null");
var hooks = {"#": metaHook};
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 == "'") {
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 tokenComment(stream, state);
}
if (stream.eat("/")) {
stream.skipToEnd();
return "comment";
}
}
if (isOperatorChar.test(ch)) {
stream.eatWhile(isOperatorChar);
return "operator";
}
stream.eatWhile(/[\w\$_]/);
var cur = stream.current().toLowerCase();
if (keyword.propertyIsEnumerable(cur)) {
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
return "keyword";
} else if (variable.propertyIsEnumerable(cur)) {
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
return "variable";
} else if (variable_2.propertyIsEnumerable(cur)) {
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
return "variable-2";
} else if (variable_3.propertyIsEnumerable(cur)) {
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
return "variable-3";
} else if (builtin.propertyIsEnumerable(cur)) {
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
return "builtin";
} else { //Data types are of from KEYWORD##
var i = cur.length - 1;
while(i >= 0 && (!isNaN(cur[i]) || cur[i] == '_'))
--i;
if (i > 0) {
var cur2 = cur.substr(0, i + 1);
if (variable_3.propertyIsEnumerable(cur2)) {
if (blockKeywords.propertyIsEnumerable(cur2)) curPunc = "newstatement";
return "variable-3";
}
}
}
if (atoms.propertyIsEnumerable(cur)) return "atom";
return null;
}
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)
state.tokenize = tokenBase;
return "string";
};
}
function tokenComment(stream, state) {
var maybeEnd = false, ch;
while (ch = stream.next()) {
if (ch == "/" && maybeEnd) {
state.tokenize = tokenBase;
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) {
return state.context = new Context(state.indented, 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 == ":") && 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" || (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 0;
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 : indentUnit);
else if (ctx.align) return ctx.column + (closing ? 0 : 1);
else return ctx.indented + (closing ? 0 : indentUnit);
},
electricChars: "{}"
};
});
CodeMirror.defineMIME("text/x-ecl", "ecl");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/ecl/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: ECL 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="ecl.js"></script>
<style>.CodeMirror {border: 1px solid black;}</style>
<div id=nav>
<a href="https://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="#">ECL</a>
</ul>
</div>
<article>
<h2>ECL mode</h2>
<form><textarea id="code" name="code">
/*
sample useless code to demonstrate ecl syntax highlighting
this is a multiline comment!
*/
// this is a singleline comment!
import ut;
r :=
record
string22 s1 := '123';
integer4 i1 := 123;
end;
#option('tmp', true);
d := dataset('tmp::qb', r, thor);
output(d);
</textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {});
</script>
<p>Based on CodeMirror's clike mode. For more information see <a href="http://hpccsystems.com">HPCC Systems</a> web site.</p>
<p><strong>MIME types defined:</strong> <code>text/x-ecl</code>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/eiffel/eiffel.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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("eiffel", function() {
function wordObj(words) {
var o = {};
for (var i = 0, e = words.length; i < e; ++i) o[words[i]] = true;
return o;
}
var keywords = wordObj([
'note',
'across',
'when',
'variant',
'until',
'unique',
'undefine',
'then',
'strip',
'select',
'retry',
'rescue',
'require',
'rename',
'reference',
'redefine',
'prefix',
'once',
'old',
'obsolete',
'loop',
'local',
'like',
'is',
'inspect',
'infix',
'include',
'if',
'frozen',
'from',
'external',
'export',
'ensure',
'end',
'elseif',
'else',
'do',
'creation',
'create',
'check',
'alias',
'agent',
'separate',
'invariant',
'inherit',
'indexing',
'feature',
'expanded',
'deferred',
'class',
'Void',
'True',
'Result',
'Precursor',
'False',
'Current',
'create',
'attached',
'detachable',
'as',
'and',
'implies',
'not',
'or'
]);
var operators = wordObj([":=", "and then","and", "or","<<",">>"]);
function chain(newtok, stream, state) {
state.tokenize.push(newtok);
return newtok(stream, state);
}
function tokenBase(stream, state) {
if (stream.eatSpace()) return null;
var ch = stream.next();
if (ch == '"'||ch == "'") {
return chain(readQuoted(ch, "string"), stream, state);
} else if (ch == "-"&&stream.eat("-")) {
stream.skipToEnd();
return "comment";
} else if (ch == ":"&&stream.eat("=")) {
return "operator";
} else if (/[0-9]/.test(ch)) {
stream.eatWhile(/[xXbBCc0-9\.]/);
stream.eat(/[\?\!]/);
return "ident";
} else if (/[a-zA-Z_0-9]/.test(ch)) {
stream.eatWhile(/[a-zA-Z_0-9]/);
stream.eat(/[\?\!]/);
return "ident";
} else if (/[=+\-\/*^%<>~]/.test(ch)) {
stream.eatWhile(/[=+\-\/*^%<>~]/);
return "operator";
} else {
return null;
}
}
function readQuoted(quote, style, unescaped) {
return function(stream, state) {
var escaped = false, ch;
while ((ch = stream.next()) != null) {
if (ch == quote && (unescaped || !escaped)) {
state.tokenize.pop();
break;
}
escaped = !escaped && ch == "%";
}
return style;
};
}
return {
startState: function() {
return {tokenize: [tokenBase]};
},
token: function(stream, state) {
var style = state.tokenize[state.tokenize.length-1](stream, state);
if (style == "ident") {
var word = stream.current();
style = keywords.propertyIsEnumerable(stream.current()) ? "keyword"
: operators.propertyIsEnumerable(stream.current()) ? "operator"
: /^[A-Z][A-Z_0-9]*$/g.test(word) ? "tag"
: /^0[bB][0-1]+$/g.test(word) ? "number"
: /^0[cC][0-7]+$/g.test(word) ? "number"
: /^0[xX][a-fA-F0-9]+$/g.test(word) ? "number"
: /^([0-9]+\.[0-9]*)|([0-9]*\.[0-9]+)$/g.test(word) ? "number"
: /^[0-9]+$/g.test(word) ? "number"
: "variable";
}
return style;
},
lineComment: "--"
};
});
CodeMirror.defineMIME("text/x-eiffel", "eiffel");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/eiffel/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: Eiffel 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">
<script src="../../lib/codemirror.js"></script>
<script src="eiffel.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="https://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="#">Eiffel</a>
</ul>
</div>
<article>
<h2>Eiffel mode</h2>
<form><textarea id="code" name="code">
note
description: "[
Project-wide universal properties.
This class is an ancestor to all developer-written classes.
ANY may be customized for individual projects or teams.
]"
library: "Free implementation of ELKS library"
status: "See notice at end of class."
legal: "See notice at end of class."
date: "$Date: 2013-01-25 11:49:00 -0800 (Fri, 25 Jan 2013) $"
revision: "$Revision: 712 $"
class
ANY
feature -- Customization
feature -- Access
generator: STRING
-- Name of current object's generating class
-- (base class of the type of which it is a direct instance)
external
"built_in"
ensure
generator_not_void: Result /= Void
generator_not_empty: not Result.is_empty
end
generating_type: TYPE [detachable like Current]
-- Type of current object
-- (type of which it is a direct instance)
do
Result := {detachable like Current}
ensure
generating_type_not_void: Result /= Void
end
feature -- Status report
conforms_to (other: ANY): BOOLEAN
-- Does type of current object conform to type
-- of `other' (as per Eiffel: The Language, chapter 13)?
require
other_not_void: other /= Void
external
"built_in"
end
same_type (other: ANY): BOOLEAN
-- Is type of current object identical to type of `other'?
require
other_not_void: other /= Void
external
"built_in"
ensure
definition: Result = (conforms_to (other) and
other.conforms_to (Current))
end
feature -- Comparison
is_equal (other: like Current): BOOLEAN
-- Is `other' attached to an object considered
-- equal to current object?
require
other_not_void: other /= Void
external
"built_in"
ensure
symmetric: Result implies other ~ Current
consistent: standard_is_equal (other) implies Result
end
frozen standard_is_equal (other: like Current): BOOLEAN
-- Is `other' attached to an object of the same type
-- as current object, and field-by-field identical to it?
require
other_not_void: other /= Void
external
"built_in"
ensure
same_type: Result implies same_type (other)
symmetric: Result implies other.standard_is_equal (Current)
end
frozen equal (a: detachable ANY; b: like a): BOOLEAN
-- Are `a' and `b' either both void or attached
-- to objects considered equal?
do
if a = Void then
Result := b = Void
else
Result := b /= Void and then
a.is_equal (b)
end
ensure
definition: Result = (a = Void and b = Void) or else
((a /= Void and b /= Void) and then
a.is_equal (b))
end
frozen standard_equal (a: detachable ANY; b: like a): BOOLEAN
-- Are `a' and `b' either both void or attached to
-- field-by-field identical objects of the same type?
-- Always uses default object comparison criterion.
do
if a = Void then
Result := b = Void
else
Result := b /= Void and then
a.standard_is_equal (b)
end
ensure
definition: Result = (a = Void and b = Void) or else
((a /= Void and b /= Void) and then
a.standard_is_equal (b))
end
frozen is_deep_equal (other: like Current): BOOLEAN
-- Are `Current' and `other' attached to isomorphic object structures?
require
other_not_void: other /= Void
external
"built_in"
ensure
shallow_implies_deep: standard_is_equal (other) implies Result
same_type: Result implies same_type (other)
symmetric: Result implies other.is_deep_equal (Current)
end
frozen deep_equal (a: detachable ANY; b: like a): BOOLEAN
-- Are `a' and `b' either both void
-- or attached to isomorphic object structures?
do
if a = Void then
Result := b = Void
else
Result := b /= Void and then a.is_deep_equal (b)
end
ensure
shallow_implies_deep: standard_equal (a, b) implies Result
both_or_none_void: (a = Void) implies (Result = (b = Void))
same_type: (Result and (a /= Void)) implies (b /= Void and then a.same_type (b))
symmetric: Result implies deep_equal (b, a)
end
feature -- Duplication
frozen twin: like Current
-- New object equal to `Current'
-- `twin' calls `copy'; to change copying/twinning semantics, redefine `copy'.
external
"built_in"
ensure
twin_not_void: Result /= Void
is_equal: Result ~ Current
end
copy (other: like Current)
-- Update current object using fields of object attached
-- to `other', so as to yield equal objects.
require
other_not_void: other /= Void
type_identity: same_type (other)
external
"built_in"
ensure
is_equal: Current ~ other
end
frozen standard_copy (other: like Current)
-- Copy every field of `other' onto corresponding field
-- of current object.
require
other_not_void: other /= Void
type_identity: same_type (other)
external
"built_in"
ensure
is_standard_equal: standard_is_equal (other)
end
frozen clone (other: detachable ANY): like other
-- Void if `other' is void; otherwise new object
-- equal to `other'
--
-- For non-void `other', `clone' calls `copy';
-- to change copying/cloning semantics, redefine `copy'.
obsolete
"Use `twin' instead."
do
if other /= Void then
Result := other.twin
end
ensure
equal: Result ~ other
end
frozen standard_clone (other: detachable ANY): like other
-- Void if `other' is void; otherwise new object
-- field-by-field identical to `other'.
-- Always uses default copying semantics.
obsolete
"Use `standard_twin' instead."
do
if other /= Void then
Result := other.standard_twin
end
ensure
equal: standard_equal (Result, other)
end
frozen standard_twin: like Current
-- New object field-by-field identical to `other'.
-- Always uses default copying semantics.
external
"built_in"
ensure
standard_twin_not_void: Result /= Void
equal: standard_equal (Result, Current)
end
frozen deep_twin: like Current
-- New object structure recursively duplicated from Current.
external
"built_in"
ensure
deep_twin_not_void: Result /= Void
deep_equal: deep_equal (Current, Result)
end
frozen deep_clone (other: detachable ANY): like other
-- Void if `other' is void: otherwise, new object structure
-- recursively duplicated from the one attached to `other'
obsolete
"Use `deep_twin' instead."
do
if other /= Void then
Result := other.deep_twin
end
ensure
deep_equal: deep_equal (other, Result)
end
frozen deep_copy (other: like Current)
-- Effect equivalent to that of:
-- `copy' (`other' . `deep_twin')
require
other_not_void: other /= Void
do
copy (other.deep_twin)
ensure
deep_equal: deep_equal (Current, other)
end
feature {NONE} -- Retrieval
frozen internal_correct_mismatch
-- Called from runtime to perform a proper dynamic dispatch on `correct_mismatch'
-- from MISMATCH_CORRECTOR.
local
l_msg: STRING
l_exc: EXCEPTIONS
do
if attached {MISMATCH_CORRECTOR} Current as l_corrector then
l_corrector.correct_mismatch
else
create l_msg.make_from_string ("Mismatch: ")
create l_exc
l_msg.append (generating_type.name)
l_exc.raise_retrieval_exception (l_msg)
end
end
feature -- Output
io: STD_FILES
-- Handle to standard file setup
once
create Result
Result.set_output_default
ensure
io_not_void: Result /= Void
end
out: STRING
-- New string containing terse printable representation
-- of current object
do
Result := tagged_out
ensure
out_not_void: Result /= Void
end
frozen tagged_out: STRING
-- New string containing terse printable representation
-- of current object
external
"built_in"
ensure
tagged_out_not_void: Result /= Void
end
print (o: detachable ANY)
-- Write terse external representation of `o'
-- on standard output.
do
if o /= Void then
io.put_string (o.out)
end
end
feature -- Platform
Operating_environment: OPERATING_ENVIRONMENT
-- Objects available from the operating system
once
create Result
ensure
operating_environment_not_void: Result /= Void
end
feature {NONE} -- Initialization
default_create
-- Process instances of classes with no creation clause.
-- (Default: do nothing.)
do
end
feature -- Basic operations
default_rescue
-- Process exception for routines with no Rescue clause.
-- (Default: do nothing.)
do
end
frozen do_nothing
-- Execute a null action.
do
end
frozen default: detachable like Current
-- Default value of object's type
do
end
frozen default_pointer: POINTER
-- Default value of type `POINTER'
-- (Avoid the need to write `p'.`default' for
-- some `p' of type `POINTER'.)
do
ensure
-- Result = Result.default
end
frozen as_attached: attached like Current
-- Attached version of Current
-- (Can be used during transitional period to convert
-- non-void-safe classes to void-safe ones.)
do
Result := Current
end
invariant
reflexive_equality: standard_is_equal (Current)
reflexive_conformance: conforms_to (Current)
note
copyright: "Copyright (c) 1984-2012, Eiffel Software and others"
license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
source: "[
Eiffel Software
5949 Hollister Ave., Goleta, CA 93117 USA
Telephone 805-685-1006, Fax 805-685-6869
Website http://www.eiffel.com
Customer support http://support.eiffel.com
]"
end
</textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
mode: "text/x-eiffel",
indentUnit: 4,
lineNumbers: true,
theme: "neat"
});
</script>
<p><strong>MIME types defined:</strong> <code>text/x-eiffel</code>.</p>
<p> Created by <a href="https://github.com/ynh">YNH</a>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/elm/elm.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://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("elm", function() {
function switchState(source, setState, f) {
setState(f);
return f(source, setState);
}
// These should all be Unicode extended, as per the Haskell 2010 report
var smallRE = /[a-z_]/;
var largeRE = /[A-Z]/;
var digitRE = /[0-9]/;
var hexitRE = /[0-9A-Fa-f]/;
var octitRE = /[0-7]/;
var idRE = /[a-z_A-Z0-9\']/;
var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:\u03BB\u2192]/;
var specialRE = /[(),;[\]`{}]/;
var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
function normal() {
return function (source, setState) {
if (source.eatWhile(whiteCharRE)) {
return null;
}
var ch = source.next();
if (specialRE.test(ch)) {
if (ch == '{' && source.eat('-')) {
var t = "comment";
if (source.eat('#')) t = "meta";
return switchState(source, setState, ncomment(t, 1));
}
return null;
}
if (ch == '\'') {
if (source.eat('\\'))
source.next(); // should handle other escapes here
else
source.next();
if (source.eat('\''))
return "string";
return "error";
}
if (ch == '"') {
return switchState(source, setState, stringLiteral);
}
if (largeRE.test(ch)) {
source.eatWhile(idRE);
if (source.eat('.'))
return "qualifier";
return "variable-2";
}
if (smallRE.test(ch)) {
var isDef = source.pos === 1;
source.eatWhile(idRE);
return isDef ? "type" : "variable";
}
if (digitRE.test(ch)) {
if (ch == '0') {
if (source.eat(/[xX]/)) {
source.eatWhile(hexitRE); // should require at least 1
return "integer";
}
if (source.eat(/[oO]/)) {
source.eatWhile(octitRE); // should require at least 1
return "number";
}
}
source.eatWhile(digitRE);
var t = "number";
if (source.eat('.')) {
t = "number";
source.eatWhile(digitRE); // should require at least 1
}
if (source.eat(/[eE]/)) {
t = "number";
source.eat(/[-+]/);
source.eatWhile(digitRE); // should require at least 1
}
return t;
}
if (symbolRE.test(ch)) {
if (ch == '-' && source.eat(/-/)) {
source.eatWhile(/-/);
if (!source.eat(symbolRE)) {
source.skipToEnd();
return "comment";
}
}
source.eatWhile(symbolRE);
return "builtin";
}
return "error";
}
}
function ncomment(type, nest) {
if (nest == 0) {
return normal();
}
return function(source, setState) {
var currNest = nest;
while (!source.eol()) {
var ch = source.next();
if (ch == '{' && source.eat('-')) {
++currNest;
} else if (ch == '-' && source.eat('}')) {
--currNest;
if (currNest == 0) {
setState(normal());
return type;
}
}
}
setState(ncomment(type, currNest));
return type;
}
}
function stringLiteral(source, setState) {
while (!source.eol()) {
var ch = source.next();
if (ch == '"') {
setState(normal());
return "string";
}
if (ch == '\\') {
if (source.eol() || source.eat(whiteCharRE)) {
setState(stringGap);
return "string";
}
if (!source.eat('&')) source.next(); // should handle other escapes here
}
}
setState(normal());
return "error";
}
function stringGap(source, setState) {
if (source.eat('\\')) {
return switchState(source, setState, stringLiteral);
}
source.next();
setState(normal());
return "error";
}
var wellKnownWords = (function() {
var wkw = {};
var keywords = [
"case", "of", "as",
"if", "then", "else",
"let", "in",
"infix", "infixl", "infixr",
"type", "alias",
"input", "output", "foreign", "loopback",
"module", "where", "import", "exposing",
"_", "..", "|", ":", "=", "\\", "\"", "->", "<-"
];
for (var i = keywords.length; i--;)
wkw[keywords[i]] = "keyword";
return wkw;
})();
return {
startState: function () { return { f: normal() }; },
copyState: function (s) { return { f: s.f }; },
token: function(stream, state) {
var t = state.f(stream, function(s) { state.f = s; });
var w = stream.current();
return (wellKnownWords.hasOwnProperty(w)) ? wellKnownWords[w] : t;
}
};
});
CodeMirror.defineMIME("text/x-elm", "elm");
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/elm/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: Elm 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="elm.js"></script>
<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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="#">Elm</a>
</ul>
</div>
<article>
<h2>Elm mode</h2>
<div><textarea id="code" name="code">
import Color exposing (..)
import Graphics.Collage exposing (..)
import Graphics.Element exposing (..)
import Time exposing (..)
main =
Signal.map clock (every second)
clock t =
collage 400 400
[ filled lightGrey (ngon 12 110)
, outlined (solid grey) (ngon 12 110)
, hand orange 100 t
, hand charcoal 100 (t/60)
, hand charcoal 60 (t/720)
]
hand clr len time =
let angle = degrees (90 - 6 * inSeconds time)
in
segment (0,0) (fromPolar (len,angle))
|> traced (solid clr)
</textarea></div>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
lineNumbers: true,
mode: "text/x-elm"
});
</script>
<p><strong>MIME types defined:</strong> <code>text/x-elm</code>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/erlang/erlang.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
/*jshint unused:true, eqnull:true, curly:true, bitwise:true */
/*jshint undef:true, latedef:true, trailing:true */
/*global CodeMirror:true */
// erlang mode.
// tokenizer -> token types -> CodeMirror styles
// tokenizer maintains a parse stack
// indenter uses the parse stack
// TODO indenter:
// bit syntax
// old guard/bif/conversion clashes (e.g. "float/1")
// type/spec/opaque
(function(mod) {
if (typeof exports == "object" && typeof module == "object") // CommonJS
mod(require("../../lib/codemirror"));
else if (typeof define == "function" && define.amd) // AMD
define(["../../lib/codemirror"], mod);
else // Plain browser env
mod(CodeMirror);
})(function(CodeMirror) {
"use strict";
CodeMirror.defineMIME("text/x-erlang", "erlang");
CodeMirror.defineMode("erlang", function(cmCfg) {
"use strict";
/////////////////////////////////////////////////////////////////////////////
// constants
var typeWords = [
"-type", "-spec", "-export_type", "-opaque"];
var keywordWords = [
"after","begin","catch","case","cond","end","fun","if",
"let","of","query","receive","try","when"];
var separatorRE = /[\->,;]/;
var separatorWords = [
"->",";",","];
var operatorAtomWords = [
"and","andalso","band","bnot","bor","bsl","bsr","bxor",
"div","not","or","orelse","rem","xor"];
var operatorSymbolRE = /[\+\-\*\/<>=\|:!]/;
var operatorSymbolWords = [
"=","+","-","*","/",">",">=","<","=<","=:=","==","=/=","/=","||","<-","!"];
var openParenRE = /[<\(\[\{]/;
var openParenWords = [
"<<","(","[","{"];
var closeParenRE = /[>\)\]\}]/;
var closeParenWords = [
"}","]",")",">>"];
var guardWords = [
"is_atom","is_binary","is_bitstring","is_boolean","is_float",
"is_function","is_integer","is_list","is_number","is_pid",
"is_port","is_record","is_reference","is_tuple",
"atom","binary","bitstring","boolean","function","integer","list",
"number","pid","port","record","reference","tuple"];
var bifWords = [
"abs","adler32","adler32_combine","alive","apply","atom_to_binary",
"atom_to_list","binary_to_atom","binary_to_existing_atom",
"binary_to_list","binary_to_term","bit_size","bitstring_to_list",
"byte_size","check_process_code","contact_binary","crc32",
"crc32_combine","date","decode_packet","delete_module",
"disconnect_node","element","erase","exit","float","float_to_list",
"garbage_collect","get","get_keys","group_leader","halt","hd",
"integer_to_list","internal_bif","iolist_size","iolist_to_binary",
"is_alive","is_atom","is_binary","is_bitstring","is_boolean",
"is_float","is_function","is_integer","is_list","is_number","is_pid",
"is_port","is_process_alive","is_record","is_reference","is_tuple",
"length","link","list_to_atom","list_to_binary","list_to_bitstring",
"list_to_existing_atom","list_to_float","list_to_integer",
"list_to_pid","list_to_tuple","load_module","make_ref","module_loaded",
"monitor_node","node","node_link","node_unlink","nodes","notalive",
"now","open_port","pid_to_list","port_close","port_command",
"port_connect","port_control","pre_loaded","process_flag",
"process_info","processes","purge_module","put","register",
"registered","round","self","setelement","size","spawn","spawn_link",
"spawn_monitor","spawn_opt","split_binary","statistics",
"term_to_binary","time","throw","tl","trunc","tuple_size",
"tuple_to_list","unlink","unregister","whereis"];
// upper case: [A-Z] [Ø-Þ] [À-Ö]
// lower case: [a-z] [ß-ö] [ø-ÿ]
var anumRE = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/;
var escapesRE =
/[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;
/////////////////////////////////////////////////////////////////////////////
// tokenizer
function tokenizer(stream,state) {
// in multi-line string
if (state.in_string) {
state.in_string = (!doubleQuote(stream));
return rval(state,stream,"string");
}
// in multi-line atom
if (state.in_atom) {
state.in_atom = (!singleQuote(stream));
return rval(state,stream,"atom");
}
// whitespace
if (stream.eatSpace()) {
return rval(state,stream,"whitespace");
}
// attributes and type specs
if (!peekToken(state) &&
stream.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/)) {
if (is_member(stream.current(),typeWords)) {
return rval(state,stream,"type");
}else{
return rval(state,stream,"attribute");
}
}
var ch = stream.next();
// comment
if (ch == '%') {
stream.skipToEnd();
return rval(state,stream,"comment");
}
// colon
if (ch == ":") {
return rval(state,stream,"colon");
}
// macro
if (ch == '?') {
stream.eatSpace();
stream.eatWhile(anumRE);
return rval(state,stream,"macro");
}
// record
if (ch == "#") {
stream.eatSpace();
stream.eatWhile(anumRE);
return rval(state,stream,"record");
}
// dollar escape
if (ch == "$") {
if (stream.next() == "\\" && !stream.match(escapesRE)) {
return rval(state,stream,"error");
}
return rval(state,stream,"number");
}
// dot
if (ch == ".") {
return rval(state,stream,"dot");
}
// quoted atom
if (ch == '\'') {
if (!(state.in_atom = (!singleQuote(stream)))) {
if (stream.match(/\s*\/\s*[0-9]/,false)) {
stream.match(/\s*\/\s*[0-9]/,true);
return rval(state,stream,"fun"); // 'f'/0 style fun
}
if (stream.match(/\s*\(/,false) || stream.match(/\s*:/,false)) {
return rval(state,stream,"function");
}
}
return rval(state,stream,"atom");
}
// string
if (ch == '"') {
state.in_string = (!doubleQuote(stream));
return rval(state,stream,"string");
}
// variable
if (/[A-Z_Ø-ÞÀ-Ö]/.test(ch)) {
stream.eatWhile(anumRE);
return rval(state,stream,"variable");
}
// atom/keyword/BIF/function
if (/[a-z_ß-öø-ÿ]/.test(ch)) {
stream.eatWhile(anumRE);
if (stream.match(/\s*\/\s*[0-9]/,false)) {
stream.match(/\s*\/\s*[0-9]/,true);
return rval(state,stream,"fun"); // f/0 style fun
}
var w = stream.current();
if (is_member(w,keywordWords)) {
return rval(state,stream,"keyword");
}else if (is_member(w,operatorAtomWords)) {
return rval(state,stream,"operator");
}else if (stream.match(/\s*\(/,false)) {
// 'put' and 'erlang:put' are bifs, 'foo:put' is not
if (is_member(w,bifWords) &&
((peekToken(state).token != ":") ||
(peekToken(state,2).token == "erlang"))) {
return rval(state,stream,"builtin");
}else if (is_member(w,guardWords)) {
return rval(state,stream,"guard");
}else{
return rval(state,stream,"function");
}
}else if (lookahead(stream) == ":") {
if (w == "erlang") {
return rval(state,stream,"builtin");
} else {
return rval(state,stream,"function");
}
}else if (is_member(w,["true","false"])) {
return rval(state,stream,"boolean");
}else{
return rval(state,stream,"atom");
}
}
// number
var digitRE = /[0-9]/;
var radixRE = /[0-9a-zA-Z]/; // 36#zZ style int
if (digitRE.test(ch)) {
stream.eatWhile(digitRE);
if (stream.eat('#')) { // 36#aZ style integer
if (!stream.eatWhile(radixRE)) {
stream.backUp(1); //"36#" - syntax error
}
} else if (stream.eat('.')) { // float
if (!stream.eatWhile(digitRE)) {
stream.backUp(1); // "3." - probably end of function
} else {
if (stream.eat(/[eE]/)) { // float with exponent
if (stream.eat(/[-+]/)) {
if (!stream.eatWhile(digitRE)) {
stream.backUp(2); // "2e-" - syntax error
}
} else {
if (!stream.eatWhile(digitRE)) {
stream.backUp(1); // "2e" - syntax error
}
}
}
}
}
return rval(state,stream,"number"); // normal integer
}
// open parens
if (nongreedy(stream,openParenRE,openParenWords)) {
return rval(state,stream,"open_paren");
}
// close parens
if (nongreedy(stream,closeParenRE,closeParenWords)) {
return rval(state,stream,"close_paren");
}
// separators
if (greedy(stream,separatorRE,separatorWords)) {
return rval(state,stream,"separator");
}
// operators
if (greedy(stream,operatorSymbolRE,operatorSymbolWords)) {
return rval(state,stream,"operator");
}
return rval(state,stream,null);
}
/////////////////////////////////////////////////////////////////////////////
// utilities
function nongreedy(stream,re,words) {
if (stream.current().length == 1 && re.test(stream.current())) {
stream.backUp(1);
while (re.test(stream.peek())) {
stream.next();
if (is_member(stream.current(),words)) {
return true;
}
}
stream.backUp(stream.current().length-1);
}
return false;
}
function greedy(stream,re,words) {
if (stream.current().length == 1 && re.test(stream.current())) {
while (re.test(stream.peek())) {
stream.next();
}
while (0 < stream.current().length) {
if (is_member(stream.current(),words)) {
return true;
}else{
stream.backUp(1);
}
}
stream.next();
}
return false;
}
function doubleQuote(stream) {
return quote(stream, '"', '\\');
}
function singleQuote(stream) {
return quote(stream,'\'','\\');
}
function quote(stream,quoteChar,escapeChar) {
while (!stream.eol()) {
var ch = stream.next();
if (ch == quoteChar) {
return true;
}else if (ch == escapeChar) {
stream.next();
}
}
return false;
}
function lookahead(stream) {
var m = stream.match(/([\n\s]+|%[^\n]*\n)*(.)/,false);
return m ? m.pop() : "";
}
function is_member(element,list) {
return (-1 < list.indexOf(element));
}
function rval(state,stream,type) {
// parse stack
pushToken(state,realToken(type,stream));
// map erlang token type to CodeMirror style class
// erlang -> CodeMirror tag
switch (type) {
case "atom": return "atom";
case "attribute": return "attribute";
case "boolean": return "atom";
case "builtin": return "builtin";
case "close_paren": return null;
case "colon": return null;
case "comment": return "comment";
case "dot": return null;
case "error": return "error";
case "fun": return "meta";
case "function": return "tag";
case "guard": return "property";
case "keyword": return "keyword";
case "macro": return "variable-2";
case "number": return "number";
case "open_paren": return null;
case "operator": return "operator";
case "record": return "bracket";
case "separator": return null;
case "string": return "string";
case "type": return "def";
case "variable": return "variable";
default: return null;
}
}
function aToken(tok,col,ind,typ) {
return {token: tok,
column: col,
indent: ind,
type: typ};
}
function realToken(type,stream) {
return aToken(stream.current(),
stream.column(),
stream.indentation(),
type);
}
function fakeToken(type) {
return aToken(type,0,0,type);
}
function peekToken(state,depth) {
var len = state.tokenStack.length;
var dep = (depth ? depth : 1);
if (len < dep) {
return false;
}else{
return state.tokenStack[len-dep];
}
}
function pushToken(state,token) {
if (!(token.type == "comment" || token.type == "whitespace")) {
state.tokenStack = maybe_drop_pre(state.tokenStack,token);
state.tokenStack = maybe_drop_post(state.tokenStack);
}
}
function maybe_drop_pre(s,token) {
var last = s.length-1;
if (0 < last && s[last].type === "record" && token.type === "dot") {
s.pop();
}else if (0 < last && s[last].type === "group") {
s.pop();
s.push(token);
}else{
s.push(token);
}
return s;
}
function maybe_drop_post(s) {
if (!s.length) return s
var last = s.length-1;
if (s[last].type === "dot") {
return [];
}
if (last > 1 && s[last].type === "fun" && s[last-1].token === "fun") {
return s.slice(0,last-1);
}
switch (s[last].token) {
case "}": return d(s,{g:["{"]});
case "]": return d(s,{i:["["]});
case ")": return d(s,{i:["("]});
case ">>": return d(s,{i:["<<"]});
case "end": return d(s,{i:["begin","case","fun","if","receive","try"]});
case ",": return d(s,{e:["begin","try","when","->",
",","(","[","{","<<"]});
case "->": return d(s,{r:["when"],
m:["try","if","case","receive"]});
case ";": return d(s,{E:["case","fun","if","receive","try","when"]});
case "catch":return d(s,{e:["try"]});
case "of": return d(s,{e:["case"]});
case "after":return d(s,{e:["receive","try"]});
default: return s;
}
}
function d(stack,tt) {
// stack is a stack of Token objects.
// tt is an object; {type:tokens}
// type is a char, tokens is a list of token strings.
// The function returns (possibly truncated) stack.
// It will descend the stack, looking for a Token such that Token.token
// is a member of tokens. If it does not find that, it will normally (but
// see "E" below) return stack. If it does find a match, it will remove
// all the Tokens between the top and the matched Token.
// If type is "m", that is all it does.
// If type is "i", it will also remove the matched Token and the top Token.
// If type is "g", like "i", but add a fake "group" token at the top.
// If type is "r", it will remove the matched Token, but not the top Token.
// If type is "e", it will keep the matched Token but not the top Token.
// If type is "E", it behaves as for type "e", except if there is no match,
// in which case it will return an empty stack.
for (var type in tt) {
var len = stack.length-1;
var tokens = tt[type];
for (var i = len-1; -1 < i ; i--) {
if (is_member(stack[i].token,tokens)) {
var ss = stack.slice(0,i);
switch (type) {
case "m": return ss.concat(stack[i]).concat(stack[len]);
case "r": return ss.concat(stack[len]);
case "i": return ss;
case "g": return ss.concat(fakeToken("group"));
case "E": return ss.concat(stack[i]);
case "e": return ss.concat(stack[i]);
}
}
}
}
return (type == "E" ? [] : stack);
}
/////////////////////////////////////////////////////////////////////////////
// indenter
function indenter(state,textAfter) {
var t;
var unit = cmCfg.indentUnit;
var wordAfter = wordafter(textAfter);
var currT = peekToken(state,1);
var prevT = peekToken(state,2);
if (state.in_string || state.in_atom) {
return CodeMirror.Pass;
}else if (!prevT) {
return 0;
}else if (currT.token == "when") {
return currT.column+unit;
}else if (wordAfter === "when" && prevT.type === "function") {
return prevT.indent+unit;
}else if (wordAfter === "(" && currT.token === "fun") {
return currT.column+3;
}else if (wordAfter === "catch" && (t = getToken(state,["try"]))) {
return t.column;
}else if (is_member(wordAfter,["end","after","of"])) {
t = getToken(state,["begin","case","fun","if","receive","try"]);
return t ? t.column : CodeMirror.Pass;
}else if (is_member(wordAfter,closeParenWords)) {
t = getToken(state,openParenWords);
return t ? t.column : CodeMirror.Pass;
}else if (is_member(currT.token,[",","|","||"]) ||
is_member(wordAfter,[",","|","||"])) {
t = postcommaToken(state);
return t ? t.column+t.token.length : unit;
}else if (currT.token == "->") {
if (is_member(prevT.token, ["receive","case","if","try"])) {
return prevT.column+unit+unit;
}else{
return prevT.column+unit;
}
}else if (is_member(currT.token,openParenWords)) {
return currT.column+currT.token.length;
}else{
t = defaultToken(state);
return truthy(t) ? t.column+unit : 0;
}
}
function wordafter(str) {
var m = str.match(/,|[a-z]+|\}|\]|\)|>>|\|+|\(/);
return truthy(m) && (m.index === 0) ? m[0] : "";
}
function postcommaToken(state) {
var objs = state.tokenStack.slice(0,-1);
var i = getTokenIndex(objs,"type",["open_paren"]);
return truthy(objs[i]) ? objs[i] : false;
}
function defaultToken(state) {
var objs = state.tokenStack;
var stop = getTokenIndex(objs,"type",["open_paren","separator","keyword"]);
var oper = getTokenIndex(objs,"type",["operator"]);
if (truthy(stop) && truthy(oper) && stop < oper) {
return objs[stop+1];
} else if (truthy(stop)) {
return objs[stop];
} else {
return false;
}
}
function getToken(state,tokens) {
var objs = state.tokenStack;
var i = getTokenIndex(objs,"token",tokens);
return truthy(objs[i]) ? objs[i] : false;
}
function getTokenIndex(objs,propname,propvals) {
for (var i = objs.length-1; -1 < i ; i--) {
if (is_member(objs[i][propname],propvals)) {
return i;
}
}
return false;
}
function truthy(x) {
return (x !== false) && (x != null);
}
/////////////////////////////////////////////////////////////////////////////
// this object defines the mode
return {
startState:
function() {
return {tokenStack: [],
in_string: false,
in_atom: false};
},
token:
function(stream, state) {
return tokenizer(stream, state);
},
indent:
function(state, textAfter) {
return indenter(state,textAfter);
},
lineComment: "%"
};
});
});
src/main/webapp/static/plugins/codemirror/5.48.4/mode/erlang/index.html 0 → 100644
View file @ 53f587bc
<!doctype html>
<title>CodeMirror: Erlang 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/erlang-dark.css">
<script src="../../lib/codemirror.js"></script>
<script src="../../addon/edit/matchbrackets.js"></script>
<script src="erlang.js"></script>
<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
<div id=nav>
<a href="https://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="#">Erlang</a>
</ul>
</div>
<article>
<h2>Erlang mode</h2>
<form><textarea id="code" name="code">
%% -*- mode: erlang; erlang-indent-level: 2 -*-
%%% Created : 7 May 2012 by mats cronqvist <masse@klarna.com>
%% @doc
%% Demonstrates how to print a record.
%% @end
-module('ex').
-author('mats cronqvist').
-export([demo/0,
rec_info/1]).
-record(demo,{a="One",b="Two",c="Three",d="Four"}).
rec_info(demo) -> record_info(fields,demo).
demo() -> expand_recs(?MODULE,#demo{a="A",b="BB"}).
expand_recs(M,List) when is_list(List) ->
[expand_recs(M,L)||L<-List];
expand_recs(M,Tup) when is_tuple(Tup) ->
case tuple_size(Tup) of
L when L < 1 -> Tup;
L ->
try
Fields = M:rec_info(element(1,Tup)),
L = length(Fields)+1,
lists:zip(Fields,expand_recs(M,tl(tuple_to_list(Tup))))
catch
_:_ -> list_to_tuple(expand_recs(M,tuple_to_list(Tup)))
end
end;
expand_recs(_,Term) ->
Term.
</textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
lineNumbers: true,
matchBrackets: true,
extraKeys: {"Tab": "indentAuto"},
theme: "erlang-dark"
});
</script>
<p><strong>MIME types defined:</strong> <code>text/x-erlang</code>.</p>
</article>
src/main/webapp/static/plugins/codemirror/5.48.4/mode/factor/factor.js 0 → 100644
View file @ 53f587bc
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
// Factor syntax highlight - simple mode
//
// by Dimage Sapelkin (https://github.com/kerabromsmu)
(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";
CodeMirror.defineSimpleMode("factor", {
// The start state contains the rules that are intially used
start: [
// comments
{regex: /#?!.*/, token: "comment"},
// strings """, multiline --> state
{regex: /"""/, token: "string", next: "string3"},
{regex: /(STRING:)(\s)/, token: ["keyword", null], next: "string2"},
{regex: /\S*?"/, token: "string", next: "string"},
// numbers: dec, hex, unicode, bin, fractional, complex
{regex: /(?:0x[\d,a-f]+)|(?:0o[0-7]+)|(?:0b[0,1]+)|(?:\-?\d+.?\d*)(?=\s)/, token: "number"},
//{regex: /[+-]?/} //fractional
// definition: defining word, defined word, etc
{regex: /((?:GENERIC)|\:?\:)(\s+)(\S+)(\s+)(\()/, token: ["keyword", null, "def", null, "bracket"], next: "stack"},
// method definition: defining word, type, defined word, etc
{regex: /(M\:)(\s+)(\S+)(\s+)(\S+)/, token: ["keyword", null, "def", null, "tag"]},
// vocabulary using --> state
{regex: /USING\:/, token: "keyword", next: "vocabulary"},
// vocabulary definition/use
{regex: /(USE\:|IN\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "tag"]},
// definition: a defining word, defined word
{regex: /(\S+\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "def"]},
// "keywords", incl. ; t f . [ ] { } defining words
{regex: /(?:;|\\|t|f|if|loop|while|until|do|PRIVATE>|<PRIVATE|\.|\S*\[|\]|\S*\{|\})(?=\s|$)/, token: "keyword"},
// <constructors> and the like
{regex: /\S+[\)>\.\*\?]+(?=\s|$)/, token: "builtin"},
{regex: /[\)><]+\S+(?=\s|$)/, token: "builtin"},
// operators
{regex: /(?:[\+\-\=\/\*<>])(?=\s|$)/, token: "keyword"},
// any id (?)
{regex: /\S+/, token: "variable"},
{regex: /\s+|./, token: null}
],
vocabulary: [
{regex: /;/, token: "keyword", next: "start"},
{regex: /\S+/, token: "tag"},
{regex: /\s+|./, token: null}
],
string: [
{regex: /(?:[^\\]|\\.)*?"/, token: "string", next: "start"},
{regex: /.*/, token: "string"}
],
string2: [
{regex: /^;/, token: "keyword", next: "start"},
{regex: /.*/, token: "string"}
],
string3: [
{regex: /(?:[^\\]|\\.)*?"""/, token: "string", next: "start"},
{regex: /.*/, token: "string"}
],
stack: [
{regex: /\)/, token: "bracket", next: "start"},
{regex: /--/, token: "bracket"},
{regex: /\S+/, token: "meta"},
{regex: /\s+|./, token: null}
],
// The meta property contains global information about the mode. It
// can contain properties like lineComment, which are supported by
// all modes, and also directives like dontIndentStates, which are
// specific to simple modes.
meta: {
dontIndentStates: ["start", "vocabulary", "string", "string3", "stack"],
lineComment: [ "!", "#!" ]
}
});
CodeMirror.defineMIME("text/x-factor", "factor");
});
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment