15c0fd1196185075ae30abb57e713be87f4332cb
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
2 // Distributed under an MIT license: https://codemirror.net/LICENSE
5 if (typeof exports
== "object" && typeof module
== "object") // CommonJS
6 mod(require("../../lib/codemirror"));
7 else if (typeof define
== "function" && define
.amd
) // AMD
8 define(["../../lib/codemirror"], mod
);
9 else // Plain browser env
11 })(function(CodeMirror
) {
14 function Context(indented
, column
, type
, info
, align
, prev
) {
15 this.indented
= indented
;
22 function pushContext(state
, col
, type
, info
) {
23 var indent
= state
.indented
;
24 if (state
.context
&& state
.context
.type
== "statement" && type
!= "statement")
25 indent
= state
.context
.indented
;
26 return state
.context
= new Context(indent
, col
, type
, info
, null, state
.context
);
28 function popContext(state
) {
29 var t
= state
.context
.type
;
30 if (t
== ")" || t
== "]" || t
== "}")
31 state
.indented
= state
.context
.indented
;
32 return state
.context
= state
.context
.prev
;
35 function typeBefore(stream
, state
, pos
) {
36 if (state
.prevToken
== "variable" || state
.prevToken
== "type") return true;
37 if (/\S(?:[^- ]>|[*\]])\s*$|\*$/.test(stream
.string
.slice(0, pos
))) return true;
38 if (state
.typeAtEndOfLine
&& stream
.column() == stream
.indentation()) return true;
41 function isTopScope(context
) {
43 if (!context
|| context
.type
== "top") return true;
44 if (context
.type
== "}" && context
.prev
.info
!= "namespace") return false;
45 context
= context
.prev
;
49 CodeMirror
.defineMode("clike", function(config
, parserConfig
) {
50 var indentUnit
= config
.indentUnit
,
51 statementIndentUnit
= parserConfig
.statementIndentUnit
|| indentUnit
,
52 dontAlignCalls
= parserConfig
.dontAlignCalls
,
53 keywords
= parserConfig
.keywords
|| {},
54 types
= parserConfig
.types
|| {},
55 builtin
= parserConfig
.builtin
|| {},
56 blockKeywords
= parserConfig
.blockKeywords
|| {},
57 defKeywords
= parserConfig
.defKeywords
|| {},
58 atoms
= parserConfig
.atoms
|| {},
59 hooks
= parserConfig
.hooks
|| {},
60 multiLineStrings
= parserConfig
.multiLineStrings
,
61 indentStatements
= parserConfig
.indentStatements
!== false,
62 indentSwitch
= parserConfig
.indentSwitch
!== false,
63 namespaceSeparator
= parserConfig
.namespaceSeparator
,
64 isPunctuationChar
= parserConfig
.isPunctuationChar
|| /[\[\]{}\(\),;\:\.]/,
65 numberStart
= parserConfig
.numberStart
|| /[\d\.]/,
66 number
= parserConfig
.number
|| /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i,
67 isOperatorChar
= parserConfig
.isOperatorChar
|| /[+\-*&%=<>!?|\/]/,
68 isIdentifierChar
= parserConfig
.isIdentifierChar
|| /[\w\$_\xa1-\uffff]/,
69 // An optional function that takes a {string} token and returns true if it
70 // should be treated as a builtin.
71 isReservedIdentifier
= parserConfig
.isReservedIdentifier
|| false;
73 var curPunc
, isDefKeyword
;
75 function tokenBase(stream
, state
) {
76 var ch
= stream
.next();
78 var result
= hooks
[ch
](stream
, state
);
79 if (result
!== false) return result
;
81 if (ch
== '"' || ch
== "'") {
82 state
.tokenize
= tokenString(ch
);
83 return state
.tokenize(stream
, state
);
85 if (numberStart
.test(ch
)) {
87 if (stream
.match(number
)) return "number"
90 if (isPunctuationChar
.test(ch
)) {
95 if (stream
.eat("*")) {
96 state
.tokenize
= tokenComment
;
97 return tokenComment(stream
, state
);
99 if (stream
.eat("/")) {
104 if (isOperatorChar
.test(ch
)) {
105 while (!stream
.match(/^\/[\/*]/, false) && stream
.eat(isOperatorChar
)) {}
108 stream
.eatWhile(isIdentifierChar
);
109 if (namespaceSeparator
) while (stream
.match(namespaceSeparator
))
110 stream
.eatWhile(isIdentifierChar
);
112 var cur
= stream
.current();
113 if (contains(keywords
, cur
)) {
114 if (contains(blockKeywords
, cur
)) curPunc
= "newstatement";
115 if (contains(defKeywords
, cur
)) isDefKeyword
= true;
118 if (contains(types
, cur
)) return "type";
119 if (contains(builtin
, cur
)
120 || (isReservedIdentifier
&& isReservedIdentifier(cur
))) {
121 if (contains(blockKeywords
, cur
)) curPunc
= "newstatement";
124 if (contains(atoms
, cur
)) return "atom";
128 function tokenString(quote
) {
129 return function(stream
, state
) {
130 var escaped
= false, next
, end
= false;
131 while ((next
= stream
.next()) != null) {
132 if (next
== quote
&& !escaped
) {end
= true; break;}
133 escaped
= !escaped
&& next
== "\\";
135 if (end
|| !(escaped
|| multiLineStrings
))
136 state
.tokenize
= null;
141 function tokenComment(stream
, state
) {
142 var maybeEnd
= false, ch
;
143 while (ch
= stream
.next()) {
144 if (ch
== "/" && maybeEnd
) {
145 state
.tokenize
= null;
148 maybeEnd
= (ch
== "*");
153 function maybeEOL(stream
, state
) {
154 if (parserConfig
.typeFirstDefinitions
&& stream
.eol() && isTopScope(state
.context
))
155 state
.typeAtEndOfLine
= typeBefore(stream
, state
, stream
.pos
)
161 startState: function(basecolumn
) {
164 context
: new Context((basecolumn
|| 0) - indentUnit
, 0, "top", null, false),
171 token: function(stream
, state
) {
172 var ctx
= state
.context
;
174 if (ctx
.align
== null) ctx
.align
= false;
175 state
.indented
= stream
.indentation();
176 state
.startOfLine
= true;
178 if (stream
.eatSpace()) { maybeEOL(stream
, state
); return null; }
179 curPunc
= isDefKeyword
= null;
180 var style
= (state
.tokenize
|| tokenBase
)(stream
, state
);
181 if (style
== "comment" || style
== "meta") return style
;
182 if (ctx
.align
== null) ctx
.align
= true;
184 if (curPunc
== ";" || curPunc
== ":" || (curPunc
== "," && stream
.match(/^\s*(?:\/\/.*)?$/, false)))
185 while (state
.context
.type
== "statement") popContext(state
);
186 else if (curPunc
== "{") pushContext(state
, stream
.column(), "}");
187 else if (curPunc
== "[") pushContext(state
, stream
.column(), "]");
188 else if (curPunc
== "(") pushContext(state
, stream
.column(), ")");
189 else if (curPunc
== "}") {
190 while (ctx
.type
== "statement") ctx
= popContext(state
);
191 if (ctx
.type
== "}") ctx
= popContext(state
);
192 while (ctx
.type
== "statement") ctx
= popContext(state
);
194 else if (curPunc
== ctx
.type
) popContext(state
);
195 else if (indentStatements
&&
196 (((ctx
.type
== "}" || ctx
.type
== "top") && curPunc
!= ";") ||
197 (ctx
.type
== "statement" && curPunc
== "newstatement"))) {
198 pushContext(state
, stream
.column(), "statement", stream
.current());
201 if (style
== "variable" &&
202 ((state
.prevToken
== "def" ||
203 (parserConfig
.typeFirstDefinitions
&& typeBefore(stream
, state
, stream
.start
) &&
204 isTopScope(state
.context
) && stream
.match(/^\s*\(/, false)))))
208 var result
= hooks
.token(stream
, state
, style
);
209 if (result
!== undefined) style
= result
;
212 if (style
== "def" && parserConfig
.styleDefs
=== false) style
= "variable";
214 state
.startOfLine
= false;
215 state
.prevToken
= isDefKeyword
? "def" : style
|| curPunc
;
216 maybeEOL(stream
, state
);
220 indent: function(state
, textAfter
) {
221 if (state
.tokenize
!= tokenBase
&& state
.tokenize
!= null || state
.typeAtEndOfLine
) return CodeMirror
.Pass
;
222 var ctx
= state
.context
, firstChar
= textAfter
&& textAfter
.charAt(0);
223 var closing
= firstChar
== ctx
.type
;
224 if (ctx
.type
== "statement" && firstChar
== "}") ctx
= ctx
.prev
;
225 if (parserConfig
.dontIndentStatements
)
226 while (ctx
.type
== "statement" && parserConfig
.dontIndentStatements
.test(ctx
.info
))
229 var hook
= hooks
.indent(state
, ctx
, textAfter
, indentUnit
);
230 if (typeof hook
== "number") return hook
232 var switchBlock
= ctx
.prev
&& ctx
.prev
.info
== "switch";
233 if (parserConfig
.allmanIndentation
&& /[{(]/.test(firstChar
)) {
234 while (ctx
.type
!= "top" && ctx
.type
!= "}") ctx
= ctx
.prev
237 if (ctx
.type
== "statement")
238 return ctx
.indented
+ (firstChar
== "{" ? 0 : statementIndentUnit
);
239 if (ctx
.align
&& (!dontAlignCalls
|| ctx
.type
!= ")"))
240 return ctx
.column
+ (closing
? 0 : 1);
241 if (ctx
.type
== ")" && !closing
)
242 return ctx
.indented
+ statementIndentUnit
;
244 return ctx
.indented
+ (closing
? 0 : indentUnit
) +
245 (!closing
&& switchBlock
&& !/^(?:case|default)\b/.test(textAfter
) ? indentUnit
: 0);
248 electricInput
: indentSwitch
? /^\s*(?:case .*?:|default:|\{\}?|\})$/ : /^\s*[{}]$/,
249 blockCommentStart
: "/*",
250 blockCommentEnd
: "*/",
251 blockCommentContinue
: " * ",
257 function words(str
) {
258 var obj
= {}, words
= str
.split(" ");
259 for (var i
= 0; i
< words
.length
; ++i
) obj
[words
[i
]] = true;
262 function contains(words
, word
) {
263 if (typeof words
=== "function") {
266 return words
.propertyIsEnumerable(word
);
269 var cKeywords
= "auto if break case register continue return default do sizeof " +
270 "static else struct switch extern typedef union for goto while enum const " +
271 "volatile inline restrict asm fortran";
273 // Keywords from https://en.cppreference.com/w/cpp/keyword includes C++20.
274 var cppKeywords
= "alignas alignof and and_eq audit axiom bitand bitor catch " +
275 "class compl concept constexpr const_cast decltype delete dynamic_cast " +
276 "explicit export final friend import module mutable namespace new noexcept " +
277 "not not_eq operator or or_eq override private protected public " +
278 "reinterpret_cast requires static_assert static_cast template this " +
279 "thread_local throw try typeid typename using virtual xor xor_eq";
281 var objCKeywords
= "bycopy byref in inout oneway out self super atomic nonatomic retain copy " +
282 "readwrite readonly strong weak assign typeof nullable nonnull null_resettable _cmd " +
283 "@interface @implementation @end @protocol @encode @property @synthesize @dynamic @class " +
284 "@public @package @private @protected @required @optional @try @catch @finally @import " +
285 "@selector @encode @defs @synchronized @autoreleasepool @compatibility_alias @available";
287 var objCBuiltins
= "FOUNDATION_EXPORT FOUNDATION_EXTERN NS_INLINE NS_FORMAT_FUNCTION " +
288 " NS_RETURNS_RETAINEDNS_ERROR_ENUM NS_RETURNS_NOT_RETAINED NS_RETURNS_INNER_POINTER " +
289 "NS_DESIGNATED_INITIALIZER NS_ENUM NS_OPTIONS NS_REQUIRES_NIL_TERMINATION " +
290 "NS_ASSUME_NONNULL_BEGIN NS_ASSUME_NONNULL_END NS_SWIFT_NAME NS_REFINED_FOR_SWIFT"
292 // Do not use this. Use the cTypes function below. This is global just to avoid
293 // excessive calls when cTypes is being called multiple times during a parse.
294 var basicCTypes
= words("int long char short double float unsigned signed " +
297 // Do not use this. Use the objCTypes function below. This is global just to avoid
298 // excessive calls when objCTypes is being called multiple times during a parse.
299 var basicObjCTypes
= words("SEL instancetype id Class Protocol BOOL");
301 // Returns true if identifier is a "C" type.
302 // C type is defined as those that are reserved by the compiler (basicTypes),
303 // and those that end in _t (Reserved by POSIX for types)
304 // http://www.gnu.org/software/libc/manual/html_node/Reserved-Names.html
305 function cTypes(identifier
) {
306 return contains(basicCTypes
, identifier
) || /.+_t$/.test(identifier
);
309 // Returns true if identifier is a "Objective C" type.
310 function objCTypes(identifier
) {
311 return cTypes(identifier
) || contains(basicObjCTypes
, identifier
);
314 var cBlockKeywords
= "case do else for if switch while struct enum union";
315 var cDefKeywords
= "struct enum union";
317 function cppHook(stream
, state
) {
318 if (!state
.startOfLine
) return false
319 for (var ch
, next
= null; ch
= stream
.peek();) {
320 if (ch
== "\\" && stream
.match(/^.$/)) {
323 } else if (ch
== "/" && stream
.match(/^\/[\/\*]/, false)) {
328 state
.tokenize
= next
332 function pointerHook(_stream
, state
) {
333 if (state
.prevToken
== "type") return "type";
337 // For C and C++ (and ObjC): identifiers starting with __
338 // or _ followed by a capital letter are reserved for the compiler.
339 function cIsReservedIdentifier(token
) {
340 if (!token
|| token
.length
< 2) return false;
341 if (token
[0] != '_') return false;
342 return (token
[1] == '_') || (token
[1] !== token
[1].toLowerCase());
345 function cpp14Literal(stream
) {
346 stream
.eatWhile(/[\w\.']/);
350 function cpp11StringHook(stream
, state
) {
353 if (stream
.match(/^(?:R|u8R|uR|UR|LR)/)) {
354 var match
= stream
.match(/^"([^\s\\()]{0,16})\(/);
358 state
.cpp11RawStringDelim
= match
[1];
359 state
.tokenize
= tokenRawString
;
360 return tokenRawString(stream
, state
);
362 // Unicode strings/chars.
363 if (stream
.match(/^(?:u8|u|U|L)/)) {
364 if (stream
.match(/^["']/, /* eat */ false)) {
374 function cppLooksLikeConstructor(word
) {
375 var lastTwo
= /(\w+)::~?(\w+)$/.exec(word
);
376 return lastTwo
&& lastTwo
[1] == lastTwo
[2];
379 // C#-style strings where "" escapes a quote.
380 function tokenAtString(stream
, state
) {
382 while ((next
= stream
.next()) != null) {
383 if (next
== '"' && !stream
.eat('"')) {
384 state
.tokenize
= null;
391 // C++11 raw string literal is <prefix>"<delim>( anything )<delim>", where
392 // <delim> can be a string up to 16 characters long.
393 function tokenRawString(stream
, state
) {
394 // Escape characters that have special regex meanings.
395 var delim
= state
.cpp11RawStringDelim
.replace(/[^\w\s]/g, '\\$&');
396 var match
= stream
.match(new RegExp(".*?\\)" + delim
+ '"'));
398 state
.tokenize
= null;
404 function def(mimes
, mode
) {
405 if (typeof mimes
== "string") mimes
= [mimes
];
408 if (obj
) for (var prop
in obj
) if (obj
.hasOwnProperty(prop
))
416 mode
.helperType
= mimes
[0];
417 CodeMirror
.registerHelper("hintWords", mimes
[0], words
);
420 for (var i
= 0; i
< mimes
.length
; ++i
)
421 CodeMirror
.defineMIME(mimes
[i
], mode
);
424 def(["text/x-csrc", "text/x-c", "text/x-chdr"], {
426 keywords
: words(cKeywords
),
428 blockKeywords
: words(cBlockKeywords
),
429 defKeywords
: words(cDefKeywords
),
430 typeFirstDefinitions
: true,
431 atoms
: words("NULL true false"),
432 isReservedIdentifier
: cIsReservedIdentifier
,
437 modeProps
: {fold
: ["brace", "include"]}
440 def(["text/x-c++src", "text/x-c++hdr"], {
442 keywords
: words(cKeywords
+ " " + cppKeywords
),
444 blockKeywords
: words(cBlockKeywords
+ " class try catch"),
445 defKeywords
: words(cDefKeywords
+ " class namespace"),
446 typeFirstDefinitions
: true,
447 atoms
: words("true false NULL nullptr"),
448 dontIndentStatements
: /^template$/,
449 isIdentifierChar
: /[\w\$_~\xa1-\uffff]/,
450 isReservedIdentifier
: cIsReservedIdentifier
,
454 "u": cpp11StringHook
,
455 "U": cpp11StringHook
,
456 "L": cpp11StringHook
,
457 "R": cpp11StringHook
,
468 token: function(stream
, state
, style
) {
469 if (style
== "variable" && stream
.peek() == "(" &&
470 (state
.prevToken
== ";" || state
.prevToken
== null ||
471 state
.prevToken
== "}") &&
472 cppLooksLikeConstructor(stream
.current()))
476 namespaceSeparator
: "::",
477 modeProps
: {fold
: ["brace", "include"]}
482 keywords
: words("abstract assert break case catch class const continue default " +
483 "do else enum extends final finally for goto if implements import " +
484 "instanceof interface native new package private protected public " +
485 "return static strictfp super switch synchronized this throw throws transient " +
486 "try volatile while @interface"),
487 types
: words("byte short int long float double boolean char void Boolean Byte Character Double Float " +
488 "Integer Long Number Object Short String StringBuffer StringBuilder Void"),
489 blockKeywords
: words("catch class do else finally for if switch try while"),
490 defKeywords
: words("class interface enum @interface"),
491 typeFirstDefinitions
: true,
492 atoms
: words("true false null"),
493 number
: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
495 "@": function(stream
) {
496 // Don't match the @interface keyword.
497 if (stream
.match('interface', false)) return false;
499 stream
.eatWhile(/[\w\$_]/);
503 modeProps
: {fold
: ["brace", "import"]}
506 def("text/x-csharp", {
508 keywords
: words("abstract as async await base break case catch checked class const continue" +
509 " default delegate do else enum event explicit extern finally fixed for" +
510 " foreach goto if implicit in interface internal is lock namespace new" +
511 " operator out override params private protected public readonly ref return sealed" +
512 " sizeof stackalloc static struct switch this throw try typeof unchecked" +
513 " unsafe using virtual void volatile while add alias ascending descending dynamic from get" +
514 " global group into join let orderby partial remove select set value var yield"),
515 types
: words("Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func" +
516 " Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32" +
517 " UInt64 bool byte char decimal double short int long object" +
518 " sbyte float string ushort uint ulong"),
519 blockKeywords
: words("catch class do else finally for foreach if struct switch try while"),
520 defKeywords
: words("class interface namespace struct var"),
521 typeFirstDefinitions
: true,
522 atoms
: words("true false null"),
524 "@": function(stream
, state
) {
525 if (stream
.eat('"')) {
526 state
.tokenize
= tokenAtString
;
527 return tokenAtString(stream
, state
);
529 stream
.eatWhile(/[\w\$_]/);
535 function tokenTripleString(stream
, state
) {
537 while (!stream
.eol()) {
538 if (!escaped
&& stream
.match('"""')) {
539 state
.tokenize
= null;
542 escaped
= stream
.next() == "\\" && !escaped
;
547 function tokenNestedComment(depth
) {
548 return function (stream
, state
) {
550 while (ch
= stream
.next()) {
551 if (ch
== "*" && stream
.eat("/")) {
553 state
.tokenize
= null
556 state
.tokenize
= tokenNestedComment(depth
- 1)
557 return state
.tokenize(stream
, state
)
559 } else if (ch
== "/" && stream
.eat("*")) {
560 state
.tokenize
= tokenNestedComment(depth
+ 1)
561 return state
.tokenize(stream
, state
)
568 def("text/x-scala", {
572 "abstract case catch class def do else extends final finally for forSome if " +
573 "implicit import lazy match new null object override package private protected return " +
574 "sealed super this throw trait try type val var while with yield _ " +
577 "assert assume require print println printf readLine readBoolean readByte readShort " +
578 "readChar readInt readLong readFloat readDouble"
581 "AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either " +
582 "Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable " +
583 "Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering " +
584 "Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder " +
585 "StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector " +
587 /* package java.lang */
588 "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
589 "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
590 "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
591 "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void"
593 multiLineStrings
: true,
594 blockKeywords
: words("catch class enum do else finally for forSome if match switch try while"),
595 defKeywords
: words("class enum def object package trait type val var"),
596 atoms
: words("true false null"),
597 indentStatements
: false,
599 isOperatorChar
: /[+\-*&%=<>!?|\/#:@]/,
601 "@": function(stream
) {
602 stream
.eatWhile(/[\w\$_]/);
605 '"': function(stream
, state
) {
606 if (!stream
.match('""')) return false;
607 state
.tokenize
= tokenTripleString
;
608 return state
.tokenize(stream
, state
);
610 "'": function(stream
) {
611 stream
.eatWhile(/[\w\$_\xa1-\uffff]/);
614 "=": function(stream
, state
) {
615 var cx
= state
.context
616 if (cx
.type
== "}" && cx
.align
&& stream
.eat(">")) {
617 state
.context
= new Context(cx
.indented
, cx
.column
, cx
.type
, cx
.info
, null, cx
.prev
)
624 "/": function(stream
, state
) {
625 if (!stream
.eat("*")) return false
626 state
.tokenize
= tokenNestedComment(1)
627 return state
.tokenize(stream
, state
)
630 modeProps
: {closeBrackets
: {pairs
: '()[]{}""', triples
: '"'}}
633 function tokenKotlinString(tripleString
){
634 return function (stream
, state
) {
635 var escaped
= false, next
, end
= false;
636 while (!stream
.eol()) {
637 if (!tripleString
&& !escaped
&& stream
.match('"') ) {end
= true; break;}
638 if (tripleString
&& stream
.match('"""')) {end
= true; break;}
639 next
= stream
.next();
640 if(!escaped
&& next
== "$" && stream
.match('{'))
642 escaped
= !escaped
&& next
== "\\" && !tripleString
;
644 if (end
|| !tripleString
)
645 state
.tokenize
= null;
650 def("text/x-kotlin", {
654 "package as typealias class interface this super val operator " +
655 "var fun for is in This throw return annotation " +
656 "break continue object if else while do try when !in !is as? " +
659 "file import where by get set abstract enum open inner override private public internal " +
660 "protected catch finally out final vararg reified dynamic companion constructor init " +
661 "sealed field property receiver param sparam lateinit data inline noinline tailrec " +
662 "external annotation crossinline const operator infix suspend actual expect setparam value"
665 /* package java.lang */
666 "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
667 "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
668 "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
669 "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void Annotation Any BooleanArray " +
670 "ByteArray Char CharArray DeprecationLevel DoubleArray Enum FloatArray Function Int IntArray Lazy " +
671 "LazyThreadSafetyMode LongArray Nothing ShortArray Unit"
674 indentStatements
: false,
675 multiLineStrings
: true,
676 number
: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+(\.\d+)?|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
677 blockKeywords
: words("catch class do else finally for if where try while enum"),
678 defKeywords
: words("class val var object interface fun"),
679 atoms
: words("true false null this"),
681 "@": function(stream
) {
682 stream
.eatWhile(/[\w\$_]/);
685 '*': function(_stream
, state
) {
686 return state
.prevToken
== '.' ? 'variable' : 'operator';
688 '"': function(stream
, state
) {
689 state
.tokenize
= tokenKotlinString(stream
.match('""'));
690 return state
.tokenize(stream
, state
);
692 "/": function(stream
, state
) {
693 if (!stream
.eat("*")) return false;
694 state
.tokenize
= tokenNestedComment(1);
695 return state
.tokenize(stream
, state
)
697 indent: function(state
, ctx
, textAfter
, indentUnit
) {
698 var firstChar
= textAfter
&& textAfter
.charAt(0);
699 if ((state
.prevToken
== "}" || state
.prevToken
== ")") && textAfter
== "")
700 return state
.indented
;
701 if ((state
.prevToken
== "operator" && textAfter
!= "}" && state
.context
.type
!= "}") ||
702 state
.prevToken
== "variable" && firstChar
== "." ||
703 (state
.prevToken
== "}" || state
.prevToken
== ")") && firstChar
== ".")
704 return indentUnit
* 2 + ctx
.indented
;
705 if (ctx
.align
&& ctx
.type
== "}")
706 return ctx
.indented
+ (state
.context
.type
== (textAfter
|| "").charAt(0) ? 0 : indentUnit
);
709 modeProps
: {closeBrackets
: {triples
: '"'}}
712 def(["x-shader/x-vertex", "x-shader/x-fragment"], {
714 keywords
: words("sampler1D sampler2D sampler3D samplerCube " +
715 "sampler1DShadow sampler2DShadow " +
716 "const attribute uniform varying " +
717 "break continue discard return " +
718 "for while do if else struct " +
720 types
: words("float int bool void " +
721 "vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 " +
723 blockKeywords
: words("for while do if else struct"),
724 builtin
: words("radians degrees sin cos tan asin acos atan " +
725 "pow exp log exp2 sqrt inversesqrt " +
726 "abs sign floor ceil fract mod min max clamp mix step smoothstep " +
727 "length distance dot cross normalize ftransform faceforward " +
728 "reflect refract matrixCompMult " +
729 "lessThan lessThanEqual greaterThan greaterThanEqual " +
730 "equal notEqual any all not " +
731 "texture1D texture1DProj texture1DLod texture1DProjLod " +
732 "texture2D texture2DProj texture2DLod texture2DProjLod " +
733 "texture3D texture3DProj texture3DLod texture3DProjLod " +
734 "textureCube textureCubeLod " +
735 "shadow1D shadow2D shadow1DProj shadow2DProj " +
736 "shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod " +
737 "dFdx dFdy fwidth " +
738 "noise1 noise2 noise3 noise4"),
739 atoms
: words("true false " +
740 "gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex " +
741 "gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 " +
742 "gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 " +
743 "gl_FogCoord gl_PointCoord " +
744 "gl_Position gl_PointSize gl_ClipVertex " +
745 "gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor " +
746 "gl_TexCoord gl_FogFragCoord " +
747 "gl_FragCoord gl_FrontFacing " +
748 "gl_FragData gl_FragDepth " +
749 "gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix " +
750 "gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse " +
751 "gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse " +
752 "gl_TextureMatrixTranspose gl_ModelViewMatrixInverseTranspose " +
753 "gl_ProjectionMatrixInverseTranspose " +
754 "gl_ModelViewProjectionMatrixInverseTranspose " +
755 "gl_TextureMatrixInverseTranspose " +
756 "gl_NormalScale gl_DepthRange gl_ClipPlane " +
757 "gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel " +
758 "gl_FrontLightModelProduct gl_BackLightModelProduct " +
759 "gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ " +
760 "gl_FogParameters " +
761 "gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords " +
762 "gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats " +
763 "gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits " +
764 "gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits " +
765 "gl_MaxDrawBuffers"),
767 hooks
: {"#": cppHook
},
768 modeProps
: {fold
: ["brace", "include"]}
773 keywords
: words(cKeywords
+ " as atomic async call command component components configuration event generic " +
774 "implementation includes interface module new norace nx_struct nx_union post provides " +
775 "signal task uses abstract extends"),
777 blockKeywords
: words(cBlockKeywords
),
778 atoms
: words("null true false"),
779 hooks
: {"#": cppHook
},
780 modeProps
: {fold
: ["brace", "include"]}
783 def("text/x-objectivec", {
785 keywords
: words(cKeywords
+ " " + objCKeywords
),
787 builtin
: words(objCBuiltins
),
788 blockKeywords
: words(cBlockKeywords
+ " @synthesize @try @catch @finally @autoreleasepool @synchronized"),
789 defKeywords
: words(cDefKeywords
+ " @interface @implementation @protocol @class"),
790 dontIndentStatements
: /^@.*$/,
791 typeFirstDefinitions
: true,
792 atoms
: words("YES NO NULL Nil nil true false nullptr"),
793 isReservedIdentifier
: cIsReservedIdentifier
,
798 modeProps
: {fold
: ["brace", "include"]}
801 def("text/x-objectivec++", {
803 keywords
: words(cKeywords
+ " " + objCKeywords
+ " " + cppKeywords
),
805 builtin
: words(objCBuiltins
),
806 blockKeywords
: words(cBlockKeywords
+ " @synthesize @try @catch @finally @autoreleasepool @synchronized class try catch"),
807 defKeywords
: words(cDefKeywords
+ " @interface @implementation @protocol @class class namespace"),
808 dontIndentStatements
: /^@.*$|^template$/,
809 typeFirstDefinitions
: true,
810 atoms
: words("YES NO NULL Nil nil true false nullptr"),
811 isReservedIdentifier
: cIsReservedIdentifier
,
815 "u": cpp11StringHook
,
816 "U": cpp11StringHook
,
817 "L": cpp11StringHook
,
818 "R": cpp11StringHook
,
829 token: function(stream
, state
, style
) {
830 if (style
== "variable" && stream
.peek() == "(" &&
831 (state
.prevToken
== ";" || state
.prevToken
== null ||
832 state
.prevToken
== "}") &&
833 cppLooksLikeConstructor(stream
.current()))
837 namespaceSeparator
: "::",
838 modeProps
: {fold
: ["brace", "include"]}
841 def("text/x-squirrel", {
843 keywords
: words("base break clone continue const default delete enum extends function in class" +
844 " foreach local resume return this throw typeof yield constructor instanceof static"),
846 blockKeywords
: words("case catch class else for foreach if switch try while"),
847 defKeywords
: words("function local class"),
848 typeFirstDefinitions
: true,
849 atoms
: words("true false null"),
850 hooks
: {"#": cppHook
},
851 modeProps
: {fold
: ["brace", "include"]}
854 // Ceylon Strings need to deal with interpolation
855 var stringTokenizer
= null;
856 function tokenCeylonString(type
) {
857 return function(stream
, state
) {
858 var escaped
= false, next
, end
= false;
859 while (!stream
.eol()) {
860 if (!escaped
&& stream
.match('"') &&
861 (type
== "single" || stream
.match('""'))) {
865 if (!escaped
&& stream
.match('``')) {
866 stringTokenizer
= tokenCeylonString(type
);
870 next
= stream
.next();
871 escaped
= type
== "single" && !escaped
&& next
== "\\";
874 state
.tokenize
= null;
879 def("text/x-ceylon", {
881 keywords
: words("abstracts alias assembly assert assign break case catch class continue dynamic else" +
882 " exists extends finally for function given if import in interface is let module new" +
883 " nonempty object of out outer package return satisfies super switch then this throw" +
884 " try value void while"),
885 types: function(word
) {
886 // In Ceylon all identifiers that start with an uppercase are types
887 var first
= word
.charAt(0);
888 return (first
=== first
.toUpperCase() && first
!== first
.toLowerCase());
890 blockKeywords
: words("case catch class dynamic else finally for function if interface module new object switch try while"),
891 defKeywords
: words("class dynamic function interface module object package value"),
892 builtin
: words("abstract actual aliased annotation by default deprecated doc final formal late license" +
893 " native optional sealed see serializable shared suppressWarnings tagged throws variable"),
894 isPunctuationChar
: /[\[\]{}\(\),;\:\.`]/,
895 isOperatorChar
: /[+\-*&%=<>!?|^~:\/]/,
896 numberStart
: /[\d#$]/,
897 number
: /^(?:#[\da-fA-F_]+|\$[01_]+|[\d_]+[kMGTPmunpf]?|[\d_]+\.[\d_]+(?:[eE][-+]?\d+|[kMGTPmunpf]|)|)/i,
898 multiLineStrings
: true,
899 typeFirstDefinitions
: true,
900 atoms
: words("true false null larger smaller equal empty finished"),
904 "@": function(stream
) {
905 stream
.eatWhile(/[\w\$_]/);
908 '"': function(stream
, state
) {
909 state
.tokenize
= tokenCeylonString(stream
.match('""') ? "triple" : "single");
910 return state
.tokenize(stream
, state
);
912 '`': function(stream
, state
) {
913 if (!stringTokenizer
|| !stream
.match('`')) return false;
914 state
.tokenize
= stringTokenizer
;
915 stringTokenizer
= null;
916 return state
.tokenize(stream
, state
);
918 "'": function(stream
) {
919 stream
.eatWhile(/[\w\$_\xa1-\uffff]/);
922 token: function(_stream
, state
, style
) {
923 if ((style
== "variable" || style
== "type") &&
924 state
.prevToken
== ".") {
930 fold
: ["brace", "import"],
931 closeBrackets
: {triples
: '"'}