ext/scintilla/src/LexHaskell.cxx

   1 /******************************************************************
   2  *    LexHaskell.cxx
   3  *
   4  *    A haskell lexer for the scintilla code control.
   5  *    Some stuff "lended" from LexPython.cxx and LexCPP.cxx.
   6  *    External lexer stuff inspired from the caml external lexer.
   7  *
   8  *    Written by Tobias Engvall - tumm at dtek dot chalmers dot se
   9  *
  10  *
  11  *    TODO:
  12  *    * Implement a folder :)
  13  *    * Nice Character-lexing (stuff inside '\''), LexPython has
  14  *      this.
  15  *
  16  *
  17  *****************************************************************/
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <ctype.h>
  22 #include <stdio.h>
  23 #include <stdarg.h>
  24
  25 #include "Platform.h"
  26
  27 #include "PropSet.h"
  28 #include "Accessor.h"
  29 #include "StyleContext.h"
  30 #include "KeyWords.h"
  31 #include "Scintilla.h"
  32 #include "SciLexer.h"
  33
  34 #ifdef SCI_NAMESPACE
  35 using namespace Scintilla;
  36 #endif
  37
  38 #ifdef BUILD_AS_EXTERNAL_LEXER
  39
  40 #include "ExternalLexer.h"
  41 #include "WindowAccessor.h"
  42
  43 #define BUILD_EXTERNAL_LEXER 0
  44
  45 #endif
  46
  47 // Max level of nested comments
  48 #define SCE_HA_COMMENTMAX SCE_HA_COMMENTBLOCK3
  49
  50
  51 enum kwType { kwOther, kwClass, kwData, kwInstance, kwImport, kwModule, kwType};
  52
  53 static inline bool IsNewline(const int ch) {
  54    return (ch == '\n' || ch == '\r');
  55 }
  56
  57 static inline bool IsWhitespace(const int ch) {
  58    return (  ch == ' '
  59           || ch == '\t'
  60           || IsNewline(ch) );
  61 }
  62
  63 static inline bool IsAWordStart(const int ch) {
  64    return (ch < 0x80) && (isalnum(ch) || ch == '_');
  65 }
  66
  67 static inline bool IsAWordChar(const int ch) {
  68    return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\'');
  69 }
  70
  71 static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle,
  72                                WordList *keywordlists[], Accessor &styler) {
  73
  74    WordList &keywords = *keywordlists[0];
  75
  76    int kwLast = kwOther;
  77
  78    StyleContext sc(startPos, length, initStyle, styler);
  79
  80    for (; sc.More(); sc.Forward()) {
  81
  82       // Check for state end
  83          // Operator
  84       if (sc.state == SCE_HA_OPERATOR) {
  85          kwLast = kwOther;
  86          sc.SetState(SCE_HA_DEFAULT);
  87       }
  88          // String
  89       else if (sc.state == SCE_HA_STRING) {
  90          if (sc.ch == '\"') {
  91             sc.ForwardSetState(SCE_HA_DEFAULT);
  92          } else if (sc.ch == '\\') {
  93             sc.Forward();
  94          }
  95       }
  96          // Char
  97       else if (sc.state == SCE_HA_CHARACTER) {
  98          if (sc.ch == '\'') {
  99             sc.ForwardSetState(SCE_HA_DEFAULT);
 100          } else if (sc.ch == '\\') {
 101             sc.Forward();
 102          }
 103       }
 104          // Number
 105       else if (sc.state == SCE_HA_NUMBER) {
 106          if (!IsADigit(sc.ch)) {
 107             sc.SetState(SCE_HA_DEFAULT);
 108          }
 109       }
 110          // Types, constructors, etc.
 111       else if (sc.state == SCE_HA_CAPITAL) {
 112          if (!IsAWordChar(sc.ch) || sc.ch == '.') {
 113             sc.SetState(SCE_HA_DEFAULT);
 114          }
 115       }
 116          // Identifier
 117       else if (sc.state == SCE_HA_IDENTIFIER) {
 118          if (!IsAWordChar(sc.ch)) {
 119             char s[100];
 120             sc.GetCurrent(s, sizeof(s));
 121             int style = SCE_HA_IDENTIFIER;
 122             if ((kwLast == kwImport) || (strcmp(s,"qualified") == 0) || (strcmp(s,"as") == 0)) {
 123                style = SCE_HA_IMPORT;
 124             } else if (keywords.InList(s)) {
 125                style = SCE_HA_KEYWORD;
 126             } else if (kwLast == kwData) {
 127                style = SCE_HA_DATA;
 128             } else if (kwLast == kwClass) {
 129                style = SCE_HA_CLASS;
 130             } else if (kwLast == kwModule) {
 131                style = SCE_HA_MODULE;
 132             } else if (isupper(s[0])) {
 133                style = SCE_HA_CAPITAL;
 134             }
 135             sc.ChangeState(style);
 136             sc.SetState(SCE_HA_DEFAULT);
 137             if (style == SCE_HA_KEYWORD) {
 138                if (0 == strcmp(s, "class"))
 139                   kwLast = kwClass;
 140                else if (0 == strcmp(s, "data"))
 141                   kwLast = kwData;
 142                else if (0 == strcmp(s, "instance"))
 143                   kwLast = kwInstance;
 144                else if (0 == strcmp(s, "import"))
 145                   kwLast = kwImport;
 146                else if (0 == strcmp(s, "module"))
 147                   kwLast = kwModule;
 148                else
 149                   kwLast = kwOther;
 150             } else if (style == SCE_HA_CLASS || style == SCE_HA_IMPORT ||
 151                        style == SCE_HA_MODULE || style == SCE_HA_CAPITAL ||
 152                        style == SCE_HA_DATA || style == SCE_HA_INSTANCE) {
 153                kwLast = kwOther;
 154             }
 155          }
 156       }
 157          // Comments
 158             // Oneliner
 159       else if (sc.state == SCE_HA_COMMENTLINE) {
 160          if (IsNewline(sc.ch))
 161             sc.SetState(SCE_HA_DEFAULT);
 162       }
 163             // Nested
 164       else if (sc.state >= SCE_HA_COMMENTBLOCK) {
 165          if (sc.Match("{-")) {
 166             if (sc.state < SCE_HA_COMMENTMAX)
 167                sc.SetState(sc.state + 1);
 168          }
 169          else if (sc.Match("-}")) {
 170             sc.Forward();
 171             if (sc.state == SCE_HA_COMMENTBLOCK)
 172                sc.ForwardSetState(SCE_HA_DEFAULT);
 173             else
 174                sc.ForwardSetState(sc.state - 1);
 175          }
 176       }
 177       // New state?
 178       if (sc.state == SCE_HA_DEFAULT) {
 179          // Digit
 180          if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
 181             sc.SetState(SCE_HA_NUMBER);
 182             if (sc.ch == '0' && (sc.chNext == 'X' || sc.chNext == 'x')) { // Match anything starting with "0x" or "0X", too
 183                sc.Forward(1);
 184             }
 185          }
 186          // Comment line
 187          else if (sc.Match("--")) {
 188             sc.SetState(SCE_HA_COMMENTLINE);
 189          // Comment block
 190          }
 191          else if (sc.Match("{-")) {
 192             sc.SetState(SCE_HA_COMMENTBLOCK);
 193          }
 194          // String
 195          else if (sc.Match('\"')) {
 196             sc.SetState(SCE_HA_STRING);
 197          }
 198          // Character
 199          else if (sc.Match('\'')) {
 200             sc.SetState(SCE_HA_CHARACTER);
 201          }
 202          // Stringstart
 203          else if (sc.Match('\"')) {
 204             sc.SetState(SCE_HA_STRING);
 205          }
 206          // Operator
 207          else if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
 208             sc.SetState(SCE_HA_OPERATOR);
 209          }
 210          // Keyword
 211          else if (IsAWordStart(sc.ch)) {
 212                sc.SetState(SCE_HA_IDENTIFIER);
 213          }
 214
 215       }
 216    }
 217    sc.Complete();
 218 }
 219
 220 // External stuff - used for dynamic-loading, not implemented in wxStyledTextCtrl yet.
 221 // Inspired by the caml external lexer - Credits to Robert Roessler - http://www.rftp.com
 222 #ifdef BUILD_EXTERNAL_LEXER
 223 static const char* LexerName = "haskell";
 224
 225 void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, int initStyle,
 226                         char *words[], WindowID window, char *props)
 227 {
 228    PropSet ps;
 229    ps.SetMultiple(props);
 230    WindowAccessor wa(window, ps);
 231
 232    int nWL = 0;
 233    for (; words[nWL]; nWL++) ;
 234    WordList** wl = new WordList* [nWL + 1];
 235    int i = 0;
 236    for (; i<nWL; i++)
 237    {
 238       wl[i] = new WordList();
 239       wl[i]->Set(words[i]);
 240    }
 241    wl[i] = 0;
 242
 243    ColorizeHaskellDoc(startPos, length, initStyle, wl, wa);
 244    wa.Flush();
 245    for (i=nWL-1;i>=0;i--)
 246       delete wl[i];
 247    delete [] wl;
 248 }
 249
 250 void EXT_LEXER_DECL Fold (unsigned int lexer, unsigned int startPos, int length, int initStyle,
 251                         char *words[], WindowID window, char *props)
 252 {
 253
 254 }
 255
 256 int EXT_LEXER_DECL GetLexerCount()
 257 {
 258    return 1;
 259 }
 260
 261 void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength)
 262 {
 263    if (buflength > 0) {
 264       buflength--;
 265       int n = strlen(LexerName);
 266       if (n > buflength)
 267          n = buflength;
 268       memcpy(name, LexerName, n), name[n] = '\0';
 269    }
 270 }
 271 #endif
 272
 273 LexerModule lmHaskell(SCLEX_HASKELL, ColorizeHaskellDoc, "haskell");
 274