text: /*
  Copyright (C) 2011 by MarkLogic Corporation
  Author: Mike Brevoort <mike@brevoort.com>
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
  
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  */
  CodeMirror.defineMode("xquery", function() {
  
    // The keywords object is set to the result of this self executing
    // function. Each keyword is a property of the keywords object whose
    // value is {type: atype, style: astyle}
    var keywords = function(){
      // conveinence functions used to build keywords object
      function kw(type) {return {type: type, style: "keyword"};}
      var A = kw("keyword a")
        , B = kw("keyword b")
        , C = kw("keyword c")
        , operator = kw("operator")
        , atom = {type: "atom", style: "atom"}
        , punctuation = {type: "punctuation", style: ""}
        , qualifier = {type: "axis_specifier", style: "qualifier"};
      
      // kwObj is what is return from this function at the end
      var kwObj = {
        'if': A, 'switch': A, 'while': A, 'for': A,
        'else': B, 'then': B, 'try': B, 'finally': B, 'catch': B,
        'element': C, 'attribute': C, 'let': C, 'implements': C, 'import': C, 'module': C, 'namespace': C, 
        'return': C, 'super': C, 'this': C, 'throws': C, 'where': C, 'private': C,      
        ',': punctuation,
        'null': atom, 'fn:false()': atom, 'fn:true()': atom
      };
      
      // a list of 'basic' keywords. For each add a property to kwObj with the value of 
      // {type: basic[i], style: "keyword"} e.g. 'after' --> {type: "after", style: "keyword"}
      var basic = ['after','ancestor','ancestor-or-self','and','as','ascending','assert','attribute','before',
      'by','case','cast','child','comment','declare','default','define','descendant','descendant-or-self',
      'descending','document','document-node','element','else','eq','every','except','external','following',
      'following-sibling','follows','for','function','if','import','in','instance','intersect','item',
      'let','module','namespace','node','node','of','only','or','order','parent','precedes','preceding',
      'preceding-sibling','processing-instruction','ref','return','returns','satisfies','schema','schema-element',
      'self','some','sortby','stable','text','then','to','treat','typeswitch','union','variable','version','where',
      'xquery', 'empty-sequence'];
      for(var i=0, l=basic.length; i < l; i++) { kwObj[basic[i]] = kw(basic[i]);};
      
      // a list of types. For each add a property to kwObj with the value of 
      // {type: "atom", style: "atom"}
      var types = ['xs:string', 'xs:float', 'xs:decimal', 'xs:double', 'xs:integer', 'xs:boolean', 'xs:date', 'xs:dateTime', 
      'xs:time', 'xs:duration', 'xs:dayTimeDuration', 'xs:time', 'xs:yearMonthDuration', 'numeric', 'xs:hexBinary', 
      'xs:base64Binary', 'xs:anyURI', 'xs:QName', 'xs:byte','xs:boolean','xs:anyURI','xf:yearMonthDuration'];
      for(var i=0, l=types.length; i < l; i++) { kwObj[types[i]] = atom;};
      
      // each operator will add a property to kwObj with value of {type: "operator", style: "keyword"}
      var operators = ['eq', 'ne', 'lt', 'le', 'gt', 'ge', ':=', '=', '>', '>=', '<', '<=', '.', '|', '?', 'and', 'or', 'div', 'idiv', 'mod', '*', '/', '+', '-'];
      for(var i=0, l=operators.length; i < l; i++) { kwObj[operators[i]] = operator;};
      
      // each axis_specifiers will add a property to kwObj with value of {type: "axis_specifier", style: "qualifier"}
      var axis_specifiers = ["self::", "attribute::", "child::", "descendant::", "descendant-or-self::", "parent::", 
      "ancestor::", "ancestor-or-self::", "following::", "preceding::", "following-sibling::", "preceding-sibling::"];
      for(var i=0, l=axis_specifiers.length; i < l; i++) { kwObj[axis_specifiers[i]] = qualifier; };
  
      return kwObj;
    }();
  
    // 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 chain(stream, state, f) {
      state.tokenize = f;
      return f(stream, state);
    }
    
    // the primary mode tokenizer
    function tokenBase(stream, state) {
      var ch = stream.next(), 
          mightBeFunction = false,
          isEQName = isEQNameAhead(stream);
      
      // an XML tag (if not in some sub, chained tokenizer)
      if (ch == "<") {
        if(stream.match("!--", true))
          return chain(stream, state, tokenXMLComment);
          
        if(stream.match("![CDATA", false)) {
          state.tokenize = tokenCDATA;
          return ret("tag", "tag");
        }
        
        if(stream.match("?", false)) {
          return chain(stream, state, tokenPreProcessing);
        }
        
        var isclose = stream.eat("/");
        stream.eatSpace();
        var tagName = "", c;
        while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
        
        return chain(stream, state, tokenTag(tagName, isclose));
      }
      // start code block
      else if(ch == "{") {
        pushStateStack(state,{ type: "codeblock"});
        return ret("", "");
      }
      // end code block
      else if(ch == "}") {
        popStateStack(state);
        return ret("", "");
      }
      // if we're in an XML block
      else if(isInXmlBlock(state)) {
        if(ch == ">")
          return ret("tag", "tag");
        else if(ch == "/" && stream.eat(">")) {
          popStateStack(state);
          return ret("tag", "tag");
        }
        else  
          return ret("word", "variable");
      }
      // if a number
      else if (/\d/.test(ch)) {
        stream.match(/^\d*(?:\.\d*)?(?:E[+\-]?\d+)?/);
        return ret("number", "atom");
      }
      // comment start
      else if (ch === "(" && stream.eat(":")) {
        pushStateStack(state, { type: "comment"});
        return chain(stream, state, tokenComment);
      }
      // quoted string
      else if (  !isEQName && (ch === '"' || ch === "'"))
        return chain(stream, state, tokenString(ch));
      // variable
      else if(ch === "$") {
        return chain(stream, state, tokenVariable);
      }
      // assignment
      else if(ch ===":" && stream.eat("=")) {
        return ret("operator", "keyword");
      }
      // open paren
      else if(ch === "(") {
        pushStateStack(state, { type: "paren"});
        return ret("", "");
      }
      // close paren
      else if(ch === ")") {
        popStateStack(state);
        return ret("", "");
      }
      // open paren
      else if(ch === "[") {
        pushStateStack(state, { type: "bracket"});
        return ret("", "");
      }
      // close paren
      else if(ch === "]") {
        popStateStack(state);
        return ret("", "");
      }
      else {
        var known = keywords.propertyIsEnumerable(ch) && keywords[ch];
  
        // if there's a EQName ahead, consume the rest of the string portion, it's likely a function
        if(isEQName && ch === '\"') while(stream.next() !== '"'){}
        if(isEQName && ch === '\'') while(stream.next() !== '\''){}
        
        // gobble up a word if the character is not known
        if(!known) stream.eatWhile(/[\w\$_-]/);
        
        // gobble a colon in the case that is a lib func type call fn:doc
        var foundColon = stream.eat(":");
        
        // if there's not a second colon, gobble another word. Otherwise, it's probably an axis specifier
        // which should get matched as a keyword
        if(!stream.eat(":") && foundColon) {
          stream.eatWhile(/[\w\$_-]/);
        }
        // if the next non whitespace character is an open paren, this is probably a function (if not a keyword of other sort)
        if(stream.match(/^[ \t]*\(/, false)) {
          mightBeFunction = true;
        }
        // is the word a keyword?
        var word = stream.current();
        known = keywords.propertyIsEnumerable(word) && keywords[word];
        
        // if we think it's a function call but not yet known, 
        // set style to variable for now for lack of something better
        if(mightBeFunction && !known) known = {type: "function_call", style: "variable def"};
        
        // if the previous word was element, attribute, axis specifier, this word should be the name of that
        if(isInXmlConstructor(state)) {
          popStateStack(state);
          return ret("word", "variable", word);
        }
        // as previously checked, if the word is element,attribute, axis specifier, call it an "xmlconstructor" and 
        // push the stack so we know to look for it on the next word
        if(word == "element" || word == "attribute" || known.type == "axis_specifier") pushStateStack(state, {type: "xmlconstructor"});
        
        // if the word is known, return the details of that else just call this a generic 'word'
        return known ? ret(known.type, known.style, word) :
                       ret("word", "variable", word);
      }
    }
  
    // handle comments, including nested 
    function tokenComment(stream, state) {
      var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
      while (ch = stream.next()) {
        if (ch == ")" && maybeEnd) {
          if(nestedCount > 0)
            nestedCount--;
          else {
            popStateStack(state);
            break;
          }
        }
        else if(ch == ":" && maybeNested) {
          nestedCount++;
        }
        maybeEnd = (ch == ":");
        maybeNested = (ch == "(");
      }
      
      return ret("comment", "comment");
    }
  
    // tokenizer for string literals
    // optionally pass a tokenizer function to set state.tokenize back to when finished
    function tokenString(quote, f) {
      return function(stream, state) {
        var ch;
  
        if(isInString(state) && stream.current() == quote) {
          popStateStack(state);
          if(f) state.tokenize = f;
          return ret("string", "string");
        }
  
        pushStateStack(state, { type: "string", name: quote, tokenize: tokenString(quote, f) });
  
        // if we're in a string and in an XML block, allow an embedded code block
        if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
          state.tokenize = tokenBase;
          return ret("string", "string"); 
        }
  
        
        while (ch = stream.next()) {
          if (ch ==  quote) {
            popStateStack(state);
            if(f) state.tokenize = f;
            break;
          }
          else {
            // if we're in a string and in an XML block, allow an embedded code block in an attribute
            if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
              state.tokenize = tokenBase;
              return ret("string", "string"); 
            }
  
          }
        }
        
        return ret("string", "string");
      };
    }
    
    // tokenizer for variables
    function tokenVariable(stream, state) {
      var isVariableChar = /[\w\$_-]/;
  
      // a variable may start with a quoted EQName so if the next character is quote, consume to the next quote
      if(stream.eat("\"")) {
        while(stream.next() !== '\"'){};
        stream.eat(":");
      } else {
        stream.eatWhile(isVariableChar);
        if(!stream.match(":=", false)) stream.eat(":");
      }
      stream.eatWhile(isVariableChar);
      state.tokenize = tokenBase;
      return ret("variable", "variable");
    }
    
    // tokenizer for XML tags
    function tokenTag(name, isclose) {
      return function(stream, state) {
        stream.eatSpace();
        if(isclose && stream.eat(">")) {
          popStateStack(state);
          state.tokenize = tokenBase;
          return ret("tag", "tag");
        }
        // self closing tag without attributes?
        if(!stream.eat("/"))
          pushStateStack(state, { type: "tag", name: name, tokenize: tokenBase});
        if(!stream.eat(">")) {
          state.tokenize = tokenAttribute;
          return ret("tag", "tag");
        }
        else {
          state.tokenize = tokenBase;        
        }
        return ret("tag", "tag");
      };
    }
  
    // tokenizer for XML attributes
    function tokenAttribute(stream, state) {
      var ch = stream.next();
      
      if(ch == "/" && stream.eat(">")) {
        if(isInXmlAttributeBlock(state)) popStateStack(state);
        if(isInXmlBlock(state)) popStateStack(state);
        return ret("tag", "tag");
      }
      if(ch == ">") {
        if(isInXmlAttributeBlock(state)) popStateStack(state);
        return ret("tag", "tag");
      }
      if(ch == "=")
        return ret("", "");
      // quoted string
      if (ch == '"' || ch == "'")
        return chain(stream, state, tokenString(ch, tokenAttribute));
  
      if(!isInXmlAttributeBlock(state)) 
        pushStateStack(state, { type: "attribute", name: name, tokenize: tokenAttribute});
  
      stream.eat(/[a-zA-Z_:]/);
      stream.eatWhile(/[-a-zA-Z0-9_:.]/);
      stream.eatSpace();
  
      // the case where the attribute has not value and the tag was closed
      if(stream.match(">", false) || stream.match("/", false)) {
        popStateStack(state);
        state.tokenize = tokenBase;      
      }
  
      return ret("attribute", "attribute");
    }
    
    // handle comments, including nested 
    function tokenXMLComment(stream, state) {
      var ch;
      while (ch = stream.next()) {
        if (ch == "-" && stream.match("->", true)) {
          state.tokenize = tokenBase;        
          return ret("comment", "comment");
        }
      }
    }
  
  
    // handle CDATA
    function tokenCDATA(stream, state) {
      var ch;
      while (ch = stream.next()) {
        if (ch == "]" && stream.match("]", true)) {
          state.tokenize = tokenBase;        
          return ret("comment", "comment");
        }
      }
    }
  
    // handle preprocessing instructions
    function tokenPreProcessing(stream, state) {
      var ch;
      while (ch = stream.next()) {
        if (ch == "?" && stream.match(">", true)) {
          state.tokenize = tokenBase;        
          return ret("comment", "comment meta");
        }
      }
    }
    
    
    // functions to test the current context of the state
    function isInXmlBlock(state) { return isIn(state, "tag"); }
    function isInXmlAttributeBlock(state) { return isIn(state, "attribute"); }
    function isInXmlConstructor(state) { return isIn(state, "xmlconstructor"); }
    function isInString(state) { return isIn(state, "string"); }
  
    function isEQNameAhead(stream) { 
      // assume we've already eaten a quote (")
      if(stream.current() === '"')
        return stream.match(/^[^\"]+\"\:/, false);
      else if(stream.current() === '\'')
        return stream.match(/^[^\"]+\'\:/, false);
      else
        return false;
    }
    
    function isIn(state, type) {
      return (state.stack.length && state.stack[state.stack.length - 1].type == type);    
    }
    
    function pushStateStack(state, newState) {
      state.stack.push(newState);
    }
    
    function popStateStack(state) {
      state.stack.pop();
      var reinstateTokenize = state.stack.length && state.stack[state.stack.length-1].tokenize;
      state.tokenize = reinstateTokenize || tokenBase;
    }
    
    // the interface for the mode API
    return {
      startState: function() {
        return {
          tokenize: tokenBase,
          cc: [],
          stack: []
        };
      },
  
      token: function(stream, state) {
        if (stream.eatSpace()) return null;
        var style = state.tokenize(stream, state);
        return style;
      }
    };
  
  });
  
  CodeMirror.defineMIME("application/xquery", "xquery");
  