[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/LICENSE
   3  
   4  // Modelica support for CodeMirror, copyright (c) by Lennart Ochel
   5  
   6  (function(mod) {
   7    if (typeof exports == "object" && typeof module == "object") // CommonJS
   8      mod(require("../../lib/codemirror"));
   9    else if (typeof define == "function" && define.amd) // AMD
  10      define(["../../lib/codemirror"], mod);
  11    else // Plain browser env
  12      mod(CodeMirror);
  13  })
  14  
  15  (function(CodeMirror) {
  16    "use strict";
  17  
  18    CodeMirror.defineMode("modelica", function(config, parserConfig) {
  19  
  20      var indentUnit = config.indentUnit;
  21      var keywords = parserConfig.keywords || {};
  22      var builtin = parserConfig.builtin || {};
  23      var atoms = parserConfig.atoms || {};
  24  
  25      var isSingleOperatorChar = /[;=\(:\),{}.*<>+\-\/^\[\]]/;
  26      var isDoubleOperatorChar = /(:=|<=|>=|==|<>|\.\+|\.\-|\.\*|\.\/|\.\^)/;
  27      var isDigit = /[0-9]/;
  28      var isNonDigit = /[_a-zA-Z]/;
  29  
  30      function tokenLineComment(stream, state) {
  31        stream.skipToEnd();
  32        state.tokenize = null;
  33        return "comment";
  34      }
  35  
  36      function tokenBlockComment(stream, state) {
  37        var maybeEnd = false, ch;
  38        while (ch = stream.next()) {
  39          if (maybeEnd && ch == "/") {
  40            state.tokenize = null;
  41            break;
  42          }
  43          maybeEnd = (ch == "*");
  44        }
  45        return "comment";
  46      }
  47  
  48      function tokenString(stream, state) {
  49        var escaped = false, ch;
  50        while ((ch = stream.next()) != null) {
  51          if (ch == '"' && !escaped) {
  52            state.tokenize = null;
  53            state.sol = false;
  54            break;
  55          }
  56          escaped = !escaped && ch == "\\";
  57        }
  58  
  59        return "string";
  60      }
  61  
  62      function tokenIdent(stream, state) {
  63        stream.eatWhile(isDigit);
  64        while (stream.eat(isDigit) || stream.eat(isNonDigit)) { }
  65  
  66  
  67        var cur = stream.current();
  68  
  69        if(state.sol && (cur == "package" || cur == "model" || cur == "when" || cur == "connector")) state.level++;
  70        else if(state.sol && cur == "end" && state.level > 0) state.level--;
  71  
  72        state.tokenize = null;
  73        state.sol = false;
  74  
  75        if (keywords.propertyIsEnumerable(cur)) return "keyword";
  76        else if (builtin.propertyIsEnumerable(cur)) return "builtin";
  77        else if (atoms.propertyIsEnumerable(cur)) return "atom";
  78        else return "variable";
  79      }
  80  
  81      function tokenQIdent(stream, state) {
  82        while (stream.eat(/[^']/)) { }
  83  
  84        state.tokenize = null;
  85        state.sol = false;
  86  
  87        if(stream.eat("'"))
  88          return "variable";
  89        else
  90          return "error";
  91      }
  92  
  93      function tokenUnsignedNumber(stream, state) {
  94        stream.eatWhile(isDigit);
  95        if (stream.eat('.')) {
  96          stream.eatWhile(isDigit);
  97        }
  98        if (stream.eat('e') || stream.eat('E')) {
  99          if (!stream.eat('-'))
 100            stream.eat('+');
 101          stream.eatWhile(isDigit);
 102        }
 103  
 104        state.tokenize = null;
 105        state.sol = false;
 106        return "number";
 107      }
 108  
 109      // Interface
 110      return {
 111        startState: function() {
 112          return {
 113            tokenize: null,
 114            level: 0,
 115            sol: true
 116          };
 117        },
 118  
 119        token: function(stream, state) {
 120          if(state.tokenize != null) {
 121            return state.tokenize(stream, state);
 122          }
 123  
 124          if(stream.sol()) {
 125            state.sol = true;
 126          }
 127  
 128          // WHITESPACE
 129          if(stream.eatSpace()) {
 130            state.tokenize = null;
 131            return null;
 132          }
 133  
 134          var ch = stream.next();
 135  
 136          // LINECOMMENT
 137          if(ch == '/' && stream.eat('/')) {
 138            state.tokenize = tokenLineComment;
 139          }
 140          // BLOCKCOMMENT
 141          else if(ch == '/' && stream.eat('*')) {
 142            state.tokenize = tokenBlockComment;
 143          }
 144          // TWO SYMBOL TOKENS
 145          else if(isDoubleOperatorChar.test(ch+stream.peek())) {
 146            stream.next();
 147            state.tokenize = null;
 148            return "operator";
 149          }
 150          // SINGLE SYMBOL TOKENS
 151          else if(isSingleOperatorChar.test(ch)) {
 152            state.tokenize = null;
 153            return "operator";
 154          }
 155          // IDENT
 156          else if(isNonDigit.test(ch)) {
 157            state.tokenize = tokenIdent;
 158          }
 159          // Q-IDENT
 160          else if(ch == "'" && stream.peek() && stream.peek() != "'") {
 161            state.tokenize = tokenQIdent;
 162          }
 163          // STRING
 164          else if(ch == '"') {
 165            state.tokenize = tokenString;
 166          }
 167          // UNSIGNED_NUMBER
 168          else if(isDigit.test(ch)) {
 169            state.tokenize = tokenUnsignedNumber;
 170          }
 171          // ERROR
 172          else {
 173            state.tokenize = null;
 174            return "error";
 175          }
 176  
 177          return state.tokenize(stream, state);
 178        },
 179  
 180        indent: function(state, textAfter) {
 181          if (state.tokenize != null) return CodeMirror.Pass;
 182  
 183          var level = state.level;
 184          if(/(algorithm)/.test(textAfter)) level--;
 185          if(/(equation)/.test(textAfter)) level--;
 186          if(/(initial algorithm)/.test(textAfter)) level--;
 187          if(/(initial equation)/.test(textAfter)) level--;
 188          if(/(end)/.test(textAfter)) level--;
 189  
 190          if(level > 0)
 191            return indentUnit*level;
 192          else
 193            return 0;
 194        },
 195  
 196        blockCommentStart: "/*",
 197        blockCommentEnd: "*/",
 198        lineComment: "//"
 199      };
 200    });
 201  
 202    function words(str) {
 203      var obj = {}, words = str.split(" ");
 204      for (var i=0; i<words.length; ++i)
 205        obj[words[i]] = true;
 206      return obj;
 207    }
 208  
 209    var modelicaKeywords = "algorithm and annotation assert block break class connect connector constant constrainedby der discrete each else elseif elsewhen encapsulated end enumeration equation expandable extends external false final flow for function if import impure in initial inner input loop model not operator or outer output package parameter partial protected public pure record redeclare replaceable return stream then true type when while within";
 210    var modelicaBuiltin = "abs acos actualStream asin atan atan2 cardinality ceil cos cosh delay div edge exp floor getInstanceName homotopy inStream integer log log10 mod pre reinit rem semiLinear sign sin sinh spatialDistribution sqrt tan tanh";
 211    var modelicaAtoms = "Real Boolean Integer String";
 212  
 213    function def(mimes, mode) {
 214      if (typeof mimes == "string")
 215        mimes = [mimes];
 216  
 217      var words = [];
 218  
 219      function add(obj) {
 220        if (obj)
 221          for (var prop in obj)
 222            if (obj.hasOwnProperty(prop))
 223              words.push(prop);
 224      }
 225  
 226      add(mode.keywords);
 227      add(mode.builtin);
 228      add(mode.atoms);
 229  
 230      if (words.length) {
 231        mode.helperType = mimes[0];
 232        CodeMirror.registerHelper("hintWords", mimes[0], words);
 233      }
 234  
 235      for (var i=0; i<mimes.length; ++i)
 236        CodeMirror.defineMIME(mimes[i], mode);
 237    }
 238  
 239    def(["text/x-modelica"], {
 240      name: "modelica",
 241      keywords: words(modelicaKeywords),
 242      builtin: words(modelicaBuiltin),
 243      atoms: words(modelicaAtoms)
 244    });
 245  });