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

// Scintilla source code edit control
// @file LexPB.cxx
// Lexer for PowerBasic by Roland Walter, roland@rowalt.de (for PowerBasic see www.powerbasic.com)
//
// Changes:
// 17.10.2003: Toggling of subs/functions now until next sub/function - this gives better results
// 29.10.2003: 1. Bug: Toggling didn't work for subs/functions added in editor
//             2. Own colors for PB constants and Inline Assembler SCE_B_CONSTANT and SCE_B_ASM
//             3. Several smaller syntax coloring improvements and speed optimizations
// 12.07.2004: 1. Toggling for macros added
//             2. Further folding speed optimitations (for people dealing with very large listings)
//
// Necessary changes for the PB lexer in Scintilla project:
//  - In SciLexer.h and Scintilla.iface:
//
//    #define SCLEX_POWERBASIC 51       //ID for PowerBasic lexer
//    (...)
//    #define SCE_B_DEFAULT 0           //in both VB and PB lexer
//    #define SCE_B_COMMENT 1           //in both VB and PB lexer
//    #define SCE_B_NUMBER 2            //in both VB and PB lexer
//    #define SCE_B_KEYWORD 3           //in both VB and PB lexer
//    #define SCE_B_STRING 4            //in both VB and PB lexer
//    #define SCE_B_PREPROCESSOR 5      //VB lexer only, not in PB lexer
//    #define SCE_B_OPERATOR 6          //in both VB and PB lexer
//    #define SCE_B_IDENTIFIER 7        //in both VB and PB lexer
//    #define SCE_B_DATE 8              //VB lexer only, not in PB lexer
//    #define SCE_B_CONSTANT 13         //PB lexer only, not in VB lexer
//    #define SCE_B_ASM 14              //PB lexer only, not in VB lexer

//  - Statement added to KeyWords.cxx:      'LINK_LEXER(lmPB);'
//  - Statement added to scintilla_vc6.mak: '$(DIR_O)\LexPB.obj: ...\src\LexPB.cxx $(LEX_HEADERS)'
//
// Copyright for Scintilla: 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 <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

static inline bool IsTypeCharacter(const int ch)
{
    return ch == '%' || ch == '&' || ch == '@' || ch == '!' || ch == '#' || ch == '$' || ch == '?';
}

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

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

bool MatchUpperCase(Accessor &styler, int pos, const char *s)   //Same as styler.Match() but uppercase comparison (a-z,A-Z and space only)
{
    char ch;
    for (int i=0; *s; i++)
    {
        ch=styler.SafeGetCharAt(pos+i);
        if (ch > 0x60) ch -= '\x20';
        if (*s != ch) return false;
        s++;
    }
    return true;
}

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

    WordList &keywords = *keywordlists[0];

    styler.StartAt(startPos);

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

    for (; sc.More(); sc.Forward()) {
        switch (sc.state)
        {
            case SCE_B_OPERATOR:
            {
                sc.SetState(SCE_B_DEFAULT);
                break;
            }
            case SCE_B_KEYWORD:
            {
                if (!IsAWordChar(sc.ch))
                {
                    if (!IsTypeCharacter(sc.ch))
                    {
                        char s[100];
                        sc.GetCurrentLowered(s, sizeof(s));
                        if (keywords.InList(s))
                        {
                            if (strcmp(s, "rem") == 0)
                            {
                                sc.ChangeState(SCE_B_COMMENT);
                                if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
                            }
                            else if (strcmp(s, "asm") == 0)
                            {
                                sc.ChangeState(SCE_B_ASM);
                                if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
                            }
                            else
                            {
                                sc.SetState(SCE_B_DEFAULT);
                            }
                        }
                        else
                        {
                            sc.ChangeState(SCE_B_IDENTIFIER);
                            sc.SetState(SCE_B_DEFAULT);
                        }
                    }
                }
                break;
            }
            case SCE_B_NUMBER:
            {
                if (!IsAWordChar(sc.ch)) {sc.SetState(SCE_B_DEFAULT);}
                break;
            }
            case SCE_B_STRING:
            {
                if (sc.ch == '\"'){sc.ForwardSetState(SCE_B_DEFAULT);}
                break;
            }
            case SCE_B_CONSTANT:
            {
                if (!IsAWordChar(sc.ch)) {sc.SetState(SCE_B_DEFAULT);}
                break;
            }
            case SCE_B_COMMENT:
            {
                if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
                break;
            }
            case SCE_B_ASM:
            {
                if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
                break;
            }
        }  //switch (sc.state)

        // Determine if a new state should be entered:
        if (sc.state == SCE_B_DEFAULT)
        {
            if (sc.ch == '\'') {sc.SetState(SCE_B_COMMENT);}
            else if (sc.ch == '\"') {sc.SetState(SCE_B_STRING);}
            else if (sc.ch == '&' && tolower(sc.chNext) == 'h') {sc.SetState(SCE_B_NUMBER);}
            else if (sc.ch == '&' && tolower(sc.chNext) == 'b') {sc.SetState(SCE_B_NUMBER);}
            else if (sc.ch == '&' && tolower(sc.chNext) == 'o') {sc.SetState(SCE_B_NUMBER);}
            else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {sc.SetState(SCE_B_NUMBER);}
            else if (IsAWordStart(sc.ch)) {sc.SetState(SCE_B_KEYWORD);}
            else if (sc.ch == '%') {sc.SetState(SCE_B_CONSTANT);}
            else if (sc.ch == '$') {sc.SetState(SCE_B_CONSTANT);}
            else if (sc.ch == '#') {sc.SetState(SCE_B_KEYWORD);}
            else if (sc.ch == '!') {sc.SetState(SCE_B_ASM);}
            else if (isoperator(static_cast<char>(sc.ch)) || (sc.ch == '\\')) {sc.SetState(SCE_B_OPERATOR);}
        }
    }      //for (; sc.More(); sc.Forward())
    sc.Complete();
}

//The folding routine for PowerBasic toggles SUBs and FUNCTIONs only. This was exactly what I wanted,
//nothing more. I had worked with this kind of toggling for several years when I used the great good old
//GFA Basic which is dead now. After testing the feature of toggling FOR-NEXT loops, WHILE-WEND loops
//and so on too I found this is more disturbing then helping (for me). So if You think in another way
//you can (or must) write Your own toggling routine ;-)
static void FoldPBDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
{
    // No folding enabled, no reason to continue...
    if( styler.GetPropertyInt("fold") == 0 )
        return;

    unsigned int endPos = startPos + length;
    int lineCurrent = styler.GetLine(startPos);
    int levelCurrent = SC_FOLDLEVELBASE;
    if (lineCurrent > 0)
        levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
    int levelNext = levelCurrent;
    char chNext = styler[startPos];

    bool fNewLine=true;
    bool fMightBeMultiLineMacro=false;
    bool fBeginOfCommentFound=false;
    for (unsigned int i = startPos; i < endPos; i++)
    {
        char ch = chNext;
        chNext = styler.SafeGetCharAt(i + 1);

        if (fNewLine)            //Begin of a new line (The Sub/Function/Macro keywords may occur at begin of line only)
        {
            fNewLine=false;
            fBeginOfCommentFound=false;
            switch (ch)
            {
            case ' ':      //Most lines start with space - so check this first, the code is the same as for 'default:'
            case '\t':     //Handle tab too
                {
                    int levelUse = levelCurrent;
                    int lev = levelUse | levelNext << 16;
                    styler.SetLevel(lineCurrent, lev);
                    break;
                }
            case 'F':
            case 'f':
                {
					switch (chNext)
					{
                    case 'U':
                    case 'u':
						{
							if( MatchUpperCase(styler,i,"FUNCTION") )
							{
								styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
								levelNext=SC_FOLDLEVELBASE+1;
							}
							break;
						}
					}
                break;
                }
            case 'S':
            case 's':
                {
					switch (chNext)
					{
                    case 'U':
                    case 'u':
						{
							if( MatchUpperCase(styler,i,"SUB") )
							{
								styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
								levelNext=SC_FOLDLEVELBASE+1;
							}
							break;
						}
                    case 'T':
                    case 't':
						{
							if( MatchUpperCase(styler,i,"STATIC FUNCTION") )
							{
								styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
								levelNext=SC_FOLDLEVELBASE+1;
							}
							else if( MatchUpperCase(styler,i,"STATIC SUB") )
							{
								styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
								levelNext=SC_FOLDLEVELBASE+1;
							}
							break;
						}
					}
                break;
                }
            case 'C':
            case 'c':
                {
					switch (chNext)
					{
                    case 'A':
                    case 'a':
						{
							if( MatchUpperCase(styler,i,"CALLBACK FUNCTION") )
							{
								styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
								levelNext=SC_FOLDLEVELBASE+1;
							}
							break;
						}
					}
                break;
                }
            case 'M':
            case 'm':
                {
					switch (chNext)
					{
                    case 'A':
                    case 'a':
						{
							if( MatchUpperCase(styler,i,"MACRO") )
							{
								fMightBeMultiLineMacro=true;  //Set folder level at end of line, we have to check for single line macro
							}
							break;
						}
					}
                break;
                }
            default:
                {
                    int levelUse = levelCurrent;
                    int lev = levelUse | levelNext << 16;
                    styler.SetLevel(lineCurrent, lev);
                    break;
                }
            }  //switch (ch)
        }  //if( fNewLine )

        switch (ch)
        {
            case '=':                              //To test single line macros
            {
                if (fBeginOfCommentFound==false)
                    fMightBeMultiLineMacro=false;  //The found macro is a single line macro only;
                break;
            }
            case '\'':                             //A comment starts
            {
                fBeginOfCommentFound=true;
                break;
            }
            case '\n':
            {
                if (fMightBeMultiLineMacro)        //The current line is the begin of a multi line macro
                {
                    fMightBeMultiLineMacro=false;
                    styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) | SC_FOLDLEVELHEADERFLAG);
                    levelNext=SC_FOLDLEVELBASE+1;
                }
                lineCurrent++;
                levelCurrent = levelNext;
                fNewLine=true;
                break;
            }
            case '\r':
            {
                if (chNext != '\n')
                {
                    lineCurrent++;
                    levelCurrent = levelNext;
                    fNewLine=true;
                }
                break;
            }
        }  //switch (ch)
    }  //for (unsigned int i = startPos; i < endPos; i++)
}

static const char * const pbWordListDesc[] = {
    "Keywords",
    0
};

LexerModule lmPB(SCLEX_POWERBASIC, ColourisePBDoc, "powerbasic", FoldPBDoc, pbWordListDesc);
Commit	Line	Data
8e54aaed	1	// Scintilla source code edit control
591d01be RD	2	// @file LexPB.cxx
591d01be RD	3	// Lexer for PowerBasic by Roland Walter, roland@rowalt.de (for PowerBasic see www.powerbasic.com)
8e54aaed	4	//
591d01be	5	// Changes:
a33203cb RD	6	// 17.10.2003: Toggling of subs/functions now until next sub/function - this gives better results
	7	// 29.10.2003: 1. Bug: Toggling didn't work for subs/functions added in editor
	8	// 2. Own colors for PB constants and Inline Assembler SCE_B_CONSTANT and SCE_B_ASM
	9	// 3. Several smaller syntax coloring improvements and speed optimizations
	10	// 12.07.2004: 1. Toggling for macros added
	11	// 2. Further folding speed optimitations (for people dealing with very large listings)
	12	//
	13	// Necessary changes for the PB lexer in Scintilla project:
	14	// - In SciLexer.h and Scintilla.iface:
	15	//
	16	// #define SCLEX_POWERBASIC 51 //ID for PowerBasic lexer
	17	// (...)
	18	// #define SCE_B_DEFAULT 0 //in both VB and PB lexer
	19	// #define SCE_B_COMMENT 1 //in both VB and PB lexer
	20	// #define SCE_B_NUMBER 2 //in both VB and PB lexer
	21	// #define SCE_B_KEYWORD 3 //in both VB and PB lexer
	22	// #define SCE_B_STRING 4 //in both VB and PB lexer
	23	// #define SCE_B_PREPROCESSOR 5 //VB lexer only, not in PB lexer
	24	// #define SCE_B_OPERATOR 6 //in both VB and PB lexer
	25	// #define SCE_B_IDENTIFIER 7 //in both VB and PB lexer
	26	// #define SCE_B_DATE 8 //VB lexer only, not in PB lexer
	27	// #define SCE_B_CONSTANT 13 //PB lexer only, not in VB lexer
	28	// #define SCE_B_ASM 14 //PB lexer only, not in VB lexer
	29
	30	// - Statement added to KeyWords.cxx: 'LINK_LEXER(lmPB);'
	31	// - Statement added to scintilla_vc6.mak: '$(DIR_O)\LexPB.obj: ...\src\LexPB.cxx $(LEX_HEADERS)'
8e54aaed RD	32	//
	33	// Copyright for Scintilla: 1998-2001 by Neil Hodgson <neilh@scintilla.org>
	34	// The License.txt file describes the conditions under which this software may be distributed.
	35
	36	#include <stdlib.h>
	37	#include <string.h>
8e54aaed RD	38	#include <stdio.h>
8e54aaed RD	39	#include <stdarg.h>
1dcf666d RD	40	#include <assert.h>
1dcf666d RD	41	#include <ctype.h>
8e54aaed	42
1dcf666d RD	43	#include "ILexer.h"
	44	#include "Scintilla.h"
	45	#include "SciLexer.h"
8e54aaed	46
1dcf666d RD	47	#include "WordList.h"
1dcf666d RD	48	#include "LexAccessor.h"
8e54aaed RD	49	#include "Accessor.h"
8e54aaed RD	50	#include "StyleContext.h"
1dcf666d RD	51	#include "CharacterSet.h"
1dcf666d RD	52	#include "LexerModule.h"
8e54aaed	53
7e0c58e9 RD	54	#ifdef SCI_NAMESPACE
	55	using namespace Scintilla;
	56	#endif
	57
591d01be RD	58	static inline bool IsTypeCharacter(const int ch)
	59	{
	60	return ch == '%' \|\| ch == '&' \|\| ch == '@' \|\| ch == '!' \|\| ch == '#' \|\| ch == '$' \|\| ch == '?';
8e54aaed RD	61	}
8e54aaed RD	62
591d01be RD	63	static inline bool IsAWordChar(const int ch)
	64	{
	65	return (ch < 0x80) && (isalnum(ch) \|\| ch == '.' \|\| ch == '_');
8e54aaed RD	66	}
8e54aaed RD	67
591d01be RD	68	static inline bool IsAWordStart(const int ch)
	69	{
	70	return (ch < 0x80) && (isalnum(ch) \|\| ch == '_');
8e54aaed RD	71	}
	72
	73	bool MatchUpperCase(Accessor &styler, int pos, const char *s) //Same as styler.Match() but uppercase comparison (a-z,A-Z and space only)
	74	{
591d01be RD	75	char ch;
	76	for (int i=0; *s; i++)
	77	{
	78	ch=styler.SafeGetCharAt(pos+i);
	79	if (ch > 0x60) ch -= '\x20';
	80	if (*s != ch) return false;
	81	s++;
	82	}
	83	return true;
8e54aaed RD	84	}
8e54aaed RD	85
591d01be RD	86	static void ColourisePBDoc(unsigned int startPos, int length, int initStyle,WordList *keywordlists[],Accessor &styler) {
	87
	88	WordList &keywords = *keywordlists[0];
	89
	90	styler.StartAt(startPos);
	91
	92	StyleContext sc(startPos, length, initStyle, styler);
	93
	94	for (; sc.More(); sc.Forward()) {
	95	switch (sc.state)
	96	{
	97	case SCE_B_OPERATOR:
	98	{
	99	sc.SetState(SCE_B_DEFAULT);
	100	break;
	101	}
	102	case SCE_B_KEYWORD:
	103	{
	104	if (!IsAWordChar(sc.ch))
	105	{
	106	if (!IsTypeCharacter(sc.ch))
	107	{
	108	char s[100];
	109	sc.GetCurrentLowered(s, sizeof(s));
	110	if (keywords.InList(s))
	111	{
	112	if (strcmp(s, "rem") == 0)
	113	{
	114	sc.ChangeState(SCE_B_COMMENT);
	115	if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
	116	}
	117	else if (strcmp(s, "asm") == 0)
	118	{
	119	sc.ChangeState(SCE_B_ASM);
	120	if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
	121	}
	122	else
	123	{
	124	sc.SetState(SCE_B_DEFAULT);
	125	}
	126	}
	127	else
	128	{
	129	sc.ChangeState(SCE_B_IDENTIFIER);
	130	sc.SetState(SCE_B_DEFAULT);
	131	}
	132	}
	133	}
	134	break;
	135	}
	136	case SCE_B_NUMBER:
	137	{
	138	if (!IsAWordChar(sc.ch)) {sc.SetState(SCE_B_DEFAULT);}
	139	break;
	140	}
	141	case SCE_B_STRING:
	142	{
	143	if (sc.ch == '\"'){sc.ForwardSetState(SCE_B_DEFAULT);}
	144	break;
	145	}
	146	case SCE_B_CONSTANT:
	147	{
	148	if (!IsAWordChar(sc.ch)) {sc.SetState(SCE_B_DEFAULT);}
	149	break;
150	}
151	case SCE_B_COMMENT:
152	{
153	if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
154	break;
155	}
156	case SCE_B_ASM:
157	{
158	if (sc.atLineEnd) {sc.SetState(SCE_B_DEFAULT);}
159	break;
160	}
161	} //switch (sc.state)
162
163	// Determine if a new state should be entered:
164	if (sc.state == SCE_B_DEFAULT)
165	{
166	if (sc.ch == '\'') {sc.SetState(SCE_B_COMMENT);}
167	else if (sc.ch == '\"') {sc.SetState(SCE_B_STRING);}
168	else if (sc.ch == '&' && tolower(sc.chNext) == 'h') {sc.SetState(SCE_B_NUMBER);}
169	else if (sc.ch == '&' && tolower(sc.chNext) == 'b') {sc.SetState(SCE_B_NUMBER);}
170	else if (sc.ch == '&' && tolower(sc.chNext) == 'o') {sc.SetState(SCE_B_NUMBER);}
171	else if (IsADigit(sc.ch) \|\| (sc.ch == '.' && IsADigit(sc.chNext))) {sc.SetState(SCE_B_NUMBER);}
172	else if (IsAWordStart(sc.ch)) {sc.SetState(SCE_B_KEYWORD);}
173	else if (sc.ch == '%') {sc.SetState(SCE_B_CONSTANT);}
174	else if (sc.ch == '$') {sc.SetState(SCE_B_CONSTANT);}
175	else if (sc.ch == '#') {sc.SetState(SCE_B_KEYWORD);}
176	else if (sc.ch == '!') {sc.SetState(SCE_B_ASM);}
177	else if (isoperator(static_cast<char>(sc.ch)) \|\| (sc.ch == '\\')) {sc.SetState(SCE_B_OPERATOR);}
178	}
179	} //for (; sc.More(); sc.Forward())
180	sc.Complete();
8e54aaed RD	181	}
8e54aaed RD	182
591d01be RD	183	//The folding routine for PowerBasic toggles SUBs and FUNCTIONs only. This was exactly what I wanted,
	184	//nothing more. I had worked with this kind of toggling for several years when I used the great good old
	185	//GFA Basic which is dead now. After testing the feature of toggling FOR-NEXT loops, WHILE-WEND loops
	186	//and so on too I found this is more disturbing then helping (for me). So if You think in another way
	187	//you can (or must) write Your own toggling routine ;-)
8e54aaed RD	188	static void FoldPBDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
8e54aaed RD	189	{
591d01be RD	190	// No folding enabled, no reason to continue...
	191	if( styler.GetPropertyInt("fold") == 0 )
	192	return;
	193
	194	unsigned int endPos = startPos + length;
	195	int lineCurrent = styler.GetLine(startPos);
	196	int levelCurrent = SC_FOLDLEVELBASE;
	197	if (lineCurrent > 0)
	198	levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
	199	int levelNext = levelCurrent;
	200	char chNext = styler[startPos];
	201
	202	bool fNewLine=true;
a33203cb RD	203	bool fMightBeMultiLineMacro=false;
a33203cb RD	204	bool fBeginOfCommentFound=false;
591d01be RD	205	for (unsigned int i = startPos; i < endPos; i++)
	206	{
	207	char ch = chNext;
	208	chNext = styler.SafeGetCharAt(i + 1);
	209
	210	if (fNewLine) //Begin of a new line (The Sub/Function/Macro keywords may occur at begin of line only)
	211	{
	212	fNewLine=false;
a33203cb	213	fBeginOfCommentFound=false;
591d01be RD	214	switch (ch)
591d01be RD	215	{
a33203cb RD	216	case ' ': //Most lines start with space - so check this first, the code is the same as for 'default:'
a33203cb RD	217	case '\t': //Handle tab too
591d01be RD	218	{
	219	int levelUse = levelCurrent;
	220	int lev = levelUse \| levelNext << 16;
	221	styler.SetLevel(lineCurrent, lev);
	222	break;
	223	}
	224	case 'F':
591d01be	225	case 'f':
a33203cb RD	226	{
	227	switch (chNext)
	228	{
	229	case 'U':
	230	case 'u':
	231	{
	232	if( MatchUpperCase(styler,i,"FUNCTION") )
	233	{
	234	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	235	levelNext=SC_FOLDLEVELBASE+1;
	236	}
	237	break;
	238	}
	239	}
	240	break;
	241	}
	242	case 'S':
591d01be	243	case 's':
a33203cb RD	244	{
	245	switch (chNext)
	246	{
	247	case 'U':
	248	case 'u':
	249	{
	250	if( MatchUpperCase(styler,i,"SUB") )
	251	{
	252	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	253	levelNext=SC_FOLDLEVELBASE+1;
	254	}
	255	break;
	256	}
	257	case 'T':
	258	case 't':
	259	{
	260	if( MatchUpperCase(styler,i,"STATIC FUNCTION") )
	261	{
	262	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	263	levelNext=SC_FOLDLEVELBASE+1;
	264	}
	265	else if( MatchUpperCase(styler,i,"STATIC SUB") )
	266	{
	267	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	268	levelNext=SC_FOLDLEVELBASE+1;
	269	}
	270	break;
	271	}
	272	}
	273	break;
	274	}
	275	case 'C':
591d01be RD	276	case 'c':
591d01be RD	277	{
a33203cb RD	278	switch (chNext)
	279	{
	280	case 'A':
	281	case 'a':
	282	{
	283	if( MatchUpperCase(styler,i,"CALLBACK FUNCTION") )
	284	{
	285	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	286	levelNext=SC_FOLDLEVELBASE+1;
	287	}
	288	break;
	289	}
	290	}
	291	break;
	292	}
	293	case 'M':
	294	case 'm':
	295	{
	296	switch (chNext)
	297	{
	298	case 'A':
	299	case 'a':
	300	{
	301	if( MatchUpperCase(styler,i,"MACRO") )
	302	{
	303	fMightBeMultiLineMacro=true; //Set folder level at end of line, we have to check for single line macro
	304	}
	305	break;
	306	}
	307	}
591d01be RD	308	break;
	309	}
	310	default:
	311	{
	312	int levelUse = levelCurrent;
	313	int lev = levelUse \| levelNext << 16;
	314	styler.SetLevel(lineCurrent, lev);
	315	break;
	316	}
	317	} //switch (ch)
	318	} //if( fNewLine )
	319
	320	switch (ch)
	321	{
a33203cb RD	322	case '=': //To test single line macros
	323	{
	324	if (fBeginOfCommentFound==false)
	325	fMightBeMultiLineMacro=false; //The found macro is a single line macro only;
	326	break;
	327	}
	328	case '\'': //A comment starts
	329	{
	330	fBeginOfCommentFound=true;
	331	break;
	332	}
591d01be RD	333	case '\n':
591d01be RD	334	{
a33203cb RD	335	if (fMightBeMultiLineMacro) //The current line is the begin of a multi line macro
	336	{
	337	fMightBeMultiLineMacro=false;
	338	styler.SetLevel(lineCurrent, (SC_FOLDLEVELBASE << 16) \| SC_FOLDLEVELHEADERFLAG);
	339	levelNext=SC_FOLDLEVELBASE+1;
	340	}
591d01be RD	341	lineCurrent++;
	342	levelCurrent = levelNext;
	343	fNewLine=true;
	344	break;
	345	}
	346	case '\r':
	347	{
	348	if (chNext != '\n')
	349	{
	350	lineCurrent++;
	351	levelCurrent = levelNext;
	352	fNewLine=true;
	353	}
	354	break;
	355	}
	356	} //switch (ch)
	357	} //for (unsigned int i = startPos; i < endPos; i++)
8e54aaed RD	358	}
	359
	360	static const char * const pbWordListDesc[] = {
591d01be RD	361	"Keywords",
591d01be RD	362	0
8e54aaed RD	363	};
	364
	365	LexerModule lmPB(SCLEX_POWERBASIC, ColourisePBDoc, "powerbasic", FoldPBDoc, pbWordListDesc);