[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  (function(mod) {
   5    if (typeof exports == "object" && typeof module == "object") // CommonJS
   6      mod(require("../../lib/codemirror"));
   7    else if (typeof define == "function" && define.amd) // AMD
   8      define(["../../lib/codemirror"], mod);
   9    else // Plain browser env
  10      mod(CodeMirror);
  11  })(function(CodeMirror) {
  12  "use strict";
  13  
  14  CodeMirror.defineMode('mllike', function(_config, parserConfig) {
  15    var words = {
  16      'as': 'keyword',
  17      'do': 'keyword',
  18      'else': 'keyword',
  19      'end': 'keyword',
  20      'exception': 'keyword',
  21      'fun': 'keyword',
  22      'functor': 'keyword',
  23      'if': 'keyword',
  24      'in': 'keyword',
  25      'include': 'keyword',
  26      'let': 'keyword',
  27      'of': 'keyword',
  28      'open': 'keyword',
  29      'rec': 'keyword',
  30      'struct': 'keyword',
  31      'then': 'keyword',
  32      'type': 'keyword',
  33      'val': 'keyword',
  34      'while': 'keyword',
  35      'with': 'keyword'
  36    };
  37  
  38    var extraWords = parserConfig.extraWords || {};
  39    for (var prop in extraWords) {
  40      if (extraWords.hasOwnProperty(prop)) {
  41        words[prop] = parserConfig.extraWords[prop];
  42      }
  43    }
  44    var hintWords = [];
  45    for (var k in words) { hintWords.push(k); }
  46    CodeMirror.registerHelper("hintWords", "mllike", hintWords);
  47  
  48    function tokenBase(stream, state) {
  49      var ch = stream.next();
  50  
  51      if (ch === '"') {
  52        state.tokenize = tokenString;
  53        return state.tokenize(stream, state);
  54      }
  55      if (ch === '{') {
  56        if (stream.eat('|')) {
  57          state.longString = true;
  58          state.tokenize = tokenLongString;
  59          return state.tokenize(stream, state);
  60        }
  61      }
  62      if (ch === '(') {
  63        if (stream.match(/^\*(?!\))/)) {
  64          state.commentLevel++;
  65          state.tokenize = tokenComment;
  66          return state.tokenize(stream, state);
  67        }
  68      }
  69      if (ch === '~' || ch === '?') {
  70        stream.eatWhile(/\w/);
  71        return 'variable-2';
  72      }
  73      if (ch === '`') {
  74        stream.eatWhile(/\w/);
  75        return 'quote';
  76      }
  77      if (ch === '/' && parserConfig.slashComments && stream.eat('/')) {
  78        stream.skipToEnd();
  79        return 'comment';
  80      }
  81      if (/\d/.test(ch)) {
  82        if (ch === '0' && stream.eat(/[bB]/)) {
  83          stream.eatWhile(/[01]/);
  84        } if (ch === '0' && stream.eat(/[xX]/)) {
  85          stream.eatWhile(/[0-9a-fA-F]/)
  86        } if (ch === '0' && stream.eat(/[oO]/)) {
  87          stream.eatWhile(/[0-7]/);
  88        } else {
  89          stream.eatWhile(/[\d_]/);
  90          if (stream.eat('.')) {
  91            stream.eatWhile(/[\d]/);
  92          }
  93          if (stream.eat(/[eE]/)) {
  94            stream.eatWhile(/[\d\-+]/);
  95          }
  96        }
  97        return 'number';
  98      }
  99      if ( /[+\-*&%=<>!?|@\.~:]/.test(ch)) {
 100        return 'operator';
 101      }
 102      if (/[\w\xa1-\uffff]/.test(ch)) {
 103        stream.eatWhile(/[\w\xa1-\uffff]/);
 104        var cur = stream.current();
 105        return words.hasOwnProperty(cur) ? words[cur] : 'variable';
 106      }
 107      return null
 108    }
 109  
 110    function tokenString(stream, state) {
 111      var next, end = false, escaped = false;
 112      while ((next = stream.next()) != null) {
 113        if (next === '"' && !escaped) {
 114          end = true;
 115          break;
 116        }
 117        escaped = !escaped && next === '\\';
 118      }
 119      if (end && !escaped) {
 120        state.tokenize = tokenBase;
 121      }
 122      return 'string';
 123    };
 124  
 125    function tokenComment(stream, state) {
 126      var prev, next;
 127      while(state.commentLevel > 0 && (next = stream.next()) != null) {
 128        if (prev === '(' && next === '*') state.commentLevel++;
 129        if (prev === '*' && next === ')') state.commentLevel--;
 130        prev = next;
 131      }
 132      if (state.commentLevel <= 0) {
 133        state.tokenize = tokenBase;
 134      }
 135      return 'comment';
 136    }
 137  
 138    function tokenLongString(stream, state) {
 139      var prev, next;
 140      while (state.longString && (next = stream.next()) != null) {
 141        if (prev === '|' && next === '}') state.longString = false;
 142        prev = next;
 143      }
 144      if (!state.longString) {
 145        state.tokenize = tokenBase;
 146      }
 147      return 'string';
 148    }
 149  
 150    return {
 151      startState: function() {return {tokenize: tokenBase, commentLevel: 0, longString: false};},
 152      token: function(stream, state) {
 153        if (stream.eatSpace()) return null;
 154        return state.tokenize(stream, state);
 155      },
 156  
 157      blockCommentStart: "(*",
 158      blockCommentEnd: "*)",
 159      lineComment: parserConfig.slashComments ? "//" : null
 160    };
 161  });
 162  
 163  CodeMirror.defineMIME('text/x-ocaml', {
 164    name: 'mllike',
 165    extraWords: {
 166      'and': 'keyword',
 167      'assert': 'keyword',
 168      'begin': 'keyword',
 169      'class': 'keyword',
 170      'constraint': 'keyword',
 171      'done': 'keyword',
 172      'downto': 'keyword',
 173      'external': 'keyword',
 174      'function': 'keyword',
 175      'initializer': 'keyword',
 176      'lazy': 'keyword',
 177      'match': 'keyword',
 178      'method': 'keyword',
 179      'module': 'keyword',
 180      'mutable': 'keyword',
 181      'new': 'keyword',
 182      'nonrec': 'keyword',
 183      'object': 'keyword',
 184      'private': 'keyword',
 185      'sig': 'keyword',
 186      'to': 'keyword',
 187      'try': 'keyword',
 188      'value': 'keyword',
 189      'virtual': 'keyword',
 190      'when': 'keyword',
 191  
 192      // builtins
 193      'raise': 'builtin',
 194      'failwith': 'builtin',
 195      'true': 'builtin',
 196      'false': 'builtin',
 197  
 198      // Pervasives builtins
 199      'asr': 'builtin',
 200      'land': 'builtin',
 201      'lor': 'builtin',
 202      'lsl': 'builtin',
 203      'lsr': 'builtin',
 204      'lxor': 'builtin',
 205      'mod': 'builtin',
 206      'or': 'builtin',
 207  
 208      // More Pervasives
 209      'raise_notrace': 'builtin',
 210      'trace': 'builtin',
 211      'exit': 'builtin',
 212      'print_string': 'builtin',
 213      'print_endline': 'builtin',
 214  
 215       'int': 'type',
 216       'float': 'type',
 217       'bool': 'type',
 218       'char': 'type',
 219       'string': 'type',
 220       'unit': 'type',
 221  
 222       // Modules
 223       'List': 'builtin'
 224    }
 225  });
 226  
 227  CodeMirror.defineMIME('text/x-fsharp', {
 228    name: 'mllike',
 229    extraWords: {
 230      'abstract': 'keyword',
 231      'assert': 'keyword',
 232      'base': 'keyword',
 233      'begin': 'keyword',
 234      'class': 'keyword',
 235      'default': 'keyword',
 236      'delegate': 'keyword',
 237      'do!': 'keyword',
 238      'done': 'keyword',
 239      'downcast': 'keyword',
 240      'downto': 'keyword',
 241      'elif': 'keyword',
 242      'extern': 'keyword',
 243      'finally': 'keyword',
 244      'for': 'keyword',
 245      'function': 'keyword',
 246      'global': 'keyword',
 247      'inherit': 'keyword',
 248      'inline': 'keyword',
 249      'interface': 'keyword',
 250      'internal': 'keyword',
 251      'lazy': 'keyword',
 252      'let!': 'keyword',
 253      'match': 'keyword',
 254      'member': 'keyword',
 255      'module': 'keyword',
 256      'mutable': 'keyword',
 257      'namespace': 'keyword',
 258      'new': 'keyword',
 259      'null': 'keyword',
 260      'override': 'keyword',
 261      'private': 'keyword',
 262      'public': 'keyword',
 263      'return!': 'keyword',
 264      'return': 'keyword',
 265      'select': 'keyword',
 266      'static': 'keyword',
 267      'to': 'keyword',
 268      'try': 'keyword',
 269      'upcast': 'keyword',
 270      'use!': 'keyword',
 271      'use': 'keyword',
 272      'void': 'keyword',
 273      'when': 'keyword',
 274      'yield!': 'keyword',
 275      'yield': 'keyword',
 276  
 277      // Reserved words
 278      'atomic': 'keyword',
 279      'break': 'keyword',
 280      'checked': 'keyword',
 281      'component': 'keyword',
 282      'const': 'keyword',
 283      'constraint': 'keyword',
 284      'constructor': 'keyword',
 285      'continue': 'keyword',
 286      'eager': 'keyword',
 287      'event': 'keyword',
 288      'external': 'keyword',
 289      'fixed': 'keyword',
 290      'method': 'keyword',
 291      'mixin': 'keyword',
 292      'object': 'keyword',
 293      'parallel': 'keyword',
 294      'process': 'keyword',
 295      'protected': 'keyword',
 296      'pure': 'keyword',
 297      'sealed': 'keyword',
 298      'tailcall': 'keyword',
 299      'trait': 'keyword',
 300      'virtual': 'keyword',
 301      'volatile': 'keyword',
 302  
 303      // builtins
 304      'List': 'builtin',
 305      'Seq': 'builtin',
 306      'Map': 'builtin',
 307      'Set': 'builtin',
 308      'Option': 'builtin',
 309      'int': 'builtin',
 310      'string': 'builtin',
 311      'not': 'builtin',
 312      'true': 'builtin',
 313      'false': 'builtin',
 314  
 315      'raise': 'builtin',
 316      'failwith': 'builtin'
 317    },
 318    slashComments: true
 319  });
 320  
 321  
 322  CodeMirror.defineMIME('text/x-sml', {
 323    name: 'mllike',
 324    extraWords: {
 325      'abstype': 'keyword',
 326      'and': 'keyword',
 327      'andalso': 'keyword',
 328      'case': 'keyword',
 329      'datatype': 'keyword',
 330      'fn': 'keyword',
 331      'handle': 'keyword',
 332      'infix': 'keyword',
 333      'infixr': 'keyword',
 334      'local': 'keyword',
 335      'nonfix': 'keyword',
 336      'op': 'keyword',
 337      'orelse': 'keyword',
 338      'raise': 'keyword',
 339      'withtype': 'keyword',
 340      'eqtype': 'keyword',
 341      'sharing': 'keyword',
 342      'sig': 'keyword',
 343      'signature': 'keyword',
 344      'structure': 'keyword',
 345      'where': 'keyword',
 346      'true': 'keyword',
 347      'false': 'keyword',
 348  
 349      // types
 350      'int': 'builtin',
 351      'real': 'builtin',
 352      'string': 'builtin',
 353      'char': 'builtin',
 354      'bool': 'builtin'
 355    },
 356    slashComments: true
 357  });
 358  
 359  });