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