Update Scintilla to version 3.5.3

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

// Scintilla source code edit control
/** @file LexHex.cxx
 ** Lexers for Motorola S-Record, Intel HEX and Tektronix extended HEX.
 **
 ** Written by Markus Heidelberg
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

/*
 *  Motorola S-Record
 * ===============================
 *
 * Each record (line) is built as follows:
 *
 *    field       digits          states
 *
 *  +----------+
 *  | start    |  1 ('S')         SCE_HEX_RECSTART
 *  +----------+
 *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
 *  +----------+
 *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
 *  +----------+
 *  | address  |  4/6/8           SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, SCE_HEX_RECCOUNT, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
 *  +----------+
 *  | data     |  0..504/502/500  SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, (SCE_HEX_DATA_UNKNOWN)
 *  +----------+
 *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
 *  +----------+
 *
 *
 *  Intel HEX
 * ===============================
 *
 * Each record (line) is built as follows:
 *
 *    field       digits          states
 *
 *  +----------+
 *  | start    |  1 (':')         SCE_HEX_RECSTART
 *  +----------+
 *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
 *  +----------+
 *  | address  |  4               SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
 *  +----------+
 *  | type     |  2               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
 *  +----------+
 *  | data     |  0..510          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, SCE_HEX_EXTENDEDADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_DATA_UNKNOWN)
 *  +----------+
 *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
 *  +----------+
 *
 *
 * Folding:
 *
 *   Data records (type 0x00), which follow an extended address record (type
 *   0x02 or 0x04), can be folded. The extended address record is the fold
 *   point at fold level 0, the corresponding data records are set to level 1.
 *
 *   Any record, which is not a data record, sets the fold level back to 0.
 *   Any line, which is not a record (blank lines and lines starting with a
 *   character other than ':'), leaves the fold level unchanged.
 *
 *
 *  Tektronix extended HEX
 * ===============================
 *
 * Each record (line) is built as follows:
 *
 *    field       digits          states
 *
 *  +----------+
 *  | start    |  1 ('%')         SCE_HEX_RECSTART
 *  +----------+
 *  | length   |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
 *  +----------+
 *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
 *  +----------+
 *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
 *  +----------+
 *  | address  |  9               SCE_HEX_DATAADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
 *  +----------+
 *  | data     |  0..241          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN
 *  +----------+
 *
 *
 *  General notes for all lexers
 * ===============================
 *
 * - Depending on where the helper functions are invoked, some of them have to
 *   read beyond the current position. In case of malformed data (record too
 *   short), it has to be ensured that this either does not have bad influence
 *   or will be captured deliberately.
 *
 * - States in parentheses in the upper format descriptions indicate that they
 *   should not appear in a valid hex file.
 *
 * - State SCE_HEX_GARBAGE means garbage data after the intended end of the
 *   record, the line is too long then. This state is used in all lexers.
 */

#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

// prototypes for general helper functions
static inline bool IsNewline(const int ch);
static int GetHexaNibble(char hd);
static int GetHexaChar(char hd1, char hd2);
static int GetHexaChar(unsigned int pos, Accessor &styler);
static bool ForwardWithinLine(StyleContext &sc, int nb = 1);
static bool PosInSameRecord(unsigned int pos1, unsigned int pos2, Accessor &styler);
static int CountByteCount(unsigned int startPos, int uncountedDigits, Accessor &styler);
static int CalcChecksum(unsigned int startPos, int cnt, bool twosCompl, Accessor &styler);

// prototypes for file format specific helper functions
static unsigned int GetSrecRecStartPosition(unsigned int pos, Accessor &styler);
static int GetSrecByteCount(unsigned int recStartPos, Accessor &styler);
static int CountSrecByteCount(unsigned int recStartPos, Accessor &styler);
static int GetSrecAddressFieldSize(unsigned int recStartPos, Accessor &styler);
static int GetSrecAddressFieldType(unsigned int recStartPos, Accessor &styler);
static int GetSrecDataFieldType(unsigned int recStartPos, Accessor &styler);
static int GetSrecRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler);
static int GetSrecChecksum(unsigned int recStartPos, Accessor &styler);
static int CalcSrecChecksum(unsigned int recStartPos, Accessor &styler);

static unsigned int GetIHexRecStartPosition(unsigned int pos, Accessor &styler);
static int GetIHexByteCount(unsigned int recStartPos, Accessor &styler);
static int CountIHexByteCount(unsigned int recStartPos, Accessor &styler);
static int GetIHexAddressFieldType(unsigned int recStartPos, Accessor &styler);
static int GetIHexDataFieldType(unsigned int recStartPos, Accessor &styler);
static int GetIHexRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler);
static int GetIHexChecksum(unsigned int recStartPos, Accessor &styler);
static int CalcIHexChecksum(unsigned int recStartPos, Accessor &styler);

static int GetTEHexDigitCount(unsigned int recStartPos, Accessor &styler);
static int CountTEHexDigitCount(unsigned int recStartPos, Accessor &styler);
static int GetTEHexAddressFieldType(unsigned int recStartPos, Accessor &styler);
static int GetTEHexChecksum(unsigned int recStartPos, Accessor &styler);
static int CalcTEHexChecksum(unsigned int recStartPos, Accessor &styler);

static inline bool IsNewline(const int ch)
{
    return (ch == '\n' || ch == '\r');
}

static int GetHexaNibble(char hd)
{
        int hexValue = 0;

        if (hd >= '0' && hd <= '9') {
                hexValue += hd - '0';
        } else if (hd >= 'A' && hd <= 'F') {
                hexValue += hd - 'A' + 10;
        } else if (hd >= 'a' && hd <= 'f') {
                hexValue += hd - 'a' + 10;
        } else {
                return -1;
        }

        return hexValue;
}

static int GetHexaChar(char hd1, char hd2)
{
        int hexValue = 0;

        if (hd1 >= '0' && hd1 <= '9') {
                hexValue += 16 * (hd1 - '0');
        } else if (hd1 >= 'A' && hd1 <= 'F') {
                hexValue += 16 * (hd1 - 'A' + 10);
        } else if (hd1 >= 'a' && hd1 <= 'f') {
                hexValue += 16 * (hd1 - 'a' + 10);
        } else {
                return -1;
        }

        if (hd2 >= '0' && hd2 <= '9') {
                hexValue += hd2 - '0';
        } else if (hd2 >= 'A' && hd2 <= 'F') {
                hexValue += hd2 - 'A' + 10;
        } else if (hd2 >= 'a' && hd2 <= 'f') {
                hexValue += hd2 - 'a' + 10;
        } else {
                return -1;
        }

        return hexValue;
}

static int GetHexaChar(unsigned int pos, Accessor &styler)
{
        char highNibble, lowNibble;

        highNibble = styler.SafeGetCharAt(pos);
        lowNibble = styler.SafeGetCharAt(pos + 1);

        return GetHexaChar(highNibble, lowNibble);
}

// Forward <nb> characters, but abort (and return false) if hitting the line
// end. Return true if forwarding within the line was possible.
// Avoids influence on highlighting of the subsequent line if the current line
// is malformed (too short).
static bool ForwardWithinLine(StyleContext &sc, int nb)
{
        for (int i = 0; i < nb; i++) {
                if (sc.atLineEnd) {
                        // line is too short
                        sc.SetState(SCE_HEX_DEFAULT);
                        sc.Forward();
                        return false;
                } else {
                        sc.Forward();
                }
        }

        return true;
}

// Checks whether the given positions are in the same record.
static bool PosInSameRecord(unsigned int pos1, unsigned int pos2, Accessor &styler)
{
        return styler.GetLine(pos1) == styler.GetLine(pos2);
}

// Count the number of digit pairs from <startPos> till end of record, ignoring
// <uncountedDigits> digits.
// If the record is too short, a negative count may be returned.
static int CountByteCount(unsigned int startPos, int uncountedDigits, Accessor &styler)
{
        int cnt;
        unsigned int pos;

        pos = startPos;

        while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
                pos++;
        }

        // number of digits in this line minus number of digits of uncounted fields
        cnt = static_cast<int>(pos - startPos) - uncountedDigits;

        // Prepare round up if odd (digit pair incomplete), this way the byte
        // count is considered to be valid if the checksum is incomplete.
        if (cnt >= 0) {
                cnt++;
        }

        // digit pairs
        cnt /= 2;

        return cnt;
}

// Calculate the checksum of the record.
// <startPos> is the position of the first character of the starting digit
// pair, <cnt> is the number of digit pairs.
static int CalcChecksum(unsigned int startPos, int cnt, bool twosCompl, Accessor &styler)
{
        int cs = 0;

        for (unsigned int pos = startPos; pos < startPos + cnt; pos += 2) {
                int val = GetHexaChar(pos, styler);

                if (val < 0) {
                        return val;
                }

                // overflow does not matter
                cs += val;
        }

        if (twosCompl) {
                // low byte of two's complement
                return -cs & 0xFF;
        } else {
                // low byte of one's complement
                return ~cs & 0xFF;
        }
}

// Get the position of the record "start" field (first character in line) in
// the record around position <pos>.
static unsigned int GetSrecRecStartPosition(unsigned int pos, Accessor &styler)
{
        while (styler.SafeGetCharAt(pos) != 'S') {
                pos--;
        }

        return pos;
}

// Get the value of the "byte count" field, it counts the number of bytes in
// the subsequent fields ("address", "data" and "checksum" fields).
static int GetSrecByteCount(unsigned int recStartPos, Accessor &styler)
{
        int val;

        val = GetHexaChar(recStartPos + 2, styler);
        if (val < 0) {
               val = 0;
        }

        return val;
}

// Count the number of digit pairs for the "address", "data" and "checksum"
// fields in this record. Has to be equal to the "byte count" field value.
// If the record is too short, a negative count may be returned.
static int CountSrecByteCount(unsigned int recStartPos, Accessor &styler)
{
        return CountByteCount(recStartPos, 4, styler);
}

// Get the size of the "address" field.
static int GetSrecAddressFieldSize(unsigned int recStartPos, Accessor &styler)
{
        switch (styler.SafeGetCharAt(recStartPos + 1)) {
                case '0':
                case '1':
                case '5':
                case '9':
                        return 2; // 16 bit

                case '2':
                case '6':
                case '8':
                        return 3; // 24 bit

                case '3':
                case '7':
                        return 4; // 32 bit

                default:
                        return 0;
        }
}

// Get the type of the "address" field content.
static int GetSrecAddressFieldType(unsigned int recStartPos, Accessor &styler)
{
        switch (styler.SafeGetCharAt(recStartPos + 1)) {
                case '0':
                        return SCE_HEX_NOADDRESS;

                case '1':
                case '2':
                case '3':
                        return SCE_HEX_DATAADDRESS;

                case '5':
                case '6':
                        return SCE_HEX_RECCOUNT;

                case '7':
                case '8':
                case '9':
                        return SCE_HEX_STARTADDRESS;

                default: // handle possible format extension in the future
                        return SCE_HEX_ADDRESSFIELD_UNKNOWN;
        }
}

// Get the type of the "data" field content.
static int GetSrecDataFieldType(unsigned int recStartPos, Accessor &styler)
{
        switch (styler.SafeGetCharAt(recStartPos + 1)) {
                case '0':
                case '1':
                case '2':
                case '3':
                        return SCE_HEX_DATA_ODD;

                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                        return SCE_HEX_DATA_EMPTY;

                default: // handle possible format extension in the future
                        return SCE_HEX_DATA_UNKNOWN;
        }
}

// Get the required size of the "data" field. Useless for block header and
// ordinary data records (type S0, S1, S2, S3), return the value calculated
// from the "byte count" and "address field" size in this case.
static int GetSrecRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler)
{
        switch (styler.SafeGetCharAt(recStartPos + 1)) {
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                        return 0;

                default:
                        return GetSrecByteCount(recStartPos, styler)
                                - GetSrecAddressFieldSize(recStartPos, styler)
                                - 1; // -1 for checksum field
        }
}

// Get the value of the "checksum" field.
static int GetSrecChecksum(unsigned int recStartPos, Accessor &styler)
{
        int byteCount;

        byteCount = GetSrecByteCount(recStartPos, styler);

        return GetHexaChar(recStartPos + 2 + byteCount * 2, styler);
}

// Calculate the checksum of the record.
static int CalcSrecChecksum(unsigned int recStartPos, Accessor &styler)
{
        int byteCount;

        byteCount = GetSrecByteCount(recStartPos, styler);

        // sum over "byte count", "address" and "data" fields (6..510 digits)
        return CalcChecksum(recStartPos + 2, byteCount * 2, false, styler);
}

// Get the position of the record "start" field (first character in line) in
// the record around position <pos>.
static unsigned int GetIHexRecStartPosition(unsigned int pos, Accessor &styler)
{
        while (styler.SafeGetCharAt(pos) != ':') {
                pos--;
        }

        return pos;
}

// Get the value of the "byte count" field, it counts the number of bytes in
// the "data" field.
static int GetIHexByteCount(unsigned int recStartPos, Accessor &styler)
{
        int val;

        val = GetHexaChar(recStartPos + 1, styler);
        if (val < 0) {
               val = 0;
        }

        return val;
}

// Count the number of digit pairs for the "data" field in this record. Has to
// be equal to the "byte count" field value.
// If the record is too short, a negative count may be returned.
static int CountIHexByteCount(unsigned int recStartPos, Accessor &styler)
{
        return CountByteCount(recStartPos, 11, styler);
}

// Get the type of the "address" field content.
static int GetIHexAddressFieldType(unsigned int recStartPos, Accessor &styler)
{
        if (!PosInSameRecord(recStartPos, recStartPos + 7, styler)) {
                // malformed (record too short)
                // type cannot be determined
                return SCE_HEX_ADDRESSFIELD_UNKNOWN;
        }

        switch (GetHexaChar(recStartPos + 7, styler)) {
                case 0x00:
                        return SCE_HEX_DATAADDRESS;

                case 0x01:
                case 0x02:
                case 0x03:
                case 0x04:
                case 0x05:
                        return SCE_HEX_NOADDRESS;

                default: // handle possible format extension in the future
                        return SCE_HEX_ADDRESSFIELD_UNKNOWN;
        }
}

// Get the type of the "data" field content.
static int GetIHexDataFieldType(unsigned int recStartPos, Accessor &styler)
{
        switch (GetHexaChar(recStartPos + 7, styler)) {
                case 0x00:
                        return SCE_HEX_DATA_ODD;

                case 0x01:
                        return SCE_HEX_DATA_EMPTY;

                case 0x02:
                case 0x04:
                        return SCE_HEX_EXTENDEDADDRESS;

                case 0x03:
                case 0x05:
                        return SCE_HEX_STARTADDRESS;

                default: // handle possible format extension in the future
                        return SCE_HEX_DATA_UNKNOWN;
        }
}

// Get the required size of the "data" field. Useless for an ordinary data
// record (type 00), return the "byte count" in this case.
static int GetIHexRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler)
{
        switch (GetHexaChar(recStartPos + 7, styler)) {
                case 0x01:
                        return 0;

                case 0x02:
                case 0x04:
                        return 2;

                case 0x03:
                case 0x05:
                        return 4;

                default:
                        return GetIHexByteCount(recStartPos, styler);
        }
}

// Get the value of the "checksum" field.
static int GetIHexChecksum(unsigned int recStartPos, Accessor &styler)
{
        int byteCount;

        byteCount = GetIHexByteCount(recStartPos, styler);

        return GetHexaChar(recStartPos + 9 + byteCount * 2, styler);
}

// Calculate the checksum of the record.
static int CalcIHexChecksum(unsigned int recStartPos, Accessor &styler)
{
        int byteCount;

        byteCount = GetIHexByteCount(recStartPos, styler);

        // sum over "byte count", "address", "type" and "data" fields (8..518 digits)
        return CalcChecksum(recStartPos + 1, 8 + byteCount * 2, true, styler);
}


// Get the value of the "record length" field, it counts the number of digits in
// the record excluding the percent.
static int GetTEHexDigitCount(unsigned int recStartPos, Accessor &styler)
{
        int val = GetHexaChar(recStartPos + 1, styler);
        if (val < 0)
               val = 0;

        return val;
}

// Count the number of digits in this record. Has to
// be equal to the "record length" field value.
static int CountTEHexDigitCount(unsigned int recStartPos, Accessor &styler)
{
        unsigned int pos;

        pos = recStartPos+1;

        while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
                pos++;
        }

        return static_cast<int>(pos - (recStartPos+1));
}

// Get the type of the "address" field content.
static int GetTEHexAddressFieldType(unsigned int recStartPos, Accessor &styler)
{
        switch (styler.SafeGetCharAt(recStartPos + 3)) {
                case '6':
                        return SCE_HEX_DATAADDRESS;

                case '8':
                        return SCE_HEX_STARTADDRESS;

                default: // handle possible format extension in the future
                        return SCE_HEX_ADDRESSFIELD_UNKNOWN;
        }
}

// Get the value of the "checksum" field.
static int GetTEHexChecksum(unsigned int recStartPos, Accessor &styler)
{
        return GetHexaChar(recStartPos+4, styler);
}

// Calculate the checksum of the record (excluding the checksum field).
static int CalcTEHexChecksum(unsigned int recStartPos, Accessor &styler)
{
        unsigned int pos = recStartPos +1;
        unsigned int length = GetTEHexDigitCount(recStartPos, styler);

        int cs = GetHexaNibble(styler.SafeGetCharAt(pos++));//length
        cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//length

        cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//type

        pos += 2;// jump over CS field

        for (; pos <= recStartPos + length; ++pos) {
                int val = GetHexaNibble(styler.SafeGetCharAt(pos));

                if (val < 0) {
                        return val;
                }

                // overflow does not matter
                cs += val;
        }

        // low byte
        return cs & 0xFF;

}

static void ColouriseSrecDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
{
        StyleContext sc(startPos, length, initStyle, styler);

        while (sc.More()) {
                unsigned int recStartPos;
                int byteCount, reqByteCount, addrFieldSize, addrFieldType, dataFieldSize, dataFieldType;
                int cs1, cs2;

                switch (sc.state) {
                        case SCE_HEX_DEFAULT:
                                if (sc.atLineStart && sc.Match('S')) {
                                        sc.SetState(SCE_HEX_RECSTART);
                                }
                                ForwardWithinLine(sc);
                                break;

                        case SCE_HEX_RECSTART:
                                recStartPos = sc.currentPos - 1;
                                addrFieldType = GetSrecAddressFieldType(recStartPos, styler);

                                if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
                                        sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
                                } else {
                                        sc.SetState(SCE_HEX_RECTYPE);
                                }

                                ForwardWithinLine(sc);
                                break;

                        case SCE_HEX_RECTYPE:
                        case SCE_HEX_RECTYPE_UNKNOWN:
                                recStartPos = sc.currentPos - 2;
                                byteCount = GetSrecByteCount(recStartPos, styler);
                                reqByteCount = GetSrecAddressFieldSize(recStartPos, styler)
                                                + GetSrecRequiredDataFieldSize(recStartPos, styler)
                                                + 1; // +1 for checksum field

                                if (byteCount == CountSrecByteCount(recStartPos, styler)
                                                && byteCount == reqByteCount) {
                                        sc.SetState(SCE_HEX_BYTECOUNT);
                                } else {
                                        sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_BYTECOUNT:
                        case SCE_HEX_BYTECOUNT_WRONG:
                                recStartPos = sc.currentPos - 4;
                                addrFieldSize = GetSrecAddressFieldSize(recStartPos, styler);
                                addrFieldType = GetSrecAddressFieldType(recStartPos, styler);

                                sc.SetState(addrFieldType);
                                ForwardWithinLine(sc, addrFieldSize * 2);
                                break;

                        case SCE_HEX_NOADDRESS:
                        case SCE_HEX_DATAADDRESS:
                        case SCE_HEX_RECCOUNT:
                        case SCE_HEX_STARTADDRESS:
                        case SCE_HEX_ADDRESSFIELD_UNKNOWN:
                                recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
                                dataFieldType = GetSrecDataFieldType(recStartPos, styler);

                                // Using the required size here if possible has the effect that the
                                // checksum is highlighted at a fixed position after this field for
                                // specific record types, independent on the "byte count" value.
                                dataFieldSize = GetSrecRequiredDataFieldSize(recStartPos, styler);

                                sc.SetState(dataFieldType);

                                if (dataFieldType == SCE_HEX_DATA_ODD) {
                                        for (int i = 0; i < dataFieldSize * 2; i++) {
                                                if ((i & 0x3) == 0) {
                                                        sc.SetState(SCE_HEX_DATA_ODD);
                                                } else if ((i & 0x3) == 2) {
                                                        sc.SetState(SCE_HEX_DATA_EVEN);
                                                }

                                                if (!ForwardWithinLine(sc)) {
                                                        break;
                                                }
                                        }
                                } else {
                                        ForwardWithinLine(sc, dataFieldSize * 2);
                                }
                                break;

                        case SCE_HEX_DATA_ODD:
                        case SCE_HEX_DATA_EVEN:
                        case SCE_HEX_DATA_EMPTY:
                        case SCE_HEX_DATA_UNKNOWN:
                                recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
                                cs1 = CalcSrecChecksum(recStartPos, styler);
                                cs2 = GetSrecChecksum(recStartPos, styler);

                                if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
                                        sc.SetState(SCE_HEX_CHECKSUM_WRONG);
                                } else {
                                        sc.SetState(SCE_HEX_CHECKSUM);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_CHECKSUM:
                        case SCE_HEX_CHECKSUM_WRONG:
                        case SCE_HEX_GARBAGE:
                                // record finished or line too long
                                sc.SetState(SCE_HEX_GARBAGE);
                                ForwardWithinLine(sc);
                                break;

                        default:
                                // prevent endless loop in faulty state
                                sc.SetState(SCE_HEX_DEFAULT);
                                break;
                }
        }
        sc.Complete();
}

static void ColouriseIHexDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
{
        StyleContext sc(startPos, length, initStyle, styler);

        while (sc.More()) {
                unsigned int recStartPos;
                int byteCount, addrFieldType, dataFieldSize, dataFieldType;
                int cs1, cs2;

                switch (sc.state) {
                        case SCE_HEX_DEFAULT:
                                if (sc.atLineStart && sc.Match(':')) {
                                        sc.SetState(SCE_HEX_RECSTART);
                                }
                                ForwardWithinLine(sc);
                                break;

                        case SCE_HEX_RECSTART:
                                recStartPos = sc.currentPos - 1;
                                byteCount = GetIHexByteCount(recStartPos, styler);
                                dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);

                                if (byteCount == CountIHexByteCount(recStartPos, styler)
                                                && byteCount == dataFieldSize) {
                                        sc.SetState(SCE_HEX_BYTECOUNT);
                                } else {
                                        sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_BYTECOUNT:
                        case SCE_HEX_BYTECOUNT_WRONG:
                                recStartPos = sc.currentPos - 3;
                                addrFieldType = GetIHexAddressFieldType(recStartPos, styler);

                                sc.SetState(addrFieldType);
                                ForwardWithinLine(sc, 4);
                                break;

                        case SCE_HEX_NOADDRESS:
                        case SCE_HEX_DATAADDRESS:
                        case SCE_HEX_ADDRESSFIELD_UNKNOWN:
                                recStartPos = sc.currentPos - 7;
                                addrFieldType = GetIHexAddressFieldType(recStartPos, styler);

                                if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
                                        sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
                                } else {
                                        sc.SetState(SCE_HEX_RECTYPE);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_RECTYPE:
                        case SCE_HEX_RECTYPE_UNKNOWN:
                                recStartPos = sc.currentPos - 9;
                                dataFieldType = GetIHexDataFieldType(recStartPos, styler);

                                // Using the required size here if possible has the effect that the
                                // checksum is highlighted at a fixed position after this field for
                                // specific record types, independent on the "byte count" value.
                                dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);

                                sc.SetState(dataFieldType);

                                if (dataFieldType == SCE_HEX_DATA_ODD) {
                                        for (int i = 0; i < dataFieldSize * 2; i++) {
                                                if ((i & 0x3) == 0) {
                                                        sc.SetState(SCE_HEX_DATA_ODD);
                                                } else if ((i & 0x3) == 2) {
                                                        sc.SetState(SCE_HEX_DATA_EVEN);
                                                }

                                                if (!ForwardWithinLine(sc)) {
                                                        break;
                                                }
                                        }
                                } else {
                                        ForwardWithinLine(sc, dataFieldSize * 2);
                                }
                                break;

                        case SCE_HEX_DATA_ODD:
                        case SCE_HEX_DATA_EVEN:
                        case SCE_HEX_DATA_EMPTY:
                        case SCE_HEX_EXTENDEDADDRESS:
                        case SCE_HEX_STARTADDRESS:
                        case SCE_HEX_DATA_UNKNOWN:
                                recStartPos = GetIHexRecStartPosition(sc.currentPos, styler);
                                cs1 = CalcIHexChecksum(recStartPos, styler);
                                cs2 = GetIHexChecksum(recStartPos, styler);

                                if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
                                        sc.SetState(SCE_HEX_CHECKSUM_WRONG);
                                } else {
                                        sc.SetState(SCE_HEX_CHECKSUM);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_CHECKSUM:
                        case SCE_HEX_CHECKSUM_WRONG:
                        case SCE_HEX_GARBAGE:
                                // record finished or line too long
                                sc.SetState(SCE_HEX_GARBAGE);
                                ForwardWithinLine(sc);
                                break;

                        default:
                                // prevent endless loop in faulty state
                                sc.SetState(SCE_HEX_DEFAULT);
                                break;
                }
        }
        sc.Complete();
}

static void FoldIHexDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
{
        unsigned int endPos = startPos + length;

        int lineCurrent = styler.GetLine(startPos);
        int levelCurrent = SC_FOLDLEVELBASE;
        if (lineCurrent > 0)
                levelCurrent = styler.LevelAt(lineCurrent - 1);

        unsigned int lineStartNext = styler.LineStart(lineCurrent + 1);
        int levelNext = SC_FOLDLEVELBASE; // default if no specific line found

        for (unsigned int i = startPos; i < endPos; i++) {
                bool atEOL = i == (lineStartNext - 1);
                int style = styler.StyleAt(i);

                // search for specific lines
                if (style == SCE_HEX_EXTENDEDADDRESS) {
                        // extended addres record
                        levelNext = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
                } else if (style == SCE_HEX_DATAADDRESS
                        || (style == SCE_HEX_DEFAULT
                                && i == (unsigned int)styler.LineStart(lineCurrent))) {
                        // data record or no record start code at all
                        if (levelCurrent & SC_FOLDLEVELHEADERFLAG) {
                                levelNext = SC_FOLDLEVELBASE + 1;
                        } else {
                                // continue level 0 or 1, no fold point
                                levelNext = levelCurrent;
                        }
                }

                if (atEOL || (i == endPos - 1)) {
                        styler.SetLevel(lineCurrent, levelNext);

                        lineCurrent++;
                        lineStartNext = styler.LineStart(lineCurrent + 1);
                        levelCurrent = levelNext;
                        levelNext = SC_FOLDLEVELBASE;
                }
        }
}

static void ColouriseTEHexDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
{
        StyleContext sc(startPos, length, initStyle, styler);

        while (sc.More()) {
                unsigned int recStartPos;
                int digitCount, addrFieldType;
                int cs1, cs2;

                switch (sc.state) {
                        case SCE_HEX_DEFAULT:
                                if (sc.atLineStart && sc.Match('%')) {
                                        sc.SetState(SCE_HEX_RECSTART);
                                }
                                ForwardWithinLine(sc);
                                break;

                        case SCE_HEX_RECSTART:

                                recStartPos = sc.currentPos - 1;

                                if (GetTEHexDigitCount(recStartPos, styler) == CountTEHexDigitCount(recStartPos, styler)) {
                                        sc.SetState(SCE_HEX_BYTECOUNT);
                                } else {
                                        sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
                                }

                                ForwardWithinLine(sc, 2);
                                break;

                        case SCE_HEX_BYTECOUNT:
                        case SCE_HEX_BYTECOUNT_WRONG:
                                recStartPos = sc.currentPos - 3;
                                addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);

                                if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
                                        sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
                                } else {
                                        sc.SetState(SCE_HEX_RECTYPE);
                                }

                                ForwardWithinLine(sc);
                                break;

                        case SCE_HEX_RECTYPE:
                        case SCE_HEX_RECTYPE_UNKNOWN:
                                recStartPos = sc.currentPos - 4;
                                cs1 = CalcTEHexChecksum(recStartPos, styler);
                                cs2 = GetTEHexChecksum(recStartPos, styler);

                                if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
                                        sc.SetState(SCE_HEX_CHECKSUM_WRONG);
                                } else {
                                        sc.SetState(SCE_HEX_CHECKSUM);
                                }

                                ForwardWithinLine(sc, 2);
                                break;


                        case SCE_HEX_CHECKSUM:
                        case SCE_HEX_CHECKSUM_WRONG:
                                recStartPos = sc.currentPos - 6;
                                addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);

                                sc.SetState(addrFieldType);
                                ForwardWithinLine(sc, 9);
                                break;

                        case SCE_HEX_DATAADDRESS:
                        case SCE_HEX_STARTADDRESS:
                        case SCE_HEX_ADDRESSFIELD_UNKNOWN:
                                recStartPos = sc.currentPos - 15;
                                digitCount = GetTEHexDigitCount(recStartPos, styler) - 14;

                                sc.SetState(SCE_HEX_DATA_ODD);

                                for (int i = 0; i < digitCount; i++) {
                                        if ((i & 0x3) == 0) {
                                                sc.SetState(SCE_HEX_DATA_ODD);
                                        } else if ((i & 0x3) == 2) {
                                                sc.SetState(SCE_HEX_DATA_EVEN);
                                        }

                                        if (!ForwardWithinLine(sc)) {
                                                break;
                                        }
                                }
                                break;

                        case SCE_HEX_DATA_ODD:
                        case SCE_HEX_DATA_EVEN:
                        case SCE_HEX_GARBAGE:
                                // record finished or line too long
                                sc.SetState(SCE_HEX_GARBAGE);
                                ForwardWithinLine(sc);
                                break;

                        default:
                                // prevent endless loop in faulty state
                                sc.SetState(SCE_HEX_DEFAULT);
                                break;
                }
        }
        sc.Complete();
}

LexerModule lmSrec(SCLEX_SREC, ColouriseSrecDoc, "srec", 0, NULL);
LexerModule lmIHex(SCLEX_IHEX, ColouriseIHexDoc, "ihex", FoldIHexDoc, NULL);
LexerModule lmTEHex(SCLEX_TEHEX, ColouriseTEHexDoc, "tehex", 0, NULL);