static char RCSid[] =

"$Header$";

#endif

/* 

 *   Copyright (c) 2000, 2002 Michael J. Roberts.  All Rights Reserved.

 *   

 *   Please see the accompanying license file, LICENSE.TXT, for information

 *   on using and copying this software.  

 */

/*

Name

  vmerrmsg.cpp - T3 VM error message strings

Function

  Defines the message text for VM errors.  All error text is isolated into

  this module for easy replacement in translated versions.

Notes

Modified

  05/13/00 MJRoberts  - Creation

*/

#include <stdarg.h>

#include <stdlib.h>

#include "t3std.h"

#include "vmerr.h"

/* ------------------------------------------------------------------------ */

/*

 *   Enable or disable verbose messages.  To conserve memory, verbose

 *   messages can be omitted.  To omit verbose messages, the platform

 *   makefile should define the preprocessor symbol VMERR_OMIT_VERBOSE. 

 */

#ifdef VMERR_OMIT_VERBOSE

# define VMsg(msg) ""

#else

# define VMsg(msg) msg

#endif

#ifdef VMERR_BOOK_MSG

# define VBook(msg) , msg

#else

# define VBook(msg) 

#endif

/*

 *   To conserve even more memory, the messages can be omitted entirely.  To

 *   disable all compiled-in messages, define VMERR_OMIT_MESSAGES. 

 */

/* ------------------------------------------------------------------------ */

/*

 *   T3 VM Error Messages 

 *   

 *   The messages must be sorted by message number, so that we can perform

 *   a binary search to look up a message by number.  

 */

const err_msg_t vm_messages_english[] =

{

#ifdef VMERR_OMIT_MESSAGES

    { 0, 0, 0  VBook(0) }

#else /* VMERR_OMIT_MESSAGES */

    { VMERR_READ_FILE,

    "error reading file",

    VMsg("Error reading file.  The file might be corrupted or a media error "

         "might have occurred.") },

    { VMERR_WRITE_FILE,

    "error writing file",

    VMsg("Error writing file.  The media might be full, or another media "

         "error might have occurred.") },

    { VMERR_FILE_NOT_FOUND,

    "file not found",

    VMsg("Error opening file.  The specified file might not exist, you "

         "might not have sufficient privileges to open the file, or "

         "a sharing violation might have occurred.") },

    { VMERR_CREATE_FILE,

    "error creating file",

    VMsg("Error creating file.  You might not have sufficient privileges "

         "to open the file, or a sharing violation might have occurred.") },

    { VMERR_OBJ_IN_USE,

    "object ID in use - the image/save file might be corrupted",

    VMsg("An object ID requested by the image/save file is already in use "

         "and cannot be allocated to the file.  This might indicate that "

         "the file is corrupted.") },

    { VMERR_OUT_OF_MEMORY,

    "out of memory",

    VMsg("Out of memory.  Try making more memory available by closing "

         "other applications if possible.") },

    { VMERR_NO_MEM_FOR_PAGE,

    "out of memory allocating pool page",

    VMsg("Out of memory allocating pool page.  Try making more memory "

         "available by closing other applications.") },

    { VMERR_BAD_POOL_PAGE_SIZE,

    "invalid page size - file is not valid",

    VMsg("Invalid page size.  The file being loaded is not valid.") },

    { VMERR_OUT_OF_PROPIDS,

    "no more property ID's are available",

    VMsg("Out of property ID's.  No more properties can be allocated.") },

    { VMERR_CIRCULAR_INIT,

    "circular initialization dependency in intrinsic class (internal error)",

    VMsg("Circular initialization dependency detected in intrinsic class.  "

         "This indicates an internal error in the interpreter.  Please "

         "report this error to the interpreter's maintainer.") },

    { VMERR_UNKNOWN_METACLASS,

    "this interpreter version cannot run this program (program requires "

    "intrinsic class %s, which is not available in this interpreter)",

    VMsg("This image file requires an intrinsic class with the identifier "

         "\"%s\", but the class is not available in this interpreter.  This "

         "program cannot be executed with this interpreter.") },

    { VMERR_UNKNOWN_FUNC_SET,

    "this interpreter version cannot run this program (program requires "

    "intrinsic function set %s, which is not available in this interpreter)",

    VMsg("This image file requires a function set with the identifier "

         "\"%s\", but the function set is not available in this "

         "intepreter.  This program cannot be executed with this "

         "interpreter.") },

    { VMERR_READ_PAST_IMG_END,

    "reading past end of image file - program might be corrupted",

    VMsg("Reading past end of image file.  The image file might "

         "be corrupted.") },

    { VMERR_NOT_AN_IMAGE_FILE,

    "this is not an image file (no valid signature found)",

    VMsg("This file is not a valid image file - the file has an invalid "

         "signature.  The image file might be corrupted.") },

    { VMERR_UNKNOWN_IMAGE_BLOCK,

    "this interpreter version cannot run this program (unknown block type "

    "in image file)",

    VMsg("Unknown block type.  This image file is either incompatible with "

         "this version of the interpreter, or has been corrupted.") },

    { VMERR_IMAGE_BLOCK_TOO_SMALL,

    "data block too small",

    VMsg("A data block in the image file is too small.  The image file might "

         "be corrupted.") },

    { VMERR_IMAGE_POOL_BEFORE_DEF,

    "invalid image file: pool page before pool definition",

    VMsg("This image file is invalid because it specifies a pool page "

         "before the pool's definition.  The image file might be "

         "corrupted.") },

    { VMERR_IMAGE_POOL_BAD_PAGE,

    "invalid image file: pool page out of range of definition",

    VMsg("This image file is invalid because it specifies a pool page "

         "outside of the range of the pool's definition.  The image file "

         "might be corrupted.") },

    { VMERR_IMAGE_BAD_POOL_ID,

    "invalid image file: invalid pool ID",

    VMsg("This image file is invalid because it specifies an invalid "

         "pool ID.  The image file might be corrupted.") },

    { VMERR_LOAD_BAD_PAGE_IDX,

    "invalid image file: bad page index",

    VMsg("This image file is invalid because it specifies an invalid "

         "page index.  The image file might be corrupted.") },

    { VMERR_LOAD_UNDEF_PAGE,

    "loading undefined pool page",

    VMsg("The program is attempting to load a pool page that is not present "

         "in the image file.  The image file might be corrupted.") },

    { VMERR_IMAGE_POOL_REDEF,

    "invalid image file: pool is defined more than once",

    VMsg("This image file is invalid because it defines a pool more than "

         "once.  The image file might be corrupted.") },

    { VMERR_IMAGE_METADEP_REDEF,

    "invalid image file: multiple intrinsic class dependency tables found",

    VMsg("This image file is invalid because it contains multiple "

         "intrinsic class tables.  The image file might be corrupted.") },

    { VMERR_IMAGE_NO_METADEP,

    "invalid image file: no intrinsic class dependency table found",

    VMsg("This image file is invalid because it contains no intrinsic class "

         "tables.  The image file might be corrupted.") },

    { VMERR_IMAGE_FUNCDEP_REDEF,

    "invalid image file: multiple function set dependency tables found",

    VMsg("This image file is invalid because it contains multiple "

         "function set tables.  The image file might be corrupted.") },

    { VMERR_IMAGE_NO_FUNCDEP,

    "invalid image file: no function set dependency table found",

    VMsg("This image file is invalid because it contains no function set "

         "tables.  The image file might be corrupted.") },

    { VMERR_IMAGE_ENTRYPT_REDEF,

    "invalid image file: multiple entrypoints found",

    VMsg("This image file is invalid because it contains multiple entrypoint "

         "definitions.  The image file might be corrupted.") },

    { VMERR_IMAGE_NO_ENTRYPT,

    "invalid image file: no entrypoint found",

    VMsg("This image file is invalid because it contains no entrypoint "

         "specification.  The image file might be corrupted.") },

    { VMERR_IMAGE_INCOMPAT_VSN,

    "incompatible image file format version",

    VMsg("This image file has an incompatible format version.  You must "

         "obtain a newer version of the interpreter to execute this "

         "program.") },

    { VMERR_IMAGE_NO_CODE,

    "image contains no code",

    VMsg("This image file contains no executable code.  The file might "

         "be corrupted.") },

    { VMERR_IMAGE_INCOMPAT_HDR_FMT,

    "incomptabile image file format: method header too old",

    VMsg("This image file has an incompatible method header format.  "

         "This is an older image file version which this interpreter "

         "does not support.") },

    { VMERR_UNAVAIL_INTRINSIC,

    "unavailable intrinsic function called (index %d in function set \"%s\")",

    VMsg("Unavailable intrinsic function called (the function is at "

         "index %d in function set \"%s\").  This function is not available "

         "in this version of the interpreter and cannot be called when "

         "running the program with this version.  This normally indicates "

         "that the \"preinit\" function, or code invoked by preinit, "

         "called an intrinsic that is invalid during compile-time "

         "pre-initialization.") },

    { VMERR_UNKNOWN_METACLASS_INTERNAL,

    "unknown internal intrinsic class ID %x",

    VMsg("Unknown internal intrinsic class ID %x.  This indicates an "

         "internal error in the interpreter.  Please report this error "

         "to the interpreter's maintainer.") },

    { VMERR_XOR_MASK_BAD_IN_MEM,

    "page mask is not allowed for in-memory image file",

    VMsg("This image file cannot be loaded from memory because it contains "

         "masked data.  Masked data is not valid with in-memory files.  "

         "This probably indicates that the program file was not installed "

         "properly; you must convert this program file for in-memory use "

         "before you can load the program with this version of the "

         "interpreter.") },

    { VMERR_NO_IMAGE_IN_EXE,

    "no embedded image file found in executable",

    VMsg("This executable does not contain an embedded image file.  The "

         "application might not be configured properly or might need to "

         "be rebuilt.  Re-install the application or obtain an updated "

         "version from the application's author.") },

    { VMERR_OBJ_SIZE_OVERFLOW,

    "object size exceeds hardware limits of this computer",

    VMsg("An object defined in this program file exceeds the hardware limits "

         "of this computer.  This program cannot be executed on this type "

         "of computer or operating system.  Contact the program's author "

         "for assistance.") },

    { VMERR_METACLASS_TOO_OLD,

    "this interpreter is too old to run this program (program requires "

    "intrinsic class version %s, interpreter provides version %s)",

    VMsg("This program needs the intrinsic class \"%s\".  This VM "

         "implementation does not provide a sufficiently recent version "

         "of this intrinsic class; the latest version available in this "

         "VM is \"%s\".  This program cannot run with this version of the "

         "VM; you must use a more recent version of the VM to execute this "

         "program.") },

    { VMERR_INVAL_METACLASS_DATA,

    "invalid intrinsic class data - image file may be corrupted",

    VMsg("Invalid data were detected in an intrinsic class.  This might "

         "indicate that the image file has been corrupted.  You might need "

         "to re-install the program.") },

    { VMERR_BAD_STATIC_NEW,

    "invalid object - class does not allow loading",

    VMsg("An object in the image file cannot be loaded because its class "

         "does not allow creation of objects of the class.  This usually "

         "means that the class is abstract and cannot be instantiated "

         "as a concrete object.") },

    { VMERR_FUNCSET_TOO_OLD,

    "this interpreter is too old to run this program (program requires "

    "function set version %s, interpreter provides version %s)",

     VMsg("This program needs the function set \"%s\".  This VM "

          "implementation does not provide a sufficiently recent version "

          "of this function set; the latest version available in this VM "

          "is \"%s\".  This program cannot run with this version of the "

          "VM; you must use a more recent version of the VM to execute "

          "this program.") },

    { VMERR_INVAL_EXPORT_TYPE,

    "exported symbol \"%s\" is of incorrect datatype",

    VMsg("The exported symbol \"%s\" is of the incorrect datatype.  Check "

         "the program and the library version.") },

    { VMERR_INVAL_IMAGE_MACRO,

    "invalid data in macro definitions in image file (error code %d)",

    VMsg("The image file contains invalid data in the macro symbols "

         "in the debugging records: macro loader error code %d.  This "

         "might indicate that the image file is corrupted.") },

    { VMERR_NO_MAINRESTORE,

    "this program is not capable of restoring a saved state on startup",

    VMsg("This program is not capable of restoring a saved state on "

         "startup.  To restore the saved state, you must run the program "

         "normally, then use the appropriate command or operation within "

         "the running program to restore the saved position file.") },

    { VMERR_IMAGE_INCOMPAT_VSN_DBG,

    "image file is incompatible with debugger - recompile the program",

    VMsg("This image file was created with a version of the compiler "

         "that is incompatible with this debugger.  Recompile the program "

         "with the compiler that's bundled with this debugger.  If no "

         "compiler is bundled, check the debugger release notes for "

         "information on which compiler to use. ") },

    { VMERR_INVALID_SETPROP,

    "property cannot be set for object",

    VMsg("Invalid property change - this property cannot be set for this "

         "object.  This normally indicates that the object is of a type "

         "that does not allow setting of properties at all, or at least "

         "of certain properties.  For example, a string object does not "

         "allow setting properties at all.") },

    { VMERR_NOT_SAVED_STATE,

    "file is not a valid saved state file",

    VMsg("This file is not a valid saved state file.  Either the file was "

         "not created as a saved state file, or its contents have been "

         "corrupted.") },

    { VMERR_WRONG_SAVED_STATE,

    "saved state is for a different program or a different version of "

        "this program",

        VMsg("This file does not contain saved state information for "

             "this program.  The file was saved by another program, or "

             "by a different version of this program; in either case, it "

             "cannot be restored with this version of this program.") },

    { VMERR_SAVED_META_TOO_LONG,

    "intrinsic class name in saved state file is too long",

    VMsg("An intrinsic class name in the saved state file is too long.  "

         "The file might be corrupted, or might have been saved by an "

         "incompatible version of the interpreter.") },

    { VMERR_SAVED_OBJ_ID_INVALID,

    "invalid object ID in saved state file",

    VMsg("The saved state file contains an invalid object ID.  The saved "

         "state file might be corrupted.") },

    { VMERR_BAD_SAVED_STATE,

    "saved state file is corrupted (incorrect checksum)",

    VMsg("The saved state file's checksum is invalid.  This usually "

         "indicates that the file has been corrupted (which could be "

         "due to a media error, modification by another application, "

         "or a file transfer that lost or changed data).") },

    { VMERR_BAD_SAVED_META_DATA,

    "invalid intrinsic class data in saved state file",

    VMsg("The saved state file contains intrinsic class data that "

         "is not valid.  This usually means that the file was saved "

         "with an incompatible version of the interpreter program.") },

    { VMERR_NO_STR_CONV,

    "cannot convert value to string",

    VMsg("This value cannot be converted to a string.") },

    { VMERR_CONV_BUF_OVF,

    "string conversion buffer overflow",

    VMsg("An internal buffer overflow occurred converting this value to "

         "a string.") },

    { VMERR_BAD_TYPE_ADD,

    "invalid datatypes for addition operator",

    VMsg("Invalid datatypes for addition operator.  The values being added "

         "cannot be combined in this manner.") },

    { VMERR_NUM_VAL_REQD,

    "numeric value required",

    VMsg("Invalid value type - a numeric value is required.") },

    { VMERR_INT_VAL_REQD,

    "integer value required",

    VMsg("Invalid value type - an integer value is required.") },

    { VMERR_NO_LOG_CONV,

    "cannot convert value to logical (true/nil)",

    VMsg("This value cannot be converted to a logical (true/nil) value.") },

    { VMERR_BAD_TYPE_SUB,

    "invalid datatypes for subtraction operator",

    VMsg("Invalid datatypes for subtraction operator.  The values used "

         "cannot be combined in this manner.") },

    { VMERR_DIVIDE_BY_ZERO,

    "division by zero",

    VMsg("Arithmetic error - Division by zero.") },

    { VMERR_INVALID_COMPARISON,

    "invalid comparison",

    VMsg("Invalid comparison - these values cannot be compared "

         "to one another.") },

    { VMERR_OBJ_VAL_REQD,

    "object value required",

    VMsg("An object value is required.") },

    { VMERR_PROPPTR_VAL_REQD,

    "property pointer required",

    VMsg("A property pointer value is required.") },

    { VMERR_LOG_VAL_REQD,

    "logical value required",

    VMsg("A logical (true/nil) value is required.") },

    { VMERR_FUNCPTR_VAL_REQD,

    "function pointer required",

    VMsg("A function pointer value is required.") },

    { VMERR_CANNOT_INDEX_TYPE,

    "invalid index operation - this type of value cannot be indexed",

    VMsg("This type of value cannot be indexed.") },

    { VMERR_INDEX_OUT_OF_RANGE,

    "index out of range",

    VMsg("The index value is out of range for the value being indexed (it is "

         "too low or too high).") },

    { VMERR_BAD_METACLASS_INDEX,

    "invalid intrinsic class index",

    VMsg("The intrinsic class index is out of range.  This probably "

         "indicates that the image file is corrupted.") },

    { VMERR_BAD_DYNAMIC_NEW,

    "invalid dynamic object creation (intrinsic class does not support NEW)",

    VMsg("This type of object cannot be dynamically created, because the "

           "intrinsic class does not support dynamic creation.") },

    { VMERR_OBJ_VAL_REQD_SC,

    "object value required for base class",

    VMsg("An object value must be specified for the base class of a dynamic "

         "object creation operation.  The superclass value is of a "

         "non-object type.") },

    { VMERR_STRING_VAL_REQD,

    "string value required",

    VMsg("A string value is required.") },

    { VMERR_LIST_VAL_REQD,

    "list value required",

    VMsg("A list value is required.") },

    { VMERR_DICT_NO_CONST,

    "list or string reference found in dictionary (entry \"%s\") - this "

        "dictionary cannot be saved in the image file",

     VMsg("A dictionary entry (for the string \"%s\") referred to a string "

          "or list value for its associated value data.  This dictionary "

          "cannot be stored in the image file, so the image file cannot "

          "be created.  Check dictionary word additions and ensure that "

          "only objects are added to the dictionary.") },

    { VMERR_INVAL_OBJ_TYPE,

    "invalid object type - cannot convert to required object type",

    VMsg("An object is not of the correct type.  The object specified "

         "cannot be converted to the required object type.") },

    { VMERR_NUM_OVERFLOW,

    "numeric overflow",

    VMsg("A numeric calculation overflowed the limits of the datatype.") },

    { VMERR_BAD_TYPE_MUL, 

    "invalid datatypes for multiplication operator",

    VMsg("Invalid datatypes for multiplication operator.  The values "

         "being added cannot be combined in this manner.") },

    { VMERR_BAD_TYPE_DIV, 

    "invalid datatypes for division operator",

    VMsg("Invalid datatypes for division operator.  The values being added "

         "cannot be combined in this manner.") },

    { VMERR_BAD_TYPE_NEG,

    "invalid datatype for arithmetic negation operator",

    VMsg("Invalid datatype for arithmetic negation operator.  The value "

         "cannot be negated.") },

    { VMERR_OUT_OF_RANGE,

    "value is out of range",

    VMsg("A value that was outside of the legal range of inputs was "

         "specified for a calculation.") },

    { VMERR_STR_TOO_LONG,

    "string is too long",

    VMsg("A string value is limited to 65535 bytes in length.  This "

         "string exceeds the length limit.") },

    { VMERR_LIST_TOO_LONG,

    "list too long",

    VMsg("A list value is limited to about 13100 elements.  This list "

         "exceeds the limit.") },

    { VMERR_TREE_TOO_DEEP_EQ,

    "maximum equality test/hash recursion depth exceeded",

    VMsg("This equality comparison or hash calculation is too complex and "

         "cannot be performed.  This usually indicates that a value "

         "contains circular references, such as a Vector that contains "

         "a reference to itself, or to another Vector that contains a "

         "reference to the first one.  This type of value cannot be "

         "compared for equality or used in a LookupTable.") },

    { VMERR_WRONG_NUM_OF_ARGS,

    "wrong number of arguments",

    VMsg("The wrong number of arguments was passed to a function or method "

         "in the invocation of the function or method.") },

    { VMERR_WRONG_NUM_OF_ARGS_CALLING,

    "argument mismatch calling %s - function definition is incorrect",

    VMsg("The number of arguments doesn't match the number expected "

         "calling %s.  Check the function or method and correct the "

         "number of parameters that it is declared to receive.") },

    { VMERR_NIL_DEREF,

    "nil object reference",

     VMsg("The value 'nil' was used to reference an object property.  Only "

          "valid object references can be used in property evaluations.") },

    { VMERR_CANNOT_CREATE_INST,

    "cannot create instance of object - object is not a class",

    VMsg("An instance of this object cannot be created, because this "

         "object is not a class.") },

    { VMERR_ILLEGAL_NEW,

    "cannot create instance - class does not allow dynamic construction",

    VMsg("An instance of this class cannot be created, because this class "

         "does not allow dynamic construction.") },

    { VMERR_INVALID_OPCODE,

    "invalid opcode - possible image file corruption",

    VMsg("Invalid instruction opcode - the image file might be corrupted.") },

    { VMERR_UNHANDLED_EXC,

    "unhandled exception",

    VMsg("An exception was thrown but was not caught by the program.  "

         "The interpreter is terminating execution of the program.") },

    { VMERR_STACK_OVERFLOW,

    "stack overflow",

    VMsg("Stack overflow.  This indicates that function or method calls "

         "were nested too deeply; this might have occurred because of "

         "unterminated recursion, which can happen when a function or method "

         "calls itself (either directly or indirectly).") },

    { VMERR_BAD_TYPE_BIF,

    "invalid type for intrinsic function argument",

    VMsg("An invalid datatype was provided for an intrinsic "

         "function argument.") },

    { VMERR_SAY_IS_NOT_DEFINED,

    "default output function is not defined",

    VMsg("The default output function is not defined.  Implicit string "

         "display is not allowed until a default output function "

         "is specified.") },

    { VMERR_BAD_VAL_BIF,

    "invalid value for intrinsic function argument",

    VMsg("An invalid value was specified for an intrinsic function argument.  "

         "The value is out of range or is not an allowed value.") },

    { VMERR_BREAKPOINT,

    "breakpoint encountered",

    VMsg("A breakpoint instruction was encountered, and no debugger is "

         "active.  The compiler might have inserted this breakpoint to "

         "indicate an invalid or unreachable location in the code, so "

         "executing this instruction probably indicates an error in the "

         "program.") },

    { VMERR_CALLEXT_NOT_IMPL,

    "external function calls are not implemented in this version",

    VMsg("This version of the interpreter does not implement external "

         "function calls.  This program requires an interpreter that "

         "provides external function call capabilities, so this program "

         "is not compatible with this interpreter.") },

    { VMERR_INVALID_OPCODE_MOD,

    "invalid opcode modifier - possible image file corruption",

    VMsg("Invalid instruction opcode modifier - the image file might "

         "be corrupted.") },

    /*

     *   Note - do NOT use the VMsg() macro on this message, since we always

     *   want to have this verbose message available. 

     */

    { VMERR_NO_CHARMAP_FILE,

    "No mapping file available for local character set \"%.32s\"",

    "[Warning: no mapping file is available for the local character set "

        "\"%.32s\".  The system will use a default ASCII character set "

        "mapping instead, so accented characters will be displayed without "

        "their accents.]" },

    { VMERR_UNHANDLED_EXC_PARAM,

    "Unhandled exception: %s",

    VMsg("Unhandled exception: %s") },

    { VMERR_VM_EXC_PARAM,

    "VM Error: %s",

    VMsg("VM Error: %s")

    VBook("This is used as a generic template for VM run-time "

    "exception messages.  The interpreter uses this to "

    "display unhandled exceptions that terminate the program.") },

    { VMERR_VM_EXC_CODE,

    "VM Error: code %d",

    VMsg("VM Error: code %d")

    VBook("This is used as a generic template for VM run-time "

    "exceptions.  The interpreter uses this to report unhandled "

    "exceptions that terminate the program.  When it can't find "

    "any message for the VM error code, the interpreter simply "

    "displays the error number using this template.") },

    { VMERR_EXC_IN_STATIC_INIT,

    "Exception in static initializer for %s.%s: %s",

    VMsg("An exception occurred in the static initializer for "

         "%s.%s: %s") },

    { VMERR_INTCLS_GENERAL_ERROR,

    "intrinsic class exception: %s",

    VMsg("Exception in intrinsic class method: %s") },

    { VMERR_DBG_ABORT,

    "'abort' signal",

    VMsg("'abort' signal")

    VBook("This exception is used internally by the debugger to "

    "signal program termination via the debugger UI.") },

    { VMERR_DBG_RESTART,

    "'restart' signal",

    VMsg("'restart' signal")

    VBook("This exception is used internally by the debugger to "

    "signal program restart via the debugger UI.") },

    { VMERR_BAD_FRAME,

    "invalid frame in debugger local/parameter evaluation",

    VMsg("An invalid stack frame was specified in a debugger local/parameter "

         "evaluation.  This probably indicates an internal problem in the "

         "debugger.") },

    { VMERR_BAD_SPEC_EVAL,

    "invalid speculative expression",

    VMsg("This expression cannot be executed speculatively.  (This does not "

         "indicate a problem; it's merely an internal condition in the "

         "debugger.)") },

    { VMERR_INVAL_DBG_EXPR,

    "invalid debugger expression",

    VMsg("This expression cannot be evaluated in the debugger.") },

    { VMERR_NO_IMAGE_DBG_INFO,

    "image file has no debugging information - recompile for debugging",

    VMsg("The image file has no debugging information.  You must recompile "

         "the source code for this program with debugging information in "

         "order to run the program under the debugger.") },

    { VMERR_BIGNUM_NO_REGS,

    "out of temporary floating point registers (calculation too complex)",

    VMsg("The interpreter is out of temporary floating point registers.  "

         "This probably indicates that an excessively complex calculation "

         "has been attempted.") }

#endif /* VMERR_OMIT_MESSAGES */

};

/* size of the english message array */

size_t vm_message_count_english =

    sizeof(vm_messages_english)/sizeof(vm_messages_english[0]);

/* 

 *   the actual message array - we'll initialize this to the

 *   english list that's linked in, but if we find an external message

 *   file, we'll use the external file instead 

 */

const err_msg_t *vm_messages = vm_messages_english;

/* message count - initialize to the english message array count */

size_t vm_message_count =

    sizeof(vm_messages_english)/sizeof(vm_messages_english[0]);

/* ------------------------------------------------------------------------ */

/*

 *   we don't need the VMsg() (verbose message) cover macro any more 

 */