[wxWidgets.git] / src / stc / scintilla / lexers / LexHaskell.cxx

/******************************************************************
 *    LexHaskell.cxx
 *
 *    A haskell lexer for the scintilla code control.
 *    Some stuff "lended" from LexPython.cxx and LexCPP.cxx.
 *    External lexer stuff inspired from the caml external lexer.
 *
 *    Written by Tobias Engvall - tumm at dtek dot chalmers dot se
 *
 *    Several bug fixes by Krasimir Angelov - kr.angelov at gmail.com
 *
 *    TODO:
 *    * Implement a folder :)
 *    * Nice Character-lexing (stuff inside '\''), LexPython has
 *      this.
 *
 *
 *****************************************************************/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>

#include "ILexer.h"
#include "Scintilla.h"
#include "SciLexer.h"

#include "PropSetSimple.h"
#include "WordList.h"
#include "LexAccessor.h"
#include "Accessor.h"
#include "StyleContext.h"
#include "CharacterSet.h"
#include "LexerModule.h"

#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif

#ifdef BUILD_AS_EXTERNAL_LEXER

#include "ExternalLexer.h"
#include "WindowAccessor.h"

#define BUILD_EXTERNAL_LEXER 0

#endif

#define HA_MODE_DEFAULT     0
#define HA_MODE_IMPORT1     1
#define HA_MODE_IMPORT2     2
#define HA_MODE_IMPORT3     3
#define HA_MODE_MODULE      4
#define HA_MODE_FFI         5
#define HA_MODE_TYPE        6

static inline bool IsNewline(const int ch) {
   return (ch == '\n' || ch == '\r');
}

static inline bool IsWhitespace(const int ch) {
   return (  ch == ' '
          || ch == '\t'
          || IsNewline(ch) );
}

static inline bool IsAWordStart(const int ch) {
   return (ch < 0x80) && (isalnum(ch) || ch == '_');
}

static inline bool IsAWordChar(const int ch) {
   return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\'');
}

static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle,
                               WordList *keywordlists[], Accessor &styler) {

   WordList &keywords = *keywordlists[0];
   WordList &ffi      = *keywordlists[1];

   StyleContext sc(startPos, length, initStyle, styler);

   int lineCurrent = styler.GetLine(startPos);
   int state = lineCurrent ? styler.GetLineState(lineCurrent-1)
                           : HA_MODE_DEFAULT;
   int mode  = state & 0xF;
   int xmode = state >> 4;

   while (sc.More()) {
      // Check for state end

         // Operator
      if (sc.state == SCE_HA_OPERATOR) {
         if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
            sc.Forward();
         } else {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.ChangeState(SCE_HA_DEFAULT);
         }
      }
         // String
      else if (sc.state == SCE_HA_STRING) {
         if (sc.ch == '\"') {
			sc.Forward();
            styler.ColourTo(sc.currentPos-1, sc.state);
            sc.ChangeState(SCE_HA_DEFAULT);
         } else if (sc.ch == '\\') {
            sc.Forward(2);
         } else if (sc.atLineEnd) {
			styler.ColourTo(sc.currentPos-1, sc.state);
			sc.ChangeState(SCE_HA_DEFAULT);
		 } else {
			sc.Forward();
		 }
      }
         // Char
      else if (sc.state == SCE_HA_CHARACTER) {
         if (sc.ch == '\'') {
			sc.Forward();
            styler.ColourTo(sc.currentPos-1, sc.state);
            sc.ChangeState(SCE_HA_DEFAULT);
         } else if (sc.ch == '\\') {
            sc.Forward(2);
         } else if (sc.atLineEnd) {
			styler.ColourTo(sc.currentPos-1, sc.state);
			sc.ChangeState(SCE_HA_DEFAULT);
		 } else {
			sc.Forward();
		 }
      }
         // Number
      else if (sc.state == SCE_HA_NUMBER) {
         if (IsADigit(sc.ch, xmode)) {
            sc.Forward();
         } else if ((xmode == 10) &&
                    (sc.ch == 'e' || sc.ch == 'E') &&
                    (IsADigit(sc.chNext) || sc.chNext == '+' || sc.chNext == '-')) {
			sc.Forward();
			if (sc.ch == '+' || sc.ch == '-')
				sc.Forward();
         } else {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.ChangeState(SCE_HA_DEFAULT);
         }
      }
         // Identifier
      else if (sc.state == SCE_HA_IDENTIFIER) {
         if (IsAWordChar(sc.ch)) {
            sc.Forward();
         } else {
            char s[100];
            sc.GetCurrent(s, sizeof(s));
            int style = sc.state;
            int new_mode = 0;
            if (keywords.InList(s)) {
               style = SCE_HA_KEYWORD;
            } else if (isupper(s[0])) {
               if (mode >= HA_MODE_IMPORT1 && mode <= HA_MODE_IMPORT3) {
                  style    = SCE_HA_MODULE;
                  new_mode = HA_MODE_IMPORT2;
               } else if (mode == HA_MODE_MODULE)
                  style = SCE_HA_MODULE;
               else
                  style = SCE_HA_CAPITAL;
            } else if (mode == HA_MODE_IMPORT1 &&
                       strcmp(s,"qualified") == 0) {
                style    = SCE_HA_KEYWORD;
                new_mode = HA_MODE_IMPORT1;
            } else if (mode == HA_MODE_IMPORT2) {
                if (strcmp(s,"as") == 0) {
                   style    = SCE_HA_KEYWORD;
                   new_mode = HA_MODE_IMPORT3;
               } else if (strcmp(s,"hiding") == 0) {
                   style     = SCE_HA_KEYWORD;
               }
            } else if (mode == HA_MODE_FFI) {
			   if (ffi.InList(s)) {
                  style = SCE_HA_KEYWORD;
                  new_mode = HA_MODE_FFI;
               }
            }
            else if (mode == HA_MODE_TYPE) {
               if (strcmp(s,"family") == 0)
                  style    = SCE_HA_KEYWORD;
			}
            styler.ColourTo(sc.currentPos - 1, style);
            if (strcmp(s,"import") == 0 && mode != HA_MODE_FFI)
               new_mode = HA_MODE_IMPORT1;
            else if (strcmp(s,"module") == 0)
               new_mode = HA_MODE_MODULE;
            else if (strcmp(s,"foreign") == 0)
               new_mode = HA_MODE_FFI;
            else if (strcmp(s,"type") == 0)
               new_mode = HA_MODE_TYPE;
            sc.ChangeState(SCE_HA_DEFAULT);
            mode = new_mode;
         }
      }

         // Comments
            // Oneliner
      else if (sc.state == SCE_HA_COMMENTLINE) {
         if (sc.atLineEnd) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.ChangeState(SCE_HA_DEFAULT);
         } else {
            sc.Forward();
         }
      }
            // Nested
      else if (sc.state == SCE_HA_COMMENTBLOCK) {
         if (sc.Match("{-")) {
            sc.Forward(2);
            xmode++;
         }
         else if (sc.Match("-}")) {
            sc.Forward(2);
            xmode--;
            if (xmode == 0) {
               styler.ColourTo(sc.currentPos - 1, sc.state);
               sc.ChangeState(SCE_HA_DEFAULT);
            }
         } else {
            if (sc.atLineEnd) {
				// Remember the line state for future incremental lexing
				styler.SetLineState(lineCurrent, (xmode << 4) | mode);
				lineCurrent++;
			}
            sc.Forward();
         }
      }
      // New state?
      if (sc.state == SCE_HA_DEFAULT) {
         // Digit
         if (IsADigit(sc.ch) ||
             (sc.ch == '.' && IsADigit(sc.chNext)) ||
             (sc.ch == '-' && IsADigit(sc.chNext))) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.ChangeState(SCE_HA_NUMBER);
            if (sc.ch == '0' && (sc.chNext == 'X' || sc.chNext == 'x')) {
				// Match anything starting with "0x" or "0X", too
				sc.Forward(2);
				xmode = 16;
            } else if (sc.ch == '0' && (sc.chNext == 'O' || sc.chNext == 'o')) {
				// Match anything starting with "0x" or "0X", too
				sc.Forward(2);
				xmode = 8;
            } else {
				sc.Forward();
				xmode = 10;
			}
            mode = HA_MODE_DEFAULT;
         }
         // Comment line
         else if (sc.Match("--")) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward(2);
            sc.ChangeState(SCE_HA_COMMENTLINE);
         // Comment block
         }
         else if (sc.Match("{-")) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward(2);
            sc.ChangeState(SCE_HA_COMMENTBLOCK);
            xmode = 1;
         }
         // String
         else if (sc.Match('\"')) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward();
            sc.ChangeState(SCE_HA_STRING);
         }
         // Character
         else if (sc.Match('\'')) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward();
            sc.ChangeState(SCE_HA_CHARACTER);
         }
         else if (sc.ch == '(' || sc.ch == ')' ||
                  sc.ch == '{' || sc.ch == '}' ||
                  sc.ch == '[' || sc.ch == ']') {
			styler.ColourTo(sc.currentPos - 1, sc.state);
			sc.Forward();
			styler.ColourTo(sc.currentPos - 1, SCE_HA_OPERATOR);
			mode = HA_MODE_DEFAULT;
		 }
         // Operator
         else if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward();
            sc.ChangeState(SCE_HA_OPERATOR);
            mode = HA_MODE_DEFAULT;
         }
         // Keyword
         else if (IsAWordStart(sc.ch)) {
            styler.ColourTo(sc.currentPos - 1, sc.state);
            sc.Forward();
            sc.ChangeState(SCE_HA_IDENTIFIER);
         } else {
            if (sc.atLineEnd) {
				// Remember the line state for future incremental lexing
				styler.SetLineState(lineCurrent, (xmode << 4) | mode);
				lineCurrent++;
			}
            sc.Forward();
         }
      }
   }
   sc.Complete();
}

// External stuff - used for dynamic-loading, not implemented in wxStyledTextCtrl yet.
// Inspired by the caml external lexer - Credits to Robert Roessler - http://www.rftp.com
#ifdef BUILD_EXTERNAL_LEXER
static const char* LexerName = "haskell";

void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, int initStyle,
                        char *words[], WindowID window, char *props)
{
   PropSetSimple ps;
   ps.SetMultiple(props);
   WindowAccessor wa(window, ps);

   int nWL = 0;
   for (; words[nWL]; nWL++) ;
   WordList** wl = new WordList* [nWL + 1];
   int i = 0;
   for (; i<nWL; i++)
   {
      wl[i] = new WordList();
      wl[i]->Set(words[i]);
   }
   wl[i] = 0;

   ColorizeHaskellDoc(startPos, length, initStyle, wl, wa);
   wa.Flush();
   for (i=nWL-1;i>=0;i--)
      delete wl[i];
   delete [] wl;
}

void EXT_LEXER_DECL Fold (unsigned int lexer, unsigned int startPos, int length, int initStyle,
                        char *words[], WindowID window, char *props)
{

}

int EXT_LEXER_DECL GetLexerCount()
{
   return 1;
}

void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength)
{
   if (buflength > 0) {
      buflength--;
      int n = strlen(LexerName);
      if (n > buflength)
         n = buflength;
      memcpy(name, LexerName, n), name[n] = '\0';
   }
}
#endif

LexerModule lmHaskell(SCLEX_HASKELL, ColorizeHaskellDoc, "haskell");
Commit	Line	Data
1dcf666d RD	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	* Several bug fixes by Krasimir Angelov - kr.angelov at gmail.com
	11	*
	12	* TODO:
	13	* * Implement a folder :)
	14	* * Nice Character-lexing (stuff inside '\''), LexPython has
	15	* this.
	16	*
	17	*
	18	*****************************************************************/
	19
	20	#include <stdlib.h>
	21	#include <string.h>
	22	#include <stdio.h>
	23	#include <stdarg.h>
	24	#include <assert.h>
	25	#include <ctype.h>
	26
	27	#include "ILexer.h"
	28	#include "Scintilla.h"
	29	#include "SciLexer.h"
	30
	31	#include "PropSetSimple.h"
	32	#include "WordList.h"
	33	#include "LexAccessor.h"
	34	#include "Accessor.h"
	35	#include "StyleContext.h"
	36	#include "CharacterSet.h"
	37	#include "LexerModule.h"
	38
	39	#ifdef SCI_NAMESPACE
	40	using namespace Scintilla;
	41	#endif
	42
	43	#ifdef BUILD_AS_EXTERNAL_LEXER
	44
	45	#include "ExternalLexer.h"
	46	#include "WindowAccessor.h"
	47
	48	#define BUILD_EXTERNAL_LEXER 0
	49
	50	#endif
	51
	52	#define HA_MODE_DEFAULT 0
	53	#define HA_MODE_IMPORT1 1
	54	#define HA_MODE_IMPORT2 2
	55	#define HA_MODE_IMPORT3 3
	56	#define HA_MODE_MODULE 4
	57	#define HA_MODE_FFI 5
	58	#define HA_MODE_TYPE 6
	59
	60	static inline bool IsNewline(const int ch) {
	61	return (ch == '\n' \|\| ch == '\r');
	62	}
	63
	64	static inline bool IsWhitespace(const int ch) {
65	return ( ch == ' '
66	\|\| ch == '\t'
67	\|\| IsNewline(ch) );
68	}
69
70	static inline bool IsAWordStart(const int ch) {
71	return (ch < 0x80) && (isalnum(ch) \|\| ch == '_');
72	}
73
74	static inline bool IsAWordChar(const int ch) {
75	return (ch < 0x80) && (isalnum(ch) \|\| ch == '.' \|\| ch == '_' \|\| ch == '\'');
76	}
77
78	static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle,
79	WordList *keywordlists[], Accessor &styler) {
80
81	WordList &keywords = *keywordlists[0];
82	WordList &ffi = *keywordlists[1];
83
84	StyleContext sc(startPos, length, initStyle, styler);
85
86	int lineCurrent = styler.GetLine(startPos);
87	int state = lineCurrent ? styler.GetLineState(lineCurrent-1)
88	: HA_MODE_DEFAULT;
89	int mode = state & 0xF;
90	int xmode = state >> 4;
91
92	while (sc.More()) {
93	// Check for state end
94
95	// Operator
96	if (sc.state == SCE_HA_OPERATOR) {
97	if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
98	sc.Forward();
99	} else {
100	styler.ColourTo(sc.currentPos - 1, sc.state);
101	sc.ChangeState(SCE_HA_DEFAULT);
102	}
103	}
104	// String
105	else if (sc.state == SCE_HA_STRING) {
106	if (sc.ch == '\"') {
107	sc.Forward();
108	styler.ColourTo(sc.currentPos-1, sc.state);
109	sc.ChangeState(SCE_HA_DEFAULT);
110	} else if (sc.ch == '\\') {
111	sc.Forward(2);
112	} else if (sc.atLineEnd) {
113	styler.ColourTo(sc.currentPos-1, sc.state);
114	sc.ChangeState(SCE_HA_DEFAULT);
115	} else {
116	sc.Forward();
117	}
118	}
119	// Char
120	else if (sc.state == SCE_HA_CHARACTER) {
121	if (sc.ch == '\'') {
122	sc.Forward();
123	styler.ColourTo(sc.currentPos-1, sc.state);
124	sc.ChangeState(SCE_HA_DEFAULT);
125	} else if (sc.ch == '\\') {
126	sc.Forward(2);
127	} else if (sc.atLineEnd) {
128	styler.ColourTo(sc.currentPos-1, sc.state);
129	sc.ChangeState(SCE_HA_DEFAULT);
130	} else {
131	sc.Forward();
132	}
133	}
134	// Number
135	else if (sc.state == SCE_HA_NUMBER) {
136	if (IsADigit(sc.ch, xmode)) {
137	sc.Forward();
138	} else if ((xmode == 10) &&
139	(sc.ch == 'e' \|\| sc.ch == 'E') &&
140	(IsADigit(sc.chNext) \|\| sc.chNext == '+' \|\| sc.chNext == '-')) {
141	sc.Forward();
142	if (sc.ch == '+' \|\| sc.ch == '-')
143	sc.Forward();
144	} else {
145	styler.ColourTo(sc.currentPos - 1, sc.state);
146	sc.ChangeState(SCE_HA_DEFAULT);
147	}
148	}
149	// Identifier
150	else if (sc.state == SCE_HA_IDENTIFIER) {
151	if (IsAWordChar(sc.ch)) {
152	sc.Forward();
153	} else {
154	char s[100];
155	sc.GetCurrent(s, sizeof(s));
156	int style = sc.state;
157	int new_mode = 0;
158	if (keywords.InList(s)) {
159	style = SCE_HA_KEYWORD;
160	} else if (isupper(s[0])) {
161	if (mode >= HA_MODE_IMPORT1 && mode <= HA_MODE_IMPORT3) {
162	style = SCE_HA_MODULE;
163	new_mode = HA_MODE_IMPORT2;
164	} else if (mode == HA_MODE_MODULE)
165	style = SCE_HA_MODULE;
166	else
167	style = SCE_HA_CAPITAL;
168	} else if (mode == HA_MODE_IMPORT1 &&
169	strcmp(s,"qualified") == 0) {
170	style = SCE_HA_KEYWORD;
171	new_mode = HA_MODE_IMPORT1;
172	} else if (mode == HA_MODE_IMPORT2) {
173	if (strcmp(s,"as") == 0) {
174	style = SCE_HA_KEYWORD;
175	new_mode = HA_MODE_IMPORT3;
176	} else if (strcmp(s,"hiding") == 0) {
177	style = SCE_HA_KEYWORD;
178	}
179	} else if (mode == HA_MODE_FFI) {
180	if (ffi.InList(s)) {
181	style = SCE_HA_KEYWORD;
182	new_mode = HA_MODE_FFI;
183	}
184	}
185	else if (mode == HA_MODE_TYPE) {
186	if (strcmp(s,"family") == 0)
187	style = SCE_HA_KEYWORD;
188	}
189	styler.ColourTo(sc.currentPos - 1, style);
190	if (strcmp(s,"import") == 0 && mode != HA_MODE_FFI)
191	new_mode = HA_MODE_IMPORT1;
192	else if (strcmp(s,"module") == 0)
193	new_mode = HA_MODE_MODULE;
194	else if (strcmp(s,"foreign") == 0)
195	new_mode = HA_MODE_FFI;
196	else if (strcmp(s,"type") == 0)
197	new_mode = HA_MODE_TYPE;
198	sc.ChangeState(SCE_HA_DEFAULT);
199	mode = new_mode;
200	}
201	}
202
203	// Comments
204	// Oneliner
205	else if (sc.state == SCE_HA_COMMENTLINE) {
206	if (sc.atLineEnd) {
207	styler.ColourTo(sc.currentPos - 1, sc.state);
208	sc.ChangeState(SCE_HA_DEFAULT);
209	} else {
210	sc.Forward();
211	}
212	}
213	// Nested
214	else if (sc.state == SCE_HA_COMMENTBLOCK) {
215	if (sc.Match("{-")) {
216	sc.Forward(2);
217	xmode++;
218	}
219	else if (sc.Match("-}")) {
220	sc.Forward(2);
221	xmode--;
222	if (xmode == 0) {
223	styler.ColourTo(sc.currentPos - 1, sc.state);
224	sc.ChangeState(SCE_HA_DEFAULT);
225	}
226	} else {
227	if (sc.atLineEnd) {
228	// Remember the line state for future incremental lexing
229	styler.SetLineState(lineCurrent, (xmode << 4) \| mode);
230	lineCurrent++;
231	}
232	sc.Forward();
233	}
234	}
235	// New state?
236	if (sc.state == SCE_HA_DEFAULT) {
237	// Digit
238	if (IsADigit(sc.ch) \|\|
239	(sc.ch == '.' && IsADigit(sc.chNext)) \|\|
240	(sc.ch == '-' && IsADigit(sc.chNext))) {
241	styler.ColourTo(sc.currentPos - 1, sc.state);
242	sc.ChangeState(SCE_HA_NUMBER);
243	if (sc.ch == '0' && (sc.chNext == 'X' \|\| sc.chNext == 'x')) {
244	// Match anything starting with "0x" or "0X", too
245	sc.Forward(2);
246	xmode = 16;
247	} else if (sc.ch == '0' && (sc.chNext == 'O' \|\| sc.chNext == 'o')) {
248	// Match anything starting with "0x" or "0X", too
249	sc.Forward(2);
250	xmode = 8;
251	} else {
252	sc.Forward();
253	xmode = 10;
254	}
255	mode = HA_MODE_DEFAULT;
256	}
257	// Comment line
258	else if (sc.Match("--")) {
259	styler.ColourTo(sc.currentPos - 1, sc.state);
260	sc.Forward(2);
261	sc.ChangeState(SCE_HA_COMMENTLINE);
262	// Comment block
263	}
264	else if (sc.Match("{-")) {
265	styler.ColourTo(sc.currentPos - 1, sc.state);
266	sc.Forward(2);
267	sc.ChangeState(SCE_HA_COMMENTBLOCK);
268	xmode = 1;
269	}
270	// String
271	else if (sc.Match('\"')) {
272	styler.ColourTo(sc.currentPos - 1, sc.state);
273	sc.Forward();
274	sc.ChangeState(SCE_HA_STRING);
275	}
276	// Character
277	else if (sc.Match('\'')) {
278	styler.ColourTo(sc.currentPos - 1, sc.state);
279	sc.Forward();
280	sc.ChangeState(SCE_HA_CHARACTER);
281	}
282	else if (sc.ch == '(' \|\| sc.ch == ')' \|\|
283	sc.ch == '{' \|\| sc.ch == '}' \|\|
284	sc.ch == '[' \|\| sc.ch == ']') {
285	styler.ColourTo(sc.currentPos - 1, sc.state);
286	sc.Forward();
287	styler.ColourTo(sc.currentPos - 1, SCE_HA_OPERATOR);
288	mode = HA_MODE_DEFAULT;
289	}
290	// Operator
291	else if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
292	styler.ColourTo(sc.currentPos - 1, sc.state);
293	sc.Forward();
294	sc.ChangeState(SCE_HA_OPERATOR);
295	mode = HA_MODE_DEFAULT;
296	}
297	// Keyword
298	else if (IsAWordStart(sc.ch)) {
299	styler.ColourTo(sc.currentPos - 1, sc.state);
300	sc.Forward();
301	sc.ChangeState(SCE_HA_IDENTIFIER);
302	} else {
303	if (sc.atLineEnd) {
304	// Remember the line state for future incremental lexing
305	styler.SetLineState(lineCurrent, (xmode << 4) \| mode);
306	lineCurrent++;
307	}
308	sc.Forward();
309	}
310	}
311	}
312	sc.Complete();
313	}
314
315	// External stuff - used for dynamic-loading, not implemented in wxStyledTextCtrl yet.
316	// Inspired by the caml external lexer - Credits to Robert Roessler - http://www.rftp.com
317	#ifdef BUILD_EXTERNAL_LEXER
318	static const char* LexerName = "haskell";
319
320	void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, int initStyle,
321	char words[], WindowID window, char props)
322	{
323	PropSetSimple ps;
324	ps.SetMultiple(props);
325	WindowAccessor wa(window, ps);
326
327	int nWL = 0;
328	for (; words[nWL]; nWL++) ;
329	WordList** wl = new WordList* [nWL + 1];
330	int i = 0;
331	for (; i<nWL; i++)
332	{
333	wl[i] = new WordList();
334	wl[i]->Set(words[i]);
335	}
336	wl[i] = 0;
337
338	ColorizeHaskellDoc(startPos, length, initStyle, wl, wa);
339	wa.Flush();
340	for (i=nWL-1;i>=0;i--)
341	delete wl[i];
342	delete [] wl;
343	}
344
345	void EXT_LEXER_DECL Fold (unsigned int lexer, unsigned int startPos, int length, int initStyle,
346	char words[], WindowID window, char props)
347	{
348
349	}
350
351	int EXT_LEXER_DECL GetLexerCount()
352	{
353	return 1;
354	}
355
356	void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength)
357	{
358	if (buflength > 0) {
359	buflength--;
360	int n = strlen(LexerName);
361	if (n > buflength)
362	n = buflength;
363	memcpy(name, LexerName, n), name[n] = '\0';
364	}
365	}
366	#endif
367
368	LexerModule lmHaskell(SCLEX_HASKELL, ColorizeHaskellDoc, "haskell");