[wxWidgets.git] / src / stc / scintilla / src / LexForth.cxx

// Scintilla source code edit control
/** @file LexCrontab.cxx
 ** Lexer to use with extended crontab files used by a powerful
 ** Windows scheduler/event monitor/automation manager nnCron.
 ** (http://nemtsev.eserv.ru/)
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

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

#include "Platform.h"

#include "PropSet.h"
#include "Accessor.h"
#include "KeyWords.h"
#include "Scintilla.h"
#include "SciLexer.h"

bool is_whitespace(int ch){
    return ch == '\n' || ch == '\r' || ch == '\t' || ch == ' ';
}

bool is_blank(int ch){
    return ch == '\t' || ch == ' ';
}
//#define FORTH_DEBUG
#ifdef FORTH_DEBUG
static FILE *f_debug;
#define log(x)  fputs(f_debug,x);
#else
#define log(x)
#endif

#define STATE_LOCALE
#define BL ' '

static Accessor *st;
static int cur_pos,pos1,pos2,pos0,lengthDoc;
char *buffer;

char getChar(bool is_bl){
    char ch=st->SafeGetCharAt(cur_pos);
    if(is_bl) if(is_whitespace(ch)) ch=BL;
    return ch;
}

char getCharBL(){
    char ch=st->SafeGetCharAt(cur_pos);
    return ch;
}
bool is_eol(char ch){
    return ch=='\n' || ch=='\r';
}

int parse(char ch, bool skip_eol){
// pos1 - start pos of word
// pos2 - pos after of word
// pos0 - start pos
    char c=0;
    int len;
    bool is_bl=ch==BL;
    pos0=pos1=pos2=cur_pos;
    for(;cur_pos<lengthDoc && (c=getChar(is_bl))==ch; cur_pos++){
        if(is_eol(c) && !skip_eol){
            pos2=pos1;
            return 0;
        }
    }
    pos1=cur_pos;
    pos2=pos1;
    if(cur_pos==lengthDoc) return 0;
    for(len=0;cur_pos<lengthDoc && (c=getChar(is_bl))!=ch; cur_pos++){
        if(is_eol(c) && !skip_eol) break;
        pos2++;
        buffer[len++]=c;
    }
    if(c==ch) pos2--;
    buffer[len]='\0';
#ifdef FORTH_DEBUG
    fprintf(f_debug,"parse: %c %s\n",ch,buffer);
#endif
    return len;
}

bool _is_number(char *s,int base){
    for(;*s;s++){
        int digit=((int)*s)-(int)'0';
#ifdef FORTH_DEBUG
    fprintf(f_debug,"digit: %c %d\n",*s,digit);
#endif
        if(digit>9 && base>10) digit-=7;
        if(digit<0) return false;
        if(digit>=base) return false;
    }
    return true;
}

bool is_number(char *s){
    if(strncmp(s,"0x",2)==0) return _is_number(s+2,16);
    return _is_number(s,10);
}

static void ColouriseForthDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
{
    st=&styler;
    cur_pos=startPos;
    lengthDoc = startPos + length;
    buffer = new char[length];

#ifdef FORTH_DEBUG
    f_debug=fopen("c:\\sci.log","at");
#endif

    WordList &control = *keywordLists[0];
    WordList &keyword = *keywordLists[1];
    WordList &defword = *keywordLists[2];
    WordList &preword1 = *keywordLists[3];
    WordList &preword2 = *keywordLists[4];
    WordList &strings = *keywordLists[5];

    // go through all provided text segment
    // using the hand-written state machine shown below
    styler.StartAt(startPos);
    styler.StartSegment(startPos);
    while(parse(BL,true)!=0){
        if(pos0!=pos1){
            styler.ColourTo(pos0,SCE_FORTH_DEFAULT);
            styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
        }
        if(strcmp("\\",buffer)==0){
            styler.ColourTo(pos1,SCE_FORTH_COMMENT);
            parse(1,false);
            styler.ColourTo(pos2,SCE_FORTH_COMMENT);
        }else if(strcmp("(",buffer)==0){
            styler.ColourTo(pos1,SCE_FORTH_COMMENT);
            parse(')',true);
            if(cur_pos<lengthDoc) cur_pos++;
            styler.ColourTo(cur_pos,SCE_FORTH_COMMENT);
        }else if(strcmp("[",buffer)==0){
            styler.ColourTo(pos1,SCE_FORTH_STRING);
            parse(']',true);
            if(cur_pos<lengthDoc) cur_pos++;
            styler.ColourTo(cur_pos,SCE_FORTH_STRING);
        }else if(strcmp("{",buffer)==0){
            styler.ColourTo(pos1,SCE_FORTH_LOCALE);
            parse('}',false);
            if(cur_pos<lengthDoc) cur_pos++;
            styler.ColourTo(cur_pos,SCE_FORTH_LOCALE);
        }else if(strings.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_STRING);
            parse('"',false);
            if(cur_pos<lengthDoc) cur_pos++;
            styler.ColourTo(cur_pos,SCE_FORTH_STRING);
        }else if(control.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_CONTROL);
            styler.ColourTo(pos2,SCE_FORTH_CONTROL);
        }else if(keyword.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
            styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
        }else if(defword.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
            styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
            parse(BL,false);
            styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
            styler.ColourTo(pos1,SCE_FORTH_DEFWORD);
            styler.ColourTo(pos2,SCE_FORTH_DEFWORD);
        }else if(preword1.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_PREWORD1);
            parse(BL,false);
            styler.ColourTo(pos2,SCE_FORTH_PREWORD1);
        }else if(preword2.InList(buffer)) {
            styler.ColourTo(pos1,SCE_FORTH_PREWORD2);
            parse(BL,false);
            styler.ColourTo(pos2,SCE_FORTH_PREWORD2);
            parse(BL,false);
            styler.ColourTo(pos1,SCE_FORTH_STRING);
            styler.ColourTo(pos2,SCE_FORTH_STRING);
        }else if(is_number(buffer)){
            styler.ColourTo(pos1,SCE_FORTH_NUMBER);
            styler.ColourTo(pos2,SCE_FORTH_NUMBER);
        }
    }
#ifdef FORTH_DEBUG
    fclose(f_debug);
#endif
    delete []buffer;
    return;
/*
                        if(control.InList(buffer)) {
                            styler.ColourTo(i,SCE_FORTH_CONTROL);
                        } else if(keyword.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
                        } else if(defword.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
//                            prev_state=SCE_FORTH_DEFWORD
                        } else if(preword1.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
//                            state=SCE_FORTH_PREWORD1;
                        } else if(preword2.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
                         } else {
                            styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
                        }
*/
/*
    chPrev=' ';
    for (int i = startPos; i < lengthDoc; i++) {
        char ch = chNext;
        chNext = styler.SafeGetCharAt(i + 1);
        if(i!=startPos) chPrev=styler.SafeGetCharAt(i - 1);

        if (styler.IsLeadByte(ch)) {
            chNext = styler.SafeGetCharAt(i + 2);
            i++;
            continue;
        }
#ifdef FORTH_DEBUG
        fprintf(f_debug,"%c %d ",ch,state);
#endif
        switch(state) {
            case SCE_FORTH_DEFAULT:
                if(is_whitespace(ch)) {
                    // whitespace is simply ignored here...
                    styler.ColourTo(i,SCE_FORTH_DEFAULT);
                    break;
                } else if( ch == '\\' && is_blank(chNext)) {
                    // signals the start of an one line comment...
                    state = SCE_FORTH_COMMENT;
                    styler.ColourTo(i,SCE_FORTH_COMMENT);
                } else if( is_whitespace(chPrev) &&  ch == '(' &&  is_whitespace(chNext)) {
                    // signals the start of a plain comment...
                    state = SCE_FORTH_COMMENT_ML;
                    styler.ColourTo(i,SCE_FORTH_COMMENT_ML);
                } else if( isdigit(ch) ) {
                    // signals the start of a number
                    bufferCount = 0;
                    buffer[bufferCount++] = ch;
                    state = SCE_FORTH_NUMBER;
                } else if( !is_whitespace(ch)) {
                    // signals the start of an identifier
                    bufferCount = 0;
                    buffer[bufferCount++] = ch;
                    state = SCE_FORTH_IDENTIFIER;
                } else {
                    // style it the default style..
                    styler.ColourTo(i,SCE_FORTH_DEFAULT);
                }
                break;

            case SCE_FORTH_COMMENT:
                // if we find a newline here,
                // we simply go to default state
                // else continue to work on it...
                if( ch == '\n' || ch == '\r' ) {
                    state = SCE_FORTH_DEFAULT;
                } else {
                    styler.ColourTo(i,SCE_FORTH_COMMENT);
                }
                break;

            case SCE_FORTH_COMMENT_ML:
                if( ch == ')') {
                    state = SCE_FORTH_DEFAULT;
                } else {
                    styler.ColourTo(i+1,SCE_FORTH_COMMENT_ML);
                }
                break;

            case SCE_FORTH_IDENTIFIER:
                // stay  in CONF_IDENTIFIER state until we find a non-alphanumeric
                if( !is_whitespace(ch) ) {
                    buffer[bufferCount++] = ch;
                } else {
                    state = SCE_FORTH_DEFAULT;
                    buffer[bufferCount] = '\0';
#ifdef FORTH_DEBUG
        fprintf(f_debug,"\nid %s\n",buffer);
#endif

                    // check if the buffer contains a keyword,
                    // and highlight it if it is a keyword...
//                    switch(prev_state)
//                    case SCE_FORTH_DEFAULT:
                        if(control.InList(buffer)) {
                            styler.ColourTo(i,SCE_FORTH_CONTROL);
                        } else if(keyword.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
                        } else if(defword.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
//                            prev_state=SCE_FORTH_DEFWORD
                        } else if(preword1.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
//                            state=SCE_FORTH_PREWORD1;
                        } else if(preword2.InList(buffer)) {
                            styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
                         } else {
                            styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
                        }
//                        break;
//                    case

                    // push back the faulty character
                    chNext = styler[i--];
                }
                break;

            case SCE_FORTH_NUMBER:
                // stay  in CONF_NUMBER state until we find a non-numeric
                if( isdigit(ch) ) {
                    buffer[bufferCount++] = ch;
                } else {
                    state = SCE_FORTH_DEFAULT;
                    buffer[bufferCount] = '\0';
                    // Colourize here... (normal number)
                    styler.ColourTo(i-1,SCE_FORTH_NUMBER);
                    // push back a character
                    chNext = styler[i--];
                }
                break;
        }
    }
#ifdef FORTH_DEBUG
    fclose(f_debug);
#endif
    delete []buffer;
*/
}

static void FoldForthDoc(unsigned int, int, int, WordList *[],
                       Accessor &) {
}

static const char * const forthWordLists[] = {
            "control keywords",
            "keywords",
            "definition words",
            "prewords with one argument",
            "prewords with two arguments",
            "string definition keywords",
            0,
        };

LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth",FoldForthDoc,forthWordLists);
Commit	Line	Data
8e54aaed RD	1	// Scintilla source code edit control
	2	/** @file LexCrontab.cxx
	3	** Lexer to use with extended crontab files used by a powerful
	4	** Windows scheduler/event monitor/automation manager nnCron.
	5	** (http://nemtsev.eserv.ru/)
	6	**/
	7	// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
	8	// The License.txt file describes the conditions under which this software may be distributed.
	9
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <ctype.h>
	13	#include <stdio.h>
	14	#include <stdarg.h>
	15
	16	#include "Platform.h"
	17
	18	#include "PropSet.h"
	19	#include "Accessor.h"
	20	#include "KeyWords.h"
	21	#include "Scintilla.h"
	22	#include "SciLexer.h"
	23
	24	bool is_whitespace(int ch){
	25	return ch == '\n' \|\| ch == '\r' \|\| ch == '\t' \|\| ch == ' ';
	26	}
	27
	28	bool is_blank(int ch){
	29	return ch == '\t' \|\| ch == ' ';
	30	}
	31	//#define FORTH_DEBUG
	32	#ifdef FORTH_DEBUG
	33	static FILE *f_debug;
	34	#define log(x) fputs(f_debug,x);
	35	#else
	36	#define log(x)
	37	#endif
	38
	39	#define STATE_LOCALE
	40	#define BL ' '
	41
	42	static Accessor *st;
	43	static int cur_pos,pos1,pos2,pos0,lengthDoc;
	44	char *buffer;
	45
	46	char getChar(bool is_bl){
	47	char ch=st->SafeGetCharAt(cur_pos);
	48	if(is_bl) if(is_whitespace(ch)) ch=BL;
	49	return ch;
	50	}
	51
	52	char getCharBL(){
	53	char ch=st->SafeGetCharAt(cur_pos);
	54	return ch;
	55	}
	56	bool is_eol(char ch){
	57	return ch=='\n' \|\| ch=='\r';
	58	}
	59
	60	int parse(char ch, bool skip_eol){
	61	// pos1 - start pos of word
	62	// pos2 - pos after of word
	63	// pos0 - start pos
	64	char c=0;
65	int len;
66	bool is_bl=ch==BL;
67	pos0=pos1=pos2=cur_pos;
68	for(;cur_pos<lengthDoc && (c=getChar(is_bl))==ch; cur_pos++){
69	if(is_eol(c) && !skip_eol){
70	pos2=pos1;
71	return 0;
72	}
73	}
74	pos1=cur_pos;
75	pos2=pos1;
76	if(cur_pos==lengthDoc) return 0;
77	for(len=0;cur_pos<lengthDoc && (c=getChar(is_bl))!=ch; cur_pos++){
78	if(is_eol(c) && !skip_eol) break;
79	pos2++;
80	buffer[len++]=c;
81	}
82	if(c==ch) pos2--;
83	buffer[len]='\0';
84	#ifdef FORTH_DEBUG
85	fprintf(f_debug,"parse: %c %s\n",ch,buffer);
86	#endif
87	return len;
88	}
89
90	bool _is_number(char *s,int base){
91	for(;*s;s++){
92	int digit=((int)*s)-(int)'0';
93	#ifdef FORTH_DEBUG
94	fprintf(f_debug,"digit: %c %d\n",*s,digit);
95	#endif
96	if(digit>9 && base>10) digit-=7;
97	if(digit<0) return false;
98	if(digit>=base) return false;
99	}
100	return true;
101	}
102
103	bool is_number(char *s){
104	if(strncmp(s,"0x",2)==0) return _is_number(s+2,16);
105	return _is_number(s,10);
106	}
107
108	static void ColouriseForthDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
109	{
110	st=&styler;
111	cur_pos=startPos;
112	lengthDoc = startPos + length;
113	buffer = new char[length];
114
115	#ifdef FORTH_DEBUG
116	f_debug=fopen("c:\\sci.log","at");
117	#endif
118
119	WordList &control = *keywordLists[0];
120	WordList &keyword = *keywordLists[1];
121	WordList &defword = *keywordLists[2];
122	WordList &preword1 = *keywordLists[3];
123	WordList &preword2 = *keywordLists[4];
124	WordList &strings = *keywordLists[5];
125
126	// go through all provided text segment
127	// using the hand-written state machine shown below
128	styler.StartAt(startPos);
129	styler.StartSegment(startPos);
130	while(parse(BL,true)!=0){
131	if(pos0!=pos1){
132	styler.ColourTo(pos0,SCE_FORTH_DEFAULT);
133	styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
134	}
135	if(strcmp("\\",buffer)==0){
136	styler.ColourTo(pos1,SCE_FORTH_COMMENT);
137	parse(1,false);
138	styler.ColourTo(pos2,SCE_FORTH_COMMENT);
139	}else if(strcmp("(",buffer)==0){
140	styler.ColourTo(pos1,SCE_FORTH_COMMENT);
141	parse(')',true);
142	if(cur_pos<lengthDoc) cur_pos++;
143	styler.ColourTo(cur_pos,SCE_FORTH_COMMENT);
144	}else if(strcmp("[",buffer)==0){
145	styler.ColourTo(pos1,SCE_FORTH_STRING);
146	parse(']',true);
147	if(cur_pos<lengthDoc) cur_pos++;
148	styler.ColourTo(cur_pos,SCE_FORTH_STRING);
149	}else if(strcmp("{",buffer)==0){
150	styler.ColourTo(pos1,SCE_FORTH_LOCALE);
151	parse('}',false);
152	if(cur_pos<lengthDoc) cur_pos++;
153	styler.ColourTo(cur_pos,SCE_FORTH_LOCALE);
154	}else if(strings.InList(buffer)) {
155	styler.ColourTo(pos1,SCE_FORTH_STRING);
156	parse('"',false);
157	if(cur_pos<lengthDoc) cur_pos++;
158	styler.ColourTo(cur_pos,SCE_FORTH_STRING);
159	}else if(control.InList(buffer)) {
160	styler.ColourTo(pos1,SCE_FORTH_CONTROL);
161	styler.ColourTo(pos2,SCE_FORTH_CONTROL);
162	}else if(keyword.InList(buffer)) {
163	styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
164	styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
165	}else if(defword.InList(buffer)) {
166	styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
167	styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
168	parse(BL,false);
169	styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
170	styler.ColourTo(pos1,SCE_FORTH_DEFWORD);
171	styler.ColourTo(pos2,SCE_FORTH_DEFWORD);
172	}else if(preword1.InList(buffer)) {
173	styler.ColourTo(pos1,SCE_FORTH_PREWORD1);
174	parse(BL,false);
175	styler.ColourTo(pos2,SCE_FORTH_PREWORD1);
176	}else if(preword2.InList(buffer)) {
177	styler.ColourTo(pos1,SCE_FORTH_PREWORD2);
178	parse(BL,false);
179	styler.ColourTo(pos2,SCE_FORTH_PREWORD2);
180	parse(BL,false);
181	styler.ColourTo(pos1,SCE_FORTH_STRING);
182	styler.ColourTo(pos2,SCE_FORTH_STRING);
183	}else if(is_number(buffer)){
184	styler.ColourTo(pos1,SCE_FORTH_NUMBER);
185	styler.ColourTo(pos2,SCE_FORTH_NUMBER);
186	}
187	}
188	#ifdef FORTH_DEBUG
189	fclose(f_debug);
190	#endif
191	delete []buffer;
192	return;
193	/*
194	if(control.InList(buffer)) {
195	styler.ColourTo(i,SCE_FORTH_CONTROL);
196	} else if(keyword.InList(buffer)) {
197	styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
198	} else if(defword.InList(buffer)) {
199	styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
200	// prev_state=SCE_FORTH_DEFWORD
201	} else if(preword1.InList(buffer)) {
202	styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
203	// state=SCE_FORTH_PREWORD1;
204	} else if(preword2.InList(buffer)) {
205	styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
206	} else {
207	styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
208	}
209	*/
210	/*
211	chPrev=' ';
212	for (int i = startPos; i < lengthDoc; i++) {
213	char ch = chNext;
214	chNext = styler.SafeGetCharAt(i + 1);
215	if(i!=startPos) chPrev=styler.SafeGetCharAt(i - 1);
216
217	if (styler.IsLeadByte(ch)) {
218	chNext = styler.SafeGetCharAt(i + 2);
219	i++;
220	continue;
221	}
222	#ifdef FORTH_DEBUG
223	fprintf(f_debug,"%c %d ",ch,state);
224	#endif
225	switch(state) {
226	case SCE_FORTH_DEFAULT:
227	if(is_whitespace(ch)) {
228	// whitespace is simply ignored here...
229	styler.ColourTo(i,SCE_FORTH_DEFAULT);
230	break;
231	} else if( ch == '\\' && is_blank(chNext)) {
232	// signals the start of an one line comment...
233	state = SCE_FORTH_COMMENT;
234	styler.ColourTo(i,SCE_FORTH_COMMENT);
235	} else if( is_whitespace(chPrev) && ch == '(' && is_whitespace(chNext)) {
236	// signals the start of a plain comment...
237	state = SCE_FORTH_COMMENT_ML;
238	styler.ColourTo(i,SCE_FORTH_COMMENT_ML);
239	} else if( isdigit(ch) ) {
240	// signals the start of a number
241	bufferCount = 0;
242	buffer[bufferCount++] = ch;
243	state = SCE_FORTH_NUMBER;
244	} else if( !is_whitespace(ch)) {
245	// signals the start of an identifier
246	bufferCount = 0;
247	buffer[bufferCount++] = ch;
248	state = SCE_FORTH_IDENTIFIER;
249	} else {
250	// style it the default style..
251	styler.ColourTo(i,SCE_FORTH_DEFAULT);
252	}
253	break;
254
255	case SCE_FORTH_COMMENT:
256	// if we find a newline here,
257	// we simply go to default state
258	// else continue to work on it...
259	if( ch == '\n' \|\| ch == '\r' ) {
260	state = SCE_FORTH_DEFAULT;
261	} else {
262	styler.ColourTo(i,SCE_FORTH_COMMENT);
263	}
264	break;
265
266	case SCE_FORTH_COMMENT_ML:
267	if( ch == ')') {
268	state = SCE_FORTH_DEFAULT;
269	} else {
270	styler.ColourTo(i+1,SCE_FORTH_COMMENT_ML);
271	}
272	break;
273
274	case SCE_FORTH_IDENTIFIER:
275	// stay in CONF_IDENTIFIER state until we find a non-alphanumeric
276	if( !is_whitespace(ch) ) {
277	buffer[bufferCount++] = ch;
278	} else {
279	state = SCE_FORTH_DEFAULT;
280	buffer[bufferCount] = '\0';
281	#ifdef FORTH_DEBUG
282	fprintf(f_debug,"\nid %s\n",buffer);
283	#endif
284
285	// check if the buffer contains a keyword,
286	// and highlight it if it is a keyword...
287	// switch(prev_state)
288	// case SCE_FORTH_DEFAULT:
289	if(control.InList(buffer)) {
290	styler.ColourTo(i,SCE_FORTH_CONTROL);
291	} else if(keyword.InList(buffer)) {
292	styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
293	} else if(defword.InList(buffer)) {
294	styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
295	// prev_state=SCE_FORTH_DEFWORD
296	} else if(preword1.InList(buffer)) {
297	styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
298	// state=SCE_FORTH_PREWORD1;
299	} else if(preword2.InList(buffer)) {
300	styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
301	} else {
302	styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
303	}
304	// break;
305	// case
306
307	// push back the faulty character
308	chNext = styler[i--];
309	}
310	break;
311
312	case SCE_FORTH_NUMBER:
313	// stay in CONF_NUMBER state until we find a non-numeric
314	if( isdigit(ch) ) {
315	buffer[bufferCount++] = ch;
316	} else {
317	state = SCE_FORTH_DEFAULT;
318	buffer[bufferCount] = '\0';
319	// Colourize here... (normal number)
320	styler.ColourTo(i-1,SCE_FORTH_NUMBER);
321	// push back a character
322	chNext = styler[i--];
323	}
324	break;
325	}
326	}
327	#ifdef FORTH_DEBUG
328	fclose(f_debug);
329	#endif
330	delete []buffer;
331	*/
332	}
333
334	static void FoldForthDoc(unsigned int, int, int, WordList *[],
335	Accessor &) {
336	}
337
338	static const char * const forthWordLists[] = {
339	"control keywords",
340	"keywords",
341	"definition words",
342	"prewords with one argument",
343	"prewords with two arguments",
344	"string definition keywords",
345	0,
346	};
347
348	LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth",FoldForthDoc,forthWordLists);