// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: http://codemirror.net/LICENSE

(function(mod) {
if (typeof exports == "object" && typeof module == "object") // CommonJS
  mod(require(["codemirror/lib/codemirror","codemirror/addon/lint/lint"]));
else if (typeof define == "function" && define.amd) // AMD
  define([ "codemirror/lib/codemirror","codemirror/addon/lint/lint" ], mod);
else // Plain browser env
  mod(CodeMirror);
})(function(CodeMirror) {
"use strict";

CodeMirror.defineMode("prolog", function(conf, parserConfig) {
  function chain(stream, state, f) {
    state.tokenize = f;
    return f(stream, state);
  }

  var cm_;
  var curLine;

  /*******************************
   *       CONFIG DATA           *
   *******************************/

  var quasiQuotations =
      parserConfig.quasiQuotations || false;   /* {|Syntax||Quotation|} */
  var dialect = parserConfig.dialect || "yap"; /* {|Syntax||Quotation|} */
  var composeGoalWithDots =
      parserConfig.composeGoalWithDots || true; /* {|Syntax||Quotation|} */
  var dicts = parserConfig.dicts || false;      /* tag{k:v, ...} */
  var groupedIntegers =
      parserConfig.groupedIntegers || false; /* tag{k:v, ...} */
  var unicodeEscape =
      parserConfig.unicodeEscape || true; /* \uXXXX and \UXXXXXXXX */
  var multiLineQuoted = parserConfig.multiLineQuoted || true; /* "...\n..." */
  var quoteType = parserConfig.quoteType ||
                  {'"' : "string", "'" : "qatom", "`" : "bqstring"};
  var singletonVars = new Map();

  var isSingleEscChar = /[abref\\'"nrtsv]/;
  var isOctalDigit = /[0-7]/;
  var isHexDigit = /[0-9a-fA-F]/;

  var isSymbolChar = /[-#$&*+./:<=>?@\\^~]/; /* Prolog glueing symbols chars */
  var isSoloChar = /[[\]{}(),;|!]/;          /* Prolog solo chars */
  var isNeck = /^(:-|-->)$/;
  var isControlOp = /^(,|;|->|\*->|\\+|\|)$/;

  /*******************************
   *        Linter Support        *
   *******************************/

  var errorFound = [];
  var exportedMsgs = [];

  function getLine(stream) {
    return stream.lineOracle.line;
    //  return cm_.getDoc().getCursor().line;
  }

  // var ed =
  // window.document.getElementsByClassName("CodeMirror")[0].CodeMirror.doc.getEditor();

  function rmError(stream) {
    if (cm_ == null)
    return;
    var doc = cm_.getDoc();
    var l = getLine(stream);
    // stream.lineOracle.line;
    for (var i = 0; i < errorFound.length; i++) {
      var elLine = doc.getLineNumber(errorFound[i].line);
      if (elLine == null || l === elLine) {
        errorFound.splice(i, 1);
        i -= 1;
      }
    }
  }

  function mkError(stream, severity, msg) {
    if (stream.pos == 0)
      return;
    var l = cm_.getDoc().getLineHandle(getLine(stream));
    var found = errorFound.find(function(
        element) { return element.line === l && element.to == stream.pos; });
    if (!found) {
      console.log( getLine(stream) );
    errorFound.push({
        "line" : l,
        "from" : stream.start,
        "to" : stream.pos,
        severity : severity,
        message : msg
      });
    }
  }

  function exportErrors(text) {
    if (cm_ == null)
      return;
    var doc = cm_.getDoc();

    exportedMsgs.length = 0;
    for (var i = 0; i < errorFound.length; i += 1) {
      var e = errorFound[i];
      var l = doc.getLineNumber(e.line);
      if (l == null) {
        errorFound.splice(i, 1);
        i -= 1;
        continue;
      }
      exportedMsgs.push({
        "from" : CodeMirror.Pos(l, e.from),
        "to" : CodeMirror.Pos(l, e.to),
        "severity" : e.severity,
        "message" : e.message
      });
    }
    return exportedMsgs;
  }

  function maybeSingleton( stream, key ) {
    console.log(key);
    var v = singletonVars.get(key);
    if (v!= undefined) {
        v.singleton = false;
      
      } else {
        singletonVars.set(key, { 'singleton': true, 
        'from': stream.start, to: stream.pos } );
         
      }
      console.log(singletonVars);
    }

    function outputSingletonVars(stream) {
var key,v;
for ( [key,v] of singletonVars.entries()) {
 if (v!=undefined && v.singleton) {
   mkError(stream,"warning", key+" singleton variable");
 }
    }
    singletonVars.clear();
    console.log("reset");
  }

  //CodeMirror.registerHelper("lint", "prolog", exportErrors);

  /*******************************
   *     CHARACTER ESCAPES    *
   *******************************/

  function readDigits(stream, re, count) {
    if (count > 0) {
      while (count-- > 0) {
        if (!re.test(stream.next()))
          return false;
      }
    } else {
      while (re.test(stream.peek()))
        stream.next();
    }
    return true;
  }

  function readEsc(stream) {
    var next = stream.next();
    if (isSingleEscChar.test(next))
      return true;
    switch (next) {
    case "u":
      if (unicodeEscape)
        return readDigits(stream, isHexDigit, conf.indentUnit); /* SWI */
      return false;
    case "U":
      if (unicodeEscape)
        return readDigits(stream, isHexDigit, 8); /* SWI */
      return false;
    case null:
      return true; /* end of line */
    case "c":
      stream.eatSpace();
      return true;
    case "x":
      return readDigits(stream, isHexDigit, 2);
    }
    if (isOctalDigit.test(next)) {
      if (!readDigits(stream, isOctalDigit, -1))
        return false;
      if (stream.peek() == "\\") /* SWI: optional closing \ */
        stream.next();
      return true;
    }
    return false;
  }

  function nextUntilUnescaped(stream, state, end) {
    var next;
    while ((next = stream.next()) != null) {
      if (next == end && end != stream.peek()) {
        state.nesting.pop();
        return false;
      }
      if (next == "\\") {
        if (!readEsc(stream))
          return false;
      }
    }
    return multiLineQuoted;
  }

  /*******************************
   *    CONTEXT NESTING        *
   *******************************/

  function nesting(state) { return state.nesting.slice(-1)[0]; }

  /* Called on every non-comment token */
  function setArg1(state) {
    var nest = nesting(state);
    if (nest) {
      if (nest.arg == 0) /* nested in a compound */
        nest.arg = 1;
      else if (nest.type == "control")
        state.goalStart = false;
    } else
      state.goalStart = false;
  }

  function setArgAlignment(state) {
    var nest = nesting(state);
    if (nest && !nest.alignment && nest.arg != undefined) {
      if (nest.arg == 0)
        nest.alignment = nest.leftCol ? nest.leftCol + conf.indentUnit
                                      : nest.column + conf.indentUnit;
      else
        nest.alignment = nest.column + 1;
    }
  }

  function nextArg(state) {
    var nest = nesting(state);
    if (nest) {
      if (nest.arg) /* nested in a compound */
        nest.arg++;
      else if (nest.type == "control") {
        state.goalStart = true; /* FIXME: also needed for ; and -> */
      }
    } else {
      state.goalStart = true;
    }
  }

  function isControl(state) { /* our terms are goals */
    var nest = nesting(state);
    if (nest) {
      if (nest.type == "control") {
        return true;
      }
      return false;
    } else
      return state.inBody;
  }

  // Used as scratch variables to communicate multiple values without
  // consing up tons of objects.
  var type; //, content;
  function ret(tp, style, cont) {
    type = tp;
    //  content = cont;
    return style;
  }

  function peekSpace(stream) { /* TBD: handle block comment as space */
    if (stream.eol() || /[\s%]/.test(stream.peek()))
      return true;
    return false;
  }

  /*******************************
   *       SUB TOKENISERS    *
   *******************************/

  function plTokenBase(stream, state) {
    var ch = stream.next();

    state.curToken = ch;

    if (ch == "(") {
      if (state.lastType == "functor") {
        state.nesting.push({
          functor : state.functorName,
          column : stream.column(),
          leftCol : state.functorColumn,
          arg : 0
        });
        delete state.functorName;
        delete state.functorColumn;
      } else {
        state.nesting.push({
          type : "control",
          closeColumn : stream.column(),
          alignment : stream.column() + 3
        });
      }
      return ret("solo", "tag", "(");
    }

    if (ch == "{" && state.lastType == "tag") {
      state.nesting.push({
        tag : state.tagName,
        column : stream.column(),
        leftCol : state.tagColumn,
        arg : 0
      });
      delete state.tagName;
      delete state.tagColumn;
      return ret("dict_open", "bracket");
    }

    if (ch == "/" && stream.eat("*"))
      return chain(stream, state, plTokenComment);

    if (ch == "%") {
      stream.skipToEnd();
      return ret("comment", "comment");
    }

    setArg1(state);

    if (isSoloChar.test(ch)) {
      switch (ch) {
      case ")": {
        state.nesting.pop();
      } break;
      case "]":

        state.nesting.pop();
        return ret("list_close", "bracket");
      case "}": {
        var nest = nesting(state);
        var type = (nest && nest.tag) ? "dict_close" : "brace_term_close";

        state.nesting.pop();
        return ret(type, null);
      } break;
      case ",": 
      {
        if (stream.eol())
          state.commaAtEOL = true;
        nextArg(state);
        /*FALLTHROUGH*/
          if (!state.commaAtEOL)
            stream.eatSpace();
            var nch = stream.peek();
             if ( nch == ';' || nch == ',') {
              mkError(stream, "error", "\",\" followed by "+stream.peek());
              return ret("solo", "error", ",");
            }
            if (isControl(state)) {
              if ("[" != ch ) {
            if (state.inBody ) {
              state.goalStart = true;
            } else {
              mkError(stream, "error", "\",\" followed by "+stream.peek());
              return ret("solo", "error", ",");
            }
          }
        }
        return ret('solo','tag', ",");
      } break;
      case ";":
      if (!state.commaAtEOL)
            stream.eatSpace();
           ch = stream.peek();
      if ( ch == ';' || ch == ',') {
        mkError(stream, "error", "\",\" followed by "+stream.peek());
        return ret("solo", "error", ";");
      }
  if (isControl(state)) {
          if (!state.inBody) {
            mkError(stream, "error", "unexpected ;");
            return ret("solo", "error", ";");
          }
          state.goalStart = true;
        }
        break;
      case "[":
        state.nesting.push({
          type : "list",
          closeColumn : stream.column(),
          alignment : stream.column() + 3
        });
        return ret("list_open", "bracket");
        break;
      case "{":
        if (quasiQuotations && stream.eat("|")) {
          state.nesting.push(
              {type : "quasi-quotation", alignment : stream.column() + 1});
          return ret("qq_open", "bracket");
        } else {
          state.nesting.push({
            type : "curly",
            closeColumn : stream.column(),
            alignment : stream.column() + 2
          });
          return ret("brace_term_open", "bracket");
        }
        break;
      case "|":
        if (quasiQuotations) {
          if (stream.eat("|")) {
            state.tokenize = plTokenQuasiQuotation;
            return ret("qq_sep", "bracket");
          } else if (stream.eat("}")) {
            state.nesting.pop();
            return ret("qq_close", "bracket");
          }
        }
        if (isControl(state)) {
          state.goalStart = true;
        }
        break;
        return ret("solo", "tag", ch);
      }
    }

    if (ch == '"' || ch == "'" || ch == "`") {
      state.nesting.push({type : "quoted", alignment : stream.column() + 1});
      return chain(stream, state, plTokenString(ch));
    }

    if (ch == "0") {
      if (stream.eat(/x/i)) {
        stream.eatWhile(/[\da-f]/i);
        return ret("number", "number");
      }
      if (stream.eat(/o/i)) {
        stream.eatWhile(/[0-7]/i);
        return ret("number", "number");
      }
      if (stream.eat(/'/)) { /* 0' */
        var next = stream.next();
        if (next == "\\") {
          if (!readEsc(stream)) {
            mkError(stream, "error", "bad escape");
            return ret("error", "error");
          }
        }
        return ret("code", "number");
      }
    }

    if (/\d/.test(ch) || /[+-]/.test(ch) && stream.eat(/\d/)) {
      if (groupedIntegers)
        stream.match(/^\d*((_|\s+)\d+)*(?:\.\d+)?(?:[eE][+\-]?\d+)?/);
      else
        stream.match(/^\d*(?:\.\d+)?(?:[eE][+\-]?\d+)?/);
      return ret(ch == "-" ? "neg-number" : ch == "+" ? "-number" : "number",
                 "number");
    }

    if (isSymbolChar.test(ch)) {
      stream.eatWhile(isSymbolChar);
      var atom = stream.current();
      if (atom == "." && (stream.eol() || peekSpace(stream))) {
        if (nesting(state)) {
          mkError(stream, "error", "Clause over before closing all brackets");
          state.nesting = [];
        }
  //  var start = cm_.getCursor("end");
    //cm_.setBookmark(start, {"widget" : document.createTextNode("&bull;")});
        state.inBody = false;
        state.goalStart = true;
        outputSingletonVars(stream);
        stream.eat(ch);
        return ret("fullstop", "def", atom);

      } else {
        if (atom === ":-" && state.headStart) {
	    state.headStart = false;
	     state.inBody = true;
          state.goalStart = true;
          return ret("directive", "attribute", atom);

        } else if (isNeck.test(atom)) {
          state.inBody = true;
          state.goalStart = true;
          return ret("neck", "property", atom);
        } else if (isControl(state) && isControlOp.test(atom)) {
          state.goalStart = true;
          return ret("symbol", "meta", atom);
        } else
          return ret("symbol", "meta", atom);
      }
    }
    stream.eatWhile(/[\w_]/);
    if (composeGoalWithDots) {
      while (stream.peek() == ".") {
        stream.eat('.');
        // a.b() and friends
        if ((ch = stream.peek()) == ' ' || stream.eol()) {
          stream.backUp(1);
          break;

        } else if (/[\w_]/.test(ch)) {
          stream.eatWhile(/[\w_]/);
        } else if (ch == "'") {

          stream.eat();

          stream.eatWhile(/[\w_]/);
          if (ch == ".") {
            mkError(stream, "error", "bad dotted name");
            return ret("atom", "error");
          }
        }
      }
    }
    var word = stream.current();
    state.curToken = word;
    var extra = "";
    if (stream.peek() == "{" && dicts) {
      state.tagName = word; /* tmp state extension */
      state.tagColumn = stream.column();
      return ret("tag", "tag", word);
    } else if ((ch = word[0]) == "_") {
      if (word.length == 1) {
        return ret("var", "variable-2", word);
      } else {
      return ret("var", "variable-2", word);
      }
    } else if (ch.match(/[A-Z]/) ) {
        maybeSingleton(stream,word);
      return ret("var", "variable-1", word);
    }
      if (stream.peek() == "(") {
      state.functorName = word; /* tmp state extension */
      state.functorColumn = stream.column();
      if (state.headStart) {
        state.headStart = false;
        if (state.headFunctor != word) {
          state.headFunctor = word;
          return ret("functor", "def", word);
        }
      }
      if (builtins[word] && isControl(state))
        return ret("functor", "keyword", word);
      return ret("functor", "atom", word);
    } else if ((extra = stream.eatSpace())) {
      if (state.headStart && (stream.peek() == ":" || stream.peek() == "-")) {
        state.headStart = false;
        if (state.headFunctor != word) {
          state.headFunctor = word;
          return ret("functor", "def", word);
        }
      }
      state.functorName = word; /* tmp state extension */
      state.functorColumn = stream.column();
      var w = stream.current();
      if (builtins[word] && isControl(state))
        return ret("functor", "keyword", w);
      return ret("functor", "atom", w);
    } else if ((extra = stream.eat(/\/(\/)?\d\d?/) != "")) {
      state.functorName = word; /* tmp state extension */
      state.functorColumn = stream.column();
      var w = stream.current();
      if (builtins[word] && isControl(state))
        return ret("functor", "keyword", w);
      return ret("functor", "atom", w);
    } else if (builtins[word] && isControl(state)) {
      return ret("atom", "keyword", word);
    }
    return ret("atom", "atom", word);

  }

  function plTokenString(quote) {
    return function(stream, state) {
      if (!nextUntilUnescaped(stream, state, quote)) {
        state.tokenize = plTokenBase;
        if (stream.peek() == "(") { /* 'quoted functor'() */
          var word = stream.current();
          state.functorName = word; /* tmp state extension */
          if (state.headStart) {
            state.headStart = false;
            if (state.headFunctor != word) {
              state.headFunctor = word;
              return ret("functor", "def", word);
            }
          }
          return ret("functor", "atom", word);
        }
        if (stream.peek() == "{" && dicts) { /* 'quoted tag'{} */
          var word = stream.current();
          state.tagName = word; /* tmp state extension */
          return ret("tag", "tag", word);
        }
      }
      return ret(quoteType[quote], "string");
    };
  }

  function plTokenQuasiQuotation(stream, state) {
    var maybeEnd = false, ch;
    while (ch = stream.next()) {
      if (ch == "}" && maybeEnd) {
        state.tokenize = plTokenBase;
        stream.backUp(2);
        break;
      }
      maybeEnd = (ch == "|");
    }
    return ret("qq_content", "string");
  }

  function plTokenComment(stream, state) {
    var maybeEnd = false, ch;
    while (ch = stream.next()) {
      if (ch == "/" && maybeEnd) {
        state.tokenize = plTokenBase;
        break;
      }
      maybeEnd = (ch == "*");
    }
    return ret("comment", "comment");
  }

  /*******************************
   *        ACTIVE KEYS        *
   *******************************/

  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                     - -
Support if-then-else layout like this:

goal :-
(
                                                             Condition
->
IfTrue
;
   IfFalse
).
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - */

  CodeMirror.commands.prologStartIfThenElse = function(cm) {
    var start = cm.getCursor("start");
    var token = cm.getTokenAt(start, true);

    if (token.state.goalStart == true) {
      cm.replaceSelection("(\n", "end");
      return;
    }

    return CodeMirror.Pass;
  };

  CodeMirror.commands.prologStartThen =
      function(cm) {
    var start = cm.getCursor("start");
    var token = cm.getTokenAt(start, true);

    /* FIXME: These functions are copied from prolog.js.  How
                                                    can we reuse these?
             */
    function nesting(state) {
      var len = state.nesting.length;
      if (len > 0)
        return state.nesting[len - 1];
      return null;
    }

    function isControl(state) { /* our terms are goals */
      var nest = nesting(state);
      if (nest) {
        if (nest.type == "control") {
          return true;
        }
        return false;
      } else
        return state.inBody;
    }

    if (start.ch == token.end && token.type == "operator" &&
        token.string == "-" && isControl(token.state)) {
      cm.replaceSelection("\n->\n", "end");
      return;
    }

    return CodeMirror.Pass;
  }

      CodeMirror.commands.prologStartElse =
          function(cm) {
    var start = cm.getCursor("start");
    var token = cm.getTokenAt(start, true);

    if (token.start == 0 && start.ch == token.end && !/\S/.test(token.string)) {
      cm.replaceSelection("\n;\n", "end");
      return;
    }

    return CodeMirror.Pass;
  }

          CodeMirror.commands.prologEndClause =
              function(cm) {
    if (!cm.state.nesting() && !isControl(cm.state)) {
      var start = cm.getCursor("end");
      cm.setBookmark(start, {widget : document.createTextNode("&para;")});
      return;
    }
    return CodeMirror.Pass;
  }

              CodeMirror.defineOption(
                  "prologKeys", true, function(cm, editor, prev) {
                    cm_ = cm;
                    if (prev && prev != CodeMirror.Init)
                      cm.removeKeyMap("prolog");
                    if (true) {
                      var map = {
                        name : "prolog",
                        "Enter '('" : "prologStartIfThenElse",
                        "Enter '-' '>'" : "prologStartThen",
                        "Enter ';'" : "prologStartElse",
                        "Ctrl-L" : "refreshHighlight",
                        "Tab" : "indent"
                      };
                      cm.addKeyMap(map);
                    }
                  });

  // Default (SWI-)Prolog operator table.   To be used later to enhance
  // the offline experience.

  var ops = {
    "-->" : {p : 1200, t : "xfx"},
    ":-" : [ {p : 1200, t : "xfx"}, {p : 1200, t : "fx"} ],
    "?-" : {p : 1200, t : "fx"},

    "dynamic" : {p : 1150, t : "fx"},
    "discontiguous" : {p : 1150, t : "fx"},
    "initialization" : {p : 1150, t : "fx"},
    "meta_predicate" : {p : 1150, t : "fx"},
    "module_transparent" : {p : 1150, t : "fx"},
    "multifile" : {p : 1150, t : "fx"},
    "thread_local" : {p : 1150, t : "fx"},
    "volatile" : {p : 1150, t : "fx"},

    ";" : {p : 1100, t : "xfy"},
    "|" : {p : 1100, t : "xfy"},

    "->" : {p : 1050, t : "xfy"},
    "*->" : {p : 1050, t : "xfy"},

    "," : {p : 1000, t : "xfy"},

    "\\+" : {p : 900, t : "fy"},

    "~" : {p : 900, t : "fx"},

    "<" : {p : 700, t : "xfx"},
    "=" : {p : 700, t : "xfx"},
    "=.." : {p : 700, t : "xfx"},
    "=@=" : {p : 700, t : "xfx"},
    "=:=" : {p : 700, t : "xfx"},
    "=<" : {p : 700, t : "xfx"},
    "==" : {p : 700, t : "xfx"},
    "=\\=" : {p : 700, t : "xfx"},
    ">" : {p : 700, t : "xfx"},
    ">=" : {p : 700, t : "xfx"},
    "@<" : {p : 700, t : "xfx"},
    "@=<" : {p : 700, t : "xfx"},
    "@>" : {p : 700, t : "xfx"},
    "@>=" : {p : 700, t : "xfx"},
    "\\=" : {p : 700, t : "xfx"},
    "\\==" : {p : 700, t : "xfx"},
    "is" : {p : 700, t : "xfx"},

    ":" : {p : 600, t : "xfy"},

    "+" : [ {p : 500, t : "yfx"}, {p : 200, t : "fy"} ],
    "-" : [ {p : 500, t : "yfx"}, {p : 200, t : "fy"} ],
    "/\\" : {p : 500, t : "yfx"},
    "\\/" : {p : 500, t : "yfx"},
    "xor" : {p : 500, t : "yfx"},

    "?" : {p : 500, t : "fx"},

    "*" : {p : 400, t : "yfx"},
    "/" : {p : 400, t : "yfx"},
    "//" : {p : 400, t : "yfx"},
    "rdiv" : {p : 400, t : "yfx"},
    "<<" : {p : 400, t : "yfx"},
    ">>" : {p : 400, t : "yfx"},
    "mod" : {p : 400, t : "yfx"},
    "rem" : {p : 400, t : "yfx"},

    "**" : {p : 200, t : "xfx"},
    "^" : {p : 200, t : "xfy"},

    "\\" : {p : 200, t : "fy"}
  };

  var builtins = {
    "C" : "prolog",
    "abolish" : "prolog",
    "abolish_all_tables" : "prolog",
    "abolish_frozen_choice_points" : "prolog",
    "abolish_module" : "prolog",
    "abolish_table" : "prolog",
    "abort" : "prolog",
    "absolute_file_name" : "prolog",
    "absolute_file_system_path" : "prolog",
    "access" : "prolog",
    "access_file" : "prolog",
    "acyclic_term" : "prolog",
    "add_import_module" : "prolog",
    "add_to_array_element" : "prolog",
    "add_to_path" : "prolog",
    "alarm" : "prolog",
    "all" : "prolog",
    "always_prompt_user" : "prolog",
    "arena_size" : "prolog",
    "arg" : "prolog",
    "array" : "prolog",
    "array_element" : "prolog",
    "assert" : "prolog",
    "assert_static" : "prolog",
    "asserta" : "prolog",
    "asserta_static" : "prolog",
    "assertz" : "prolog",
    "assertz_static" : "prolog",
    "at_end_of_line" : "prolog",
    "at_end_of_stream" : "prolog",
    "at_end_of_stream_0" : "prolog",
    "at_halt" : "prolog",
    "atom" : "prolog",
    "atom_chars" : "prolog",
    "atom_codes" : "prolog",
    "atom_concat" : "prolog",
    "atom_length" : "prolog",
    "atom_number" : "prolog",
    "atom_string" : "prolog",
    "atom_to_term" : "prolog",
    "atomic_concat" : "prolog",
    "atomic_length" : "prolog",
    "atomic_list_concat" : "prolog",
    "atomics_to_string" : "prolog",
    "attvar" : "prolog",
    "b_getval" : "prolog",
    "b_setval" : "prolog",
    "bagof" : "prolog",
    "bb_delete" : "prolog",
    "bb_get" : "prolog",
    "bb_put" : "prolog",
    "bb_update" : "prolog",
    "between" : "prolog",
    "bootstrap" : "prolog",
    "break" : "prolog",
    "call" : "prolog",
    "call_cleanup" : "prolog",
    "call_count" : "prolog",
    "call_count_data" : "prolog",
    "call_count_reset" : "prolog",
    "call_residue" : "prolog",
    "call_residue_vars" : "prolog",
    "call_shared_object_function" : "prolog",
    "call_with_args" : "prolog",
    "callable" : "prolog",
    "catch" : "prolog",
    "catch_ball" : "prolog",
    "cd" : "prolog",
    "cfile_search_path" : "prolog",
    "char_code" : "prolog",
    "char_conversion" : "prolog",
    "char_type" : "prolog",
    "clause" : "prolog",
    "clause_property" : "prolog",
    "close" : "prolog",
    "close_shared_object" : "prolog",
    "close_static_array" : "prolog",
    "code_type" : "prolog",
    "commons_directory" : "prolog",
    "commons_library" : "prolog",
    "compare" : "prolog",
    "compile" : "prolog",
    "compile_expressions" : "prolog",
    "compile_predicates" : "prolog",
    "compound" : "prolog",
    "consult" : "prolog",
    "consult_depth" : "prolog",
    "context_module" : "prolog",
    "copy_term" : "prolog",
    "copy_term_nat" : "prolog",
    "create_mutable" : "prolog",
    "create_prolog_flag" : "prolog",
    "creep_allowed" : "prolog",
    "current_atom" : "prolog",
    "current_char_conversion" : "prolog",
    "current_host" : "prolog",
    "current_input" : "prolog",
    "current_key" : "prolog",
    "current_line_number" : "prolog",
    "current_module" : "prolog",
    "current_mutex" : "prolog",
    "current_op" : "prolog",
    "current_predicate" : "prolog",
    "current_prolog_flag" : "prolog",
    "current_reference_count" : "prolog",
    "current_stream" : "prolog",
    "current_thread" : "prolog",
    "db_files" : "prolog",
    "db_reference" : "prolog",
    "debug" : "prolog",
    "debugging" : "prolog",
    "decrease_reference_count" : "prolog",
    "del_attr" : "prolog",
    "del_attrs" : "prolog",
    "delete_import_module" : "prolog",
    "depth_bound_call" : "prolog",
    "dif" : "prolog",
    "discontiguous" : "prolog",
    "display" : "prolog",
    "do_c_built_in" : "prolog",
    "do_c_built_metacall" : "prolog",
    "do_not_compile_expressions" : "prolog",
    "dule" : "prolog",
    "dum" : "prolog",
    "dump_active_goals" : "prolog",
    "duplicate_term" : "prolog",
    "dynamic" : "prolog",
    "dynamic_predicate" : "prolog",
    "dynamic_update_array" : "prolog",
    "eamconsult" : "prolog",
    "eamtrans" : "prolog",
    "end_of_file" : "prolog",
    "ensure_loaded" : "prolog",
    "erase" : "prolog",
    "eraseall" : "prolog",
    "erased" : "prolog",
    "exists" : "prolog",
    "exists_directory" : "prolog",
    "exists_file" : "prolog",
    "exists_source" : "prolog",
    "exo_files" : "prolog",
    "expand_expr" : "prolog",
    "expand_exprs" : "prolog",
    "expand_file_name" : "prolog",
    "expand_goal" : "prolog",
    "expand_term" : "prolog",
    "expects_dialect" : "prolog",
    "export" : "prolog",
    "export_list" : "prolog",
    "export_resource" : "prolog",
    "extend" : "prolog",
    "fail" : "prolog",
    "false" : "prolog",
    "file_base_name" : "prolog",
    "file_directory_name" : "prolog",
    "file_exists" : "prolog",
    "file_name_extension" : "prolog",
    "file_search_path" : "prolog",
    "file_size" : "prolog",
    "fileerrors" : "prolog",
    "findall" : "prolog",
    "float" : "prolog",
    "flush_output" : "prolog",
    "forall" : "prolog",
    "foreign_directory" : "prolog",
    "format" : "prolog",
    "freeze" : "prolog",
    "freeze_choice_point" : "prolog",
    "frozen" : "prolog",
    "functor" : "prolog",
    "garbage_collect" : "prolog",
    "garbage_collect_atoms" : "prolog",
    "gc" : "prolog",
    "get" : "prolog",
    "get0" : "prolog",
    "get_attr" : "prolog",
    "get_attrs" : "prolog",
    "get_byte" : "prolog",
    "get_char" : "prolog",
    "get_code" : "prolog",
    "get_depth_limit" : "prolog",
    "get_mutable" : "prolog",
    "get_string_code" : "prolog",
    "get_value" : "prolog",
    "getcwd" : "prolog",
    "getenv" : "prolog",
    "global_trie_statistics" : "prolog",
    "ground" : "prolog",
    "grow_heap" : "prolog",
    "grow_stack" : "prolog",
    "halt" : "prolog",
    "heap_space_info" : "prolog",
    "hide_atom" : "prolog",
    "hide_predicate" : "prolog",
    "hostname_address" : "prolog",
    "hread_get_message" : "prolog",
    "hread_signal" : "prolog",
    "if" : "prolog",
    "ignore" : "prolog",
    "import_module" : "prolog",
    "incore" : "prolog",
    "increase_reference_count" : "prolog",
    "init_random_state" : "prolog",
    "initialization" : "prolog",
    "instance" : "prolog",
    "instance_property" : "prolog",
    "int_message" : "prolog",
    "integer" : "prolog",
    "is" : "prolog",
    "is_absolute_file_name" : "prolog",
    "is_list" : "prolog",
    "is_mutable" : "prolog",
    "is_tabled" : "prolog",
    "isinf" : "prolog",
    "isnan" : "prolog",
    "key_erased_statistics" : "prolog",
    "key_statistics" : "prolog",
    "keysort" : "prolog",
    "leash" : "prolog",
    "length" : "prolog",
    "libraries_directories" : "prolog",
    "line_count" : "prolog",
    "listing" : "prolog",
    "load_absolute_foreign_files" : "prolog",
    "load_db" : "prolog",
    "load_files" : "prolog",
    "load_foreign_files" : "prolog",
    "log_event" : "prolog",
    "logsum" : "prolog",
    "ls" : "prolog",
    "ls_imports" : "prolog",
    "make" : "prolog",
    "make_directory" : "prolog",
    "make_library_index" : "prolog",
    "message_queue_create" : "prolog",
    "message_queue_destroy" : "prolog",
    "message_queue_property" : "prolog",
    "message_to_string" : "prolog",
    "mmapped_array" : "prolog",
    "module" : "prolog",
    "module_property" : "prolog",
    "module_state" : "prolog",
    "msort" : "prolog",
    "multifile" : "prolog",
    "must_be_of_type" : "prolog",
    "mutex_create" : "prolog",
    "mutex_property" : "prolog",
    "mutex_unlock_all" : "prolog",
    "name" : "prolog",
    "nb_create" : "prolog",
    "nb_current" : "prolog",
    "nb_delete" : "prolog",
    "nb_getval" : "prolog",
    "nb_linkarg" : "prolog",
    "nb_linkval" : "prolog",
    "nb_set_bit" : "prolog",
    "nb_set_shared_arg" : "prolog",
    "nb_set_shared_val" : "prolog",
    "nb_setarg" : "prolog",
    "nb_setval" : "prolog",
    "new_system_module" : "prolog",
    "nl" : "prolog",
    "no_source" : "prolog",
    "no_style_check" : "prolog",
    "nodebug" : "prolog",
    "nofileeleerrors" : "prolog",
    "nogc" : "prolog",
    "nonvar" : "prolog",
    "nospy" : "prolog",
    "nospyall" : "prolog",
    "not" : "prolog",
    "notrace" : "prolog",
    "nth_clause" : "prolog",
    "nth_instance" : "prolog",
    "number" : "prolog",
    "number_atom" : "prolog",
    "number_chars" : "prolog",
    "number_codes" : "prolog",
    "on_signal" : "prolog",
    "once" : "prolog",
    "op" : "prolog",
    "opaque" : "prolog",
    "open" : "prolog",
    "open_pipe_stream" : "prolog",
    "open_shared_object" : "prolog",
    "opt_statistics" : "prolog",
    "or_statistics" : "prolog",
    "ortray_clause" : "prolog",
    "otherwise" : "prolog",
    "parallel" : "prolog",
    "parallel_findall" : "prolog",
    "parallel_findfirst" : "prolog",
    "parallel_once" : "prolog",
    "path" : "prolog",
    "peek" : "prolog",
    "peek_byte" : "prolog",
    "peek_char" : "prolog",
    "peek_code" : "prolog",
    "phrase" : "prolog",
    "plus" : "prolog",
    "portray_clause" : "prolog",
    "predicate_erased_statistics" : "prolog",
    "predicate_property" : "prolog",
    "predicate_statistics" : "prolog",
    "predmerge" : "prolog",
    "predsort" : "prolog",
    "primitive" : "prolog",
    "print" : "prolog",
    "print_message" : "prolog",
    "print_message_lines" : "prolog",
    "private" : "prolog",
    "profalt" : "prolog",
    "profend" : "prolog",
    "profile_data" : "prolog",
    "profile_reset" : "prolog",
    "profinit" : "prolog",
    "profoff" : "prolog",
    "profon" : "prolog",
    "prolog" : "prolog",
    "prolog_current_frame" : "prolog",
    "prolog_file_name" : "prolog",
    "prolog_file_type" : "prolog",
    "prolog_flag" : "prolog",
    "prolog_flag_property" : "prolog",
    "prolog_initialization" : "prolog",
    "prolog_load_context" : "prolog",
    "prolog_to_os_filename" : "prolog",
    "prompt" : "prolog",
    "prompt1" : "prolog",
    "put" : "prolog",
    "put_attr" : "prolog",
    "put_attrs" : "prolog",
    "put_byte" : "prolog",
    "put_char" : "prolog",
    "put_char1" : "prolog",
    "put_code" : "prolog",
    "putenv" : "prolog",
    "pwd" : "prolog",
    "qend_program" : "prolog",
    "qload_file" : "prolog",
    "qload_module" : "prolog",
    "qpack_clean_up_to_disjunction" : "prolog",
    "qsave_file" : "prolog",
    "qsave_module" : "prolog",
    "qsave_program" : "prolog",
    "raise_exception" : "prolog",
    "rational" : "prolog",
    "rational_term_to_tree" : "prolog",
    "read" : "prolog",
    "read_clause" : "prolog",
    "read_sig" : "prolog",
    "read_term" : "prolog",
    "read_term_from_atom" : "prolog",
    "read_term_from_atomic" : "prolog",
    "read_term_from_string" : "prolog",
    "real_path" : "prolog",
    "reconsult" : "prolog",
    "recorda" : "prolog",
    "recorda_at" : "prolog",
    "recordaifnot" : "prolog",
    "recorded" : "prolog",
    "recordz" : "prolog",
    "recordz_at" : "prolog",
    "recordzifnot" : "prolog",
    "release_random_state" : "prolog",
    "remove_from_path" : "prolog",
    "rename" : "prolog",
    "repeat" : "prolog",
    "reset_static_array" : "prolog",
    "reset_total_choicepoints" : "prolog",
    "resize_static_array" : "prolog",
    "restore" : "prolog",
    "retract" : "prolog",
    "retractall" : "prolog",
    "rmdir" : "prolog",
    "same_file" : "prolog",
    "save_program" : "prolog",
    "see" : "prolog",
    "seeing" : "prolog",
    "seen" : "prolog",
    "set_base_module" : "prolog",
    "set_input" : "prolog",
    "set_output" : "prolog",
    "set_prolog_flag" : "prolog",
    "set_random_state" : "prolog",
    "set_stream" : "prolog",
    "set_stream_position" : "prolog",
    "set_value" : "prolog",
    "setarg" : "prolog",
    "setenv" : "prolog",
    "setof" : "prolog",
    "setup_call_catcher_cleanup" : "prolog",
    "setup_call_cleanup" : "prolog",
    "sformat" : "prolog",
    "sh" : "prolog",
    "show_all_local_tables" : "prolog",
    "show_all_tables" : "prolog",
    "show_global_trie" : "prolog",
    "show_global_trieshow_tabled_predicates" : "prolog",
    "show_low_level_trace" : "prolog",
    "show_table" : "prolog",
    "show_tabled_predicates" : "prolog",
    "showprofres" : "prolog",
    "simple" : "prolog",
    "skip" : "prolog",
    "skip1" : "prolog",
    "socket" : "prolog",
    "socket_accept" : "prolog",
    "socket_bind" : "prolog",
    "socket_close" : "prolog",
    "socket_connect" : "prolog",
    "socket_listen" : "prolog",
    "sort" : "prolog",
    "sort2" : "prolog",
    "source" : "prolog",
    "source_file" : "prolog",
    "source_file_property" : "prolog",
    "source_location" : "prolog",
    "source_mode" : "prolog",
    "source_module" : "prolog",
    "split_path_file" : "prolog",
    "spy" : "prolog",
    "srandom" : "prolog",
    "start_low_level_trace" : "prolog",
    "stash_predicate" : "prolog",
    "static_array" : "prolog",
    "static_array_location" : "prolog",
    "static_array_properties" : "prolog",
    "static_array_to_term" : "prolog",
    "statistics" : "prolog",
    "stop_low_level_trace" : "prolog",
    "stream_position" : "prolog",
    "stream_position_data" : "prolog",
    "stream_property" : "prolog",
    "stream_select" : "prolog",
    "string" : "prolog",
    "string_chars" : "prolog",
    "string_code" : "prolog",
    "string_codes" : "prolog",
    "string_concat" : "prolog",
    "string_length" : "prolog",
    "string_number" : "prolog",
    "string_to_atom" : "prolog",
    "string_to_atomic" : "prolog",
    "string_to_list" : "prolog",
    "strip_module" : "prolog",
    "style_check" : "prolog",
    "sub_atom" : "prolog",
    "sub_string" : "prolog",
    "subsumes_term" : "prolog",
    "succ" : "prolog",
    "sys_debug" : "prolog",
    "system" : "prolog",
    "system_error" : "prolog",
    "system_library" : "prolog",
    "system_module" : "prolog",
    "system_predicate" : "prolog",
    "t_body" : "prolog",
    "t_head" : "prolog",
    "t_hgoal" : "prolog",
    "t_hlist" : "prolog",
    "t_tidy" : "prolog",
    "tab" : "prolog",
    "tab1" : "prolog",
    "table" : "prolog",
    "table_statistics" : "prolog",
    "tabling_mode" : "prolog",
    "tabling_statistics" : "prolog",
    "tell" : "prolog",
    "telling" : "prolog",
    "term_attvars" : "prolog",
    "term_factorized" : "prolog",
    "term_to_atom" : "prolog",
    "term_to_string" : "prolog",
    "term_variables" : "prolog",
    "thread_at_exit" : "prolog",
    "thread_cancel" : "prolog",
    "thread_create" : "prolog",
    "thread_default" : "prolog",
    "thread_defaults" : "prolog",
    "thread_detach" : "prolog",
    "thread_exit" : "prolog",
    "thread_get_message" : "prolog",
    "thread_join" : "prolog",
    "thread_local" : "prolog",
    "thread_peek_message" : "prolog",
    "thread_property" : "prolog",
    "thread_self" : "prolog",
    "thread_send_message" : "prolog",
    "thread_set_default" : "prolog",
    "thread_set_defaults" : "prolog",
    "thread_signal" : "prolog",
    "thread_sleep" : "prolog",
    "thread_statistics" : "prolog",
    "threads" : "prolog",
    "throw" : "prolog",
    "time" : "prolog",
    "time_file" : "prolog",
    "time_file64" : "prolog",
    "told" : "prolog",
    "tolower" : "prolog",
    "total_choicepoints" : "prolog",
    "total_erased" : "prolog",
    "toupper" : "prolog",
    "trace" : "prolog",
    "true" : "prolog",
    "true_file_name" : "prolog",
    "tthread_peek_message" : "prolog",
    "ttyget" : "prolog",
    "ttyget0" : "prolog",
    "ttynl" : "prolog",
    "ttyput" : "prolog",
    "ttyskip" : "prolog",
    "udi" : "prolog",
    "unhide_atom" : "prolog",
    "unify_with_occurs_check" : "prolog",
    "unix" : "prolog",
    "unknown" : "prolog",
    "unload_file" : "prolog",
    "unload_module" : "prolog",
    "unnumbervars" : "prolog",
    "update_array" : "prolog",
    "update_mutable" : "prolog",
    "use_module" : "prolog",
    "use_system_module" : "prolog",
    "user_defined_directive" : "prolog",
    "var" : "prolog",
    "version" : "prolog",
    "volatile" : "prolog",
    "wake_choice_point" : "prolog",
    "when" : "prolog",
    "with_mutex" : "prolog",
    "with_output_to" : "prolog",
    "working_directory" : "prolog",
    "write" : "prolog",
    "write_canonical" : "prolog",
    "write_depth" : "prolog",
    "write_term" : "prolog",
    "writeln" : "prolog",
    "writeq" : "prolog",
    "yap_flag" : "prolog"
  };

  /*******************************
   *       RETURN OBJECT         *
   *******************************/

  var external = {
    startState : function() {
      return {
        tokenize : plTokenBase,
        inBody : false,
        goalStart : false,
        headStart : true,
        headFunctor : "",
        lastType : null,
        nesting : new Array(), /* ([{}]) nesting FIXME: copy this */
        curTerm : null,        /* term index in metainfo */
        curToken : null        /* token in term */
      };
    },
    token : function(stream, state) {
      // var nest;

      if (state.curTerm == null) {
        if (parserConfig.metainfo) {
          state.curTerm = 0;
          state.curToken = 0;
        }
      }

      if (stream.eol()) {
        curLine++;
        delete state.commaAtEOL;
      }

      if (state.tokenize == plTokenBase && stream.eatSpace()) {
        if (stream.eol())
          setArgAlignment(state);
        return null;
      }
      if (state.curLine == null || state.pos == 0)
        rmError(stream);

      var style = state.tokenize(stream, state);
      console.log(state.curToken);

      if (stream.eol()) {
        if (stream.pos > 0)
          setArgAlignment(state);
      }

      state.lastType = type;

      if (builtins[state.curToken] == "prolog")
        return "builtin";
      if (ops[state.curToken])
        return "keyword";

      // if (typeof(parserConfig.enrich) == "function")
      //  style = parserConfig.enrich(stream, state, type, content,
      //  style);

      return style;
    },

    indent : function(state, textAfter) {
      if (state.tokenize == plTokenComment)
        return CodeMirror.Pass;

      var nest;
      if (!state.inBody)
        return 0;
      var ctl = isControl(state);
      if ((nest = nesting(state))) {
        if (!ctl && nest.closeColumn && !state.commaAtEOL)
          return nest.closeColumn;
        if ((textAfter === ']' || textAfter === ')' || textAfter === ').' ||
             textAfter === '->' || textAfter === ';' || textAfter === '*->') &&
            ctl)
          return nest.alignment - 3;
        return nest.alignment;
      }

      return conf.indentUnit;
    },

    electricInput : /^\s*([\}\]\)\;]|\-\>}\*\-\>|\)\.)$/,
    blockCommentStart : "/*", /* continuecomment.js support */
    blockCommentEnd : "*/",
    blockCommentContinue : " * ",
    comment : "%",
    matchBrackets: true
  };
  return external;
});

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