]> git.saurik.com Git - wxWidgets.git/blobdiff - src/stc/scintilla/src/LexOthers.cxx
docopydocs is not needed for this script.
[wxWidgets.git] / src / stc / scintilla / src / LexOthers.cxx
index dd8603368790b11695121b13ea8a6b6f23953880..4f4c1e3258fcabf2c106f7813c12bb48d2c11511 100644 (file)
@@ -1,13 +1,16 @@
-// SciTE - Scintilla based Text Editor
-// LexOthers.cxx - lexers for properties files, batch files, make files and error lists
-// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// 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 <ctype.h> 
-#include <stdio.h> 
-#include <stdarg.h> 
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-static void ColouriseBatchLine(char *lineBuffer, int endLine, Accessor &styler) {
-       if (0 == strncmp(lineBuffer, "REM", 3)) {
-               styler.ColourTo(endLine, 1);
-       } else if (0 == strncmp(lineBuffer, "rem", 3)) {
-               styler.ColourTo(endLine, 1);
-       } else if (0 == strncmp(lineBuffer, "SET", 3)) {
-               styler.ColourTo(endLine, 2);
-       } else if (0 == strncmp(lineBuffer, "set", 3)) {
-               styler.ColourTo(endLine, 2);
-       } else if (lineBuffer[0] == ':') {
-               styler.ColourTo(endLine, 3);
-       } else {
-               styler.ColourTo(endLine, 0);
+static bool Is0To9(char ch) {
+       return (ch >= '0') && (ch <= '9');
+}
+
+static bool Is1To9(char ch) {
+       return (ch >= '1') && (ch <= '9');
+}
+
+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 == '\'') || (ch == '/') || (ch == ')');
+}
+
+static void ColouriseBatchLine(
+    char *lineBuffer,
+    unsigned int lengthLine,
+    unsigned int startLine,
+    unsigned int endPos,
+    WordList &keywords,
+    Accessor &styler) {
+
+       unsigned int offset = 0;        // Line Buffer Offset
+       unsigned int enVarEnd;          // Environment Variable End point
+       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
+       bool forFound = false;          // No Local Variable without FOR statement
+       // 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 ((isalpha(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++;
+       // Check for Argument (%n) or Environment Variable (%x...%)
+       } else if (lineBuffer[offset] == '%') {
+               enVarEnd = offset + 1;
+               // Search end of word for second % (can be a long path)
+               while ((enVarEnd < lengthLine) &&
+                       (!isspacechar(lineBuffer[enVarEnd])) &&
+                       (lineBuffer[enVarEnd] != '%') &&
+                       (!IsBOperator(lineBuffer[enVarEnd])) &&
+                       (!IsBSeparator(lineBuffer[enVarEnd]))) {
+                       enVarEnd++;
+               }
+               // Check for Argument (%n)
+               if ((Is0To9(lineBuffer[offset + 1])) &&
+                       (lineBuffer[enVarEnd] != '%')) {
+                       // Colorize Argument
+                       styler.ColourTo(startLine + offset + 1, SCE_BAT_IDENTIFIER);
+                       offset += 2;
+                       // Check for External Command / Program
+                       if (!isspacechar(lineBuffer[offset])) {
+                               cmdLoc = offset;
+                       }
+               // Check for Environment Variable (%x...%)
+               } else if ((lineBuffer[offset + 1] != '%') &&
+                       (lineBuffer[enVarEnd] == '%')) {
+                       offset = enVarEnd;
+                       // Colorize Environment Variable
+                       styler.ColourTo(startLine + offset, SCE_BAT_IDENTIFIER);
+                       offset++;
+                       // Check for External Command / Program
+                       if (!isspacechar(lineBuffer[offset])) {
+                               cmdLoc = 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
+                               styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+                               // 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)) {
+                       // Local Variables do not exist if no FOR statement
+                       if (CompareCaseInsensitive(wordBuffer, "for") == 0) {
+                               forFound = true;
+                       }
+                       // 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] != '%') &&
+                       (!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] != '%') &&
+                                               (!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
+                                       styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+                                       // No need to Reset Offset
+                               // Check for Default Text
+                               } else {
+                                       // Read up to %, Operator or Separator
+                                       while ((wbo < wbl) &&
+                                               (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)
+                       if ((Is0To9(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 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 ((forFound) &&
+                               (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 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] != '%') &&
+                               (!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, WordList *[], Accessor &styler) {
+static void ColouriseBatchDoc(
+    unsigned int startPos,
+    int length,
+    int /*initStyle*/,
+    WordList *keywordlists[],
+    Accessor &styler) {
+
        char lineBuffer[1024];
+       WordList &keywords = *keywordlists[0];
+
        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 (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
-                       ColouriseBatchLine(lineBuffer, i, styler);
+               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, keywords, styler);
                        linePos = 0;
+                       startLine = i + 1;
                }
        }
-       if (linePos > 0)
-               ColouriseBatchLine(lineBuffer, startPos + length, styler);
+       if (linePos > 0) {      // Last line does not have ending characters
+               ColouriseBatchLine(lineBuffer, linePos, startLine, startPos + length - 1,
+                                  keywords, styler);
+       }
 }
 
 static void ColouriseDiffLine(char *lineBuffer, int endLine, Accessor &styler) {
@@ -54,22 +474,47 @@ static void ColouriseDiffLine(char *lineBuffer, int endLine, Accessor &styler) {
        // 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 ", 3)) {
-               styler.ColourTo(endLine, 2);
-       } else if (0 == strncmp(lineBuffer, "--- ", 3)) {
-               styler.ColourTo(endLine, 3);
-       } else if (0 == strncmp(lineBuffer, "+++ ", 3)) {
-               styler.ColourTo(endLine, 3);
+       if (0 == strncmp(lineBuffer, "diff ", 5)) {
+               styler.ColourTo(endLine, SCE_DIFF_COMMAND);
+       } else if (0 == strncmp(lineBuffer, "--- ", 4)) {
+               // In a context diff, --- appears in both the header and the position markers
+               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)) {
+               // 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, 4);
-       } else if (lineBuffer[0] == '-') {
-               styler.ColourTo(endLine, 5);
-       } else if (lineBuffer[0] == '+') {
-               styler.ColourTo(endLine, 6);
+               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, 1);
+               styler.ColourTo(endLine, SCE_DIFF_COMMENT);
        } else {
-               styler.ColourTo(endLine, 0);
+               styler.ColourTo(endLine, SCE_DIFF_DEFAULT);
        }
 }
 
@@ -80,38 +525,83 @@ static void ColouriseDiffDoc(unsigned int startPos, int length, int, WordList *[
        unsigned int linePos = 0;
        for (unsigned int i = startPos; i < startPos + length; i++) {
                lineBuffer[linePos++] = styler[i];
-               if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
+               if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
+                       // End of line (or of line buffer) met, colourise it
+                       lineBuffer[linePos] = '\0';
                        ColouriseDiffLine(lineBuffer, i, styler);
                        linePos = 0;
                }
        }
-       if (linePos > 0)
-               ColouriseDiffLine(lineBuffer, startPos + length, styler);
+       if (linePos > 0) {      // Last line does not have ending characters
+               ColouriseDiffLine(lineBuffer, startPos + length - 1, styler);
+       }
 }
 
-static void ColourisePropsLine(char *lineBuffer, int lengthLine, int startLine, int endPos, Accessor &styler) {
-       int i = 0;
-       while (isspace(lineBuffer[i]) && (i < lengthLine))      // Skip initial spaces
+static void FoldDiffDoc(unsigned int startPos, int length, int, WordList*[], Accessor &styler) {
+       int curLine = styler.GetLine(startPos);
+       int prevLevel = SC_FOLDLEVELBASE;
+       if (curLine > 0)
+               prevLevel = styler.LevelAt(curLine-1);
+
+       int curLineStart = styler.LineStart(curLine);
+       do {
+               int nextLevel = prevLevel;
+               if (prevLevel & SC_FOLDLEVELHEADERFLAG)
+                       nextLevel = (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1;
+
+               int lineType = styler.StyleAt(curLineStart);
+               if (lineType == SCE_DIFF_COMMAND)
+                       nextLevel = (SC_FOLDLEVELBASE + 1) | SC_FOLDLEVELHEADERFLAG;
+               else if (lineType == SCE_DIFF_HEADER) {
+                       nextLevel = (SC_FOLDLEVELBASE + 2) | SC_FOLDLEVELHEADERFLAG;
+               } else if (lineType == SCE_DIFF_POSITION)
+                       nextLevel = (SC_FOLDLEVELBASE + 3) | SC_FOLDLEVELHEADERFLAG;
+
+               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 void ColourisePropsLine(
+    char *lineBuffer,
+    unsigned int lengthLine,
+    unsigned int startLine,
+    unsigned int endPos,
+    Accessor &styler) {
+
+       unsigned int i = 0;
+       while ((i < lengthLine) && isspacechar(lineBuffer[i]))  // Skip initial spaces
                i++;
-       if (lineBuffer[i] == '#' || lineBuffer[i] == '!' || lineBuffer[i] == ';') {
-               styler.ColourTo(endPos, 1);
-       } else if (lineBuffer[i] == '[') {
-               styler.ColourTo(endPos, 2);
-       } else if (lineBuffer[i] == '@') {
-               styler.ColourTo(startLine+i, 4);
-               if (lineBuffer[++i] == '=')
-                       styler.ColourTo(startLine+i, 3);
-               styler.ColourTo(endPos, 0);
-       } else {
-               while (lineBuffer[i] != '=' && (i < lengthLine))        // Search the '=' character
-                       i++;
-               if (lineBuffer[i] == '=') {
-                       styler.ColourTo(startLine+i-1, 0);
-                       styler.ColourTo(startLine+i, 3);
-                       styler.ColourTo(endPos, 0);
+       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 (lineBuffer[++i] == '=')
+                               styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
+                       styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
                } else {
-                       styler.ColourTo(endPos, 0);
+                       // Search for the '=' character
+                       while ((i < lengthLine) && (lineBuffer[i] != '='))
+                               i++;
+                       if ((i < lengthLine) && (lineBuffer[i] == '=')) {
+                               styler.ColourTo(startLine + i - 1, SCE_PROPS_DEFAULT);
+                               styler.ColourTo(startLine + i, 3);
+                               styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+                       } else {
+                               styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+                       }
                }
+       } else {
+               styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
        }
 }
 
@@ -120,30 +610,155 @@ static void ColourisePropsDoc(unsigned int startPos, int length, int, WordList *
        styler.StartAt(startPos);
        styler.StartSegment(startPos);
        unsigned int linePos = 0;
-       int startLine = startPos;
-       for (unsigned int i = startPos; i <= startPos + length; i++) {
+       unsigned int startLine = startPos;
+       for (unsigned int i = startPos; i < startPos + length; i++) {
                lineBuffer[linePos++] = styler[i];
-               if ((styler[i] == '\r' && styler.SafeGetCharAt(i+1) != '\n') || 
-                       styler[i] == '\n' || 
-                       (linePos >= sizeof(lineBuffer) - 1)) {
+               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);
                        linePos = 0;
-                       startLine = i+1;
+                       startLine = i + 1;
+               }
+       }
+       if (linePos > 0) {      // Last line does not have ending characters
+               ColourisePropsLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
+       }
+}
+
+// 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;
        }
-       if (linePos > 0)
-               ColourisePropsLine(lineBuffer, linePos, startLine, startPos + length, styler);
+       int flagsNext = styler.LevelAt(lineCurrent);
+       styler.SetLevel(lineCurrent, lev | flagsNext & ~SC_FOLDLEVELNUMBERMASK);
 }
 
-static void ColouriseMakeLine(char *lineBuffer, int lengthLine, int endPos, Accessor &styler) {
-       int i = 0;
-       while (isspace(lineBuffer[i]) && (i < lengthLine))
+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;
+       // Skip initial spaces
+       while ((i < lengthLine) && isspacechar(lineBuffer[i])) {
                i++;
-       if (lineBuffer[i] == '#' || lineBuffer[i] == '!') {
-               styler.ColourTo(endPos, 1);
+       }
+       if (lineBuffer[i] == '#') {     // Comment
+               styler.ColourTo(endPos, SCE_MAKE_COMMENT);
+               return;
+       }
+       if (lineBuffer[i] == '!') {     // Special directive
+               styler.ColourTo(endPos, SCE_MAKE_PREPROCESSOR);
+               return;
+       }
+       while (i < lengthLine) {
+               if (lineBuffer[i] == '$' && lineBuffer[i + 1] == '(') {
+                       styler.ColourTo(startLine + i - 1, state);
+                       state = SCE_MAKE_IDENTIFIER;
+               } else if (state == SCE_MAKE_IDENTIFIER && lineBuffer[i] == ')') {
+                       styler.ColourTo(startLine + i, state);
+                       state = SCE_MAKE_DEFAULT;
+               }
+               if (!bSpecial) {
+                       if (lineBuffer[i] == ':') {
+                               // 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, 0);
+               styler.ColourTo(endPos, SCE_MAKE_DEFAULT);
        }
 }
 
@@ -152,103 +767,248 @@ static void ColouriseMakeDoc(unsigned int startPos, int length, int, WordList *[
        styler.StartAt(startPos);
        styler.StartSegment(startPos);
        unsigned int linePos = 0;
-       for (unsigned int i = startPos; i <= startPos + length; i++) {
+       unsigned int startLine = startPos;
+       for (unsigned int i = startPos; i < startPos + length; i++) {
                lineBuffer[linePos++] = styler[i];
-               if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
-                       ColouriseMakeLine(lineBuffer, linePos, i, styler);
+               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)
-               ColouriseMakeLine(lineBuffer, linePos, startPos + length, styler);
+       if (linePos > 0) {      // Last line does not have ending characters
+               ColouriseMakeLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
+       }
+}
+
+static bool strstart(const char *haystack, const char *needle) {
+       return strncmp(haystack, needle, strlen(needle)) == 0;
 }
 
-static void ColouriseErrorListLine(char *lineBuffer, int lengthLine, int endPos, Accessor &styler) {
+static int RecogniseErrorListLine(const char *lineBuffer, unsigned int lengthLine) {
        if (lineBuffer[0] == '>') {
                // Command or return status
-               styler.ColourTo(endPos, SCE_ERR_CMD);
+               return SCE_ERR_CMD;
+       } else if (lineBuffer[0] == '<') {
+               // Diff removal, but not interested. Trapped to avoid hitting CTAG cases.
+               return SCE_ERR_DEFAULT;
+       } 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 ")) {
-               styler.ColourTo(endPos, SCE_ERR_PYTHON);
-       } else if (0 == strncmp(lineBuffer, "Error ", strlen("Error "))) {
+               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
-               styler.ColourTo(endPos, SCE_ERR_BORLAND);
-       } else if (0 == strncmp(lineBuffer, "Warning ", strlen("Warning "))) {
+               return SCE_ERR_BORLAND;
+       } else if (strstart(lineBuffer, "Warning ")) {
                // Borland warning message
-               styler.ColourTo(endPos, SCE_ERR_BORLAND);
-       } else if (strstr(lineBuffer, " at "  ) && 
-               strstr(lineBuffer, " at "  ) < lineBuffer+lengthLine && 
-               strstr(lineBuffer, " line ") && 
-               strstr(lineBuffer, " line ") < lineBuffer+lengthLine) {
+               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
-               styler.ColourTo(endPos, SCE_ERR_PERL);
+               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 <filename>:<line>:message
-               // Look for <filename>(line)message
-               // Look for <filename>(line,pos)message
-               int state = 0;
-               for (int i = 0; i < lengthLine; i++) {
-                       if (state == 0 && lineBuffer[i] == ':' && isdigit(lineBuffer[i + 1])) {
-                               state = 1;
-                       } else if (state == 0 && lineBuffer[i] == '(') {
-                               state = 10;
-                       } else if (state == 1 && isdigit(lineBuffer[i])) {
-                               state = 2;
-                       } else if (state == 2 && lineBuffer[i] == ':') {
-                               state = 3;
-                               break;
-                       } else if (state == 2 && !isdigit(lineBuffer[i])) {
-                               state = 99;
-                       } else if (state == 10 && isdigit(lineBuffer[i])) {
-                               state = 11;
-                       } else if (state == 11 && lineBuffer[i] == ',') {
-                               state = 14;
-                       } else if (state == 11 && lineBuffer[i] == ')') {
-                               state = 12;
-                       } else if (state == 12 && lineBuffer[i] == ':') {
-                               state = 13;
-                       } else if (state == 14 && lineBuffer[i] == ')') {
-                               state = 15;
+               // 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>
+               bool initialTab = (lineBuffer[0] == '\t');
+               enum { stInitial, 
+                       stGccStart, stGccDigit, 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 != '/')) {
+                                               // This check is not completely accurate as may be on
+                                               // GTK+ with a file name that includes ':'.
+                                               state = stGccStart;
+                                       }
+                               } 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 = stGcc;  // :9.*: is GCC
+                                       break;
+                               } else if (!Is0To9(ch)) {
+                                       state = stUnrecognized;
+                               }
+                       } 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 && isalpha(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;
-                       } else if (((state == 11) || (state == 14)) && !((lineBuffer[i] == ' ') || isdigit(lineBuffer[i]))) {
-                               state = 99;
                        }
                }
-               if (state == 3) {
-                       styler.ColourTo(endPos, SCE_ERR_GCC);
-               } else if ((state == 13) || (state == 14) || (state == 15)) {
-                       styler.ColourTo(endPos, SCE_ERR_MS);
+               if (state == stGcc) {
+                       return SCE_ERR_GCC;
+               } else if ((state == stMsVc) || (state == stMsDotNet)) {
+                       return SCE_ERR_MS;
+               } else if ((state == stCtagsStringDollar) || (state == stCtags)) {
+                       return SCE_ERR_CTAG;
                } else {
-                       styler.ColourTo(endPos, SCE_ERR_DEFAULT);
+                       return SCE_ERR_DEFAULT;
                }
        }
 }
 
+static void ColouriseErrorListLine(
+    char *lineBuffer,
+    unsigned int lengthLine,
+    unsigned int endPos,
+    Accessor &styler) {
+       styler.ColourTo(endPos, RecogniseErrorListLine(lineBuffer, lengthLine));
+}
+
 static void ColouriseErrorListDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-       char lineBuffer[1024];
+       char lineBuffer[10000];
        styler.StartAt(startPos);
        styler.StartSegment(startPos);
        unsigned int linePos = 0;
-       for (unsigned int i = startPos; i <= startPos + length; i++) {
+       for (unsigned int i = startPos; i < startPos + length; i++) {
                lineBuffer[linePos++] = styler[i];
-               if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
+               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);
                        linePos = 0;
                }
        }
-       if (linePos > 0)
-               ColouriseErrorListLine(lineBuffer, linePos, startPos + length, styler);
+       if (linePos > 0) {      // Last line does not have ending characters
+               ColouriseErrorListLine(lineBuffer, linePos, startPos + length - 1, styler);
+       }
 }
 
 static int isSpecial(char s) {
-
        return (s == '\\') || (s == ',') || (s == ';') || (s == '\'') || (s == ' ') ||
               (s == '\"') || (s == '`') || (s == '^') || (s == '~');
 }
 
 static int isTag(int start, Accessor &styler) {
-
        char s[6];
-       unsigned int i = 0, e=1;
+       unsigned int i = 0, e = 1;
        while (i < 5 && e) {
                s[i] = styler[start + i];
                i++;
@@ -259,7 +1019,7 @@ static int isTag(int start, Accessor &styler) {
 }
 
 static void ColouriseLatexDoc(unsigned int startPos, int length, int initStyle,
-                          WordList *[], Accessor &styler) {
+                              WordList *[], Accessor &styler) {
 
        styler.StartAt(startPos);
 
@@ -277,75 +1037,94 @@ static void ColouriseLatexDoc(unsigned int startPos, int length, int initStyle,
                        i++;
                        continue;
                }
-               switch(state) {
-                       case SCE_L_DEFAULT :
-                               switch(ch) {
-                                       case '\\' :
-                                               styler.ColourTo(i - 1, state);
-                                               if (isSpecial(styler[i + 1])) {
-                                                       styler.ColourTo(i + 1, SCE_L_COMMAND);
-                                                       i++;
-                                                       chNext = styler.SafeGetCharAt(i + 1);
-                                               }               
-                                               else {
-                                                   if (isTag(i+1, styler))
-                                                       state = SCE_L_TAG;
-                                                   else
-                                                       state = SCE_L_COMMAND;
-                                               }
-                                               break;
-                                       case '$' :
-                                               styler.ColourTo(i - 1, state);
-                                               state = SCE_L_MATH;
-                                               if (chNext == '$') {
-                                                       i++;
-                                                       chNext = styler.SafeGetCharAt(i + 1);
-                                               }
-                                               break;
-                                       case '%' :
-                                               styler.ColourTo(i - 1, state);
-                                               state = SCE_L_COMMENT;
-                                               break;
-                               }
-                               break;                          
-                       case SCE_L_COMMAND :
-                               if (chNext == '[' || chNext == '{' || chNext == '}' || 
-                                   chNext == ' ' || chNext == '\r' || chNext == '\n') {
-                                       styler.ColourTo(i, state);
-                                       state = SCE_L_DEFAULT;
+               switch (state) {
+               case SCE_L_DEFAULT :
+                       switch (ch) {
+                       case '\\' :
+                               styler.ColourTo(i - 1, state);
+                               if (isSpecial(styler[i + 1])) {
+                                       styler.ColourTo(i + 1, SCE_L_COMMAND);
                                        i++;
                                        chNext = styler.SafeGetCharAt(i + 1);
-                               }
-                               break;                                  
-                       case SCE_L_TAG :
-                               if (ch == '}') {
-                                       styler.ColourTo(i, state);
-                                       state = SCE_L_DEFAULT;
+                               } else {
+                                       if (isTag(i + 1, styler))
+                                               state = SCE_L_TAG;
+                                       else
+                                               state = SCE_L_COMMAND;
                                }
                                break;
-                       case SCE_L_MATH :
-                               if (ch == '$') {
-                                       if (chNext == '$') {
-                                               i++;
-                                               chNext = styler.SafeGetCharAt(i + 1);
-                                       }
-                                       styler.ColourTo(i, state);
-                                       state = SCE_L_DEFAULT;
+                       case '$' :
+                               styler.ColourTo(i - 1, state);
+                               state = SCE_L_MATH;
+                               if (chNext == '$') {
+                                       i++;
+                                       chNext = styler.SafeGetCharAt(i + 1);
                                }
                                break;
-                       case SCE_L_COMMENT :
-                               if (ch == '\r' || ch == '\n') {
-                                       styler.ColourTo(i - 1, state);
-                                       state = SCE_L_DEFAULT;
+                       case '%' :
+                               styler.ColourTo(i - 1, state);
+                               state = SCE_L_COMMENT;
+                               break;
+                       }
+                       break;
+               case SCE_L_COMMAND :
+                       if (chNext == '[' || chNext == '{' || chNext == '}' ||
+                               chNext == ' ' || chNext == '\r' || chNext == '\n') {
+                               styler.ColourTo(i, state);
+                               state = SCE_L_DEFAULT;
+                               i++;
+                               chNext = styler.SafeGetCharAt(i + 1);
+                       }
+                       break;
+               case SCE_L_TAG :
+                       if (ch == '}') {
+                               styler.ColourTo(i, state);
+                               state = SCE_L_DEFAULT;
+                       }
+                       break;
+               case SCE_L_MATH :
+                       if (ch == '$') {
+                               if (chNext == '$') {
+                                       i++;
+                                       chNext = styler.SafeGetCharAt(i + 1);
                                }
-               }               
+                               styler.ColourTo(i, state);
+                               state = SCE_L_DEFAULT;
+                       }
+                       break;
+               case SCE_L_COMMENT :
+                       if (ch == '\r' || ch == '\n') {
+                               styler.ColourTo(i - 1, state);
+                               state = SCE_L_DEFAULT;
+                       }
+               }
+       }
+       styler.ColourTo(lengthDoc-1, state);
+}
+
+static const char * const batchWordListDesc[] = {
+       "Keywords",
+       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);
        }
-       styler.ColourTo(lengthDoc, state);
 }
 
-LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc);
-LexerModule lmDiff(SCLEX_DIFF, ColouriseDiffDoc);
-LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc);
-LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc);
-LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc);
-LexerModule lmLatex(SCLEX_LATEX, ColouriseLatexDoc);
+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");