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

// Scintilla source code edit control
/** @file LexYAML.cxx
 ** Lexer for YAML.
 **/
// Copyright 2003- by Sean O'Dell <sean@celsoft.com>
// Release under the same license as Scintilla/SciTE.

#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

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

static inline bool AtEOL(Accessor &styler, unsigned int i) {
	return (styler[i] == '\n') ||
		((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
}

static unsigned int SpaceCount(char* lineBuffer) {
	if (lineBuffer == NULL)
		return 0;

	char* headBuffer = lineBuffer;

	while (*headBuffer == ' ')
		headBuffer++;

	return headBuffer - lineBuffer;
}

#define YAML_STATE_BITSIZE 16
#define YAML_STATE_MASK			(0xFFFF0000)
#define YAML_STATE_DOCUMENT		(1 << YAML_STATE_BITSIZE)
#define YAML_STATE_VALUE			(2 << YAML_STATE_BITSIZE)
#define YAML_STATE_COMMENT		(3 << YAML_STATE_BITSIZE)
#define YAML_STATE_TEXT_PARENT	(4 << YAML_STATE_BITSIZE)
#define YAML_STATE_TEXT			(5 << YAML_STATE_BITSIZE)

static void ColouriseYAMLLine(
	char *lineBuffer,
	unsigned int currentLine,
	unsigned int lengthLine,
	unsigned int startLine,
	unsigned int endPos,
	WordList &keywords,
	Accessor &styler) {

	unsigned int i = 0;
	bool bInQuotes = false;
	unsigned int indentAmount = SpaceCount(lineBuffer);

	if (currentLine > 0) {
		int parentLineState = styler.GetLineState(currentLine - 1);

		if ((parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT || (parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT_PARENT) {
			unsigned int parentIndentAmount = parentLineState&(~YAML_STATE_MASK);
			if (indentAmount > parentIndentAmount) {
				styler.SetLineState(currentLine, YAML_STATE_TEXT | parentIndentAmount);
				styler.ColourTo(endPos, SCE_YAML_TEXT);
				return;
			}
		}
	}
	styler.SetLineState(currentLine, 0);
	if (strncmp(lineBuffer, "---", 3) == 0) {	// Document marker
		styler.SetLineState(currentLine, YAML_STATE_DOCUMENT);
		styler.ColourTo(endPos, SCE_YAML_DOCUMENT);
		return;
	}
	// Skip initial spaces
	while ((i < lengthLine) && lineBuffer[i] == ' ') { // YAML always uses space, never TABS or anything else
		i++;
	}
	if (lineBuffer[i] == '\t') { // if we skipped all spaces, and we are NOT inside a text block, this is wrong
		styler.ColourTo(endPos, SCE_YAML_ERROR);
		return;
	}
	if (lineBuffer[i] == '#') {	// Comment
		styler.SetLineState(currentLine, YAML_STATE_COMMENT);
		styler.ColourTo(endPos, SCE_YAML_COMMENT);
		return;
	}
	while (i < lengthLine) {
		if (lineBuffer[i] == '\'' || lineBuffer[i] == '\"') {
			bInQuotes = !bInQuotes;
		} else if (lineBuffer[i] == ':' && !bInQuotes) {
			styler.ColourTo(startLine + i - 1, SCE_YAML_IDENTIFIER);
			styler.ColourTo(startLine + i, SCE_YAML_OPERATOR);
			// Non-folding scalar
			i++;
			while ((i < lengthLine) && isspacechar(lineBuffer[i]))
				i++;
			unsigned int endValue = lengthLine - 1;
			while ((endValue >= i) && isspacechar(lineBuffer[endValue]))
				endValue--;
			lineBuffer[endValue + 1] = '\0';
			if (lineBuffer[i] == '|' || lineBuffer[i] == '>') {
				i++;
				if (lineBuffer[i] == '+' || lineBuffer[i] == '-')
					i++;
				while ((i < lengthLine) && isspacechar(lineBuffer[i]))
					i++;
				if (lineBuffer[i] == '\0') {
					styler.SetLineState(currentLine, YAML_STATE_TEXT_PARENT | indentAmount);
					styler.ColourTo(endPos, SCE_YAML_DEFAULT);
					return;
				} else if (lineBuffer[i] == '#') {
					styler.SetLineState(currentLine, YAML_STATE_TEXT_PARENT | indentAmount);
					styler.ColourTo(startLine + i - 1, SCE_YAML_DEFAULT);
					styler.ColourTo(endPos, SCE_YAML_COMMENT);
					return;
				} else {
					styler.ColourTo(endPos, SCE_YAML_ERROR);
					return;
				}
			} else if (lineBuffer[i] == '#') {
				styler.ColourTo(startLine + i - 1, SCE_YAML_DEFAULT);
				styler.ColourTo(endPos, SCE_YAML_COMMENT);
				return;
			}
			styler.SetLineState(currentLine, YAML_STATE_VALUE);
			if (lineBuffer[i] == '&' || lineBuffer[i] == '*') {
				styler.ColourTo(endPos, SCE_YAML_REFERENCE);
				return;
			}
			if (keywords.InList(&lineBuffer[i])) { // Convertible value (true/false, etc.)
				styler.ColourTo(endPos, SCE_YAML_KEYWORD);
				return;
			} else {
				unsigned int i2 = i;
				while ((i < lengthLine) && lineBuffer[i]) {
					if (!isdigit(lineBuffer[i]) && lineBuffer[i] != '-' && lineBuffer[i] != '.' && lineBuffer[i] != ',') {
						styler.ColourTo(endPos, SCE_YAML_DEFAULT);
						return;
					}
					i++;
				}
				if (i > i2) {
					styler.ColourTo(endPos, SCE_YAML_NUMBER);
					return;
				}
			}
			break; // shouldn't get here, but just in case, the rest of the line is coloured the default
		}
		i++;
	}
	styler.ColourTo(endPos, SCE_YAML_DEFAULT);
}

static void ColouriseYAMLDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) {
	char lineBuffer[1024];
	styler.StartAt(startPos);
	styler.StartSegment(startPos);
	unsigned int linePos = 0;
	unsigned int startLine = startPos;
	unsigned int endPos = startPos + length;
	unsigned int maxPos = styler.Length();
	unsigned int lineCurrent = styler.GetLine(startPos);

	for (unsigned int i = startPos; i < maxPos && i < endPos; i++) {
		lineBuffer[linePos++] = styler[i];
		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
			// End of line (or of line buffer) met, colourise it
			lineBuffer[linePos] = '\0';
			ColouriseYAMLLine(lineBuffer, lineCurrent, linePos, startLine, i, *keywordLists[0], styler);
			linePos = 0;
			startLine = i + 1;
			lineCurrent++;
		}
	}
	if (linePos > 0) {	// Last line does not have ending characters
		ColouriseYAMLLine(lineBuffer, lineCurrent, linePos, startLine, startPos + length - 1, *keywordLists[0], styler);
	}
}

static bool IsCommentLine(int line, Accessor &styler) {
	int pos = styler.LineStart(line);
	if (styler[pos] == '#')
		return true;
	return false;
}

static void FoldYAMLDoc(unsigned int startPos, int length, int /*initStyle - unused*/,
                      WordList *[], Accessor &styler) {
	const int maxPos = startPos + length;
	const int maxLines = styler.GetLine(maxPos - 1);             // Requested last line
	const int docLines = styler.GetLine(styler.Length() - 1);  // Available last line
	const bool foldComment = styler.GetPropertyInt("fold.comment.yaml") != 0;

	// Backtrack to previous non-blank line so we can determine indent level
	// for any white space lines
	// and so we can fix any preceding fold level (which is why we go back
	// at least one line in all cases)
	int spaceFlags = 0;
	int lineCurrent = styler.GetLine(startPos);
	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
	while (lineCurrent > 0) {
		lineCurrent--;
		indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
		if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG) &&
		        (!IsCommentLine(lineCurrent, styler)))
			break;
	}
	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;

	// Set up initial loop state
	int prevComment = 0;
	if (lineCurrent >= 1)
		prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);

	// Process all characters to end of requested range
	// or comment that hangs over the end of the range.  Cap processing in all cases
	// to end of document (in case of unclosed comment at end).
	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) || prevComment)) {

		// Gather info
		int lev = indentCurrent;
		int lineNext = lineCurrent + 1;
		int indentNext = indentCurrent;
		if (lineNext <= docLines) {
			// Information about next line is only available if not at end of document
			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
	}
		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
		                           IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
		const int comment_continue = (comment && prevComment);
		if (!comment)
			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
		if (indentNext & SC_FOLDLEVELWHITEFLAG)
			indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;

		if (comment_start) {
			// Place fold point at start of a block of comments
			lev |= SC_FOLDLEVELHEADERFLAG;
		} else if (comment_continue) {
			// Add level to rest of lines in the block
			lev = lev + 1;
		}

		// Skip past any blank lines for next indent level info; we skip also
		// comments (all comments, not just those starting in column 0)
		// which effectively folds them into surrounding code rather
		// than screwing up folding.

		while ((lineNext < docLines) &&
		        ((indentNext & SC_FOLDLEVELWHITEFLAG) ||
		         (lineNext <= docLines && IsCommentLine(lineNext, styler)))) {

			lineNext++;
			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
		}

		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
		const int levelBeforeComments = Platform::Maximum(indentCurrentLevel,levelAfterComments);

		// Now set all the indent levels on the lines we skipped
		// Do this from end to start.  Once we encounter one line
		// which is indented more than the line after the end of
		// the comment-block, use the level of the block before

		int skipLine = lineNext;
		int skipLevel = levelAfterComments;

		while (--skipLine > lineCurrent) {
			int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, NULL);

			if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
				skipLevel = levelBeforeComments;

			int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;

			styler.SetLevel(skipLine, skipLevel | whiteFlag);
		}

		// Set fold header on non-comment line
		if (!comment && !(indentCurrent & SC_FOLDLEVELWHITEFLAG) ) {
			if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
				lev |= SC_FOLDLEVELHEADERFLAG;
		}

		// Keep track of block comment state of previous line
		prevComment = comment_start || comment_continue;

		// Set fold level for this line and move to next line
		styler.SetLevel(lineCurrent, lev);
		indentCurrent = indentNext;
		lineCurrent = lineNext;
	}

	// NOTE: Cannot set level of last line here because indentCurrent doesn't have
	// header flag set; the loop above is crafted to take care of this case!
	//styler.SetLevel(lineCurrent, indentCurrent);
}

LexerModule lmYAML(SCLEX_YAML, ColouriseYAMLDoc, "yaml", FoldYAMLDoc, yamlWordListDesc);
Commit	Line	Data
8e54aaed RD	1	// Scintilla source code edit control
	2	/** @file LexYAML.cxx
	3	** Lexer for YAML.
	4	**/
	5	// Copyright 2003- by Sean O'Dell <sean@celsoft.com>
	6	// Release under the same license as Scintilla/SciTE.
	7
	8	#include <stdlib.h>
	9	#include <string.h>
	10	#include <ctype.h>
	11	#include <stdio.h>
	12	#include <stdarg.h>
	13
	14	#include "Platform.h"
	15
	16	#include "PropSet.h"
	17	#include "Accessor.h"
	18	#include "StyleContext.h"
	19	#include "KeyWords.h"
	20	#include "Scintilla.h"
	21	#include "SciLexer.h"
	22
7e0c58e9 RD	23	#ifdef SCI_NAMESPACE
	24	using namespace Scintilla;
	25	#endif
	26
8e54aaed RD	27	static const char * const yamlWordListDesc[] = {
	28	"Keywords",
	29	0
	30	};
	31
	32	static inline bool AtEOL(Accessor &styler, unsigned int i) {
	33	return (styler[i] == '\n') \|\|
	34	((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
	35	}
	36
	37	static unsigned int SpaceCount(char* lineBuffer) {
	38	if (lineBuffer == NULL)
	39	return 0;
7e0c58e9	40
8e54aaed	41	char* headBuffer = lineBuffer;
7e0c58e9	42
8e54aaed RD	43	while (*headBuffer == ' ')
8e54aaed RD	44	headBuffer++;
7e0c58e9	45
8e54aaed RD	46	return headBuffer - lineBuffer;
	47	}
	48
	49	#define YAML_STATE_BITSIZE 16
	50	#define YAML_STATE_MASK (0xFFFF0000)
	51	#define YAML_STATE_DOCUMENT (1 << YAML_STATE_BITSIZE)
	52	#define YAML_STATE_VALUE (2 << YAML_STATE_BITSIZE)
	53	#define YAML_STATE_COMMENT (3 << YAML_STATE_BITSIZE)
	54	#define YAML_STATE_TEXT_PARENT (4 << YAML_STATE_BITSIZE)
	55	#define YAML_STATE_TEXT (5 << YAML_STATE_BITSIZE)
	56
	57	static void ColouriseYAMLLine(
	58	char *lineBuffer,
	59	unsigned int currentLine,
	60	unsigned int lengthLine,
	61	unsigned int startLine,
	62	unsigned int endPos,
	63	WordList &keywords,
	64	Accessor &styler) {
7e0c58e9	65
8e54aaed RD	66	unsigned int i = 0;
	67	bool bInQuotes = false;
	68	unsigned int indentAmount = SpaceCount(lineBuffer);
7e0c58e9	69
8e54aaed RD	70	if (currentLine > 0) {
8e54aaed RD	71	int parentLineState = styler.GetLineState(currentLine - 1);
7e0c58e9	72
8e54aaed RD	73	if ((parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT \|\| (parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT_PARENT) {
	74	unsigned int parentIndentAmount = parentLineState&(~YAML_STATE_MASK);
	75	if (indentAmount > parentIndentAmount) {
	76	styler.SetLineState(currentLine, YAML_STATE_TEXT \| parentIndentAmount);
	77	styler.ColourTo(endPos, SCE_YAML_TEXT);
	78	return;
	79	}
	80	}
	81	}
	82	styler.SetLineState(currentLine, 0);
	83	if (strncmp(lineBuffer, "---", 3) == 0) { // Document marker
	84	styler.SetLineState(currentLine, YAML_STATE_DOCUMENT);
	85	styler.ColourTo(endPos, SCE_YAML_DOCUMENT);
	86	return;
	87	}
	88	// Skip initial spaces
	89	while ((i < lengthLine) && lineBuffer[i] == ' ') { // YAML always uses space, never TABS or anything else
	90	i++;
	91	}
	92	if (lineBuffer[i] == '\t') { // if we skipped all spaces, and we are NOT inside a text block, this is wrong
	93	styler.ColourTo(endPos, SCE_YAML_ERROR);
	94	return;
	95	}
	96	if (lineBuffer[i] == '#') { // Comment
	97	styler.SetLineState(currentLine, YAML_STATE_COMMENT);
	98	styler.ColourTo(endPos, SCE_YAML_COMMENT);
	99	return;
	100	}
	101	while (i < lengthLine) {
	102	if (lineBuffer[i] == '\'' \|\| lineBuffer[i] == '\"') {
	103	bInQuotes = !bInQuotes;
	104	} else if (lineBuffer[i] == ':' && !bInQuotes) {
7e0c58e9 RD	105	styler.ColourTo(startLine + i - 1, SCE_YAML_IDENTIFIER);
7e0c58e9 RD	106	styler.ColourTo(startLine + i, SCE_YAML_OPERATOR);
8e54aaed RD	107	// Non-folding scalar
	108	i++;
	109	while ((i < lengthLine) && isspacechar(lineBuffer[i]))
	110	i++;
	111	unsigned int endValue = lengthLine - 1;
	112	while ((endValue >= i) && isspacechar(lineBuffer[endValue]))
	113	endValue--;
	114	lineBuffer[endValue + 1] = '\0';
	115	if (lineBuffer[i] == '\|' \|\| lineBuffer[i] == '>') {
	116	i++;
	117	if (lineBuffer[i] == '+' \|\| lineBuffer[i] == '-')
	118	i++;
	119	while ((i < lengthLine) && isspacechar(lineBuffer[i]))
	120	i++;
	121	if (lineBuffer[i] == '\0') {
	122	styler.SetLineState(currentLine, YAML_STATE_TEXT_PARENT \| indentAmount);
	123	styler.ColourTo(endPos, SCE_YAML_DEFAULT);
	124	return;
	125	} else if (lineBuffer[i] == '#') {
	126	styler.SetLineState(currentLine, YAML_STATE_TEXT_PARENT \| indentAmount);
	127	styler.ColourTo(startLine + i - 1, SCE_YAML_DEFAULT);
	128	styler.ColourTo(endPos, SCE_YAML_COMMENT);
	129	return;
	130	} else {
	131	styler.ColourTo(endPos, SCE_YAML_ERROR);
	132	return;
	133	}
7e0c58e9 RD	134	} else if (lineBuffer[i] == '#') {
	135	styler.ColourTo(startLine + i - 1, SCE_YAML_DEFAULT);
	136	styler.ColourTo(endPos, SCE_YAML_COMMENT);
	137	return;
8e54aaed RD	138	}
	139	styler.SetLineState(currentLine, YAML_STATE_VALUE);
	140	if (lineBuffer[i] == '&' \|\| lineBuffer[i] == '*') {
	141	styler.ColourTo(endPos, SCE_YAML_REFERENCE);
	142	return;
	143	}
	144	if (keywords.InList(&lineBuffer[i])) { // Convertible value (true/false, etc.)
	145	styler.ColourTo(endPos, SCE_YAML_KEYWORD);
	146	return;
	147	} else {
	148	unsigned int i2 = i;
	149	while ((i < lengthLine) && lineBuffer[i]) {
	150	if (!isdigit(lineBuffer[i]) && lineBuffer[i] != '-' && lineBuffer[i] != '.' && lineBuffer[i] != ',') {
	151	styler.ColourTo(endPos, SCE_YAML_DEFAULT);
	152	return;
	153	}
	154	i++;
	155	}
	156	if (i > i2) {
	157	styler.ColourTo(endPos, SCE_YAML_NUMBER);
	158	return;
	159	}
	160	}
	161	break; // shouldn't get here, but just in case, the rest of the line is coloured the default
	162	}
	163	i++;
	164	}
	165	styler.ColourTo(endPos, SCE_YAML_DEFAULT);
	166	}
	167
	168	static void ColouriseYAMLDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) {
	169	char lineBuffer[1024];
	170	styler.StartAt(startPos);
	171	styler.StartSegment(startPos);
	172	unsigned int linePos = 0;
	173	unsigned int startLine = startPos;
	174	unsigned int endPos = startPos + length;
	175	unsigned int maxPos = styler.Length();
	176	unsigned int lineCurrent = styler.GetLine(startPos);
7e0c58e9	177
8e54aaed RD	178	for (unsigned int i = startPos; i < maxPos && i < endPos; i++) {
	179	lineBuffer[linePos++] = styler[i];
	180	if (AtEOL(styler, i) \|\| (linePos >= sizeof(lineBuffer) - 1)) {
	181	// End of line (or of line buffer) met, colourise it
	182	lineBuffer[linePos] = '\0';
	183	ColouriseYAMLLine(lineBuffer, lineCurrent, linePos, startLine, i, *keywordLists[0], styler);
	184	linePos = 0;
	185	startLine = i + 1;
	186	lineCurrent++;
	187	}
	188	}
	189	if (linePos > 0) { // Last line does not have ending characters
	190	ColouriseYAMLLine(lineBuffer, lineCurrent, linePos, startLine, startPos + length - 1, *keywordLists[0], styler);
	191	}
	192	}
	193
	194	static bool IsCommentLine(int line, Accessor &styler) {
	195	int pos = styler.LineStart(line);
	196	if (styler[pos] == '#')
	197	return true;
	198	return false;
	199	}
	200
	201	static void FoldYAMLDoc(unsigned int startPos, int length, int /initStyle - unused/,
	202	WordList *[], Accessor &styler) {
	203	const int maxPos = startPos + length;
	204	const int maxLines = styler.GetLine(maxPos - 1); // Requested last line
	205	const int docLines = styler.GetLine(styler.Length() - 1); // Available last line
	206	const bool foldComment = styler.GetPropertyInt("fold.comment.yaml") != 0;
	207
	208	// Backtrack to previous non-blank line so we can determine indent level
	209	// for any white space lines
	210	// and so we can fix any preceding fold level (which is why we go back
	211	// at least one line in all cases)
	212	int spaceFlags = 0;
	213	int lineCurrent = styler.GetLine(startPos);
	214	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
	215	while (lineCurrent > 0) {
	216	lineCurrent--;
	217	indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
	218	if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG) &&
	219	(!IsCommentLine(lineCurrent, styler)))
	220	break;
	221	}
	222	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
	223
	224	// Set up initial loop state
	225	int prevComment = 0;
	226	if (lineCurrent >= 1)
	227	prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);
	228
	229	// Process all characters to end of requested range
	230	// or comment that hangs over the end of the range. Cap processing in all cases
	231	// to end of document (in case of unclosed comment at end).
	232	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) \|\| prevComment)) {
	233
	234	// Gather info
	235	int lev = indentCurrent;
	236	int lineNext = lineCurrent + 1;
	237	int indentNext = indentCurrent;
	238	if (lineNext <= docLines) {
	239	// Information about next line is only available if not at end of document
	240	indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
	241	}
242	const int comment = foldComment && IsCommentLine(lineCurrent, styler);
243	const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
244	IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
245	const int comment_continue = (comment && prevComment);
246	if (!comment)
247	indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
248	if (indentNext & SC_FOLDLEVELWHITEFLAG)
249	indentNext = SC_FOLDLEVELWHITEFLAG \| indentCurrentLevel;
250
251	if (comment_start) {
252	// Place fold point at start of a block of comments
253	lev \|= SC_FOLDLEVELHEADERFLAG;
254	} else if (comment_continue) {
255	// Add level to rest of lines in the block
256	lev = lev + 1;
257	}
258
259	// Skip past any blank lines for next indent level info; we skip also
260	// comments (all comments, not just those starting in column 0)
261	// which effectively folds them into surrounding code rather
262	// than screwing up folding.
263
264	while ((lineNext < docLines) &&
265	((indentNext & SC_FOLDLEVELWHITEFLAG) \|\|
266	(lineNext <= docLines && IsCommentLine(lineNext, styler)))) {
267
268	lineNext++;
269	indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
270	}
271
272	const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
273	const int levelBeforeComments = Platform::Maximum(indentCurrentLevel,levelAfterComments);
274
275	// Now set all the indent levels on the lines we skipped
276	// Do this from end to start. Once we encounter one line
277	// which is indented more than the line after the end of
278	// the comment-block, use the level of the block before
279
280	int skipLine = lineNext;
281	int skipLevel = levelAfterComments;
282
283	while (--skipLine > lineCurrent) {
284	int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, NULL);
285
286	if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
287	skipLevel = levelBeforeComments;
288
289	int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
290
291	styler.SetLevel(skipLine, skipLevel \| whiteFlag);
292	}
293
294	// Set fold header on non-comment line
295	if (!comment && !(indentCurrent & SC_FOLDLEVELWHITEFLAG) ) {
296	if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
297	lev \|= SC_FOLDLEVELHEADERFLAG;
298	}
299
300	// Keep track of block comment state of previous line
301	prevComment = comment_start \|\| comment_continue;
302
303	// Set fold level for this line and move to next line
304	styler.SetLevel(lineCurrent, lev);
305	indentCurrent = indentNext;
306	lineCurrent = lineNext;
307	}
308
309	// NOTE: Cannot set level of last line here because indentCurrent doesn't have
310	// header flag set; the loop above is crafted to take care of this case!
311	//styler.SetLevel(lineCurrent, indentCurrent);
312	}
313
314	LexerModule lmYAML(SCLEX_YAML, ColouriseYAMLDoc, "yaml", FoldYAMLDoc, yamlWordListDesc);