Update Scintilla to version 3.7.0

[TortoiseGit.git] / ext / scintilla / lexers / LexErrorList.cxx

// Scintilla source code edit control
/** @file LexErrorList.cxx
 ** Lexer for error lists. Used for the output pane in SciTE.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>

#include "ILexer.h"
#include "Scintilla.h"
#include "SciLexer.h"

#include "WordList.h"
#include "LexAccessor.h"
#include "Accessor.h"
#include "StyleContext.h"
#include "CharacterSet.h"
#include "LexerModule.h"

#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif

static bool strstart(const char *haystack, const char *needle) {
        return strncmp(haystack, needle, strlen(needle)) == 0;
}

static bool Is0To9(char ch) {
        return (ch >= '0') && (ch <= '9');
}

static bool Is1To9(char ch) {
        return (ch >= '1') && (ch <= '9');
}

static bool IsAlphabetic(int ch) {
        return IsASCII(ch) && isalpha(ch);
}

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

static int RecogniseErrorListLine(const char *lineBuffer, Sci_PositionU lengthLine, Sci_Position &startValue) {
        if (lineBuffer[0] == '>') {
                // Command or return status
                return SCE_ERR_CMD;
        } else if (lineBuffer[0] == '<') {
                // Diff removal.
                return SCE_ERR_DIFF_DELETION;
        } else if (lineBuffer[0] == '!') {
                return SCE_ERR_DIFF_CHANGED;
        } else if (lineBuffer[0] == '+') {
                if (strstart(lineBuffer, "+++ ")) {
                        return SCE_ERR_DIFF_MESSAGE;
                } else {
                        return SCE_ERR_DIFF_ADDITION;
                }
        } else if (lineBuffer[0] == '-') {
                if (strstart(lineBuffer, "--- ")) {
                        return SCE_ERR_DIFF_MESSAGE;
                } else {
                        return SCE_ERR_DIFF_DELETION;
                }
        } else if (strstart(lineBuffer, "cf90-")) {
                // Absoft Pro Fortran 90/95 v8.2 error and/or warning message
                return SCE_ERR_ABSF;
        } else if (strstart(lineBuffer, "fortcom:")) {
                // Intel Fortran Compiler v8.0 error/warning message
                return SCE_ERR_IFORT;
        } else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
                return SCE_ERR_PYTHON;
        } else if (strstr(lineBuffer, " in ") && strstr(lineBuffer, " on line ")) {
                return SCE_ERR_PHP;
        } else if ((strstart(lineBuffer, "Error ") ||
                    strstart(lineBuffer, "Warning ")) &&
                   strstr(lineBuffer, " at (") &&
                   strstr(lineBuffer, ") : ") &&
                   (strstr(lineBuffer, " at (") < strstr(lineBuffer, ") : "))) {
                // Intel Fortran Compiler error/warning message
                return SCE_ERR_IFC;
        } else if (strstart(lineBuffer, "Error ")) {
                // Borland error message
                return SCE_ERR_BORLAND;
        } else if (strstart(lineBuffer, "Warning ")) {
                // Borland warning message
                return SCE_ERR_BORLAND;
        } else if (strstr(lineBuffer, "at line ") &&
                (strstr(lineBuffer, "at line ") < (lineBuffer + lengthLine)) &&
                   strstr(lineBuffer, "file ") &&
                   (strstr(lineBuffer, "file ") < (lineBuffer + lengthLine))) {
                // Lua 4 error message
                return SCE_ERR_LUA;
        } else if (strstr(lineBuffer, " at ") &&
                (strstr(lineBuffer, " at ") < (lineBuffer + lengthLine)) &&
                   strstr(lineBuffer, " line ") &&
                   (strstr(lineBuffer, " line ") < (lineBuffer + lengthLine)) &&
                (strstr(lineBuffer, " at ") + 4 < (strstr(lineBuffer, " line ")))) {
                // perl error message:
                // <message> at <file> line <line>
                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 if (strstart(lineBuffer, "In file included from ") ||
                   strstart(lineBuffer, "                 from ")) {
                // GCC showing include path to following error
                return SCE_ERR_GCC_INCLUDED_FROM;
        } else if (strstr(lineBuffer, "warning LNK")) {
                // Microsoft linker warning:
                // {<object> : } warning LNK9999
                return SCE_ERR_MS;
        } else {
                // Look for one of the following formats:
                // GCC: <filename>:<line>:<message>
                // Microsoft: <filename>(<line>) :<message>
                // Common: <filename>(<line>): warning|error|note|remark|catastrophic|fatal
                // Common: <filename>(<line>) warning|error|note|remark|catastrophic|fatal
                // Microsoft: <filename>(<line>,<column>)<message>
                // CTags: <identifier>\t<filename>\t<message>
                // Lua 5 traceback: \t<filename>:<line>:<message>
                // Lua 5.1: <exe>: <filename>:<line>:<message>
                bool initialTab = (lineBuffer[0] == '\t');
                bool initialColonPart = false;
                bool canBeCtags = !initialTab;  // For ctags must have an identifier with no spaces then a tab
                enum { stInitial,
                        stGccStart, stGccDigit, stGccColumn, stGcc,
                        stMsStart, stMsDigit, stMsBracket, stMsVc, stMsDigitComma, stMsDotNet,
                        stCtagsStart, stCtagsFile, stCtagsStartString, stCtagsStringDollar, stCtags,
                        stUnrecognized
                } state = stInitial;
                for (Sci_PositionU i = 0; i < lengthLine; i++) {
                        char ch = lineBuffer[i];
                        char chNext = ' ';
                        if ((i + 1) < lengthLine)
                                chNext = lineBuffer[i + 1];
                        if (state == stInitial) {
                                if (ch == ':') {
                                        // May be GCC, or might be Lua 5 (Lua traceback same but with tab prefix)
                                        if ((chNext != '\\') && (chNext != '/') && (chNext != ' ')) {
                                                // This check is not completely accurate as may be on
                                                // GTK+ with a file name that includes ':'.
                                                state = stGccStart;
                                        } else if (chNext == ' ') { // indicates a Lua 5.1 error message
                                                initialColonPart = true;
                                        }
                                } else if ((ch == '(') && Is1To9(chNext) && (!initialTab)) {
                                        // May be Microsoft
                                        // Check against '0' often removes phone numbers
                                        state = stMsStart;
                                } else if ((ch == '\t') && canBeCtags) {
                                        // May be CTags
                                        state = stCtagsStart;
                                } else if (ch == ' ') {
                                        canBeCtags = false;
                                }
                        } else if (state == stGccStart) {       // <filename>:
                                state = Is0To9(ch) ? stGccDigit : stUnrecognized;
                        } else if (state == stGccDigit) {       // <filename>:<line>
                                if (ch == ':') {
                                        state = stGccColumn;    // :9.*: is GCC
                                        startValue = i + 1;
                                } else if (!Is0To9(ch)) {
                                        state = stUnrecognized;
                                }
                        } else if (state == stGccColumn) {      // <filename>:<line>:<column>
                                if (!Is0To9(ch)) {
                                        state = stGcc;
                                        if (ch == ':')
                                                startValue = i + 1;
                                        break;
                                }
                        } else if (state == stMsStart) {        // <filename>(
                                state = Is0To9(ch) ? stMsDigit : stUnrecognized;
                        } else if (state == stMsDigit) {        // <filename>(<line>
                                if (ch == ',') {
                                        state = stMsDigitComma;
                                } else if (ch == ')') {
                                        state = stMsBracket;
                                } else if ((ch != ' ') && !Is0To9(ch)) {
                                        state = stUnrecognized;
                                }
                        } else if (state == stMsBracket) {      // <filename>(<line>)
                                if ((ch == ' ') && (chNext == ':')) {
                                        state = stMsVc;
                                } else if ((ch == ':' && chNext == ' ') || (ch == ' ')) {
                                        // Possibly Delphi.. don't test against chNext as it's one of the strings below.
                                        char word[512];
                                        Sci_PositionU j, chPos;
                                        unsigned numstep;
                                        chPos = 0;
                                        if (ch == ' ')
                                                numstep = 1; // ch was ' ', handle as if it's a delphi errorline, only add 1 to i.
                                        else
                                                numstep = 2; // otherwise add 2.
                                        for (j = i + numstep; j < lengthLine && IsAlphabetic(lineBuffer[j]) && chPos < sizeof(word) - 1; j++)
                                                word[chPos++] = lineBuffer[j];
                                        word[chPos] = 0;
                                        if (!CompareCaseInsensitive(word, "error") || !CompareCaseInsensitive(word, "warning") ||
                                                !CompareCaseInsensitive(word, "fatal") || !CompareCaseInsensitive(word, "catastrophic") ||
                                                !CompareCaseInsensitive(word, "note") || !CompareCaseInsensitive(word, "remark")) {
                                                state = stMsVc;
                                        } else {
                                                state = stUnrecognized;
                                        }
                                } else {
                                        state = stUnrecognized;
                                }
                        } else if (state == stMsDigitComma) {   // <filename>(<line>,
                                if (ch == ')') {
                                        state = stMsDotNet;
                                        break;
                                } else if ((ch != ' ') && !Is0To9(ch)) {
                                        state = stUnrecognized;
                                }
                        } else if (state == stCtagsStart) {
                                if (ch == '\t') {
                                        state = stCtagsFile;
                                }
                        } else if (state == stCtagsFile) {
                                if ((lineBuffer[i - 1] == '\t') &&
                                        ((ch == '/' && chNext == '^') || Is0To9(ch))) {
                                        state = stCtags;
                                        break;
                                } else if ((ch == '/') && (chNext == '^')) {
                                        state = stCtagsStartString;
                                }
                        } else if ((state == stCtagsStartString) && ((lineBuffer[i] == '$') && (lineBuffer[i + 1] == '/'))) {
                                state = stCtagsStringDollar;
                                break;
                        }
                }
                if (state == stGcc) {
                        return initialColonPart ? SCE_ERR_LUA : SCE_ERR_GCC;
                } else if ((state == stMsVc) || (state == stMsDotNet)) {
                        return SCE_ERR_MS;
                } else if ((state == stCtagsStringDollar) || (state == stCtags)) {
                        return SCE_ERR_CTAG;
                } else if (initialColonPart && strstr(lineBuffer, ": warning C")) {
                        // Microsoft warning without line number
                        // <filename>: warning C9999
                        return SCE_ERR_MS;
                } else {
                        return SCE_ERR_DEFAULT;
                }
        }
}

#define CSI "\033["

namespace {

bool SequenceEnd(int ch) {
        return (ch == 0) || ((ch >= '@') && (ch <= '~'));
}

int StyleFromSequence(const char *seq) {
        int bold = 0;
        int colour = 0;
        while (!SequenceEnd(*seq)) {
                if (Is0To9(*seq)) {
                        int base = *seq - '0';
                        if (Is0To9(seq[1])) {
                                base = base * 10;
                                base += seq[1] - '0';
                                seq++;
                        }
                        if (base == 0) {
                                colour = 0;
                                bold = 0;
                        }
                        else if (base == 1) {
                                bold = 1;
                        }
                        else if (base >= 30 && base <= 37) {
                                colour = base - 30;
                        }
                }
                seq++;
        }
        return SCE_ERR_ES_BLACK + bold * 8 + colour;
}

}

static void ColouriseErrorListLine(
    char *lineBuffer,
    Sci_PositionU lengthLine,
    Sci_PositionU endPos,
    Accessor &styler,
        bool valueSeparate,
        bool escapeSequences) {
        Sci_Position startValue = -1;
        int style = RecogniseErrorListLine(lineBuffer, lengthLine, startValue);
        if (escapeSequences && strstr(lineBuffer, CSI)) {
                const int startPos = endPos - lengthLine;
                const char *linePortion = lineBuffer;
                int startPortion = startPos;
                int portionStyle = style;
                while (const char *startSeq = strstr(linePortion, CSI)) {
                        if (startSeq > linePortion) {
                                styler.ColourTo(startPortion + static_cast<int>(startSeq - linePortion), portionStyle);
                        }
                        const char *endSeq = startSeq + 2;
                        while (!SequenceEnd(*endSeq))
                                endSeq++;
                        const int endSeqPosition = startPortion + static_cast<int>(endSeq - linePortion) + 1;
                        switch (*endSeq) {
                        case 0:
                                styler.ColourTo(endPos, SCE_ERR_ESCSEQ_UNKNOWN);
                                return;
                        case 'm':       // Colour command
                                styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ);
                                portionStyle = StyleFromSequence(startSeq+2);
                                break;
                        case 'K':       // Erase to end of line -> ignore
                                styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ);
                                break;
                        default:
                                styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ_UNKNOWN);
                                portionStyle = style;
                        }
                        startPortion = endSeqPosition;
                        linePortion = endSeq + 1;
                }
                styler.ColourTo(endPos, portionStyle);
        } else {
                if (valueSeparate && (startValue >= 0)) {
                        styler.ColourTo(endPos - (lengthLine - startValue), style);
                        styler.ColourTo(endPos, SCE_ERR_VALUE);
                } else {
                        styler.ColourTo(endPos, style);
                }
        }
}

static void ColouriseErrorListDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
        char lineBuffer[10000];
        styler.StartAt(startPos);
        styler.StartSegment(startPos);
        Sci_PositionU linePos = 0;

        // property lexer.errorlist.value.separate
        //      For lines in the output pane that are matches from Find in Files or GCC-style
        //      diagnostics, style the path and line number separately from the rest of the
        //      line with style 21 used for the rest of the line.
        //      This allows matched text to be more easily distinguished from its location.
        bool valueSeparate = styler.GetPropertyInt("lexer.errorlist.value.separate", 0) != 0;

        // property lexer.errorlist.escape.sequences
        //      Set to 1 to interpret escape sequences.
        const bool escapeSequences = styler.GetPropertyInt("lexer.errorlist.escape.sequences") != 0;

        for (Sci_PositionU i = startPos; i < startPos + length; i++) {
                lineBuffer[linePos++] = styler[i];
                if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
                        // End of line (or of line buffer) met, colourise it
                        lineBuffer[linePos] = '\0';
                        ColouriseErrorListLine(lineBuffer, linePos, i, styler, valueSeparate, escapeSequences);
                        linePos = 0;
                }
        }
        if (linePos > 0) {      // Last line does not have ending characters
                lineBuffer[linePos] = '\0';
                ColouriseErrorListLine(lineBuffer, linePos, startPos + length - 1, styler, valueSeparate, escapeSequences);
        }
}

static const char *const emptyWordListDesc[] = {
        0
};

LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc, "errorlist", 0, emptyWordListDesc);