[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  CodeMirror.defineMode("verilog", function(config, parserConfig) {
  15  
  16    var indentUnit = config.indentUnit,
  17        statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,
  18        dontAlignCalls = parserConfig.dontAlignCalls,
  19        // compilerDirectivesUseRegularIndentation - If set, Compiler directive
  20        // indentation follows the same rules as everything else. Otherwise if
  21        // false, compiler directives will track their own indentation.
  22        // For example, `ifdef nested inside another `ifndef will be indented,
  23        // but a `ifdef inside a function block may not be indented.
  24        compilerDirectivesUseRegularIndentation = parserConfig.compilerDirectivesUseRegularIndentation,
  25        noIndentKeywords = parserConfig.noIndentKeywords || [],
  26        multiLineStrings = parserConfig.multiLineStrings,
  27        hooks = parserConfig.hooks || {};
  28  
  29    function words(str) {
  30      var obj = {}, words = str.split(" ");
  31      for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
  32      return obj;
  33    }
  34  
  35    /**
  36     * Keywords from IEEE 1800-2012
  37     */
  38    var keywords = words(
  39      "accept_on alias always always_comb always_ff always_latch and assert assign assume automatic before begin bind " +
  40      "bins binsof bit break buf bufif0 bufif1 byte case casex casez cell chandle checker class clocking cmos config " +
  41      "const constraint context continue cover covergroup coverpoint cross deassign default defparam design disable " +
  42      "dist do edge else end endcase endchecker endclass endclocking endconfig endfunction endgenerate endgroup " +
  43      "endinterface endmodule endpackage endprimitive endprogram endproperty endspecify endsequence endtable endtask " +
  44      "enum event eventually expect export extends extern final first_match for force foreach forever fork forkjoin " +
  45      "function generate genvar global highz0 highz1 if iff ifnone ignore_bins illegal_bins implements implies import " +
  46      "incdir include initial inout input inside instance int integer interconnect interface intersect join join_any " +
  47      "join_none large let liblist library local localparam logic longint macromodule matches medium modport module " +
  48      "nand negedge nettype new nexttime nmos nor noshowcancelled not notif0 notif1 null or output package packed " +
  49      "parameter pmos posedge primitive priority program property protected pull0 pull1 pulldown pullup " +
  50      "pulsestyle_ondetect pulsestyle_onevent pure rand randc randcase randsequence rcmos real realtime ref reg " +
  51      "reject_on release repeat restrict return rnmos rpmos rtran rtranif0 rtranif1 s_always s_eventually s_nexttime " +
  52      "s_until s_until_with scalared sequence shortint shortreal showcancelled signed small soft solve specify " +
  53      "specparam static string strong strong0 strong1 struct super supply0 supply1 sync_accept_on sync_reject_on " +
  54      "table tagged task this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 triand trior " +
  55      "trireg type typedef union unique unique0 unsigned until until_with untyped use uwire var vectored virtual void " +
  56      "wait wait_order wand weak weak0 weak1 while wildcard wire with within wor xnor xor");
  57  
  58    /** Operators from IEEE 1800-2012
  59       unary_operator ::=
  60         + | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~
  61       binary_operator ::=
  62         + | - | * | / | % | == | != | === | !== | ==? | !=? | && | || | **
  63         | < | <= | > | >= | & | | | ^ | ^~ | ~^ | >> | << | >>> | <<<
  64         | -> | <->
  65       inc_or_dec_operator ::= ++ | --
  66       unary_module_path_operator ::=
  67         ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~
  68       binary_module_path_operator ::=
  69         == | != | && | || | & | | | ^ | ^~ | ~^
  70    */
  71    var isOperatorChar = /[\+\-\*\/!~&|^%=?:<>]/;
  72    var isBracketChar = /[\[\]{}()]/;
  73  
  74    var unsignedNumber = /\d[0-9_]*/;
  75    var decimalLiteral = /\d*\s*'s?d\s*\d[0-9_]*/i;
  76    var binaryLiteral = /\d*\s*'s?b\s*[xz01][xz01_]*/i;
  77    var octLiteral = /\d*\s*'s?o\s*[xz0-7][xz0-7_]*/i;
  78    var hexLiteral = /\d*\s*'s?h\s*[0-9a-fxz?][0-9a-fxz?_]*/i;
  79    var realLiteral = /(\d[\d_]*(\.\d[\d_]*)?E-?[\d_]+)|(\d[\d_]*\.\d[\d_]*)/i;
  80  
  81    var closingBracketOrWord = /^((`?\w+)|[)}\]])/;
  82    var closingBracket = /[)}\]]/;
  83    var compilerDirectiveRegex      = new RegExp(
  84      "^(`(?:ifdef|ifndef|elsif|else|endif|undef|undefineall|define|include|begin_keywords|celldefine|default|" +
  85      "nettype|end_keywords|endcelldefine|line|nounconnected_drive|pragma|resetall|timescale|unconnected_drive))\\b");
  86    var compilerDirectiveBeginRegex = /^(`(?:ifdef|ifndef|elsif|else))\b/;
  87    var compilerDirectiveEndRegex   = /^(`(?:elsif|else|endif))\b/;
  88  
  89    var curPunc;
  90    var curKeyword;
  91  
  92    // Block openings which are closed by a matching keyword in the form of ("end" + keyword)
  93    // E.g. "task" => "endtask"
  94    var blockKeywords = words(
  95      "case checker class clocking config function generate interface module package " +
  96      "primitive program property specify sequence table task"
  97    );
  98  
  99    // Opening/closing pairs
 100    var openClose = {};
 101    for (var keyword in blockKeywords) {
 102      openClose[keyword] = "end" + keyword;
 103    }
 104    openClose["begin"] = "end";
 105    openClose["casex"] = "endcase";
 106    openClose["casez"] = "endcase";
 107    openClose["do"   ] = "while";
 108    openClose["fork" ] = "join;join_any;join_none";
 109    openClose["covergroup"] = "endgroup";
 110    openClose["macro_begin"] = "macro_end";
 111  
 112    for (var i in noIndentKeywords) {
 113      var keyword = noIndentKeywords[i];
 114      if (openClose[keyword]) {
 115        openClose[keyword] = undefined;
 116      }
 117    }
 118  
 119    // Keywords which open statements that are ended with a semi-colon
 120    var statementKeywords = words("always always_comb always_ff always_latch assert assign assume else export for foreach forever if import initial repeat while extern typedef");
 121  
 122    function tokenBase(stream, state) {
 123      var ch = stream.peek(), style;
 124      if (hooks[ch] && (style = hooks[ch](stream, state)) != false) return style;
 125      if (hooks.tokenBase && (style = hooks.tokenBase(stream, state)) != false)
 126        return style;
 127  
 128      if (/[,;:\.]/.test(ch)) {
 129        curPunc = stream.next();
 130        return null;
 131      }
 132      if (isBracketChar.test(ch)) {
 133        curPunc = stream.next();
 134        return "bracket";
 135      }
 136      // Macros (tick-defines)
 137      if (ch == '`') {
 138        stream.next();
 139        if (stream.eatWhile(/[\w\$_]/)) {
 140          var cur = stream.current();
 141          curKeyword = cur;
 142          // Macros that end in _begin, are start of block and end with _end
 143          if (cur.startsWith("`uvm_") && cur.endsWith("_begin")) {
 144            var keywordClose = curKeyword.substr(0,curKeyword.length - 5) + "end";
 145            openClose[cur] = keywordClose;
 146            curPunc = "newblock";
 147          } else {
 148            stream.eatSpace();
 149            if (stream.peek() == '(') {
 150              // Check if this is a block
 151              curPunc = "newmacro";
 152            }
 153            var withSpace = stream.current();
 154            // Move the stream back before the spaces
 155            stream.backUp(withSpace.length - cur.length);
 156          }
 157          return "def";
 158        } else {
 159          return null;
 160        }
 161      }
 162      // System calls
 163      if (ch == '$') {
 164        stream.next();
 165        if (stream.eatWhile(/[\w\$_]/)) {
 166          return "meta";
 167        } else {
 168          return null;
 169        }
 170      }
 171      // Time literals
 172      if (ch == '#') {
 173        stream.next();
 174        stream.eatWhile(/[\d_.]/);
 175        return "def";
 176      }
 177      // Event
 178      if (ch == '@') {
 179        stream.next();
 180        stream.eatWhile(/[@]/);
 181        return "def";
 182      }
 183      // Strings
 184      if (ch == '"') {
 185        stream.next();
 186        state.tokenize = tokenString(ch);
 187        return state.tokenize(stream, state);
 188      }
 189      // Comments
 190      if (ch == "/") {
 191        stream.next();
 192        if (stream.eat("*")) {
 193          state.tokenize = tokenComment;
 194          return tokenComment(stream, state);
 195        }
 196        if (stream.eat("/")) {
 197          stream.skipToEnd();
 198          return "comment";
 199        }
 200        stream.backUp(1);
 201      }
 202  
 203      // Numeric literals
 204      if (stream.match(realLiteral) ||
 205          stream.match(decimalLiteral) ||
 206          stream.match(binaryLiteral) ||
 207          stream.match(octLiteral) ||
 208          stream.match(hexLiteral) ||
 209          stream.match(unsignedNumber) ||
 210          stream.match(realLiteral)) {
 211        return "number";
 212      }
 213  
 214      // Operators
 215      if (stream.eatWhile(isOperatorChar)) {
 216        curPunc = stream.current();
 217        return "meta";
 218      }
 219  
 220      // Keywords / plain variables
 221      if (stream.eatWhile(/[\w\$_]/)) {
 222        var cur = stream.current();
 223        if (keywords[cur]) {
 224          if (openClose[cur]) {
 225            curPunc = "newblock";
 226            if (cur === "fork") {
 227              // Fork can be a statement instead of block in cases of:
 228              // "disable fork;" and "wait fork;" (trailing semicolon)
 229              stream.eatSpace()
 230              if (stream.peek() == ';') {
 231                curPunc = "newstatement";
 232              }
 233              stream.backUp(stream.current().length - cur.length);
 234            }
 235          }
 236          if (statementKeywords[cur]) {
 237            curPunc = "newstatement";
 238          }
 239          curKeyword = cur;
 240          return "keyword";
 241        }
 242        return "variable";
 243      }
 244  
 245      stream.next();
 246      return null;
 247    }
 248  
 249    function tokenString(quote) {
 250      return function(stream, state) {
 251        var escaped = false, next, end = false;
 252        while ((next = stream.next()) != null) {
 253          if (next == quote && !escaped) {end = true; break;}
 254          escaped = !escaped && next == "\\";
 255        }
 256        if (end || !(escaped || multiLineStrings))
 257          state.tokenize = tokenBase;
 258        return "string";
 259      };
 260    }
 261  
 262    function tokenComment(stream, state) {
 263      var maybeEnd = false, ch;
 264      while (ch = stream.next()) {
 265        if (ch == "/" && maybeEnd) {
 266          state.tokenize = tokenBase;
 267          break;
 268        }
 269        maybeEnd = (ch == "*");
 270      }
 271      return "comment";
 272    }
 273  
 274    function Context(indented, column, type, scopekind, align, prev) {
 275      this.indented = indented;
 276      this.column = column;
 277      this.type = type;
 278      this.scopekind = scopekind;
 279      this.align = align;
 280      this.prev = prev;
 281    }
 282    function pushContext(state, col, type, scopekind) {
 283      var indent = state.indented;
 284      var c = new Context(indent, col, type, scopekind ? scopekind : "", null, state.context);
 285      return state.context = c;
 286    }
 287    function popContext(state) {
 288      var t = state.context.type;
 289      if (t == ")" || t == "]" || t == "}") {
 290        state.indented = state.context.indented;
 291      }
 292      return state.context = state.context.prev;
 293    }
 294  
 295    function isClosing(text, contextClosing) {
 296      if (text == contextClosing) {
 297        return true;
 298      } else {
 299        // contextClosing may be multiple keywords separated by ;
 300        var closingKeywords = contextClosing.split(";");
 301        for (var i in closingKeywords) {
 302          if (text == closingKeywords[i]) {
 303            return true;
 304          }
 305        }
 306        return false;
 307      }
 308    }
 309  
 310    function isInsideScopeKind(ctx, scopekind) {
 311      if (ctx == null) {
 312        return false;
 313      }
 314      if (ctx.scopekind === scopekind) {
 315        return true;
 316      }
 317      return isInsideScopeKind(ctx.prev, scopekind);
 318    }
 319  
 320    function buildElectricInputRegEx() {
 321      // Reindentation should occur on any bracket char: {}()[]
 322      // or on a match of any of the block closing keywords, at
 323      // the end of a line
 324      var allClosings = [];
 325      for (var i in openClose) {
 326        if (openClose[i]) {
 327          var closings = openClose[i].split(";");
 328          for (var j in closings) {
 329            allClosings.push(closings[j]);
 330          }
 331        }
 332      }
 333      var re = new RegExp("[{}()\\[\\]]|(" + allClosings.join("|") + ")$");
 334      return re;
 335    }
 336  
 337    // Interface
 338    return {
 339  
 340      // Regex to force current line to reindent
 341      electricInput: buildElectricInputRegEx(),
 342  
 343      startState: function(basecolumn) {
 344        var state = {
 345          tokenize: null,
 346          context: new Context((basecolumn || 0) - indentUnit, 0, "top", "top", false),
 347          indented: 0,
 348          compilerDirectiveIndented: 0,
 349          startOfLine: true
 350        };
 351        if (hooks.startState) hooks.startState(state);
 352        return state;
 353      },
 354  
 355      token: function(stream, state) {
 356        var ctx = state.context;
 357        if (stream.sol()) {
 358          if (ctx.align == null) ctx.align = false;
 359          state.indented = stream.indentation();
 360          state.startOfLine = true;
 361        }
 362        if (hooks.token) {
 363          // Call hook, with an optional return value of a style to override verilog styling.
 364          var style = hooks.token(stream, state);
 365          if (style !== undefined) {
 366            return style;
 367          }
 368        }
 369        if (stream.eatSpace()) return null;
 370        curPunc = null;
 371        curKeyword = null;
 372        var style = (state.tokenize || tokenBase)(stream, state);
 373        if (style == "comment" || style == "meta" || style == "variable") {
 374          if (((curPunc === "=") || (curPunc === "<=")) && !isInsideScopeKind(ctx, "assignment")) {
 375            // '<=' could be nonblocking assignment or lessthan-equals (which shouldn't cause indent)
 376            //      Search through the context to see if we are already in an assignment.
 377            // '=' could be inside port declaration with comma or ')' afterward, or inside for(;;) block.
 378            pushContext(state, stream.column() + curPunc.length, "assignment", "assignment");
 379            if (ctx.align == null) ctx.align = true;
 380          }
 381          return style;
 382        }
 383        if (ctx.align == null) ctx.align = true;
 384  
 385        var isClosingAssignment = ctx.type == "assignment" &&
 386          closingBracket.test(curPunc) && ctx.prev && ctx.prev.type === curPunc;
 387        if (curPunc == ctx.type || isClosingAssignment) {
 388          if (isClosingAssignment) {
 389            ctx = popContext(state);
 390          }
 391          ctx = popContext(state);
 392          if (curPunc == ")") {
 393            // Handle closing macros, assuming they could have a semicolon or begin/end block inside.
 394            if (ctx && (ctx.type === "macro")) {
 395              ctx = popContext(state);
 396              while (ctx && (ctx.type == "statement" || ctx.type == "assignment")) ctx = popContext(state);
 397            }
 398          } else if (curPunc == "}") {
 399            // Handle closing statements like constraint block: "foreach () {}" which
 400            // do not have semicolon at end.
 401            if (ctx && (ctx.type === "statement")) {
 402              while (ctx && (ctx.type == "statement")) ctx = popContext(state);
 403            }
 404          }
 405        } else if (((curPunc == ";" || curPunc == ",") && (ctx.type == "statement" || ctx.type == "assignment")) ||
 406                 (ctx.type && isClosing(curKeyword, ctx.type))) {
 407          ctx = popContext(state);
 408          while (ctx && (ctx.type == "statement" || ctx.type == "assignment")) ctx = popContext(state);
 409        } else if (curPunc == "{") {
 410          pushContext(state, stream.column(), "}");
 411        } else if (curPunc == "[") {
 412          pushContext(state, stream.column(), "]");
 413        } else if (curPunc == "(") {
 414          pushContext(state, stream.column(), ")");
 415        } else if (ctx && ctx.type == "endcase" && curPunc == ":") {
 416          pushContext(state, stream.column(), "statement", "case");
 417        } else if (curPunc == "newstatement") {
 418          pushContext(state, stream.column(), "statement", curKeyword);
 419        } else if (curPunc == "newblock") {
 420          if (curKeyword == "function" && ctx && (ctx.type == "statement" || ctx.type == "endgroup")) {
 421            // The 'function' keyword can appear in some other contexts where it actually does not
 422            // indicate a function (import/export DPI and covergroup definitions).
 423            // Do nothing in this case
 424          } else if (curKeyword == "task" && ctx && ctx.type == "statement") {
 425            // Same thing for task
 426          } else if (curKeyword == "class" && ctx && ctx.type == "statement") {
 427            // Same thing for class (e.g. typedef)
 428          } else {
 429            var close = openClose[curKeyword];
 430            pushContext(state, stream.column(), close, curKeyword);
 431          }
 432        } else if (curPunc == "newmacro" || (curKeyword && curKeyword.match(compilerDirectiveRegex))) {
 433          if (curPunc == "newmacro") {
 434            // Macros (especially if they have parenthesis) potentially have a semicolon
 435            // or complete statement/block inside, and should be treated as such.
 436            pushContext(state, stream.column(), "macro", "macro");
 437          }
 438          if (curKeyword.match(compilerDirectiveEndRegex)) {
 439            state.compilerDirectiveIndented -= statementIndentUnit;
 440          }
 441          if (curKeyword.match(compilerDirectiveBeginRegex)) {
 442            state.compilerDirectiveIndented += statementIndentUnit;
 443          }
 444        }
 445  
 446        state.startOfLine = false;
 447        return style;
 448      },
 449  
 450      indent: function(state, textAfter) {
 451        if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;
 452        if (hooks.indent) {
 453          var fromHook = hooks.indent(state);
 454          if (fromHook >= 0) return fromHook;
 455        }
 456        var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
 457        if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
 458        var closing = false;
 459        var possibleClosing = textAfter.match(closingBracketOrWord);
 460        if (possibleClosing)
 461          closing = isClosing(possibleClosing[0], ctx.type);
 462        if (!compilerDirectivesUseRegularIndentation && textAfter.match(compilerDirectiveRegex)) {
 463          if (textAfter.match(compilerDirectiveEndRegex)) {
 464            return state.compilerDirectiveIndented - statementIndentUnit;
 465          }
 466          return state.compilerDirectiveIndented;
 467        }
 468        if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit);
 469        else if ((closingBracket.test(ctx.type) || ctx.type == "assignment")
 470          && ctx.align && !dontAlignCalls) return ctx.column + (closing ? 0 : 1);
 471        else if (ctx.type == ")" && !closing) return ctx.indented + statementIndentUnit;
 472        else return ctx.indented + (closing ? 0 : indentUnit);
 473      },
 474  
 475      blockCommentStart: "/*",
 476      blockCommentEnd: "*/",
 477      lineComment: "//",
 478      fold: "indent"
 479    };
 480  });
 481  
 482    CodeMirror.defineMIME("text/x-verilog", {
 483      name: "verilog"
 484    });
 485  
 486    CodeMirror.defineMIME("text/x-systemverilog", {
 487      name: "verilog"
 488    });
 489  
 490  
 491  
 492    // TL-Verilog mode.
 493    // See tl-x.org for language spec.
 494    // See the mode in action at makerchip.com.
 495    // Contact: [email protected]
 496  
 497    // TLV Identifier prefixes.
 498    // Note that sign is not treated separately, so "+/-" versions of numeric identifiers
 499    // are included.
 500    var tlvIdentifierStyle = {
 501      "|": "link",
 502      ">": "property",  // Should condition this off for > TLV 1c.
 503      "$": "variable",
 504      "$$": "variable",
 505      "?$": "qualifier",
 506      "?*": "qualifier",
 507      "-": "hr",
 508      "/": "property",
 509      "/-": "property",
 510      "@": "variable-3",
 511      "@-": "variable-3",
 512      "@++": "variable-3",
 513      "@+=": "variable-3",
 514      "@+=-": "variable-3",
 515      "@--": "variable-3",
 516      "@-=": "variable-3",
 517      "%+": "tag",
 518      "%-": "tag",
 519      "%": "tag",
 520      ">>": "tag",
 521      "<<": "tag",
 522      "<>": "tag",
 523      "#": "tag",  // Need to choose a style for this.
 524      "^": "attribute",
 525      "^^": "attribute",
 526      "^!": "attribute",
 527      "*": "variable-2",
 528      "**": "variable-2",
 529      "\\": "keyword",
 530      "\"": "comment"
 531    };
 532  
 533    // Lines starting with these characters define scope (result in indentation).
 534    var tlvScopePrefixChars = {
 535      "/": "beh-hier",
 536      ">": "beh-hier",
 537      "-": "phys-hier",
 538      "|": "pipe",
 539      "?": "when",
 540      "@": "stage",
 541      "\\": "keyword"
 542    };
 543    var tlvIndentUnit = 3;
 544    var tlvTrackStatements = false;
 545    var tlvIdentMatch = /^([~!@#\$%\^&\*-\+=\?\/\\\|'"<>]+)([\d\w_]*)/;  // Matches an identifier.
 546    // Note that ':' is excluded, because of it's use in [:].
 547    var tlvFirstLevelIndentMatch = /^[! ]  /;
 548    var tlvLineIndentationMatch = /^[! ] */;
 549    var tlvCommentMatch = /^\/[\/\*]/;
 550  
 551  
 552    // Returns a style specific to the scope at the given indentation column.
 553    // Type is one of: "indent", "scope-ident", "before-scope-ident".
 554    function tlvScopeStyle(state, indentation, type) {
 555      // Begin scope.
 556      var depth = indentation / tlvIndentUnit;  // TODO: Pass this in instead.
 557      return "tlv-" + state.tlvIndentationStyle[depth] + "-" + type;
 558    }
 559  
 560    // Return true if the next thing in the stream is an identifier with a mnemonic.
 561    function tlvIdentNext(stream) {
 562      var match;
 563      return (match = stream.match(tlvIdentMatch, false)) && match[2].length > 0;
 564    }
 565  
 566    CodeMirror.defineMIME("text/x-tlv", {
 567      name: "verilog",
 568  
 569      hooks: {
 570  
 571        electricInput: false,
 572  
 573  
 574        // Return undefined for verilog tokenizing, or style for TLV token (null not used).
 575        // Standard CM styles are used for most formatting, but some TL-Verilog-specific highlighting
 576        // can be enabled with the definition of cm-tlv-* styles, including highlighting for:
 577        //   - M4 tokens
 578        //   - TLV scope indentation
 579        //   - Statement delimitation (enabled by tlvTrackStatements)
 580        token: function(stream, state) {
 581          var style = undefined;
 582          var match;  // Return value of pattern matches.
 583  
 584          // Set highlighting mode based on code region (TLV or SV).
 585          if (stream.sol() && ! state.tlvInBlockComment) {
 586            // Process region.
 587            if (stream.peek() == '\\') {
 588              style = "def";
 589              stream.skipToEnd();
 590              if (stream.string.match(/\\SV/)) {
 591                state.tlvCodeActive = false;
 592              } else if (stream.string.match(/\\TLV/)){
 593                state.tlvCodeActive = true;
 594              }
 595            }
 596            // Correct indentation in the face of a line prefix char.
 597            if (state.tlvCodeActive && stream.pos == 0 &&
 598                (state.indented == 0) && (match = stream.match(tlvLineIndentationMatch, false))) {
 599              state.indented = match[0].length;
 600            }
 601  
 602            // Compute indentation state:
 603            //   o Auto indentation on next line
 604            //   o Indentation scope styles
 605            var indented = state.indented;
 606            var depth = indented / tlvIndentUnit;
 607            if (depth <= state.tlvIndentationStyle.length) {
 608              // not deeper than current scope
 609  
 610              var blankline = stream.string.length == indented;
 611              var chPos = depth * tlvIndentUnit;
 612              if (chPos < stream.string.length) {
 613                var bodyString = stream.string.slice(chPos);
 614                var ch = bodyString[0];
 615                if (tlvScopePrefixChars[ch] && ((match = bodyString.match(tlvIdentMatch)) &&
 616                    tlvIdentifierStyle[match[1]])) {
 617                  // This line begins scope.
 618                  // Next line gets indented one level.
 619                  indented += tlvIndentUnit;
 620                  // Style the next level of indentation (except non-region keyword identifiers,
 621                  //   which are statements themselves)
 622                  if (!(ch == "\\" && chPos > 0)) {
 623                    state.tlvIndentationStyle[depth] = tlvScopePrefixChars[ch];
 624                    if (tlvTrackStatements) {state.statementComment = false;}
 625                    depth++;
 626                  }
 627                }
 628              }
 629              // Clear out deeper indentation levels unless line is blank.
 630              if (!blankline) {
 631                while (state.tlvIndentationStyle.length > depth) {
 632                  state.tlvIndentationStyle.pop();
 633                }
 634              }
 635            }
 636            // Set next level of indentation.
 637            state.tlvNextIndent = indented;
 638          }
 639  
 640          if (state.tlvCodeActive) {
 641            // Highlight as TLV.
 642  
 643            var beginStatement = false;
 644            if (tlvTrackStatements) {
 645              // This starts a statement if the position is at the scope level
 646              // and we're not within a statement leading comment.
 647              beginStatement =
 648                     (stream.peek() != " ") &&   // not a space
 649                     (style === undefined) &&    // not a region identifier
 650                     !state.tlvInBlockComment && // not in block comment
 651                     //!stream.match(tlvCommentMatch, false) && // not comment start
 652                     (stream.column() == state.tlvIndentationStyle.length * tlvIndentUnit);  // at scope level
 653              if (beginStatement) {
 654                if (state.statementComment) {
 655                  // statement already started by comment
 656                  beginStatement = false;
 657                }
 658                state.statementComment =
 659                     stream.match(tlvCommentMatch, false); // comment start
 660              }
 661            }
 662  
 663            var match;
 664            if (style !== undefined) {
 665              // Region line.
 666              style += " " + tlvScopeStyle(state, 0, "scope-ident")
 667            } else if (((stream.pos / tlvIndentUnit) < state.tlvIndentationStyle.length) &&
 668                       (match = stream.match(stream.sol() ? tlvFirstLevelIndentMatch : /^   /))) {
 669              // Indentation
 670              style = // make this style distinct from the previous one to prevent
 671                      // codemirror from combining spans
 672                      "tlv-indent-" + (((stream.pos % 2) == 0) ? "even" : "odd") +
 673                      // and style it
 674                      " " + tlvScopeStyle(state, stream.pos - tlvIndentUnit, "indent");
 675              // Style the line prefix character.
 676              if (match[0].charAt(0) == "!") {
 677                style += " tlv-alert-line-prefix";
 678              }
 679              // Place a class before a scope identifier.
 680              if (tlvIdentNext(stream)) {
 681                style += " " + tlvScopeStyle(state, stream.pos, "before-scope-ident");
 682              }
 683            } else if (state.tlvInBlockComment) {
 684              // In a block comment.
 685              if (stream.match(/^.*?\*\//)) {
 686                // Exit block comment.
 687                state.tlvInBlockComment = false;
 688                if (tlvTrackStatements && !stream.eol()) {
 689                  // Anything after comment is assumed to be real statement content.
 690                  state.statementComment = false;
 691                }
 692              } else {
 693                stream.skipToEnd();
 694              }
 695              style = "comment";
 696            } else if ((match = stream.match(tlvCommentMatch)) && !state.tlvInBlockComment) {
 697              // Start comment.
 698              if (match[0] == "//") {
 699                // Line comment.
 700                stream.skipToEnd();
 701              } else {
 702                // Block comment.
 703                state.tlvInBlockComment = true;
 704              }
 705              style = "comment";
 706            } else if (match = stream.match(tlvIdentMatch)) {
 707              // looks like an identifier (or identifier prefix)
 708              var prefix = match[1];
 709              var mnemonic = match[2];
 710              if (// is identifier prefix
 711                  tlvIdentifierStyle.hasOwnProperty(prefix) &&
 712                  // has mnemonic or we're at the end of the line (maybe it hasn't been typed yet)
 713                  (mnemonic.length > 0 || stream.eol())) {
 714                style = tlvIdentifierStyle[prefix];
 715                if (stream.column() == state.indented) {
 716                  // Begin scope.
 717                  style += " " + tlvScopeStyle(state, stream.column(), "scope-ident")
 718                }
 719              } else {
 720                // Just swallow one character and try again.
 721                // This enables subsequent identifier match with preceding symbol character, which
 722                //   is legal within a statement.  (E.g., !$reset).  It also enables detection of
 723                //   comment start with preceding symbols.
 724                stream.backUp(stream.current().length - 1);
 725                style = "tlv-default";
 726              }
 727            } else if (stream.match(/^\t+/)) {
 728              // Highlight tabs, which are illegal.
 729              style = "tlv-tab";
 730            } else if (stream.match(/^[\[\]{}\(\);\:]+/)) {
 731              // [:], (), {}, ;.
 732              style = "meta";
 733            } else if (match = stream.match(/^[mM]4([\+_])?[\w\d_]*/)) {
 734              // m4 pre proc
 735              style = (match[1] == "+") ? "tlv-m4-plus" : "tlv-m4";
 736            } else if (stream.match(/^ +/)){
 737              // Skip over spaces.
 738              if (stream.eol()) {
 739                // Trailing spaces.
 740                style = "error";
 741              } else {
 742                // Non-trailing spaces.
 743                style = "tlv-default";
 744              }
 745            } else if (stream.match(/^[\w\d_]+/)) {
 746              // alpha-numeric token.
 747              style = "number";
 748            } else {
 749              // Eat the next char w/ no formatting.
 750              stream.next();
 751              style = "tlv-default";
 752            }
 753            if (beginStatement) {
 754              style += " tlv-statement";
 755            }
 756          } else {
 757            if (stream.match(/^[mM]4([\w\d_]*)/)) {
 758              // m4 pre proc
 759              style = "tlv-m4";
 760            }
 761          }
 762          return style;
 763        },
 764  
 765        indent: function(state) {
 766          return (state.tlvCodeActive == true) ? state.tlvNextIndent : -1;
 767        },
 768  
 769        startState: function(state) {
 770          state.tlvIndentationStyle = [];  // Styles to use for each level of indentation.
 771          state.tlvCodeActive = true;  // True when we're in a TLV region (and at beginning of file).
 772          state.tlvNextIndent = -1;    // The number of spaces to autoindent the next line if tlvCodeActive.
 773          state.tlvInBlockComment = false;  // True inside /**/ comment.
 774          if (tlvTrackStatements) {
 775            state.statementComment = false;  // True inside a statement's header comment.
 776          }
 777        }
 778  
 779      }
 780    });
 781  });