codemirror-rails 0.3.0 → 0.3.1
Sign up to get free protection for your applications and to get access to all the features.
- data/lib/codemirror/rails/version.rb +2 -2
- data/vendor/assets/javascripts/codemirror.js +199 -64
- data/vendor/assets/javascripts/codemirror/modes/groovy.js +210 -0
- data/vendor/assets/javascripts/codemirror/modes/htmlmixed.js +4 -0
- data/vendor/assets/javascripts/codemirror/modes/javascript.js +1 -1
- data/vendor/assets/javascripts/codemirror/modes/lua.js +1 -1
- data/vendor/assets/javascripts/codemirror/modes/perl.js +810 -0
- data/vendor/assets/javascripts/codemirror/modes/php.js +4 -0
- data/vendor/assets/javascripts/codemirror/modes/rust.js +395 -0
- data/vendor/assets/javascripts/codemirror/modes/tiddlywiki.js +374 -0
- data/vendor/assets/javascripts/codemirror/modes/xml.js +1 -0
- data/vendor/assets/javascripts/codemirror/runmode.js +1 -1
- data/vendor/assets/stylesheets/codemirror/modes/tiddlywiki.css +21 -0
- metadata +7 -2
|
@@ -0,0 +1,210 @@
|
|
|
1
|
+
CodeMirror.defineMode("groovy", function(config, parserConfig) {
|
|
2
|
+
function words(str) {
|
|
3
|
+
var obj = {}, words = str.split(" ");
|
|
4
|
+
for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
|
|
5
|
+
return obj;
|
|
6
|
+
}
|
|
7
|
+
var keywords = words(
|
|
8
|
+
"abstract as assert boolean break byte case catch char class const continue def default " +
|
|
9
|
+
"do double else enum extends final finally float for goto if implements import in " +
|
|
10
|
+
"instanceof int interface long native new package private protected public return " +
|
|
11
|
+
"short static strictfp super switch synchronized threadsafe throw throws transient " +
|
|
12
|
+
"try void volatile while");
|
|
13
|
+
var blockKeywords = words("catch class do else finally for if switch try while enum interface def");
|
|
14
|
+
var atoms = words("null true false this");
|
|
15
|
+
|
|
16
|
+
var curPunc;
|
|
17
|
+
function tokenBase(stream, state) {
|
|
18
|
+
var ch = stream.next();
|
|
19
|
+
if (ch == '"' || ch == "'") {
|
|
20
|
+
return startString(ch, stream, state);
|
|
21
|
+
}
|
|
22
|
+
if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
|
|
23
|
+
curPunc = ch;
|
|
24
|
+
return null
|
|
25
|
+
}
|
|
26
|
+
if (/\d/.test(ch)) {
|
|
27
|
+
stream.eatWhile(/[\w\.]/);
|
|
28
|
+
if (stream.eat(/eE/)) { stream.eat(/+\-/); stream.eatWhile(/\d/); }
|
|
29
|
+
return "number";
|
|
30
|
+
}
|
|
31
|
+
if (ch == "/") {
|
|
32
|
+
if (stream.eat("*")) {
|
|
33
|
+
state.tokenize.push(tokenComment);
|
|
34
|
+
return tokenComment(stream, state);
|
|
35
|
+
}
|
|
36
|
+
if (stream.eat("/")) {
|
|
37
|
+
stream.skipToEnd();
|
|
38
|
+
return "comment";
|
|
39
|
+
}
|
|
40
|
+
if (expectExpression(state.lastToken)) {
|
|
41
|
+
return startString(ch, stream, state);
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
if (ch == "-" && stream.eat(">")) {
|
|
45
|
+
curPunc = "->";
|
|
46
|
+
return null;
|
|
47
|
+
}
|
|
48
|
+
if (/[+\-*&%=<>!?|\/~]/.test(ch)) {
|
|
49
|
+
stream.eatWhile(/[+\-*&%=<>|~]/);
|
|
50
|
+
return "operator";
|
|
51
|
+
}
|
|
52
|
+
stream.eatWhile(/[\w\$_]/);
|
|
53
|
+
if (ch == "@") return "meta";
|
|
54
|
+
if (state.lastToken == ".") return "property";
|
|
55
|
+
if (stream.eat(":")) { curPunc = "proplabel"; return "property"; }
|
|
56
|
+
var cur = stream.current();
|
|
57
|
+
if (atoms.propertyIsEnumerable(cur)) { return "atom"; }
|
|
58
|
+
if (keywords.propertyIsEnumerable(cur)) {
|
|
59
|
+
if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
|
|
60
|
+
return "keyword";
|
|
61
|
+
}
|
|
62
|
+
return "word";
|
|
63
|
+
}
|
|
64
|
+
tokenBase.isBase = true;
|
|
65
|
+
|
|
66
|
+
function startString(quote, stream, state) {
|
|
67
|
+
var tripleQuoted = false;
|
|
68
|
+
if (quote != "/" && stream.eat(quote)) {
|
|
69
|
+
if (stream.eat(quote)) tripleQuoted = true;
|
|
70
|
+
else return "string";
|
|
71
|
+
}
|
|
72
|
+
function t(stream, state) {
|
|
73
|
+
var escaped = false, next, end = !tripleQuoted;
|
|
74
|
+
while ((next = stream.next()) != null) {
|
|
75
|
+
if (next == quote && !escaped) {
|
|
76
|
+
if (!tripleQuoted) { break; }
|
|
77
|
+
if (stream.match(quote + quote)) { end = true; break; }
|
|
78
|
+
}
|
|
79
|
+
if (quote == '"' && next == "$" && !escaped && stream.eat("{")) {
|
|
80
|
+
state.tokenize.push(tokenBaseUntilBrace());
|
|
81
|
+
return "string";
|
|
82
|
+
}
|
|
83
|
+
escaped = !escaped && next == "\\";
|
|
84
|
+
}
|
|
85
|
+
if (end) state.tokenize.pop();
|
|
86
|
+
return "string";
|
|
87
|
+
}
|
|
88
|
+
state.tokenize.push(t);
|
|
89
|
+
return t(stream, state);
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
function tokenBaseUntilBrace() {
|
|
93
|
+
var depth = 1;
|
|
94
|
+
function t(stream, state) {
|
|
95
|
+
if (stream.peek() == "}") {
|
|
96
|
+
depth--;
|
|
97
|
+
if (depth == 0) {
|
|
98
|
+
state.tokenize.pop();
|
|
99
|
+
return state.tokenize[state.tokenize.length-1](stream, state);
|
|
100
|
+
}
|
|
101
|
+
} else if (stream.peek() == "{") {
|
|
102
|
+
depth++;
|
|
103
|
+
}
|
|
104
|
+
return tokenBase(stream, state);
|
|
105
|
+
}
|
|
106
|
+
t.isBase = true;
|
|
107
|
+
return t;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
function tokenComment(stream, state) {
|
|
111
|
+
var maybeEnd = false, ch;
|
|
112
|
+
while (ch = stream.next()) {
|
|
113
|
+
if (ch == "/" && maybeEnd) {
|
|
114
|
+
state.tokenize.pop();
|
|
115
|
+
break;
|
|
116
|
+
}
|
|
117
|
+
maybeEnd = (ch == "*");
|
|
118
|
+
}
|
|
119
|
+
return "comment";
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
function expectExpression(last) {
|
|
123
|
+
return !last || last == "operator" || last == "->" || /[\.\[\{\(,;:]/.test(last) ||
|
|
124
|
+
last == "newstatement" || last == "keyword" || last == "proplabel";
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
function Context(indented, column, type, align, prev) {
|
|
128
|
+
this.indented = indented;
|
|
129
|
+
this.column = column;
|
|
130
|
+
this.type = type;
|
|
131
|
+
this.align = align;
|
|
132
|
+
this.prev = prev;
|
|
133
|
+
}
|
|
134
|
+
function pushContext(state, col, type) {
|
|
135
|
+
return state.context = new Context(state.indented, col, type, null, state.context);
|
|
136
|
+
}
|
|
137
|
+
function popContext(state) {
|
|
138
|
+
var t = state.context.type;
|
|
139
|
+
if (t == ")" || t == "]" || t == "}")
|
|
140
|
+
state.indented = state.context.indented;
|
|
141
|
+
return state.context = state.context.prev;
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
// Interface
|
|
145
|
+
|
|
146
|
+
return {
|
|
147
|
+
startState: function(basecolumn) {
|
|
148
|
+
return {
|
|
149
|
+
tokenize: [tokenBase],
|
|
150
|
+
context: new Context((basecolumn || 0) - config.indentUnit, 0, "top", false),
|
|
151
|
+
indented: 0,
|
|
152
|
+
startOfLine: true,
|
|
153
|
+
lastToken: null
|
|
154
|
+
};
|
|
155
|
+
},
|
|
156
|
+
|
|
157
|
+
token: function(stream, state) {
|
|
158
|
+
var ctx = state.context;
|
|
159
|
+
if (stream.sol()) {
|
|
160
|
+
if (ctx.align == null) ctx.align = false;
|
|
161
|
+
state.indented = stream.indentation();
|
|
162
|
+
state.startOfLine = true;
|
|
163
|
+
// Automatic semicolon insertion
|
|
164
|
+
if (ctx.type == "statement" && !expectExpression(state.lastToken)) {
|
|
165
|
+
popContext(state); ctx = state.context;
|
|
166
|
+
}
|
|
167
|
+
}
|
|
168
|
+
if (stream.eatSpace()) return null;
|
|
169
|
+
curPunc = null;
|
|
170
|
+
var style = state.tokenize[state.tokenize.length-1](stream, state);
|
|
171
|
+
if (style == "comment") return style;
|
|
172
|
+
if (ctx.align == null) ctx.align = true;
|
|
173
|
+
|
|
174
|
+
if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
|
|
175
|
+
// Handle indentation for {x -> \n ... }
|
|
176
|
+
else if (curPunc == "->" && ctx.type == "statement" && ctx.prev.type == "}") {
|
|
177
|
+
popContext(state);
|
|
178
|
+
state.context.align = false;
|
|
179
|
+
}
|
|
180
|
+
else if (curPunc == "{") pushContext(state, stream.column(), "}");
|
|
181
|
+
else if (curPunc == "[") pushContext(state, stream.column(), "]");
|
|
182
|
+
else if (curPunc == "(") pushContext(state, stream.column(), ")");
|
|
183
|
+
else if (curPunc == "}") {
|
|
184
|
+
while (ctx.type == "statement") ctx = popContext(state);
|
|
185
|
+
if (ctx.type == "}") ctx = popContext(state);
|
|
186
|
+
while (ctx.type == "statement") ctx = popContext(state);
|
|
187
|
+
}
|
|
188
|
+
else if (curPunc == ctx.type) popContext(state);
|
|
189
|
+
else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
|
|
190
|
+
pushContext(state, stream.column(), "statement");
|
|
191
|
+
state.startOfLine = false;
|
|
192
|
+
state.lastToken = curPunc || style;
|
|
193
|
+
return style;
|
|
194
|
+
},
|
|
195
|
+
|
|
196
|
+
indent: function(state, textAfter) {
|
|
197
|
+
if (!state.tokenize[state.tokenize.length-1].isBase) return 0;
|
|
198
|
+
var firstChar = textAfter && textAfter.charAt(0), ctx = state.context;
|
|
199
|
+
if (ctx.type == "statement" && !expectExpression(state.lastToken)) ctx = ctx.prev;
|
|
200
|
+
var closing = firstChar == ctx.type;
|
|
201
|
+
if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : config.indentUnit);
|
|
202
|
+
else if (ctx.align) return ctx.column + (closing ? 0 : 1);
|
|
203
|
+
else return ctx.indented + (closing ? 0 : config.indentUnit);
|
|
204
|
+
},
|
|
205
|
+
|
|
206
|
+
electricChars: "{}"
|
|
207
|
+
};
|
|
208
|
+
});
|
|
209
|
+
|
|
210
|
+
CodeMirror.defineMIME("text/x-groovy", "groovy");
|
|
@@ -72,6 +72,10 @@ CodeMirror.defineMode("htmlmixed", function(config, parserConfig) {
|
|
|
72
72
|
return cssMode.indent(state.localState, textAfter);
|
|
73
73
|
},
|
|
74
74
|
|
|
75
|
+
compareStates: function(a, b) {
|
|
76
|
+
return htmlMode.compareStates(a.htmlState, b.htmlState);
|
|
77
|
+
},
|
|
78
|
+
|
|
75
79
|
electricChars: "/{}:"
|
|
76
80
|
}
|
|
77
81
|
});
|
|
@@ -54,7 +54,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
|
|
|
54
54
|
return ret("number", "number");
|
|
55
55
|
}
|
|
56
56
|
else if (/\d/.test(ch)) {
|
|
57
|
-
stream.match(/^\d*(?:\.\d*)?(?:
|
|
57
|
+
stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
|
|
58
58
|
return ret("number", "number");
|
|
59
59
|
}
|
|
60
60
|
else if (ch == "/") {
|
|
@@ -50,7 +50,7 @@ CodeMirror.defineMode("lua", function(config, parserConfig) {
|
|
|
50
50
|
"true","function", "end", "if", "then", "else", "do",
|
|
51
51
|
"while", "repeat", "until", "for", "in", "local" ]);
|
|
52
52
|
|
|
53
|
-
var indentTokens = wordRE(["function", "if","repeat","
|
|
53
|
+
var indentTokens = wordRE(["function", "if","repeat","do", "\\(", "{"]);
|
|
54
54
|
var dedentTokens = wordRE(["end", "until", "\\)", "}"]);
|
|
55
55
|
var dedentPartial = prefixRE(["end", "until", "\\)", "}", "else", "elseif"]);
|
|
56
56
|
|
|
@@ -0,0 +1,810 @@
|
|
|
1
|
+
// CodeMirror2 mode/perl/perl.js (text/x-perl) beta 0.09 (2011-10-15)
|
|
2
|
+
// This is a part of CodeMirror from https://github.com/sabaca/CodeMirror_mode_perl (mail@sabaca.com)
|
|
3
|
+
CodeMirror.defineMode("perl",function(config,parserConfig){
|
|
4
|
+
// http://perldoc.perl.org
|
|
5
|
+
var PERL={ // null - magic touch
|
|
6
|
+
// 1 - keyword
|
|
7
|
+
// 2 - def
|
|
8
|
+
// 3 - atom
|
|
9
|
+
// 4 - operator
|
|
10
|
+
// 5 - variable-2 (predefined)
|
|
11
|
+
// [x,y] - x=1,2,3; y=must be defined if x{...}
|
|
12
|
+
// PERL operators
|
|
13
|
+
'->' : 4,
|
|
14
|
+
'++' : 4,
|
|
15
|
+
'--' : 4,
|
|
16
|
+
'**' : 4,
|
|
17
|
+
// ! ~ \ and unary + and -
|
|
18
|
+
'=~' : 4,
|
|
19
|
+
'!~' : 4,
|
|
20
|
+
'*' : 4,
|
|
21
|
+
'/' : 4,
|
|
22
|
+
'%' : 4,
|
|
23
|
+
'x' : 4,
|
|
24
|
+
'+' : 4,
|
|
25
|
+
'-' : 4,
|
|
26
|
+
'.' : 4,
|
|
27
|
+
'<<' : 4,
|
|
28
|
+
'>>' : 4,
|
|
29
|
+
// named unary operators
|
|
30
|
+
'<' : 4,
|
|
31
|
+
'>' : 4,
|
|
32
|
+
'<=' : 4,
|
|
33
|
+
'>=' : 4,
|
|
34
|
+
'lt' : 4,
|
|
35
|
+
'gt' : 4,
|
|
36
|
+
'le' : 4,
|
|
37
|
+
'ge' : 4,
|
|
38
|
+
'==' : 4,
|
|
39
|
+
'!=' : 4,
|
|
40
|
+
'<=>' : 4,
|
|
41
|
+
'eq' : 4,
|
|
42
|
+
'ne' : 4,
|
|
43
|
+
'cmp' : 4,
|
|
44
|
+
'~~' : 4,
|
|
45
|
+
'&' : 4,
|
|
46
|
+
'|' : 4,
|
|
47
|
+
'^' : 4,
|
|
48
|
+
'&&' : 4,
|
|
49
|
+
'||' : 4,
|
|
50
|
+
'//' : 4,
|
|
51
|
+
'..' : 4,
|
|
52
|
+
'...' : 4,
|
|
53
|
+
'?' : 4,
|
|
54
|
+
':' : 4,
|
|
55
|
+
'=' : 4,
|
|
56
|
+
'+=' : 4,
|
|
57
|
+
'-=' : 4,
|
|
58
|
+
'*=' : 4, // etc. ???
|
|
59
|
+
',' : 4,
|
|
60
|
+
'=>' : 4,
|
|
61
|
+
'::' : 4,
|
|
62
|
+
// list operators (rightward)
|
|
63
|
+
'not' : 4,
|
|
64
|
+
'and' : 4,
|
|
65
|
+
'or' : 4,
|
|
66
|
+
'xor' : 4,
|
|
67
|
+
// PERL predefined variables (I know, what this is a paranoid idea, but may be needed for people, who learn PERL, and for me as well, ...and may be for you?;)
|
|
68
|
+
'BEGIN' : [5,1],
|
|
69
|
+
'END' : [5,1],
|
|
70
|
+
'PRINT' : [5,1],
|
|
71
|
+
'PRINTF' : [5,1],
|
|
72
|
+
'GETC' : [5,1],
|
|
73
|
+
'READ' : [5,1],
|
|
74
|
+
'READLINE' : [5,1],
|
|
75
|
+
'DESTROY' : [5,1],
|
|
76
|
+
'TIE' : [5,1],
|
|
77
|
+
'TIEHANDLE' : [5,1],
|
|
78
|
+
'UNTIE' : [5,1],
|
|
79
|
+
'STDIN' : 5,
|
|
80
|
+
'STDIN_TOP' : 5,
|
|
81
|
+
'STDOUT' : 5,
|
|
82
|
+
'STDOUT_TOP' : 5,
|
|
83
|
+
'STDERR' : 5,
|
|
84
|
+
'STDERR_TOP' : 5,
|
|
85
|
+
'$ARG' : 5,
|
|
86
|
+
'$_' : 5,
|
|
87
|
+
'@ARG' : 5,
|
|
88
|
+
'@_' : 5,
|
|
89
|
+
'$LIST_SEPARATOR' : 5,
|
|
90
|
+
'$"' : 5,
|
|
91
|
+
'$PROCESS_ID' : 5,
|
|
92
|
+
'$PID' : 5,
|
|
93
|
+
'$$' : 5,
|
|
94
|
+
'$REAL_GROUP_ID' : 5,
|
|
95
|
+
'$GID' : 5,
|
|
96
|
+
'$(' : 5,
|
|
97
|
+
'$EFFECTIVE_GROUP_ID' : 5,
|
|
98
|
+
'$EGID' : 5,
|
|
99
|
+
'$)' : 5,
|
|
100
|
+
'$PROGRAM_NAME' : 5,
|
|
101
|
+
'$0' : 5,
|
|
102
|
+
'$SUBSCRIPT_SEPARATOR' : 5,
|
|
103
|
+
'$SUBSEP' : 5,
|
|
104
|
+
'$;' : 5,
|
|
105
|
+
'$REAL_USER_ID' : 5,
|
|
106
|
+
'$UID' : 5,
|
|
107
|
+
'$<' : 5,
|
|
108
|
+
'$EFFECTIVE_USER_ID' : 5,
|
|
109
|
+
'$EUID' : 5,
|
|
110
|
+
'$>' : 5,
|
|
111
|
+
'$a' : 5,
|
|
112
|
+
'$b' : 5,
|
|
113
|
+
'$COMPILING' : 5,
|
|
114
|
+
'$^C' : 5,
|
|
115
|
+
'$DEBUGGING' : 5,
|
|
116
|
+
'$^D' : 5,
|
|
117
|
+
'${^ENCODING}' : 5,
|
|
118
|
+
'$ENV' : 5,
|
|
119
|
+
'%ENV' : 5,
|
|
120
|
+
'$SYSTEM_FD_MAX' : 5,
|
|
121
|
+
'$^F' : 5,
|
|
122
|
+
'@F' : 5,
|
|
123
|
+
'${^GLOBAL_PHASE}' : 5,
|
|
124
|
+
'$^H' : 5,
|
|
125
|
+
'%^H' : 5,
|
|
126
|
+
'@INC' : 5,
|
|
127
|
+
'%INC' : 5,
|
|
128
|
+
'$INPLACE_EDIT' : 5,
|
|
129
|
+
'$^I' : 5,
|
|
130
|
+
'$^M' : 5,
|
|
131
|
+
'$OSNAME' : 5,
|
|
132
|
+
'$^O' : 5,
|
|
133
|
+
'${^OPEN}' : 5,
|
|
134
|
+
'$PERLDB' : 5,
|
|
135
|
+
'$^P' : 5,
|
|
136
|
+
'$SIG' : 5,
|
|
137
|
+
'%SIG' : 5,
|
|
138
|
+
'$BASETIME' : 5,
|
|
139
|
+
'$^T' : 5,
|
|
140
|
+
'${^TAINT}' : 5,
|
|
141
|
+
'${^UNICODE}' : 5,
|
|
142
|
+
'${^UTF8CACHE}' : 5,
|
|
143
|
+
'${^UTF8LOCALE}' : 5,
|
|
144
|
+
'$PERL_VERSION' : 5,
|
|
145
|
+
'$^V' : 5,
|
|
146
|
+
'${^WIN32_SLOPPY_STAT}' : 5,
|
|
147
|
+
'$EXECUTABLE_NAME' : 5,
|
|
148
|
+
'$^X' : 5,
|
|
149
|
+
'$1' : 5, // - regexp $1, $2...
|
|
150
|
+
'$MATCH' : 5,
|
|
151
|
+
'$&' : 5,
|
|
152
|
+
'${^MATCH}' : 5,
|
|
153
|
+
'$PREMATCH' : 5,
|
|
154
|
+
'$`' : 5,
|
|
155
|
+
'${^PREMATCH}' : 5,
|
|
156
|
+
'$POSTMATCH' : 5,
|
|
157
|
+
"$'" : 5,
|
|
158
|
+
'${^POSTMATCH}' : 5,
|
|
159
|
+
'$LAST_PAREN_MATCH' : 5,
|
|
160
|
+
'$+' : 5,
|
|
161
|
+
'$LAST_SUBMATCH_RESULT' : 5,
|
|
162
|
+
'$^N' : 5,
|
|
163
|
+
'@LAST_MATCH_END' : 5,
|
|
164
|
+
'@+' : 5,
|
|
165
|
+
'%LAST_PAREN_MATCH' : 5,
|
|
166
|
+
'%+' : 5,
|
|
167
|
+
'@LAST_MATCH_START' : 5,
|
|
168
|
+
'@-' : 5,
|
|
169
|
+
'%LAST_MATCH_START' : 5,
|
|
170
|
+
'%-' : 5,
|
|
171
|
+
'$LAST_REGEXP_CODE_RESULT' : 5,
|
|
172
|
+
'$^R' : 5,
|
|
173
|
+
'${^RE_DEBUG_FLAGS}' : 5,
|
|
174
|
+
'${^RE_TRIE_MAXBUF}' : 5,
|
|
175
|
+
'$ARGV' : 5,
|
|
176
|
+
'@ARGV' : 5,
|
|
177
|
+
'ARGV' : 5,
|
|
178
|
+
'ARGVOUT' : 5,
|
|
179
|
+
'$OUTPUT_FIELD_SEPARATOR' : 5,
|
|
180
|
+
'$OFS' : 5,
|
|
181
|
+
'$,' : 5,
|
|
182
|
+
'$INPUT_LINE_NUMBER' : 5,
|
|
183
|
+
'$NR' : 5,
|
|
184
|
+
'$.' : 5,
|
|
185
|
+
'$INPUT_RECORD_SEPARATOR' : 5,
|
|
186
|
+
'$RS' : 5,
|
|
187
|
+
'$/' : 5,
|
|
188
|
+
'$OUTPUT_RECORD_SEPARATOR' : 5,
|
|
189
|
+
'$ORS' : 5,
|
|
190
|
+
'$\\' : 5,
|
|
191
|
+
'$OUTPUT_AUTOFLUSH' : 5,
|
|
192
|
+
'$|' : 5,
|
|
193
|
+
'$ACCUMULATOR' : 5,
|
|
194
|
+
'$^A' : 5,
|
|
195
|
+
'$FORMAT_FORMFEED' : 5,
|
|
196
|
+
'$^L' : 5,
|
|
197
|
+
'$FORMAT_PAGE_NUMBER' : 5,
|
|
198
|
+
'$%' : 5,
|
|
199
|
+
'$FORMAT_LINES_LEFT' : 5,
|
|
200
|
+
'$-' : 5,
|
|
201
|
+
'$FORMAT_LINE_BREAK_CHARACTERS' : 5,
|
|
202
|
+
'$:' : 5,
|
|
203
|
+
'$FORMAT_LINES_PER_PAGE' : 5,
|
|
204
|
+
'$=' : 5,
|
|
205
|
+
'$FORMAT_TOP_NAME' : 5,
|
|
206
|
+
'$^' : 5,
|
|
207
|
+
'$FORMAT_NAME' : 5,
|
|
208
|
+
'$~' : 5,
|
|
209
|
+
'${^CHILD_ERROR_NATIVE}' : 5,
|
|
210
|
+
'$EXTENDED_OS_ERROR' : 5,
|
|
211
|
+
'$^E' : 5,
|
|
212
|
+
'$EXCEPTIONS_BEING_CAUGHT' : 5,
|
|
213
|
+
'$^S' : 5,
|
|
214
|
+
'$WARNING' : 5,
|
|
215
|
+
'$^W' : 5,
|
|
216
|
+
'${^WARNING_BITS}' : 5,
|
|
217
|
+
'$OS_ERROR' : 5,
|
|
218
|
+
'$ERRNO' : 5,
|
|
219
|
+
'$!' : 5,
|
|
220
|
+
'%OS_ERROR' : 5,
|
|
221
|
+
'%ERRNO' : 5,
|
|
222
|
+
'%!' : 5,
|
|
223
|
+
'$CHILD_ERROR' : 5,
|
|
224
|
+
'$?' : 5,
|
|
225
|
+
'$EVAL_ERROR' : 5,
|
|
226
|
+
'$@' : 5,
|
|
227
|
+
'$OFMT' : 5,
|
|
228
|
+
'$#' : 5,
|
|
229
|
+
'$*' : 5,
|
|
230
|
+
'$ARRAY_BASE' : 5,
|
|
231
|
+
'$[' : 5,
|
|
232
|
+
'$OLD_PERL_VERSION' : 5,
|
|
233
|
+
'$]' : 5,
|
|
234
|
+
// PERL blocks
|
|
235
|
+
'if' :[1,1],
|
|
236
|
+
elsif :[1,1],
|
|
237
|
+
'else' :[1,1],
|
|
238
|
+
'while' :[1,1],
|
|
239
|
+
unless :[1,1],
|
|
240
|
+
'for' :[1,1],
|
|
241
|
+
foreach :[1,1],
|
|
242
|
+
// PERL functions
|
|
243
|
+
'abs' :1, // - absolute value function
|
|
244
|
+
accept :1, // - accept an incoming socket connect
|
|
245
|
+
alarm :1, // - schedule a SIGALRM
|
|
246
|
+
'atan2' :1, // - arctangent of Y/X in the range -PI to PI
|
|
247
|
+
bind :1, // - binds an address to a socket
|
|
248
|
+
binmode :1, // - prepare binary files for I/O
|
|
249
|
+
bless :1, // - create an object
|
|
250
|
+
bootstrap :1, //
|
|
251
|
+
'break' :1, // - break out of a "given" block
|
|
252
|
+
caller :1, // - get context of the current subroutine call
|
|
253
|
+
chdir :1, // - change your current working directory
|
|
254
|
+
chmod :1, // - changes the permissions on a list of files
|
|
255
|
+
chomp :1, // - remove a trailing record separator from a string
|
|
256
|
+
chop :1, // - remove the last character from a string
|
|
257
|
+
chown :1, // - change the owership on a list of files
|
|
258
|
+
chr :1, // - get character this number represents
|
|
259
|
+
chroot :1, // - make directory new root for path lookups
|
|
260
|
+
close :1, // - close file (or pipe or socket) handle
|
|
261
|
+
closedir :1, // - close directory handle
|
|
262
|
+
connect :1, // - connect to a remote socket
|
|
263
|
+
'continue' :[1,1], // - optional trailing block in a while or foreach
|
|
264
|
+
'cos' :1, // - cosine function
|
|
265
|
+
crypt :1, // - one-way passwd-style encryption
|
|
266
|
+
dbmclose :1, // - breaks binding on a tied dbm file
|
|
267
|
+
dbmopen :1, // - create binding on a tied dbm file
|
|
268
|
+
'default' :1, //
|
|
269
|
+
defined :1, // - test whether a value, variable, or function is defined
|
|
270
|
+
'delete' :1, // - deletes a value from a hash
|
|
271
|
+
die :1, // - raise an exception or bail out
|
|
272
|
+
'do' :1, // - turn a BLOCK into a TERM
|
|
273
|
+
dump :1, // - create an immediate core dump
|
|
274
|
+
each :1, // - retrieve the next key/value pair from a hash
|
|
275
|
+
endgrent :1, // - be done using group file
|
|
276
|
+
endhostent :1, // - be done using hosts file
|
|
277
|
+
endnetent :1, // - be done using networks file
|
|
278
|
+
endprotoent :1, // - be done using protocols file
|
|
279
|
+
endpwent :1, // - be done using passwd file
|
|
280
|
+
endservent :1, // - be done using services file
|
|
281
|
+
eof :1, // - test a filehandle for its end
|
|
282
|
+
'eval' :1, // - catch exceptions or compile and run code
|
|
283
|
+
'exec' :1, // - abandon this program to run another
|
|
284
|
+
exists :1, // - test whether a hash key is present
|
|
285
|
+
exit :1, // - terminate this program
|
|
286
|
+
'exp' :1, // - raise I to a power
|
|
287
|
+
fcntl :1, // - file control system call
|
|
288
|
+
fileno :1, // - return file descriptor from filehandle
|
|
289
|
+
flock :1, // - lock an entire file with an advisory lock
|
|
290
|
+
fork :1, // - create a new process just like this one
|
|
291
|
+
format :1, // - declare a picture format with use by the write() function
|
|
292
|
+
formline :1, // - internal function used for formats
|
|
293
|
+
getc :1, // - get the next character from the filehandle
|
|
294
|
+
getgrent :1, // - get next group record
|
|
295
|
+
getgrgid :1, // - get group record given group user ID
|
|
296
|
+
getgrnam :1, // - get group record given group name
|
|
297
|
+
gethostbyaddr :1, // - get host record given its address
|
|
298
|
+
gethostbyname :1, // - get host record given name
|
|
299
|
+
gethostent :1, // - get next hosts record
|
|
300
|
+
getlogin :1, // - return who logged in at this tty
|
|
301
|
+
getnetbyaddr :1, // - get network record given its address
|
|
302
|
+
getnetbyname :1, // - get networks record given name
|
|
303
|
+
getnetent :1, // - get next networks record
|
|
304
|
+
getpeername :1, // - find the other end of a socket connection
|
|
305
|
+
getpgrp :1, // - get process group
|
|
306
|
+
getppid :1, // - get parent process ID
|
|
307
|
+
getpriority :1, // - get current nice value
|
|
308
|
+
getprotobyname :1, // - get protocol record given name
|
|
309
|
+
getprotobynumber :1, // - get protocol record numeric protocol
|
|
310
|
+
getprotoent :1, // - get next protocols record
|
|
311
|
+
getpwent :1, // - get next passwd record
|
|
312
|
+
getpwnam :1, // - get passwd record given user login name
|
|
313
|
+
getpwuid :1, // - get passwd record given user ID
|
|
314
|
+
getservbyname :1, // - get services record given its name
|
|
315
|
+
getservbyport :1, // - get services record given numeric port
|
|
316
|
+
getservent :1, // - get next services record
|
|
317
|
+
getsockname :1, // - retrieve the sockaddr for a given socket
|
|
318
|
+
getsockopt :1, // - get socket options on a given socket
|
|
319
|
+
given :1, //
|
|
320
|
+
glob :1, // - expand filenames using wildcards
|
|
321
|
+
gmtime :1, // - convert UNIX time into record or string using Greenwich time
|
|
322
|
+
'goto' :1, // - create spaghetti code
|
|
323
|
+
grep :1, // - locate elements in a list test true against a given criterion
|
|
324
|
+
hex :1, // - convert a string to a hexadecimal number
|
|
325
|
+
'import' :1, // - patch a module's namespace into your own
|
|
326
|
+
index :1, // - find a substring within a string
|
|
327
|
+
int :1, // - get the integer portion of a number
|
|
328
|
+
ioctl :1, // - system-dependent device control system call
|
|
329
|
+
'join' :1, // - join a list into a string using a separator
|
|
330
|
+
keys :1, // - retrieve list of indices from a hash
|
|
331
|
+
kill :1, // - send a signal to a process or process group
|
|
332
|
+
last :1, // - exit a block prematurely
|
|
333
|
+
lc :1, // - return lower-case version of a string
|
|
334
|
+
lcfirst :1, // - return a string with just the next letter in lower case
|
|
335
|
+
length :1, // - return the number of bytes in a string
|
|
336
|
+
'link' :1, // - create a hard link in the filesytem
|
|
337
|
+
listen :1, // - register your socket as a server
|
|
338
|
+
local : 2, // - create a temporary value for a global variable (dynamic scoping)
|
|
339
|
+
localtime :1, // - convert UNIX time into record or string using local time
|
|
340
|
+
lock :1, // - get a thread lock on a variable, subroutine, or method
|
|
341
|
+
'log' :1, // - retrieve the natural logarithm for a number
|
|
342
|
+
lstat :1, // - stat a symbolic link
|
|
343
|
+
m :null, // - match a string with a regular expression pattern
|
|
344
|
+
map :1, // - apply a change to a list to get back a new list with the changes
|
|
345
|
+
mkdir :1, // - create a directory
|
|
346
|
+
msgctl :1, // - SysV IPC message control operations
|
|
347
|
+
msgget :1, // - get SysV IPC message queue
|
|
348
|
+
msgrcv :1, // - receive a SysV IPC message from a message queue
|
|
349
|
+
msgsnd :1, // - send a SysV IPC message to a message queue
|
|
350
|
+
my : 2, // - declare and assign a local variable (lexical scoping)
|
|
351
|
+
'new' :1, //
|
|
352
|
+
next :1, // - iterate a block prematurely
|
|
353
|
+
no :1, // - unimport some module symbols or semantics at compile time
|
|
354
|
+
oct :1, // - convert a string to an octal number
|
|
355
|
+
open :1, // - open a file, pipe, or descriptor
|
|
356
|
+
opendir :1, // - open a directory
|
|
357
|
+
ord :1, // - find a character's numeric representation
|
|
358
|
+
our : 2, // - declare and assign a package variable (lexical scoping)
|
|
359
|
+
pack :1, // - convert a list into a binary representation
|
|
360
|
+
'package' :1, // - declare a separate global namespace
|
|
361
|
+
pipe :1, // - open a pair of connected filehandles
|
|
362
|
+
pop :1, // - remove the last element from an array and return it
|
|
363
|
+
pos :1, // - find or set the offset for the last/next m//g search
|
|
364
|
+
print :1, // - output a list to a filehandle
|
|
365
|
+
printf :1, // - output a formatted list to a filehandle
|
|
366
|
+
prototype :1, // - get the prototype (if any) of a subroutine
|
|
367
|
+
push :1, // - append one or more elements to an array
|
|
368
|
+
q :null, // - singly quote a string
|
|
369
|
+
qq :null, // - doubly quote a string
|
|
370
|
+
qr :null, // - Compile pattern
|
|
371
|
+
quotemeta :null, // - quote regular expression magic characters
|
|
372
|
+
qw :null, // - quote a list of words
|
|
373
|
+
qx :null, // - backquote quote a string
|
|
374
|
+
rand :1, // - retrieve the next pseudorandom number
|
|
375
|
+
read :1, // - fixed-length buffered input from a filehandle
|
|
376
|
+
readdir :1, // - get a directory from a directory handle
|
|
377
|
+
readline :1, // - fetch a record from a file
|
|
378
|
+
readlink :1, // - determine where a symbolic link is pointing
|
|
379
|
+
readpipe :1, // - execute a system command and collect standard output
|
|
380
|
+
recv :1, // - receive a message over a Socket
|
|
381
|
+
redo :1, // - start this loop iteration over again
|
|
382
|
+
ref :1, // - find out the type of thing being referenced
|
|
383
|
+
rename :1, // - change a filename
|
|
384
|
+
require :1, // - load in external functions from a library at runtime
|
|
385
|
+
reset :1, // - clear all variables of a given name
|
|
386
|
+
'return' :1, // - get out of a function early
|
|
387
|
+
reverse :1, // - flip a string or a list
|
|
388
|
+
rewinddir :1, // - reset directory handle
|
|
389
|
+
rindex :1, // - right-to-left substring search
|
|
390
|
+
rmdir :1, // - remove a directory
|
|
391
|
+
s :null, // - replace a pattern with a string
|
|
392
|
+
say :1, // - print with newline
|
|
393
|
+
scalar :1, // - force a scalar context
|
|
394
|
+
seek :1, // - reposition file pointer for random-access I/O
|
|
395
|
+
seekdir :1, // - reposition directory pointer
|
|
396
|
+
select :1, // - reset default output or do I/O multiplexing
|
|
397
|
+
semctl :1, // - SysV semaphore control operations
|
|
398
|
+
semget :1, // - get set of SysV semaphores
|
|
399
|
+
semop :1, // - SysV semaphore operations
|
|
400
|
+
send :1, // - send a message over a socket
|
|
401
|
+
setgrent :1, // - prepare group file for use
|
|
402
|
+
sethostent :1, // - prepare hosts file for use
|
|
403
|
+
setnetent :1, // - prepare networks file for use
|
|
404
|
+
setpgrp :1, // - set the process group of a process
|
|
405
|
+
setpriority :1, // - set a process's nice value
|
|
406
|
+
setprotoent :1, // - prepare protocols file for use
|
|
407
|
+
setpwent :1, // - prepare passwd file for use
|
|
408
|
+
setservent :1, // - prepare services file for use
|
|
409
|
+
setsockopt :1, // - set some socket options
|
|
410
|
+
shift :1, // - remove the first element of an array, and return it
|
|
411
|
+
shmctl :1, // - SysV shared memory operations
|
|
412
|
+
shmget :1, // - get SysV shared memory segment identifier
|
|
413
|
+
shmread :1, // - read SysV shared memory
|
|
414
|
+
shmwrite :1, // - write SysV shared memory
|
|
415
|
+
shutdown :1, // - close down just half of a socket connection
|
|
416
|
+
'sin' :1, // - return the sine of a number
|
|
417
|
+
sleep :1, // - block for some number of seconds
|
|
418
|
+
socket :1, // - create a socket
|
|
419
|
+
socketpair :1, // - create a pair of sockets
|
|
420
|
+
'sort' :1, // - sort a list of values
|
|
421
|
+
splice :1, // - add or remove elements anywhere in an array
|
|
422
|
+
'split' :1, // - split up a string using a regexp delimiter
|
|
423
|
+
sprintf :1, // - formatted print into a string
|
|
424
|
+
'sqrt' :1, // - square root function
|
|
425
|
+
srand :1, // - seed the random number generator
|
|
426
|
+
stat :1, // - get a file's status information
|
|
427
|
+
state :1, // - declare and assign a state variable (persistent lexical scoping)
|
|
428
|
+
study :1, // - optimize input data for repeated searches
|
|
429
|
+
'sub' :1, // - declare a subroutine, possibly anonymously
|
|
430
|
+
'substr' :1, // - get or alter a portion of a stirng
|
|
431
|
+
symlink :1, // - create a symbolic link to a file
|
|
432
|
+
syscall :1, // - execute an arbitrary system call
|
|
433
|
+
sysopen :1, // - open a file, pipe, or descriptor
|
|
434
|
+
sysread :1, // - fixed-length unbuffered input from a filehandle
|
|
435
|
+
sysseek :1, // - position I/O pointer on handle used with sysread and syswrite
|
|
436
|
+
system :1, // - run a separate program
|
|
437
|
+
syswrite :1, // - fixed-length unbuffered output to a filehandle
|
|
438
|
+
tell :1, // - get current seekpointer on a filehandle
|
|
439
|
+
telldir :1, // - get current seekpointer on a directory handle
|
|
440
|
+
tie :1, // - bind a variable to an object class
|
|
441
|
+
tied :1, // - get a reference to the object underlying a tied variable
|
|
442
|
+
time :1, // - return number of seconds since 1970
|
|
443
|
+
times :1, // - return elapsed time for self and child processes
|
|
444
|
+
tr :null, // - transliterate a string
|
|
445
|
+
truncate :1, // - shorten a file
|
|
446
|
+
uc :1, // - return upper-case version of a string
|
|
447
|
+
ucfirst :1, // - return a string with just the next letter in upper case
|
|
448
|
+
umask :1, // - set file creation mode mask
|
|
449
|
+
undef :1, // - remove a variable or function definition
|
|
450
|
+
unlink :1, // - remove one link to a file
|
|
451
|
+
unpack :1, // - convert binary structure into normal perl variables
|
|
452
|
+
unshift :1, // - prepend more elements to the beginning of a list
|
|
453
|
+
untie :1, // - break a tie binding to a variable
|
|
454
|
+
use :1, // - load in a module at compile time
|
|
455
|
+
utime :1, // - set a file's last access and modify times
|
|
456
|
+
values :1, // - return a list of the values in a hash
|
|
457
|
+
vec :1, // - test or set particular bits in a string
|
|
458
|
+
wait :1, // - wait for any child process to die
|
|
459
|
+
waitpid :1, // - wait for a particular child process to die
|
|
460
|
+
wantarray :1, // - get void vs scalar vs list context of current subroutine call
|
|
461
|
+
warn :1, // - print debugging info
|
|
462
|
+
when :1, //
|
|
463
|
+
write :1, // - print a picture record
|
|
464
|
+
y :null}; // - transliterate a string
|
|
465
|
+
|
|
466
|
+
var RXstyle="string-2";
|
|
467
|
+
var RXmodifiers=/[goseximacplud]/; // NOTE: "m", "s", "y" and "tr" need to correct real modifiers for each regexp type
|
|
468
|
+
|
|
469
|
+
function tokenChain(stream,state,chain,style,tail){ // NOTE: chain.length > 2 is not working now (it's for s[...][...]geos;)
|
|
470
|
+
state.chain=null; // 12 3tail
|
|
471
|
+
state.style=null;
|
|
472
|
+
state.tail=null;
|
|
473
|
+
state.tokenize=function(stream,state){
|
|
474
|
+
var e=false,c,i=0;
|
|
475
|
+
while(c=stream.next()){
|
|
476
|
+
if(c===chain[i]&&!e){
|
|
477
|
+
if(chain[++i]!==undefined){
|
|
478
|
+
state.chain=chain[i];
|
|
479
|
+
state.style=style;
|
|
480
|
+
state.tail=tail}
|
|
481
|
+
else if(tail)
|
|
482
|
+
stream.eatWhile(tail);
|
|
483
|
+
state.tokenize=tokenPerl;
|
|
484
|
+
return style}
|
|
485
|
+
e=!e&&c=="\\"}
|
|
486
|
+
return style};
|
|
487
|
+
return state.tokenize(stream,state)}
|
|
488
|
+
|
|
489
|
+
function tokenSOMETHING(stream,state,string){
|
|
490
|
+
state.tokenize=function(stream,state){
|
|
491
|
+
if(stream.string==string)
|
|
492
|
+
state.tokenize=tokenPerl;
|
|
493
|
+
stream.skipToEnd();
|
|
494
|
+
return "string"};
|
|
495
|
+
return state.tokenize(stream,state)}
|
|
496
|
+
|
|
497
|
+
function tokenPerl(stream,state){
|
|
498
|
+
if(stream.eatSpace())
|
|
499
|
+
return null;
|
|
500
|
+
if(state.chain)
|
|
501
|
+
return tokenChain(stream,state,state.chain,state.style,state.tail);
|
|
502
|
+
if(stream.match(/^\-?[\d\.]/,false))
|
|
503
|
+
if(stream.match(/^(\-?(\d*\.\d+(e[+-]?\d+)?|\d+\.\d*)|0x[\da-fA-F]+|0b[01]+|\d+(e[+-]?\d+)?)/))
|
|
504
|
+
return 'number';
|
|
505
|
+
if(stream.match(/^<<(?=\w)/)){ // NOTE: <<SOMETHING\n...\nSOMETHING\n
|
|
506
|
+
stream.eatWhile(/\w/);
|
|
507
|
+
return tokenSOMETHING(stream,state,stream.current().substr(2))}
|
|
508
|
+
if(stream.sol()&&stream.match(/^\=item(?!\w)/)){// NOTE: \n=item...\n=cut\n
|
|
509
|
+
return tokenSOMETHING(stream,state,'=cut')}
|
|
510
|
+
var ch=stream.next();
|
|
511
|
+
if(ch=='"'||ch=="'"){ // NOTE: ' or " or <<'SOMETHING'\n...\nSOMETHING\n or <<"SOMETHING"\n...\nSOMETHING\n
|
|
512
|
+
if(stream.prefix(3)=="<<"+ch){
|
|
513
|
+
var p=stream.pos;
|
|
514
|
+
stream.eatWhile(/\w/);
|
|
515
|
+
var n=stream.current().substr(1);
|
|
516
|
+
if(n&&stream.eat(ch))
|
|
517
|
+
return tokenSOMETHING(stream,state,n);
|
|
518
|
+
stream.pos=p}
|
|
519
|
+
return tokenChain(stream,state,[ch],"string")}
|
|
520
|
+
if(ch=="q"){
|
|
521
|
+
var c=stream.look(-2);
|
|
522
|
+
if(!(c&&/\w/.test(c))){
|
|
523
|
+
c=stream.look(0);
|
|
524
|
+
if(c=="x"){
|
|
525
|
+
c=stream.look(1);
|
|
526
|
+
if(c=="("){
|
|
527
|
+
stream.eatSuffix(2);
|
|
528
|
+
return tokenChain(stream,state,[")"],RXstyle,RXmodifiers)}
|
|
529
|
+
if(c=="["){
|
|
530
|
+
stream.eatSuffix(2);
|
|
531
|
+
return tokenChain(stream,state,["]"],RXstyle,RXmodifiers)}
|
|
532
|
+
if(c=="{"){
|
|
533
|
+
stream.eatSuffix(2);
|
|
534
|
+
return tokenChain(stream,state,["}"],RXstyle,RXmodifiers)}
|
|
535
|
+
if(c=="<"){
|
|
536
|
+
stream.eatSuffix(2);
|
|
537
|
+
return tokenChain(stream,state,[">"],RXstyle,RXmodifiers)}
|
|
538
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
539
|
+
stream.eatSuffix(1);
|
|
540
|
+
return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers)}}
|
|
541
|
+
else if(c=="q"){
|
|
542
|
+
c=stream.look(1);
|
|
543
|
+
if(c=="("){
|
|
544
|
+
stream.eatSuffix(2);
|
|
545
|
+
return tokenChain(stream,state,[")"],"string")}
|
|
546
|
+
if(c=="["){
|
|
547
|
+
stream.eatSuffix(2);
|
|
548
|
+
return tokenChain(stream,state,["]"],"string")}
|
|
549
|
+
if(c=="{"){
|
|
550
|
+
stream.eatSuffix(2);
|
|
551
|
+
return tokenChain(stream,state,["}"],"string")}
|
|
552
|
+
if(c=="<"){
|
|
553
|
+
stream.eatSuffix(2);
|
|
554
|
+
return tokenChain(stream,state,[">"],"string")}
|
|
555
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
556
|
+
stream.eatSuffix(1);
|
|
557
|
+
return tokenChain(stream,state,[stream.eat(c)],"string")}}
|
|
558
|
+
else if(c=="w"){
|
|
559
|
+
c=stream.look(1);
|
|
560
|
+
if(c=="("){
|
|
561
|
+
stream.eatSuffix(2);
|
|
562
|
+
return tokenChain(stream,state,[")"],"bracket")}
|
|
563
|
+
if(c=="["){
|
|
564
|
+
stream.eatSuffix(2);
|
|
565
|
+
return tokenChain(stream,state,["]"],"bracket")}
|
|
566
|
+
if(c=="{"){
|
|
567
|
+
stream.eatSuffix(2);
|
|
568
|
+
return tokenChain(stream,state,["}"],"bracket")}
|
|
569
|
+
if(c=="<"){
|
|
570
|
+
stream.eatSuffix(2);
|
|
571
|
+
return tokenChain(stream,state,[">"],"bracket")}
|
|
572
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
573
|
+
stream.eatSuffix(1);
|
|
574
|
+
return tokenChain(stream,state,[stream.eat(c)],"bracket")}}
|
|
575
|
+
else if(c=="r"){
|
|
576
|
+
c=stream.look(1);
|
|
577
|
+
if(c=="("){
|
|
578
|
+
stream.eatSuffix(2);
|
|
579
|
+
return tokenChain(stream,state,[")"],RXstyle,RXmodifiers)}
|
|
580
|
+
if(c=="["){
|
|
581
|
+
stream.eatSuffix(2);
|
|
582
|
+
return tokenChain(stream,state,["]"],RXstyle,RXmodifiers)}
|
|
583
|
+
if(c=="{"){
|
|
584
|
+
stream.eatSuffix(2);
|
|
585
|
+
return tokenChain(stream,state,["}"],RXstyle,RXmodifiers)}
|
|
586
|
+
if(c=="<"){
|
|
587
|
+
stream.eatSuffix(2);
|
|
588
|
+
return tokenChain(stream,state,[">"],RXstyle,RXmodifiers)}
|
|
589
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
590
|
+
stream.eatSuffix(1);
|
|
591
|
+
return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers)}}
|
|
592
|
+
else if(/[\^'"!~\/(\[{<]/.test(c)){
|
|
593
|
+
if(c=="("){
|
|
594
|
+
stream.eatSuffix(1);
|
|
595
|
+
return tokenChain(stream,state,[")"],"string")}
|
|
596
|
+
if(c=="["){
|
|
597
|
+
stream.eatSuffix(1);
|
|
598
|
+
return tokenChain(stream,state,["]"],"string")}
|
|
599
|
+
if(c=="{"){
|
|
600
|
+
stream.eatSuffix(1);
|
|
601
|
+
return tokenChain(stream,state,["}"],"string")}
|
|
602
|
+
if(c=="<"){
|
|
603
|
+
stream.eatSuffix(1);
|
|
604
|
+
return tokenChain(stream,state,[">"],"string")}
|
|
605
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
606
|
+
return tokenChain(stream,state,[stream.eat(c)],"string")}}}}
|
|
607
|
+
if(ch=="m"){
|
|
608
|
+
var c=stream.look(-2);
|
|
609
|
+
if(!(c&&/\w/.test(c))){
|
|
610
|
+
c=stream.eat(/[(\[{<\^'"!~\/]/);
|
|
611
|
+
if(c){
|
|
612
|
+
if(/[\^'"!~\/]/.test(c)){
|
|
613
|
+
return tokenChain(stream,state,[c],RXstyle,RXmodifiers)}
|
|
614
|
+
if(c=="("){
|
|
615
|
+
return tokenChain(stream,state,[")"],RXstyle,RXmodifiers)}
|
|
616
|
+
if(c=="["){
|
|
617
|
+
return tokenChain(stream,state,["]"],RXstyle,RXmodifiers)}
|
|
618
|
+
if(c=="{"){
|
|
619
|
+
return tokenChain(stream,state,["}"],RXstyle,RXmodifiers)}
|
|
620
|
+
if(c=="<"){
|
|
621
|
+
return tokenChain(stream,state,[">"],RXstyle,RXmodifiers)}}}}
|
|
622
|
+
if(ch=="s"){
|
|
623
|
+
var c=/[\/>\]})\w]/.test(stream.look(-2));
|
|
624
|
+
if(!c){
|
|
625
|
+
c=stream.eat(/[(\[{<\^'"!~\/]/);
|
|
626
|
+
if(c){
|
|
627
|
+
if(c=="[")
|
|
628
|
+
return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
|
|
629
|
+
if(c=="{")
|
|
630
|
+
return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
|
|
631
|
+
if(c=="<")
|
|
632
|
+
return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
|
|
633
|
+
if(c=="(")
|
|
634
|
+
return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
|
|
635
|
+
return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers)}}}
|
|
636
|
+
if(ch=="y"){
|
|
637
|
+
var c=/[\/>\]})\w]/.test(stream.look(-2));
|
|
638
|
+
if(!c){
|
|
639
|
+
c=stream.eat(/[(\[{<\^'"!~\/]/);
|
|
640
|
+
if(c){
|
|
641
|
+
if(c=="[")
|
|
642
|
+
return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
|
|
643
|
+
if(c=="{")
|
|
644
|
+
return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
|
|
645
|
+
if(c=="<")
|
|
646
|
+
return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
|
|
647
|
+
if(c=="(")
|
|
648
|
+
return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
|
|
649
|
+
return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers)}}}
|
|
650
|
+
if(ch=="t"){
|
|
651
|
+
var c=/[\/>\]})\w]/.test(stream.look(-2));
|
|
652
|
+
if(!c){
|
|
653
|
+
c=stream.eat("r");if(c){
|
|
654
|
+
c=stream.eat(/[(\[{<\^'"!~\/]/);
|
|
655
|
+
if(c){
|
|
656
|
+
if(c=="[")
|
|
657
|
+
return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
|
|
658
|
+
if(c=="{")
|
|
659
|
+
return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
|
|
660
|
+
if(c=="<")
|
|
661
|
+
return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
|
|
662
|
+
if(c=="(")
|
|
663
|
+
return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
|
|
664
|
+
return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers)}}}}
|
|
665
|
+
if(ch=="`"){
|
|
666
|
+
return tokenChain(stream,state,[ch],"variable-2")}
|
|
667
|
+
if(ch=="/"){
|
|
668
|
+
return tokenChain(stream,state,[ch],RXstyle,RXmodifiers)}
|
|
669
|
+
if(ch=="$"){
|
|
670
|
+
var p=stream.pos;
|
|
671
|
+
if(stream.eatWhile(/\d/)||stream.eat("{")&&stream.eatWhile(/\d/)&&stream.eat("}"))
|
|
672
|
+
return "variable-2";
|
|
673
|
+
else
|
|
674
|
+
stream.pos=p}
|
|
675
|
+
if(/[$@%]/.test(ch)){
|
|
676
|
+
var p=stream.pos;
|
|
677
|
+
if(stream.eat("^")&&stream.eat(/[A-Z]/)||!/[@$%&]/.test(stream.look(-2))&&stream.eat(/[=|\\\-#?@;:&`~\^!\[\]*'"$+.,\/<>()]/)){
|
|
678
|
+
var c=stream.current();
|
|
679
|
+
if(PERL[c])
|
|
680
|
+
return "variable-2"}
|
|
681
|
+
stream.pos=p}
|
|
682
|
+
if(/[$@%&]/.test(ch)){
|
|
683
|
+
if(stream.eatWhile(/[\w$\[\]]/)||stream.eat("{")&&stream.eatWhile(/[\w$\[\]]/)&&stream.eat("}")){
|
|
684
|
+
var c=stream.current();
|
|
685
|
+
if(PERL[c])
|
|
686
|
+
return "variable-2";
|
|
687
|
+
else
|
|
688
|
+
return "variable"}}
|
|
689
|
+
if(ch=="#"){
|
|
690
|
+
if(stream.look(-2)!="$"){
|
|
691
|
+
stream.skipToEnd();
|
|
692
|
+
return "comment"}}
|
|
693
|
+
if(/[:+\-\^*$&%@=<>!?|\/~\.]/.test(ch)){
|
|
694
|
+
var p=stream.pos;
|
|
695
|
+
stream.eatWhile(/[:+\-\^*$&%@=<>!?|\/~\.]/);
|
|
696
|
+
if(PERL[stream.current()])
|
|
697
|
+
return "operator";
|
|
698
|
+
else
|
|
699
|
+
stream.pos=p}
|
|
700
|
+
if(ch=="_"){
|
|
701
|
+
if(stream.pos==1){
|
|
702
|
+
if(stream.suffix(6)=="_END__"){
|
|
703
|
+
return tokenChain(stream,state,['\0'],"comment")}
|
|
704
|
+
else if(stream.suffix(7)=="_DATA__"){
|
|
705
|
+
return tokenChain(stream,state,['\0'],"variable-2")}
|
|
706
|
+
else if(stream.suffix(7)=="_C__"){
|
|
707
|
+
return tokenChain(stream,state,['\0'],"string")}}}
|
|
708
|
+
if(/\w/.test(ch)){
|
|
709
|
+
var p=stream.pos;
|
|
710
|
+
if(stream.look(-2)=="{"&&(stream.look(0)=="}"||stream.eatWhile(/\w/)&&stream.look(0)=="}"))
|
|
711
|
+
return "string";
|
|
712
|
+
else
|
|
713
|
+
stream.pos=p}
|
|
714
|
+
if(/[A-Z]/.test(ch)){
|
|
715
|
+
var l=stream.look(-2);
|
|
716
|
+
var p=stream.pos;
|
|
717
|
+
stream.eatWhile(/[A-Z_]/);
|
|
718
|
+
if(/[\da-z]/.test(stream.look(0))){
|
|
719
|
+
stream.pos=p}
|
|
720
|
+
else{
|
|
721
|
+
var c=PERL[stream.current()];
|
|
722
|
+
if(!c)
|
|
723
|
+
return "meta";
|
|
724
|
+
if(c[1])
|
|
725
|
+
c=c[0];
|
|
726
|
+
if(l!=":"){
|
|
727
|
+
if(c==1)
|
|
728
|
+
return "keyword";
|
|
729
|
+
else if(c==2)
|
|
730
|
+
return "def";
|
|
731
|
+
else if(c==3)
|
|
732
|
+
return "atom";
|
|
733
|
+
else if(c==4)
|
|
734
|
+
return "operator";
|
|
735
|
+
else if(c==5)
|
|
736
|
+
return "variable-2";
|
|
737
|
+
else
|
|
738
|
+
return "meta"}
|
|
739
|
+
else
|
|
740
|
+
return "meta"}}
|
|
741
|
+
if(/[a-zA-Z_]/.test(ch)){
|
|
742
|
+
var l=stream.look(-2);
|
|
743
|
+
stream.eatWhile(/\w/);
|
|
744
|
+
var c=PERL[stream.current()];
|
|
745
|
+
if(!c)
|
|
746
|
+
return "meta";
|
|
747
|
+
if(c[1])
|
|
748
|
+
c=c[0];
|
|
749
|
+
if(l!=":"){
|
|
750
|
+
if(c==1)
|
|
751
|
+
return "keyword";
|
|
752
|
+
else if(c==2)
|
|
753
|
+
return "def";
|
|
754
|
+
else if(c==3)
|
|
755
|
+
return "atom";
|
|
756
|
+
else if(c==4)
|
|
757
|
+
return "operator";
|
|
758
|
+
else if(c==5)
|
|
759
|
+
return "variable-2";
|
|
760
|
+
else
|
|
761
|
+
return "meta"}
|
|
762
|
+
else
|
|
763
|
+
return "meta"}
|
|
764
|
+
return null}
|
|
765
|
+
|
|
766
|
+
return{
|
|
767
|
+
startState:function(){
|
|
768
|
+
return{
|
|
769
|
+
tokenize:tokenPerl,
|
|
770
|
+
chain:null,
|
|
771
|
+
style:null,
|
|
772
|
+
tail:null}},
|
|
773
|
+
token:function(stream,state){
|
|
774
|
+
return (state.tokenize||tokenPerl)(stream,state)},
|
|
775
|
+
electricChars:"{}"}});
|
|
776
|
+
|
|
777
|
+
CodeMirror.defineMIME("text/x-perl", "perl");
|
|
778
|
+
|
|
779
|
+
// it's like "peek", but need for look-ahead or look-behind if index < 0
|
|
780
|
+
CodeMirror.StringStream.prototype.look=function(c){
|
|
781
|
+
return this.string.charAt(this.pos+(c||0))};
|
|
782
|
+
|
|
783
|
+
// return a part of prefix of current stream from current position
|
|
784
|
+
CodeMirror.StringStream.prototype.prefix=function(c){
|
|
785
|
+
var x=this.pos-c;
|
|
786
|
+
return this.string.substr((x>=0?x:0),c)};
|
|
787
|
+
|
|
788
|
+
// return a part of suffix of current stream from current position
|
|
789
|
+
CodeMirror.StringStream.prototype.suffix=function(c){
|
|
790
|
+
var y=this.string.length;
|
|
791
|
+
var x=y-this.pos+1;
|
|
792
|
+
return this.string.substr(this.pos,(c&&c<y?c:x))};
|
|
793
|
+
|
|
794
|
+
// return a part of suffix of current stream from current position and change current position
|
|
795
|
+
CodeMirror.StringStream.prototype.nsuffix=function(c){
|
|
796
|
+
var p=this.pos;
|
|
797
|
+
var l=c||(this.string.length-this.pos+1);
|
|
798
|
+
this.pos+=l;
|
|
799
|
+
return this.string.substr(p,l)};
|
|
800
|
+
|
|
801
|
+
// eating and vomiting a part of stream from current position
|
|
802
|
+
CodeMirror.StringStream.prototype.eatSuffix=function(c){
|
|
803
|
+
var x=this.pos+c;
|
|
804
|
+
var y;
|
|
805
|
+
if(x<=0)
|
|
806
|
+
this.pos=0;
|
|
807
|
+
else if(x>=(y=this.string.length-1))
|
|
808
|
+
this.pos=y;
|
|
809
|
+
else
|
|
810
|
+
this.pos=x};
|