drygdryg/calc
1
0
Fork 0
mirror of https://github.com/lcn2/calc.git synced 2025-08-16 01:03:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
calc/errtbl.c

2248 lines
106 KiB
C
Raw Permalink Blame History

/*
* 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 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 */
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "func.h"
#include "errtbl.h"
#include "bool.h"
/*
* Copyright (C) year for generated files
*/
#define ERRTBL_COPYRIGHT_YEAR 2023
/*
* 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 fsize or fpos 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 fsize or fpos 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 /* !ERRCODE_SRC */
/*
* 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
*/
S_FUNC 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
*/
S_FUNC 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 /* !INCLUDE_ERRSYM_H */\n");
return;
}
int
main(int argc, char *argv[])
{
EXTERN char *optarg; /* argv index of the next arg */
EXTERN int optind; /* argv index of the next arg */
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 /* ERRCODE_SRC */
Reference in New Issue View Git Blame Copy Permalink