text: // Scintilla source code edit control
  /** @file LexOthers.cxx
   ** Lexers for batch files, diff results, properties files, make files and error lists.
   ** Also lexer for LaTeX documents.
   **/
  // Copyright 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 bool strstart(const char *haystack, const char *needle) {
  	return strncmp(haystack, needle, strlen(needle)) == 0;
  }
  
  static bool Is0To9(char ch) {
  	return (ch >= '0') && (ch <= '9');
  }
  
  static bool Is1To9(char ch) {
  	return (ch >= '1') && (ch <= '9');
  }
  
  static bool IsAlphabetic(int ch) {
  	return isascii(ch) && isalpha(ch);
  }
  
  static inline bool AtEOL(Accessor &styler, unsigned int i) {
  	return (styler[i] == '\n') ||
  	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
  }
  
  // Tests for BATCH Operators
  static bool IsBOperator(char ch) {
  	return (ch == '=') || (ch == '+') || (ch == '>') || (ch == '<') ||
  		(ch == '|') || (ch == '?') || (ch == '*');
  }
  
  // Tests for BATCH Separators
  static bool IsBSeparator(char ch) {
  	return (ch == '\\') || (ch == '.') || (ch == ';') ||
  		(ch == '\"') || (ch == '\'') || (ch == '/');
  }
  
  static void ColouriseBatchLine(
      char *lineBuffer,
      unsigned int lengthLine,
      unsigned int startLine,
      unsigned int endPos,
      WordList *keywordlists[],
      Accessor &styler) {
  
  	unsigned int offset = 0;	// Line Buffer Offset
  	unsigned int cmdLoc;		// External Command / Program Location
  	char wordBuffer[81];		// Word Buffer - large to catch long paths
  	unsigned int wbl;		// Word Buffer Length
  	unsigned int wbo;		// Word Buffer Offset - also Special Keyword Buffer Length
  	WordList &keywords = *keywordlists[0];      // Internal Commands
  	WordList &keywords2 = *keywordlists[1];     // External Commands (optional)
  
  	// CHOICE, ECHO, GOTO, PROMPT and SET have Default Text that may contain Regular Keywords
  	//   Toggling Regular Keyword Checking off improves readability
  	// Other Regular Keywords and External Commands / Programs might also benefit from toggling
  	//   Need a more robust algorithm to properly toggle Regular Keyword Checking
  	bool continueProcessing = true;	// Used to toggle Regular Keyword Checking
  	// Special Keywords are those that allow certain characters without whitespace after the command
  	// Examples are: cd. cd\ md. rd. dir| dir> echo: echo. path=
  	// Special Keyword Buffer used to determine if the first n characters is a Keyword
  	char sKeywordBuffer[10];	// Special Keyword Buffer
  	bool sKeywordFound;		// Exit Special Keyword for-loop if found
  
  	// Skip initial spaces
  	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
  		offset++;
  	}
  	// Colorize Default Text
  	styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
  	// Set External Command / Program Location
  	cmdLoc = offset;
  
  	// Check for Fake Label (Comment) or Real Label - return if found
  	if (lineBuffer[offset] == ':') {
  		if (lineBuffer[offset + 1] == ':') {
  			// Colorize Fake Label (Comment) - :: is similar to REM, see http://content.techweb.com/winmag/columns/explorer/2000/21.htm
  			styler.ColourTo(endPos, SCE_BAT_COMMENT);
  		} else {
  			// Colorize Real Label
  			styler.ColourTo(endPos, SCE_BAT_LABEL);
  		}
  		return;
  	// Check for Drive Change (Drive Change is internal command) - return if found
  	} else if ((IsAlphabetic(lineBuffer[offset])) &&
  		(lineBuffer[offset + 1] == ':') &&
  		((isspacechar(lineBuffer[offset + 2])) ||
  		(((lineBuffer[offset + 2] == '\\')) &&
  		(isspacechar(lineBuffer[offset + 3]))))) {
  		// Colorize Regular Keyword
  		styler.ColourTo(endPos, SCE_BAT_WORD);
  		return;
  	}
  
  	// Check for Hide Command (@ECHO OFF/ON)
  	if (lineBuffer[offset] == '@') {
  		styler.ColourTo(startLine + offset, SCE_BAT_HIDE);
  		offset++;
  	}
  	// Skip next spaces
  	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
  		offset++;
  	}
  
  	// Read remainder of line word-at-a-time or remainder-of-word-at-a-time
  	while (offset < lengthLine) {
  		if (offset > startLine) {
  			// Colorize Default Text
  			styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
  		}
  		// Copy word from Line Buffer into Word Buffer
  		wbl = 0;
  		for (; offset < lengthLine && wbl < 80 &&
  		        !isspacechar(lineBuffer[offset]); wbl++, offset++) {
  			wordBuffer[wbl] = static_cast<char>(tolower(lineBuffer[offset]));
  		}
  		wordBuffer[wbl] = '\0';
  		wbo = 0;
  
  		// Check for Comment - return if found
  		if (CompareCaseInsensitive(wordBuffer, "rem") == 0) {
  			styler.ColourTo(endPos, SCE_BAT_COMMENT);
  			return;
  		}
  		// Check for Separator
  		if (IsBSeparator(wordBuffer[0])) {
  			// Check for External Command / Program
  			if ((cmdLoc == offset - wbl) &&
  				((wordBuffer[0] == ':') ||
  				(wordBuffer[0] == '\\') ||
  				(wordBuffer[0] == '.'))) {
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 1);
  				// Colorize External Command / Program
  				if (!keywords2) {
  					styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
  				} else if (keywords2.InList(wordBuffer)) {
  					styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
  				} else {
  					styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
  				}
  				// Reset External Command / Program Location
  				cmdLoc = offset;
  			} else {
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 1);
  				// Colorize Default Text
  				styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
  			}
  		// Check for Regular Keyword in list
  		} else if ((keywords.InList(wordBuffer)) &&
  			(continueProcessing)) {
  			// ECHO, GOTO, PROMPT and SET require no further Regular Keyword Checking
  			if ((CompareCaseInsensitive(wordBuffer, "echo") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "goto") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "prompt") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "set") == 0)) {
  				continueProcessing = false;
  			}
  			// Identify External Command / Program Location for ERRORLEVEL, and EXIST
  			if ((CompareCaseInsensitive(wordBuffer, "errorlevel") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "exist") == 0)) {
  				// Reset External Command / Program Location
  				cmdLoc = offset;
  				// Skip next spaces
  				while ((cmdLoc < lengthLine) &&
  					(isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  				// Skip comparison
  				while ((cmdLoc < lengthLine) &&
  					(!isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  				// Skip next spaces
  				while ((cmdLoc < lengthLine) &&
  					(isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  			// Identify External Command / Program Location for CALL, DO, LOADHIGH and LH
  			} else if ((CompareCaseInsensitive(wordBuffer, "call") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "do") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "loadhigh") == 0) ||
  				(CompareCaseInsensitive(wordBuffer, "lh") == 0)) {
  				// Reset External Command / Program Location
  				cmdLoc = offset;
  				// Skip next spaces
  				while ((cmdLoc < lengthLine) &&
  					(isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  			}
  			// Colorize Regular keyword
  			styler.ColourTo(startLine + offset - 1, SCE_BAT_WORD);
  			// No need to Reset Offset
  		// Check for Special Keyword in list, External Command / Program, or Default Text
  		} else if ((wordBuffer[0] != '%') &&
  				   (wordBuffer[0] != '!') &&
  			(!IsBOperator(wordBuffer[0])) &&
  			(continueProcessing)) {
  			// Check for Special Keyword
  			//     Affected Commands are in Length range 2-6
  			//     Good that ERRORLEVEL, EXIST, CALL, DO, LOADHIGH, and LH are unaffected
  			sKeywordFound = false;
  			for (unsigned int keywordLength = 2; keywordLength < wbl && keywordLength < 7 && !sKeywordFound; keywordLength++) {
  				wbo = 0;
  				// Copy Keyword Length from Word Buffer into Special Keyword Buffer
  				for (; wbo < keywordLength; wbo++) {
  					sKeywordBuffer[wbo] = static_cast<char>(wordBuffer[wbo]);
  				}
  				sKeywordBuffer[wbo] = '\0';
  				// Check for Special Keyword in list
  				if ((keywords.InList(sKeywordBuffer)) &&
  					((IsBOperator(wordBuffer[wbo])) ||
  					(IsBSeparator(wordBuffer[wbo])))) {
  					sKeywordFound = true;
  					// ECHO requires no further Regular Keyword Checking
  					if (CompareCaseInsensitive(sKeywordBuffer, "echo") == 0) {
  						continueProcessing = false;
  					}
  					// Colorize Special Keyword as Regular Keyword
  					styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_WORD);
  					// Reset Offset to re-process remainder of word
  					offset -= (wbl - wbo);
  				}
  			}
  			// Check for External Command / Program or Default Text
  			if (!sKeywordFound) {
  				wbo = 0;
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					// Read up to %, Operator or Separator
  					while ((wbo < wbl) &&
  						(wordBuffer[wbo] != '%') &&
  						(wordBuffer[wbo] != '!') &&
  						(!IsBOperator(wordBuffer[wbo])) &&
  						(!IsBSeparator(wordBuffer[wbo]))) {
  						wbo++;
  					}
  					// Reset External Command / Program Location
  					cmdLoc = offset - (wbl - wbo);
  					// Reset Offset to re-process remainder of word
  					offset -= (wbl - wbo);
  					// CHOICE requires no further Regular Keyword Checking
  					if (CompareCaseInsensitive(wordBuffer, "choice") == 0) {
  						continueProcessing = false;
  					}
  					// Check for START (and its switches) - What follows is External Command \ Program
  					if (CompareCaseInsensitive(wordBuffer, "start") == 0) {
  						// Reset External Command / Program Location
  						cmdLoc = offset;
  						// Skip next spaces
  						while ((cmdLoc < lengthLine) &&
  							(isspacechar(lineBuffer[cmdLoc]))) {
  							cmdLoc++;
  						}
  						// Reset External Command / Program Location if command switch detected
  						if (lineBuffer[cmdLoc] == '/') {
  							// Skip command switch
  							while ((cmdLoc < lengthLine) &&
  								(!isspacechar(lineBuffer[cmdLoc]))) {
  								cmdLoc++;
  							}
  							// Skip next spaces
  							while ((cmdLoc < lengthLine) &&
  								(isspacechar(lineBuffer[cmdLoc]))) {
  								cmdLoc++;
  							}
  						}
  					}
  					// Colorize External Command / Program
  					if (!keywords2) {
  						styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
  					} else if (keywords2.InList(wordBuffer)) {
  						styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
  					} else {
  						styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
  					}
  					// No need to Reset Offset
  				// Check for Default Text
  				} else {
  					// Read up to %, Operator or Separator
  					while ((wbo < wbl) &&
  						(wordBuffer[wbo] != '%') &&
  						(wordBuffer[wbo] != '!') &&
  						(!IsBOperator(wordBuffer[wbo])) &&
  						(!IsBSeparator(wordBuffer[wbo]))) {
  						wbo++;
  					}
  					// Colorize Default Text
  					styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
  					// Reset Offset to re-process remainder of word
  					offset -= (wbl - wbo);
  				}
  			}
  		// Check for Argument  (%n), Environment Variable (%x...%) or Local Variable (%%a)
  		} else if (wordBuffer[0] == '%') {
  			// Colorize Default Text
  			styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
  			wbo++;
  			// Search to end of word for second % (can be a long path)
  			while ((wbo < wbl) &&
  				(wordBuffer[wbo] != '%') &&
  				(!IsBOperator(wordBuffer[wbo])) &&
  				(!IsBSeparator(wordBuffer[wbo]))) {
  				wbo++;
  			}
  			// Check for Argument (%n) or (%*)
  			if (((Is0To9(wordBuffer[1])) || (wordBuffer[1] == '*')) &&
  				(wordBuffer[wbo] != '%')) {
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					cmdLoc = offset - (wbl - 2);
  				}
  				// Colorize Argument
  				styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_IDENTIFIER);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 2);
  			// Check for Expanded Argument (%~...) / Variable (%%~...)
  			} else if (((wbl > 1) && (wordBuffer[1] == '~')) ||
  				((wbl > 2) && (wordBuffer[1] == '%') && (wordBuffer[2] == '~'))) {
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					cmdLoc = offset - (wbl - wbo);
  				}
  				// Colorize Expanded Argument / Variable
  				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - wbo);
  			// Check for Environment Variable (%x...%)
  			} else if ((wordBuffer[1] != '%') &&
  				(wordBuffer[wbo] == '%')) {
  				wbo++;
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					cmdLoc = offset - (wbl - wbo);
  				}
  				// Colorize Environment Variable
  				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - wbo);
  			// Check for Local Variable (%%a)
  			} else if (
  				(wbl > 2) &&
  				(wordBuffer[1] == '%') &&
  				(wordBuffer[2] != '%') &&
  				(!IsBOperator(wordBuffer[2])) &&
  				(!IsBSeparator(wordBuffer[2]))) {
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					cmdLoc = offset - (wbl - 3);
  				}
  				// Colorize Local Variable
  				styler.ColourTo(startLine + offset - 1 - (wbl - 3), SCE_BAT_IDENTIFIER);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 3);
  			}
  		// Check for Environment Variable (!x...!)
  		} else if (wordBuffer[0] == '!') {
  			// Colorize Default Text
  			styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
  			wbo++;
  			// Search to end of word for second ! (can be a long path)
  			while ((wbo < wbl) &&
  				(wordBuffer[wbo] != '!') &&
  				(!IsBOperator(wordBuffer[wbo])) &&
  				(!IsBSeparator(wordBuffer[wbo]))) {
  				wbo++;
  			}
  			if (wordBuffer[wbo] == '!') {
  				wbo++;
  				// Check for External Command / Program
  				if (cmdLoc == offset - wbl) {
  					cmdLoc = offset - (wbl - wbo);
  				}
  				// Colorize Environment Variable
  				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - wbo);
  			}
  		// Check for Operator
  		} else if (IsBOperator(wordBuffer[0])) {
  			// Colorize Default Text
  			styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
  			// Check for Comparison Operator
  			if ((wordBuffer[0] == '=') && (wordBuffer[1] == '=')) {
  				// Identify External Command / Program Location for IF
  				cmdLoc = offset;
  				// Skip next spaces
  				while ((cmdLoc < lengthLine) &&
  					(isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  				// Colorize Comparison Operator
  				styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_OPERATOR);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 2);
  			// Check for Pipe Operator
  			} else if (wordBuffer[0] == '|') {
  				// Reset External Command / Program Location
  				cmdLoc = offset - wbl + 1;
  				// Skip next spaces
  				while ((cmdLoc < lengthLine) &&
  					(isspacechar(lineBuffer[cmdLoc]))) {
  					cmdLoc++;
  				}
  				// Colorize Pipe Operator
  				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 1);
  			// Check for Other Operator
  			} else {
  				// Check for > Operator
  				if (wordBuffer[0] == '>') {
  					// Turn Keyword and External Command / Program checking back on
  					continueProcessing = true;
  				}
  				// Colorize Other Operator
  				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
  				// Reset Offset to re-process remainder of word
  				offset -= (wbl - 1);
  			}
  		// Check for Default Text
  		} else {
  			// Read up to %, Operator or Separator
  			while ((wbo < wbl) &&
  				(wordBuffer[wbo] != '%') &&
  				(wordBuffer[wbo] != '!') &&
  				(!IsBOperator(wordBuffer[wbo])) &&
  				(!IsBSeparator(wordBuffer[wbo]))) {
  				wbo++;
  			}
  			// Colorize Default Text
  			styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
  			// Reset Offset to re-process remainder of word
  			offset -= (wbl - wbo);
  		}
  		// Skip next spaces - nothing happens if Offset was Reset
  		while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
  			offset++;
  		}
  	}
  	// Colorize Default Text for remainder of line - currently not lexed
  	styler.ColourTo(endPos, SCE_BAT_DEFAULT);
  }
  
  static void ColouriseBatchDoc(
      unsigned int startPos,
      int length,
      int /*initStyle*/,
      WordList *keywordlists[],
      Accessor &styler) {
  
  	char lineBuffer[1024];
  
  	styler.StartAt(startPos);
  	styler.StartSegment(startPos);
  	unsigned int linePos = 0;
  	unsigned int startLine = startPos;
  	for (unsigned int i = startPos; i < startPos + length; 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';
  			ColouriseBatchLine(lineBuffer, linePos, startLine, i, keywordlists, styler);
  			linePos = 0;
  			startLine = i + 1;
  		}
  	}
  	if (linePos > 0) {	// Last line does not have ending characters
  		lineBuffer[linePos] = '\0';
  		ColouriseBatchLine(lineBuffer, linePos, startLine, startPos + length - 1,
  		                   keywordlists, styler);
  	}
  }
  
  #define DIFF_BUFFER_START_SIZE 16
  // Note that ColouriseDiffLine analyzes only the first DIFF_BUFFER_START_SIZE
  // characters of each line to classify the line.
  
  static void ColouriseDiffLine(char *lineBuffer, int endLine, Accessor &styler) {
  	// It is needed to remember the current state to recognize starting
  	// comment lines before the first "diff " or "--- ". If a real
  	// difference starts then each line starting with ' ' is a whitespace
  	// otherwise it is considered a comment (Only in..., Binary file...)
  	if (0 == strncmp(lineBuffer, "diff ", 5)) {
  		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
  	} else if (0 == strncmp(lineBuffer, "Index: ", 7)) {  // For subversion's diff
  		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
  	} else if (0 == strncmp(lineBuffer, "---", 3) && lineBuffer[3] != '-') {
  		// In a context diff, --- appears in both the header and the position markers
  		if (lineBuffer[3] == ' ' && atoi(lineBuffer + 4) && !strchr(lineBuffer, '/'))
  			styler.ColourTo(endLine, SCE_DIFF_POSITION);
  		else if (lineBuffer[3] == '\r' || lineBuffer[3] == '\n')
  			styler.ColourTo(endLine, SCE_DIFF_POSITION);
  		else
  			styler.ColourTo(endLine, SCE_DIFF_HEADER);
  	} else if (0 == strncmp(lineBuffer, "+++ ", 4)) {
  		// I don't know of any diff where "+++ " is a position marker, but for
  		// consistency, do the same as with "--- " and "*** ".
  		if (atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
  			styler.ColourTo(endLine, SCE_DIFF_POSITION);
  		else
  			styler.ColourTo(endLine, SCE_DIFF_HEADER);
  	} else if (0 == strncmp(lineBuffer, "====", 4)) {  // For p4's diff
  		styler.ColourTo(endLine, SCE_DIFF_HEADER);
  	} else if (0 == strncmp(lineBuffer, "***", 3)) {
  		// In a context diff, *** appears in both the header and the position markers.
  		// Also ******** is a chunk header, but here it's treated as part of the
  		// position marker since there is no separate style for a chunk header.
  		if (lineBuffer[3] == ' ' && atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
  			styler.ColourTo(endLine, SCE_DIFF_POSITION);
  		else if (lineBuffer[3] == '*')
  			styler.ColourTo(endLine, SCE_DIFF_POSITION);
  		else
  			styler.ColourTo(endLine, SCE_DIFF_HEADER);
  	} else if (0 == strncmp(lineBuffer, "? ", 2)) {    // For difflib
  		styler.ColourTo(endLine, SCE_DIFF_HEADER);
  	} else if (lineBuffer[0] == '@') {
  		styler.ColourTo(endLine, SCE_DIFF_POSITION);
  	} else if (lineBuffer[0] >= '0' && lineBuffer[0] <= '9') {
  		styler.ColourTo(endLine, SCE_DIFF_POSITION);
  	} else if (lineBuffer[0] == '-' || lineBuffer[0] == '<') {
  		styler.ColourTo(endLine, SCE_DIFF_DELETED);
  	} else if (lineBuffer[0] == '+' || lineBuffer[0] == '>') {
  		styler.ColourTo(endLine, SCE_DIFF_ADDED);
  	} else if (lineBuffer[0] == '!') {
  		styler.ColourTo(endLine, SCE_DIFF_CHANGED);
  	} else if (lineBuffer[0] != ' ') {
  		styler.ColourTo(endLine, SCE_DIFF_COMMENT);
  	} else {
  		styler.ColourTo(endLine, SCE_DIFF_DEFAULT);
  	}
  }
  
  static void ColouriseDiffDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	char lineBuffer[DIFF_BUFFER_START_SIZE] = "";
  	styler.StartAt(startPos);
  	styler.StartSegment(startPos);
  	unsigned int linePos = 0;
  	for (unsigned int i = startPos; i < startPos + length; i++) {
  		if (AtEOL(styler, i)) {
  			if (linePos < DIFF_BUFFER_START_SIZE) {
  				lineBuffer[linePos] = 0;
  			}
  			ColouriseDiffLine(lineBuffer, i, styler);
  			linePos = 0;
  		} else if (linePos < DIFF_BUFFER_START_SIZE - 1) {
  			lineBuffer[linePos++] = styler[i];
  		} else if (linePos == DIFF_BUFFER_START_SIZE - 1) {
  			lineBuffer[linePos++] = 0;
  		}
  	}
  	if (linePos > 0) {	// Last line does not have ending characters
  		if (linePos < DIFF_BUFFER_START_SIZE) {
  			lineBuffer[linePos] = 0;
  		}
  		ColouriseDiffLine(lineBuffer, startPos + length - 1, styler);
  	}
  }
  
  static void FoldDiffDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	int curLine = styler.GetLine(startPos);
  	int curLineStart = styler.LineStart(curLine);
  	int prevLevel = curLine > 0 ? styler.LevelAt(curLine - 1) : SC_FOLDLEVELBASE;
  	int nextLevel;
  
  	do {
  		int lineType = styler.StyleAt(curLineStart);
  		if (lineType == SCE_DIFF_COMMAND)
  			nextLevel = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
  		else if (lineType == SCE_DIFF_HEADER)
  			nextLevel = (SC_FOLDLEVELBASE + 1) | SC_FOLDLEVELHEADERFLAG;
  		else if (lineType == SCE_DIFF_POSITION && styler[curLineStart] != '-')
  			nextLevel = (SC_FOLDLEVELBASE + 2) | SC_FOLDLEVELHEADERFLAG;
  		else if (prevLevel & SC_FOLDLEVELHEADERFLAG)
  			nextLevel = (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1;
  		else
  			nextLevel = prevLevel;
  
  		if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && (nextLevel == prevLevel))
  			styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG);
  
  		styler.SetLevel(curLine, nextLevel);
  		prevLevel = nextLevel;
  
  		curLineStart = styler.LineStart(++curLine);
  	} while (static_cast<int>(startPos) + length > curLineStart);
  }
  
  static inline bool isassignchar(unsigned char ch) {
  	return (ch == '=') || (ch == ':');
  }
  
  static void ColourisePropsLine(
      char *lineBuffer,
      unsigned int lengthLine,
      unsigned int startLine,
      unsigned int endPos,
      Accessor &styler,
      bool allowInitialSpaces) {
  
  	unsigned int i = 0;
  	if (allowInitialSpaces) {
  		while ((i < lengthLine) && isspacechar(lineBuffer[i]))	// Skip initial spaces
  			i++;
  	} else {
  		if (isspacechar(lineBuffer[i])) // don't allow initial spaces
  			i = lengthLine;
  	}
  
  	if (i < lengthLine) {
  		if (lineBuffer[i] == '#' || lineBuffer[i] == '!' || lineBuffer[i] == ';') {
  			styler.ColourTo(endPos, SCE_PROPS_COMMENT);
  		} else if (lineBuffer[i] == '[') {
  			styler.ColourTo(endPos, SCE_PROPS_SECTION);
  		} else if (lineBuffer[i] == '@') {
  			styler.ColourTo(startLine + i, SCE_PROPS_DEFVAL);
  			if (isassignchar(lineBuffer[i++]))
  				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
  			styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
  		} else {
  			// Search for the '=' character
  			while ((i < lengthLine) && !isassignchar(lineBuffer[i]))
  				i++;
  			if ((i < lengthLine) && isassignchar(lineBuffer[i])) {
  				styler.ColourTo(startLine + i - 1, SCE_PROPS_KEY);
  				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
  				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
  			} else {
  				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
  			}
  		}
  	} else {
  		styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
  	}
  }
  
  static void ColourisePropsDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	char lineBuffer[1024];
  	styler.StartAt(startPos);
  	styler.StartSegment(startPos);
  	unsigned int linePos = 0;
  	unsigned int startLine = startPos;
  
  	// property lexer.props.allow.initial.spaces
  	//	For properties files, set to 0 to style all lines that start with whitespace in the default style.
  	//	This is not suitable for SciTE .properties files which use indentation for flow control but
  	//	can be used for RFC2822 text where indentation is used for continuation lines.
  	bool allowInitialSpaces = styler.GetPropertyInt("lexer.props.allow.initial.spaces", 1) != 0;
  
  	for (unsigned int i = startPos; i < startPos + length; 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';
  			ColourisePropsLine(lineBuffer, linePos, startLine, i, styler, allowInitialSpaces);
  			linePos = 0;
  			startLine = i + 1;
  		}
  	}
  	if (linePos > 0) {	// Last line does not have ending characters
  		ColourisePropsLine(lineBuffer, linePos, startLine, startPos + length - 1, styler, allowInitialSpaces);
  	}
  }
  
  // adaption by ksc, using the "} else {" trick of 1.53
  // 030721
  static void FoldPropsDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
  
  	unsigned int endPos = startPos + length;
  	int visibleChars = 0;
  	int lineCurrent = styler.GetLine(startPos);
  
  	char chNext = styler[startPos];
  	int styleNext = styler.StyleAt(startPos);
  	bool headerPoint = false;
  	int lev;
  
  	for (unsigned int i = startPos; i < endPos; i++) {
  		char ch = chNext;
  		chNext = styler[i+1];
  
  		int style = styleNext;
  		styleNext = styler.StyleAt(i + 1);
  		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
  
  		if (style == SCE_PROPS_SECTION) {
  			headerPoint = true;
  		}
  
  		if (atEOL) {
  			lev = SC_FOLDLEVELBASE;
  
  			if (lineCurrent > 0) {
  				int levelPrevious = styler.LevelAt(lineCurrent - 1);
  
  				if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
  					lev = SC_FOLDLEVELBASE + 1;
  				} else {
  					lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
  				}
  			}
  
  			if (headerPoint) {
  				lev = SC_FOLDLEVELBASE;
  			}
  			if (visibleChars == 0 && foldCompact)
  				lev |= SC_FOLDLEVELWHITEFLAG;
  
  			if (headerPoint) {
  				lev |= SC_FOLDLEVELHEADERFLAG;
  			}
  			if (lev != styler.LevelAt(lineCurrent)) {
  				styler.SetLevel(lineCurrent, lev);
  			}
  
  			lineCurrent++;
  			visibleChars = 0;
  			headerPoint = false;
  		}
  		if (!isspacechar(ch))
  			visibleChars++;
  	}
  
  	if (lineCurrent > 0) {
  		int levelPrevious = styler.LevelAt(lineCurrent - 1);
  		if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
  			lev = SC_FOLDLEVELBASE + 1;
  		} else {
  			lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
  		}
  	} else {
  		lev = SC_FOLDLEVELBASE;
  	}
  	int flagsNext = styler.LevelAt(lineCurrent);
  	styler.SetLevel(lineCurrent, lev | (flagsNext & ~SC_FOLDLEVELNUMBERMASK));
  }
  
  static void ColouriseMakeLine(
      char *lineBuffer,
      unsigned int lengthLine,
      unsigned int startLine,
      unsigned int endPos,
      Accessor &styler) {
  
  	unsigned int i = 0;
  	int lastNonSpace = -1;
  	unsigned int state = SCE_MAKE_DEFAULT;
  	bool bSpecial = false;
  
  	// check for a tab character in column 0 indicating a command
  	bool bCommand = false;
  	if ((lengthLine > 0) && (lineBuffer[0] == '\t'))
  		bCommand = true;
  
  	// Skip initial spaces
  	while ((i < lengthLine) && isspacechar(lineBuffer[i])) {
  		i++;
  	}
  	if (i < lengthLine) {
  		if (lineBuffer[i] == '#') {	// Comment
  			styler.ColourTo(endPos, SCE_MAKE_COMMENT);
  			return;
  		}
  		if (lineBuffer[i] == '!') {	// Special directive
  			styler.ColourTo(endPos, SCE_MAKE_PREPROCESSOR);
  			return;
  		}
  	}
  	int varCount = 0;
  	while (i < lengthLine) {
  		if (((i + 1) < lengthLine) && (lineBuffer[i] == '$' && lineBuffer[i + 1] == '(')) {
  			styler.ColourTo(startLine + i - 1, state);
  			state = SCE_MAKE_IDENTIFIER;
  			varCount++;
  		} else if (state == SCE_MAKE_IDENTIFIER && lineBuffer[i] == ')') {
  			if (--varCount == 0) {
  				styler.ColourTo(startLine + i, state);
  				state = SCE_MAKE_DEFAULT;
  			}
  		}
  
  		// skip identifier and target styling if this is a command line
  		if (!bSpecial && !bCommand) {
  			if (lineBuffer[i] == ':') {
  				if (((i + 1) < lengthLine) && (lineBuffer[i + 1] == '=')) {
  					// it's a ':=', so style as an identifier
  					if (lastNonSpace >= 0)
  						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
  					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
  					styler.ColourTo(startLine + i + 1, SCE_MAKE_OPERATOR);
  				} else {
  					// We should check that no colouring was made since the beginning of the line,
  					// to avoid colouring stuff like /OUT:file
  					if (lastNonSpace >= 0)
  						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_TARGET);
  					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
  					styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
  				}
  				bSpecial = true;	// Only react to the first ':' of the line
  				state = SCE_MAKE_DEFAULT;
  			} else if (lineBuffer[i] == '=') {
  				if (lastNonSpace >= 0)
  					styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
  				styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
  				styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
  				bSpecial = true;	// Only react to the first '=' of the line
  				state = SCE_MAKE_DEFAULT;
  			}
  		}
  		if (!isspacechar(lineBuffer[i])) {
  			lastNonSpace = i;
  		}
  		i++;
  	}
  	if (state == SCE_MAKE_IDENTIFIER) {
  		styler.ColourTo(endPos, SCE_MAKE_IDEOL);	// Error, variable reference not ended
  	} else {
  		styler.ColourTo(endPos, SCE_MAKE_DEFAULT);
  	}
  }
  
  static void ColouriseMakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	char lineBuffer[1024];
  	styler.StartAt(startPos);
  	styler.StartSegment(startPos);
  	unsigned int linePos = 0;
  	unsigned int startLine = startPos;
  	for (unsigned int i = startPos; i < startPos + length; 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';
  			ColouriseMakeLine(lineBuffer, linePos, startLine, i, styler);
  			linePos = 0;
  			startLine = i + 1;
  		}
  	}
  	if (linePos > 0) {	// Last line does not have ending characters
  		ColouriseMakeLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
  	}
  }
  
  static int RecogniseErrorListLine(const char *lineBuffer, unsigned int lengthLine, int &startValue) {
  	if (lineBuffer[0] == '>') {
  		// Command or return status
  		return SCE_ERR_CMD;
  	} else if (lineBuffer[0] == '<') {
  		// Diff removal.
  		return SCE_ERR_DIFF_DELETION;
  	} else if (lineBuffer[0] == '!') {
  		return SCE_ERR_DIFF_CHANGED;
  	} else if (lineBuffer[0] == '+') {
  		if (strstart(lineBuffer, "+++ ")) {
  			return SCE_ERR_DIFF_MESSAGE;
  		} else {
  			return SCE_ERR_DIFF_ADDITION;
  		}
  	} else if (lineBuffer[0] == '-') {
  		if (strstart(lineBuffer, "--- ")) {
  			return SCE_ERR_DIFF_MESSAGE;
  		} else {
  			return SCE_ERR_DIFF_DELETION;
  		}
  	} else if (strstart(lineBuffer, "cf90-")) {
  		// Absoft Pro Fortran 90/95 v8.2 error and/or warning message
  		return SCE_ERR_ABSF;
  	} else if (strstart(lineBuffer, "fortcom:")) {
  		// Intel Fortran Compiler v8.0 error/warning message
  		return SCE_ERR_IFORT;
  	} else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
  		return SCE_ERR_PYTHON;
  	} else if (strstr(lineBuffer, " in ") && strstr(lineBuffer, " on line ")) {
  		return SCE_ERR_PHP;
  	} else if ((strstart(lineBuffer, "Error ") ||
  	            strstart(lineBuffer, "Warning ")) &&
  	           strstr(lineBuffer, " at (") &&
  	           strstr(lineBuffer, ") : ") &&
  	           (strstr(lineBuffer, " at (") < strstr(lineBuffer, ") : "))) {
  		// Intel Fortran Compiler error/warning message
  		return SCE_ERR_IFC;
  	} else if (strstart(lineBuffer, "Error ")) {
  		// Borland error message
  		return SCE_ERR_BORLAND;
  	} else if (strstart(lineBuffer, "Warning ")) {
  		// Borland warning message
  		return SCE_ERR_BORLAND;
  	} else if (strstr(lineBuffer, "at line ") &&
  	        (strstr(lineBuffer, "at line ") < (lineBuffer + lengthLine)) &&
  	           strstr(lineBuffer, "file ") &&
  	           (strstr(lineBuffer, "file ") < (lineBuffer + lengthLine))) {
  		// Lua 4 error message
  		return SCE_ERR_LUA;
  	} else if (strstr(lineBuffer, " at ") &&
  	        (strstr(lineBuffer, " at ") < (lineBuffer + lengthLine)) &&
  	           strstr(lineBuffer, " line ") &&
  	           (strstr(lineBuffer, " line ") < (lineBuffer + lengthLine)) &&
  	        (strstr(lineBuffer, " at ") < (strstr(lineBuffer, " line ")))) {
  		// perl error message
  		return SCE_ERR_PERL;
  	} else if ((memcmp(lineBuffer, "   at ", 6) == 0) &&
  	           strstr(lineBuffer, ":line ")) {
  		// A .NET traceback
  		return SCE_ERR_NET;
  	} else if (strstart(lineBuffer, "Line ") &&
  	           strstr(lineBuffer, ", file ")) {
  		// Essential Lahey Fortran error message
  		return SCE_ERR_ELF;
  	} else if (strstart(lineBuffer, "line ") &&
  	           strstr(lineBuffer, " column ")) {
  		// HTML tidy style: line 42 column 1
  		return SCE_ERR_TIDY;
  	} else if (strstart(lineBuffer, "\tat ") &&
  	           strstr(lineBuffer, "(") &&
  	           strstr(lineBuffer, ".java:")) {
  		// Java stack back trace
  		return SCE_ERR_JAVA_STACK;
  	} else {
  		// Look for one of the following formats:
  		// GCC: <filename>:<line>:<message>
  		// Microsoft: <filename>(<line>) :<message>
  		// Common: <filename>(<line>): warning|error|note|remark|catastrophic|fatal
  		// Common: <filename>(<line>) warning|error|note|remark|catastrophic|fatal
  		// Microsoft: <filename>(<line>,<column>)<message>
  		// CTags: \t<message>
  		// Lua 5 traceback: \t<filename>:<line>:<message>
  		// Lua 5.1: <exe>: <filename>:<line>:<message>
  		bool initialTab = (lineBuffer[0] == '\t');
  		bool initialColonPart = false;
  		enum { stInitial,
  			stGccStart, stGccDigit, stGccColumn, stGcc,
  			stMsStart, stMsDigit, stMsBracket, stMsVc, stMsDigitComma, stMsDotNet,
  			stCtagsStart, stCtagsStartString, stCtagsStringDollar, stCtags,
  			stUnrecognized
  		} state = stInitial;
  		for (unsigned int i = 0; i < lengthLine; i++) {
  			char ch = lineBuffer[i];
  			char chNext = ' ';
  			if ((i + 1) < lengthLine)
  				chNext = lineBuffer[i + 1];
  			if (state == stInitial) {
  				if (ch == ':') {
  					// May be GCC, or might be Lua 5 (Lua traceback same but with tab prefix)
  					if ((chNext != '\\') && (chNext != '/') && (chNext != ' ')) {
  						// This check is not completely accurate as may be on
  						// GTK+ with a file name that includes ':'.
  						state = stGccStart;
  					} else if (chNext == ' ') { // indicates a Lua 5.1 error message
  						initialColonPart = true;
  					}
  				} else if ((ch == '(') && Is1To9(chNext) && (!initialTab)) {
  					// May be Microsoft
  					// Check against '0' often removes phone numbers
  					state = stMsStart;
  				} else if ((ch == '\t') && (!initialTab)) {
  					// May be CTags
  					state = stCtagsStart;
  				}
  			} else if (state == stGccStart) {	// <filename>:
  				state = Is1To9(ch) ? stGccDigit : stUnrecognized;
  			} else if (state == stGccDigit) {	// <filename>:<line>
  				if (ch == ':') {
  					state = stGccColumn;	// :9.*: is GCC
  					startValue = i + 1;
  				} else if (!Is0To9(ch)) {
  					state = stUnrecognized;
  				}
  			} else if (state == stGccColumn) {	// <filename>:<line>:<column>
  				if (!Is0To9(ch)) {
  					state = stGcc;
  					if (ch == ':')
  						startValue = i + 1;
  					break;
  				}
  			} else if (state == stMsStart) {	// <filename>(
  				state = Is0To9(ch) ? stMsDigit : stUnrecognized;
  			} else if (state == stMsDigit) {	// <filename>(<line>
  				if (ch == ',') {
  					state = stMsDigitComma;
  				} else if (ch == ')') {
  					state = stMsBracket;
  				} else if ((ch != ' ') && !Is0To9(ch)) {
  					state = stUnrecognized;
  				}
  			} else if (state == stMsBracket) {	// <filename>(<line>)
  				if ((ch == ' ') && (chNext == ':')) {
  					state = stMsVc;
  				} else if ((ch == ':' && chNext == ' ') || (ch == ' ')) {
  					// Possibly Delphi.. don't test against chNext as it's one of the strings below.
  					char word[512];
  					unsigned int j, chPos;
  					unsigned numstep;
  					chPos = 0;
  					if (ch == ' ')
  						numstep = 1; // ch was ' ', handle as if it's a delphi errorline, only add 1 to i.
  					else
  						numstep = 2; // otherwise add 2.
  					for (j = i + numstep; j < lengthLine && IsAlphabetic(lineBuffer[j]) && chPos < sizeof(word) - 1; j++)
  						word[chPos++] = lineBuffer[j];
  					word[chPos] = 0;
  					if (!CompareCaseInsensitive(word, "error") || !CompareCaseInsensitive(word, "warning") ||
  						!CompareCaseInsensitive(word, "fatal") || !CompareCaseInsensitive(word, "catastrophic") ||
  						!CompareCaseInsensitive(word, "note") || !CompareCaseInsensitive(word, "remark")) {
  						state = stMsVc;
  					} else
  						state = stUnrecognized;
  				} else {
  					state = stUnrecognized;
  				}
  			} else if (state == stMsDigitComma) {	// <filename>(<line>,
  				if (ch == ')') {
  					state = stMsDotNet;
  					break;
  				} else if ((ch != ' ') && !Is0To9(ch)) {
  					state = stUnrecognized;
  				}
  			} else if (state == stCtagsStart) {
  				if ((lineBuffer[i - 1] == '\t') &&
  				        ((ch == '/' && lineBuffer[i + 1] == '^') || Is0To9(ch))) {
  					state = stCtags;
  					break;
  				} else if ((ch == '/') && (lineBuffer[i + 1] == '^')) {
  					state = stCtagsStartString;
  				}
  			} else if ((state == stCtagsStartString) && ((lineBuffer[i] == '$') && (lineBuffer[i + 1] == '/'))) {
  				state = stCtagsStringDollar;
  				break;
  			}
  		}
  		if (state == stGcc) {
  			return initialColonPart ? SCE_ERR_LUA : SCE_ERR_GCC;
  		} else if ((state == stMsVc) || (state == stMsDotNet)) {
  			return SCE_ERR_MS;
  		} else if ((state == stCtagsStringDollar) || (state == stCtags)) {
  			return SCE_ERR_CTAG;
  		} else {
  			return SCE_ERR_DEFAULT;
  		}
  	}
  }
  
  static void ColouriseErrorListLine(
      char *lineBuffer,
      unsigned int lengthLine,
      unsigned int endPos,
      Accessor &styler,
  	bool valueSeparate) {
  	int startValue = -1;
  	int style = RecogniseErrorListLine(lineBuffer, lengthLine, startValue);
  	if (valueSeparate && (startValue >= 0)) {
  		styler.ColourTo(endPos - (lengthLine - startValue), style);
  		styler.ColourTo(endPos, SCE_ERR_VALUE);
  	} else {
  		styler.ColourTo(endPos, style);
  	}
  }
  
  static void ColouriseErrorListDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
  	char lineBuffer[10000];
  	styler.StartAt(startPos);
  	styler.StartSegment(startPos);
  	unsigned int linePos = 0;
  
  	// property lexer.errorlist.value.separate
  	//	For lines in the output pane that are matches from Find in Files or GCC-style
  	//	diagnostics, style the path and line number separately from the rest of the
  	//	line with style 21 used for the rest of the line.
  	//	This allows matched text to be more easily distinguished from its location.
  	bool valueSeparate = styler.GetPropertyInt("lexer.errorlist.value.separate", 0) != 0;
  	for (unsigned int i = startPos; i < startPos + length; 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';
  			ColouriseErrorListLine(lineBuffer, linePos, i, styler, valueSeparate);
  			linePos = 0;
  		}
  	}
  	if (linePos > 0) {	// Last line does not have ending characters
  		ColouriseErrorListLine(lineBuffer, linePos, startPos + length - 1, styler, valueSeparate);
  	}
  }
  
  static bool latexIsSpecial(int ch) {
  	return (ch == '#') || (ch == '$') || (ch == '%') || (ch == '&') || (ch == '_') ||
  	       (ch == '{') || (ch == '}') || (ch == ' ');
  }
  
  static bool latexIsBlank(int ch) {
  	return (ch == ' ') || (ch == '\t');
  }
  
  static bool latexIsBlankAndNL(int ch) {
  	return (ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n');
  }
  
  static bool latexIsLetter(int ch) {
  	return isascii(ch) && isalpha(ch);
  }
  
  static bool latexIsTagValid(int &i, int l, Accessor &styler) {
  	while (i < l) {
  		if (styler.SafeGetCharAt(i) == '{') {
  			while (i < l) {
  				i++;
  				if (styler.SafeGetCharAt(i) == '}') {
  					return true;
  				}	else if (!latexIsLetter(styler.SafeGetCharAt(i)) &&
                     styler.SafeGetCharAt(i)!='*') {
  					return false;
  				}
  			}
  		} else if (!latexIsBlank(styler.SafeGetCharAt(i))) {
  			return false;
  		}
  		i++;
  	}
  	return false;
  }
  
  static bool latexNextNotBlankIs(int i, int l, Accessor &styler, char needle) {
    char ch;
  	while (i < l) {
      ch = styler.SafeGetCharAt(i);
  		if (!latexIsBlankAndNL(ch) && ch != '*') {
        if (ch == needle)
          return true;
        else
          return false;
  		}
  		i++;
  	}
  	return false;
  }
  
  static bool latexLastWordIs(int start, Accessor &styler, const char *needle) {
    unsigned int i = 0;
  	unsigned int l = static_cast<unsigned int>(strlen(needle));
  	int ini = start-l+1;
  	char s[32];
  
  	while (i < l && i < 32) {
  		s[i] = styler.SafeGetCharAt(ini + i);
      i++;
  	}
  	s[i] = '\0';
  
  	return (strcmp(s, needle) == 0);
  }
  
  static void ColouriseLatexDoc(unsigned int startPos, int length, int initStyle,
                                WordList *[], Accessor &styler) {
  
  	styler.StartAt(startPos);
  
  	int state = initStyle;
  	char chNext = styler.SafeGetCharAt(startPos);
  	styler.StartSegment(startPos);
  	int lengthDoc = startPos + length;
    char chVerbatimDelim = '\0';
  
  	for (int i = startPos; i < lengthDoc; i++) {
  		char ch = chNext;
  		chNext = styler.SafeGetCharAt(i + 1);
  
  		if (styler.IsLeadByte(ch)) {
  			i++;
  			chNext = styler.SafeGetCharAt(i + 1);
  			continue;
  		}
  
  		switch (state) {
  		case SCE_L_DEFAULT :
  			switch (ch) {
  			case '\\' :
  				styler.ColourTo(i - 1, state);
  				if (latexIsSpecial(chNext)) {
  					state = SCE_L_SPECIAL;
  				} else {
  					if (latexIsLetter(chNext)) {
  						state = SCE_L_COMMAND;
  					}	else {
  						if (chNext == '(' || chNext == '[') {
  							styler.ColourTo(i-1, state);
  							styler.ColourTo(i+1, SCE_L_SHORTCMD);
  							state = SCE_L_MATH;
  							if (chNext == '[')
  								state = SCE_L_MATH2;
  							i++;
  							chNext = styler.SafeGetCharAt(i+1);
  						} else {
  							state = SCE_L_SHORTCMD;
  						}
  					}
  				}
  				break;
  			case '$' :
  				styler.ColourTo(i - 1, state);
  				state = SCE_L_MATH;
  				if (chNext == '$') {
  					state = SCE_L_MATH2;
  					i++;
  					chNext = styler.SafeGetCharAt(i + 1);
  				}
  				break;
  			case '%' :
  				styler.ColourTo(i - 1, state);
  				state = SCE_L_COMMENT;
  				break;
  			}
  			break;
  		case SCE_L_ERROR:
  			styler.ColourTo(i-1, state);
  			state = SCE_L_DEFAULT;
  			break;
  		case SCE_L_SPECIAL:
  		case SCE_L_SHORTCMD:
  			styler.ColourTo(i, state);
  			state = SCE_L_DEFAULT;
  			break;
  		case SCE_L_COMMAND :
  			if (!latexIsLetter(chNext)) {
  				styler.ColourTo(i, state);
  				state = SCE_L_DEFAULT;
          if (latexNextNotBlankIs(i+1, lengthDoc, styler, '[' )) {
            state = SCE_L_CMDOPT;
  				} else if (latexLastWordIs(i, styler, "\\begin")) {
  					state = SCE_L_TAG;
  				} else if (latexLastWordIs(i, styler, "\\end")) {
  					state = SCE_L_TAG2;
  				} else if (latexLastWordIs(i, styler, "\\verb") &&
                     chNext != '*' && chNext != ' ') {
            chVerbatimDelim = chNext;
  					state = SCE_L_VERBATIM;
  				}
  			}
  			break;
  		case SCE_L_CMDOPT :
        if (ch == ']') {
          styler.ColourTo(i, state);
          state = SCE_L_DEFAULT;
        }
  			break;
  		case SCE_L_TAG :
  			if (latexIsTagValid(i, lengthDoc, styler)) {
  				styler.ColourTo(i, state);
  				state = SCE_L_DEFAULT;
  				if (latexLastWordIs(i, styler, "{verbatim}")) {
  					state = SCE_L_VERBATIM;
  				} else if (latexLastWordIs(i, styler, "{comment}")) {
  					state = SCE_L_COMMENT2;
  				} else if (latexLastWordIs(i, styler, "{math}")) {
  					state = SCE_L_MATH;
  				} else if (latexLastWordIs(i, styler, "{displaymath}")) {
  					state = SCE_L_MATH2;
  				} else if (latexLastWordIs(i, styler, "{equation}")) {
  					state = SCE_L_MATH2;
  				}
  			} else {
  				state = SCE_L_ERROR;
  				styler.ColourTo(i, state);
  				state = SCE_L_DEFAULT;
  			}
  			chNext = styler.SafeGetCharAt(i+1);
  			break;
  		case SCE_L_TAG2 :
  			if (latexIsTagValid(i, lengthDoc, styler)) {
  				styler.ColourTo(i, state);
  				state = SCE_L_DEFAULT;
  			} else {
  				state = SCE_L_ERROR;
  			}
  			chNext = styler.SafeGetCharAt(i+1);
  			break;
  		case SCE_L_MATH :
  			if (ch == '$') {
  				styler.ColourTo(i, state);
  				state = SCE_L_DEFAULT;
  			} else if (ch == '\\' && chNext == ')') {
  				styler.ColourTo(i-1, state);
  				styler.ColourTo(i+1, SCE_L_SHORTCMD);
  				i++;
  				chNext = styler.SafeGetCharAt(i+1);
  				state = SCE_L_DEFAULT;
  			} else if (ch == '\\') {
  				int match = i + 3;
  				if (latexLastWordIs(match, styler, "\\end")) {
  					match++;
  					if (latexIsTagValid(match, lengthDoc, styler)) {
  						if (latexLastWordIs(match, styler, "{math}")) {
  							styler.ColourTo(i-1, state);
  							state = SCE_L_COMMAND;
  						}
  					}
  				}
  			}
  
  			break;
  		case SCE_L_MATH2 :
  			if (ch == '$') {
          if (chNext == '$') {
            i++;
            chNext = styler.SafeGetCharAt(i + 1);
            styler.ColourTo(i, state);
            state = SCE_L_DEFAULT;
          } else {
            styler.ColourTo(i, SCE_L_ERROR);
            state = SCE_L_DEFAULT;
          }
  			} else if (ch == '\\' && chNext == ']') {
  				styler.ColourTo(i-1, state);
  				styler.ColourTo(i+1, SCE_L_SHORTCMD);
  				i++;
  				chNext = styler.SafeGetCharAt(i+1);
  				state = SCE_L_DEFAULT;
  			} else if (ch == '\\') {
  				int match = i + 3;
  				if (latexLastWordIs(match, styler, "\\end")) {
  					match++;
  					if (latexIsTagValid(match, lengthDoc, styler)) {
  						if (latexLastWordIs(match, styler, "{displaymath}")) {
  							styler.ColourTo(i-1, state);
  							state = SCE_L_COMMAND;
  						} else if (latexLastWordIs(match, styler, "{equation}")) {
  							styler.ColourTo(i-1, state);
  							state = SCE_L_COMMAND;
  						}
  					}
  				}
  			}
  			break;
  		case SCE_L_COMMENT :
  			if (ch == '\r' || ch == '\n') {
  				styler.ColourTo(i - 1, state);
  				state = SCE_L_DEFAULT;
  			}
  			break;
  		case SCE_L_COMMENT2 :
  			if (ch == '\\') {
  				int match = i + 3;
  				if (latexLastWordIs(match, styler, "\\end")) {
  					match++;
  					if (latexIsTagValid(match, lengthDoc, styler)) {
  						if (latexLastWordIs(match, styler, "{comment}")) {
  							styler.ColourTo(i-1, state);
  							state = SCE_L_COMMAND;
  						}
  					}
  				}
  			}
  			break;
  		case SCE_L_VERBATIM :
  			if (ch == '\\') {
  				int match = i + 3;
  				if (latexLastWordIs(match, styler, "\\end")) {
  					match++;
  					if (latexIsTagValid(match, lengthDoc, styler)) {
  						if (latexLastWordIs(match, styler, "{verbatim}")) {
  							styler.ColourTo(i-1, state);
  							state = SCE_L_COMMAND;
  						}
  					}
  				}
  			} else if (chNext == chVerbatimDelim) {
          styler.ColourTo(i+1, state);
  				state = SCE_L_DEFAULT;
          chVerbatimDelim = '\0';
        } else if (chVerbatimDelim != '\0' && (ch == '\n' || ch == '\r')) {
          styler.ColourTo(i, SCE_L_ERROR);
  				state = SCE_L_DEFAULT;
          chVerbatimDelim = '\0';
        }
  			break;
  		}
  	}
  	styler.ColourTo(lengthDoc-1, state);
  }
  
  static const char *const batchWordListDesc[] = {
  	"Internal Commands",
  	"External Commands",
  	0
  };
  
  static const char *const emptyWordListDesc[] = {
  	0
  };
  
  static void ColouriseNullDoc(unsigned int startPos, int length, int, WordList *[],
                              Accessor &styler) {
  	// Null language means all style bytes are 0 so just mark the end - no need to fill in.
  	if (length > 0) {
  		styler.StartAt(startPos + length - 1);
  		styler.StartSegment(startPos + length - 1);
  		styler.ColourTo(startPos + length - 1, 0);
  	}
  }
  
  LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc, "batch", 0, batchWordListDesc);
  LexerModule lmDiff(SCLEX_DIFF, ColouriseDiffDoc, "diff", FoldDiffDoc, emptyWordListDesc);
  LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc, "props", FoldPropsDoc, emptyWordListDesc);
  LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc, "makefile", 0, emptyWordListDesc);
  LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc, "errorlist", 0, emptyWordListDesc);
  LexerModule lmLatex(SCLEX_LATEX, ColouriseLatexDoc, "latex", 0, emptyWordListDesc);
  LexerModule lmNull(SCLEX_NULL, ColouriseNullDoc, "null");
  