[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("haskell", function(_config, modeConfig) {
  15  
  16    function switchState(source, setState, f) {
  17      setState(f);
  18      return f(source, setState);
  19    }
  20  
  21    // These should all be Unicode extended, as per the Haskell 2010 report
  22    var smallRE = /[a-z_]/;
  23    var largeRE = /[A-Z]/;
  24    var digitRE = /\d/;
  25    var hexitRE = /[0-9A-Fa-f]/;
  26    var octitRE = /[0-7]/;
  27    var idRE = /[a-z_A-Z0-9'\xa1-\uffff]/;
  28    var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:]/;
  29    var specialRE = /[(),;[\]`{}]/;
  30    var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
  31  
  32    function normal(source, setState) {
  33      if (source.eatWhile(whiteCharRE)) {
  34        return null;
  35      }
  36  
  37      var ch = source.next();
  38      if (specialRE.test(ch)) {
  39        if (ch == '{' && source.eat('-')) {
  40          var t = "comment";
  41          if (source.eat('#')) {
  42            t = "meta";
  43          }
  44          return switchState(source, setState, ncomment(t, 1));
  45        }
  46        return null;
  47      }
  48  
  49      if (ch == '\'') {
  50        if (source.eat('\\')) {
  51          source.next();  // should handle other escapes here
  52        }
  53        else {
  54          source.next();
  55        }
  56        if (source.eat('\'')) {
  57          return "string";
  58        }
  59        return "string error";
  60      }
  61  
  62      if (ch == '"') {
  63        return switchState(source, setState, stringLiteral);
  64      }
  65  
  66      if (largeRE.test(ch)) {
  67        source.eatWhile(idRE);
  68        if (source.eat('.')) {
  69          return "qualifier";
  70        }
  71        return "variable-2";
  72      }
  73  
  74      if (smallRE.test(ch)) {
  75        source.eatWhile(idRE);
  76        return "variable";
  77      }
  78  
  79      if (digitRE.test(ch)) {
  80        if (ch == '0') {
  81          if (source.eat(/[xX]/)) {
  82            source.eatWhile(hexitRE); // should require at least 1
  83            return "integer";
  84          }
  85          if (source.eat(/[oO]/)) {
  86            source.eatWhile(octitRE); // should require at least 1
  87            return "number";
  88          }
  89        }
  90        source.eatWhile(digitRE);
  91        var t = "number";
  92        if (source.match(/^\.\d+/)) {
  93          t = "number";
  94        }
  95        if (source.eat(/[eE]/)) {
  96          t = "number";
  97          source.eat(/[-+]/);
  98          source.eatWhile(digitRE); // should require at least 1
  99        }
 100        return t;
 101      }
 102  
 103      if (ch == "." && source.eat("."))
 104        return "keyword";
 105  
 106      if (symbolRE.test(ch)) {
 107        if (ch == '-' && source.eat(/-/)) {
 108          source.eatWhile(/-/);
 109          if (!source.eat(symbolRE)) {
 110            source.skipToEnd();
 111            return "comment";
 112          }
 113        }
 114        var t = "variable";
 115        if (ch == ':') {
 116          t = "variable-2";
 117        }
 118        source.eatWhile(symbolRE);
 119        return t;
 120      }
 121  
 122      return "error";
 123    }
 124  
 125    function ncomment(type, nest) {
 126      if (nest == 0) {
 127        return normal;
 128      }
 129      return function(source, setState) {
 130        var currNest = nest;
 131        while (!source.eol()) {
 132          var ch = source.next();
 133          if (ch == '{' && source.eat('-')) {
 134            ++currNest;
 135          }
 136          else if (ch == '-' && source.eat('}')) {
 137            --currNest;
 138            if (currNest == 0) {
 139              setState(normal);
 140              return type;
 141            }
 142          }
 143        }
 144        setState(ncomment(type, currNest));
 145        return type;
 146      };
 147    }
 148  
 149    function stringLiteral(source, setState) {
 150      while (!source.eol()) {
 151        var ch = source.next();
 152        if (ch == '"') {
 153          setState(normal);
 154          return "string";
 155        }
 156        if (ch == '\\') {
 157          if (source.eol() || source.eat(whiteCharRE)) {
 158            setState(stringGap);
 159            return "string";
 160          }
 161          if (source.eat('&')) {
 162          }
 163          else {
 164            source.next(); // should handle other escapes here
 165          }
 166        }
 167      }
 168      setState(normal);
 169      return "string error";
 170    }
 171  
 172    function stringGap(source, setState) {
 173      if (source.eat('\\')) {
 174        return switchState(source, setState, stringLiteral);
 175      }
 176      source.next();
 177      setState(normal);
 178      return "error";
 179    }
 180  
 181  
 182    var wellKnownWords = (function() {
 183      var wkw = {};
 184      function setType(t) {
 185        return function () {
 186          for (var i = 0; i < arguments.length; i++)
 187            wkw[arguments[i]] = t;
 188        };
 189      }
 190  
 191      setType("keyword")(
 192        "case", "class", "data", "default", "deriving", "do", "else", "foreign",
 193        "if", "import", "in", "infix", "infixl", "infixr", "instance", "let",
 194        "module", "newtype", "of", "then", "type", "where", "_");
 195  
 196      setType("keyword")(
 197        "\.\.", ":", "::", "=", "\\", "<-", "->", "@", "~", "=>");
 198  
 199      setType("builtin")(
 200        "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<*", "<=",
 201        "<$>", "<*>", "=<<", "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*",
 202        "*>", "**");
 203  
 204      setType("builtin")(
 205        "Applicative", "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum",
 206        "Eq", "False", "FilePath", "Float", "Floating", "Fractional", "Functor",
 207        "GT", "IO", "IOError", "Int", "Integer", "Integral", "Just", "LT", "Left",
 208        "Maybe", "Monad", "Nothing", "Num", "Ord", "Ordering", "Rational", "Read",
 209        "ReadS", "Real", "RealFloat", "RealFrac", "Right", "Show", "ShowS",
 210        "String", "True");
 211  
 212      setType("builtin")(
 213        "abs", "acos", "acosh", "all", "and", "any", "appendFile", "asTypeOf",
 214        "asin", "asinh", "atan", "atan2", "atanh", "break", "catch", "ceiling",
 215        "compare", "concat", "concatMap", "const", "cos", "cosh", "curry",
 216        "cycle", "decodeFloat", "div", "divMod", "drop", "dropWhile", "either",
 217        "elem", "encodeFloat", "enumFrom", "enumFromThen", "enumFromThenTo",
 218        "enumFromTo", "error", "even", "exp", "exponent", "fail", "filter",
 219        "flip", "floatDigits", "floatRadix", "floatRange", "floor", "fmap",
 220        "foldl", "foldl1", "foldr", "foldr1", "fromEnum", "fromInteger",
 221        "fromIntegral", "fromRational", "fst", "gcd", "getChar", "getContents",
 222        "getLine", "head", "id", "init", "interact", "ioError", "isDenormalized",
 223        "isIEEE", "isInfinite", "isNaN", "isNegativeZero", "iterate", "last",
 224        "lcm", "length", "lex", "lines", "log", "logBase", "lookup", "map",
 225        "mapM", "mapM_", "max", "maxBound", "maximum", "maybe", "min", "minBound",
 226        "minimum", "mod", "negate", "not", "notElem", "null", "odd", "or",
 227        "otherwise", "pi", "pred", "print", "product", "properFraction", "pure",
 228        "putChar", "putStr", "putStrLn", "quot", "quotRem", "read", "readFile",
 229        "readIO", "readList", "readLn", "readParen", "reads", "readsPrec",
 230        "realToFrac", "recip", "rem", "repeat", "replicate", "return", "reverse",
 231        "round", "scaleFloat", "scanl", "scanl1", "scanr", "scanr1", "seq",
 232        "sequence", "sequence_", "show", "showChar", "showList", "showParen",
 233        "showString", "shows", "showsPrec", "significand", "signum", "sin",
 234        "sinh", "snd", "span", "splitAt", "sqrt", "subtract", "succ", "sum",
 235        "tail", "take", "takeWhile", "tan", "tanh", "toEnum", "toInteger",
 236        "toRational", "truncate", "uncurry", "undefined", "unlines", "until",
 237        "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
 238        "zip3", "zipWith", "zipWith3");
 239  
 240      var override = modeConfig.overrideKeywords;
 241      if (override) for (var word in override) if (override.hasOwnProperty(word))
 242        wkw[word] = override[word];
 243  
 244      return wkw;
 245    })();
 246  
 247  
 248  
 249    return {
 250      startState: function ()  { return { f: normal }; },
 251      copyState:  function (s) { return { f: s.f }; },
 252  
 253      token: function(stream, state) {
 254        var t = state.f(stream, function(s) { state.f = s; });
 255        var w = stream.current();
 256        return wellKnownWords.hasOwnProperty(w) ? wellKnownWords[w] : t;
 257      },
 258  
 259      blockCommentStart: "{-",
 260      blockCommentEnd: "-}",
 261      lineComment: "--"
 262    };
 263  
 264  });
 265  
 266  CodeMirror.defineMIME("text/x-haskell", "haskell");
 267  
 268  });