/*
 * errtbl - calc computation error codes, symbols and messages
 *
 * This code is used to generate errsym.h and help/errorcodes.
 * This code also verifies the consistency of the error_table[] array.
 *
 * Copyright (C) 1999-2006,2021,2023,2026  Ernest Bowen and Landon Curt Noll
 *
 * Calc is open software; you can redistribute it and/or modify it under
 * the terms of the version 2.1 of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * Calc is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
 * Public License for more details.
 *
 * A copy of version 2.1 of the GNU Lesser General Public License is
 * distributed with calc under the filename COPYING-LGPL.  You should have
 * received a copy with calc; if not, write to Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * Under source code control:   1996/05/23 17:38:44
 * File existed as early as:    1996
 *
 * Share and enjoy!  :-)                http://www.isthe.com/chongo/tech/comp/calc/
 *
 * HISTORIC NOTE:
 *
 * This file was once called calcerr.tbl.  It once was a simple table of:
 *
 *              SYMBOL  meaning
 *
 *       until 2023 when the new calc computation error code system was introduced.
 */

/* special comments for the seqcexit tool */
/* exit code out of numerical order - ignore in sequencing - ooo */
/* exit code change of order - use new value in sequencing - coo */

/*
 * important <system> header includes
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <getopt.h>

/*
 * calc local src includes
 */
#include "value.h"
#include "label.h"
#include "func.h"
#include "attribute.h"
#include "errtbl.h"

#include "banned.h" /* include after all other includes */

/*
 * Copyright (C) year for generated files
 */
#define ERRTBL_COPYRIGHT_YEAR 2026

/*
 * number of calc computation error codes in the error_table[] array
 *
 * This count does NOT include the initial E__BASE entry NOR
 * the final NULL entry.
 */
#define MY_ECOUNT ((sizeof(error_table) / sizeof(error_table[0])) - 2)

/*
 * number of calc computation error codes in the private_error_alias[] array
 *
 * This count does NOT include the final NULL entry.
 */
#define MY_PRIV_ECOUNT ((sizeof(private_error_alias) / sizeof(private_error_alias[0])) - 1)

/* highest assigned calc computation error code */
#define MY_E__HIGHEST (E__BASE + MY_ECOUNT)

/*
 * errnum waiting to be replaced by E__HIGHEST
 *
 * The INV_ERRNUM must be < 0, AND != NULL_ERRNUM
 */
#define INV_ERRNUM (-2) /* errnum is waiting to be replaced by E__HIGHEST */

/************************************************************************/
/*                                                                      */
/*  WARNING: The order of ierror_table[] arrays critical!  If you       */
/*           change the order, you will break code that depends on the  */
/*           return value of the errno() builtin function.              */
/*                                                                      */
/*           When adding entries to this table add then just before     */
/*           the NULL pointer (* must be last *) entry.                 */
/*                                                                      */
/************************************************************************/

/*
 * The error_table[] array represents the calc computation error related
 * error codes, symbols and messages.
 *
 * The errnum of the 1st entry error_table[0] must be E__BASE.
 *
 * All errnum for the following entries just be consecutive,
 * except for the final NULL entry.
 *
 * The final entry must have an errnum of NULL_ERRNUM (-1),
 * errsym of NULL and errmsg of NULL.
 *
 * With exception to the 1st E__BASE entry, all other errsym strings
 * must match the following regular expression:
 *
 *      ^E_[A-Z][A-Z0-9_]+$
 *
 * NOTE: The above regular expression is more restrictive them the
 *       E_STRING regular expression from help/errno, help/error,
 *       and help/strerror.  This is because errsym strings that
 *       start with "E__" are special symbols that #define-d in errtbl.h,
 *       AND because errsym strings that are "^E_[0-9]+$" reserved for
 *       numeric aliases for errnum.
 *
 * If multiple computation error codes are needed for a similar purpose,
 * use E_STRING errsym codes followed by _digit(s).
 *
 * Keep the errmsg short enough that lines in this table are not too long.
 * You might want to keep the length of the errmsg to 80 characters or less.
 *
 * IMPORTANT NOTE:
 *
 * The list of errnum values in error_table[], and the consecutive values
 * starting from the 10000 (E__BASE) entry) is important to maintain for
 * compatibility.  DO NOT change the values of existing errnum codes once
 * a new code is released in a calc stable version.  If a different code
 * is needed, add a new code to the bottom (just above the final NULL entry).
 *
 * Starting with calc version 2.15 the E_STRING errsym values became visible
 * via the error, errno, errsym and strerror builtin interface.  DO NOT change
 * the existing E_STRING errsym codes once a new code is released in a calc
 * stable version.  If a different E_STRING errsym code is needed, add a new
 * entry to the bottom (just above the final NULL entry).
 *
 * These is NO requirement for the errmsg error message to be backward compatible.
 *
 * There is a convention that when a computation error code is no longer needed,
 * that the phrase: "UNUSED ERROR: " be prepended to the errmsg error message.
 * Do not remove such computation error codes, nor change their errnum values,
 * not change their E_STRING errsym codes.
 */
const struct errtbl error_table[] = {

    /* The E__BASE entry below must start with 10000 and must be first!! */
    {10000, "E__BASE", "No error"},
    {10001, "E_DIVBYZERO", "Division by zero"},
    {10002, "E_ZERODIVZERO", "Indeterminate (0/0)"},
    {10003, "E_ADD", "Bad arguments for +"},
    {10004, "E_SUB", "Bad arguments for binary -"},
    {10005, "E_MUL", "Bad arguments for *"},
    {10006, "E_DIV", "Bad arguments for /"},
    {10007, "E_NEG", "Bad argument for unary -"},
    {10008, "E_SQUARE", "Bad argument for squaring"},
    {10009, "E_INV", "Bad argument for inverse"},
    {10010, "E_INCV", "Bad argument for ++"},
    {10011, "E_DECV", "Bad argument for --"},
    {10012, "E_INT", "Bad argument for int"},
    {10013, "E_FRAC", "Bad argument for frac"},
    {10014, "E_CONJ", "Bad argument for conj"},
    {10015, "E_APPR_1", "Bad first argument for appr"},
    {10016, "E_APPR_2", "Bad second argument for appr"},
    {10017, "E_APPR_3", "Bad third argument for appr"},
    {10018, "E_ROUND_1", "Bad first argument for round"},
    {10019, "E_ROUND_2", "Bad second argument for round"},
    {10020, "E_ROUND_3", "Bad third argument for round"},
    {10021, "E_BROUND_1", "Bad first argument for bround"},
    {10022, "E_BROUND_2", "Bad second argument for bround"},
    {10023, "E_BROUND_3", "Bad third argument for bround"},
    {10024, "E_SQRT_1", "Bad first argument for sqrt"},
    {10025, "E_SQRT_2", "Bad second argument for sqrt"},
    {10026, "E_SQRT_3", "Bad third argument for sqrt"},
    {10027, "E_ROOT_1", "Bad first argument for root"},
    {10028, "E_ROOT_2", "Bad second argument for root"},
    {10029, "E_ROOT_3", "Bad third argument for root"},
    {10030, "E_NORM", "Bad argument for norm"},
    {10031, "E_SHIFT_1", "Bad first argument for << or >>"},
    {10032, "E_SHIFT_2", "Bad second argument for << or >>"},
    {10033, "E_SCALE_1", "Bad first argument for scale"},
    {10034, "E_SCALE_2", "Bad second argument for scale"},
    {10035, "E_POWI_1", "Bad first argument for ^"},
    {10036, "E_POWI_2", "Bad second argument for ^"},
    {10037, "E_POWER_1", "Bad first argument for power"},
    {10038, "E_POWER_2", "Bad second argument for power"},
    {10039, "E_POWER_3", "Bad third argument for power"},
    {10040, "E_QUO_1", "Bad first argument for quo or //"},
    {10041, "E_QUO_2", "Bad second argument for quo or //"},
    {10042, "E_QUO_3", "Bad third argument for quo"},
    {10043, "E_MOD_1", "Bad first argument for mod or %"},
    {10044, "E_MOD_2", "Bad second argument for mod or %"},
    {10045, "E_MOD_3", "Bad third argument for mod"},
    {10046, "E_SGN", "Bad argument for sgn"},
    {10047, "E_ABS_1", "Bad first argument for abs"},
    {10048, "E_ABS_2", "Bad second argument for abs"},
    {10049, "E_EVAL", "Scan error in argument for eval"},
    {10050, "E_STR", "Non-simple type for str"},
    {10051, "E_EXP_1", "Non-real epsilon for exp"},
    {10052, "E_EXP_2", "Bad first argument for exp"},
    {10053, "E_FPUTC_1", "Non-file first argument for fputc"},
    {10054, "E_FPUTC_2", "Bad second argument for fputc"},
    {10055, "E_FPUTC_3", "File not open for writing for fputc"},
    {10056, "E_FGETC_1", "Non-file first argument for fgetc"},
    {10057, "E_FGETC_2", "File not open for reading for fgetc"},
    {10058, "E_FOPEN_1", "Non-string arguments for fopen"},
    {10059, "E_FOPEN_2", "Unrecognized mode for fopen"},
    {10060, "E_FREOPEN_1", "Non-file first argument for freopen"},
    {10061, "E_FREOPEN_2", "Non-string or unrecognized mode for freopen"},
    {10062, "E_FREOPEN_3", "Non-string third argument for freopen"},
    {10063, "E_FCLOSE_1", "Non-file argument for fclose"},
    {10064, "E_FFLUSH", "Non-file argument for fflush"},
    {10065, "E_FPUTS_1", "Non-file first argument for fputs"},
    {10066, "E_FPUTS_2", "Non-string argument after first for fputs"},
    {10067, "E_FPUTS_3", "File not open for writing for fputs"},
    {10068, "E_FGETS_1", "Non-file argument for fgets"},
    {10069, "E_FGETS_2", "File not open for reading for fgets"},
    {10070, "E_FPUTSTR_1", "Non-file first argument for fputstr"},
    {10071, "E_FPUTSTR_2", "Non-string argument after first for fputstr"},
    {10072, "E_FPUTSTR_3", "File not open for writing for fputstr"},
    {10073, "E_FGETSTR_1", "Non-file first argument for fgetstr"},
    {10074, "E_FGETSTR_2", "File not open for reading for fgetstr"},
    {10075, "E_FGETLINE_1", "Non-file  argument for fgetline"},
    {10076, "E_FGETLINE_2", "File not open for reading for fgetline"},
    {10077, "E_FGETFIELD_1", "Non-file argument for fgetfield"},
    {10078, "E_FGETFIELD_2", "File not open for reading for fgetfield"},
    {10079, "E_REWIND_1", "Non-file argument for rewind"},
    {10080, "E_FILES", "Non-integer argument for files"},
    {10081, "E_PRINTF_1", "Non-string fmt argument for fprint"},
    {10082, "E_PRINTF_2", "Stdout not open for writing to ???"},
    {10083, "E_FPRINTF_1", "Non-file first argument for fprintf"},
    {10084, "E_FPRINTF_2", "Non-string second (fmt) argument for fprintf"},
    {10085, "E_FPRINTF_3", "File not open for writing for fprintf"},
    {10086, "E_STRPRINTF_1", "Non-string first (fmt) argument for strprintf"},
    {10087, "E_STRPRINTF_2", "Error in attempting strprintf ???"},
    {10088, "E_FSCAN_1", "Non-file first argument for fscan"},
    {10089, "E_FSCAN_2", "File not open for reading for fscan"},
    {10090, "E_STRSCAN", "Non-string first argument for strscan"},
    {10091, "E_FSCANF_1", "Non-file first argument for fscanf"},
    {10092, "E_FSCANF_2", "Non-string second (fmt) argument for fscanf"},
    {10093, "E_FSCANF_3", "Non-lvalue argument after second for fscanf"},
    {10094, "E_FSCANF_4", "File not open for reading or other error for fscanf"},
    {10095, "E_STRSCANF_1", "Non-string first argument for strscanf"},
    {10096, "E_STRSCANF_2", "Non-string second (fmt) argument for strscanf"},
    {10097, "E_STRSCANF_3", "Non-lvalue argument after second for strscanf"},
    {10098, "E_STRSCANF_4", "Some error in attempting strscanf ???"},
    {10099, "E_SCANF_1", "Non-string first (fmt) argument for scanf"},
    {10100, "E_SCANF_2", "Non-lvalue argument after first for scanf"},
    {10101, "E_SCANF_3", "Some error in attempting scanf ???"},
    {10102, "E_FTELL_1", "Non-file argument for ftell"},
    {10103, "E_FTELL_2", "File not open or other error for ftell"},
    {10104, "E_FSEEK_1", "Non-file first argument for fseek"},
    {10105, "E_FSEEK_2", "Non-integer or negative second argument for fseek"},
    {10106, "E_FSEEK_3", "File not open or other error for fseek"},
    {10107, "E_FSIZE_1", "Non-file argument for fsize"},
    {10108, "E_FSIZE_2", "File not open or other error for fsize"},
    {10109, "E_FEOF_1", "Non-file argument for feof"},
    {10110, "E_FEOF_2", "File not open or other error for feof"},
    {10111, "E_FERROR_1", "Non-file argument for ferror"},
    {10112, "E_FERROR_2", "File not open or other error for ferror"},
    {10113, "E_UNGETC_1", "Non-file argument for ungetc"},
    {10114, "E_UNGETC_2", "File not open for reading for ungetc"},
    {10115, "E_UNGETC_3", "Bad second argument or other error for ungetc"},
    {10116, "E_BIGEXP", "Exponent too big in scanning"},
    {10117, "E_ISATTY_1", "UNUSED ERROR: E_ISATTY_1 is no longer used"},
    {10118, "E_ISATTY_2", "UNUSED ERROR: E_ISATTY_2 is no longer used"},
    {10119, "E_ACCESS_1", "Non-string first argument for access"},
    {10120, "E_ACCESS_2", "Bad second argument for access"},
    {10121, "E_SEARCH_1", "Bad first argument for search"},
    {10122, "E_SEARCH_2", "Bad second argument for search"},
    {10123, "E_SEARCH_3", "Bad third argument for search"},
    {10124, "E_SEARCH_4", "Bad fourth argument for search"},
    {10125, "E_SEARCH_5", "Cannot find off_t for search"},
    {10126, "E_SEARCH_6", "File not readable for search"},
    {10127, "E_RSEARCH_1", "Bad first argument for rsearch"},
    {10128, "E_RSEARCH_2", "Bad second argument for rsearch"},
    {10129, "E_RSEARCH_3", "Bad third argument for rsearch"},
    {10130, "E_RSEARCH_4", "Bad fourth argument for rsearch"},
    {10131, "E_RSEARCH_5", "Cannot find off_t for rsearch"},
    {10132, "E_RSEARCH_6", "File not readable for rsearch"},
    {10133, "E_MANYOPEN", "Too many open files"},
    {10134, "E_REWIND_2", "Attempt to rewind a file that is not open"},
    {10135, "E_STRERROR_1", "Bad argument type for strerror"},
    {10136, "E_STRERROR_2", "Numeric argument is outside valid errnum range for strerror"},
    {10137, "E_COS_1", "Bad epsilon for cos"},
    {10138, "E_COS_2", "Bad first argument for cos"},
    {10139, "E_SIN_1", "Bad epsilon for sin"},
    {10140, "E_SIN_2", "Bad first argument for sin"},
    {10141, "E_EVAL_2", "Non-string argument for eval"},
    {10142, "E_ARG_1", "Bad epsilon for arg"},
    {10143, "E_ARG_2", "Bad first argument for arg"},
    {10144, "E_POLAR_1", "Non-real argument for polar"},
    {10145, "E_POLAR_2", "Bad epsilon for polar"},
    {10146, "E_FCNT", "UNUSED ERROR: Non-integral argument for fcnt"},
    {10147, "E_MATFILL_1", "Non-variable first argument for matfill"},
    {10148, "E_MATFILL_2", "Non-matrix first argument-value for matfill"},
    {10149, "E_MATDIM", "Non-matrix argument for matdim"},
    {10150, "E_MATSUM", "Non-matrix argument for matsum"},
    {10151, "E_ISIDENT", "UNUSED ERROR: E_ISIDENT is no longer used"},
    {10152, "E_MATTRANS_1", "Non-matrix argument for mattrans"},
    {10153, "E_MATTRANS_2", "Non-two-dimensional matrix for mattrans"},
    {10154, "E_DET_1", "Non-matrix argument for det"},
    {10155, "E_DET_2", "Matrix for det not of dimension 2"},
    {10156, "E_DET_3", "Non-square matrix for det"},
    {10157, "E_MATMIN_1", "Non-matrix first argument for matmin"},
    {10158, "E_MATMIN_2", "Non-positive-integer second argument for matmin"},
    {10159, "E_MATMIN_3", "Second argument for matmin exceeds dimension"},
    {10160, "E_MATMAX_1", "Non-matrix first argument for matmin"},
    {10161, "E_MATMAX_2", "Second argument for matmax not positive integer"},
    {10162, "E_MATMAX_3", "Second argument for matmax exceeds dimension"},
    {10163, "E_CP_1", "Non-matrix argument for cp"},
    {10164, "E_CP_2", "Non-one-dimensional matrix for cp"},
    {10165, "E_CP_3", "Matrix size not 3 for cp"},
    {10166, "E_DP_1", "Non-matrix argument for dp"},
    {10167, "E_DP_2", "Non-one-dimensional matrix for dp"},
    {10168, "E_DP_3", "Different-size matrices for dp"},
    {10169, "E_STRLEN", "Non-string argument for strlen"},
    {10170, "E_STRCAT", "Non-string argument for strcat"},
    {10171, "E_SUBSTR_1", "Non-string first argument for strcat"},
    {10172, "E_SUBSTR_2", "Non-non-negative integer second argument for strcat"},
    {10173, "E_CHAR", "Bad argument for char"},
    {10174, "E_ORD", "Non-string argument for ord"},
    {10175, "E_INSERT_1", "Non-list-variable first argument for insert"},
    {10176, "E_INSERT_2", "Non-integral second argument for insert"},
    {10177, "E_PUSH", "Non-list-variable first argument for push"},
    {10178, "E_APPEND", "Non-list-variable first argument for append"},
    {10179, "E_DELETE_1", "Non-list-variable first argument for delete"},
    {10180, "E_DELETE_2", "Non-integral second argument for delete"},
    {10181, "E_POP", "Non-list-variable argument for pop"},
    {10182, "E_REMOVE", "Non-list-variable argument for remove"},
    {10183, "E_LN_1", "Bad epsilon argument for ln"},
    {10184, "E_LN_2", "Non-numeric first argument for ln"},
    {10185, "E_ERROR_1", "Invalid argument type for error"},
    {10186, "E_ERROR_2", "Numeric argument is outside valid errnum range for error"},
    {10187, "E_EVAL_3", "Attempt to eval at maximum input depth"},
    {10188, "E_EVAL_4", "Unable to open string for reading"},
    {10189, "E_RM_1", "First argument for rm is not a non-empty string"},
    {10190, "E_RM_2", "UNUSED ERROR: Unable to remove a file"},
    {10191, "E_RDPERM", "UNUSED ERROR: Operation allowed because calc mode disallows read operations"},
    {10192, "E_WRPERM", "Operation allowed because calc mode disallows write operations"},
    {10193, "E_EXPERM", "UNUSED ERROR: Operation allowed because calc mode disallows exec operations"},
    {10194, "E_MIN", "Unordered arguments for min"},
    {10195, "E_MAX", "Unordered arguments for max"},
    {10196, "E_LISTMIN", "Unordered items for minimum of list"},
    {10197, "E_LISTMAX", "Unordered items for maximum of list"},
    {10198, "E_SIZE", "Size undefined for argument type"},
    {10199, "E_NO_C_ARG", "Calc must be run with a -C argument to use custom function"},
    {10200, "E_NO_CUSTOM", "Calc was built with custom functions disabled"},
    {10201, "E_UNK_CUSTOM", "Custom function unknown, try: show custom"},
    {10202, "E_BLK_1", "Non-integral length for block"},
    {10203, "E_BLK_2", "Negative or too-large length for block"},
    {10204, "E_BLK_3", "Non-integral chunksize for block"},
    {10205, "E_BLK_4", "Negative or too-large chunksize for block"},
    {10206, "E_BLKFREE_1", "Named block does not exist for blkfree"},
    {10207, "E_BLKFREE_2", "Non-integral id specification for blkfree"},
    {10208, "E_BLKFREE_3", "Block with specified id does not exist"},
    {10209, "E_BLKFREE_4", "Block already freed"},
    {10210, "E_BLKFREE_5", "No-realloc protection prevents blkfree"},
    {10211, "E_BLOCKS_1", "Non-integer argument for blocks"},
    {10212, "E_BLOCKS_2", "Non-allocated index number for blocks"},
    {10213, "E_COPY_01", "Non-integer or negative source index for copy"},
    {10214, "E_COPY_02", "Source index too large for copy"},
    {10215, "E_COPY_03", "UNUSED ERROR: E_COPY_03 is no longer used"},
    {10216, "E_COPY_04", "Non-integer or negative number for copy"},
    {10217, "E_COPY_05", "Number too large for copy"},
    {10218, "E_COPY_06", "Non-integer or negative destination index for copy"},
    {10219, "E_COPY_07", "Destination index too large for copy"},
    {10220, "E_COPY_08", "Freed block source for copy"},
    {10221, "E_COPY_09", "Unsuitable source type for copy"},
    {10222, "E_COPY_10", "Freed block destination for copy"},
    {10223, "E_COPY_11", "Unsuitable destination type for copy"},
    {10224, "E_COPY_12", "Incompatible source and destination for copy"},
    {10225, "E_COPY_13", "No-copy-from source variable"},
    {10226, "E_COPY_14", "No-copy-to destination variable"},
    {10227, "E_COPY_15", "No-copy-from source named block"},
    {10228, "E_COPY_16", "No-copy-to destination named block"},
    {10229, "E_COPY_17", "No-relocate destination for copy"},
    {10230, "E_COPYF_1", "File not open for copy"},
    {10231, "E_COPYF_2", "fseek or fsize failure for copy"},
    {10232, "E_COPYF_3", "fwrite error for copy"},
    {10233, "E_COPYF_4", "fread error for copy"},
    {10234, "E_PROTECT_1", "Non-variable first argument for protect"},
    {10235, "E_PROTECT_2", "Bad second argument for protect"},
    {10236, "E_PROTECT_3", "Bad third argument for protect"},
    {10237, "E_MATFILL_3", "No-copy-to destination for matfill"},
    {10238, "E_MATFILL_4", "No-assign-from source for matfill"},
    {10239, "E_MATTRACE_1", "Non-matrix argument for mattrace"},
    {10240, "E_MATTRACE_2", "Non-two-dimensional argument for mattrace"},
    {10241, "E_MATTRACE_3", "Non-square argument for mattrace"},
    {10242, "E_TAN_1", "Bad epsilon for tan"},
    {10243, "E_TAN_2", "Bad argument for tan"},
    {10244, "E_COT_1", "Bad epsilon for cot"},
    {10245, "E_COT_2", "Bad argument for cot"},
    {10246, "E_SEC_1", "Bad epsilon for sec"},
    {10247, "E_SEC_2", "Bad argument for sec"},
    {10248, "E_CSC_1", "Bad epsilon for csc"},
    {10249, "E_CSC_2", "Bad argument for csc"},
    {10250, "E_SINH_1", "Bad epsilon for sinh"},
    {10251, "E_SINH_2", "Bad argument for sinh"},
    {10252, "E_COSH_1", "Bad epsilon for cosh"},
    {10253, "E_COSH_2", "Bad argument for cosh"},
    {10254, "E_TANH_1", "Bad epsilon for tanh"},
    {10255, "E_TANH_2", "Bad argument for tanh"},
    {10256, "E_COTH_1", "Bad epsilon for coth"},
    {10257, "E_COTH_2", "Bad argument for coth"},
    {10258, "E_SECH_1", "Bad epsilon for sech"},
    {10259, "E_SECH_2", "Bad argument for sech"},
    {10260, "E_CSCH_1", "Bad epsilon for csch"},
    {10261, "E_CSCH_2", "Bad argument for csch"},
    {10262, "E_ASIN_1", "Bad epsilon for asin"},
    {10263, "E_ASIN_2", "Bad argument for asin"},
    {10264, "E_ACOS_1", "Bad epsilon for acos"},
    {10265, "E_ACOS_2", "Bad argument for acos"},
    {10266, "E_ATAN_1", "Bad epsilon for atan"},
    {10267, "E_ATAN_2", "Bad argument for atan"},
    {10268, "E_ACOT_1", "Bad epsilon for acot"},
    {10269, "E_ACOT_2", "Bad argument for acot"},
    {10270, "E_ASEC_1", "Bad epsilon for asec"},
    {10271, "E_ASEC_2", "Bad argument for asec"},
    {10272, "E_ACSC_1", "Bad epsilon for acsc"},
    {10273, "E_ACSC_2", "Bad argument for acsc"},
    {10274, "E_ASINH_1", "Bad epsilon for asin"},
    {10275, "E_ASINH_2", "Bad argument for asinh"},
    {10276, "E_ACOSH_1", "Bad epsilon for acosh"},
    {10277, "E_ACOSH_2", "Bad argument for acosh"},
    {10278, "E_ATANH_1", "Bad epsilon for atanh"},
    {10279, "E_ATANH_2", "Bad argument for atanh"},
    {10280, "E_ACOTH_1", "Bad epsilon for acoth"},
    {10281, "E_ACOTH_2", "Bad argument for acoth"},
    {10282, "E_ASECH_1", "UNUSED ERROR: Bad epsilon for asech"},
    {10283, "E_ASECH_2", "Bad argument for asech"},
    {10284, "E_ACSCH_1", "Bad epsilon for acsch"},
    {10285, "E_ACSCH_2", "Bad argument for acsch"},
    {10286, "E_GD_1", "Bad epsilon for gd"},
    {10287, "E_GD_2", "Bad argument for gd"},
    {10288, "E_AGD_1", "Bad epsilon for agd"},
    {10289, "E_AGD_2", "Bad argument for agd"},
    {10290, "E_LOGINF", "Log of zero or infinity"},
    {10291, "E_STRADD", "String addition failure"},
    {10292, "E_STRMUL", "String multiplication failure"},
    {10293, "E_STRNEG", "String reversal failure"},
    {10294, "E_STRSUB", "String subtraction failure"},
    {10295, "E_BIT_1", "Bad argument type for bit"},
    {10296, "E_BIT_2", "Index too large for bit"},
    {10297, "E_SETBIT_1", "Non-integer second argument for setbit"},
    {10298, "E_SETBIT_2", "Out-of-range index for setbit"},
    {10299, "E_SETBIT_3", "Non-string first argument for setbit"},
    {10300, "E_OR", "Bad argument for or"},
    {10301, "E_AND", "Bad argument for and"},
    {10302, "E_STROR", "Allocation failure for string or"},
    {10303, "E_STRAND", "Allocation failure for string and"},
    {10304, "E_XOR", "Bad argument for xorvalue"},
    {10305, "E_COMP", "Bad argument for comp"},
    {10306, "E_STRDIFF", "Allocation failure for string diff"},
    {10307, "E_STRCOMP", "Allocation failure for string comp"},
    {10308, "E_SEG_1", "Bad first argument for segment"},
    {10309, "E_SEG_2", "Bad second argument for segment"},
    {10310, "E_SEG_3", "Bad third argument for segment"},
    {10311, "E_STRSEG", "Failure for string segment"},
    {10312, "E_HIGHBIT_1", "Bad argument type for highbit"},
    {10313, "E_HIGHBIT_2", "Non-integer argument for highbit"},
    {10314, "E_LOWBIT_1", "Bad argument type for lowbit"},
    {10315, "E_LOWBIT_2", "Non-integer argument for lowbit"},
    {10316, "E_CONTENT", "Bad argument type for unary hash op"},
    {10317, "E_HASHOP", "Bad argument type for binary hash op"},
    {10318, "E_HEAD_1", "Bad first argument for head"},
    {10319, "E_HEAD_2", "Bad second argument for head"},
    {10320, "E_STRHEAD", "Failure for strhead"},
    {10321, "E_TAIL_1", "Bad first argument for tail"},
    {10322, "E_TAIL_2", "UNUSED ERROR: Bad second argument for tail"},
    {10323, "E_STRTAIL", "Failure for strtail"},
    {10324, "E_STRSHIFT", "Failure for strshift"},
    {10325, "E_STRCMP", "Non-string argument for strcmp"},
    {10326, "E_STRNCMP", "Bad argument type for strncmp"},
    {10327, "E_XOR_1", "Varying types of argument for xor"},
    {10328, "E_XOR_2", "Bad argument type for xor"},
    {10329, "E_STRCPY", "Bad argument type for strcpy"},
    {10330, "E_STRNCPY", "Bad argument type for strncpy"},
    {10331, "E_BACKSLASH", "Bad argument type for unary backslash"},
    {10332, "E_SETMINUS", "Bad argument type for setminus"},
    {10333, "E_INDICES_1", "Bad first argument type for indices"},
    {10334, "E_INDICES_2", "Bad second argument for indices"},
    {10335, "E_EXP_3", "Too-large re(argument) for exp"},
    {10336, "E_SINH_3", "Too-large re(argument) for sinh"},
    {10337, "E_COSH_3", "Too-large re(argument) for cosh"},
    {10338, "E_SIN_3", "Too-large im(argument) for sin"},
    {10339, "E_COS_3", "Too-large im(argument) for cos"},
    {10340, "E_GD_3", "Infinite or too-large result for gd"},
    {10341, "E_AGD_3", "Infinite or too-large result for agd"},
    {10342, "E_POWER_4", "Too-large value for power"},
    {10343, "E_ROOT_4", "Too-large value for root"},
    {10344, "E_DGT_1", "Non-real first arg for digit"},
    {10345, "E_DGT_2", "Non-integral second arg for digit"},
    {10346, "E_DGT_3", "Bad third arg for digit"},
    {10347, "E_PLCS_1", "Bad first argument for places"},
    {10348, "E_PLCS_2", "Bad second argument for places"},
    {10349, "E_DGTS_1", "Bad first argument for digits"},
    {10350, "E_DGTS_2", "Bad second argument for digits"},
    {10351, "E_ILOG", "Bad first argument for ilog"},
    {10352, "E_ILOGB", "Bad second argument for ilog"},
    {10353, "E_IBASE10_LOG", "Bad argument for ilog10"},
    {10354, "E_IBASE2_LOG", "Bad argument for ilog2"},
    {10355, "E_COMB_1", "Non-integer second arg for comb"},
    {10356, "E_COMB_2", "Too-large second arg for comb"},
    {10357, "E_CTLN", "Bad argument for catalan"},
    {10358, "E_BERN", "Bad argument for bern"},
    {10359, "E_EULER", "Bad argument for euler"},
    {10360, "E_SLEEP", "Bad argument for sleep"},
    {10361, "E_TTY", "calc_tty failure"},
    {10362, "E_ASSIGN_1", "No-copy-to destination for octet assign"},
    {10363, "E_ASSIGN_2", "No-copy-from source for octet assign"},
    {10364, "E_ASSIGN_3", "No-change destination for octet assign"},
    {10365, "E_ASSIGN_4", "Non-variable destination for assign"},
    {10366, "E_ASSIGN_5", "No-assign-to destination for assign"},
    {10367, "E_ASSIGN_6", "No-assign-from source for assign"},
    {10368, "E_ASSIGN_7", "No-change destination for assign"},
    {10369, "E_ASSIGN_8", "No-type-change destination for assign"},
    {10370, "E_ASSIGN_9", "No-error-value destination for assign"},
    {10371, "E_SWAP_1", "No-copy argument for octet swap"},
    {10372, "E_SWAP_2", "No-assign-to-or-from argument for swap"},
    {10373, "E_SWAP_3", "Non-lvalue argument for swap"},
    {10374, "E_QUOMOD_1", "Non-lvalue argument 3 or 4 for quomod"},
    {10375, "E_QUOMOD_2", "Non-real-number arg 1 or 2 or bad arg 5 for quomod"},
    {10376, "E_QUOMOD_3", "No-assign-to argument 3 or 4 for quomod"},
    {10377, "E_PREINC_1", "No-copy-to or no-change argument for octet preinc"},
    {10378, "E_PREINC_2", "Non-variable argument for preinc"},
    {10379, "E_PREINC_3", "No-assign-to or no-change argument for preinc"},
    {10380, "E_PREDEC_1", "No-copy-to or no-change argument for octet predec"},
    {10381, "E_PREDEC_2", "Non-variable argument for predec"},
    {10382, "E_PREDEC_3", "No-assign-to or no-change argument for predec"},
    {10383, "E_POSTINC_1", "No-copy-to or no-change argument for octet postinc"},
    {10384, "E_POSTINC_2", "Non-variable argument for postinc"},
    {10385, "E_POSTINC_3", "No-assign-to or no-change argument for postinc"},
    {10386, "E_POSTDEC_1", "No-copy-to or no-change argument for octet postdec"},
    {10387, "E_POSTDEC_2", "Non-variable argument for postdec"},
    {10388, "E_POSTDEC_3", "No-assign-to or no-change argument for postdec"},
    {10389, "E_INIT_01", "Error-type structure for initialization"},
    {10390, "E_INIT_02", "No-copy-to structure for initialization"},
    {10391, "E_INIT_03", "Too many initializer values"},
    {10392, "E_INIT_04", "Attempt to initialize freed named block"},
    {10393, "E_INIT_05", "Bad structure type for initialization"},
    {10394, "E_INIT_06", "No-assign-to element for initialization"},
    {10395, "E_INIT_07", "No-change element for initialization"},
    {10396, "E_INIT_08", "No-type-change element for initialization"},
    {10397, "E_INIT_09", "No-error-value element for initialization"},
    {10398, "E_INIT_10", "No-assign-or-copy-from source for initialization"},
    {10399, "E_LIST_1", "No-relocate for list insert"},
    {10400, "E_LIST_2", "No-relocate for list delete"},
    {10401, "E_LIST_3", "No-relocate for list push"},
    {10402, "E_LIST_4", "No-relocate for list append"},
    {10403, "E_LIST_5", "No-relocate for list pop"},
    {10404, "E_LIST_6", "No-relocate for list remove"},
    {10405, "E_MODIFY_1", "Non-variable first argument for modify"},
    {10406, "E_MODIFY_2", "Non-string second argument for modify"},
    {10407, "E_MODIFY_3", "No-change first argument for modify"},
    {10408, "E_MODIFY_4", "Undefined function for modify"},
    {10409, "E_MODIFY_5", "Unacceptable type first argument for modify"},
    {10410, "E_FPATHOPEN_1", "Non-string arguments for fpathopen"},
    {10411, "E_FPATHOPEN_2", "Unrecognized mode for fpathopen"},
    {10412, "E_LOG_1", "Bad epsilon argument for log"},
    {10413, "E_LOG_2", "Non-numeric first argument for log"},
    {10414, "E_LOG_3", "Cannot calculate log for this value"},
    {10415, "E_FGETFILE_1", "Non-file argument for fgetfile"},
    {10416, "E_FGETFILE_2", "File argument for fgetfile not open for reading"},
    {10417, "E_FGETFILE_3", "Unable to set file position in fgetfile"},
    {10418, "E_ESTR", "UNUSED ERROR: Non-representable type for estr"},
    {10419, "E_STRCASECMP", "Non-string argument for strcasecmp"},
    {10420, "E_STRNCASECMP", "Bad argument type for strncasecmp"},
    {10421, "E_ISUPPER", "Bad argument for isupper"},
    {10422, "E_ISLOWER", "Bad argument for islower"},
    {10423, "E_ISALNUM", "Bad argument for isalnum"},
    {10424, "E_ISALPHA", "Bad argument for isalpha"},
    {10425, "E_ISASCII", "Bad argument for isascii"},
    {10426, "E_ISCNTRL", "Bad argument for iscntrl"},
    {10427, "E_ISDIGIT", "Bad argument for isdigit"},
    {10428, "E_ISGRAPH", "Bad argument for isgraph"},
    {10429, "E_ISPRINT", "Bad argument for isprint"},
    {10430, "E_ISPUNCT", "Bad argument for ispunct"},
    {10431, "E_ISSPACE", "Bad argument for isspace"},
    {10432, "E_ISXDIGIT", "Bad argument for isxdigit"},
    {10433, "E_STRTOUPPER", "Bad argument type for strtoupper"},
    {10434, "E_STRTOLOWER", "Bad argument type for strtolower"},
    {10435, "E_TAN_3", "UNUSED ERROR: Invalid value for calculating the sin numerator for tan"},
    {10436, "E_TAN_4", "UNUSED ERROR: Invalid value for calculating the cos denominator for tan"},
    {10437, "E_COT_3", "UNUSED ERROR: Invalid value for calculating the sin numerator for cot"},
    {10438, "E_COT_4", "UNUSED ERROR: Invalid value for calculating the cos denominator for cot"},
    {10439, "E_SEC_3", "UNUSED ERROR: Invalid value for calculating the cos reciprocal for sec"},
    {10440, "E_CSC_3", "UNUSED ERROR: Invalid value for calculating the sin reciprocal for csc"},
    {10441, "E_TANH_3", "Invalid value for calculating the sinh numerator for tanh"},
    {10442, "E_TANH_4", "Invalid value for calculating the cosh denominator for tanh"},
    {10443, "E_COTH_3", "Invalid value for calculating the sinh numerator for coth"},
    {10444, "E_COTH_4", "Invalid value for calculating the cosh denominator for coth"},
    {10445, "E_SECH_3", "Invalid value for calculating the cosh reciprocal for sech"},
    {10446, "E_CSCH_3", "Invalid value for calculating the sinh reciprocal for csch"},
    {10447, "E_ASIN_3", "Invalid value for calculating asin"},
    {10448, "E_ACOS_3", "Invalid value for calculating acos"},
    {10449, "E_ASINH_3", "Invalid value for calculating asinh"},
    {10450, "E_ACOSH_3", "Invalid value for calculating acosn"},
    {10451, "E_ATAN_3", "Invalid value for calculating atan"},
    {10452, "E_ACOT_3", "Invalid value for calculating acot"},
    {10453, "E_ASEC_3", "Invalid value for calculating asec"},
    {10454, "E_ACSC_3", "Invalid value for calculating acsc"},
    {10455, "E_ATANH_3", "Invalid value for calculating atan"},
    {10456, "E_ACOTH_3", "Invalid value for calculating acot"},
    {10457, "E_ASECH_3", "Invalid value for calculating asec"},
    {10458, "E_ACSCH_3", "Invalid value for calculating acsc"},
    {10459, "E_D2R_1", "Bad epsilon for converting degrees to radians"},
    {10460, "E_D2R_2", "Bad first argument converting degrees to radians"},
    {10461, "E_R2D_1", "Bad epsilon for converting radians to degrees"},
    {10462, "E_R2D_2", "Bad first argument converting radians to degrees"},
    {10463, "E_G2R_1", "Bad epsilon for converting gradians to radians"},
    {10464, "E_G2R_2", "Bad first argument converting gradians to radians"},
    {10465, "E_R2G_1", "Bad epsilon for converting radians to gradians"},
    {10466, "E_R2G_2", "Bad first argument converting radians to gradians"},
    {10467, "E_D2G_1", "Bad first argument converting degrees to gradians"},
    {10468, "E_G2D_1", "Bad first argument converting gradians to degrees"},
    {10469, "E_D2DMS_1", "Non-lvalue arguments 2, 3 or 4 for d2dms"},
    {10470, "E_D2DMS_2", "Non-real-number arg 1 for d2dms"},
    {10471, "E_D2DMS_3", "No-assign-to argument 2, 3 or 4 for d2dms"},
    {10472, "E_D2DMS_4", "Invalid rounding arg 5 for d2dms"},
    {10473, "E_D2DM_1", "Non-lvalue arguments 2 or 3 for d2dm"},
    {10474, "E_D2DM_2", "Non-real-number arg 1 for d2dm"},
    {10475, "E_D2DM_3", "No-assign-to argument 2 or 3 for d2dm"},
    {10476, "E_D2DM_4", "Invalid rounding arg 4 for d2dm"},
    {10477, "E_G2GMS_1", "Non-lvalue arguments 2, 3 or 4 for g2gms"},
    {10478, "E_G2GMS_2", "Non-real-number arg 1 for g2gms"},
    {10479, "E_G2GMS_3", "No-assign-to argument 2 or 3 for g2gms"},
    {10480, "E_G2GMS_4", "Invalid rounding arg 5 for g2gms"},
    {10481, "E_G2GM_1", "Non-lvalue arguments 2 or 3 for g2gm"},
    {10482, "E_G2GM_2", "Non-real-number arg 1 for g2gm"},
    {10483, "E_G2GM_3", "No-assign-to argument 2, 3 or 4 for g2gm"},
    {10484, "E_G2GM_4", "Invalid rounding arg 4 for g2gm"},
    {10485, "E_H2HMS_1", "Non-lvalue arguments 2, 3 or 4 for h2hms"},
    {10486, "E_H2HMS_2", "Non-real-number arg 1 for h2hms"},
    {10487, "E_H2HMS_3", "No-assign-to argument 2, 3 or 4 for h2hms"},
    {10488, "E_H2HMS_4", "Invalid rounding arg 5 for h2hms"},
    {10489, "E_H2HM_1", "Non-lvalue arguments 2 or 3 for h2hm"},
    {10490, "E_H2HM_2", "Non-real-number arg 1 for h2hm"},
    {10491, "E_H2HM_3", "No-assign-to argument 2 or 3 for h2hm"},
    {10492, "E_H2HM_4", "Invalid rounding arg 4 for h2hm"},
    {10493, "E_DMS2D_1", "Non-real-number arguments 1, 2 or 3 for dms2d"},
    {10494, "E_DMS2D_2", "Invalid rounding arg 4 for dms2d"},
    {10495, "E_DM2D_1", "Non-real-number arguments 1 or 2 for dm2d"},
    {10496, "E_DM2D_2", "Invalid rounding arg 4 for dm2d"},
    {10497, "E_GMS2G_1", "Non-real-number arguments 1, 2 or 3 for gms2g"},
    {10498, "E_GMS2G_2", "Invalid rounding arg 4 for gms2g"},
    {10499, "E_GM2G_1", "Non-real-number arguments 1 or 2 for gm2g"},
    {10500, "E_GM2G_2", "Invalid rounding arg 4 for gm2g"},
    {10501, "E_HMS2H_1", "Non-real-number arguments 1, 2 or 3 for hms2h"},
    {10502, "E_HMS2H_2", "Invalid rounding arg 4 for hms2h"},
    {10503, "E_HM2H_1", "UNUSED ERROR: Non-real-number arguments 1 or 2 for hm2h"},
    {10504, "E_HM2H_2", "UNUSED ERROR: Invalid rounding arg 4 for hm2h"},
    {10505, "E_LOG2_1", "Bad epsilon argument for log2"},
    {10506, "E_LOG2_2", "Non-numeric first argument for log2"},
    {10507, "E_LOG2_3", "Cannot calculate log2 for this value"},
    {10508, "E_LOGN_1", "Bad epsilon argument for logn"},
    {10509, "E_LOGN_2", "Non-numeric first argument for logn"},
    {10510, "E_LOGN_3", "Cannot calculate logn for this value"},
    {10511, "E_LOGN_4", "Cannot calculate logn for this log base"},
    {10512, "E_LOGN_5", "Non-numeric second argument for logn"},
    {10513, "E_VERSIN_1", "Bad epsilon for versin"},
    {10514, "E_VERSIN_2", "Bad first argument for versin"},
    {10515, "E_VERSIN_3", "Too-large im(argument) for versin"},
    {10516, "E_AVERSIN_1", "Bad epsilon for aversin"},
    {10517, "E_AVERSIN_2", "Bad first argument for aversin"},
    {10518, "E_AVERSIN_3", "Too-large im(argument) for aversin"},
    {10519, "E_COVERSIN_1", "Bad epsilon for coversin"},
    {10520, "E_COVERSIN_2", "Bad first argument for coversin"},
    {10521, "E_COVERSIN_3", "Too-large im(argument) for coversin"},
    {10522, "E_ACOVERSIN_1", "Bad epsilon for acoversin"},
    {10523, "E_ACOVERSIN_2", "Bad first argument for acoversin"},
    {10524, "E_ACOVERSIN_3", "Too-large im(argument) for acoversin"},
    {10525, "E_VERCOS_1", "Bad epsilon for vercos"},
    {10526, "E_VERCOS_2", "Bad first argument for vercos"},
    {10527, "E_VERCOS_3", "Too-large im(argument) for vercos"},
    {10528, "E_AVERCOS_1", "Bad epsilon for avercos"},
    {10529, "E_AVERCOS_2", "Bad first argument for avercos"},
    {10530, "E_AVERCOS_3", "Too-large im(argument) for avercos"},
    {10531, "E_COVERCOS_1", "Bad epsilon for covercos"},
    {10532, "E_COVERCOS_2", "Bad first argument for covercos"},
    {10533, "E_COVERCOS_3", "Too-large im(argument) for covercos"},
    {10534, "E_ACOVERCOS_1", "Bad epsilon for acovercos"},
    {10535, "E_ACOVERCOS_2", "Bad first argument for acovercos"},
    {10536, "E_ACOVERCOS_3", "Too-large im(argument) for acovercos"},
    {10537, "E_TAN_5", "Invalid complex argument for tan"},
    {10538, "E_COT_5", "Invalid zero argument for cot"},
    {10539, "E_COT_6", "Invalid complex argument for cot"},
    {10540, "E_SEC_5", "Invalid complex argument for sec"},
    {10541, "E_CSC_5", "Invalid zero argument for csc"},
    {10542, "E_CSC_6", "Invalid complex argument for csc"},
    {10543, "E_ERROR_3", "String argument is not a valid E_STRING for error"},
    {10544, "E_ERROR_4", "Numeric argument is not an integer for error"},
    {10545, "E_STRERROR_3", "String argument is not a valid E_STRING for strerror"},
    {10546, "E_STRERROR_4", "errnum_2_errmsg returned NULL as called from strerror"},
    {10547, "E_STRERROR_5", "Numeric argument is not an integer for strerror"},
    {10548, "E_ERRNO_1", "Invalid argument type for errno"},
    {10549, "E_ERRNO_2", "Numeric argument is outside valid errnum range for errno"},
    {10550, "E_ERRNO_3", "String argument is not a valid E_STRING for errno"},
    {10551, "E_ERRNO_4", "Numeric argument is not an integer for errno"},
    {10552, "E_ERRSYM_1", "Invalid argument type for errsym"},
    {10553, "E_ERRSYM_2", "Numeric argument is outside valid errnum range for errsym"},
    {10554, "E_ERRSYM_3", "String argument is not a valid E_STRING for errsym"},
    {10555, "E_ERRSYM_4", "Numeric argument is not an integer for errsym"},
    {10556, "E_ERRSYM_5", "Unable to create a valid E_STRING from the errnum for errsym"},
    {10557, "E_HAVERSIN_1", "Bad epsilon for haversin"},
    {10558, "E_HAVERSIN_2", "Bad first argument for haversin"},
    {10559, "E_HAVERSIN_3", "Too-large im(argument) for haversin"},
    {10560, "E_AHAVERSIN_1", "Bad epsilon for ahaversin"},
    {10561, "E_AHAVERSIN_2", "Bad first argument for ahaversin"},
    {10562, "E_AHAVERSIN_3", "Too-large im(argument) for ahaversin"},
    {10563, "E_HACOVERSIN_1", "Bad epsilon for hacoversin"},
    {10564, "E_HACOVERSIN_2", "Bad first argument for hacoversin"},
    {10565, "E_HACOVERSIN_3", "Too-large im(argument) for hacoversin"},
    {10566, "E_AHACOVERSIN_1", "Bad epsilon for ahacoversin"},
    {10567, "E_AHACOVERSIN_2", "Bad first argument for achaoversin"},
    {10568, "E_AHACOVERSIN_3", "Too-large im(argument) for ahacoversin"},
    {10569, "E_HAVERCOS_1", "Bad epsilon for havercos"},
    {10570, "E_HAVERCOS_2", "Bad first argument for havercos"},
    {10571, "E_HAVERCOS_3", "Too-large im(argument) for havercos"},
    {10572, "E_AHAVERCOS_1", "Bad epsilon for ahavercos"},
    {10573, "E_AHAVERCOS_2", "Bad first argument for ahavercos"},
    {10574, "E_AHAVERCOS_3", "Too-large im(argument) for ahavercos"},
    {10575, "E_HACOVERCOS_1", "Bad epsilon for hacovercos"},
    {10576, "E_HACOVERCOS_2", "Bad first argument for hacovercos"},
    {10577, "E_HACOVERCOS_3", "Too-large im(argument) for hacovercos"},
    {10578, "E_AHACOVERCOS_1", "Bad epsilon for ahacovercos"},
    {10579, "E_AHACOVERCOS_2", "Bad first argument for achaovercos"},
    {10580, "E_AHACOVERCOS_3", "Too-large im(argument) for ahacovercos"},
    {10581, "E_EXSEC_1", "Bad epsilon for exsec"},
    {10582, "E_EXSEC_2", "Bad argument for exsec"},
    {10583, "E_EXSEC_3", "Invalid complex argument for exsec"},
    {10584, "E_AEXSEC_1", "Bad epsilon for aexsec"},
    {10585, "E_AEXSEC_2", "Bad argument for aexsec"},
    {10586, "E_AEXSEC_3", "Invalid value for calculating aexsec"},
    {10587, "E_EXCSC_1", "Bad epsilon for excsc"},
    {10588, "E_EXCSC_2", "Bad argument for excsc"},
    {10589, "E_EXCSC_3", "Invalid zero argument for excsc"},
    {10590, "E_EXCSC_4", "Invalid complex argument for excsc"},
    {10591, "E_AEXCSC_1", "Bad epsilon for aexcsc"},
    {10592, "E_AEXCSC_2", "Bad argument for aexcsc"},
    {10593, "E_AEXCSC_3", "Invalid value for calculating aexcsc"},
    {10594, "E_CRD_1", "Bad epsilon for crd"},
    {10595, "E_CRD_2", "Bad argument for crd"},
    {10596, "E_CRD_3", "Invalid complex argument for crd"},
    {10597, "E_ACRD_1", "Bad epsilon for acrd"},
    {10598, "E_ACRD_2", "Bad argument for acrd"},
    {10599, "E_ACRD_3", "Invalid value for calculating acrd"},
    {10600, "E_CAS_1", "Bad epsilon for cas"},
    {10601, "E_CAS_2", "Bad argument for cas"},
    {10602, "E_CAS_3", "Invalid complex argument for cas"},
    {10603, "E_CIS_1", "Non-real epsilon for cis"},
    {10604, "E_CIS_2", "Bad first argument for cis"},
    {10605, "E_CIS_3", "Too-large re(argument) for cis"},
    {10606, "E_LN_3", "Cannot calculate ln of 0"},
    {10607, "E_LOG_5", "Cannot calculate log of 0"},
    {10608, "E_LOG2_4", "Cannot calculate log base 2 of 0"},
    {10609, "E_LOGN_6", "Cannot calculate log base n of 0"},
    {10610, "E_INVALID_DEREF", "Dereferencing a non-variable"},
    {10611, "E_INVALID_ADDR_OP", "Invalid arithmetic address operation"},
    /* IMPORTANT NOTE: add new entries above here and be sure their errnum numeric value is consecutive! */

    /* The next NULL entry must be last */
    {NULL_ERRNUM, NULL, NULL}};

/*
 * The error_table[] array represents the special "E__" E_STRING related
 * error codes, symbols and messages.
 *
 * The purpose of this internal table is to allow functions below to convert
 * between E__" E_STRING related errsym, and their respective errnum
 * calc computation error codes and their respective errmsg messages.
 *
 * In this table, the errnum values must starting with 0 and ascending until
 * the final NULL entry's NULL_ERRNUM (-1) value.  Unlike error_table[],
 * the errnum values in private_error_alias[] do not need to be consecutive.
 *
 * In this table the E_STRING related errsym must match the regular expression:
 *
 *      ^E__[A-Z][A-Z0-9_]+$
 *
 * IMPORTANT: DO NOT ADD NEW calc computation TO THIS TABLE!!!
 *            Add new calc computation to the error_table[] above.
 */
static struct errtbl private_error_alias[] = {

    /* The E__NONE entry below must start with E__NONE (0) and must be first!! */
    {E__NONE, "E__NONE", "calc_errno cleared: libc errno codes above here"},
    {E__BASE, "E__BASE", "calc computation error codes start above here"},
    /* In the next E__HIGHEST entry, errnum and errmsg are changed when verify_error_table() is called */
    {INV_ERRNUM, "E__HIGHEST", "replace this with the E__HIGHEST errmsg"},
    {E__USERDEF, "E__USERDEF", "user defined error codes start here"},
    {E__USERMAX, "E__USERMAX", "maximum user defined error code"},

    /* The next NULL entry must be last */
    {NULL_ERRNUM, NULL, NULL}};

/*
 * external values
 */
extern char *program; /* our name */

/*
 * is_e_digits - E_STRING is of the form E_ followed by digits
 *
 * This function determines of errsym matches the regular expression:
 *
 *      ^E_[0-9][0-9]*$
 *
 * There is NO attempt to determine if the number type of digits
 * that follow the E_ forms a valid numeric E_STRING.
 *
 * NOTE: See also e_digits_2_errnum() below.
 *
 * given:
 *      errsym  E_STRING to check
 *
 * returns:
 *      true ==> E_STRING is of the form E_ followed by digits
 *      false ==> E_STRING is NULL and/or not E_ followed by digits
 */
bool
is_e_digits(const char *errsym)
{
    const char *p;

    /*
     * firewall
     */
    if (errsym == NULL) {
        return false;
    }

    /*
     * must start with E_
     */
    if (strncmp(errsym, "E_", 2) != 0) {
        return false;
    }

    /*
     * length must be >= 3
     */
    if (errsym[2] == '\0') {
        return false;
    }

    /*
     * check for only digits remaining
     */
    for (p = errsym + 2; *p != '\0'; ++p) {
        if (!isascii((int)*p) || !isdigit((int)*p)) {
            return false;
        }
    }

    /*
     * errsym matches: ^E_[0-9][0-9]*$
     */
    return true;
}

/*
 * is_valid_errnum - determine if errnum is within the proper range
 *
 * A valid errnum must be:
 *
 *      E__NONE <= errnum <= E__USERMAX
 *
 * NOTE: This functions does NOT check of the errnum is in
 * some struct errtbl array.  For that see find_errsym_in_errtbl().
 *
 * given:
 *      errnum  errnum to check
 *
 * returns:
 *      true ==> errnum is valid
 *      false ==> errnum is NOT valid
 */
bool
is_valid_errnum(int errnum)
{
    /*
     * check for range
     */
    if (errnum < E__NONE) {
        return false;
    }
    if (errnum > E__USERMAX) {
        return false;
    }
    /* errnum is valid */
    return true;
}

/*
 * is_errnum_in_error_table - determine if errnum falls within the error_table[] array bounds
 *
 * This function determines if the errnum is a value that is in the range
 * that the error_table[] array holds.  This function does NOT perform a
 * lookup within the error_table[] array, only a errnum value range check.
 *
 * returns:
 *      true ==> errnum falls within the error_table[] array bounds
 *      false ==> errnum does NOT fall within the error_table[] array bounds
 */
bool
is_errnum_in_error_table(int errnum)
{
    /*
     * firewall - errnum must be valid
     */
    if (is_valid_errnum(errnum) == false) {
        /* errnum is not a valid value */
        return false;
    }

    /*
     * case: errnum is too low for error_table[] array
     */
    if (errnum < E__BASE) {
        /* errnum is too low */
        return false;
    }

    /*
     * case: errnum is too high for error_table[] array
     */
    if ((unsigned long)errnum > MY_E__HIGHEST) {
        /* errnum is too high */
        return false;
    }

    /*
     * return error_table[] array matching the errnum value
     */
    return true;
}

/*
 * e_digits_2_errnum - convert an E_STRING of digits into a valid errnum
 *
 * Given an E_STRING errsym matching the regular expression:
 *
 *      ^E_[0-9][0-9]*$
 *
 * this function attempts to convert those digits into an errnum, and
 * if successful, that the resulting errnum is valid:
 *
 *      E__NONE <= errnum <= E__USERMAX
 *
 * NOTE: Leading zeros in digits are not allowed.  So the E_STRING errsym
 *       must match the regular expression:
 *
 *      ^(0|[1-9][0-9]*)$
 *
 * This function calls is_e_digits() first to determine that E_STRING
 * is E_ followed by digits.
 *
 * given:
 *      errsym  E_STRING to convert
 *
 * returns:
 *      == NULL_ERRNUM ==> errsym is NULL, or not E_STRING of digits, or
 *                         the resulting errnum would be invald
 *      != NULL_ERRNUM == valid errnum corresponding to errsym
 */
int
e_digits_2_errnum(const char *errsym)
{
    long errnum; /* digits converted into a possible errnum */

    /*
     * firewall
     */
    if (errsym == NULL) {
        /* errsym is NULL */
        return NULL_ERRNUM;
    }

    /*
     * must be an E_STRING of digits
     */
    if (is_e_digits(errsym) == false) {
        /* errsym doesn't match: ^E_[0-9][0-9]*$ */
        return NULL_ERRNUM;
    }

    /*
     * case: for E_0, return E__NONE
     */
    if (strcmp(errsym, "E_0") == 0) {
        /* quick return for E_0 */
        return E__NONE;
    }

    /*
     * errnum is not E_0, digits cannot start with "0"
     */
    if (errsym[2] == '0') {
        /* digits cannot start with 0 unless it is E_0 */
        return NULL_ERRNUM;
    }

    /*
     * try to convert digits into long
     */
    errno = 0;
    errnum = strtol(errsym + 2, NULL, 10);
    if (errno != 0) {
        /* failed to convert digits in base 10 */
        return NULL_ERRNUM;
    }

    /*
     * errnum, to be valid, just be in the range [E__NONE,E__USERMAX]
     */
    if (is_valid_errnum(errnum) == false) {
        /* errnum is out of range */
        return NULL_ERRNUM;
    }

    /*
     * return converted errnum
     */
    return errnum;
}

/*
 * is_e_1string - E_STRING is of the form E_ followed by letters and digits and underscores
 *
 * This function determines of errsym matches the regular expression:
 *
 *      ^E_[A-Z][A-Z0-9_]+$
 *
 * This function will not match the special E_STRING is of the form E__ followed by
 * letters and digits and underscores.  For that see is_e_2string().
 *
 * given:
 *      errsym  E_STRING to check
 *
 * returns:
 *      true ==> E_STRING matches the regular expression: ^E_[A-Z][A-Z0-9_]+$
 *      false ==> E_STRING is NULL and/or does not match expression: ^E_[A-Z][A-Z0-9_]+$
 */
bool
is_e_1string(const char *errsym)
{
    const char *p;

    /*
     * firewall
     */
    if (errsym == NULL) {
        return false;
    }

    /*
     * must start with E_
     */
    if (strncmp(errsym, "E_", 2) != 0) {
        return false;
    }

    /*
     * length must be >= 3
     */
    if (errsym[2] == '\0') {
        return false;
    }

    /*
     * errsym, after E_, must be an UPPER case letter
     */
    if (!isascii(errsym[2]) || !isupper(errsym[2])) {
        return false;
    }

    /*
     * must match regular expression: ^E_[A-Z][A-Z0-9_]+$
     */
    for (p = errsym + 3; *p != '\0'; ++p) {
        if (!isascii((int)*p) || !(isupper((int)*p) || isdigit((int)*p) || *p == '_')) {
            return false;
        }
    }

    /*
     * errsym matches: ^E_[A-Z][A-Z0-9_]+$
     */
    return true;
}

/*
 * is_e_2string - E_STRING is of the form E__ followed by letters and digits and underscores
 *
 * This function determines of errsym matches the regular expression:
 *
 *      ^E__[A-Z][A-Z0-9_]+$
 *
 * This function will not match the special E_STRING is of the form E_ followed by
 * letters and digits and underscores.  For that see is_e_1string().
 *
 * given:
 *      errsym  E_STRING to check
 *
 * returns:
 *      true ==> E_STRING matches the regular expression: ^E__[A-Z][A-Z0-9_]+$
 *      false ==> E_STRING is NULL and/or does not match expression: ^E__[A-Z][A-Z0-9_]+$
 */
bool
is_e_2string(const char *errsym)
{
    const char *p;

    /*
     * firewall
     */
    if (errsym == NULL) {
        return false;
    }

    /*
     * must start with E_
     */
    if (strncmp(errsym, "E__", 3) != 0) {
        return false;
    }

    /*
     * length must be >= 4
     */
    if (errsym[3] == '\0') {
        return false;
    }

    /*
     * errsym, after E__, must be an UPPER case letter
     */
    if (!isascii(errsym[3]) || !isupper(errsym[3])) {
        return false;
    }

    /*
     * must match regular expression: ^E__[A-Z][A-Z0-9_]+$
     */
    for (p = errsym + 4; *p != '\0'; ++p) {
        if (!isascii(*p) || !(isupper(*p) || isdigit(*p) || *p == '_')) {
            return false;
        }
    }

    /*
     * errsym matches: ^E__[A-Z][A-Z0-9_]+$
     */
    return true;
}

/*
 * find_errsym_in_errtbl - given an E_STRING find it in a struct errtbl array
 *
 * given:
 *      errsym  E_STRING to check
 *      tbl     pointer to a NULL an array of struct errtbl with a final NULL entry
 *
 * returns:
 *      != NULL ==> pointer to entry in tbl struct errtbl entry with matching errsym
 *      NULL ==> NULL arg, or errsym not found
 */
struct errtbl *
find_errsym_in_errtbl(const char *errsym, const struct errtbl *tbl)
{
    const struct errtbl *ret; /* pointer to struct errtbl entry with matching errsym */

    /*
     * firewall
     */
    if (errsym == NULL || tbl == NULL) {
        /* invalid NULL arg(s) */
        return NULL;
    }

    /*
     * scan tbl until final NULL entry
     */
    for (ret = tbl; ret->errsym != NULL; ++ret) {
        if (strcmp(ret->errsym, errsym) == 0) {
            /* found matching errsym */
            return (struct errtbl *)ret;
        }
    }
    /* no match */
    return NULL;
}

/*
 * find_errnum_in_errtbl - given a valid errnum, search for it in a struct errtbl array
 *
 * This function assumes that the errnum values in a struct errtbl array are
 * both valid errnum and ascending.  The function verify_error_table() will verify that
 * this is the case for both error_table[] and private_error_alias[].
 *
 * See also lookup_errnum_in_error_table() for a faster way to do:
 *
 *      find_errnum_in_errtbl(errnum, error_table); (* use lookup_errnum_in_error_table() instead *)
 *
 * given:
 *      errnum  the errnum code to seach for
 *      tbl     pointer to a NULL an array of struct errtbl with a final NULL entry
 *
 * returns:
 *      != NULL ==> pointer to entry in tbl struct errtbl entry with matching
 *      NULL ==> NULL arg, or matching errnum not foun
 */
struct errtbl *
find_errnum_in_errtbl(int errnum, const struct errtbl *tbl)
{
    const struct errtbl *ret; /* pointer to struct errtbl entry with matching errsym */

    /*
     * firewall
     */
    if (tbl == NULL) {
        /* invalid NULL arg */
        return NULL;
    }
    if (is_valid_errnum(errnum) == false) {
        /* invalid errnum */
        return NULL;
    }

    /*
     * scan tbl until final NULL entry
     */
    for (ret = tbl; ret->errsym != NULL; ++ret) {

        /* case: found errnum match */
        if (ret->errnum == errnum) {
            /* found matching errnum */
            return (struct errtbl *)ret;
        }

        /* case: we passed errnum in struct errtbl array */
        if (ret->errnum > errnum) {
            /* we have searched beyond errnum: everthing else is > errnum */
            return NULL;
        }
    }
    /* no match */
    return NULL;
}

/*
 * lookup_errnum_in_error_table - lookup errnum within error_table[] array
 *
 * This function searches for errnum within the error_table[] array
 * by using the fact that the error_table[] array contains a compact
 * sequential set of errnum values from E__BASE thru and including E__HIGHEST.
 *
 * This function performs the equivalent of:
 *
 *      find_errnum_in_errtbl(errnum, error_table); (* use lookup_errnum_in_error_table() instead *)
 *
 * given:
 *      errnum  the errnum code to seach for
 *
 * returns:
 *      != NULL ==> pointer to entry in error_table[] array with matching errnum
 *      NULL ==> NULL arg, or no matching errnum in error_table[] array
 */
const struct errtbl *
lookup_errnum_in_error_table(int errnum)
{
    const struct errtbl *ret; /* pointer to struct errtbl entry with matching errsym */
    int offset;               /* offset within the error_table[] array */

    /*
     * firewall - errnum must be valid
     */
    if (is_errnum_in_error_table(errnum) == false) {
        /* errnum is not a valid or not within the error_table[] array range */
        return NULL;
    }

    /*
     * paranoia
     */
    if (errnum < E__BASE || errnum > (long)MY_E__HIGHEST) {
        /* errnum is outside of the error_table[] array range */
        return NULL;
    }
    offset = errnum - E__BASE;
    if (offset < 0 || offset > (long)(sizeof(error_table) / sizeof(error_table[0]))) {
        /* offset is outside of the error_table[] array */
        return NULL;
    }

    /*
     * fetch entry from error_table[] array that should have the errnum value
     */
    ret = &error_table[offset];
    if (ret->errnum != errnum) {
        /* error_table[] entry has the wrong errnum */
        return NULL;
    }

    /*
     * return error_table[] array matching the errnum value
     */
    return ret;
}

/*
 * verify_error_table - verify the consistency of the error_table
 *
 * For error_table[]:
 *
 *      The errnum must start with E__BASE and be consecutive until the final entry.
 *
 *      With the exception of the 1st "E__BASE" entry, the errsym must be a non-NULL string that
 *      matches, up until the last entry, the regular expression:
 *
 *              ^E_[A-Z][A-Z0-9_]+$
 *
 *      The errmsg must be a non-NULL non-empty string until the last entry.
 *
 *      The final entry must have an errnum of NULL_ERRNUM (-1), errsym of NULL and errmsg of NULL.
 *
 * For private_error_alias[]:
 *
 *      This function also verifies the private_error_alias[] array.
 *
 *      With the exception of the last entry, the errsym must be a non-NULL string that
 *      matches regular expression:
 *
 *              ^E__[A-Z][A-Z0-9_]+$
 *
 *      The errmsg of the E__HIGHEST errsym entry points to the
 *      corresponding error_table[] entry's MY_E__HIGHEST errsym
 *      so that E__HIGHEST becomes an alias for the highest assigned
 *      calc computation error code.
 *
 *      The errmsg must be a non-NULL non-empty string until the last entry.
 *
 *      The final entry must have an errnum of NULL_ERRNUM (-1), errsym of NULL and errmsg of NULL.
 *
 * This function does not return on error or if the error_table is invalid.
 *
 * Use the seqcexit tool to keep the exit codes for this function unique, starting with 10.
 * Apply the following command in this soure code:
 *
 *      seqcexit errtbl.c
 *
 * For more information on the seqcexit tool, see:
 *
 *      https://github.com/lcn2/seqcexit
 */
void
verify_error_table(void)
{
    size_t len;           /* length of the error_table[] */
    size_t e__count;      /* computed ECOUNT value */
    size_t priv_len;      /* length of the private_error_alias[] */
    size_t priv_e__count; /* computed MY_PRIV_ECOUNT value */
    struct errtbl *found; /* pointer to E__HIGHEST errsym entry in private_error_alias[] or NULL */
    int prev_errnum;      /* previous errnum found in private_error_alias[] */
    long ten;             /* used to try an compute 10^USERMAX_DIGITS */
    VALUE test;           /* value to test if E__USERMAX fits into a v_type */
    size_t i;

    /*
     * verify error_table[] size
     */
    len = sizeof(error_table) / sizeof(error_table[0]);
    e__count = len - 2;
    if (e__count != MY_ECOUNT) {
        fprintf(stderr, "**** %s ERROR: error_table length: %zu != MY_ECOUNT+2: %lu\n", program, len,
                (unsigned long)MY_ECOUNT + 2);
        exit(10); /*coo*/
    }

    /*
     * verify the initial errnum of the 1st error_table[] entry
     */
    if (error_table[0].errnum != E__BASE) {
        fprintf(stderr, "**** %s ERROR: initial entry error_table[0].errnum: %d must == E__BASE: %d\n", program,
                error_table[0].errnum, E__BASE);
        exit(11);
    }
    if (error_table[0].errsym == NULL) {
        fprintf(stderr, "**** %s ERROR: error_table[0].errsym must != NULL\n", program);
        exit(12);
    }
    if (strcmp(error_table[0].errsym, "E__BASE") != 0) {
        fprintf(stderr, "**** %s ERROR: error_table[0].errsym: %s must be E__BASE\n", program, error_table[0].errsym);
        exit(13);
    }
    if (error_table[0].errmsg == NULL) {
        fprintf(stderr, "**** %s ERROR: error_table[0].errmsg must != NULL\n", program);
        exit(14);
    }
    if (strlen(error_table[0].errmsg) <= 0) {
        fprintf(stderr, "**** %s ERROR: error_table[0].errmsg length: %zu must be > 0\n", program, strlen(error_table[0].errmsg));
        exit(15);
    }

    /*
     * verify 2nd thru end to last entry of error_table[]
     */
    for (i = 1; i < len - 1; ++i) {

        /*
         * check errnum - must be consecutive starting with E__BASE
         */
        if ((size_t)error_table[i].errnum != E__BASE + i) {
            fprintf(stderr, "**** %s ERROR: error_table[%zu].errnum: %d != %lu\n", program, i, error_table[i].errnum,
                    (unsigned long)E__BASE + i);
            exit(16);
        }

        /*
         * check if errsym is non-NULL
         */
        if (error_table[i].errsym == NULL) {
            fprintf(stderr, "**** %s ERROR: error_table[%zu]..errsym must != NULL\n", program, i);
            exit(17);
        }

        /*
         * check if errsym is matches the regular expression: ^E_[A-Z][A-Z0-9_]+$
         */
        if (is_e_1string(error_table[i].errsym) == false) {
            fprintf(stderr,
                    "**** %s ERROR: error_table[%zu].errsym: %s "
                    "must match the regular expression: %s\n",
                    program, i, error_table[i].errsym, "^E_[A-Z][A-Z0-9_]+$");
            exit(18);
        }

        /*
         * verify error_table[] entry errmsg is not NULL
         */
        if (error_table[i].errmsg == NULL) {
            fprintf(stderr, "**** %s ERROR: error_table[%zu].errmsg must != NULL\n", program, i);
            exit(19);
        }

        /*
         * verify error_table[] entry errmsg is not empty
         */
        if (error_table[i].errmsg[0] == '\0') {
            fprintf(stderr, "**** %s ERROR: error_table[%zu].errmsg length: %zu must be > 0\n", program, i,
                    strlen(error_table[i].errmsg));
            exit(20);
        }
    }

    /*
     * verify 2nd to last error_table[] entry has the MY_E__HIGHEST errnum
     */
    if (error_table[len - 2].errnum != MY_E__HIGHEST) {
        fprintf(stderr,
                "**** %s ERROR: highest assigned calc computation error code entry "
                "error_table[%zu].errnum: %d must == %lu\n",
                program, len - 2, error_table[len - 2].errnum, (unsigned long)MY_E__HIGHEST);
        exit(21);
    }

    /*
     * verify the last error_table[] entry
     */
    if (error_table[len - 1].errnum != NULL_ERRNUM) {
        fprintf(stderr, "**** %s ERROR: final NULL entry error_table[%zu].errnum: %d must == %d\n", program, len - 1,
                error_table[len - 1].errnum, NULL_ERRNUM);
        exit(22);
    }
    if (error_table[len - 1].errsym != NULL) {
        fprintf(stderr, "**** %s ERROR: final NULL entry error_table[%zu].errsym must == NULL\n", program, len - 1);
        exit(23);
    }
    if (error_table[len - 1].errmsg != NULL) {
        fprintf(stderr, "**** %s ERROR: final NULL entry error_table[%zu].errmsg must == NULL\n", program, len - 1);
        exit(24);
    }

    /*
     * verify private_error_alias[] size
     */
    priv_len = sizeof(private_error_alias) / sizeof(private_error_alias[0]);
    priv_e__count = priv_len - 1;
    if (priv_e__count != MY_PRIV_ECOUNT) {
        fprintf(stderr, "**** %s ERROR: private_error_alias length: %zu must == MY_PRIV_ECOUNT+1: %lu\n", program, priv_len,
                (unsigned long)MY_PRIV_ECOUNT + 1);
        exit(25);
    }

    /*
     * setup the E__HIGHEST entry in private_error_alias[] to be an alias for
     * the highest assigned calc computation error code from error_table[].
     */
    found = find_errsym_in_errtbl("E__HIGHEST", private_error_alias);
    if (found == NULL) {
        fprintf(stderr, "**** %s ERROR: private_error_alias missing E__HIGHEST errsym entry", program);
        exit(26);
    }
    found->errnum = error_table[len - 2].errnum;
    found->errmsg = error_table[len - 2].errmsg;

    /*
     * verify 1st private_error_alias[] entry == (E__NONE) 0
     */
    if (private_error_alias[0].errnum != 0) {
        fprintf(stderr, "**** %s ERROR: initial entry error_table[0].errnum: %d myst == 0\n", program, error_table[0].errnum);
        exit(27);
    }
    if (private_error_alias[0].errnum != E__NONE) {
        fprintf(stderr, "**** %s ERROR: initial entry error_table[0].errnum: %d must == E__NONE: %d\n", program,
                error_table[0].errnum, E__NONE);
        exit(28);
    }

    /*
     * verify all but the final private_error_alias[] entry
     */
    prev_errnum = INV_ERRNUM; /* preset previous errnum to INV_ERRNUM, and <0 value */
    for (i = 0; i < priv_len - 1; ++i) {

        /*
         * The private_error_alias[] entry errnum must be >= 0
         */
        if (private_error_alias[i].errnum < 0) {
            fprintf(stderr, "**** %s ERROR: entry private_error_alias[%zu].errnum: %d must be >= 0\n", program, i,
                    private_error_alias[i].errnum);
            exit(29);
        }
        if (i > 0) {
            if (private_error_alias[i].errnum <= prev_errnum) {
                fprintf(stderr,
                        "**** %s ERROR: entry private_error_alias[%zu].errnum: %d "
                        "must be > private_error_alias[%zu].errnum: %d\n",
                        program, i, private_error_alias[i].errnum, i - 1, prev_errnum);
                exit(30);
            }
        }
        prev_errnum = private_error_alias[i].errnum;

        /*
         * The private_error_alias[] entry errsym must not be NULL
         */
        if (private_error_alias[i].errsym == NULL) {
            fprintf(stderr, "**** %s ERROR: entry private_error_alias[%zu].errsym must != NULL\n", program, i);
            exit(31);
        }

        /*
         * check errsym that is string matching the regular expression: ^E__[A-Z][A-Z0-9_]+$
         */
        if (is_e_2string(private_error_alias[i].errsym) == false) {
            fprintf(stderr,
                    "**** %s ERROR: private_error_alias[%zu].errsym: %s "
                    "E_STRING must match the regular expression: %s\n",
                    program, i, private_error_alias[i].errsym, "^E__[A-Z][A-Z0-9_]+$");
            exit(32);
        }

        /*
         * verify private_error_alias[] entry errmsg is not NULL
         */
        if (private_error_alias[i].errmsg == NULL) {
            fprintf(stderr, "**** %s ERROR: private_error_alias[%zu].errmsg must != NULL\n", program, i);
            exit(33);
        }

        /*
         * verify private_error_alias[] entry errmsg is not empty
         */
        if (private_error_alias[i].errmsg[0] == '\0') {
            fprintf(stderr, "**** %s ERROR: private_error_alias[%zu].errmsg length: %zu must be > 0\n", program, i,
                    strlen(private_error_alias[i].errmsg));
            exit(34);
        }
    }

    /*
     * verify the last private_error_alias[] entry
     */
    if (private_error_alias[priv_len - 1].errnum != NULL_ERRNUM) {
        fprintf(stderr, "**** %s ERROR: final NULL entry private_error_alias[%zu].errnum: %d must == %d\n", program, priv_len - 1,
                private_error_alias[priv_len - 1].errnum, NULL_ERRNUM);
        exit(35);
    }
    if (private_error_alias[priv_len - 1].errsym != NULL) {
        fprintf(stderr, "**** %s ERROR: final NULL entry private_error_alias[%zu].errsym must == NULL\n", program, priv_len - 1);
        exit(36);
    }
    if (private_error_alias[priv_len - 1].errmsg != NULL) {
        fprintf(stderr, "**** %s ERROR: final NULL entry private_error_alias[%zu].errmsg must == NULL\n", program, priv_len - 1);
        exit(37);
    }

    /*
     * verify USERMAX_DIGITS is correct with respect to the size of E__USERMAX
     */
    if (USERMAX_DIGITS <= 0) {
        fprintf(stderr, "**** %s ERROR: USERMAX_DIGITS: %d must be > 0\n", program, USERMAX_DIGITS);
        exit(38);
    }
    if (USERMAX_DIGITS > 20) {
        fprintf(stderr, "**** %s ERROR: USERMAX_DIGITS: %d must be <= 20\n", program, USERMAX_DIGITS);
        exit(39);
    }
    for (i = 0, ten = 1; ten > 0 && ten <= E__USERMAX; ++i) {
        ten *= 10;
    }
    if (i != USERMAX_DIGITS) {
        fprintf(stderr, "**** %s ERROR: USERMAX_DIGITS: %d must be == %ld\n", program, USERMAX_DIGITS, (unsigned long)i);
        exit(40);
    }

    /*
     * verify that E__USERMAX can fit into a value.v_type
     *
     * When a VALUE indicates an error, value.v_type is set to < 0.
     * So we need to test if -E__USERMAX can be stored into a test.v_type.
     */
    test.v_type = -E__USERMAX;
    if (-E__USERMAX != test.v_type) {
        fprintf(stderr, "**** %s ERROR: E__USERMAX: %d cannot fit into a value.v_type of size: %lu\n", program, E__USERMAX,
                (unsigned long)sizeof(test.v_type));
        exit(41);
    }
    return;
}

/*
 * errsym_2_errnum - convert a valid errsym to errnum
 *
 * We will convert E_STRING of E_digits into errnum if digits as a valid errnum,
 * otherwise we will search private_error_alias[] if E_STRING is of E__ form,
 * otherwise we will search error_table[] if E_STRING is of E_ form,
 * otherwise we will return NULL_ERRNUM.
 *
 * given:
 *      errsym  pointer to a E_STRING
 *
 * returns:
 *      != NULL_ERRNUM ==> valid errnum corresponding to a valid E_STRING errsym
 *      == NULL_ERRNUM ==> errsym is NULL, not valid E_STRING errsym,
 *                         or no corresponding errnum found
 */
int
errsym_2_errnum(const char *errsym)
{
    struct errtbl *found; /* pointer to entry in struct errtbl array with matching errsym */
    int errnum;           /* errnum to return */

    /*
     * firewall
     */
    if (errsym == NULL) {
        /* errsym is NULL */
        return NULL_ERRNUM;
    }

    /*
     * case: E_STRING is a E_digits errsym
     */
    errnum = e_digits_2_errnum(errsym);
    if (is_valid_errnum(errnum) == true) {
        /* digits of E_digits is a valid errnum */
        return errnum;
    }

    /*
     * case: E_STRING is a E_digits but errnum is not valid
     */
    if (is_e_digits(errsym) == true) {
        /* E_digits but digits to not form a valid errnum */
        return NULL_ERRNUM;
    }

    /*
     * case: E_STRING is a known E__ errsym
     */
    if (is_e_2string(errsym) == true) {

        /*
         * look in private_error_alias[] for E__ errsym
         */
        found = find_errsym_in_errtbl(errsym, private_error_alias);
        if (found != NULL) {
            /* return matching errnum */
            return found->errnum;
        }
    }

    /*
     * case: E_STRING is a known E_ errsym
     */
    if (is_e_1string(errsym) == true) {

        /*
         * look in error_table[] for E_ errsym
         */
        found = find_errsym_in_errtbl(errsym, error_table);
        if (found != NULL) {
            /* return matching errnum */
            return found->errnum;
        }
    }

    /*
     * cannot convert errsym to a valid errnum
     */
    return NULL_ERRNUM;
}

/*
 * The code below is not compatible with the errcode executable
 */
#if !defined(ERRCODE_SRC)

/*
 * errnum_2_errsym - convert an errnum value into an errsym E_STRING, possibly malloced
 *
 * given:
 *      errnum          errnum code to convert
 *      palloced        pointer to bool to be set if errsym E_STRING was malloced
 *
 * return:
 *      != NULL ==> E_STRING for errnum (malloced if *palloced == true, static is not)
 *      == NULL ==> errnum is not valid, or palloced is NULL
 */
char *
errnum_2_errsym(int errnum, bool *palloced)
{
    char *ret;                  /* return string, possibly malloced */
    const struct errtbl *entry; /* struct errtbl entry lookup found or NULL */
    size_t snprintf_len;        /* malloced snprintf buffer length */

    /*
     * firewall
     */
    if (palloced == NULL) {
        /* palloced is NULL */
        return NULL;
    }
    if (is_valid_errnum(errnum) == false) {
        /* errnum is not a valid code */
        *palloced = false;
        return NULL;
    }

    /*
     * case: errnum is within in the error_table[] array bounds
     */
    if (is_errnum_in_error_table(errnum) == true) {

        /*
         * struct errtbl entry found
         */
        entry = lookup_errnum_in_error_table(errnum);
        if (entry == NULL) {
            /* lookup failed, return NULL */
            *palloced = false;
            return NULL;
        }

        /*
         * return non-malloced errsym
         */
        *palloced = false;
        ret = entry->errsym;
        return ret;
    }

    /*
     * case: form a malloced E_STRING of E_digits
     */
    snprintf_len = sizeof("E_") - 1 + USERMAX_DIGITS + 1; /* + 1 for trailing NUL */
    ret = calloc(snprintf_len + 1, 1);                    /* +1 for paranoia */
    if (ret == NULL) {
        math_error("Out of memory for errnum_2_errsym");
        not_reached();
    }
    *palloced = true;
    snprintf(ret, snprintf_len, "E_%d", errnum);
    ret[snprintf_len] = '\0'; /* paranoia */

    /*
     * return alloced E_STRING of E_digits
     */
    return ret;
}

/*
 * errnum_2_errmsg - convert an errnum value into an errmsg string, possibly malloced
 *
 * given:
 *      errnum          errnum code to convert
 *      palloced        pointer to bool to be set if errmsg string was malloced
 *
 * return:
 *      != NULL ==> errmsg string for errnum (malloced if *palloced == true, static is not)
 *      == NULL ==> errnum is not valid, or palloced is NULL
 */
char *
errnum_2_errmsg(int errnum, bool *palloced)
{
    char *ret;                  /* return string, possibly malloced */
    const struct errtbl *entry; /* struct errtbl entry lookup found or NULL */
    size_t snprintf_len;        /* malloced snprintf buffer length */

    /*
     * firewall
     */
    if (palloced == NULL) {
        /* palloced is NULL */
        return NULL;
    }
    if (is_valid_errnum(errnum) == false) {
        /* errnum is not a valid code */
        *palloced = false;
        return NULL;
    }

    /*
     * case: errnum is within in the error_table[] array bounds
     */
    if (is_errnum_in_error_table(errnum) == true) {

        /*
         * struct errtbl entry found
         */
        entry = lookup_errnum_in_error_table(errnum);
        if (entry == NULL) {
            /* lookup failed, return NULL */
            *palloced = false;
            return NULL;
        }

        /*
         * return non-malloced errmsg
         */
        *palloced = false;
        ret = entry->errmsg;

        /*
         * case: errnum is a user-described errno
         */
    } else if (errnum >= E__USERDEF && errnum <= E__USERMAX) {

        /*
         * return non-malloced errmsg
         */
        *palloced = false;
        ret = name_newerrorstr(errnum);
        if (ret == NULL) {
            snprintf_len = sizeof("Unknown user error ") - 1 + USERMAX_DIGITS + 1; /* + 1 for trailing NUL */
            ret = calloc(snprintf_len + 1, 1);                                     /* +1 for paranoia */
            if (ret == NULL) {
                math_error("Out of memory #0 for errnum_2_errmsg");
                not_reached();
            }
            *palloced = true;
            snprintf(ret, snprintf_len, "Unknown user error %d", errnum);
            ret[snprintf_len] = '\0'; /* paranoia */
        }

        /*
         * case: errnum is 0
         */
    } else if (errnum == E__NONE) {

        /*
         * return "No error"
         */
        *palloced = false;
        ret = "No error";

        /*
         * case: errnum is a system errno
         */
    } else if (errnum > E__NONE && errnum < E__BASE) {

        /*
         * return non-malloced result of strerror()
         */
        *palloced = false;
        ret = strerror(errnum);
        if (ret == NULL) {
            snprintf_len = sizeof("Unknown system error ") - 1 + USERMAX_DIGITS + 1; /* + 1 for trailing NUL */
            ret = calloc(snprintf_len + 1, 1);                                       /* +1 for paranoia */
            if (ret == NULL) {
                math_error("Out of memory #1 for errnum_2_errmsg");
                not_reached();
            }
            *palloced = true;
            snprintf(ret, snprintf_len, "Unknown system error %d", errnum);
            ret[snprintf_len] = '\0'; /* paranoia */
        }

        /*
         * case: unknown errnum
         */
    } else {
        snprintf_len = sizeof("Unknown error ") - 1 + USERMAX_DIGITS + 1; /* + 1 for trailing NUL */
        ret = calloc(snprintf_len + 1, 1);                                /* +1 for paranoia */
        if (ret == NULL) {
            math_error("Out of memory #2 for errnum_2_errmsg");
            not_reached();
        }
        *palloced = true;
        snprintf(ret, snprintf_len, "Unknown error %d", errnum);
        ret[snprintf_len] = '\0'; /* paranoia */
    }

    /*
     * return possibly allocated errmsg string
     */
    return ret;
}

/*
 * errsym_2_errmsg - convert convert an E_STRING into an errmsg string, possibly malloced
 *
 * given:
 *      errsym          E_STRING to convert
 *      palloced        pointer to bool to be set if errmsg string was malloced
 *
 * return:
 *      != NULL ==> errmsg string for errsym (malloced if *palloced == true, static is not)
 *      == NULL ==> errsym is not valid, or palloced is NULL, or errsym is NULL
 */
char *
errsym_2_errmsg(const char *errsym, bool *palloced)
{
    int errnum; /* errsym E_STRING converted to errnum code or NULL_ERRNUM */
    char *ret;  /* errmsg string, possibly malloced, or NULL */

    /*
     * firewall
     */
    if (palloced == NULL) {
        /* palloced is NULL */
        return NULL;
    }
    if (errsym == NULL) {
        /* errsym is NULL */
        *palloced = false;
        return NULL;
    }

    /*
     * convert errsym E_STRING to errnum
     */
    errnum = errsym_2_errnum(errsym);
    if (is_valid_errnum(errnum) == false) {
        /* errsym did not convert into a valid errnum code */
        *palloced = false;
        return NULL;
    }

    /*
     * return errnum value into an errmsg string, possibly malloced or return NULL
     */
    ret = errnum_2_errmsg(errnum, palloced);
    return ret;
}

#endif

/*
 * The code below is used to form the errcode executable and is NOT part of libcalc
 */
#if defined(ERRCODE_SRC)

/*
 * errcode command line
 */
const char *usage = "usage: %s [-h] [-e | -d]\n"
                    "\n"
                    "\t-h\tprint help and exit\n"
                    "\t-e\tprint the contents of help/errorcodes\n"
                    "\t-d\tprint the contents of errsym.h\n"
                    "\n"
                    "Exit codes:\n"
                    "    0\t\tall is OK\n"
                    "    2\t\t-h and help string\n"
                    "    3\t\tcommand line error\n"
                    " >=10\t\terror_table[] and/or private_error_alias[] is invalid\n";

char *program = "((NULL))"; /* our name */

/*
 * print_errorcodes - print the help/errorcodes file
 */
static void
print_errorcodes(void)
{
    /*
     * print the help/errorcodes file header
     */
    size_t len; /* length of the error_table */
    size_t i;

    /*
     * print the help/errorcodes file header
     */
    printf("## DO NOT EDIT - This file was generated by errcode -e via the Makefile\n"
           "Calc computation error codes\n"
           "\n"
           "\"E_STRING\"\terrnum\tCalc computation error message\n"
           "----------\t------\t------------------------------\n"
           "\n"
           "\"E__NONE\"\t%d\tcalc_errno cleared: libc errno codes above here\n"
           "\"E__BASE\"\t%d\tReserved for \"No error\" calc internal state\n"
           "\n",
           E__NONE, E__BASE);

    /*
     * print the error message lines
     */
    len = sizeof(error_table) / sizeof(error_table[0]);
    for (i = 1; i < len - 1; ++i) {
        if (strlen(error_table[i].errsym) < 6) {
            printf("\"%s\"\t\t%d\t%s\n", error_table[i].errsym, error_table[i].errnum, error_table[i].errmsg);
        } else {
            printf("\"%s\"\t%d\t%s\n", error_table[i].errsym, error_table[i].errnum, error_table[i].errmsg);
        }
    }

    /*
     * print the help/errorcodes file trailer
     */
    printf("\n"
           "\"E__HIGHEST\"\t%lu\thighest assigned calc computation error code\n"
           "\"E__USERDEF\"\t%lu\tuser defined error codes start here\n"
           "\"E__USERMAX\"\t%lu\tmaximum user defined error code\n",
           (unsigned long)MY_E__HIGHEST, (unsigned long)E__USERDEF, (unsigned long)E__USERMAX);
    printf("\n"
           "## Copyright (C) %d  Landon Curt Noll\n"
           "##\n"
           "## Calc is open software; you can redistribute it and/or modify it under\n"
           "## the terms of the version 2.1 of the GNU Lesser General Public License\n"
           "## as published by the Free Software Foundation.\n"
           "##\n"
           "## Calc is distributed in the hope that it will be useful, but WITHOUT\n"
           "## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n"
           "## or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General\n"
           "## Public License for more details.\n"
           "##\n"
           "## A copy of version 2.1 of the GNU Lesser General Public License is\n"
           "## distributed with calc under the filename COPYING-LGPL.  You should have\n"
           "## received a copy with calc; if not, write to Free Software Foundation, Inc.\n"
           "## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\n"
           "##\n"
           "## Under source code control:   n/a\n"
           "## File existed as early as:    n/a\n"
           "##\n"
           "## chongo <was here> /\\oo/\\     http://www.isthe.com/chongo/\n"
           "## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/\n",
           ERRTBL_COPYRIGHT_YEAR);
    return;
}

/*
 * print_errsym - print the contents of errsym.h
 */
static void
print_errsym(void)
{
    size_t len; /* length of the error_table */
    size_t i;

    /*
     * print the errsym.h file header
     */
    printf("/*\n"
           " * DO NOT EDIT - This file was generated by errcode -d via the Makefile\n"
           " *\n"
           " * Copyright (C) %d  Landon Curt Noll\n"
           " *\n"
           " * Calc is open software; you can redistribute it and/or modify it under\n"
           " * the terms of the version 2.1 of the GNU Lesser General Public License\n"
           " * as published by the Free Software Foundation.\n"
           " *\n"
           " * Calc is distributed in the hope that it will be useful, but WITHOUT\n"
           " * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n"
           " * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General\n"
           " * Public License for more details.\n"
           " *\n"
           " * A copy of version 2.1 of the GNU Lesser General Public License is\n"
           " * distributed with calc under the filename COPYING-LGPL.  You should have\n"
           " * received a copy with calc; if not, write to Free Software Foundation, Inc.\n"
           " * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\n"
           " *\n"
           " * Under source code control:   n/a\n"
           " * File existed as early as:    n/a\n"
           " *\n"
           " * chongo <was here> /\\oo/\\     http://www.isthe.com/chongo/\n"
           " * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/\n"
           " */\n"
           "\n"
           "\n"
           "#if !defined(INCLUDE_ERRSYM_H)\n"
           "#define INCLUDE_ERRSYM_H\n"
           "\n"
           "\n",
           ERRTBL_COPYRIGHT_YEAR);

    /*
     * print the #define lines
     */
    len = sizeof(error_table) / sizeof(error_table[0]);
    for (i = 1; i < len - 1; ++i) {
        if (strlen(error_table[i].errsym) < 8) {
            printf("#define %s\t\t%d\t/* %s */\n", error_table[i].errsym, error_table[i].errnum, error_table[i].errmsg);
        } else {
            printf("#define %s\t%d\t/* %s */\n", error_table[i].errsym, error_table[i].errnum, error_table[i].errmsg);
        }
    }

    /*
     * print the errsym.h file trailer
     */
    printf("\n"
           "#define E__HIGHEST\t%lu\t/* highest assigned calc computation error code */\n"
           "\n"
           "#define ECOUNT\t%lu\t/* number of calc computation error codes w/o E__BASE */\n",
           (unsigned long)MY_E__HIGHEST, (unsigned long)MY_ECOUNT);
    printf("\n"
           "\n"
           "#endif\n");
    return;
}

int
main(int argc, char *argv[])
{
    int e_flag = 0; /* 1 ==> -e flag was used */
    int d_flag = 0; /* 1 ==> -s flag was used */
    int i;

    /*
     * parse args
     */
    program = argv[0];
    while ((i = getopt(argc, argv, "hed")) != -1) {
        switch (i) {
        case 'h':
            fprintf(stderr, usage, program);
            exit(2); /*ooo*/
        case 'e':
            e_flag = 1;
            break;
        case 'd':
            d_flag = 1;
            break;
        default:
            fprintf(stderr, "**** %s ERROR: invalid command line\n", program);
            fprintf(stderr, usage, program);
            exit(3); /*ooo*/
        }
    }
    if (e_flag && d_flag) {
        fprintf(stderr, "**** %s ERROR: -e and -d conflict\n", program);
        fprintf(stderr, usage, program);
        exit(3); /*ooo*/
    }

    /*
     * verify the consistency of the error_table
     */
    verify_error_table();

    /*
     * -e - print the contents of help/errorcodes
     */
    if (e_flag) {
        print_errorcodes();
    }

    /*
     * -d - print the contents of errsym.h
     */
    if (d_flag) {
        print_errsym();
    }

    /*
     * All Done!!! -- Jessica Noll, Age 2
     */
    exit(0); /*ooo*/
}

#endif
