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

// Scintilla source code edit control
/**
 * @file LexMagik.cxx
 * Lexer for GE(r) Smallworld(tm) MagikSF
 */
// Copyright 1998-2005 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 <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>

#include "ILexer.h"
#include "Scintilla.h"
#include "SciLexer.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

/**
 * Is it a core character (C isalpha(), exclamation and question mark)
 *
 * \param  ch The character
 * \return True if ch is a character, False otherwise
 */
static inline bool IsAlphaCore(int ch) {
    return (isalpha(ch) || ch == '!' || ch == '?');
}

/**
 * Is it a character (IsAlphaCore() and underscore)
 *
 * \param  ch The character
 * \return True if ch is a character, False otherwise
 */
static inline bool IsAlpha(int ch) {
    return (IsAlphaCore(ch) || ch == '_');
}

/**
 * Is it a symbolic character (IsAlpha() and colon)
 *
 * \param  ch The character
 * \return True if ch is a character, False otherwise
 */
static inline bool IsAlphaSym(int ch) {
    return (IsAlpha(ch) || ch == ':');
}

/**
 * Is it a numerical character (IsAlpha() and 0 - 9)
 *
 * \param  ch The character
 * \return True if ch is a character, False otherwise
 */
static inline bool IsAlNum(int ch) {
    return ((ch >= '0' && ch <= '9') || IsAlpha(ch));
}

/**
 * Is it a symbolic numerical character (IsAlNum() and colon)
 *
 * \param  ch The character
 * \return True if ch is a character, False otherwise
 */
static inline bool IsAlNumSym(int ch) {
    return (IsAlNum(ch) || ch == ':');
}

/**
 * The lexer function
 *
 * \param  startPos Where to start scanning
 * \param  length Where to scan to
 * \param  initStyle The style at the initial point, not used in this folder
 * \param  keywordslists The keywordslists, currently, number 5 is used
 * \param  styler The styler
 */
static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
                           WordList *keywordlists[], Accessor &styler) {
    styler.StartAt(startPos);

    WordList &keywords = *keywordlists[0];
    WordList &pragmatics = *keywordlists[1];
    WordList &containers = *keywordlists[2];
    WordList &flow = *keywordlists[3];
    WordList &characters = *keywordlists[4];

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


	for (; sc.More(); sc.Forward()) {

    repeat:

        if(sc.ch == '#') {
            if (sc.chNext == '#') sc.SetState(SCE_MAGIK_HYPER_COMMENT);
            else sc.SetState(SCE_MAGIK_COMMENT);
            for(; sc.More() && !(sc.atLineEnd); sc.Forward());
            sc.SetState(SCE_MAGIK_DEFAULT);
            goto repeat;
        }

        if(sc.ch == '"') {
            sc.SetState(SCE_MAGIK_STRING);

            if(sc.More())
            {
                sc.Forward();
                for(; sc.More() && sc.ch != '"'; sc.Forward());
            }

            sc.ForwardSetState(SCE_MAGIK_DEFAULT);
            goto repeat;
        }

	    // The default state
	    if(sc.state == SCE_MAGIK_DEFAULT) {

	        // A certain keyword has been detected
	        if (sc.ch == '_' && (
                    sc.currentPos == 0 || !IsAlNum(sc.chPrev))) {
	            char keyword[50];
	            memset(keyword, '\0', 50);

	            for(
                    int scanPosition = 0;
                    scanPosition < 50;
                    scanPosition++) {
	                char keywordChar = static_cast<char>(
                        tolower(styler.SafeGetCharAt(
                            scanPosition +
                                static_cast<int>(sc.currentPos+1), ' ')));
                    if(IsAlpha(keywordChar)) {
                        keyword[scanPosition] = keywordChar;
                    } else {
                        break;
                    }
	            }

                // It is a pragma
	            if(pragmatics.InList(keyword)) {
	                sc.SetState(SCE_MAGIK_PRAGMA);
	            }

	            // it is a normal keyword like _local, _self, etc.
	            else if(keywords.InList(keyword)) {
	                sc.SetState(SCE_MAGIK_KEYWORD);
	            }

                // It is a container keyword, such as _method, _proc, etc.
	            else if(containers.InList(keyword)) {
	                sc.SetState(SCE_MAGIK_CONTAINER);
	            }

	            // It is a flow keyword, such as _for, _if, _try, etc.
	            else if(flow.InList(keyword)) {
	                sc.SetState(SCE_MAGIK_FLOW);
	            }

	            // Interpret as unknown keyword
	            else {
	                sc.SetState(SCE_MAGIK_UNKNOWN_KEYWORD);
	            }
	        }

            // Symbolic expression
	        else if(sc.ch == ':' && !IsAlNum(sc.chPrev)) {
	            sc.SetState(SCE_MAGIK_SYMBOL);
	            bool firstTrip = true;
	            for(sc.Forward(); sc.More(); sc.Forward()) {
	                if(firstTrip && IsAlphaSym(sc.ch));
	                else if(!firstTrip && IsAlNumSym(sc.ch));
	                else if(sc.ch == '|') {
	                    for(sc.Forward();
                            sc.More() && sc.ch != '|';
                            sc.Forward());
	                }
	                else break;

	                firstTrip = false;
	            }
	            sc.SetState(SCE_MAGIK_DEFAULT);
	            goto repeat;
	        }

            // Identifier (label) expression
	        else if(sc.ch == '@') {
	            sc.SetState(SCE_MAGIK_IDENTIFIER);
	            bool firstTrip = true;
	            for(sc.Forward(); sc.More(); sc.Forward()) {
	                if(firstTrip && IsAlphaCore(sc.ch)) {
	                    firstTrip = false;
	                }
	                else if(!firstTrip && IsAlpha(sc.ch));
	                else break;
	            }
	            sc.SetState(SCE_MAGIK_DEFAULT);
	            goto repeat;
	        }

	        // Start of a character
            else if(sc.ch == '%') {
                sc.SetState(SCE_MAGIK_CHARACTER);
                sc.Forward();
                char keyword[50];
	            memset(keyword, '\0', 50);

	            for(
                    int scanPosition = 0;
                    scanPosition < 50;
                    scanPosition++) {
	                char keywordChar = static_cast<char>(
                        tolower(styler.SafeGetCharAt(
                            scanPosition +
                                static_cast<int>(sc.currentPos), ' ')));
                    if(IsAlpha(keywordChar)) {
                        keyword[scanPosition] = keywordChar;
                    } else {
                        break;
                    }
	            }

	            if(characters.InList(keyword)) {
	                sc.Forward(static_cast<int>(strlen(keyword)));
	            } else {
	                sc.Forward();
	            }

                sc.SetState(SCE_MAGIK_DEFAULT);
                goto repeat;
            }

            // Operators
	        else if(
                sc.ch == '>' ||
                sc.ch == '<' ||
                sc.ch == '.' ||
                sc.ch == ',' ||
                sc.ch == '+' ||
                sc.ch == '-' ||
                sc.ch == '/' ||
                sc.ch == '*' ||
                sc.ch == '~' ||
                sc.ch == '$' ||
                sc.ch == '=') {
                sc.SetState(SCE_MAGIK_OPERATOR);
            }

            // Braces
            else if(sc.ch == '(' || sc.ch == ')') {
                sc.SetState(SCE_MAGIK_BRACE_BLOCK);
            }

            // Brackets
            else if(sc.ch == '{' || sc.ch == '}') {
                sc.SetState(SCE_MAGIK_BRACKET_BLOCK);
            }

            // Square Brackets
            else if(sc.ch == '[' || sc.ch == ']') {
                sc.SetState(SCE_MAGIK_SQBRACKET_BLOCK);
            }


	    }

	    // It is an operator
	    else if(
            sc.state == SCE_MAGIK_OPERATOR ||
            sc.state == SCE_MAGIK_BRACE_BLOCK ||
            sc.state == SCE_MAGIK_BRACKET_BLOCK ||
            sc.state == SCE_MAGIK_SQBRACKET_BLOCK) {
	        sc.SetState(SCE_MAGIK_DEFAULT);
	        goto repeat;
	    }

	    // It is the pragma state
	    else if(sc.state == SCE_MAGIK_PRAGMA) {
	        if(!IsAlpha(sc.ch)) {
	            sc.SetState(SCE_MAGIK_DEFAULT);
                goto repeat;
	        }
	    }

	    // It is the keyword state
	    else if(
            sc.state == SCE_MAGIK_KEYWORD ||
            sc.state == SCE_MAGIK_CONTAINER ||
            sc.state == SCE_MAGIK_FLOW ||
            sc.state == SCE_MAGIK_UNKNOWN_KEYWORD) {
	        if(!IsAlpha(sc.ch)) {
	            sc.SetState(SCE_MAGIK_DEFAULT);
	            goto repeat;
	        }
	    }
	}

	sc.Complete();
}

/**
 * The word list description
 */
static const char * const magikWordListDesc[] = {
    "Accessors (local, global, self, super, thisthread)",
    "Pragmatic (pragma, private)",
    "Containers (method, block, proc)",
    "Flow (if, then, elif, else)",
    "Characters (space, tab, newline, return)",
    "Fold Containers (method, proc, block, if, loop)",
    0};

/**
 * This function detects keywords which are able to have a body. Note that it
 * uses the Fold Containers word description, not the containers description. It
 * only works when the style at that particular position is set on Containers
 * or Flow (number 3 or 4).
 *
 * \param  keywordslist The list of keywords that are scanned, they should only
 *         contain the start keywords, not the end keywords
 * \param  The actual keyword
 * \return 1 if it is a folding start-keyword, -1 if it is a folding end-keyword
 *         0 otherwise
 */
static inline int IsFoldingContainer(WordList &keywordslist, char * keyword) {
    if(
        strlen(keyword) > 3 &&
        keyword[0] == 'e' && keyword[1] == 'n' && keyword[2] == 'd') {
        if (keywordslist.InList(keyword + 3)) {
            return -1;
        }

    } else {
        if(keywordslist.InList(keyword)) {
            return 1;
        }
    }

    return 0;
}

/**
 * The folding function
 *
 * \param  startPos Where to start scanning
 * \param  length Where to scan to
 * \param  keywordslists The keywordslists, currently, number 5 is used
 * \param  styler The styler
 */
static void FoldMagikDoc(unsigned int startPos, int length, int,
    WordList *keywordslists[], Accessor &styler) {

    bool compact = styler.GetPropertyInt("fold.compact") != 0;

    WordList &foldingElements = *keywordslists[5];
    int endPos = startPos + length;
    int line = styler.GetLine(startPos);
    int level = styler.LevelAt(line) & SC_FOLDLEVELNUMBERMASK;
    int flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;

    for(
        int currentPos = startPos;
        currentPos < endPos;
        currentPos++) {
            char currentState = styler.StyleAt(currentPos);
            char c = styler.SafeGetCharAt(currentPos, ' ');
            int prevLine = styler.GetLine(currentPos - 1);
            line = styler.GetLine(currentPos);

            // Default situation
            if(prevLine < line) {
                styler.SetLevel(line, (level|flags) & ~SC_FOLDLEVELHEADERFLAG);
                flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
            }

            if(
                (
                    currentState == SCE_MAGIK_CONTAINER ||
                    currentState == SCE_MAGIK_FLOW
                ) &&
                c == '_') {

                char keyword[50];
                memset(keyword, '\0', 50);

                for(
                    int scanPosition = 0;
                    scanPosition < 50;
                    scanPosition++) {
                    char keywordChar = static_cast<char>(
                        tolower(styler.SafeGetCharAt(
                            scanPosition +
                                currentPos + 1, ' ')));
                    if(IsAlpha(keywordChar)) {
                        keyword[scanPosition] = keywordChar;
                    } else {
                        break;
                    }
                }

                if(IsFoldingContainer(foldingElements, keyword) > 0) {
                    styler.SetLevel(
                        line,
                        styler.LevelAt(line) | SC_FOLDLEVELHEADERFLAG);
                    level++;
                } else if(IsFoldingContainer(foldingElements, keyword) < 0) {
                    styler.SetLevel(line, styler.LevelAt(line));
                    level--;
                }
            }

            if(
                compact && (
                    currentState == SCE_MAGIK_BRACE_BLOCK ||
                    currentState == SCE_MAGIK_BRACKET_BLOCK ||
                    currentState == SCE_MAGIK_SQBRACKET_BLOCK)) {
                if(c == '{' || c == '[' || c == '(') {
                    styler.SetLevel(
                        line,
                        styler.LevelAt(line) | SC_FOLDLEVELHEADERFLAG);
                    level++;
                } else if(c == '}' || c == ']' || c == ')') {
                    styler.SetLevel(line, styler.LevelAt(line));
                    level--;
                }
            }
        }

}

/**
 * Injecting the module
 */
LexerModule lmMagikSF(
    SCLEX_MAGIK, ColouriseMagikDoc, "magiksf", FoldMagikDoc, magikWordListDesc);
Commit	Line	Data
9e96e16f RD	1	// Scintilla source code edit control
	2	/**
	3	* @file LexMagik.cxx
	4	* Lexer for GE(r) Smallworld(tm) MagikSF
	5	*/
	6	// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
	7	// The License.txt file describes the conditions under which this software may be distributed.
	8
	9	#include <stdlib.h>
	10	#include <string.h>
9e96e16f RD	11	#include <stdio.h>
9e96e16f RD	12	#include <stdarg.h>
1dcf666d RD	13	#include <assert.h>
1dcf666d RD	14	#include <ctype.h>
9e96e16f	15
1dcf666d RD	16	#include "ILexer.h"
	17	#include "Scintilla.h"
	18	#include "SciLexer.h"
9e96e16f	19
1dcf666d RD	20	#include "WordList.h"
1dcf666d RD	21	#include "LexAccessor.h"
9e96e16f RD	22	#include "Accessor.h"
9e96e16f RD	23	#include "StyleContext.h"
1dcf666d RD	24	#include "CharacterSet.h"
1dcf666d RD	25	#include "LexerModule.h"
9e96e16f RD	26
	27	#ifdef SCI_NAMESPACE
	28	using namespace Scintilla;
	29	#endif
	30
	31	/**
	32	* Is it a core character (C isalpha(), exclamation and question mark)
	33	*
	34	* \param ch The character
	35	* \return True if ch is a character, False otherwise
	36	*/
	37	static inline bool IsAlphaCore(int ch) {
	38	return (isalpha(ch) \|\| ch == '!' \|\| ch == '?');
	39	}
	40
	41	/**
	42	* Is it a character (IsAlphaCore() and underscore)
	43	*
	44	* \param ch The character
	45	* \return True if ch is a character, False otherwise
	46	*/
	47	static inline bool IsAlpha(int ch) {
	48	return (IsAlphaCore(ch) \|\| ch == '_');
	49	}
	50
	51	/**
	52	* Is it a symbolic character (IsAlpha() and colon)
	53	*
	54	* \param ch The character
	55	* \return True if ch is a character, False otherwise
	56	*/
	57	static inline bool IsAlphaSym(int ch) {
	58	return (IsAlpha(ch) \|\| ch == ':');
	59	}
	60
	61	/**
	62	* Is it a numerical character (IsAlpha() and 0 - 9)
	63	*
	64	* \param ch The character
	65	* \return True if ch is a character, False otherwise
	66	*/
	67	static inline bool IsAlNum(int ch) {
	68	return ((ch >= '0' && ch <= '9') \|\| IsAlpha(ch));
	69	}
	70
	71	/**
	72	* Is it a symbolic numerical character (IsAlNum() and colon)
	73	*
	74	* \param ch The character
	75	* \return True if ch is a character, False otherwise
	76	*/
	77	static inline bool IsAlNumSym(int ch) {
	78	return (IsAlNum(ch) \|\| ch == ':');
	79	}
	80
	81	/**
	82	* The lexer function
	83	*
	84	* \param startPos Where to start scanning
	85	* \param length Where to scan to
	86	* \param initStyle The style at the initial point, not used in this folder
	87	* \param keywordslists The keywordslists, currently, number 5 is used
	88	* \param styler The styler
	89	*/
90	static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
91	WordList *keywordlists[], Accessor &styler) {
92	styler.StartAt(startPos);
93
94	WordList &keywords = *keywordlists[0];
95	WordList &pragmatics = *keywordlists[1];
96	WordList &containers = *keywordlists[2];
97	WordList &flow = *keywordlists[3];
98	WordList &characters = *keywordlists[4];
99
100	StyleContext sc(startPos, length, initStyle, styler);
101
102
103	for (; sc.More(); sc.Forward()) {
104
105	repeat:
106
107	if(sc.ch == '#') {
108	if (sc.chNext == '#') sc.SetState(SCE_MAGIK_HYPER_COMMENT);
109	else sc.SetState(SCE_MAGIK_COMMENT);
110	for(; sc.More() && !(sc.atLineEnd); sc.Forward());
111	sc.SetState(SCE_MAGIK_DEFAULT);
112	goto repeat;
113	}
114
115	if(sc.ch == '"') {
116	sc.SetState(SCE_MAGIK_STRING);
117
118	if(sc.More())
119	{
120	sc.Forward();
121	for(; sc.More() && sc.ch != '"'; sc.Forward());
122	}
123
124	sc.ForwardSetState(SCE_MAGIK_DEFAULT);
125	goto repeat;
126	}
127
128	// The default state
129	if(sc.state == SCE_MAGIK_DEFAULT) {
130
131	// A certain keyword has been detected
132	if (sc.ch == '_' && (
133	sc.currentPos == 0 \|\| !IsAlNum(sc.chPrev))) {
134	char keyword[50];
135	memset(keyword, '\0', 50);
136
137	for(
138	int scanPosition = 0;
139	scanPosition < 50;
140	scanPosition++) {
141	char keywordChar = static_cast<char>(
142	tolower(styler.SafeGetCharAt(
143	scanPosition +
144	static_cast<int>(sc.currentPos+1), ' ')));
145	if(IsAlpha(keywordChar)) {
146	keyword[scanPosition] = keywordChar;
147	} else {
148	break;
149	}
150	}
151
152	// It is a pragma
153	if(pragmatics.InList(keyword)) {
154	sc.SetState(SCE_MAGIK_PRAGMA);
155	}
156
157	// it is a normal keyword like _local, _self, etc.
158	else if(keywords.InList(keyword)) {
159	sc.SetState(SCE_MAGIK_KEYWORD);
160	}
161
162	// It is a container keyword, such as _method, _proc, etc.
163	else if(containers.InList(keyword)) {
164	sc.SetState(SCE_MAGIK_CONTAINER);
165	}
166
167	// It is a flow keyword, such as _for, _if, _try, etc.
168	else if(flow.InList(keyword)) {
169	sc.SetState(SCE_MAGIK_FLOW);
170	}
171
172	// Interpret as unknown keyword
173	else {
174	sc.SetState(SCE_MAGIK_UNKNOWN_KEYWORD);
175	}
176	}
177
178	// Symbolic expression
179	else if(sc.ch == ':' && !IsAlNum(sc.chPrev)) {
180	sc.SetState(SCE_MAGIK_SYMBOL);
181	bool firstTrip = true;
182	for(sc.Forward(); sc.More(); sc.Forward()) {
183	if(firstTrip && IsAlphaSym(sc.ch));
184	else if(!firstTrip && IsAlNumSym(sc.ch));
185	else if(sc.ch == '\|') {
186	for(sc.Forward();
187	sc.More() && sc.ch != '\|';
188	sc.Forward());
189	}
190	else break;
191
192	firstTrip = false;
193	}
194	sc.SetState(SCE_MAGIK_DEFAULT);
195	goto repeat;
196	}
197
198	// Identifier (label) expression
199	else if(sc.ch == '@') {
200	sc.SetState(SCE_MAGIK_IDENTIFIER);
201	bool firstTrip = true;
202	for(sc.Forward(); sc.More(); sc.Forward()) {
203	if(firstTrip && IsAlphaCore(sc.ch)) {
204	firstTrip = false;
205	}
206	else if(!firstTrip && IsAlpha(sc.ch));
207	else break;
208	}
209	sc.SetState(SCE_MAGIK_DEFAULT);
210	goto repeat;
211	}
212
213	// Start of a character
214	else if(sc.ch == '%') {
215	sc.SetState(SCE_MAGIK_CHARACTER);
216	sc.Forward();
217	char keyword[50];
218	memset(keyword, '\0', 50);
219
220	for(
221	int scanPosition = 0;
222	scanPosition < 50;
223	scanPosition++) {
224	char keywordChar = static_cast<char>(
225	tolower(styler.SafeGetCharAt(
226	scanPosition +
227	static_cast<int>(sc.currentPos), ' ')));
228	if(IsAlpha(keywordChar)) {
229	keyword[scanPosition] = keywordChar;
230	} else {
231	break;
232	}
233	}
234
235	if(characters.InList(keyword)) {
1dcf666d	236	sc.Forward(static_cast<int>(strlen(keyword)));
9e96e16f RD	237	} else {
	238	sc.Forward();
	239	}
	240
	241	sc.SetState(SCE_MAGIK_DEFAULT);
	242	goto repeat;
	243	}
	244
	245	// Operators
	246	else if(
	247	sc.ch == '>' \|\|
	248	sc.ch == '<' \|\|
	249	sc.ch == '.' \|\|
	250	sc.ch == ',' \|\|
	251	sc.ch == '+' \|\|
	252	sc.ch == '-' \|\|
	253	sc.ch == '/' \|\|
	254	sc.ch == '*' \|\|
	255	sc.ch == '~' \|\|
	256	sc.ch == '$' \|\|
	257	sc.ch == '=') {
	258	sc.SetState(SCE_MAGIK_OPERATOR);
	259	}
	260
	261	// Braces
	262	else if(sc.ch == '(' \|\| sc.ch == ')') {
	263	sc.SetState(SCE_MAGIK_BRACE_BLOCK);
	264	}
	265
	266	// Brackets
	267	else if(sc.ch == '{' \|\| sc.ch == '}') {
	268	sc.SetState(SCE_MAGIK_BRACKET_BLOCK);
	269	}
	270
	271	// Square Brackets
	272	else if(sc.ch == '[' \|\| sc.ch == ']') {
	273	sc.SetState(SCE_MAGIK_SQBRACKET_BLOCK);
	274	}
	275
	276
	277	}
	278
	279	// It is an operator
	280	else if(
	281	sc.state == SCE_MAGIK_OPERATOR \|\|
	282	sc.state == SCE_MAGIK_BRACE_BLOCK \|\|
	283	sc.state == SCE_MAGIK_BRACKET_BLOCK \|\|
	284	sc.state == SCE_MAGIK_SQBRACKET_BLOCK) {
	285	sc.SetState(SCE_MAGIK_DEFAULT);
	286	goto repeat;
	287	}
	288
	289	// It is the pragma state
	290	else if(sc.state == SCE_MAGIK_PRAGMA) {
	291	if(!IsAlpha(sc.ch)) {
	292	sc.SetState(SCE_MAGIK_DEFAULT);
	293	goto repeat;
	294	}
	295	}
	296
	297	// It is the keyword state
	298	else if(
	299	sc.state == SCE_MAGIK_KEYWORD \|\|
	300	sc.state == SCE_MAGIK_CONTAINER \|\|
301	sc.state == SCE_MAGIK_FLOW \|\|
302	sc.state == SCE_MAGIK_UNKNOWN_KEYWORD) {
303	if(!IsAlpha(sc.ch)) {
304	sc.SetState(SCE_MAGIK_DEFAULT);
305	goto repeat;
306	}
307	}
308	}
309
310	sc.Complete();
311	}
312
313	/**
314	* The word list description
315	*/
316	static const char * const magikWordListDesc[] = {
317	"Accessors (local, global, self, super, thisthread)",
318	"Pragmatic (pragma, private)",
319	"Containers (method, block, proc)",
320	"Flow (if, then, elif, else)",
321	"Characters (space, tab, newline, return)",
322	"Fold Containers (method, proc, block, if, loop)",
323	0};
324
325	/**
326	* This function detects keywords which are able to have a body. Note that it
327	* uses the Fold Containers word description, not the containers description. It
328	* only works when the style at that particular position is set on Containers
329	* or Flow (number 3 or 4).
330	*
331	* \param keywordslist The list of keywords that are scanned, they should only
332	* contain the start keywords, not the end keywords
333	* \param The actual keyword
334	* \return 1 if it is a folding start-keyword, -1 if it is a folding end-keyword
335	* 0 otherwise
336	*/
337	static inline int IsFoldingContainer(WordList &keywordslist, char * keyword) {
338	if(
339	strlen(keyword) > 3 &&
340	keyword[0] == 'e' && keyword[1] == 'n' && keyword[2] == 'd') {
341	if (keywordslist.InList(keyword + 3)) {
342	return -1;
343	}
344
345	} else {
346	if(keywordslist.InList(keyword)) {
347	return 1;
348	}
349	}
350
351	return 0;
352	}
353
354	/**
355	* The folding function
356	*
357	* \param startPos Where to start scanning
358	* \param length Where to scan to
359	* \param keywordslists The keywordslists, currently, number 5 is used
360	* \param styler The styler
361	*/
362	static void FoldMagikDoc(unsigned int startPos, int length, int,
363	WordList *keywordslists[], Accessor &styler) {
364
365	bool compact = styler.GetPropertyInt("fold.compact") != 0;
366
367	WordList &foldingElements = *keywordslists[5];
368	int endPos = startPos + length;
369	int line = styler.GetLine(startPos);
370	int level = styler.LevelAt(line) & SC_FOLDLEVELNUMBERMASK;
371	int flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
372
373	for(
374	int currentPos = startPos;
375	currentPos < endPos;
376	currentPos++) {
377	char currentState = styler.StyleAt(currentPos);
378	char c = styler.SafeGetCharAt(currentPos, ' ');
379	int prevLine = styler.GetLine(currentPos - 1);
380	line = styler.GetLine(currentPos);
381
382	// Default situation
383	if(prevLine < line) {
384	styler.SetLevel(line, (level\|flags) & ~SC_FOLDLEVELHEADERFLAG);
385	flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
386	}
387
388	if(
389	(
390	currentState == SCE_MAGIK_CONTAINER \|\|
391	currentState == SCE_MAGIK_FLOW
392	) &&
393	c == '_') {
394
395	char keyword[50];
396	memset(keyword, '\0', 50);
397
398	for(
399	int scanPosition = 0;
400	scanPosition < 50;
401	scanPosition++) {
402	char keywordChar = static_cast<char>(
403	tolower(styler.SafeGetCharAt(
404	scanPosition +
405	currentPos + 1, ' ')));
406	if(IsAlpha(keywordChar)) {
407	keyword[scanPosition] = keywordChar;
408	} else {
409	break;
410	}
411	}
412
413	if(IsFoldingContainer(foldingElements, keyword) > 0) {
414	styler.SetLevel(
415	line,
416	styler.LevelAt(line) \| SC_FOLDLEVELHEADERFLAG);
417	level++;
418	} else if(IsFoldingContainer(foldingElements, keyword) < 0) {
419	styler.SetLevel(line, styler.LevelAt(line));
420	level--;
421	}
422	}
423
424	if(
425	compact && (
426	currentState == SCE_MAGIK_BRACE_BLOCK \|\|
427	currentState == SCE_MAGIK_BRACKET_BLOCK \|\|
428	currentState == SCE_MAGIK_SQBRACKET_BLOCK)) {
429	if(c == '{' \|\| c == '[' \|\| c == '(') {
430	styler.SetLevel(
431	line,
432	styler.LevelAt(line) \| SC_FOLDLEVELHEADERFLAG);
433	level++;
434	} else if(c == '}' \|\| c == ']' \|\| c == ')') {
435	styler.SetLevel(line, styler.LevelAt(line));
436	level--;
437	}
438	}
439	}
440
441	}
442
443	/**
444	* Injecting the module
445	*/
446	LexerModule lmMagikSF(
447	SCLEX_MAGIK, ColouriseMagikDoc, "magiksf", FoldMagikDoc, magikWordListDesc);
448