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

// Scintilla source code edit control
/** @file LexCmake.cxx
 ** Lexer for Cmake
 **/
// Copyright 2007 by Cristian Adam <cristian [dot] adam [at] gmx [dot] net>
// based on the NSIS lexer
// 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 bool isCmakeNumber(char ch)
{
    return(ch >= '0' && ch <= '9');
}

static bool isCmakeChar(char ch)
{
    return(ch == '.' ) || (ch == '_' ) || isCmakeNumber(ch) || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
}

static bool isCmakeLetter(char ch)
{
    return(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
}

static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor &styler)
{
    int nNextLine = -1;
    for ( unsigned int i = start; i < end; i++ ) {
        char cNext = styler.SafeGetCharAt( i );
        if ( cNext == '\n' ) {
            nNextLine = i+1;
            break;
        }
    }

    if ( nNextLine == -1 ) // We never foudn the next line...
        return false;

    for ( unsigned int firstChar = nNextLine; firstChar < end; firstChar++ ) {
        char cNext = styler.SafeGetCharAt( firstChar );
        if ( cNext == ' ' )
            continue;
        if ( cNext == '\t' )
            continue;
        if ( styler.Match(firstChar, "ELSE")  || styler.Match(firstChar, "else"))
            return true;
        break;
    }

    return false;
}

static int calculateFoldCmake(unsigned int start, unsigned int end, int foldlevel, Accessor &styler, bool bElse)
{
    // If the word is too long, it is not what we are looking for
    if ( end - start > 20 )
        return foldlevel;

    int newFoldlevel = foldlevel;

    char s[20]; // The key word we are looking for has atmost 13 characters
    for (unsigned int i = 0; i < end - start + 1 && i < 19; i++) {
        s[i] = static_cast<char>( styler[ start + i ] );
        s[i + 1] = '\0';
    }

    if ( CompareCaseInsensitive(s, "IF") == 0 || CompareCaseInsensitive(s, "WHILE") == 0
         || CompareCaseInsensitive(s, "MACRO") == 0 || CompareCaseInsensitive(s, "FOREACH") == 0
         || CompareCaseInsensitive(s, "ELSEIF") == 0 )
        newFoldlevel++;
    else if ( CompareCaseInsensitive(s, "ENDIF") == 0 || CompareCaseInsensitive(s, "ENDWHILE") == 0
              || CompareCaseInsensitive(s, "ENDMACRO") == 0 || CompareCaseInsensitive(s, "ENDFOREACH") == 0)
        newFoldlevel--;
    else if ( bElse && CompareCaseInsensitive(s, "ELSEIF") == 0 )
        newFoldlevel++;
    else if ( bElse && CompareCaseInsensitive(s, "ELSE") == 0 )
        newFoldlevel++;

    return newFoldlevel;
}

static int classifyWordCmake(unsigned int start, unsigned int end, WordList *keywordLists[], Accessor &styler )
{
    char word[100] = {0};
    char lowercaseWord[100] = {0};

    WordList &Commands = *keywordLists[0];
    WordList &Parameters = *keywordLists[1];
    WordList &UserDefined = *keywordLists[2];

    for (unsigned int i = 0; i < end - start + 1 && i < 99; i++) {
        word[i] = static_cast<char>( styler[ start + i ] );
        lowercaseWord[i] = static_cast<char>(tolower(word[i]));
    }

    // Check for special words...
    if ( CompareCaseInsensitive(word, "MACRO") == 0 || CompareCaseInsensitive(word, "ENDMACRO") == 0 )
        return SCE_CMAKE_MACRODEF;

    if ( CompareCaseInsensitive(word, "IF") == 0 ||  CompareCaseInsensitive(word, "ENDIF") == 0 )
        return SCE_CMAKE_IFDEFINEDEF;

    if ( CompareCaseInsensitive(word, "ELSEIF") == 0  || CompareCaseInsensitive(word, "ELSE") == 0 )
        return SCE_CMAKE_IFDEFINEDEF;

    if ( CompareCaseInsensitive(word, "WHILE") == 0 || CompareCaseInsensitive(word, "ENDWHILE") == 0)
        return SCE_CMAKE_WHILEDEF;

    if ( CompareCaseInsensitive(word, "FOREACH") == 0 || CompareCaseInsensitive(word, "ENDFOREACH") == 0)
        return SCE_CMAKE_FOREACHDEF;

    if ( Commands.InList(lowercaseWord) )
        return SCE_CMAKE_COMMANDS;

    if ( Parameters.InList(word) )
        return SCE_CMAKE_PARAMETERS;


    if ( UserDefined.InList(word) )
        return SCE_CMAKE_USERDEFINED;

    if ( strlen(word) > 3 ) {
        if ( word[1] == '{' && word[strlen(word)-1] == '}' )
            return SCE_CMAKE_VARIABLE;
    }

    // To check for numbers
    if ( isCmakeNumber( word[0] ) ) {
        bool bHasSimpleCmakeNumber = true;
        for (unsigned int j = 1; j < end - start + 1 && j < 99; j++) {
            if ( !isCmakeNumber( word[j] ) ) {
                bHasSimpleCmakeNumber = false;
                break;
            }
        }

        if ( bHasSimpleCmakeNumber )
            return SCE_CMAKE_NUMBER;
    }

    return SCE_CMAKE_DEFAULT;
}

static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
{
    int state = SCE_CMAKE_DEFAULT;
    if ( startPos > 0 )
        state = styler.StyleAt(startPos-1); // Use the style from the previous line, usually default, but could be commentbox

    styler.StartAt( startPos );
    styler.GetLine( startPos );

    unsigned int nLengthDoc = startPos + length;
    styler.StartSegment( startPos );

    char cCurrChar;
    bool bVarInString = false;
    bool bClassicVarInString = false;

    unsigned int i;
    for ( i = startPos; i < nLengthDoc; i++ ) {
        cCurrChar = styler.SafeGetCharAt( i );
        char cNextChar = styler.SafeGetCharAt(i+1);

        switch (state) {
        case SCE_CMAKE_DEFAULT:
            if ( cCurrChar == '#' ) { // we have a comment line
                styler.ColourTo(i-1, state );
                state = SCE_CMAKE_COMMENT;
                break;
            }
            if ( cCurrChar == '"' ) {
                styler.ColourTo(i-1, state );
                state = SCE_CMAKE_STRINGDQ;
                bVarInString = false;
                bClassicVarInString = false;
                break;
            }
            if ( cCurrChar == '\'' ) {
                styler.ColourTo(i-1, state );
                state = SCE_CMAKE_STRINGRQ;
                bVarInString = false;
                bClassicVarInString = false;
                break;
            }
            if ( cCurrChar == '`' ) {
                styler.ColourTo(i-1, state );
                state = SCE_CMAKE_STRINGLQ;
                bVarInString = false;
                bClassicVarInString = false;
                break;
            }

            // CMake Variable
            if ( cCurrChar == '$' || isCmakeChar(cCurrChar)) {
                styler.ColourTo(i-1,state);
                state = SCE_CMAKE_VARIABLE;

                // If it is a number, we must check and set style here first...
                if ( isCmakeNumber(cCurrChar) && (cNextChar == '\t' || cNextChar == ' ' || cNextChar == '\r' || cNextChar == '\n' ) )
                    styler.ColourTo( i, SCE_CMAKE_NUMBER);

                break;
            }

            break;
        case SCE_CMAKE_COMMENT:
            if ( cNextChar == '\n' || cNextChar == '\r' ) {
                // Special case:
                if ( cCurrChar == '\\' ) {
                    styler.ColourTo(i-2,state);
                    styler.ColourTo(i,SCE_CMAKE_DEFAULT);
                }
                else {
                    styler.ColourTo(i,state);
                    state = SCE_CMAKE_DEFAULT;
                }
            }
            break;
        case SCE_CMAKE_STRINGDQ:
        case SCE_CMAKE_STRINGLQ:
        case SCE_CMAKE_STRINGRQ:

            if ( styler.SafeGetCharAt(i-1) == '\\' && styler.SafeGetCharAt(i-2) == '$' )
                break; // Ignore the next character, even if it is a quote of some sort

            if ( cCurrChar == '"' && state == SCE_CMAKE_STRINGDQ ) {
                styler.ColourTo(i,state);
                state = SCE_CMAKE_DEFAULT;
                break;
            }

            if ( cCurrChar == '`' && state == SCE_CMAKE_STRINGLQ ) {
                styler.ColourTo(i,state);
                state = SCE_CMAKE_DEFAULT;
                break;
            }

            if ( cCurrChar == '\'' && state == SCE_CMAKE_STRINGRQ ) {
                styler.ColourTo(i,state);
                state = SCE_CMAKE_DEFAULT;
                break;
            }

            if ( cNextChar == '\r' || cNextChar == '\n' ) {
                int nCurLine = styler.GetLine(i+1);
                int nBack = i;
                // We need to check if the previous line has a \ in it...
                bool bNextLine = false;

                while ( nBack > 0 ) {
                    if ( styler.GetLine(nBack) != nCurLine )
                        break;

                    char cTemp = styler.SafeGetCharAt(nBack, 'a'); // Letter 'a' is safe here

                    if ( cTemp == '\\' ) {
                        bNextLine = true;
                        break;
                    }
                    if ( cTemp != '\r' && cTemp != '\n' && cTemp != '\t' && cTemp != ' ' )
                        break;

                    nBack--;
                }

                if ( bNextLine ) {
                    styler.ColourTo(i+1,state);
                }
                if ( bNextLine == false ) {
                    styler.ColourTo(i,state);
                    state = SCE_CMAKE_DEFAULT;
                }
            }
            break;

        case SCE_CMAKE_VARIABLE:

            // CMake Variable:
            if ( cCurrChar == '$' )
                state = SCE_CMAKE_DEFAULT;
            else if ( cCurrChar == '\\' && (cNextChar == 'n' || cNextChar == 'r' || cNextChar == 't' ) )
                state = SCE_CMAKE_DEFAULT;
            else if ( (isCmakeChar(cCurrChar) && !isCmakeChar( cNextChar) && cNextChar != '}') || cCurrChar == '}' ) {
                state = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler );
                styler.ColourTo( i, state);
                state = SCE_CMAKE_DEFAULT;
            }
            else if ( !isCmakeChar( cCurrChar ) && cCurrChar != '{' && cCurrChar != '}' ) {
                if ( classifyWordCmake( styler.GetStartSegment(), i-1, keywordLists, styler) == SCE_CMAKE_NUMBER )
                    styler.ColourTo( i-1, SCE_CMAKE_NUMBER );

                state = SCE_CMAKE_DEFAULT;

                if ( cCurrChar == '"' ) {
                    state = SCE_CMAKE_STRINGDQ;
                    bVarInString = false;
                    bClassicVarInString = false;
                }
                else if ( cCurrChar == '`' ) {
                    state = SCE_CMAKE_STRINGLQ;
                    bVarInString = false;
                    bClassicVarInString = false;
                }
                else if ( cCurrChar == '\'' ) {
                    state = SCE_CMAKE_STRINGRQ;
                    bVarInString = false;
                    bClassicVarInString = false;
                }
                else if ( cCurrChar == '#' ) {
                    state = SCE_CMAKE_COMMENT;
                }
            }
            break;
        }

        if ( state == SCE_CMAKE_COMMENT) {
            styler.ColourTo(i,state);
        }
        else if ( state == SCE_CMAKE_STRINGDQ || state == SCE_CMAKE_STRINGLQ || state == SCE_CMAKE_STRINGRQ ) {
            bool bIngoreNextDollarSign = false;

            if ( bVarInString && cCurrChar == '$' ) {
                bVarInString = false;
                bIngoreNextDollarSign = true;
            }
            else if ( bVarInString && cCurrChar == '\\' && (cNextChar == 'n' || cNextChar == 'r' || cNextChar == 't' || cNextChar == '"' || cNextChar == '`' || cNextChar == '\'' ) ) {
                styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR);
                bVarInString = false;
                bIngoreNextDollarSign = false;
            }

            else if ( bVarInString && !isCmakeChar(cNextChar) ) {
                int nWordState = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler);
                if ( nWordState == SCE_CMAKE_VARIABLE )
                    styler.ColourTo( i, SCE_CMAKE_STRINGVAR);
                bVarInString = false;
            }
            // Covers "${TEST}..."
            else if ( bClassicVarInString && cNextChar == '}' ) {
                styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR);
                bClassicVarInString = false;
            }

            // Start of var in string
            if ( !bIngoreNextDollarSign && cCurrChar == '$' && cNextChar == '{' ) {
                styler.ColourTo( i-1, state);
                bClassicVarInString = true;
                bVarInString = false;
            }
            else if ( !bIngoreNextDollarSign && cCurrChar == '$' ) {
                styler.ColourTo( i-1, state);
                bVarInString = true;
                bClassicVarInString = false;
            }
        }
    }

    // Colourise remaining document
    styler.ColourTo(nLengthDoc-1,state);
}

static void FoldCmakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
{
    // No folding enabled, no reason to continue...
    if ( styler.GetPropertyInt("fold") == 0 )
        return;

    bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) == 1;

    int lineCurrent = styler.GetLine(startPos);
    unsigned int safeStartPos = styler.LineStart( lineCurrent );

    bool bArg1 = true;
    int nWordStart = -1;

    int levelCurrent = SC_FOLDLEVELBASE;
    if (lineCurrent > 0)
        levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
    int levelNext = levelCurrent;

    for (unsigned int i = safeStartPos; i < startPos + length; i++) {
        char chCurr = styler.SafeGetCharAt(i);

        if ( bArg1 ) {
            if ( nWordStart == -1 && (isCmakeLetter(chCurr)) ) {
                nWordStart = i;
            }
            else if ( isCmakeLetter(chCurr) == false && nWordStart > -1 ) {
                int newLevel = calculateFoldCmake( nWordStart, i-1, levelNext, styler, foldAtElse);

                if ( newLevel == levelNext ) {
                    if ( foldAtElse ) {
                        if ( CmakeNextLineHasElse(i, startPos + length, styler) )
                            levelNext--;
                    }
                }
                else
                    levelNext = newLevel;
                bArg1 = false;
            }
        }

        if ( chCurr == '\n' ) {
            if ( bArg1 && foldAtElse) {
                if ( CmakeNextLineHasElse(i, startPos + length, styler) )
                    levelNext--;
            }

            // If we are on a new line...
            int levelUse = levelCurrent;
            int lev = levelUse | levelNext << 16;
            if (levelUse < levelNext )
                lev |= SC_FOLDLEVELHEADERFLAG;
            if (lev != styler.LevelAt(lineCurrent))
                styler.SetLevel(lineCurrent, lev);

            lineCurrent++;
            levelCurrent = levelNext;
            bArg1 = true; // New line, lets look at first argument again
            nWordStart = -1;
        }
    }

    int levelUse = levelCurrent;
    int lev = levelUse | levelNext << 16;
    if (levelUse < levelNext)
        lev |= SC_FOLDLEVELHEADERFLAG;
    if (lev != styler.LevelAt(lineCurrent))
        styler.SetLevel(lineCurrent, lev);
}

static const char * const cmakeWordLists[] = {
    "Commands",
    "Parameters",
    "UserDefined",
    0,
    0,};

LexerModule lmCmake(SCLEX_CMAKE, ColouriseCmakeDoc, "cmake", FoldCmakeDoc, cmakeWordLists);
Commit	Line	Data
7e0c58e9 RD	1	// Scintilla source code edit control
	2	/** @file LexCmake.cxx
	3	** Lexer for Cmake
	4	**/
	5	// Copyright 2007 by Cristian Adam <cristian [dot] adam [at] gmx [dot] net>
	6	// based on the NSIS lexer
	7	// The License.txt file describes the conditions under which this software may be distributed.
1dcf666d	8
7e0c58e9 RD	9	#include <stdlib.h>
7e0c58e9 RD	10	#include <string.h>
7e0c58e9 RD	11	#include <stdio.h>
7e0c58e9 RD	12	#include <stdarg.h>
1dcf666d RD	13	#include <assert.h>
1dcf666d RD	14	#include <ctype.h>
7e0c58e9	15
1dcf666d	16	#include "ILexer.h"
7e0c58e9 RD	17	#include "Scintilla.h"
	18	#include "SciLexer.h"
	19
1dcf666d RD	20	#include "WordList.h"
	21	#include "LexAccessor.h"
	22	#include "Accessor.h"
	23	#include "StyleContext.h"
	24	#include "CharacterSet.h"
	25	#include "LexerModule.h"
	26
7e0c58e9 RD	27	#ifdef SCI_NAMESPACE
	28	using namespace Scintilla;
	29	#endif
	30
	31	static bool isCmakeNumber(char ch)
	32	{
	33	return(ch >= '0' && ch <= '9');
	34	}
	35
	36	static bool isCmakeChar(char ch)
	37	{
	38	return(ch == '.' ) \|\| (ch == '_' ) \|\| isCmakeNumber(ch) \|\| (ch >= 'A' && ch <= 'Z') \|\| (ch >= 'a' && ch <= 'z');
	39	}
	40
	41	static bool isCmakeLetter(char ch)
	42	{
	43	return(ch >= 'A' && ch <= 'Z') \|\| (ch >= 'a' && ch <= 'z');
	44	}
	45
	46	static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor &styler)
	47	{
	48	int nNextLine = -1;
	49	for ( unsigned int i = start; i < end; i++ ) {
	50	char cNext = styler.SafeGetCharAt( i );
	51	if ( cNext == '\n' ) {
	52	nNextLine = i+1;
	53	break;
	54	}
	55	}
	56
	57	if ( nNextLine == -1 ) // We never foudn the next line...
	58	return false;
	59
	60	for ( unsigned int firstChar = nNextLine; firstChar < end; firstChar++ ) {
	61	char cNext = styler.SafeGetCharAt( firstChar );
	62	if ( cNext == ' ' )
	63	continue;
	64	if ( cNext == '\t' )
	65	continue;
	66	if ( styler.Match(firstChar, "ELSE") \|\| styler.Match(firstChar, "else"))
	67	return true;
	68	break;
	69	}
	70
	71	return false;
	72	}
	73
	74	static int calculateFoldCmake(unsigned int start, unsigned int end, int foldlevel, Accessor &styler, bool bElse)
	75	{
	76	// If the word is too long, it is not what we are looking for
	77	if ( end - start > 20 )
	78	return foldlevel;
	79
	80	int newFoldlevel = foldlevel;
	81
	82	char s[20]; // The key word we are looking for has atmost 13 characters
	83	for (unsigned int i = 0; i < end - start + 1 && i < 19; i++) {
	84	s[i] = static_cast<char>( styler[ start + i ] );
	85	s[i + 1] = '\0';
	86	}
	87
	88	if ( CompareCaseInsensitive(s, "IF") == 0 \|\| CompareCaseInsensitive(s, "WHILE") == 0
	89	\|\| CompareCaseInsensitive(s, "MACRO") == 0 \|\| CompareCaseInsensitive(s, "FOREACH") == 0
	90	\|\| CompareCaseInsensitive(s, "ELSEIF") == 0 )
91	newFoldlevel++;
92	else if ( CompareCaseInsensitive(s, "ENDIF") == 0 \|\| CompareCaseInsensitive(s, "ENDWHILE") == 0
93	\|\| CompareCaseInsensitive(s, "ENDMACRO") == 0 \|\| CompareCaseInsensitive(s, "ENDFOREACH") == 0)
94	newFoldlevel--;
95	else if ( bElse && CompareCaseInsensitive(s, "ELSEIF") == 0 )
96	newFoldlevel++;
97	else if ( bElse && CompareCaseInsensitive(s, "ELSE") == 0 )
98	newFoldlevel++;
99
100	return newFoldlevel;
101	}
102
103	static int classifyWordCmake(unsigned int start, unsigned int end, WordList *keywordLists[], Accessor &styler )
104	{
105	char word[100] = {0};
106	char lowercaseWord[100] = {0};
107
108	WordList &Commands = *keywordLists[0];
109	WordList &Parameters = *keywordLists[1];
110	WordList &UserDefined = *keywordLists[2];
111
112	for (unsigned int i = 0; i < end - start + 1 && i < 99; i++) {
113	word[i] = static_cast<char>( styler[ start + i ] );
114	lowercaseWord[i] = static_cast<char>(tolower(word[i]));
115	}
116
117	// Check for special words...
118	if ( CompareCaseInsensitive(word, "MACRO") == 0 \|\| CompareCaseInsensitive(word, "ENDMACRO") == 0 )
119	return SCE_CMAKE_MACRODEF;
120
121	if ( CompareCaseInsensitive(word, "IF") == 0 \|\| CompareCaseInsensitive(word, "ENDIF") == 0 )
122	return SCE_CMAKE_IFDEFINEDEF;
123
124	if ( CompareCaseInsensitive(word, "ELSEIF") == 0 \|\| CompareCaseInsensitive(word, "ELSE") == 0 )
125	return SCE_CMAKE_IFDEFINEDEF;
126
127	if ( CompareCaseInsensitive(word, "WHILE") == 0 \|\| CompareCaseInsensitive(word, "ENDWHILE") == 0)
128	return SCE_CMAKE_WHILEDEF;
129
130	if ( CompareCaseInsensitive(word, "FOREACH") == 0 \|\| CompareCaseInsensitive(word, "ENDFOREACH") == 0)
131	return SCE_CMAKE_FOREACHDEF;
132
133	if ( Commands.InList(lowercaseWord) )
134	return SCE_CMAKE_COMMANDS;
135
136	if ( Parameters.InList(word) )
137	return SCE_CMAKE_PARAMETERS;
138
139
140	if ( UserDefined.InList(word) )
141	return SCE_CMAKE_USERDEFINED;
142
143	if ( strlen(word) > 3 ) {
144	if ( word[1] == '{' && word[strlen(word)-1] == '}' )
145	return SCE_CMAKE_VARIABLE;
146	}
147
148	// To check for numbers
149	if ( isCmakeNumber( word[0] ) ) {
150	bool bHasSimpleCmakeNumber = true;
151	for (unsigned int j = 1; j < end - start + 1 && j < 99; j++) {
152	if ( !isCmakeNumber( word[j] ) ) {
153	bHasSimpleCmakeNumber = false;
154	break;
155	}
156	}
157
158	if ( bHasSimpleCmakeNumber )
159	return SCE_CMAKE_NUMBER;
160	}
161
162	return SCE_CMAKE_DEFAULT;
163	}
164
165	static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
166	{
167	int state = SCE_CMAKE_DEFAULT;
168	if ( startPos > 0 )
169	state = styler.StyleAt(startPos-1); // Use the style from the previous line, usually default, but could be commentbox
170
171	styler.StartAt( startPos );
172	styler.GetLine( startPos );
173
174	unsigned int nLengthDoc = startPos + length;
175	styler.StartSegment( startPos );
176
177	char cCurrChar;
178	bool bVarInString = false;
179	bool bClassicVarInString = false;
180
181	unsigned int i;
182	for ( i = startPos; i < nLengthDoc; i++ ) {
183	cCurrChar = styler.SafeGetCharAt( i );
184	char cNextChar = styler.SafeGetCharAt(i+1);
185
186	switch (state) {
187	case SCE_CMAKE_DEFAULT:
188	if ( cCurrChar == '#' ) { // we have a comment line
189	styler.ColourTo(i-1, state );
190	state = SCE_CMAKE_COMMENT;
191	break;
192	}
193	if ( cCurrChar == '"' ) {
194	styler.ColourTo(i-1, state );
195	state = SCE_CMAKE_STRINGDQ;
196	bVarInString = false;
197	bClassicVarInString = false;
198	break;
199	}
200	if ( cCurrChar == '\'' ) {
201	styler.ColourTo(i-1, state );
202	state = SCE_CMAKE_STRINGRQ;
203	bVarInString = false;
204	bClassicVarInString = false;
205	break;
206	}
207	if ( cCurrChar == '`' ) {
208	styler.ColourTo(i-1, state );
209	state = SCE_CMAKE_STRINGLQ;
210	bVarInString = false;
211	bClassicVarInString = false;
212	break;
213	}
214
215	// CMake Variable
216	if ( cCurrChar == '$' \|\| isCmakeChar(cCurrChar)) {
217	styler.ColourTo(i-1,state);
218	state = SCE_CMAKE_VARIABLE;
219
220	// If it is a number, we must check and set style here first...
221	if ( isCmakeNumber(cCurrChar) && (cNextChar == '\t' \|\| cNextChar == ' ' \|\| cNextChar == '\r' \|\| cNextChar == '\n' ) )
222	styler.ColourTo( i, SCE_CMAKE_NUMBER);
223
224	break;
225	}
226
227	break;
228	case SCE_CMAKE_COMMENT:
229	if ( cNextChar == '\n' \|\| cNextChar == '\r' ) {
230	// Special case:
231	if ( cCurrChar == '\\' ) {
232	styler.ColourTo(i-2,state);
233	styler.ColourTo(i,SCE_CMAKE_DEFAULT);
234	}
235	else {
236	styler.ColourTo(i,state);
237	state = SCE_CMAKE_DEFAULT;
238	}
239	}
240	break;
241	case SCE_CMAKE_STRINGDQ:
242	case SCE_CMAKE_STRINGLQ:
243	case SCE_CMAKE_STRINGRQ:
244
245	if ( styler.SafeGetCharAt(i-1) == '\\' && styler.SafeGetCharAt(i-2) == '$' )
246	break; // Ignore the next character, even if it is a quote of some sort
247
248	if ( cCurrChar == '"' && state == SCE_CMAKE_STRINGDQ ) {
249	styler.ColourTo(i,state);
250	state = SCE_CMAKE_DEFAULT;
251	break;
252	}
253
254	if ( cCurrChar == '`' && state == SCE_CMAKE_STRINGLQ ) {
255	styler.ColourTo(i,state);
256	state = SCE_CMAKE_DEFAULT;
257	break;
258	}
259
260	if ( cCurrChar == '\'' && state == SCE_CMAKE_STRINGRQ ) {
261	styler.ColourTo(i,state);
262	state = SCE_CMAKE_DEFAULT;
263	break;
264	}
265
266	if ( cNextChar == '\r' \|\| cNextChar == '\n' ) {
267	int nCurLine = styler.GetLine(i+1);
268	int nBack = i;
269	// We need to check if the previous line has a \ in it...
270	bool bNextLine = false;
271
272	while ( nBack > 0 ) {
273	if ( styler.GetLine(nBack) != nCurLine )
274	break;
275
276	char cTemp = styler.SafeGetCharAt(nBack, 'a'); // Letter 'a' is safe here
277
278	if ( cTemp == '\\' ) {
279	bNextLine = true;
280	break;
281	}
282	if ( cTemp != '\r' && cTemp != '\n' && cTemp != '\t' && cTemp != ' ' )
283	break;
284
285	nBack--;
286	}
287
288	if ( bNextLine ) {
289	styler.ColourTo(i+1,state);
290	}
291	if ( bNextLine == false ) {
292	styler.ColourTo(i,state);
293	state = SCE_CMAKE_DEFAULT;
294	}
295	}
296	break;
297
298	case SCE_CMAKE_VARIABLE:
299
300	// CMake Variable:
301	if ( cCurrChar == '$' )
302	state = SCE_CMAKE_DEFAULT;
303	else if ( cCurrChar == '\\' && (cNextChar == 'n' \|\| cNextChar == 'r' \|\| cNextChar == 't' ) )
304	state = SCE_CMAKE_DEFAULT;
305	else if ( (isCmakeChar(cCurrChar) && !isCmakeChar( cNextChar) && cNextChar != '}') \|\| cCurrChar == '}' ) {
306	state = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler );
307	styler.ColourTo( i, state);
308	state = SCE_CMAKE_DEFAULT;
309	}
310	else if ( !isCmakeChar( cCurrChar ) && cCurrChar != '{' && cCurrChar != '}' ) {
311	if ( classifyWordCmake( styler.GetStartSegment(), i-1, keywordLists, styler) == SCE_CMAKE_NUMBER )
312	styler.ColourTo( i-1, SCE_CMAKE_NUMBER );
313
314	state = SCE_CMAKE_DEFAULT;
315
316	if ( cCurrChar == '"' ) {
317	state = SCE_CMAKE_STRINGDQ;
318	bVarInString = false;
319	bClassicVarInString = false;
320	}
321	else if ( cCurrChar == '`' ) {
322	state = SCE_CMAKE_STRINGLQ;
323	bVarInString = false;
324	bClassicVarInString = false;
325	}
326	else if ( cCurrChar == '\'' ) {
327	state = SCE_CMAKE_STRINGRQ;
328	bVarInString = false;
329	bClassicVarInString = false;
330	}
331	else if ( cCurrChar == '#' ) {
332	state = SCE_CMAKE_COMMENT;
333	}
334	}
335	break;
336	}
337
338	if ( state == SCE_CMAKE_COMMENT) {
339	styler.ColourTo(i,state);
340	}
341	else if ( state == SCE_CMAKE_STRINGDQ \|\| state == SCE_CMAKE_STRINGLQ \|\| state == SCE_CMAKE_STRINGRQ ) {
342	bool bIngoreNextDollarSign = false;
343
344	if ( bVarInString && cCurrChar == '$' ) {
345	bVarInString = false;
346	bIngoreNextDollarSign = true;
347	}
348	else if ( bVarInString && cCurrChar == '\\' && (cNextChar == 'n' \|\| cNextChar == 'r' \|\| cNextChar == 't' \|\| cNextChar == '"' \|\| cNextChar == '`' \|\| cNextChar == '\'' ) ) {
349	styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR);
350	bVarInString = false;
351	bIngoreNextDollarSign = false;
352	}
353
354	else if ( bVarInString && !isCmakeChar(cNextChar) ) {
355	int nWordState = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler);
356	if ( nWordState == SCE_CMAKE_VARIABLE )
357	styler.ColourTo( i, SCE_CMAKE_STRINGVAR);
358	bVarInString = false;
359	}
360	// Covers "${TEST}..."
361	else if ( bClassicVarInString && cNextChar == '}' ) {
362	styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR);
363	bClassicVarInString = false;
364	}
365
366	// Start of var in string
367	if ( !bIngoreNextDollarSign && cCurrChar == '$' && cNextChar == '{' ) {
368	styler.ColourTo( i-1, state);
369	bClassicVarInString = true;
370	bVarInString = false;
371	}
372	else if ( !bIngoreNextDollarSign && cCurrChar == '$' ) {
373	styler.ColourTo( i-1, state);
374	bVarInString = true;
375	bClassicVarInString = false;
376	}
377	}
378	}
379
380	// Colourise remaining document
381	styler.ColourTo(nLengthDoc-1,state);
382	}
383
384	static void FoldCmakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
385	{
386	// No folding enabled, no reason to continue...
387	if ( styler.GetPropertyInt("fold") == 0 )
388	return;
389
390	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) == 1;
391
392	int lineCurrent = styler.GetLine(startPos);
393	unsigned int safeStartPos = styler.LineStart( lineCurrent );
394
395	bool bArg1 = true;
396	int nWordStart = -1;
397
398	int levelCurrent = SC_FOLDLEVELBASE;
399	if (lineCurrent > 0)
400	levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
401	int levelNext = levelCurrent;
402
403	for (unsigned int i = safeStartPos; i < startPos + length; i++) {
404	char chCurr = styler.SafeGetCharAt(i);
405
406	if ( bArg1 ) {
407	if ( nWordStart == -1 && (isCmakeLetter(chCurr)) ) {
408	nWordStart = i;
409	}
410	else if ( isCmakeLetter(chCurr) == false && nWordStart > -1 ) {
411	int newLevel = calculateFoldCmake( nWordStart, i-1, levelNext, styler, foldAtElse);
412
413	if ( newLevel == levelNext ) {
414	if ( foldAtElse ) {
415	if ( CmakeNextLineHasElse(i, startPos + length, styler) )
416	levelNext--;
417	}
418	}
419	else
420	levelNext = newLevel;
421	bArg1 = false;
422	}
423	}
424
425	if ( chCurr == '\n' ) {
426	if ( bArg1 && foldAtElse) {
427	if ( CmakeNextLineHasElse(i, startPos + length, styler) )
428	levelNext--;
429	}
430
431	// If we are on a new line...
432	int levelUse = levelCurrent;
433	int lev = levelUse \| levelNext << 16;
434	if (levelUse < levelNext )
435	lev \|= SC_FOLDLEVELHEADERFLAG;
436	if (lev != styler.LevelAt(lineCurrent))
437	styler.SetLevel(lineCurrent, lev);
438
439	lineCurrent++;
440	levelCurrent = levelNext;
441	bArg1 = true; // New line, lets look at first argument again
442	nWordStart = -1;
443	}
444	}
445
446	int levelUse = levelCurrent;
447	int lev = levelUse \| levelNext << 16;
448	if (levelUse < levelNext)
449	lev \|= SC_FOLDLEVELHEADERFLAG;
450	if (lev != styler.LevelAt(lineCurrent))
451	styler.SetLevel(lineCurrent, lev);
452	}
453
454	static const char * const cmakeWordLists[] = {
455	"Commands",
456	"Parameters",
457	"UserDefined",
458	0,
459	0,};
460
461	LexerModule lmCmake(SCLEX_CMAKE, ColouriseCmakeDoc, "cmake", FoldCmakeDoc, cmakeWordLists);