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

/** @file LexD.cxx
 ** Lexer for D.
 **
 ** Copyright (c) 2006 by Waldemar Augustyn <waldemar@wdmsys.com>
 **/
// 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 <ctype.h>
#include <stdio.h>
#include <stdarg.h>

#include "Platform.h"

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

#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif

/*/ Nested comments require keeping the value of the nesting level for every
    position in the document.  But since scintilla always styles line by line,
    we only need to store one value per line. The non-negative number indicates
    nesting level at the end of the line.
/*/

// We use custom qualifiers since it is not clear what D allows.

static bool IsWordStart(int ch) {
	return isascii(ch) && (isalpha(ch) || ch == '_');
}

static bool IsWord(int ch) {
	return isascii(ch) && (isalnum(ch) || ch == '_');
}

static bool IsDoxygen(int ch) {
	if (isascii(ch) && islower(ch))
		return true;
	if (ch == '$' || ch == '@' || ch == '\\' ||
		ch == '&' || ch == '#' || ch == '<' || ch == '>' ||
		ch == '{' || ch == '}' || ch == '[' || ch == ']')
		return true;
	return false;
}


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

    WordList &keywords = *keywordlists[0];
    WordList &keywords2 = *keywordlists[1];
    WordList &keywords3 = *keywordlists[2];
    WordList &keywords4 = *keywordlists[3];

    int styleBeforeDCKeyword = SCE_D_DEFAULT;

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

    int curLine = styler.GetLine(startPos);
    int curNcLevel = curLine > 0? styler.GetLineState(curLine-1): 0;

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

        if (sc.atLineStart) {
            if (sc.state == SCE_D_STRING) {
                // Prevent SCE_D_STRINGEOL from leaking back to previous line which
                // ends with a line continuation by locking in the state upto this position.
                sc.SetState(SCE_D_STRING);
            }
            curLine = styler.GetLine(sc.currentPos);
            styler.SetLineState(curLine, curNcLevel);
        }

        // Handle line continuation generically.
        if (sc.ch == '\\') {
            if (sc.chNext == '\n' || sc.chNext == '\r') {
                sc.Forward();
                if (sc.ch == '\r' && sc.chNext == '\n') {
                    sc.Forward();
                }
                continue;
            }
        }

        // Determine if the current state should terminate.
        switch (sc.state) {
            case SCE_D_OPERATOR:
                sc.SetState(SCE_D_DEFAULT);
                break;
            case SCE_D_NUMBER:
                // We accept almost anything because of hex. and number suffixes
                if (!IsWord(sc.ch) && sc.ch != '.') {
                    sc.SetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_IDENTIFIER:
                if (!IsWord(sc.ch)) {
                    char s[1000];
                    if (caseSensitive) {
                        sc.GetCurrent(s, sizeof(s));
                    } else {
                        sc.GetCurrentLowered(s, sizeof(s));
                    }
                    if (keywords.InList(s)) {
                        sc.ChangeState(SCE_D_WORD);
                    } else if (keywords2.InList(s)) {
                        sc.ChangeState(SCE_D_WORD2);
                    } else if (keywords4.InList(s)) {
                        sc.ChangeState(SCE_D_TYPEDEF);
                    }
                    sc.SetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_COMMENT:
                if (sc.Match('*', '/')) {
                    sc.Forward();
                    sc.ForwardSetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_COMMENTDOC:
                if (sc.Match('*', '/')) {
                    sc.Forward();
                    sc.ForwardSetState(SCE_D_DEFAULT);
                } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
                    // Verify that we have the conditions to mark a comment-doc-keyword
                    if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
                        styleBeforeDCKeyword = SCE_D_COMMENTDOC;
                        sc.SetState(SCE_D_COMMENTDOCKEYWORD);
                    }
                }
                break;
            case SCE_D_COMMENTLINE:
                if (sc.atLineStart) {
                    sc.SetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_COMMENTLINEDOC:
                if (sc.atLineStart) {
                    sc.SetState(SCE_D_DEFAULT);
                } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
                    // Verify that we have the conditions to mark a comment-doc-keyword
                    if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
                        styleBeforeDCKeyword = SCE_D_COMMENTLINEDOC;
                        sc.SetState(SCE_D_COMMENTDOCKEYWORD);
                    }
                }
                break;
            case SCE_D_COMMENTDOCKEYWORD:
                if ((styleBeforeDCKeyword == SCE_D_COMMENTDOC) && sc.Match('*', '/')) {
                    sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
                    sc.Forward();
                    sc.ForwardSetState(SCE_D_DEFAULT);
                } else if (!IsDoxygen(sc.ch)) {
                    char s[100];
                    if (caseSensitive) {
                        sc.GetCurrent(s, sizeof(s));
                    } else {
                        sc.GetCurrentLowered(s, sizeof(s));
                    }
                    if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) {
                        sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
                    }
                    sc.SetState(styleBeforeDCKeyword);
                }
                break;
            case SCE_D_COMMENTNESTED:
                if (sc.Match('+', '/')) {
                    if (curNcLevel > 0)
                        curNcLevel -= 1;
                    curLine = styler.GetLine(sc.currentPos);
                    styler.SetLineState(curLine, curNcLevel);
                    sc.Forward();
                    if (curNcLevel == 0) {
                        sc.ForwardSetState(SCE_D_DEFAULT);
		    }
                }
                else if (sc.Match('/','+')) {
                    curNcLevel += 1;
                    curLine = styler.GetLine(sc.currentPos);
                    styler.SetLineState(curLine, curNcLevel);
                    sc.Forward();
                }
                break;
            case SCE_D_STRING:
                if (sc.atLineEnd) {
                    sc.ChangeState(SCE_D_STRINGEOL);
                } else if (sc.ch == '\\') {
                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
                        sc.Forward();
                    }
                } else if (sc.ch == '\"') {
                    sc.ForwardSetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_CHARACTER:
                if (sc.atLineEnd) {
                    sc.ChangeState(SCE_D_STRINGEOL);
                } else if (sc.ch == '\\') {
                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
                        sc.Forward();
                    }
                } else if (sc.ch == '\'') {
                    sc.ForwardSetState(SCE_D_DEFAULT);
                }
                break;
            case SCE_D_STRINGEOL:
                if (sc.atLineStart) {
                    sc.SetState(SCE_D_DEFAULT);
                }
                break;
        }

        // Determine if a new state should be entered.
        if (sc.state == SCE_D_DEFAULT) {
            if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
                    sc.SetState(SCE_D_NUMBER);
            } else if (IsWordStart(sc.ch)) {
                    sc.SetState(SCE_D_IDENTIFIER);
            } else if (sc.Match('/','+')) {
                curNcLevel += 1;
		curLine = styler.GetLine(sc.currentPos);
                styler.SetLineState(curLine, curNcLevel);
                sc.SetState(SCE_D_COMMENTNESTED);
                sc.Forward();
            } else if (sc.Match('/', '*')) {
                if (sc.Match("/**") || sc.Match("/*!")) {   // Support of Qt/Doxygen doc. style
                    sc.SetState(SCE_D_COMMENTDOC);
                } else {
                    sc.SetState(SCE_D_COMMENT);
                }
                sc.Forward();   // Eat the * so it isn't used for the end of the comment
            } else if (sc.Match('/', '/')) {
                if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!"))
                    // Support of Qt/Doxygen doc. style
                    sc.SetState(SCE_D_COMMENTLINEDOC);
                else
                    sc.SetState(SCE_D_COMMENTLINE);
            } else if (sc.ch == '\"') {
                sc.SetState(SCE_D_STRING);
            } else if (sc.ch == '\'') {
                sc.SetState(SCE_D_CHARACTER);
            } else if (isoperator(static_cast<char>(sc.ch))) {
                sc.SetState(SCE_D_OPERATOR);
            }
        }
    }
    sc.Complete();
}

static bool IsStreamCommentStyle(int style) {
    return style == SCE_D_COMMENT ||
        style == SCE_D_COMMENTDOC ||
        style == SCE_D_COMMENTDOCKEYWORD ||
        style == SCE_D_COMMENTDOCKEYWORDERROR;
}

// Store both the current line's fold level and the next lines in the
// level store to make it easy to pick up with each increment
// and to make it possible to fiddle the current level for "} else {".
static void FoldDoc(unsigned int startPos, int length, int initStyle, Accessor &styler) {
    bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
    bool foldAtElse = styler.GetPropertyInt("lexer.d.fold.at.else",
		styler.GetPropertyInt("fold.at.else", 0)) != 0;
    unsigned int endPos = startPos + length;
    int visibleChars = 0;
    int lineCurrent = styler.GetLine(startPos);
    int levelCurrent = SC_FOLDLEVELBASE;
    if (lineCurrent > 0)
        levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
    int levelMinCurrent = levelCurrent;
    int levelNext = levelCurrent;
    char chNext = styler[startPos];
    int styleNext = styler.StyleAt(startPos);
    int style = initStyle;
    for (unsigned int i = startPos; i < endPos; i++) {
        char ch = chNext;
        chNext = styler.SafeGetCharAt(i + 1);
        int stylePrev = style;
        style = styleNext;
        styleNext = styler.StyleAt(i + 1);
        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
        if (foldComment && IsStreamCommentStyle(style)) {
            if (!IsStreamCommentStyle(stylePrev)) {
                levelNext++;
            } else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
                // Comments don't end at end of line and the next character may be unstyled.
                levelNext--;
            }
        }
        if (style == SCE_D_OPERATOR) {
            if (ch == '{') {
                // Measure the minimum before a '{' to allow
                // folding on "} else {"
                if (levelMinCurrent > levelNext) {
                    levelMinCurrent = levelNext;
                }
                levelNext++;
            } else if (ch == '}') {
                levelNext--;
            }
        }
        if (atEOL) {
            if (foldComment) {	// Handle nested comments
		int nc;
                nc =  styler.GetLineState(lineCurrent);
                nc -= lineCurrent>0? styler.GetLineState(lineCurrent-1): 0;
                levelNext += nc;
	    }
            int levelUse = levelCurrent;
            if (foldAtElse) {
                levelUse = levelMinCurrent;
            }
            int lev = levelUse | levelNext << 16;
            if (visibleChars == 0 && foldCompact)
                lev |= SC_FOLDLEVELWHITEFLAG;
            if (levelUse < levelNext)
                lev |= SC_FOLDLEVELHEADERFLAG;
            if (lev != styler.LevelAt(lineCurrent)) {
                styler.SetLevel(lineCurrent, lev);
            }
            lineCurrent++;
            levelCurrent = levelNext;
            levelMinCurrent = levelCurrent;
            visibleChars = 0;
        }
        if (!IsASpace(ch))
            visibleChars++;
    }
}

static void FoldDDoc(unsigned int startPos, int length, int initStyle,
    WordList *[], Accessor &styler) {
        FoldDoc(startPos, length, initStyle, styler);
}

static const char * const dWordLists[] = {
            "Primary keywords and identifiers",
            "Secondary keywords and identifiers",
            "Documentation comment keywords",
            "Type definitions and aliases",
            0,
        };

static void ColouriseDDoc(unsigned int startPos, int length, 
    int initStyle, WordList *keywordlists[], Accessor &styler) {
        ColouriseDoc(startPos, length, initStyle, keywordlists, styler, true);
}

LexerModule lmD(SCLEX_D, ColouriseDDoc, "d", FoldDDoc, dWordLists);
Commit	Line	Data
7e0c58e9 RD	1	/** @file LexD.cxx
	2	** Lexer for D.
	3	**
	4	** Copyright (c) 2006 by Waldemar Augustyn <waldemar@wdmsys.com>
	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>
	11	#include <ctype.h>
	12	#include <stdio.h>
	13	#include <stdarg.h>
	14
	15	#include "Platform.h"
	16
	17	#include "PropSet.h"
	18	#include "Accessor.h"
	19	#include "StyleContext.h"
	20	#include "KeyWords.h"
	21	#include "Scintilla.h"
	22	#include "SciLexer.h"
	23
	24	#ifdef SCI_NAMESPACE
	25	using namespace Scintilla;
	26	#endif
	27
	28	/*/ Nested comments require keeping the value of the nesting level for every
	29	position in the document. But since scintilla always styles line by line,
	30	we only need to store one value per line. The non-negative number indicates
	31	nesting level at the end of the line.
	32	/*/
	33
	34	// We use custom qualifiers since it is not clear what D allows.
	35
	36	static bool IsWordStart(int ch) {
	37	return isascii(ch) && (isalpha(ch) \|\| ch == '_');
	38	}
	39
	40	static bool IsWord(int ch) {
	41	return isascii(ch) && (isalnum(ch) \|\| ch == '_');
	42	}
	43
	44	static bool IsDoxygen(int ch) {
	45	if (isascii(ch) && islower(ch))
	46	return true;
	47	if (ch == '$' \|\| ch == '@' \|\| ch == '\\' \|\|
	48	ch == '&' \|\| ch == '#' \|\| ch == '<' \|\| ch == '>' \|\|
	49	ch == '{' \|\| ch == '}' \|\| ch == '[' \|\| ch == ']')
	50	return true;
	51	return false;
	52	}
	53
	54
	55	static void ColouriseDoc(unsigned int startPos, int length, int initStyle,
	56	WordList *keywordlists[], Accessor &styler, bool caseSensitive) {
	57
	58	WordList &keywords = *keywordlists[0];
	59	WordList &keywords2 = *keywordlists[1];
	60	WordList &keywords3 = *keywordlists[2];
	61	WordList &keywords4 = *keywordlists[3];
	62
	63	int styleBeforeDCKeyword = SCE_D_DEFAULT;
	64
65	StyleContext sc(startPos, length, initStyle, styler);
66
67	int curLine = styler.GetLine(startPos);
68	int curNcLevel = curLine > 0? styler.GetLineState(curLine-1): 0;
69
70	for (; sc.More(); sc.Forward()) {
71
72	if (sc.atLineStart) {
73	if (sc.state == SCE_D_STRING) {
74	// Prevent SCE_D_STRINGEOL from leaking back to previous line which
75	// ends with a line continuation by locking in the state upto this position.
76	sc.SetState(SCE_D_STRING);
77	}
78	curLine = styler.GetLine(sc.currentPos);
79	styler.SetLineState(curLine, curNcLevel);
80	}
81
82	// Handle line continuation generically.
83	if (sc.ch == '\\') {
84	if (sc.chNext == '\n' \|\| sc.chNext == '\r') {
85	sc.Forward();
86	if (sc.ch == '\r' && sc.chNext == '\n') {
87	sc.Forward();
88	}
89	continue;
90	}
91	}
92
93	// Determine if the current state should terminate.
94	switch (sc.state) {
95	case SCE_D_OPERATOR:
96	sc.SetState(SCE_D_DEFAULT);
97	break;
98	case SCE_D_NUMBER:
99	// We accept almost anything because of hex. and number suffixes
100	if (!IsWord(sc.ch) && sc.ch != '.') {
101	sc.SetState(SCE_D_DEFAULT);
102	}
103	break;
104	case SCE_D_IDENTIFIER:
105	if (!IsWord(sc.ch)) {
106	char s[1000];
107	if (caseSensitive) {
108	sc.GetCurrent(s, sizeof(s));
109	} else {
110	sc.GetCurrentLowered(s, sizeof(s));
111	}
112	if (keywords.InList(s)) {
113	sc.ChangeState(SCE_D_WORD);
114	} else if (keywords2.InList(s)) {
115	sc.ChangeState(SCE_D_WORD2);
116	} else if (keywords4.InList(s)) {
117	sc.ChangeState(SCE_D_TYPEDEF);
118	}
119	sc.SetState(SCE_D_DEFAULT);
120	}
121	break;
122	case SCE_D_COMMENT:
123	if (sc.Match('*', '/')) {
124	sc.Forward();
125	sc.ForwardSetState(SCE_D_DEFAULT);
126	}
127	break;
128	case SCE_D_COMMENTDOC:
129	if (sc.Match('*', '/')) {
130	sc.Forward();
131	sc.ForwardSetState(SCE_D_DEFAULT);
132	} else if (sc.ch == '@' \|\| sc.ch == '\\') { // JavaDoc and Doxygen support
133	// Verify that we have the conditions to mark a comment-doc-keyword
134	if ((IsASpace(sc.chPrev) \|\| sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
135	styleBeforeDCKeyword = SCE_D_COMMENTDOC;
136	sc.SetState(SCE_D_COMMENTDOCKEYWORD);
137	}
138	}
139	break;
140	case SCE_D_COMMENTLINE:
141	if (sc.atLineStart) {
142	sc.SetState(SCE_D_DEFAULT);
143	}
144	break;
145	case SCE_D_COMMENTLINEDOC:
146	if (sc.atLineStart) {
147	sc.SetState(SCE_D_DEFAULT);
148	} else if (sc.ch == '@' \|\| sc.ch == '\\') { // JavaDoc and Doxygen support
149	// Verify that we have the conditions to mark a comment-doc-keyword
150	if ((IsASpace(sc.chPrev) \|\| sc.chPrev == '/' \|\| sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
151	styleBeforeDCKeyword = SCE_D_COMMENTLINEDOC;
152	sc.SetState(SCE_D_COMMENTDOCKEYWORD);
153	}
154	}
155	break;
156	case SCE_D_COMMENTDOCKEYWORD:
157	if ((styleBeforeDCKeyword == SCE_D_COMMENTDOC) && sc.Match('*', '/')) {
158	sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
159	sc.Forward();
160	sc.ForwardSetState(SCE_D_DEFAULT);
161	} else if (!IsDoxygen(sc.ch)) {
162	char s[100];
163	if (caseSensitive) {
164	sc.GetCurrent(s, sizeof(s));
165	} else {
166	sc.GetCurrentLowered(s, sizeof(s));
167	}
168	if (!IsASpace(sc.ch) \|\| !keywords3.InList(s + 1)) {
169	sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
170	}
171	sc.SetState(styleBeforeDCKeyword);
172	}
173	break;
174	case SCE_D_COMMENTNESTED:
175	if (sc.Match('+', '/')) {
176	if (curNcLevel > 0)
177	curNcLevel -= 1;
178	curLine = styler.GetLine(sc.currentPos);
179	styler.SetLineState(curLine, curNcLevel);
180	sc.Forward();
181	if (curNcLevel == 0) {
182	sc.ForwardSetState(SCE_D_DEFAULT);
183	}
184	}
185	else if (sc.Match('/','+')) {
186	curNcLevel += 1;
187	curLine = styler.GetLine(sc.currentPos);
188	styler.SetLineState(curLine, curNcLevel);
189	sc.Forward();
190	}
191	break;
192	case SCE_D_STRING:
193	if (sc.atLineEnd) {
194	sc.ChangeState(SCE_D_STRINGEOL);
195	} else if (sc.ch == '\\') {
196	if (sc.chNext == '\"' \|\| sc.chNext == '\'' \|\| sc.chNext == '\\') {
197	sc.Forward();
198	}
199	} else if (sc.ch == '\"') {
200	sc.ForwardSetState(SCE_D_DEFAULT);
201	}
202	break;
203	case SCE_D_CHARACTER:
204	if (sc.atLineEnd) {
205	sc.ChangeState(SCE_D_STRINGEOL);
206	} else if (sc.ch == '\\') {
207	if (sc.chNext == '\"' \|\| sc.chNext == '\'' \|\| sc.chNext == '\\') {
208	sc.Forward();
209	}
210	} else if (sc.ch == '\'') {
211	sc.ForwardSetState(SCE_D_DEFAULT);
212	}
213	break;
214	case SCE_D_STRINGEOL:
215	if (sc.atLineStart) {
216	sc.SetState(SCE_D_DEFAULT);
217	}
218	break;
219	}
220
221	// Determine if a new state should be entered.
222	if (sc.state == SCE_D_DEFAULT) {
223	if (IsADigit(sc.ch) \|\| (sc.ch == '.' && IsADigit(sc.chNext))) {
224	sc.SetState(SCE_D_NUMBER);
225	} else if (IsWordStart(sc.ch)) {
226	sc.SetState(SCE_D_IDENTIFIER);
227	} else if (sc.Match('/','+')) {
228	curNcLevel += 1;
229	curLine = styler.GetLine(sc.currentPos);
230	styler.SetLineState(curLine, curNcLevel);
231	sc.SetState(SCE_D_COMMENTNESTED);
232	sc.Forward();
233	} else if (sc.Match('/', '*')) {
234	if (sc.Match("/*") \|\| sc.Match("/!")) { // Support of Qt/Doxygen doc. style
235	sc.SetState(SCE_D_COMMENTDOC);
236	} else {
237	sc.SetState(SCE_D_COMMENT);
238	}
239	sc.Forward(); // Eat the * so it isn't used for the end of the comment
240	} else if (sc.Match('/', '/')) {
241	if ((sc.Match("///") && !sc.Match("////")) \|\| sc.Match("//!"))
242	// Support of Qt/Doxygen doc. style
243	sc.SetState(SCE_D_COMMENTLINEDOC);
244	else
245	sc.SetState(SCE_D_COMMENTLINE);
246	} else if (sc.ch == '\"') {
247	sc.SetState(SCE_D_STRING);
248	} else if (sc.ch == '\'') {
249	sc.SetState(SCE_D_CHARACTER);
250	} else if (isoperator(static_cast<char>(sc.ch))) {
251	sc.SetState(SCE_D_OPERATOR);
252	}
253	}
254	}
255	sc.Complete();
256	}
257
258	static bool IsStreamCommentStyle(int style) {
259	return style == SCE_D_COMMENT \|\|
260	style == SCE_D_COMMENTDOC \|\|
261	style == SCE_D_COMMENTDOCKEYWORD \|\|
262	style == SCE_D_COMMENTDOCKEYWORDERROR;
263	}
264
265	// Store both the current line's fold level and the next lines in the
266	// level store to make it easy to pick up with each increment
267	// and to make it possible to fiddle the current level for "} else {".
268	static void FoldDoc(unsigned int startPos, int length, int initStyle, Accessor &styler) {
269	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
270	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
271	bool foldAtElse = styler.GetPropertyInt("lexer.d.fold.at.else",
272	styler.GetPropertyInt("fold.at.else", 0)) != 0;
273	unsigned int endPos = startPos + length;
274	int visibleChars = 0;
275	int lineCurrent = styler.GetLine(startPos);
276	int levelCurrent = SC_FOLDLEVELBASE;
277	if (lineCurrent > 0)
278	levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
279	int levelMinCurrent = levelCurrent;
280	int levelNext = levelCurrent;
281	char chNext = styler[startPos];
282	int styleNext = styler.StyleAt(startPos);
283	int style = initStyle;
284	for (unsigned int i = startPos; i < endPos; i++) {
285	char ch = chNext;
286	chNext = styler.SafeGetCharAt(i + 1);
287	int stylePrev = style;
288	style = styleNext;
289	styleNext = styler.StyleAt(i + 1);
290	bool atEOL = (ch == '\r' && chNext != '\n') \|\| (ch == '\n');
291	if (foldComment && IsStreamCommentStyle(style)) {
292	if (!IsStreamCommentStyle(stylePrev)) {
293	levelNext++;
294	} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
295	// Comments don't end at end of line and the next character may be unstyled.
296	levelNext--;
297	}
298	}
299	if (style == SCE_D_OPERATOR) {
300	if (ch == '{') {
301	// Measure the minimum before a '{' to allow
302	// folding on "} else {"
303	if (levelMinCurrent > levelNext) {
304	levelMinCurrent = levelNext;
305	}
306	levelNext++;
307	} else if (ch == '}') {
308	levelNext--;
309	}
310	}
311	if (atEOL) {
312	if (foldComment) { // Handle nested comments
313	int nc;
314	nc = styler.GetLineState(lineCurrent);
315	nc -= lineCurrent>0? styler.GetLineState(lineCurrent-1): 0;
316	levelNext += nc;
317	}
318	int levelUse = levelCurrent;
319	if (foldAtElse) {
320	levelUse = levelMinCurrent;
321	}
322	int lev = levelUse \| levelNext << 16;
323	if (visibleChars == 0 && foldCompact)
324	lev \|= SC_FOLDLEVELWHITEFLAG;
325	if (levelUse < levelNext)
326	lev \|= SC_FOLDLEVELHEADERFLAG;
327	if (lev != styler.LevelAt(lineCurrent)) {
328	styler.SetLevel(lineCurrent, lev);
329	}
330	lineCurrent++;
331	levelCurrent = levelNext;
332	levelMinCurrent = levelCurrent;
333	visibleChars = 0;
334	}
335	if (!IsASpace(ch))
336	visibleChars++;
337	}
338	}
339
340	static void FoldDDoc(unsigned int startPos, int length, int initStyle,
341	WordList *[], Accessor &styler) {
342	FoldDoc(startPos, length, initStyle, styler);
343	}
344
345	static const char * const dWordLists[] = {
346	"Primary keywords and identifiers",
347	"Secondary keywords and identifiers",
348	"Documentation comment keywords",
349	"Type definitions and aliases",
350	0,
351	};
352
353	static void ColouriseDDoc(unsigned int startPos, int length,
354	int initStyle, WordList *keywordlists[], Accessor &styler) {
355	ColouriseDoc(startPos, length, initStyle, keywordlists, styler, true);
356	}
357
358	LexerModule lmD(SCLEX_D, ColouriseDDoc, "d", FoldDDoc, dWordLists);