Last commit: Sun Dec 17 01:14:09 2017 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.


      // 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");
    
    });


Download modules/editor/codemirror/mode/julia/julia.js

History
Sun, 17 Dec 2017 01:14:09 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.