[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/LICENSE
   3  
   4  (function(mod) {
   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
  10      mod(CodeMirror);
  11  })(function(CodeMirror) {
  12  "use strict";
  13  
  14  function Context(indented, column, type, info, align, prev) {
  15    this.indented = indented;
  16    this.column = column;
  17    this.type = type;
  18    this.info = info;
  19    this.align = align;
  20    this.prev = prev;
  21  }
  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);
  27  }
  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;
  33  }
  34  
  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;
  39  }
  40  
  41  function isTopScope(context) {
  42    for (;;) {
  43      if (!context || context.type == "top") return true;
  44      if (context.type == "}" && context.prev.info != "namespace") return false;
  45      context = context.prev;
  46    }
  47  }
  48  
  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;
  72  
  73    var curPunc, isDefKeyword;
  74  
  75    function tokenBase(stream, state) {
  76      var ch = stream.next();
  77      if (hooks[ch]) {
  78        var result = hooks[ch](stream, state);
  79        if (result !== false) return result;
  80      }
  81      if (ch == '"' || ch == "'") {
  82        state.tokenize = tokenString(ch);
  83        return state.tokenize(stream, state);
  84      }
  85      if (numberStart.test(ch)) {
  86        stream.backUp(1)
  87        if (stream.match(number)) return "number"
  88        stream.next()
  89      }
  90      if (isPunctuationChar.test(ch)) {
  91        curPunc = ch;
  92        return null;
  93      }
  94      if (ch == "/") {
  95        if (stream.eat("*")) {
  96          state.tokenize = tokenComment;
  97          return tokenComment(stream, state);
  98        }
  99        if (stream.eat("/")) {
 100          stream.skipToEnd();
 101          return "comment";
 102        }
 103      }
 104      if (isOperatorChar.test(ch)) {
 105        while (!stream.match(/^\/[\/*]/, false) && stream.eat(isOperatorChar)) {}
 106        return "operator";
 107      }
 108      stream.eatWhile(isIdentifierChar);
 109      if (namespaceSeparator) while (stream.match(namespaceSeparator))
 110        stream.eatWhile(isIdentifierChar);
 111  
 112      var cur = stream.current();
 113      if (contains(keywords, cur)) {
 114        if (contains(blockKeywords, cur)) curPunc = "newstatement";
 115        if (contains(defKeywords, cur)) isDefKeyword = true;
 116        return "keyword";
 117      }
 118      if (contains(types, cur)) return "type";
 119      if (contains(builtin, cur)
 120          || (isReservedIdentifier && isReservedIdentifier(cur))) {
 121        if (contains(blockKeywords, cur)) curPunc = "newstatement";
 122        return "builtin";
 123      }
 124      if (contains(atoms, cur)) return "atom";
 125      return "variable";
 126    }
 127  
 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 == "\\";
 134        }
 135        if (end || !(escaped || multiLineStrings))
 136          state.tokenize = null;
 137        return "string";
 138      };
 139    }
 140  
 141    function tokenComment(stream, state) {
 142      var maybeEnd = false, ch;
 143      while (ch = stream.next()) {
 144        if (ch == "/" && maybeEnd) {
 145          state.tokenize = null;
 146          break;
 147        }
 148        maybeEnd = (ch == "*");
 149      }
 150      return "comment";
 151    }
 152  
 153    function maybeEOL(stream, state) {
 154      if (parserConfig.typeFirstDefinitions && stream.eol() && isTopScope(state.context))
 155        state.typeAtEndOfLine = typeBefore(stream, state, stream.pos)
 156    }
 157  
 158    // Interface
 159  
 160    return {
 161      startState: function(basecolumn) {
 162        return {
 163          tokenize: null,
 164          context: new Context((basecolumn || 0) - indentUnit, 0, "top", null, false),
 165          indented: 0,
 166          startOfLine: true,
 167          prevToken: null
 168        };
 169      },
 170  
 171      token: function(stream, state) {
 172        var ctx = state.context;
 173        if (stream.sol()) {
 174          if (ctx.align == null) ctx.align = false;
 175          state.indented = stream.indentation();
 176          state.startOfLine = true;
 177        }
 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;
 183  
 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);
 193        }
 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());
 199        }
 200  
 201        if (style == "variable" &&
 202            ((state.prevToken == "def" ||
 203              (parserConfig.typeFirstDefinitions && typeBefore(stream, state, stream.start) &&
 204               isTopScope(state.context) && stream.match(/^\s*\(/, false)))))
 205          style = "def";
 206  
 207        if (hooks.token) {
 208          var result = hooks.token(stream, state, style);
 209          if (result !== undefined) style = result;
 210        }
 211  
 212        if (style == "def" && parserConfig.styleDefs === false) style = "variable";
 213  
 214        state.startOfLine = false;
 215        state.prevToken = isDefKeyword ? "def" : style || curPunc;
 216        maybeEOL(stream, state);
 217        return style;
 218      },
 219  
 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))
 227            ctx = ctx.prev
 228        if (hooks.indent) {
 229          var hook = hooks.indent(state, ctx, textAfter, indentUnit);
 230          if (typeof hook == "number") return hook
 231        }
 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
 235          return ctx.indented
 236        }
 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;
 243  
 244        return ctx.indented + (closing ? 0 : indentUnit) +
 245          (!closing && switchBlock && !/^(?:case|default)\b/.test(textAfter) ? indentUnit : 0);
 246      },
 247  
 248      electricInput: indentSwitch ? /^\s*(?:case .*?:|default:|\{\}?|\})$/ : /^\s*[{}]$/,
 249      blockCommentStart: "/*",
 250      blockCommentEnd: "*/",
 251      blockCommentContinue: " * ",
 252      lineComment: "//",
 253      fold: "brace"
 254    };
 255  });
 256  
 257    function words(str) {
 258      var obj = {}, words = str.split(" ");
 259      for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
 260      return obj;
 261    }
 262    function contains(words, word) {
 263      if (typeof words === "function") {
 264        return words(word);
 265      } else {
 266        return words.propertyIsEnumerable(word);
 267      }
 268    }
 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";
 272  
 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";
 280  
 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";
 286  
 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"
 291  
 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 " +
 295      "void bool");
 296  
 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");
 300  
 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);
 307    }
 308  
 309    // Returns true if identifier is a "Objective C" type.
 310    function objCTypes(identifier) {
 311      return cTypes(identifier) || contains(basicObjCTypes, identifier);
 312    }
 313  
 314    var cBlockKeywords = "case do else for if switch while struct enum union";
 315    var cDefKeywords = "struct enum union";
 316  
 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(/^.$/)) {
 321          next = cppHook
 322          break
 323        } else if (ch == "/" && stream.match(/^\/[\/\*]/, false)) {
 324          break
 325        }
 326        stream.next()
 327      }
 328      state.tokenize = next
 329      return "meta"
 330    }
 331  
 332    function pointerHook(_stream, state) {
 333      if (state.prevToken == "type") return "type";
 334      return false;
 335    }
 336  
 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());
 343    }
 344  
 345    function cpp14Literal(stream) {
 346      stream.eatWhile(/[\w\.']/);
 347      return "number";
 348    }
 349  
 350    function cpp11StringHook(stream, state) {
 351      stream.backUp(1);
 352      // Raw strings.
 353      if (stream.match(/^(?:R|u8R|uR|UR|LR)/)) {
 354        var match = stream.match(/^"([^\s\\()]{0,16})\(/);
 355        if (!match) {
 356          return false;
 357        }
 358        state.cpp11RawStringDelim = match[1];
 359        state.tokenize = tokenRawString;
 360        return tokenRawString(stream, state);
 361      }
 362      // Unicode strings/chars.
 363      if (stream.match(/^(?:u8|u|U|L)/)) {
 364        if (stream.match(/^["']/, /* eat */ false)) {
 365          return "string";
 366        }
 367        return false;
 368      }
 369      // Ignore this hook.
 370      stream.next();
 371      return false;
 372    }
 373  
 374    function cppLooksLikeConstructor(word) {
 375      var lastTwo = /(\w+)::~?(\w+)$/.exec(word);
 376      return lastTwo && lastTwo[1] == lastTwo[2];
 377    }
 378  
 379    // C#-style strings where "" escapes a quote.
 380    function tokenAtString(stream, state) {
 381      var next;
 382      while ((next = stream.next()) != null) {
 383        if (next == '"' && !stream.eat('"')) {
 384          state.tokenize = null;
 385          break;
 386        }
 387      }
 388      return "string";
 389    }
 390  
 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 + '"'));
 397      if (match)
 398        state.tokenize = null;
 399      else
 400        stream.skipToEnd();
 401      return "string";
 402    }
 403  
 404    function def(mimes, mode) {
 405      if (typeof mimes == "string") mimes = [mimes];
 406      var words = [];
 407      function add(obj) {
 408        if (obj) for (var prop in obj) if (obj.hasOwnProperty(prop))
 409          words.push(prop);
 410      }
 411      add(mode.keywords);
 412      add(mode.types);
 413      add(mode.builtin);
 414      add(mode.atoms);
 415      if (words.length) {
 416        mode.helperType = mimes[0];
 417        CodeMirror.registerHelper("hintWords", mimes[0], words);
 418      }
 419  
 420      for (var i = 0; i < mimes.length; ++i)
 421        CodeMirror.defineMIME(mimes[i], mode);
 422    }
 423  
 424    def(["text/x-csrc", "text/x-c", "text/x-chdr"], {
 425      name: "clike",
 426      keywords: words(cKeywords),
 427      types: cTypes,
 428      blockKeywords: words(cBlockKeywords),
 429      defKeywords: words(cDefKeywords),
 430      typeFirstDefinitions: true,
 431      atoms: words("NULL true false"),
 432      isReservedIdentifier: cIsReservedIdentifier,
 433      hooks: {
 434        "#": cppHook,
 435        "*": pointerHook,
 436      },
 437      modeProps: {fold: ["brace", "include"]}
 438    });
 439  
 440    def(["text/x-c++src", "text/x-c++hdr"], {
 441      name: "clike",
 442      keywords: words(cKeywords + " " + cppKeywords),
 443      types: cTypes,
 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,
 451      hooks: {
 452        "#": cppHook,
 453        "*": pointerHook,
 454        "u": cpp11StringHook,
 455        "U": cpp11StringHook,
 456        "L": cpp11StringHook,
 457        "R": cpp11StringHook,
 458        "0": cpp14Literal,
 459        "1": cpp14Literal,
 460        "2": cpp14Literal,
 461        "3": cpp14Literal,
 462        "4": cpp14Literal,
 463        "5": cpp14Literal,
 464        "6": cpp14Literal,
 465        "7": cpp14Literal,
 466        "8": cpp14Literal,
 467        "9": cpp14Literal,
 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()))
 473            return "def";
 474        }
 475      },
 476      namespaceSeparator: "::",
 477      modeProps: {fold: ["brace", "include"]}
 478    });
 479  
 480    def("text/x-java", {
 481      name: "clike",
 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("var 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,
 494      hooks: {
 495        "@": function(stream) {
 496          // Don't match the @interface keyword.
 497          if (stream.match('interface', false)) return false;
 498  
 499          stream.eatWhile(/[\w\$_]/);
 500          return "meta";
 501        },
 502        '"': function(stream, state) {
 503          if (!stream.match(/""$/)) return false;
 504          state.tokenize = tokenTripleString;
 505          return state.tokenize(stream, state);
 506        }
 507      },
 508      modeProps: {fold: ["brace", "import"]}
 509    });
 510  
 511    def("text/x-csharp", {
 512      name: "clike",
 513      keywords: words("abstract as async await base break case catch checked class const continue" +
 514                      " default delegate do else enum event explicit extern finally fixed for" +
 515                      " foreach goto if implicit in interface internal is lock namespace new" +
 516                      " operator out override params private protected public readonly ref return sealed" +
 517                      " sizeof stackalloc static struct switch this throw try typeof unchecked" +
 518                      " unsafe using virtual void volatile while add alias ascending descending dynamic from get" +
 519                      " global group into join let orderby partial remove select set value var yield"),
 520      types: words("Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func" +
 521                   " Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32" +
 522                   " UInt64 bool byte char decimal double short int long object"  +
 523                   " sbyte float string ushort uint ulong"),
 524      blockKeywords: words("catch class do else finally for foreach if struct switch try while"),
 525      defKeywords: words("class interface namespace struct var"),
 526      typeFirstDefinitions: true,
 527      atoms: words("true false null"),
 528      hooks: {
 529        "@": function(stream, state) {
 530          if (stream.eat('"')) {
 531            state.tokenize = tokenAtString;
 532            return tokenAtString(stream, state);
 533          }
 534          stream.eatWhile(/[\w\$_]/);
 535          return "meta";
 536        }
 537      }
 538    });
 539  
 540    function tokenTripleString(stream, state) {
 541      var escaped = false;
 542      while (!stream.eol()) {
 543        if (!escaped && stream.match('"""')) {
 544          state.tokenize = null;
 545          break;
 546        }
 547        escaped = stream.next() == "\\" && !escaped;
 548      }
 549      return "string";
 550    }
 551  
 552    function tokenNestedComment(depth) {
 553      return function (stream, state) {
 554        var ch
 555        while (ch = stream.next()) {
 556          if (ch == "*" && stream.eat("/")) {
 557            if (depth == 1) {
 558              state.tokenize = null
 559              break
 560            } else {
 561              state.tokenize = tokenNestedComment(depth - 1)
 562              return state.tokenize(stream, state)
 563            }
 564          } else if (ch == "/" && stream.eat("*")) {
 565            state.tokenize = tokenNestedComment(depth + 1)
 566            return state.tokenize(stream, state)
 567          }
 568        }
 569        return "comment"
 570      }
 571    }
 572  
 573    def("text/x-scala", {
 574      name: "clike",
 575      keywords: words(
 576        /* scala */
 577        "abstract case catch class def do else extends final finally for forSome if " +
 578        "implicit import lazy match new null object override package private protected return " +
 579        "sealed super this throw trait try type val var while with yield _ " +
 580  
 581        /* package scala */
 582        "assert assume require print println printf readLine readBoolean readByte readShort " +
 583        "readChar readInt readLong readFloat readDouble"
 584      ),
 585      types: words(
 586        "AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either " +
 587        "Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable " +
 588        "Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering " +
 589        "Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder " +
 590        "StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector " +
 591  
 592        /* package java.lang */
 593        "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
 594        "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
 595        "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
 596        "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void"
 597      ),
 598      multiLineStrings: true,
 599      blockKeywords: words("catch class enum do else finally for forSome if match switch try while"),
 600      defKeywords: words("class enum def object package trait type val var"),
 601      atoms: words("true false null"),
 602      indentStatements: false,
 603      indentSwitch: false,
 604      isOperatorChar: /[+\-*&%=<>!?|\/#:@]/,
 605      hooks: {
 606        "@": function(stream) {
 607          stream.eatWhile(/[\w\$_]/);
 608          return "meta";
 609        },
 610        '"': function(stream, state) {
 611          if (!stream.match('""')) return false;
 612          state.tokenize = tokenTripleString;
 613          return state.tokenize(stream, state);
 614        },
 615        "'": function(stream) {
 616          stream.eatWhile(/[\w\$_\xa1-\uffff]/);
 617          return "atom";
 618        },
 619        "=": function(stream, state) {
 620          var cx = state.context
 621          if (cx.type == "}" && cx.align && stream.eat(">")) {
 622            state.context = new Context(cx.indented, cx.column, cx.type, cx.info, null, cx.prev)
 623            return "operator"
 624          } else {
 625            return false
 626          }
 627        },
 628  
 629        "/": function(stream, state) {
 630          if (!stream.eat("*")) return false
 631          state.tokenize = tokenNestedComment(1)
 632          return state.tokenize(stream, state)
 633        }
 634      },
 635      modeProps: {closeBrackets: {pairs: '()[]{}""', triples: '"'}}
 636    });
 637  
 638    function tokenKotlinString(tripleString){
 639      return function (stream, state) {
 640        var escaped = false, next, end = false;
 641        while (!stream.eol()) {
 642          if (!tripleString && !escaped && stream.match('"') ) {end = true; break;}
 643          if (tripleString && stream.match('"""')) {end = true; break;}
 644          next = stream.next();
 645          if(!escaped && next == "$" && stream.match('{'))
 646            stream.skipTo("}");
 647          escaped = !escaped && next == "\\" && !tripleString;
 648        }
 649        if (end || !tripleString)
 650          state.tokenize = null;
 651        return "string";
 652      }
 653    }
 654  
 655    def("text/x-kotlin", {
 656      name: "clike",
 657      keywords: words(
 658        /*keywords*/
 659        "package as typealias class interface this super val operator " +
 660        "var fun for is in This throw return annotation " +
 661        "break continue object if else while do try when !in !is as? " +
 662  
 663        /*soft keywords*/
 664        "file import where by get set abstract enum open inner override private public internal " +
 665        "protected catch finally out final vararg reified dynamic companion constructor init " +
 666        "sealed field property receiver param sparam lateinit data inline noinline tailrec " +
 667        "external annotation crossinline const operator infix suspend actual expect setparam value"
 668      ),
 669      types: words(
 670        /* package java.lang */
 671        "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
 672        "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
 673        "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
 674        "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void Annotation Any BooleanArray " +
 675        "ByteArray Char CharArray DeprecationLevel DoubleArray Enum FloatArray Function Int IntArray Lazy " +
 676        "LazyThreadSafetyMode LongArray Nothing ShortArray Unit"
 677      ),
 678      intendSwitch: false,
 679      indentStatements: false,
 680      multiLineStrings: true,
 681      number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+(\.\d+)?|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
 682      blockKeywords: words("catch class do else finally for if where try while enum"),
 683      defKeywords: words("class val var object interface fun"),
 684      atoms: words("true false null this"),
 685      hooks: {
 686        "@": function(stream) {
 687          stream.eatWhile(/[\w\$_]/);
 688          return "meta";
 689        },
 690        '*': function(_stream, state) {
 691          return state.prevToken == '.' ? 'variable' : 'operator';
 692        },
 693        '"': function(stream, state) {
 694          state.tokenize = tokenKotlinString(stream.match('""'));
 695          return state.tokenize(stream, state);
 696        },
 697        "/": function(stream, state) {
 698          if (!stream.eat("*")) return false;
 699          state.tokenize = tokenNestedComment(1);
 700          return state.tokenize(stream, state)
 701        },
 702        indent: function(state, ctx, textAfter, indentUnit) {
 703          var firstChar = textAfter && textAfter.charAt(0);
 704          if ((state.prevToken == "}" || state.prevToken == ")") && textAfter == "")
 705            return state.indented;
 706          if ((state.prevToken == "operator" && textAfter != "}" && state.context.type != "}") ||
 707            state.prevToken == "variable" && firstChar == "." ||
 708            (state.prevToken == "}" || state.prevToken == ")") && firstChar == ".")
 709            return indentUnit * 2 + ctx.indented;
 710          if (ctx.align && ctx.type == "}")
 711            return ctx.indented + (state.context.type == (textAfter || "").charAt(0) ? 0 : indentUnit);
 712        }
 713      },
 714      modeProps: {closeBrackets: {triples: '"'}}
 715    });
 716  
 717    def(["x-shader/x-vertex", "x-shader/x-fragment"], {
 718      name: "clike",
 719      keywords: words("sampler1D sampler2D sampler3D samplerCube " +
 720                      "sampler1DShadow sampler2DShadow " +
 721                      "const attribute uniform varying " +
 722                      "break continue discard return " +
 723                      "for while do if else struct " +
 724                      "in out inout"),
 725      types: words("float int bool void " +
 726                   "vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 " +
 727                   "mat2 mat3 mat4"),
 728      blockKeywords: words("for while do if else struct"),
 729      builtin: words("radians degrees sin cos tan asin acos atan " +
 730                      "pow exp log exp2 sqrt inversesqrt " +
 731                      "abs sign floor ceil fract mod min max clamp mix step smoothstep " +
 732                      "length distance dot cross normalize ftransform faceforward " +
 733                      "reflect refract matrixCompMult " +
 734                      "lessThan lessThanEqual greaterThan greaterThanEqual " +
 735                      "equal notEqual any all not " +
 736                      "texture1D texture1DProj texture1DLod texture1DProjLod " +
 737                      "texture2D texture2DProj texture2DLod texture2DProjLod " +
 738                      "texture3D texture3DProj texture3DLod texture3DProjLod " +
 739                      "textureCube textureCubeLod " +
 740                      "shadow1D shadow2D shadow1DProj shadow2DProj " +
 741                      "shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod " +
 742                      "dFdx dFdy fwidth " +
 743                      "noise1 noise2 noise3 noise4"),
 744      atoms: words("true false " +
 745                  "gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex " +
 746                  "gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 " +
 747                  "gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 " +
 748                  "gl_FogCoord gl_PointCoord " +
 749                  "gl_Position gl_PointSize gl_ClipVertex " +
 750                  "gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor " +
 751                  "gl_TexCoord gl_FogFragCoord " +
 752                  "gl_FragCoord gl_FrontFacing " +
 753                  "gl_FragData gl_FragDepth " +
 754                  "gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix " +
 755                  "gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse " +
 756                  "gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse " +
 757                  "gl_TextureMatrixTranspose gl_ModelViewMatrixInverseTranspose " +
 758                  "gl_ProjectionMatrixInverseTranspose " +
 759                  "gl_ModelViewProjectionMatrixInverseTranspose " +
 760                  "gl_TextureMatrixInverseTranspose " +
 761                  "gl_NormalScale gl_DepthRange gl_ClipPlane " +
 762                  "gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel " +
 763                  "gl_FrontLightModelProduct gl_BackLightModelProduct " +
 764                  "gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ " +
 765                  "gl_FogParameters " +
 766                  "gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords " +
 767                  "gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats " +
 768                  "gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits " +
 769                  "gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits " +
 770                  "gl_MaxDrawBuffers"),
 771      indentSwitch: false,
 772      hooks: {"#": cppHook},
 773      modeProps: {fold: ["brace", "include"]}
 774    });
 775  
 776    def("text/x-nesc", {
 777      name: "clike",
 778      keywords: words(cKeywords + " as atomic async call command component components configuration event generic " +
 779                      "implementation includes interface module new norace nx_struct nx_union post provides " +
 780                      "signal task uses abstract extends"),
 781      types: cTypes,
 782      blockKeywords: words(cBlockKeywords),
 783      atoms: words("null true false"),
 784      hooks: {"#": cppHook},
 785      modeProps: {fold: ["brace", "include"]}
 786    });
 787  
 788    def("text/x-objectivec", {
 789      name: "clike",
 790      keywords: words(cKeywords + " " + objCKeywords),
 791      types: objCTypes,
 792      builtin: words(objCBuiltins),
 793      blockKeywords: words(cBlockKeywords + " @synthesize @try @catch @finally @autoreleasepool @synchronized"),
 794      defKeywords: words(cDefKeywords + " @interface @implementation @protocol @class"),
 795      dontIndentStatements: /^@.*$/,
 796      typeFirstDefinitions: true,
 797      atoms: words("YES NO NULL Nil nil true false nullptr"),
 798      isReservedIdentifier: cIsReservedIdentifier,
 799      hooks: {
 800        "#": cppHook,
 801        "*": pointerHook,
 802      },
 803      modeProps: {fold: ["brace", "include"]}
 804    });
 805  
 806    def("text/x-objectivec++", {
 807      name: "clike",
 808      keywords: words(cKeywords + " " + objCKeywords + " " + cppKeywords),
 809      types: objCTypes,
 810      builtin: words(objCBuiltins),
 811      blockKeywords: words(cBlockKeywords + " @synthesize @try @catch @finally @autoreleasepool @synchronized class try catch"),
 812      defKeywords: words(cDefKeywords + " @interface @implementation @protocol @class class namespace"),
 813      dontIndentStatements: /^@.*$|^template$/,
 814      typeFirstDefinitions: true,
 815      atoms: words("YES NO NULL Nil nil true false nullptr"),
 816      isReservedIdentifier: cIsReservedIdentifier,
 817      hooks: {
 818        "#": cppHook,
 819        "*": pointerHook,
 820        "u": cpp11StringHook,
 821        "U": cpp11StringHook,
 822        "L": cpp11StringHook,
 823        "R": cpp11StringHook,
 824        "0": cpp14Literal,
 825        "1": cpp14Literal,
 826        "2": cpp14Literal,
 827        "3": cpp14Literal,
 828        "4": cpp14Literal,
 829        "5": cpp14Literal,
 830        "6": cpp14Literal,
 831        "7": cpp14Literal,
 832        "8": cpp14Literal,
 833        "9": cpp14Literal,
 834        token: function(stream, state, style) {
 835          if (style == "variable" && stream.peek() == "(" &&
 836              (state.prevToken == ";" || state.prevToken == null ||
 837               state.prevToken == "}") &&
 838              cppLooksLikeConstructor(stream.current()))
 839            return "def";
 840        }
 841      },
 842      namespaceSeparator: "::",
 843      modeProps: {fold: ["brace", "include"]}
 844    });
 845  
 846    def("text/x-squirrel", {
 847      name: "clike",
 848      keywords: words("base break clone continue const default delete enum extends function in class" +
 849                      " foreach local resume return this throw typeof yield constructor instanceof static"),
 850      types: cTypes,
 851      blockKeywords: words("case catch class else for foreach if switch try while"),
 852      defKeywords: words("function local class"),
 853      typeFirstDefinitions: true,
 854      atoms: words("true false null"),
 855      hooks: {"#": cppHook},
 856      modeProps: {fold: ["brace", "include"]}
 857    });
 858  
 859    // Ceylon Strings need to deal with interpolation
 860    var stringTokenizer = null;
 861    function tokenCeylonString(type) {
 862      return function(stream, state) {
 863        var escaped = false, next, end = false;
 864        while (!stream.eol()) {
 865          if (!escaped && stream.match('"') &&
 866                (type == "single" || stream.match('""'))) {
 867            end = true;
 868            break;
 869          }
 870          if (!escaped && stream.match('``')) {
 871            stringTokenizer = tokenCeylonString(type);
 872            end = true;
 873            break;
 874          }
 875          next = stream.next();
 876          escaped = type == "single" && !escaped && next == "\\";
 877        }
 878        if (end)
 879            state.tokenize = null;
 880        return "string";
 881      }
 882    }
 883  
 884    def("text/x-ceylon", {
 885      name: "clike",
 886      keywords: words("abstracts alias assembly assert assign break case catch class continue dynamic else" +
 887                      " exists extends finally for function given if import in interface is let module new" +
 888                      " nonempty object of out outer package return satisfies super switch then this throw" +
 889                      " try value void while"),
 890      types: function(word) {
 891          // In Ceylon all identifiers that start with an uppercase are types
 892          var first = word.charAt(0);
 893          return (first === first.toUpperCase() && first !== first.toLowerCase());
 894      },
 895      blockKeywords: words("case catch class dynamic else finally for function if interface module new object switch try while"),
 896      defKeywords: words("class dynamic function interface module object package value"),
 897      builtin: words("abstract actual aliased annotation by default deprecated doc final formal late license" +
 898                     " native optional sealed see serializable shared suppressWarnings tagged throws variable"),
 899      isPunctuationChar: /[\[\]{}\(\),;\:\.`]/,
 900      isOperatorChar: /[+\-*&%=<>!?|^~:\/]/,
 901      numberStart: /[\d#$]/,
 902      number: /^(?:#[\da-fA-F_]+|\$[01_]+|[\d_]+[kMGTPmunpf]?|[\d_]+\.[\d_]+(?:[eE][-+]?\d+|[kMGTPmunpf]|)|)/i,
 903      multiLineStrings: true,
 904      typeFirstDefinitions: true,
 905      atoms: words("true false null larger smaller equal empty finished"),
 906      indentSwitch: false,
 907      styleDefs: false,
 908      hooks: {
 909        "@": function(stream) {
 910          stream.eatWhile(/[\w\$_]/);
 911          return "meta";
 912        },
 913        '"': function(stream, state) {
 914            state.tokenize = tokenCeylonString(stream.match('""') ? "triple" : "single");
 915            return state.tokenize(stream, state);
 916          },
 917        '`': function(stream, state) {
 918            if (!stringTokenizer || !stream.match('`')) return false;
 919            state.tokenize = stringTokenizer;
 920            stringTokenizer = null;
 921            return state.tokenize(stream, state);
 922          },
 923        "'": function(stream) {
 924          stream.eatWhile(/[\w\$_\xa1-\uffff]/);
 925          return "atom";
 926        },
 927        token: function(_stream, state, style) {
 928            if ((style == "variable" || style == "type") &&
 929                state.prevToken == ".") {
 930              return "variable-2";
 931            }
 932          }
 933      },
 934      modeProps: {
 935          fold: ["brace", "import"],
 936          closeBrackets: {triples: '"'}
 937      }
 938    });
 939  
 940  });