[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  function forEach(arr, f) {
  15    for (var i = 0; i < arr.length; i++) f(arr[i], i)
  16  }
  17  function some(arr, f) {
  18    for (var i = 0; i < arr.length; i++) if (f(arr[i], i)) return true
  19    return false
  20  }
  21  
  22  CodeMirror.defineMode("dylan", function(_config) {
  23    // Words
  24    var words = {
  25      // Words that introduce unnamed definitions like "define interface"
  26      unnamedDefinition: ["interface"],
  27  
  28      // Words that introduce simple named definitions like "define library"
  29      namedDefinition: ["module", "library", "macro",
  30                        "C-struct", "C-union",
  31                        "C-function", "C-callable-wrapper"
  32                       ],
  33  
  34      // Words that introduce type definitions like "define class".
  35      // These are also parameterized like "define method" and are
  36      // appended to otherParameterizedDefinitionWords
  37      typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
  38  
  39      // Words that introduce trickier definitions like "define method".
  40      // These require special definitions to be added to startExpressions
  41      otherParameterizedDefinition: ["method", "function",
  42                                     "C-variable", "C-address"
  43                                    ],
  44  
  45      // Words that introduce module constant definitions.
  46      // These must also be simple definitions and are
  47      // appended to otherSimpleDefinitionWords
  48      constantSimpleDefinition: ["constant"],
  49  
  50      // Words that introduce module variable definitions.
  51      // These must also be simple definitions and are
  52      // appended to otherSimpleDefinitionWords
  53      variableSimpleDefinition: ["variable"],
  54  
  55      // Other words that introduce simple definitions
  56      // (without implicit bodies).
  57      otherSimpleDefinition: ["generic", "domain",
  58                              "C-pointer-type",
  59                              "table"
  60                             ],
  61  
  62      // Words that begin statements with implicit bodies.
  63      statement: ["if", "block", "begin", "method", "case",
  64                  "for", "select", "when", "unless", "until",
  65                  "while", "iterate", "profiling", "dynamic-bind"
  66                 ],
  67  
  68      // Patterns that act as separators in compound statements.
  69      // This may include any general pattern that must be indented
  70      // specially.
  71      separator: ["finally", "exception", "cleanup", "else",
  72                  "elseif", "afterwards"
  73                 ],
  74  
  75      // Keywords that do not require special indentation handling,
  76      // but which should be highlighted
  77      other: ["above", "below", "by", "from", "handler", "in",
  78              "instance", "let", "local", "otherwise", "slot",
  79              "subclass", "then", "to", "keyed-by", "virtual"
  80             ],
  81  
  82      // Condition signaling function calls
  83      signalingCalls: ["signal", "error", "cerror",
  84                       "break", "check-type", "abort"
  85                      ]
  86    };
  87  
  88    words["otherDefinition"] =
  89      words["unnamedDefinition"]
  90      .concat(words["namedDefinition"])
  91      .concat(words["otherParameterizedDefinition"]);
  92  
  93    words["definition"] =
  94      words["typeParameterizedDefinition"]
  95      .concat(words["otherDefinition"]);
  96  
  97    words["parameterizedDefinition"] =
  98      words["typeParameterizedDefinition"]
  99      .concat(words["otherParameterizedDefinition"]);
 100  
 101    words["simpleDefinition"] =
 102      words["constantSimpleDefinition"]
 103      .concat(words["variableSimpleDefinition"])
 104      .concat(words["otherSimpleDefinition"]);
 105  
 106    words["keyword"] =
 107      words["statement"]
 108      .concat(words["separator"])
 109      .concat(words["other"]);
 110  
 111    // Patterns
 112    var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
 113    var symbol = new RegExp("^" + symbolPattern);
 114    var patterns = {
 115      // Symbols with special syntax
 116      symbolKeyword: symbolPattern + ":",
 117      symbolClass: "<" + symbolPattern + ">",
 118      symbolGlobal: "\\*" + symbolPattern + "\\*",
 119      symbolConstant: "\\$" + symbolPattern
 120    };
 121    var patternStyles = {
 122      symbolKeyword: "atom",
 123      symbolClass: "tag",
 124      symbolGlobal: "variable-2",
 125      symbolConstant: "variable-3"
 126    };
 127  
 128    // Compile all patterns to regular expressions
 129    for (var patternName in patterns)
 130      if (patterns.hasOwnProperty(patternName))
 131        patterns[patternName] = new RegExp("^" + patterns[patternName]);
 132  
 133    // Names beginning "with-" and "without-" are commonly
 134    // used as statement macro
 135    patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
 136  
 137    var styles = {};
 138    styles["keyword"] = "keyword";
 139    styles["definition"] = "def";
 140    styles["simpleDefinition"] = "def";
 141    styles["signalingCalls"] = "builtin";
 142  
 143    // protected words lookup table
 144    var wordLookup = {};
 145    var styleLookup = {};
 146  
 147    forEach([
 148      "keyword",
 149      "definition",
 150      "simpleDefinition",
 151      "signalingCalls"
 152    ], function(type) {
 153      forEach(words[type], function(word) {
 154        wordLookup[word] = type;
 155        styleLookup[word] = styles[type];
 156      });
 157    });
 158  
 159  
 160    function chain(stream, state, f) {
 161      state.tokenize = f;
 162      return f(stream, state);
 163    }
 164  
 165    function tokenBase(stream, state) {
 166      // String
 167      var ch = stream.peek();
 168      if (ch == "'" || ch == '"') {
 169        stream.next();
 170        return chain(stream, state, tokenString(ch, "string"));
 171      }
 172      // Comment
 173      else if (ch == "/") {
 174        stream.next();
 175        if (stream.eat("*")) {
 176          return chain(stream, state, tokenComment);
 177        } else if (stream.eat("/")) {
 178          stream.skipToEnd();
 179          return "comment";
 180        }
 181        stream.backUp(1);
 182      }
 183      // Decimal
 184      else if (/[+\-\d\.]/.test(ch)) {
 185        if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) ||
 186            stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) ||
 187            stream.match(/^[+-]?\d+/)) {
 188          return "number";
 189        }
 190      }
 191      // Hash
 192      else if (ch == "#") {
 193        stream.next();
 194        // Symbol with string syntax
 195        ch = stream.peek();
 196        if (ch == '"') {
 197          stream.next();
 198          return chain(stream, state, tokenString('"', "string"));
 199        }
 200        // Binary number
 201        else if (ch == "b") {
 202          stream.next();
 203          stream.eatWhile(/[01]/);
 204          return "number";
 205        }
 206        // Hex number
 207        else if (ch == "x") {
 208          stream.next();
 209          stream.eatWhile(/[\da-f]/i);
 210          return "number";
 211        }
 212        // Octal number
 213        else if (ch == "o") {
 214          stream.next();
 215          stream.eatWhile(/[0-7]/);
 216          return "number";
 217        }
 218        // Token concatenation in macros
 219        else if (ch == '#') {
 220          stream.next();
 221          return "punctuation";
 222        }
 223        // Sequence literals
 224        else if ((ch == '[') || (ch == '(')) {
 225          stream.next();
 226          return "bracket";
 227        // Hash symbol
 228        } else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) {
 229          return "atom";
 230        } else {
 231          stream.eatWhile(/[-a-zA-Z]/);
 232          return "error";
 233        }
 234      } else if (ch == "~") {
 235        stream.next();
 236        ch = stream.peek();
 237        if (ch == "=") {
 238          stream.next();
 239          ch = stream.peek();
 240          if (ch == "=") {
 241            stream.next();
 242            return "operator";
 243          }
 244          return "operator";
 245        }
 246        return "operator";
 247      } else if (ch == ":") {
 248        stream.next();
 249        ch = stream.peek();
 250        if (ch == "=") {
 251          stream.next();
 252          return "operator";
 253        } else if (ch == ":") {
 254          stream.next();
 255          return "punctuation";
 256        }
 257      } else if ("[](){}".indexOf(ch) != -1) {
 258        stream.next();
 259        return "bracket";
 260      } else if (".,".indexOf(ch) != -1) {
 261        stream.next();
 262        return "punctuation";
 263      } else if (stream.match("end")) {
 264        return "keyword";
 265      }
 266      for (var name in patterns) {
 267        if (patterns.hasOwnProperty(name)) {
 268          var pattern = patterns[name];
 269          if ((pattern instanceof Array && some(pattern, function(p) {
 270            return stream.match(p);
 271          })) || stream.match(pattern))
 272            return patternStyles[name];
 273        }
 274      }
 275      if (/[+\-*\/^=<>&|]/.test(ch)) {
 276        stream.next();
 277        return "operator";
 278      }
 279      if (stream.match("define")) {
 280        return "def";
 281      } else {
 282        stream.eatWhile(/[\w\-]/);
 283        // Keyword
 284        if (wordLookup.hasOwnProperty(stream.current())) {
 285          return styleLookup[stream.current()];
 286        } else if (stream.current().match(symbol)) {
 287          return "variable";
 288        } else {
 289          stream.next();
 290          return "variable-2";
 291        }
 292      }
 293    }
 294  
 295    function tokenComment(stream, state) {
 296      var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
 297      while ((ch = stream.next())) {
 298        if (ch == "/" && maybeEnd) {
 299          if (nestedCount > 0) {
 300            nestedCount--;
 301          } else {
 302            state.tokenize = tokenBase;
 303            break;
 304          }
 305        } else if (ch == "*" && maybeNested) {
 306          nestedCount++;
 307        }
 308        maybeEnd = (ch == "*");
 309        maybeNested = (ch == "/");
 310      }
 311      return "comment";
 312    }
 313  
 314    function tokenString(quote, style) {
 315      return function(stream, state) {
 316        var escaped = false, next, end = false;
 317        while ((next = stream.next()) != null) {
 318          if (next == quote && !escaped) {
 319            end = true;
 320            break;
 321          }
 322          escaped = !escaped && next == "\\";
 323        }
 324        if (end || !escaped) {
 325          state.tokenize = tokenBase;
 326        }
 327        return style;
 328      };
 329    }
 330  
 331    // Interface
 332    return {
 333      startState: function() {
 334        return {
 335          tokenize: tokenBase,
 336          currentIndent: 0
 337        };
 338      },
 339      token: function(stream, state) {
 340        if (stream.eatSpace())
 341          return null;
 342        var style = state.tokenize(stream, state);
 343        return style;
 344      },
 345      blockCommentStart: "/*",
 346      blockCommentEnd: "*/"
 347    };
 348  });
 349  
 350  CodeMirror.defineMIME("text/x-dylan", "dylan");
 351  
 352  });