openrat-cms

julia.js (12309B)

---

 // 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("../../lib/codemirror"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
 "use strict";
 
 CodeMirror.defineMode("julia", function(config, parserConf) {
   function wordRegexp(words, end) {
     if (typeof end === "undefined") { end = "\\b"; }
     return new RegExp("^((" + words.join(")|(") + "))" + end);
   }
 
   var octChar = "\\\\[0-7]{1,3}";
   var hexChar = "\\\\x[A-Fa-f0-9]{1,2}";
   var sChar = "\\\\[abefnrtv0%?'\"\\\\]";
   var uChar = "([^\\u0027\\u005C\\uD800-\\uDFFF]|[\\uD800-\\uDFFF][\\uDC00-\\uDFFF])";
 
   var operators = parserConf.operators || wordRegexp([
       "[<>]:", "[<>=]=", "<<=?", ">>>?=?", "=>", "->", "\\/\\/",
       "[\\\\%*+\\-<>!=\\/^|&\\u00F7\\u22BB]=?", "\\?", "\\$", "~", ":",
       "\\u00D7", "\\u2208", "\\u2209", "\\u220B", "\\u220C", "\\u2218",
       "\\u221A", "\\u221B", "\\u2229", "\\u222A", "\\u2260", "\\u2264",
       "\\u2265", "\\u2286", "\\u2288", "\\u228A", "\\u22C5",
       "\\b(in|isa)\\b(?!\.?\\()"], "");
   var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
   var identifiers = parserConf.identifiers ||
       /^[_A-Za-z\u00A1-\u2217\u2219-\uFFFF][\w\u00A1-\u2217\u2219-\uFFFF]*!*/;
 
   var chars = wordRegexp([octChar, hexChar, sChar, uChar], "'");
   var openers = wordRegexp(["begin", "function", "type", "struct", "immutable",
       "let", "macro", "for", "while", "quote", "if", "else", "elseif", "try",
       "finally", "catch", "do"]);
   var closers = wordRegexp(["end", "else", "elseif", "catch", "finally"]);
   var keywords = wordRegexp(["if", "else", "elseif", "while", "for", "begin",
       "let", "end", "do", "try", "catch", "finally", "return", "break",
       "continue", "global", "local", "const", "export", "import", "importall",
       "using", "function", "where", "macro", "module", "baremodule", "struct",
       "type", "mutable", "immutable", "quote", "typealias", "abstract",
       "primitive", "bitstype"]);
   var builtins = wordRegexp(["true", "false", "nothing", "NaN", "Inf"]);
 
   var macro = /^@[_A-Za-z][\w]*/;
   var symbol = /^:[_A-Za-z\u00A1-\uFFFF][\w\u00A1-\uFFFF]*!*/;
   var stringPrefixes = /^(`|([_A-Za-z\u00A1-\uFFFF]*"("")?))/;
 
   function inArray(state) {
     return inGenerator(state, '[')
   }
 
   function inGenerator(state, bracket) {
     var curr = currentScope(state),
         prev = currentScope(state, 1);
     if (typeof(bracket) === "undefined") { bracket = '('; }
     if (curr === bracket || (prev === bracket && curr === "for")) {
       return true;
     }
     return false;
   }
 
   function currentScope(state, n) {
     if (typeof(n) === "undefined") { n = 0; }
     if (state.scopes.length <= n) {
       return null;
     }
     return state.scopes[state.scopes.length - (n + 1)];
   }
 
   // tokenizers
   function tokenBase(stream, state) {
     // Handle multiline comments
     if (stream.match(/^#=/, false)) {
       state.tokenize = tokenComment;
       return state.tokenize(stream, state);
     }
 
     // Handle scope changes
     var leavingExpr = state.leavingExpr;
     if (stream.sol()) {
       leavingExpr = false;
     }
     state.leavingExpr = false;
 
     if (leavingExpr) {
       if (stream.match(/^'+/)) {
         return "operator";
       }
     }
 
     if (stream.match(/\.{4,}/)) {
       return "error";
     } else if (stream.match(/\.{1,3}/)) {
       return "operator";
     }
 
     if (stream.eatSpace()) {
       return null;
     }
 
     var ch = stream.peek();
 
     // Handle single line comments
     if (ch === '#') {
       stream.skipToEnd();
       return "comment";
     }
 
     if (ch === '[') {
       state.scopes.push('[');
     }
 
     if (ch === '(') {
       state.scopes.push('(');
     }
 
     var scope = currentScope(state);
 
     if (inArray(state) && ch === ']') {
       if (scope === "for") { state.scopes.pop(); }
       state.scopes.pop();
       state.leavingExpr = true;
     }
 
     if (inGenerator(state) && ch === ')') {
       if (scope === "for") { state.scopes.pop(); }
       state.scopes.pop();
       state.leavingExpr = true;
     }
 
     if (inArray(state)) {
       if (state.lastToken == "end" && stream.match(/^:/)) {
         return "operator";
       }
       if (stream.match(/^end/)) {
         return "number";
       }
     }
 
     var match;
     if (match = stream.match(openers, false)) {
       state.scopes.push(match[0]);
     }
 
     if (stream.match(closers, false)) {
       state.scopes.pop();
     }
 
     // Handle type annotations
     if (stream.match(/^::(?![:\$])/)) {
       state.tokenize = tokenAnnotation;
       return state.tokenize(stream, state);
     }
 
     // Handle symbols
     if (!leavingExpr && stream.match(symbol) ||
         stream.match(/:([<>]:|<<=?|>>>?=?|->|\/\/|\.{2,3}|[\.\\%*+\-<>!\/^|&]=?|[~\?\$])/)) {
       return "builtin";
     }
 
     // Handle parametric types
     //if (stream.match(/^{[^}]*}(?=\()/)) {
     //  return "builtin";
     //}
 
     // Handle operators and Delimiters
     if (stream.match(operators)) {
       return "operator";
     }
 
     // Handle Number Literals
     if (stream.match(/^\.?\d/, false)) {
       var imMatcher = RegExp(/^im\b/);
       var numberLiteral = false;
       // Floats
       if (stream.match(/^\d*\.(?!\.)\d*([Eef][\+\-]?\d+)?/i)) { numberLiteral = true; }
       if (stream.match(/^\d+\.(?!\.)\d*/)) { numberLiteral = true; }
       if (stream.match(/^\.\d+/)) { numberLiteral = true; }
       if (stream.match(/^0x\.[0-9a-f]+p[\+\-]?\d+/i)) { numberLiteral = true; }
       // Integers
       if (stream.match(/^0x[0-9a-f]+/i)) { numberLiteral = true; } // Hex
       if (stream.match(/^0b[01]+/i)) { numberLiteral = true; } // Binary
       if (stream.match(/^0o[0-7]+/i)) { numberLiteral = true; } // Octal
       if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) { numberLiteral = true; } // Decimal
       // Zero by itself with no other piece of number.
       if (stream.match(/^0(?![\dx])/i)) { numberLiteral = true; }
       if (numberLiteral) {
           // Integer literals may be "long"
           stream.match(imMatcher);
           state.leavingExpr = true;
           return "number";
       }
     }
 
     // Handle Chars
     if (stream.match(/^'/)) {
       state.tokenize = tokenChar;
       return state.tokenize(stream, state);
     }
 
     // Handle Strings
     if (stream.match(stringPrefixes)) {
       state.tokenize = tokenStringFactory(stream.current());
       return state.tokenize(stream, state);
     }
 
     if (stream.match(macro)) {
       return "meta";
     }
 
     if (stream.match(delimiters)) {
       return null;
     }
 
     if (stream.match(keywords)) {
       return "keyword";
     }
 
     if (stream.match(builtins)) {
       return "builtin";
     }
 
     var isDefinition = state.isDefinition || state.lastToken == "function" ||
                        state.lastToken == "macro" || state.lastToken == "type" ||
                        state.lastToken == "struct" || state.lastToken == "immutable";
 
     if (stream.match(identifiers)) {
       if (isDefinition) {
         if (stream.peek() === '.') {
           state.isDefinition = true;
           return "variable";
         }
         state.isDefinition = false;
         return "def";
       }
       if (stream.match(/^({[^}]*})*\(/, false)) {
         state.tokenize = tokenCallOrDef;
         return state.tokenize(stream, state);
       }
       state.leavingExpr = true;
       return "variable";
     }
 
     // Handle non-detected items
     stream.next();
     return "error";
   }
 
   function tokenCallOrDef(stream, state) {
     var match = stream.match(/^(\(\s*)/);
     if (match) {
       if (state.firstParenPos < 0)
         state.firstParenPos = state.scopes.length;
       state.scopes.push('(');
       state.charsAdvanced += match[1].length;
     }
     if (currentScope(state) == '(' && stream.match(/^\)/)) {
       state.scopes.pop();
       state.charsAdvanced += 1;
       if (state.scopes.length <= state.firstParenPos) {
         var isDefinition = stream.match(/^(\s*where\s+[^\s=]+)*\s*?=(?!=)/, false);
         stream.backUp(state.charsAdvanced);
         state.firstParenPos = -1;
         state.charsAdvanced = 0;
         state.tokenize = tokenBase;
         if (isDefinition)
           return "def";
         return "builtin";
       }
     }
     // Unfortunately javascript does not support multiline strings, so we have
     // to undo anything done upto here if a function call or definition splits
     // over two or more lines.
     if (stream.match(/^$/g, false)) {
       stream.backUp(state.charsAdvanced);
       while (state.scopes.length > state.firstParenPos)
         state.scopes.pop();
       state.firstParenPos = -1;
       state.charsAdvanced = 0;
       state.tokenize = tokenBase;
       return "builtin";
     }
     state.charsAdvanced += stream.match(/^([^()]*)/)[1].length;
     return state.tokenize(stream, state);
   }
 
   function tokenAnnotation(stream, state) {
     stream.match(/.*?(?=,|;|{|}|\(|\)|=|$|\s)/);
     if (stream.match(/^{/)) {
       state.nestedLevels++;
     } else if (stream.match(/^}/)) {
       state.nestedLevels--;
     }
     if (state.nestedLevels > 0) {
       stream.match(/.*?(?={|})/) || stream.next();
     } else if (state.nestedLevels == 0) {
       state.tokenize = tokenBase;
     }
     return "builtin";
   }
 
   function tokenComment(stream, state) {
     if (stream.match(/^#=/)) {
       state.nestedLevels++;
     }
     if (!stream.match(/.*?(?=(#=|=#))/)) {
       stream.skipToEnd();
     }
     if (stream.match(/^=#/)) {
       state.nestedLevels--;
       if (state.nestedLevels == 0)
         state.tokenize = tokenBase;
     }
     return "comment";
   }
 
   function tokenChar(stream, state) {
     var isChar = false, match;
     if (stream.match(chars)) {
       isChar = true;
     } else if (match = stream.match(/\\u([a-f0-9]{1,4})(?=')/i)) {
       var value = parseInt(match[1], 16);
       if (value <= 55295 || value >= 57344) { // (U+0,U+D7FF), (U+E000,U+FFFF)
         isChar = true;
         stream.next();
       }
     } else if (match = stream.match(/\\U([A-Fa-f0-9]{5,8})(?=')/)) {
       var value = parseInt(match[1], 16);
       if (value <= 1114111) { // U+10FFFF
         isChar = true;
         stream.next();
       }
     }
     if (isChar) {
       state.leavingExpr = true;
       state.tokenize = tokenBase;
       return "string";
     }
     if (!stream.match(/^[^']+(?=')/)) { stream.skipToEnd(); }
     if (stream.match(/^'/)) { state.tokenize = tokenBase; }
     return "error";
   }
 
   function tokenStringFactory(delimiter) {
     if (delimiter.substr(-3) === '"""') {
       delimiter = '"""';
     } else if (delimiter.substr(-1) === '"') {
       delimiter = '"';
     }
     function tokenString(stream, state) {
       if (stream.eat('\\')) {
         stream.next();
       } else if (stream.match(delimiter)) {
         state.tokenize = tokenBase;
         state.leavingExpr = true;
         return "string";
       } else {
         stream.eat(/[`"]/);
       }
       stream.eatWhile(/[^\\`"]/);
       return "string";
     }
     return tokenString;
   }
 
   var external = {
     startState: function() {
       return {
         tokenize: tokenBase,
         scopes: [],
         lastToken: null,
         leavingExpr: false,
         isDefinition: false,
         nestedLevels: 0,
         charsAdvanced: 0,
         firstParenPos: -1
       };
     },
 
     token: function(stream, state) {
       var style = state.tokenize(stream, state);
       var current = stream.current();
 
       if (current && style) {
         state.lastToken = current;
       }
 
       return style;
     },
 
     indent: function(state, textAfter) {
       var delta = 0;
       if ( textAfter === ']' || textAfter === ')' || textAfter === "end" ||
            textAfter === "else" || textAfter === "catch" || textAfter === "elseif" ||
            textAfter === "finally" ) {
         delta = -1;
       }
       return (state.scopes.length + delta) * config.indentUnit;
     },
 
     electricInput: /\b(end|else|catch|finally)\b/,
     blockCommentStart: "#=",
     blockCommentEnd: "=#",
     lineComment: "#",
     fold: "indent"
   };
   return external;
 });
 
 
 CodeMirror.defineMIME("text/x-julia", "julia");
 
 });