(function() {

  if (!CodeMirror.modeURL) CodeMirror.modeURL = "../mode/%N/%N.js";

  var loading = {};

  function splitCallback(cont, n) {

    var countDown = n;

    return function() { if (--countDown == 0) cont(); };

  }

  function ensureDeps(mode, cont) {

    var deps = CodeMirror.modes[mode].dependencies;

    if (!deps) return cont();

    var missing = [];

    for (var i = 0; i < deps.length; ++i) {

      if (!CodeMirror.modes.hasOwnProperty(deps[i]))

        missing.push(deps[i]);

    }

    if (!missing.length) return cont();

    var split = splitCallback(cont, missing.length);

    for (var i = 0; i < missing.length; ++i)

      CodeMirror.requireMode(missing[i], split);

  }

  CodeMirror.requireMode = function(mode, cont) {

    if (typeof mode != "string") mode = mode.name;

    if (CodeMirror.modes.hasOwnProperty(mode)) return ensureDeps(mode, cont);

    if (loading.hasOwnProperty(mode)) return loading[mode].push(cont);

    var script = document.createElement("script");

    script.src = CodeMirror.modeURL.replace(/%N/g, mode);

    var others = document.getElementsByTagName("script")[0];

    others.parentNode.insertBefore(script, others);

    var list = loading[mode] = [cont];

    var count = 0, poll = setInterval(function() {

      if (++count > 100) return clearInterval(poll);

      if (CodeMirror.modes.hasOwnProperty(mode)) {

        clearInterval(poll);

        loading[mode] = null;

        ensureDeps(mode, function() {

          for (var i = 0; i < list.length; ++i) list[i]();

        });

      }

    }, 200);

  };

  CodeMirror.autoLoadMode = function(instance, mode) {

    if (!CodeMirror.modes.hasOwnProperty(mode))

      CodeMirror.requireMode(mode, function() {

        instance.setOption("mode", instance.getOption("mode"));

      });

  };

}());

//overlay plugin

// Utility function that allows modes to be combined. The mode given

// as the base argument takes care of most of the normal mode

// functionality, but a second (typically simple) mode is used, which

// can override the style of text. Both modes get to parse all of the

// text, but when both assign a non-null style to a piece of code, the

// overlay wins, unless the combine argument was true, in which case

// the styles are combined.

// overlayParser is the old, deprecated name

CodeMirror.overlayMode = CodeMirror.overlayParser = function(base, overlay, combine) {

  return {

    startState: function() {

      return {

        base: CodeMirror.startState(base),

        overlay: CodeMirror.startState(overlay),

        basePos: 0, baseCur: null,

        overlayPos: 0, overlayCur: null

      };

    },

    copyState: function(state) {

      return {

        base: CodeMirror.copyState(base, state.base),

        overlay: CodeMirror.copyState(overlay, state.overlay),

        basePos: state.basePos, baseCur: null,

        overlayPos: state.overlayPos, overlayCur: null

      };

    },

    token: function(stream, state) {

      if (stream.start == state.basePos) {

        state.baseCur = base.token(stream, state.base);

        state.basePos = stream.pos;

      }

      if (stream.start == state.overlayPos) {

        stream.pos = stream.start;

        state.overlayCur = overlay.token(stream, state.overlay);

        state.overlayPos = stream.pos;

      }

      stream.pos = Math.min(state.basePos, state.overlayPos);

      if (stream.eol()) state.basePos = state.overlayPos = 0;

      if (state.overlayCur == null) return state.baseCur;

      if (state.baseCur != null && combine) return state.baseCur + " " + state.overlayCur;

      else return state.overlayCur;

    },

    indent: base.indent && function(state, textAfter) {

      return base.indent(state.base, textAfter);

    },

    electricChars: base.electricChars,

    innerMode: function(state) { return {state: state.base, mode: base}; },

    blankLine: function(state) {

      if (base.blankLine) base.blankLine(state.base);

      if (overlay.blankLine) overlay.blankLine(state.overlay);

    }

  };

};

CodeMirror.defineMode("apl", function() {

  var builtInOps = {

    ".": "innerProduct",

    "\\": "scan",

    "/": "reduce",

    "⌿": "reduce1Axis",

    "⍀": "scan1Axis",

    "¨": "each",

    "⍣": "power"

  };

  var builtInFuncs = {

    "+": ["conjugate", "add"],

    "−": ["negate", "subtract"],

    "×": ["signOf", "multiply"],

    "÷": ["reciprocal", "divide"],

    "⌈": ["ceiling", "greaterOf"],

    "⌊": ["floor", "lesserOf"],

    "∣": ["absolute", "residue"],

    "⍳": ["indexGenerate", "indexOf"],

    "?": ["roll", "deal"],

    "⋆": ["exponentiate", "toThePowerOf"],

    "⍟": ["naturalLog", "logToTheBase"],

    "○": ["piTimes", "circularFuncs"],

    "!": ["factorial", "binomial"],

    "⌹": ["matrixInverse", "matrixDivide"],

    "<": [null, "lessThan"],

    "≤": [null, "lessThanOrEqual"],

    "=": [null, "equals"],

    ">": [null, "greaterThan"],

    "≥": [null, "greaterThanOrEqual"],

    "≠": [null, "notEqual"],

    "≡": ["depth", "match"],

    "≢": [null, "notMatch"],

    "∈": ["enlist", "membership"],

    "⍷": [null, "find"],

    "∪": ["unique", "union"],

    "∩": [null, "intersection"],

    "∼": ["not", "without"],

    "∨": [null, "or"],

    "∧": [null, "and"],

    "⍱": [null, "nor"],

    "⍲": [null, "nand"],

    "⍴": ["shapeOf", "reshape"],

    ",": ["ravel", "catenate"],

    "⍪": [null, "firstAxisCatenate"],

    "⌽": ["reverse", "rotate"],

    "⊖": ["axis1Reverse", "axis1Rotate"],

    "⍉": ["transpose", null],

    "↑": ["first", "take"],

    "↓": [null, "drop"],

    "⊂": ["enclose", "partitionWithAxis"],

    "⊃": ["diclose", "pick"],

    "⌷": [null, "index"],

    "⍋": ["gradeUp", null],

    "⍒": ["gradeDown", null],

    "⊤": ["encode", null],

    "⊥": ["decode", null],

    "⍕": ["format", "formatByExample"],

    "⍎": ["execute", null],

    "⊣": ["stop", "left"],

    "⊢": ["pass", "right"]

  };

  var isOperator = /[\.\/⌿⍀¨⍣]/;

  var isNiladic = /⍬/;

  var isFunction = /[\+−×÷⌈⌊∣⍳\?⋆⍟○!⌹<≤=>≥≠≡≢∈⍷∪∩∼∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢]/;

  var isArrow = /←/;

  var isComment = /[⍝#].*$/;

  var stringEater = function(type) {

    var prev;

    prev = false;

    return function(c) {

      prev = c;

      if (c === type) {

        return prev === "\\";

      }

      return true;

    };

  };

  return {

    startState: function() {

      return {

        prev: false,

        func: false,

        op: false,

        string: false,

        escape: false

      };

    },

    token: function(stream, state) {

      var ch, funcName, word;

      if (stream.eatSpace()) {

        return null;

      }

      ch = stream.next();

      if (ch === '"' || ch === "'") {

        stream.eatWhile(stringEater(ch));

        stream.next();

        state.prev = true;

        return "string";

      }

      if (/[\[{\(]/.test(ch)) {

        state.prev = false;

        return null;

      }

      if (/[\]}\)]/.test(ch)) {

        state.prev = true;

        return null;

      }

      if (isNiladic.test(ch)) {

        state.prev = false;

        return "niladic";

      }

      if (/[¯\d]/.test(ch)) {

        if (state.func) {

          state.func = false;

          state.prev = false;

        } else {

          state.prev = true;

        }

        stream.eatWhile(/[\w\.]/);

        return "number";

      }

      if (isOperator.test(ch)) {

        return "operator apl-" + builtInOps[ch];

      }

      if (isArrow.test(ch)) {

        return "apl-arrow";

      }

      if (isFunction.test(ch)) {

        funcName = "apl-";

        if (builtInFuncs[ch] != null) {

          if (state.prev) {

            funcName += builtInFuncs[ch][1];

          } else {

            funcName += builtInFuncs[ch][0];

          }

        }

        state.func = true;

        state.prev = false;

        return "function " + funcName;

      }

      if (isComment.test(ch)) {

        stream.skipToEnd();

        return "comment";

      }

      if (ch === "∘" && stream.peek() === ".") {

        stream.next();

        return "function jot-dot";

      }

      stream.eatWhile(/[\w\$_]/);

      word = stream.current();

      state.prev = true;

      return "keyword";

    }

  };

});

CodeMirror.defineMIME("text/apl", "apl");

<!doctype html>

<html>

  <head>

    <meta charset="utf-8">

    <title>CodeMirror: APL mode</title>

    <link rel="stylesheet" href="../../doc/docs.css"> 

    <link rel="stylesheet" href="../../lib/codemirror.css"> 

    <script src="../../lib/codemirror.js"></script>

    <script src="../../addon/edit/matchbrackets.js"></script>

    <script src="apl.js"></script>

    <style>

	.CodeMirror { border: 2px inset #dee; }

    </style>

  </head>

  <body>

    <h1>CodeMirror: APL mode</h1>

<form><textarea id="code" name="code">

⍝ Conway's game of life

⍝ This example was inspired by the impressive demo at

⍝ http://www.youtube.com/watch?v=a9xAKttWgP4

⍝ Create a matrix:

⍝     0 1 1

⍝     1 1 0

⍝     0 1 0

creature ← (3 3 ⍴ ⍳ 9) ∈ 1 2 3 4 7   ⍝ Original creature from demo

creature ← (3 3 ⍴ ⍳ 9) ∈ 1 3 6 7 8   ⍝ Glider

⍝ Place the creature on a larger board, near the centre

board ← ¯1 ⊖ ¯2 ⌽ 5 7 ↑ creature

⍝ A function to move from one generation to the next

life ← {∨/ 1 ⍵ ∧ 3 4 = ⊂+/ +⌿ 1 0 ¯1 ∘.⊖ 1 0 ¯1 ⌽¨ ⊂⍵}

⍝ Compute n-th generation and format it as a

⍝ character matrix

gen ← {' #'[(life ⍣ ⍵) board]}

⍝ Show first three generations

(gen 1) (gen 2) (gen 3)

</textarea></form>

    <script>

      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {

        lineNumbers: true,

        matchBrackets: true,

        mode: "text/apl"

      });

    </script>

    <p>Simple mode that tries to handle APL as well as it can.</p>

    <p>It attempts to label functions/operators based upon

    monadic/dyadic usage (but this is far from fully fleshed out).

    This means there are meaningful classnames so hover states can

    have popups etc.</p>

    <p><strong>MIME types defined:</strong> <code>text/apl</code> (APL code)</p>

  </body>

</html>

/*

 * =====================================================================================

 *

 *       Filename:  mode/asterisk/asterisk.js

 *

 *    Description:  CodeMirror mode for Asterisk dialplan

 *

 *        Created:  05/17/2012 09:20:25 PM

 *       Revision:  none

 *

 *         Author:  Stas Kobzar (stas@modulis.ca),

 *        Company:  Modulis.ca Inc.

 *

 * =====================================================================================

 */

CodeMirror.defineMode("asterisk", function() {

  var atoms    = ["exten", "same", "include","ignorepat","switch"],

      dpcmd    = ["#include","#exec"],

      apps     = [

                  "addqueuemember","adsiprog","aelsub","agentlogin","agentmonitoroutgoing","agi",

                  "alarmreceiver","amd","answer","authenticate","background","backgrounddetect",

                  "bridge","busy","callcompletioncancel","callcompletionrequest","celgenuserevent",

                  "changemonitor","chanisavail","channelredirect","chanspy","clearhash","confbridge",

                  "congestion","continuewhile","controlplayback","dahdiacceptr2call","dahdibarge",

                  "dahdiras","dahdiscan","dahdisendcallreroutingfacility","dahdisendkeypadfacility",

                  "datetime","dbdel","dbdeltree","deadagi","dial","dictate","directory","disa",

                  "dumpchan","eagi","echo","endwhile","exec","execif","execiftime","exitwhile","extenspy",

                  "externalivr","festival","flash","followme","forkcdr","getcpeid","gosub","gosubif",

                  "goto","gotoif","gotoiftime","hangup","iax2provision","ices","importvar","incomplete",

                  "ivrdemo","jabberjoin","jabberleave","jabbersend","jabbersendgroup","jabberstatus",

                  "jack","log","macro","macroexclusive","macroexit","macroif","mailboxexists","meetme",

                  "meetmeadmin","meetmechanneladmin","meetmecount","milliwatt","minivmaccmess","minivmdelete",

                  "minivmgreet","minivmmwi","minivmnotify","minivmrecord","mixmonitor","monitor","morsecode",

                  "mp3player","mset","musiconhold","nbscat","nocdr","noop","odbc","odbc","odbcfinish",

                  "originate","ospauth","ospfinish","osplookup","ospnext","page","park","parkandannounce",

                  "parkedcall","pausemonitor","pausequeuemember","pickup","pickupchan","playback","playtones",

                  "privacymanager","proceeding","progress","queue","queuelog","raiseexception","read","readexten",

                  "readfile","receivefax","receivefax","receivefax","record","removequeuemember",

                  "resetcdr","retrydial","return","ringing","sayalpha","saycountedadj","saycountednoun",

                  "saycountpl","saydigits","saynumber","sayphonetic","sayunixtime","senddtmf","sendfax",

                  "sendfax","sendfax","sendimage","sendtext","sendurl","set","setamaflags",

                  "setcallerpres","setmusiconhold","sipaddheader","sipdtmfmode","sipremoveheader","skel",

                  "slastation","slatrunk","sms","softhangup","speechactivategrammar","speechbackground",

                  "speechcreate","speechdeactivategrammar","speechdestroy","speechloadgrammar","speechprocessingsound",

                  "speechstart","speechunloadgrammar","stackpop","startmusiconhold","stopmixmonitor","stopmonitor",

                  "stopmusiconhold","stopplaytones","system","testclient","testserver","transfer","tryexec",

                  "trysystem","unpausemonitor","unpausequeuemember","userevent","verbose","vmauthenticate",

                  "vmsayname","voicemail","voicemailmain","wait","waitexten","waitfornoise","waitforring",

                  "waitforsilence","waitmusiconhold","waituntil","while","zapateller"

                 ];

  function basicToken(stream,state){

    var cur = '';

    var ch  = '';

    ch = stream.next();

    // comment

    if(ch == ";") {

      stream.skipToEnd();

      return "comment";

    }

    // context

    if(ch == '[') {

      stream.skipTo(']');

      stream.eat(']');

      return "header";

    }

    // string

    if(ch == '"') {

      stream.skipTo('"');

      return "string";

    }

    if(ch == "'") {

      stream.skipTo("'");

      return "string-2";

    }

    // dialplan commands

    if(ch == '#') {

      stream.eatWhile(/\w/);

      cur = stream.current();

      if(dpcmd.indexOf(cur) !== -1) {

        stream.skipToEnd();

        return "strong";

      }

    }

    // application args

    if(ch == '$'){

      var ch1 = stream.peek();

      if(ch1 == '{'){

        stream.skipTo('}');

        stream.eat('}');

        return "variable-3";

      }

    }

    // extension

    stream.eatWhile(/\w/);

    cur = stream.current();

    if(atoms.indexOf(cur) !== -1) {

      state.extenStart = true;

      switch(cur) {

        case 'same': state.extenSame = true; break;

        case 'include':

        case 'switch':

        case 'ignorepat':

          state.extenInclude = true;break;

        default:break;

      }

      return "atom";

    }

  }

  return {

    startState: function() {

      return {

        extenStart: false,

        extenSame:  false,

        extenInclude: false,

        extenExten: false,

        extenPriority: false,

        extenApplication: false

      };

    },

    token: function(stream, state) {

      var cur = '';

      var ch  = '';

      if(stream.eatSpace()) return null;

      // extension started

      if(state.extenStart){

        stream.eatWhile(/[^\s]/);

        cur = stream.current();

        if(/^=>?$/.test(cur)){

          state.extenExten = true;

          state.extenStart = false;

          return "strong";

        } else {

          state.extenStart = false;

          stream.skipToEnd();

          return "error";

        }

      } else if(state.extenExten) {

        // set exten and priority

        state.extenExten = false;

        state.extenPriority = true;

        stream.eatWhile(/[^,]/);

        if(state.extenInclude) {

          stream.skipToEnd();

          state.extenPriority = false;

          state.extenInclude = false;

        }

        if(state.extenSame) {

          state.extenPriority = false;

          state.extenSame = false;

          state.extenApplication = true;

        }

        return "tag";

      } else if(state.extenPriority) {

        state.extenPriority = false;

        state.extenApplication = true;

        ch = stream.next(); // get comma

        if(state.extenSame) return null;

        stream.eatWhile(/[^,]/);

        return "number";

      } else if(state.extenApplication) {

        stream.eatWhile(/,/);

        cur = stream.current();

        if(cur === ',') return null;

        stream.eatWhile(/\w/);

        cur = stream.current().toLowerCase();

        state.extenApplication = false;

        if(apps.indexOf(cur) !== -1){

          return "def strong";

        }

      } else{

        return basicToken(stream,state);

      }

      return null;

    }

  };

});

CodeMirror.defineMIME("text/x-asterisk", "asterisk");

<!doctype html>

<html>

  <head>

    <meta charset="utf-8">

    <title>CodeMirror: Asterisk dialplan mode</title>

    <link rel="stylesheet" href="../../lib/codemirror.css">

    <script src="../../lib/codemirror.js"></script>

    <script src="asterisk.js"></script>

    <style>

      .CodeMirror {border: 1px solid #999;}

      .cm-s-default span.cm-arrow { color: red; }

    </style>

    <link rel="stylesheet" href="../../doc/docs.css">

  </head>

  <body>

    <h1>CodeMirror: Asterisk dialplan mode</h1>

    <form><textarea id="code" name="code">

; extensions.conf - the Asterisk dial plan

;

[general]

;

; If static is set to no, or omitted, then the pbx_config will rewrite

; this file when extensions are modified.  Remember that all comments

; made in the file will be lost when that happens.

static=yes

#include "/etc/asterisk/additional_general.conf

[iaxprovider]

switch => IAX2/user:[key]@myserver/mycontext

[dynamic]

#exec /usr/bin/dynamic-peers.pl

[trunkint]

;

; International long distance through trunk

;

exten => _9011.,1,Macro(dundi-e164,${EXTEN:4})

exten => _9011.,n,Dial(${GLOBAL(TRUNK)}/${FILTER(0-9,${EXTEN:${GLOBAL(TRUNKMSD)}})})

[local]

;

; Master context for local, toll-free, and iaxtel calls only

;

ignorepat => 9

include => default

[demo]

include => stdexten

;

; We start with what to do when a call first comes in.

;

exten => s,1,Wait(1)			; Wait a second, just for fun

same  => n,Answer			; Answer the line

same  => n,Set(TIMEOUT(digit)=5)	; Set Digit Timeout to 5 seconds

same  => n,Set(TIMEOUT(response)=10)	; Set Response Timeout to 10 seconds

same  => n(restart),BackGround(demo-congrats)	; Play a congratulatory message

same  => n(instruct),BackGround(demo-instruct)	; Play some instructions

same  => n,WaitExten			; Wait for an extension to be dialed.

exten => 2,1,BackGround(demo-moreinfo)	; Give some more information.

exten => 2,n,Goto(s,instruct)

exten => 3,1,Set(LANGUAGE()=fr)		; Set language to french

exten => 3,n,Goto(s,restart)		; Start with the congratulations

exten => 1000,1,Goto(default,s,1)

;

; We also create an example user, 1234, who is on the console and has

; voicemail, etc.

;

exten => 1234,1,Playback(transfer,skip)		; "Please hold while..."

					; (but skip if channel is not up)

exten => 1234,n,Gosub(${EXTEN},stdexten(${GLOBAL(CONSOLE)}))

exten => 1234,n,Goto(default,s,1)		; exited Voicemail

exten => 1235,1,Voicemail(1234,u)		; Right to voicemail

exten => 1236,1,Dial(Console/dsp)		; Ring forever

exten => 1236,n,Voicemail(1234,b)		; Unless busy

;

; # for when they're done with the demo

;

exten => #,1,Playback(demo-thanks)	; "Thanks for trying the demo"

exten => #,n,Hangup			; Hang them up.

;

; A timeout and "invalid extension rule"

;

exten => t,1,Goto(#,1)			; If they take too long, give up

exten => i,1,Playback(invalid)		; "That's not valid, try again"

;

; Create an extension, 500, for dialing the

; Asterisk demo.

;

exten => 500,1,Playback(demo-abouttotry); Let them know what's going on

exten => 500,n,Dial(IAX2/guest@pbx.digium.com/s@default)	; Call the Asterisk demo

exten => 500,n,Playback(demo-nogo)	; Couldn't connect to the demo site

exten => 500,n,Goto(s,6)		; Return to the start over message.

;

; Create an extension, 600, for evaluating echo latency.

;

exten => 600,1,Playback(demo-echotest)	; Let them know what's going on

exten => 600,n,Echo			; Do the echo test

exten => 600,n,Playback(demo-echodone)	; Let them know it's over

exten => 600,n,Goto(s,6)		; Start over

;

;	You can use the Macro Page to intercom a individual user

exten => 76245,1,Macro(page,SIP/Grandstream1)

; or if your peernames are the same as extensions

exten => _7XXX,1,Macro(page,SIP/${EXTEN})

;

;

; System Wide Page at extension 7999

;

exten => 7999,1,Set(TIMEOUT(absolute)=60)

exten => 7999,2,Page(Local/Grandstream1@page&Local/Xlite1@page&Local/1234@page/n,d)

; Give voicemail at extension 8500

;

exten => 8500,1,VoicemailMain

exten => 8500,n,Goto(s,6)

    </textarea></form>

    <script>

      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {

        mode: "text/x-asterisk",

        matchBrackets: true,

        lineNumber: true

      });

    </script>

    <p><strong>MIME types defined:</strong> <code>text/x-asterisk</code>.</p>

  </body>

</html>

CodeMirror.defineMode("clike", function(config, parserConfig) {

  var indentUnit = config.indentUnit,

      statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,

      dontAlignCalls = parserConfig.dontAlignCalls,

      keywords = parserConfig.keywords || {},

      builtin = parserConfig.builtin || {},

      blockKeywords = parserConfig.blockKeywords || {},

      atoms = parserConfig.atoms || {},

      hooks = parserConfig.hooks || {},

      multiLineStrings = parserConfig.multiLineStrings;

  var isOperatorChar = /[+\-*&%=<>!?|\/]/;

  var curPunc;

  function tokenBase(stream, state) {

    var ch = stream.next();

    if (hooks[ch]) {

      var result = hooks[ch](stream, state);

      if (result !== false) return result;

    }

    if (ch == '"' || ch == "'") {

      state.tokenize = tokenString(ch);

      return state.tokenize(stream, state);

    }

    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {

      curPunc = ch;

      return null;

    }

    if (/\d/.test(ch)) {

      stream.eatWhile(/[\w\.]/);

      return "number";

    }

    if (ch == "/") {

      if (stream.eat("*")) {

        state.tokenize = tokenComment;

        return tokenComment(stream, state);

      }

      if (stream.eat("/")) {

        stream.skipToEnd();

        return "comment";

      }

    }

    if (isOperatorChar.test(ch)) {

      stream.eatWhile(isOperatorChar);

      return "operator";

    }

    stream.eatWhile(/[\w\$_]/);

    var cur = stream.current();

    if (keywords.propertyIsEnumerable(cur)) {

      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";

      return "keyword";

    }

    if (builtin.propertyIsEnumerable(cur)) {

      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";

      return "builtin";

    }

    if (atoms.propertyIsEnumerable(cur)) return "atom";

    return "variable";

  }

  function tokenString(quote) {

    return function(stream, state) {

      var escaped = false, next, end = false;

      while ((next = stream.next()) != null) {

        if (next == quote && !escaped) {end = true; break;}

        escaped = !escaped && next == "\\";

      }

      if (end || !(escaped || multiLineStrings))

        state.tokenize = null;

      return "string";

    };

  }

  function tokenComment(stream, state) {

    var maybeEnd = false, ch;

    while (ch = stream.next()) {

      if (ch == "/" && maybeEnd) {

        state.tokenize = null;

        break;

      }

      maybeEnd = (ch == "*");

    }

    return "comment";

  }

  function Context(indented, column, type, align, prev) {

    this.indented = indented;

    this.column = column;

    this.type = type;

    this.align = align;

    this.prev = prev;

  }

  function pushContext(state, col, type) {

    var indent = state.indented;

    if (state.context && state.context.type == "statement")

      indent = state.context.indented;

    return state.context = new Context(indent, col, type, null, state.context);

  }

  function popContext(state) {

    var t = state.context.type;

    if (t == ")" || t == "]" || t == "}")

      state.indented = state.context.indented;

    return state.context = state.context.prev;

  }

  // Interface

  return {

    startState: function(basecolumn) {

      return {

        tokenize: null,

        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),

        indented: 0,

        startOfLine: true

      };

    },

    token: function(stream, state) {

      var ctx = state.context;

      if (stream.sol()) {

        if (ctx.align == null) ctx.align = false;

        state.indented = stream.indentation();

        state.startOfLine = true;

      }

      if (stream.eatSpace()) return null;

      curPunc = null;

      var style = (state.tokenize || tokenBase)(stream, state);

      if (style == "comment" || style == "meta") return style;

      if (ctx.align == null) ctx.align = true;

      if ((curPunc == ";" || curPunc == ":" || curPunc == ",") && ctx.type == "statement") popContext(state);

      else if (curPunc == "{") pushContext(state, stream.column(), "}");

      else if (curPunc == "[") pushContext(state, stream.column(), "]");

      else if (curPunc == "(") pushContext(state, stream.column(), ")");

      else if (curPunc == "}") {

        while (ctx.type == "statement") ctx = popContext(state);

        if (ctx.type == "}") ctx = popContext(state);

        while (ctx.type == "statement") ctx = popContext(state);

      }

      else if (curPunc == ctx.type) popContext(state);

      else if (((ctx.type == "}" || ctx.type == "top") && curPunc != ';') || (ctx.type == "statement" && curPunc == "newstatement"))

        pushContext(state, stream.column(), "statement");

      state.startOfLine = false;

      return style;

    },

    indent: function(state, textAfter) {

      if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;

      var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);

      if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;

      var closing = firstChar == ctx.type;

      if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit);

      else if (ctx.align && (!dontAlignCalls || ctx.type != ")")) return ctx.column + (closing ? 0 : 1);

      else if (ctx.type == ")" && !closing) return ctx.indented + statementIndentUnit;

      else return ctx.indented + (closing ? 0 : indentUnit);

    },

    electricChars: "{}",

    blockCommentStart: "/*",

    blockCommentEnd: "*/",

    lineComment: "//"

  };

});