{"version":3,"sources":["../../node_modules/codemirror/mode/verilog/verilog.js"],"names":["mod","exports","module","require","define","amd","CodeMirror","defineMode","config","parserConfig","indentUnit","statementIndentUnit","dontAlignCalls","noIndentKeywords","multiLineStrings","hooks","words","str","obj","split","i","length","keywords","isOperatorChar","isBracketChar","unsignedNumber","decimalLiteral","binaryLiteral","octLiteral","hexLiteral","realLiteral","closingBracketOrWord","closingBracket","curPunc","curKeyword","blockKeywords","openClose","keyword","undefined","statementKeywords","tokenBase","stream","state","ch","peek","style","test","next","eatWhile","tokenize","tokenString","eat","tokenComment","skipToEnd","backUp","match","cur","current","quote","escaped","end","maybeEnd","Context","indented","column","type","align","prev","this","pushContext","col","indent","c","context","popContext","t","isClosing","text","contextClosing","closingKeywords","buildElectricInputRegEx","allClosings","closings","j","push","re","RegExp","join","electricInput","startState","basecolumn","startOfLine","token","ctx","sol","indentation","eatSpace","close","textAfter","Pass","fromHook","firstChar","charAt","closing","possibleClosing","blockCommentStart","blockCommentEnd","lineComment","fold","defineMIME","name","tlvIdentifierStyle","|",">","$","$$","?$","?*","-","/","/-","@","@-","@++","@+=","@+=-","@--","@-=","%+","%-","%",">>","<<","<>","#","^","^^","^!","*","**","\\","\"","tlvScopePrefixChars","?","tlvIndentUnit","tlvTrackStatements","tlvIdentMatch","tlvFirstLevelIndentMatch","tlvLineIndentationMatch","tlvCommentMatch","tlvScopeStyle","depth","tlvIndentationStyle","tlvIdentNext","tlvInBlockComment","string","tlvCodeActive","pos","blankline","chPos","bodyString","slice","statementComment","pop","tlvNextIndent","beginStatement","eol","prefix","mnemonic","hasOwnProperty"],"mappings":"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","file":"verilog.min.js","sourcesContent":["// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"verilog\", function(config, parserConfig) {\n\n  var indentUnit = config.indentUnit,\n      statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,\n      dontAlignCalls = parserConfig.dontAlignCalls,\n      noIndentKeywords = parserConfig.noIndentKeywords || [],\n      multiLineStrings = parserConfig.multiLineStrings,\n      hooks = parserConfig.hooks || {};\n\n  function words(str) {\n    var obj = {}, words = str.split(\" \");\n    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;\n    return obj;\n  }\n\n  /**\n   * Keywords from IEEE 1800-2012\n   */\n  var keywords = words(\n    \"accept_on alias always always_comb always_ff always_latch and assert assign assume automatic before begin bind \" +\n    \"bins binsof bit break buf bufif0 bufif1 byte case casex casez cell chandle checker class clocking cmos config \" +\n    \"const constraint context continue cover covergroup coverpoint cross deassign default defparam design disable \" +\n    \"dist do edge else end endcase endchecker endclass endclocking endconfig endfunction endgenerate endgroup \" +\n    \"endinterface endmodule endpackage endprimitive endprogram endproperty endspecify endsequence endtable endtask \" +\n    \"enum event eventually expect export extends extern final first_match for force foreach forever fork forkjoin \" +\n    \"function generate genvar global highz0 highz1 if iff ifnone ignore_bins illegal_bins implements implies import \" +\n    \"incdir include initial inout input inside instance int integer interconnect interface intersect join join_any \" +\n    \"join_none large let liblist library local localparam logic longint macromodule matches medium modport module \" +\n    \"nand negedge nettype new nexttime nmos nor noshowcancelled not notif0 notif1 null or output package packed \" +\n    \"parameter pmos posedge primitive priority program property protected pull0 pull1 pulldown pullup \" +\n    \"pulsestyle_ondetect pulsestyle_onevent pure rand randc randcase randsequence rcmos real realtime ref reg \" +\n    \"reject_on release repeat restrict return rnmos rpmos rtran rtranif0 rtranif1 s_always s_eventually s_nexttime \" +\n    \"s_until s_until_with scalared sequence shortint shortreal showcancelled signed small soft solve specify \" +\n    \"specparam static string strong strong0 strong1 struct super supply0 supply1 sync_accept_on sync_reject_on \" +\n    \"table tagged task this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 triand trior \" +\n    \"trireg type typedef union unique unique0 unsigned until until_with untyped use uwire var vectored virtual void \" +\n    \"wait wait_order wand weak weak0 weak1 while wildcard wire with within wor xnor xor\");\n\n  /** Operators from IEEE 1800-2012\n     unary_operator ::=\n       + | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~\n     binary_operator ::=\n       + | - | * | / | % | == | != | === | !== | ==? | !=? | && | || | **\n       | < | <= | > | >= | & | | | ^ | ^~ | ~^ | >> | << | >>> | <<<\n       | -> | <->\n     inc_or_dec_operator ::= ++ | --\n     unary_module_path_operator ::=\n       ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~\n     binary_module_path_operator ::=\n       == | != | && | || | & | | | ^ | ^~ | ~^\n  */\n  var isOperatorChar = /[\\+\\-\\*\\/!~&|^%=?:]/;\n  var isBracketChar = /[\\[\\]{}()]/;\n\n  var unsignedNumber = /\\d[0-9_]*/;\n  var decimalLiteral = /\\d*\\s*'s?d\\s*\\d[0-9_]*/i;\n  var binaryLiteral = /\\d*\\s*'s?b\\s*[xz01][xz01_]*/i;\n  var octLiteral = /\\d*\\s*'s?o\\s*[xz0-7][xz0-7_]*/i;\n  var hexLiteral = /\\d*\\s*'s?h\\s*[0-9a-fxz?][0-9a-fxz?_]*/i;\n  var realLiteral = /(\\d[\\d_]*(\\.\\d[\\d_]*)?E-?[\\d_]+)|(\\d[\\d_]*\\.\\d[\\d_]*)/i;\n\n  var closingBracketOrWord = /^((\\w+)|[)}\\]])/;\n  var closingBracket = /[)}\\]]/;\n\n  var curPunc;\n  var curKeyword;\n\n  // Block openings which are closed by a matching keyword in the form of (\"end\" + keyword)\n  // E.g. \"task\" => \"endtask\"\n  var blockKeywords = words(\n    \"case checker class clocking config function generate interface module package \" +\n    \"primitive program property specify sequence table task\"\n  );\n\n  // Opening/closing pairs\n  var openClose = {};\n  for (var keyword in blockKeywords) {\n    openClose[keyword] = \"end\" + keyword;\n  }\n  openClose[\"begin\"] = \"end\";\n  openClose[\"casex\"] = \"endcase\";\n  openClose[\"casez\"] = \"endcase\";\n  openClose[\"do\"   ] = \"while\";\n  openClose[\"fork\" ] = \"join;join_any;join_none\";\n  openClose[\"covergroup\"] = \"endgroup\";\n\n  for (var i in noIndentKeywords) {\n    var keyword = noIndentKeywords[i];\n    if (openClose[keyword]) {\n      openClose[keyword] = undefined;\n    }\n  }\n\n  // Keywords which open statements that are ended with a semi-colon\n  var statementKeywords = words(\"always always_comb always_ff always_latch assert assign assume else export for foreach forever if import initial repeat while\");\n\n  function tokenBase(stream, state) {\n    var ch = stream.peek(), style;\n    if (hooks[ch] && (style = hooks[ch](stream, state)) != false) return style;\n    if (hooks.tokenBase && (style = hooks.tokenBase(stream, state)) != false)\n      return style;\n\n    if (/[,;:\\.]/.test(ch)) {\n      curPunc = stream.next();\n      return null;\n    }\n    if (isBracketChar.test(ch)) {\n      curPunc = stream.next();\n      return \"bracket\";\n    }\n    // Macros (tick-defines)\n    if (ch == '`') {\n      stream.next();\n      if (stream.eatWhile(/[\\w\\$_]/)) {\n        return \"def\";\n      } else {\n        return null;\n      }\n    }\n    // System calls\n    if (ch == '$') {\n      stream.next();\n      if (stream.eatWhile(/[\\w\\$_]/)) {\n        return \"meta\";\n      } else {\n        return null;\n      }\n    }\n    // Time literals\n    if (ch == '#') {\n      stream.next();\n      stream.eatWhile(/[\\d_.]/);\n      return \"def\";\n    }\n    // Strings\n    if (ch == '\"') {\n      stream.next();\n      state.tokenize = tokenString(ch);\n      return state.tokenize(stream, state);\n    }\n    // Comments\n    if (ch == \"/\") {\n      stream.next();\n      if (stream.eat(\"*\")) {\n        state.tokenize = tokenComment;\n        return tokenComment(stream, state);\n      }\n      if (stream.eat(\"/\")) {\n        stream.skipToEnd();\n        return \"comment\";\n      }\n      stream.backUp(1);\n    }\n\n    // Numeric literals\n    if (stream.match(realLiteral) ||\n        stream.match(decimalLiteral) ||\n        stream.match(binaryLiteral) ||\n        stream.match(octLiteral) ||\n        stream.match(hexLiteral) ||\n        stream.match(unsignedNumber) ||\n        stream.match(realLiteral)) {\n      return \"number\";\n    }\n\n    // Operators\n    if (stream.eatWhile(isOperatorChar)) {\n      return \"meta\";\n    }\n\n    // Keywords / plain variables\n    if (stream.eatWhile(/[\\w\\$_]/)) {\n      var cur = stream.current();\n      if (keywords[cur]) {\n        if (openClose[cur]) {\n          curPunc = \"newblock\";\n        }\n        if (statementKeywords[cur]) {\n          curPunc = \"newstatement\";\n        }\n        curKeyword = cur;\n        return \"keyword\";\n      }\n      return \"variable\";\n    }\n\n    stream.next();\n    return null;\n  }\n\n  function tokenString(quote) {\n    return function(stream, state) {\n      var escaped = false, next, end = false;\n      while ((next = stream.next()) != null) {\n        if (next == quote && !escaped) {end = true; break;}\n        escaped = !escaped && next == \"\\\\\";\n      }\n      if (end || !(escaped || multiLineStrings))\n        state.tokenize = tokenBase;\n      return \"string\";\n    };\n  }\n\n  function tokenComment(stream, state) {\n    var maybeEnd = false, ch;\n    while (ch = stream.next()) {\n      if (ch == \"/\" && maybeEnd) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      maybeEnd = (ch == \"*\");\n    }\n    return \"comment\";\n  }\n\n  function Context(indented, column, type, align, prev) {\n    this.indented = indented;\n    this.column = column;\n    this.type = type;\n    this.align = align;\n    this.prev = prev;\n  }\n  function pushContext(state, col, type) {\n    var indent = state.indented;\n    var c = new Context(indent, col, type, null, state.context);\n    return state.context = c;\n  }\n  function popContext(state) {\n    var t = state.context.type;\n    if (t == \")\" || t == \"]\" || t == \"}\") {\n      state.indented = state.context.indented;\n    }\n    return state.context = state.context.prev;\n  }\n\n  function isClosing(text, contextClosing) {\n    if (text == contextClosing) {\n      return true;\n    } else {\n      // contextClosing may be multiple keywords separated by ;\n      var closingKeywords = contextClosing.split(\";\");\n      for (var i in closingKeywords) {\n        if (text == closingKeywords[i]) {\n          return true;\n        }\n      }\n      return false;\n    }\n  }\n\n  function buildElectricInputRegEx() {\n    // Reindentation should occur on any bracket char: {}()[]\n    // or on a match of any of the block closing keywords, at\n    // the end of a line\n    var allClosings = [];\n    for (var i in openClose) {\n      if (openClose[i]) {\n        var closings = openClose[i].split(\";\");\n        for (var j in closings) {\n          allClosings.push(closings[j]);\n        }\n      }\n    }\n    var re = new RegExp(\"[{}()\\\\[\\\\]]|(\" + allClosings.join(\"|\") + \")$\");\n    return re;\n  }\n\n  // Interface\n  return {\n\n    // Regex to force current line to reindent\n    electricInput: buildElectricInputRegEx(),\n\n    startState: function(basecolumn) {\n      var state = {\n        tokenize: null,\n        context: new Context((basecolumn || 0) - indentUnit, 0, \"top\", false),\n        indented: 0,\n        startOfLine: true\n      };\n      if (hooks.startState) hooks.startState(state);\n      return state;\n    },\n\n    token: function(stream, state) {\n      var ctx = state.context;\n      if (stream.sol()) {\n        if (ctx.align == null) ctx.align = false;\n        state.indented = stream.indentation();\n        state.startOfLine = true;\n      }\n      if (hooks.token) {\n        // Call hook, with an optional return value of a style to override verilog styling.\n        var style = hooks.token(stream, state);\n        if (style !== undefined) {\n          return style;\n        }\n      }\n      if (stream.eatSpace()) return null;\n      curPunc = null;\n      curKeyword = null;\n      var style = (state.tokenize || tokenBase)(stream, state);\n      if (style == \"comment\" || style == \"meta\" || style == \"variable\") return style;\n      if (ctx.align == null) ctx.align = true;\n\n      if (curPunc == ctx.type) {\n        popContext(state);\n      } else if ((curPunc == \";\" && ctx.type == \"statement\") ||\n               (ctx.type && isClosing(curKeyword, ctx.type))) {\n        ctx = popContext(state);\n        while (ctx && ctx.type == \"statement\") ctx = popContext(state);\n      } else if (curPunc == \"{\") {\n        pushContext(state, stream.column(), \"}\");\n      } else if (curPunc == \"[\") {\n        pushContext(state, stream.column(), \"]\");\n      } else if (curPunc == \"(\") {\n        pushContext(state, stream.column(), \")\");\n      } else if (ctx && ctx.type == \"endcase\" && curPunc == \":\") {\n        pushContext(state, stream.column(), \"statement\");\n      } else if (curPunc == \"newstatement\") {\n        pushContext(state, stream.column(), \"statement\");\n      } else if (curPunc == \"newblock\") {\n        if (curKeyword == \"function\" && ctx && (ctx.type == \"statement\" || ctx.type == \"endgroup\")) {\n          // The 'function' keyword can appear in some other contexts where it actually does not\n          // indicate a function (import/export DPI and covergroup definitions).\n          // Do nothing in this case\n        } else if (curKeyword == \"task\" && ctx && ctx.type == \"statement\") {\n          // Same thing for task\n        } else {\n          var close = openClose[curKeyword];\n          pushContext(state, stream.column(), close);\n        }\n      }\n\n      state.startOfLine = false;\n      return style;\n    },\n\n    indent: function(state, textAfter) {\n      if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;\n      if (hooks.indent) {\n        var fromHook = hooks.indent(state);\n        if (fromHook >= 0) return fromHook;\n      }\n      var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);\n      if (ctx.type == \"statement\" && firstChar == \"}\") ctx = ctx.prev;\n      var closing = false;\n      var possibleClosing = textAfter.match(closingBracketOrWord);\n      if (possibleClosing)\n        closing = isClosing(possibleClosing[0], ctx.type);\n      if (ctx.type == \"statement\") return ctx.indented + (firstChar == \"{\" ? 0 : statementIndentUnit);\n      else if (closingBracket.test(ctx.type) && ctx.align && !dontAlignCalls) return ctx.column + (closing ? 0 : 1);\n      else if (ctx.type == \")\" && !closing) return ctx.indented + statementIndentUnit;\n      else return ctx.indented + (closing ? 0 : indentUnit);\n    },\n\n    blockCommentStart: \"/*\",\n    blockCommentEnd: \"*/\",\n    lineComment: \"//\",\n    fold: \"indent\"\n  };\n});\n\n  CodeMirror.defineMIME(\"text/x-verilog\", {\n    name: \"verilog\"\n  });\n\n  CodeMirror.defineMIME(\"text/x-systemverilog\", {\n    name: \"verilog\"\n  });\n\n\n\n  // TL-Verilog mode.\n  // See tl-x.org for language spec.\n  // See the mode in action at makerchip.com.\n  // Contact: steve.hoover@redwoodeda.com\n\n  // TLV Identifier prefixes.\n  // Note that sign is not treated separately, so \"+/-\" versions of numeric identifiers\n  // are included.\n  var tlvIdentifierStyle = {\n    \"|\": \"link\",\n    \">\": \"property\",  // Should condition this off for > TLV 1c.\n    \"$\": \"variable\",\n    \"$$\": \"variable\",\n    \"?$\": \"qualifier\",\n    \"?*\": \"qualifier\",\n    \"-\": \"hr\",\n    \"/\": \"property\",\n    \"/-\": \"property\",\n    \"@\": \"variable-3\",\n    \"@-\": \"variable-3\",\n    \"@++\": \"variable-3\",\n    \"@+=\": \"variable-3\",\n    \"@+=-\": \"variable-3\",\n    \"@--\": \"variable-3\",\n    \"@-=\": \"variable-3\",\n    \"%+\": \"tag\",\n    \"%-\": \"tag\",\n    \"%\": \"tag\",\n    \">>\": \"tag\",\n    \"<<\": \"tag\",\n    \"<>\": \"tag\",\n    \"#\": \"tag\",  // Need to choose a style for this.\n    \"^\": \"attribute\",\n    \"^^\": \"attribute\",\n    \"^!\": \"attribute\",\n    \"*\": \"variable-2\",\n    \"**\": \"variable-2\",\n    \"\\\\\": \"keyword\",\n    \"\\\"\": \"comment\"\n  };\n\n  // Lines starting with these characters define scope (result in indentation).\n  var tlvScopePrefixChars = {\n    \"/\": \"beh-hier\",\n    \">\": \"beh-hier\",\n    \"-\": \"phys-hier\",\n    \"|\": \"pipe\",\n    \"?\": \"when\",\n    \"@\": \"stage\",\n    \"\\\\\": \"keyword\"\n  };\n  var tlvIndentUnit = 3;\n  var tlvTrackStatements = false;\n  var tlvIdentMatch = /^([~!@#\\$%\\^&\\*-\\+=\\?\\/\\\\\\|'\"<>]+)([\\d\\w_]*)/;  // Matches an identifiere.\n  // Note that ':' is excluded, because of it's use in [:].\n  var tlvFirstLevelIndentMatch = /^[! ]  /;\n  var tlvLineIndentationMatch = /^[! ] */;\n  var tlvCommentMatch = /^\\/[\\/\\*]/;\n\n\n  // Returns a style specific to the scope at the given indentation column.\n  // Type is one of: \"indent\", \"scope-ident\", \"before-scope-ident\".\n  function tlvScopeStyle(state, indentation, type) {\n    // Begin scope.\n    var depth = indentation / tlvIndentUnit;  // TODO: Pass this in instead.\n    return \"tlv-\" + state.tlvIndentationStyle[depth] + \"-\" + type;\n  }\n\n  // Return true if the next thing in the stream is an identifier with a mnemonic.\n  function tlvIdentNext(stream) {\n    var match;\n    return (match = stream.match(tlvIdentMatch, false)) && match[2].length > 0;\n  }\n\n  CodeMirror.defineMIME(\"text/x-tlv\", {\n    name: \"verilog\",\n\n    hooks: {\n\n      electricInput: false,\n\n\n      // Return undefined for verilog tokenizing, or style for TLV token (null not used).\n      // Standard CM styles are used for most formatting, but some TL-Verilog-specific highlighting\n      // can be enabled with the definition of cm-tlv-* styles, including highlighting for:\n      //   - M4 tokens\n      //   - TLV scope indentation\n      //   - Statement delimitation (enabled by tlvTrackStatements)\n      token: function(stream, state) {\n        var style = undefined;\n        var match;  // Return value of pattern matches.\n\n        // Set highlighting mode based on code region (TLV or SV).\n        if (stream.sol() && ! state.tlvInBlockComment) {\n          // Process region.\n          if (stream.peek() == '\\\\') {\n            style = \"def\";\n            stream.skipToEnd();\n            if (stream.string.match(/\\\\SV/)) {\n              state.tlvCodeActive = false;\n            } else if (stream.string.match(/\\\\TLV/)){\n              state.tlvCodeActive = true;\n            }\n          }\n          // Correct indentation in the face of a line prefix char.\n          if (state.tlvCodeActive && stream.pos == 0 &&\n              (state.indented == 0) && (match = stream.match(tlvLineIndentationMatch, false))) {\n            state.indented = match[0].length;\n          }\n\n          // Compute indentation state:\n          //   o Auto indentation on next line\n          //   o Indentation scope styles\n          var indented = state.indented;\n          var depth = indented / tlvIndentUnit;\n          if (depth <= state.tlvIndentationStyle.length) {\n            // not deeper than current scope\n\n            var blankline = stream.string.length == indented;\n            var chPos = depth * tlvIndentUnit;\n            if (chPos < stream.string.length) {\n              var bodyString = stream.string.slice(chPos);\n              var ch = bodyString[0];\n              if (tlvScopePrefixChars[ch] && ((match = bodyString.match(tlvIdentMatch)) &&\n                  tlvIdentifierStyle[match[1]])) {\n                // This line begins scope.\n                // Next line gets indented one level.\n                indented += tlvIndentUnit;\n                // Style the next level of indentation (except non-region keyword identifiers,\n                //   which are statements themselves)\n                if (!(ch == \"\\\\\" && chPos > 0)) {\n                  state.tlvIndentationStyle[depth] = tlvScopePrefixChars[ch];\n                  if (tlvTrackStatements) {state.statementComment = false;}\n                  depth++;\n                }\n              }\n            }\n            // Clear out deeper indentation levels unless line is blank.\n            if (!blankline) {\n              while (state.tlvIndentationStyle.length > depth) {\n                state.tlvIndentationStyle.pop();\n              }\n            }\n          }\n          // Set next level of indentation.\n          state.tlvNextIndent = indented;\n        }\n\n        if (state.tlvCodeActive) {\n          // Highlight as TLV.\n\n          var beginStatement = false;\n          if (tlvTrackStatements) {\n            // This starts a statement if the position is at the scope level\n            // and we're not within a statement leading comment.\n            beginStatement =\n                   (stream.peek() != \" \") &&   // not a space\n                   (style === undefined) &&    // not a region identifier\n                   !state.tlvInBlockComment && // not in block comment\n                   //!stream.match(tlvCommentMatch, false) && // not comment start\n                   (stream.column() == state.tlvIndentationStyle.length * tlvIndentUnit);  // at scope level\n            if (beginStatement) {\n              if (state.statementComment) {\n                // statement already started by comment\n                beginStatement = false;\n              }\n              state.statementComment =\n                   stream.match(tlvCommentMatch, false); // comment start\n            }\n          }\n\n          var match;\n          if (style !== undefined) {\n            // Region line.\n            style += \" \" + tlvScopeStyle(state, 0, \"scope-ident\")\n          } else if (((stream.pos / tlvIndentUnit) < state.tlvIndentationStyle.length) &&\n                     (match = stream.match(stream.sol() ? tlvFirstLevelIndentMatch : /^   /))) {\n            // Indentation\n            style = // make this style distinct from the previous one to prevent\n                    // codemirror from combining spans\n                    \"tlv-indent-\" + (((stream.pos % 2) == 0) ? \"even\" : \"odd\") +\n                    // and style it\n                    \" \" + tlvScopeStyle(state, stream.pos - tlvIndentUnit, \"indent\");\n            // Style the line prefix character.\n            if (match[0].charAt(0) == \"!\") {\n              style += \" tlv-alert-line-prefix\";\n            }\n            // Place a class before a scope identifier.\n            if (tlvIdentNext(stream)) {\n              style += \" \" + tlvScopeStyle(state, stream.pos, \"before-scope-ident\");\n            }\n          } else if (state.tlvInBlockComment) {\n            // In a block comment.\n            if (stream.match(/^.*?\\*\\//)) {\n              // Exit block comment.\n              state.tlvInBlockComment = false;\n              if (tlvTrackStatements && !stream.eol()) {\n                // Anything after comment is assumed to be real statement content.\n                state.statementComment = false;\n              }\n            } else {\n              stream.skipToEnd();\n            }\n            style = \"comment\";\n          } else if ((match = stream.match(tlvCommentMatch)) && !state.tlvInBlockComment) {\n            // Start comment.\n            if (match[0] == \"//\") {\n              // Line comment.\n              stream.skipToEnd();\n            } else {\n              // Block comment.\n              state.tlvInBlockComment = true;\n            }\n            style = \"comment\";\n          } else if (match = stream.match(tlvIdentMatch)) {\n            // looks like an identifier (or identifier prefix)\n            var prefix = match[1];\n            var mnemonic = match[2];\n            if (// is identifier prefix\n                tlvIdentifierStyle.hasOwnProperty(prefix) &&\n                // has mnemonic or we're at the end of the line (maybe it hasn't been typed yet)\n                (mnemonic.length > 0 || stream.eol())) {\n              style = tlvIdentifierStyle[prefix];\n              if (stream.column() == state.indented) {\n                // Begin scope.\n                style += \" \" + tlvScopeStyle(state, stream.column(), \"scope-ident\")\n              }\n            } else {\n              // Just swallow one character and try again.\n              // This enables subsequent identifier match with preceding symbol character, which\n              //   is legal within a statement.  (Eg, !$reset).  It also enables detection of\n              //   comment start with preceding symbols.\n              stream.backUp(stream.current().length - 1);\n              style = \"tlv-default\";\n            }\n          } else if (stream.match(/^\\t+/)) {\n            // Highlight tabs, which are illegal.\n            style = \"tlv-tab\";\n          } else if (stream.match(/^[\\[\\]{}\\(\\);\\:]+/)) {\n            // [:], (), {}, ;.\n            style = \"meta\";\n          } else if (match = stream.match(/^[mM]4([\\+_])?[\\w\\d_]*/)) {\n            // m4 pre proc\n            style = (match[1] == \"+\") ? \"tlv-m4-plus\" : \"tlv-m4\";\n          } else if (stream.match(/^ +/)){\n            // Skip over spaces.\n            if (stream.eol()) {\n              // Trailing spaces.\n              style = \"error\";\n            } else {\n              // Non-trailing spaces.\n              style = \"tlv-default\";\n            }\n          } else if (stream.match(/^[\\w\\d_]+/)) {\n            // alpha-numeric token.\n            style = \"number\";\n          } else {\n            // Eat the next char w/ no formatting.\n            stream.next();\n            style = \"tlv-default\";\n          }\n          if (beginStatement) {\n            style += \" tlv-statement\";\n          }\n        } else {\n          if (stream.match(/^[mM]4([\\w\\d_]*)/)) {\n            // m4 pre proc\n            style = \"tlv-m4\";\n          }\n        }\n        return style;\n      },\n\n      indent: function(state) {\n        return (state.tlvCodeActive == true) ? state.tlvNextIndent : -1;\n      },\n\n      startState: function(state) {\n        state.tlvIndentationStyle = [];  // Styles to use for each level of indentation.\n        state.tlvCodeActive = true;  // True when we're in a TLV region (and at beginning of file).\n        state.tlvNextIndent = -1;    // The number of spaces to autoindent the next line if tlvCodeActive.\n        state.tlvInBlockComment = false;  // True inside /**/ comment.\n        if (tlvTrackStatements) {\n          state.statementComment = false;  // True inside a statement's header comment.\n        }\n      }\n\n    }\n  });\n});\n"]}