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
      
      // Yacas mode copyright (c) 2015 by Grzegorz Mazur
      // Loosely based on mathematica mode by Calin Barbat
      
      (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('yacas', function(_config, _parserConfig) {
     
       function words(str) {
         var obj = {}, words = str.split(" ");
         for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
         return obj;
       }
     
       var bodiedOps = words("Assert BackQuote D Defun Deriv For ForEach FromFile " +
                             "FromString Function Integrate InverseTaylor Limit " +
                             "LocalSymbols Macro MacroRule MacroRulePattern " +
                             "NIntegrate Rule RulePattern Subst TD TExplicitSum " +
                             "TSum Taylor Taylor1 Taylor2 Taylor3 ToFile " +
                             "ToStdout ToString TraceRule Until While");
     
       // patterns
       var pFloatForm  = "(?:(?:\\.\\d+|\\d+\\.\\d*|\\d+)(?:[eE][+-]?\\d+)?)";
       var pIdentifier = "(?:[a-zA-Z\\$'][a-zA-Z0-9\\$']*)";
     
       // regular expressions
       var reFloatForm    = new RegExp(pFloatForm);
       var reIdentifier   = new RegExp(pIdentifier);
       var rePattern      = new RegExp(pIdentifier + "?_" + pIdentifier);
       var reFunctionLike = new RegExp(pIdentifier + "\\s*\\(");
     
       function tokenBase(stream, state) {
         var ch;
     
         // get next character
         ch = stream.next();
     
         // string
         if (ch === '"') {
           state.tokenize = tokenString;
           return state.tokenize(stream, state);
         }
     
         // comment
         if (ch === '/') {
           if (stream.eat('*')) {
             state.tokenize = tokenComment;
             return state.tokenize(stream, state);
           }
           if (stream.eat("/")) {
             stream.skipToEnd();
             return "comment";
           }
         }
     
         // go back one character
         stream.backUp(1);
     
         // update scope info
         var m = stream.match(/^(\w+)\s*\(/, false);
         if (m !== null && bodiedOps.hasOwnProperty(m[1]))
           state.scopes.push('bodied');
     
         var scope = currentScope(state);
     
         if (scope === 'bodied' && ch === '[')
           state.scopes.pop();
     
         if (ch === '[' || ch === '{' || ch === '(')
           state.scopes.push(ch);
     
         scope = currentScope(state);
     
         if (scope === '[' && ch === ']' ||
             scope === '{' && ch === '}' ||
             scope === '(' && ch === ')')
           state.scopes.pop();
     
         if (ch === ';') {
           while (scope === 'bodied') {
             state.scopes.pop();
             scope = currentScope(state);
           }
         }
     
         // look for ordered rules
         if (stream.match(/\d+ *#/, true, false)) {
           return 'qualifier';
         }
    
        // look for numbers
        if (stream.match(reFloatForm, true, false)) {
          return 'number';
        }
    
        // look for placeholders
        if (stream.match(rePattern, true, false)) {
          return 'variable-3';
        }
    
        // match all braces separately
        if (stream.match(/(?:\[|\]|{|}|\(|\))/, true, false)) {
          return 'bracket';
        }
    
        // literals looking like function calls
        if (stream.match(reFunctionLike, true, false)) {
          stream.backUp(1);
          return 'variable';
        }
    
        // all other identifiers
        if (stream.match(reIdentifier, true, false)) {
          return 'variable-2';
        }
    
        // operators; note that operators like @@ or /; are matched separately for each symbol.
        if (stream.match(/(?:\\|\+|\-|\*|\/|,|;|\.|:|@|~|=|>|<|&|\||_|`|'|\^|\?|!|%|#)/, true, false)) {
          return 'operator';
        }
    
        // everything else is an error
        return 'error';
      }
    
      function tokenString(stream, state) {
        var next, end = false, escaped = false;
        while ((next = stream.next()) != null) {
          if (next === '"' && !escaped) {
            end = true;
            break;
          }
          escaped = !escaped && next === '\\';
        }
        if (end && !escaped) {
          state.tokenize = tokenBase;
        }
        return 'string';
      };
    
      function tokenComment(stream, state) {
        var prev, next;
        while((next = stream.next()) != null) {
          if (prev === '*' && next === '/') {
            state.tokenize = tokenBase;
            break;
          }
          prev = next;
        }
        return 'comment';
      }
    
      function currentScope(state) {
        var scope = null;
        if (state.scopes.length > 0)
          scope = state.scopes[state.scopes.length - 1];
        return scope;
      }
    
      return {
        startState: function() {
          return {
            tokenize: tokenBase,
            scopes: []
          };
        },
        token: function(stream, state) {
          if (stream.eatSpace()) return null;
          return state.tokenize(stream, state);
        },
        indent: function(state, textAfter) {
          if (state.tokenize !== tokenBase && state.tokenize !== null)
            return CodeMirror.Pass;
    
          var delta = 0;
          if (textAfter === ']' || textAfter === '];' ||
              textAfter === '}' || textAfter === '};' ||
              textAfter === ');')
            delta = -1;
    
          return (state.scopes.length + delta) * _config.indentUnit;
        },
        electricChars: "{}[]();",
        blockCommentStart: "/*",
        blockCommentEnd: "*/",
        lineComment: "//"
      };
    });
    
    CodeMirror.defineMIME('text/x-yacas', {
      name: 'yacas'
    });
    
    });


Download modules/editor/codemirror/mode/yacas/yacas.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.