Subversion Repositories forwardcom

/****************************   error.cpp   **********************************

* Author:        Agner Fog

* Date created:  2017-11-03

* Last modified: 2021-03-30

* Version:       1.11

* Project:       Binary tools for ForwardCom instruction set

* Module:        error.cpp

* Description:

* Standard procedure for error reporting to stderr

*

* Copyright 2006-2021 GNU General Public License http://www.gnu.org/licenses

******************************************************************************

You may set breakpoints here to trace errors (use stack trace)

Runtime errors during emulation are not going here, but to

CThread::interrupt in emulator6.cpp

*****************************************************************************/

#include "stdafx.h"

// Make and initialize error reporter object

CErrorReporter err;

// General error messages

// to do: remove unused error messages!

SErrorText errorTexts[] = {

    // Unknown error

    {0,    2, "Unknown error!"},

    // Warning messages

    {ERR_EMPTY_OPTION, 1, "Empty command line option"},

    {ERR_UNKNOWN_OPTION, 2, "Unknown command line option: %s"},

    {ERR_UNKNOWN_ERROR_NUM, 1, "Unknown warning/error number: %i"},

    {ERR_OUTFILE_IGNORED, 1, "Output file name ignored"},

    {ERR_MEMBER_NOT_FOUND_EXTRACT, 1, "Library member %s not found. Extraction failed"},

    {ERR_MEMBER_NOT_FOUND_DEL, 1, "Library member %s not found. Deletion failed"},

    {ERR_DUPLICATE_NAME_COMMANDL, 1, "Library member %s specified more than once"}, // duplicate name on command line

    {ERR_DUPLICATE_NAME_IN_LIB, 1, "Library has more than one members named %s"}, // duplicate name in library

    {ERR_DUPLICATE_SYMBOL_IN_LIB, 1, "More than one symbol named %s in modules %s"}, // duplicate symbol in library

    {ERR_NO_SYMTAB_IN_LIB, 2, "No ForwardCom symbol table found in library"}, // probably wrong library type

    {ERR_ABS_RELOCATION_WARN, 1, "Code at line %i is position dependent because it contains absolute address of symbol: %s"}, // warn if absolute address

    {ERR_LIBRARY_FILE_TYPE, 2, "Library file has wrong type: %s"}, // expecting library file

    {ERR_LIBRARY_FILE_CORRUPT, 2, "Library file is corrupt"}, // index out of range in library file

    {ERR_LIBRARY_LIST_ONLY, 2, "Library list command cannnot be combined with other commands"}, // conflicting commands

    {ERR_LIBRARY_MEMBER_TYPE, 2, "Library member %s has wrong type: %s"}, // expecting ForwardCom object file

    {ERR_LINK_LIST_ONLY, 2, "Linker list command cannnot be combined with other commands"}, // conflicting commands

    {ERR_LINK_FILE_TYPE, 2, "Wrong file type. Expecting ForwardCom object file: %s"}, // wrong file type to linker

    {ERR_LINK_FILE_TYPE_LIB, 2, "Wrong file type. Expecting ForwardCom library file: %s"}, // wrong file type to linker

    {ERR_LINK_FILE_TYPE_EXE, 2, "Wrong file type. Expecting ForwardCom executable file: %s"}, // wrong file type to emulator

    {ERR_LINK_COMMUNAL, 1, "Communal section %s has different sizes in modules %s"}, // communal sections not identical

    {ERR_LINK_DUPLICATE_SYMBOL, 1, "More than one symbol named %s in modules %s"}, // duplicate symbol encountered during linking

    {ERR_LINK_DIFFERENT_BASE, 2, "Link source and target use different base pointers. Cannot link from module %s to symbol %s in module %s"}, // link source and target use different base pointers

    {ERR_LINK_MISALIGNED_TARGET, 2, "Link target is misaligned. Scaling failed when linking from module %s to symbol %s in module %s"}, // link target alignment does not fit scale factor

    {ERR_LINK_OVERFLOW, 2, "Address overflow when linking from module %s to symbol %s in module %s"}, // relocation overflow

    {ERR_LINK_RELOCATION_OVERFLOW, 2, "Address overflow when linking to symbol %s"}, // relocation overflow    

    {ERR_LINK_REGUSE, 2, "Mismatched register use when linking from module %s to symbol %s. Missing registers: %s"}, // register use mismatch

    {ERR_LINK_MODULE_NOT_FOUND, 2, "Module %s not found in library %s"}, // cannot find explicitly specified library module

    {ERR_EVENT_SIZE, 1, "Wrong size of event handler records in module %s"}, // event section size not divisible by event record size

    {ERR_REL_SYMBOL_NOT_FOUND, 2, "Relocated symbol not found"}, // relocation failed. should not occur

    {ERR_CANT_RELINK_MODULE, 2, "Module %s is not relinkable. Cannot remove or replace"}, // attempt to delete or replace non-relinkable module

    {ERR_CANT_RELINK_LIBRARY, 2, "Library %s is not relinkable. Cannot remove or replace"}, // attempt to delete or replace non-relinkable library

    {ERR_RELINK_MODULE_NOT_FOUND, 1, "Module %s not found in input file. Cannot remove or replace"}, // attempt to delete or replace non-existing module

    {ERR_RELINK_LIBRARY_NOT_FOUND, 1, "Library %s not found in input file. Cannot remove or replace"}, // attempt to delete or replace non-existing library

    {ERR_RELINK_BASE_POINTER_MOD, 2, "Base pointer overridden during relinking. Relative addresses may be wrong"}, // base pointer has been overridden during relinking

    {ERR_INPUT_NOT_RELINKABLE, 2, "File %s is not relinkable"}, // attempt to relink non-relinkable file

    {ERR_LINK_UNRESOLVED, 2, "Unresolved external symbol %s in module %s"}, // symbol not found in any module or library

    {ERR_LINK_UNRESOLVED_WARN, 1, "Unresolved external symbol %s in module %s"}, // symbol not found. warn only because incomplete output allowed

    // Error messages

    {ERR_MULTIPLE_IO_FILES, 2, "No more than one input file and one output file can be specified"}, //?

    {ERR_MULTIPLE_COMMANDS, 2, "More than one command specified on command line: %s"},

    {ERR_UNKNOWN_OPTION, 2, "Unknown command line option: %s"},

    {ERR_FILES_SAME_NAME, 2, "Input file and output file cannot have same name: %s"},

    {ERR_DUMP_NOT_SUPPORTED, 2, "Sorry. Dump of file type %s is not supported"},

    {ERR_INDEX_OUT_OF_RANGE, 2, "Index out of range"},

    {ERR_ELF_RECORD_SIZE, 2, "Error in ELF file. Record size wrong"},

    {ERR_ELF_SYMTAB_MISSING, 2, "Symbol table not found in ELF file"},

    {ERR_ELF_INDEX_RANGE, 2, "Index out of range in object file"},

    {ERR_ELF_UNKNOWN_SECTION, 2, "Unknown section index in ELF file: %i"},

    {ERR_ELF_STRING_TABLE, 2, "String table corrupt"},

    {ERR_ELF_NO_SECTIONS, 2, "File with absolute constants must have at least one section, even if empty"},

    {ERR_CONTAINER_INDEX, 2, "Index out of range in internal container"},

    {ERR_CONTAINER_OVERFLOW, 2, "Overflow of internal container"},

    {ERR_INPUT_FILE, 2, "Cannot read input file %s"},

    {ERR_OUTPUT_FILE, 2, "Cannot write output file %s"},

    {ERR_UNKNOWN_FILE_TYPE, 2, "Unknown file type %i: %s"},

    {ERR_FILE_SIZE, 2, "Wrong size of file %s"},

    {ERR_TOO_MANY_RESP_FILES, 2, "Too many response files"},

    {ERR_FILE_NAME_LONG, 2, "File name %s too long"},

    {ERR_INSTRUCTION_LIST_SYNTAX, 2, "Syntax error in instruction list: %s"},

    {ERR_INSTRUCTION_LIST_QUOTE, 2, "Unmatched quote in instruction list, line %i"},  //?

    // Fatal errors makes the program stop immediately:

    {ERR_INTERNAL, 9, "Objconv program internal inconsistency"}, // table fault, etc.

    {ERR_TOO_MANY_ERRORS, 9, "Too many errors. Aborting"},

    {ERR_BIG_ENDIAN, 9, "This machine has big-endian memory organization or other incompatibility. Program cannot be compiled on this machine."},

    {ERR_MEMORY_ALLOCATION, 9, "Memory allocation failed"},

    // Mark end of list

    {9999, 9999, "End of error text list"}

};

// Error messages for assembly file

SErrorText assemErrorTexts[] = {

    // the status number indicates if an extra string is required

    {0,          0, "misplaced unknown token"},

    {TOK_NAM,    1, "unknown name: "},

    {TOK_LAB,    1, "misplaced label: "},

    {TOK_VAR,    1, "misplaced variable: "},

    {TOK_SEC,    1, "misplaced section name: "},

    {TOK_INS,    1, "misplaced instruction: "},

    {TOK_OPR,    1, "misplaced operator: "},

    {TOK_NUM,    1, "misplaced number: "},

    {TOK_FLT,    1, "misplaced floating point number: "},

    {TOK_CHA,    1, "misplaced character constant: "},

    {TOK_STR,    1, "misplaced string: "},

    {TOK_DIR,    1, "misplaced directive: "},

    {TOK_ATT,    1, "misplaced attribute: "},

    {TOK_TYP,    1, "misplaced type name: "},

    {TOK_OPT,    1, "misplaced option: "},

    {TOK_REG,    1, "misplaced register: "},

    {TOK_SYM,    1, "misplaced symbol: "},

    {TOK_XPR,    1, "misplaced expression: "},

    {TOK_HLL,    1, "misplaced keyword: "},

    {ERR_CONTROL_CHAR,       1, "illegal control character: "},

    {ERR_ILLEGAL_CHAR,       1, "illegal character: "},

    {ERR_COMMENT_BEGIN,      0, "unmatched comment begin: /*"},

    {ERR_COMMENT_END,        0, "unmatched comment end: */"},

    {ERR_BRACKET_BEGIN,      1, "unmatched begin bracket: "},

    {ERR_BRACKET_END,        1, "unmatched end bracket: "},

    {ERR_QUOTE_BEGIN,        1, "unmatched begin quote: "},

    {ERR_QUESTION_MARK,      0, "unmatched '?'"},

    {ERR_COLON,              0, "unmatched ':'"},

    {ERR_SYMBOL_DEFINED,     1, "symbol already defined, cannot redefine: "},

    {ERR_SYMBOL_UNDEFINED,   1, "symbol not defined: "},

    {ERR_MULTIDIMENSIONAL,   1, "multidimensional array not allowed: "},

    {ERR_UNFINISHED_VAR,     1, "unfinished variable declaration: "},

    {ERR_MISSING_EXPR,       1, "expecting expression: "},

    {ERR_CONFLICT_ARRAYSZ,   1, "conflicting array size: "},

    {ERR_CONFLICT_TYPE,      1, "conflicting type of symbol: "},

    {ERR_CONDITION,          1, "expression cannot be used for condition: "},

    {ERR_OVERFLOW,           1, "expression overflow: "},

    {ERR_WRONG_TYPE,         1, "wrong operand type for operator: "},

    {ERR_WRONG_TYPE_VAR,     1, "wrong or mismatched type for variable (must be int64, double, string, register, or memory operand): "},

    {ERR_WRONG_OPERANDS,     1, "wrong operands for this instruction: "},

    {ERR_MISSING_DESTINATION,1, "this instruction needs a destination: "},

    {ERR_NO_DESTINATION,     1, "this instruction should not have a destination: "},

    {ERR_NOT_OP_AMBIGUOUS,   0, "'!' operator is ambiguous. For booleans and masks replace !A by A^1. For numeric operands replace !A by A==0"},

    {ERR_TOO_COMPLEX,        1, "expression does not fit into a single instruction: "},

    {ERR_MASK_NOT_REGISTER,  1, "mask must be a register: "},

    {ERR_FALLBACK_WRONG,     1, "fallback must be a register 0-30 or zero: "},

    {ERR_CONSTANT_TOO_LARGE, 1, "constant too large for specified type: "},

    {ERR_ALIGNMENT,          1, "alignment must be a power of 2, not higher than 4096: "},  // maximum alignment value must equal MAX_ALIGN in assem.h

    {ERR_SECTION_DIFFERENT_TYPE,1, "redefinition of section is different type: "},

    {ERR_EXPECT_COLON,       1, "expecting colon after label: "},

    {ERR_STRING_TYPE,        1, "string must have type int8: "},

    {ERR_NONZERO_IN_BSS,     1, "data in uninitialized section must be zero: "},

    {ERR_SYMBOL_REDEFINED,   1, "symbol has been assigned more than one value: "},

    {ERR_EXPORT_EXPRESSION,  1, "cannot export expression: "},

    {ERR_CANNOT_EXPORT,      1, "cannot export: "},

    {ERR_CODE_WO_SECTION,    1, "code without section: "},

    {ERR_DATA_WO_SECTION,    1, "data without section: "},

    {ERR_MIX_DATA_AND_CODE,  1, "code and data in same section: "},

    {ERR_MUST_BE_CONSTANT,   1, "value must be constant: "},

    {ERR_MEM_COMPONENT_TWICE,1, "component of memory operand specified twice: "},

    {ERR_SCALE_FACTOR,       1, "wrong scale factor for this instruction: "},

    {ERR_MUST_BE_GP,         1, "vector length must be general purpose register: "},

    {ERR_LIMIT_AND_OFFSET,   1, "memory operand cannot have both limit and offset: "},

    {ERR_NOT_INSIDE_MEM,     1, "this option is not allowed inside memory operand: "},

    {ERR_TOO_MANY_OPERANDS,  1, "too many operands: "},

    {ERR_TOO_FEW_OPERANDS,   1, "not enough operands: "},

    {ERR_OPERANDS_WRONG_ORDER,1, "operands in wrong order. register operands must come first: "},

    {ERR_BOTH_MEM_AND_IMMEDIATE, 1, "this instruction cannot have both a memory operand and immediate constant: "},  // except store in format 2.7B and VARIANT_M1

    {ERR_BOTH_MEM_AND_OPTIONS, 1, "this instruction cannot have both a memory operand and options: "},

    {ERR_UNFINISHED_INSTRUCTION,  1, "unfinished instruction: "},

    {ERR_TYPE_MISSING,       1, "type must be specified: "},

    {ERR_MASK_FALLBACK_TYPE, 0, "mask and fallback must have same register type as destination"},

    {ERR_NEG_INDEX_LENGTH,   0, "length register must be the same as negative index register"},

    {ERR_INDEX_AND_LENGTH,   0, "memory operand cannot have length or broadcast with positive index"},

    {ERR_MASK_REGISTER,      0, "mask must be register 0-6"},

    {ERR_LIMIT_TOO_HIGH,     1, "limit on memory index cannot exceed 0xFFFF: "},

    {ERR_NO_INSTRUCTION_FIT, 1, "no version of this instruction fits the specified operands: "},

    {ERR_CANNOT_SWAP_VECT,   0, "cannot change the order of vector registers. if the vectors have the same length then put the register operands before the constant or memory operand"},

    {ERR_EXPECT_JUMP_TARGET, 1, "expecting jump target: "},

    {ERR_JUMP_TARGET_MISALIGN, 1, "jump target offset must be divisible by 4: "},

    {ERR_ABS_RELOCATION,     1, "absolute address not possible here: "},

    {ERR_RELOCATION_DOMAIN,  1, "cannot calculate difference between two symbols in different domains: "},

    {ERR_WRONG_REG_TYPE,     1, "wrong type for register operand: "},

    {ERR_CONFLICT_OPTIONS,   1, "conflicting options: "},

    {ERR_VECTOR_OPTION,      1, "vector option applied to non-vector operands: "},

    {ERR_LENGTH_OPTION_MISS, 1, "vector memory operand must have scalar, length, or broadcast option: "},

    {ERR_DEST_BROADCAST,     0, "memory destination cannot have broadcast"},

    {ERR_OFFSET_TOO_LARGE,   1, "address offset too large: "},

    {ERR_LIMIT_TOO_LARGE,    1, "limit too large: "},

    {ERR_IMMEDIATE_TOO_LARGE,1, "instruction format does not have space for full-size constant and option/signbits: "},

    {ERR_TOO_LARGE_FOR_JUMP, 1, "conditional jump does not have space for 64-bit constant: "},

    {ERR_CANNOT_HAVE_OPTION, 1, "this instruction cannot have options: "},

    {ERR_CANNOT_HAVEFALLBACK1, 1, "this instruction cannot have a fallback register: "},

    {ERR_CANNOT_HAVEFALLBACK2, 1, "the fallback must be the same as the first source operand when there is a memory operand with index or vector: "},

    {ERR_3OP_AND_FALLBACK,   1, "the fallback must be the same as the first source operand on instructions with three operands: "},

    {ERR_3OP_AND_MEM,        1, "the first source register must be the same as the destination when there is a memory operand with index or vector: "},

    {ERR_R28_30_BASE,        1, "cannot use r28-r30 as base pointer with more than 8 bits offset: "},

    {ERR_NO_BASE,            1, "memory operand has no base pointer: "},

    {ERR_MEM_WO_BRACKET,     1, "memory operand requires [] bracket: "},

    {ERR_UNKNOWN,            1, "unknown assembly error"},

    {ERR_UNMATCHED_END,      0, "unmatched end"},

    {ERR_SECTION_MISS_END,   1, "missing end of section: "},

    {ERR_FUNCTION_MISS_END,  1, "missing end of function: "},

    {ERR_ELSE_WO_IF,         1, "else without if: "},

    {ERR_EXPECT_PARENTHESIS, 1, "expecting parenthesis: "},

    {ERR_EXPECT_BRACKET,     1, "expecting '{' bracket: "},

    {ERR_EXPECT_LOGICAL,     1, "expecting logical expression: "},

    {ERR_MEM_NOT_ALLOWED,    1, "cannot have memory operand: "},

    //{ERR_MUST_BE_POW2,       1, "constant must have only one bit set: "},

    {ERR_WHILE_EXPECTED,     1, "'do' statement requires a 'while' here: "},

    {ERR_MISPLACED_BREAK,    1, "nothing: to break out of: "},

    {ERR_MISPLACED_CONTINUE, 1, "no loop to continue: "}

};

// buffer for text strings (this cannot be member of CMemoryBuffer because CErrorReporter must be defined before CMemoryBuffer)

static CMemoryBuffer strings;

// Members of class CErrorReporter: reporting of general errors

// Constructor for CErrorReporter

CErrorReporter::CErrorReporter() {

    numErrors = numWarnings = worstError = 0;

    maxWarnings = 50;      // Max number of warning messages to pring

    maxErrors = 50;      // Max number of error messages to print

}

SErrorText * CErrorReporter::FindError(int ErrorNumber) {

    // Search for error in ErrorTexts

    int e;

    const int ErrorTextsLength = sizeof(errorTexts) / sizeof(errorTexts[0]);

    for (e = 0; e < ErrorTextsLength; e++) {

        if (errorTexts[e].errorNumber == ErrorNumber) return errorTexts + e;

    }

    // Error number not found

    static SErrorText UnknownErr = errorTexts[0];

    UnknownErr.errorNumber = ErrorNumber;

    UnknownErr.status = 0x102;  // Unknown error

    return &UnknownErr;

}

void CErrorReporter::submit(int ErrorNumber) {

    // Print error message with no extra info

    SErrorText * err = FindError(ErrorNumber);

    handleError(err, err->text);

}

void CErrorReporter::submit(int ErrorNumber, int extra) {

    // Print error message with extra numeric info

    // ErrorTexts[ErrorNumber] must contain %i where extra is to be inserted

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + 10);

    sprintf((char*)strings.buf(), err->text, extra);

    handleError(err, (char*)strings.buf());

}

void CErrorReporter::submit(int ErrorNumber, int extra1, int extra2) {

    // Print error message with 2 extra numeric values inserted

    // ErrorTexts[ErrorNumber] must contain two %i fields where extra numbers are to be inserted

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + 20);

    sprintf((char*)strings.buf(), err->text, extra1, extra2);

    handleError(err, (char*)strings.buf());

}

void CErrorReporter::submit(int ErrorNumber, char const * extra) {

    // Print error message with extra text info

    // ErrorTexts[ErrorNumber] must contain %s where extra is to be inserted

    if (extra == 0) extra = "???";

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + (uint32_t)strlen(extra));

    sprintf((char*)strings.buf(), err->text, extra);

    handleError(err, (char*)strings.buf());

}

void CErrorReporter::submit(int ErrorNumber, char const * extra1, char const * extra2) {

    // Print error message with two extra text info fields

    // ErrorTexts[ErrorNumber] must contain %s where extra texts are to be inserted

    if (extra1 == 0) extra1 = "???";

    if (extra2 == 0) extra2 = "???";

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + (uint32_t)strlen(extra1) + (uint32_t)strlen(extra2));

    sprintf((char*)strings.buf(), err->text, extra1, extra2);

    handleError(err, (char*)strings.buf());

}

void CErrorReporter::submit(int ErrorNumber, char const * extra1, char const * extra2, char const * extra3) {

    // Print error message with three extra text info fields

    // ErrorTexts[ErrorNumber] must contain %s where extra texts are to be inserted

    if (extra1 == 0) extra1 = "???";

    if (extra2 == 0) extra2 = "???";

    if (extra3 == 0) extra3 = "???";

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + (uint32_t)strlen(extra1) + (uint32_t)strlen(extra2) + (uint32_t)strlen(extra3));

    sprintf((char*)strings.buf(), err->text, extra1, extra2, extra3);

    handleError(err, (char*)strings.buf());

}

void CErrorReporter::submit(int ErrorNumber, int extra1, char const * extra2) {

    // Print error message with two extra text fields inserted

    // ErrorTexts[ErrorNumber] must contain %i and %s where extra texts are to be inserted

    if (extra2 == 0) extra2 = "???";

    SErrorText * err = FindError(ErrorNumber);

    strings.setSize((uint32_t)strlen(err->text) + 10 + (uint32_t)strlen(extra2));

    sprintf((char*)strings.buf(), err->text, extra1, extra2);

    handleError(err, (char*)strings.buf());

}

// Write an error message.

// To trace a runtime error message: set a breakpoint here !½

void CErrorReporter::handleError(SErrorText * err, char const * text) {

    // HandleError is used by submit functions

    // check severity

    int severity = err->status & 0x0F;

    if (severity == 0) {

        return;  // Ignore message

    }

    if (severity > 1 && err->errorNumber > worstError) {

        // Store highest error number

        worstError = err->errorNumber;

    }

    if (severity == 1) {

        // Treat message as warning

        if (++numWarnings > maxWarnings) return; // Maximum number of warnings has been printed

        // Treat message as warning

        fprintf(stderr, "\nWarning %i: %s", err->errorNumber, text);

        if (numWarnings == maxWarnings) {

            // Maximum number reached

            fprintf(stderr, "\nSupressing further warning messages");

        }

    }

    else {

        // Treat message as error

        if (++numErrors > maxErrors) return; // Maximum number of warnings has been printed

        fprintf(stderr, "\nError %i: %s", err->errorNumber, text);

        if (numErrors == maxErrors) {

            // Maximum number reached

            fprintf(stderr, "\nSupressing further warning messages");

        }

    }

    if (severity == 9) {

        // Abortion required

        fprintf(stderr, "\nAborting\n");

        exit(err->errorNumber);

    }

}

int CErrorReporter::number() {

    // Get number of fatal errors

    return numErrors;

}

int CErrorReporter::getWorstError() {

    // Get highest warning or error number encountered

    return worstError;

}

void CErrorReporter::clearError(int ErrorNumber) {

    // Ignore further occurrences of this error

    int e;

    const int ErrorTextsLength = sizeof(errorTexts) / sizeof(errorTexts[0]);

    for (e = 0; e < ErrorTextsLength; e++) {

        if (errorTexts[e].errorNumber == ErrorNumber) break;

    }

    if (e < ErrorTextsLength) {

        errorTexts[e].status = 0;

    }

}

// Members of class CAssemErrors: reporting of errors in assembly file

CAssemErrors::CAssemErrors() {                   // Constructor

    maxErrors = cmd.maxErrors;

}

void CAssemErrors::setOwner(CAssembler * a) {

    // Give access to CAssembler

    owner = a;

}

uint32_t CAssemErrors::numErrors() {

    // Return number of errors

    return list.numEntries();

}

bool CAssemErrors::tooMany() {

    // true if too many errors

    return list.numEntries() >= maxErrors;

}

// Report an error in assembly file

// To trace an assembly error: set a breakpoint here ½

void CAssemErrors::report(uint32_t position, uint32_t stringLength, uint32_t num) {

    // position: position in input file

    // stringLength: length of token

    // num = index into assemErrorTexts or token type

    owner->lineError = true;                         // avoid reporting multiple errors on same line

    uint32_t linei = owner->linei;

    if (linei < owner->lines.numEntries()) {

        owner->lines[owner->linei].type = LINE_ERROR;    // mark current line as error

    }

    if (tooMany()) return;

    SAssemError e;

    e.pos = position;

    e.stringLength = stringLength;

    e.file = owner->filei;

    e.num = num;

    e.pass = owner->pass;

    // save error record

    list.push(e);

}

// Report a misplaced token

void CAssemErrors::report(SToken const & token) {

    report(token.pos, token.stringLength, token.type);

}

// Report an error in current line

void CAssemErrors::reportLine(uint32_t num) {

    int tokenB = owner->lines[owner->linei].firstToken;

    int tokenN = owner->lines[owner->linei].numTokens;

    if (tokenB <= 0 || tokenN <= 0) {

        num = ERR_UNKNOWN;

        tokenB = 0;

        tokenN = 1;

    }

    report(owner->tokens[tokenB].pos,

        owner->tokens[tokenB + tokenN - 1].pos + owner->tokens[tokenB + tokenN - 1].stringLength - owner->tokens[tokenB].pos, num);

}

void CAssemErrors::outputErrors() {

    // Output errors to STDERR

    const uint32_t tabstops = 8;                      // default position of tabstops

    if (list.numEntries() == 0) return;

    const char * text1;

    char text2[256];

    const char * filename = cmd.getFilename(cmd.inputFile); // owner->fileName; // to do: support include filenames

    const uint32_t errorTextsLength = TableSize(assemErrorTexts);

    uint32_t i, j, texti;

    uint32_t lastPass = 0;

    for (i = 0; i < list.numEntries() && i < maxErrors; i++) {

        // tell which pass if verbose option

        if (list[i].pass != lastPass && cmd.verbose) {

            printf("\n\nDuring pass %i:", list[i].pass);

            lastPass = list[i].pass;

        }

        // find line containing error

        uint32_t line;

        uint32_t numLines = owner->lines.numEntries();

        uint32_t pos = list[i].pos;

        for (line = 0; line < numLines; line++) {

            if (pos < owner->lines[line].beginPos) break;

        }

        line--;

        // if this line has multiple records in lines[] then find the first one

        j = line;

        while (j > 0 && owner->lines[j - 1].linenum == owner->lines[line].linenum) j--;

        line = j;

        // find column

        uint32_t pos1 = owner->lines[line].beginPos;

        uint32_t stringLength = list[i].stringLength;

        uint32_t column = pos - pos1;

        // count UTF-8 multibyte characters in line up to error position

        int32_t extraBytes = 0;

        int8_t c;   // current character

        for (uint32_t pp = pos1; pp < pos1 + column; pp++) {

            if (pp >= owner->dataSize()) break;

            c = *(owner->buf() + pp);

            if ((c & 0xC0) == 0xC0) extraBytes--;   // count UTF-8 continuation bytes

            if (c == '\t') {

                uint32_t pos2 = (pp + tabstops) % tabstops;  // find next tabstop

                extraBytes += pos2 - pp - 1;

            }

        }

        // adjust column number to 1-based. count UTF-8 characters as one

        column += extraBytes + 1;

        // find text

        texti = list[i].num;

        for (j = 0; j < errorTextsLength; j++) {

            if ((uint32_t)assemErrorTexts[j].errorNumber == texti) break;

        }

        if (j >= errorTextsLength) j = 0;

        text1 = assemErrorTexts[j].text;

        if (assemErrorTexts[j].status && stringLength < sizeof(text2)) {

            // extra text required

            memcpy(text2, owner->buf() + pos, stringLength);

            text2[stringLength] = 0;

        }

        else text2[0] = 0;

        if (filename) {

            fprintf(stderr, "\n%s:", filename);

        }

        else {

            fprintf(stderr, "\n");

        }

        fprintf(stderr, "%i:%i: %s%s", owner->lines[line].linenum, column, text1, text2);

    }

}