diff --git a/CHANGES b/CHANGES index d820b1e..7f097df 100644 --- a/CHANGES +++ b/CHANGES @@ -339,6 +339,10 @@ The following are the changes from calc version 2.14.3.5 to date: Supplying a non-integer numeric errnum code to error(), errno(), strerror(), or errsym() will result in an error. + Added tests to the calc regression test suite (cal/regress.cal) to + verify that the errnum calc computation error codes and their + E_STRING values have not changed. + The following are the changes from calc version 2.14.3.4 to 2.14.3.5: diff --git a/cal/regress.cal b/cal/regress.cal index c96323b..3154d53 100644 --- a/cal/regress.cal +++ b/cal/regress.cal @@ -9925,6 +9925,579 @@ vrfy_errsym( print '9920: ending test of error("E_STRING") errno("E_STRING"), strerror("E_STRING") and errsym("E_STRING")'; +/* + * test 10ddd: verify E_STRING values for calc computation error codes + * + * We verify that the errnum calc computation error codes and + * their E_STRING values match. If someone messes up the error_table[] table + * that would impact user code, one or more of the tests (test 10ddd) will fail. + */ +print; +print '10000: verify E_STRING values for calc computation error codes'; +vrfy_errsym(10001, 10001, "E_DIVBYZERO"); +vrfy_errsym(10002, 10002, "E_ZERODIVZERO"); +vrfy_errsym(10003, 10003, "E_ADD"); +vrfy_errsym(10004, 10004, "E_SUB"); +vrfy_errsym(10005, 10005, "E_MUL"); +vrfy_errsym(10006, 10006, "E_DIV"); +vrfy_errsym(10007, 10007, "E_NEG"); +vrfy_errsym(10008, 10008, "E_SQUARE"); +vrfy_errsym(10009, 10009, "E_INV"); +vrfy_errsym(10010, 10010, "E_INCV"); +vrfy_errsym(10011, 10011, "E_DECV"); +vrfy_errsym(10012, 10012, "E_INT"); +vrfy_errsym(10013, 10013, "E_FRAC"); +vrfy_errsym(10014, 10014, "E_CONJ"); +vrfy_errsym(10015, 10015, "E_APPR_1"); +vrfy_errsym(10016, 10016, "E_APPR_2"); +vrfy_errsym(10017, 10017, "E_APPR_3"); +vrfy_errsym(10018, 10018, "E_ROUND_1"); +vrfy_errsym(10019, 10019, "E_ROUND_2"); +vrfy_errsym(10020, 10020, "E_ROUND_3"); +vrfy_errsym(10021, 10021, "E_BROUND"); +vrfy_errsym(10022, 10022, "E_BROUND_2"); +vrfy_errsym(10023, 10023, "E_BROUND_3"); +vrfy_errsym(10024, 10024, "E_SQRT_1"); +vrfy_errsym(10025, 10025, "E_SQRT_2"); +vrfy_errsym(10026, 10026, "E_SQRT_3"); +vrfy_errsym(10027, 10027, "E_ROOT_1"); +vrfy_errsym(10028, 10028, "E_ROOT_2"); +vrfy_errsym(10029, 10029, "E_ROOT_3"); +vrfy_errsym(10030, 10030, "E_NORM"); +vrfy_errsym(10031, 10031, "E_SHIFT_1"); +vrfy_errsym(10032, 10032, "E_SHIFT_2"); +vrfy_errsym(10033, 10033, "E_SCALE_1"); +vrfy_errsym(10034, 10034, "E_SCALE_2"); +vrfy_errsym(10035, 10035, "E_POWI_1"); +vrfy_errsym(10036, 10036, "E_POWI_2"); +vrfy_errsym(10037, 10037, "E_POWER_1"); +vrfy_errsym(10038, 10038, "E_POWER_2"); +vrfy_errsym(10039, 10039, "E_POWER_3"); +vrfy_errsym(10040, 10040, "E_QUO_1"); +vrfy_errsym(10041, 10041, "E_QUO_2"); +vrfy_errsym(10042, 10042, "E_QUO_3"); +vrfy_errsym(10043, 10043, "E_MOD_1"); +vrfy_errsym(10044, 10044, "E_MOD_2"); +vrfy_errsym(10045, 10045, "E_MOD_3"); +vrfy_errsym(10046, 10046, "E_SGN"); +vrfy_errsym(10047, 10047, "E_ABS_1"); +vrfy_errsym(10048, 10048, "E_ABS_2"); +vrfy_errsym(10049, 10049, "E_EVAL"); +vrfy_errsym(10050, 10050, "E_STR"); +vrfy_errsym(10051, 10051, "E_EXP_1"); +vrfy_errsym(10052, 10052, "E_EXP_2"); +vrfy_errsym(10053, 10053, "E_FPUTC_1"); +vrfy_errsym(10054, 10054, "E_FPUTC_2"); +vrfy_errsym(10055, 10055, "E_FPUTC_3"); +vrfy_errsym(10056, 10056, "E_FGETC_1"); +vrfy_errsym(10057, 10057, "E_FGETC_2"); +vrfy_errsym(10058, 10058, "E_FOPEN_1"); +vrfy_errsym(10059, 10059, "E_FOPEN_2"); +vrfy_errsym(10060, 10060, "E_FREOPEN_1"); +vrfy_errsym(10061, 10061, "E_FREOPEN_2"); +vrfy_errsym(10062, 10062, "E_FREOPEN_3"); +vrfy_errsym(10063, 10063, "E_FCLOSE_1"); +vrfy_errsym(10064, 10064, "E_FFLUSH"); +vrfy_errsym(10065, 10065, "E_FPUTS_1"); +vrfy_errsym(10066, 10066, "E_FPUTS_2"); +vrfy_errsym(10067, 10067, "E_FPUTS_3"); +vrfy_errsym(10068, 10068, "E_FGETS_1"); +vrfy_errsym(10069, 10069, "E_FGETS_2"); +vrfy_errsym(10070, 10070, "E_FPUTSTR_1"); +vrfy_errsym(10071, 10071, "E_FPUTSTR_2"); +vrfy_errsym(10072, 10072, "E_FPUTSTR_3"); +vrfy_errsym(10073, 10073, "E_FGETSTR_1"); +vrfy_errsym(10074, 10074, "E_FGETSTR_2"); +vrfy_errsym(10075, 10075, "E_FGETLINE_1"); +vrfy_errsym(10076, 10076, "E_FGETLINE_2"); +vrfy_errsym(10077, 10077, "E_FGETFIELD_1"); +vrfy_errsym(10078, 10078, "E_FGETFIELD_2"); +vrfy_errsym(10079, 10079, "E_REWIND_1"); +vrfy_errsym(10080, 10080, "E_FILES"); +vrfy_errsym(10081, 10081, "E_PRINTF_1"); +vrfy_errsym(10082, 10082, "E_PRINTF_2"); +vrfy_errsym(10083, 10083, "E_FPRINTF_1"); +vrfy_errsym(10084, 10084, "E_FPRINTF_2"); +vrfy_errsym(10085, 10085, "E_FPRINTF_3"); +vrfy_errsym(10086, 10086, "E_STRPRINTF_1"); +vrfy_errsym(10087, 10087, "E_STRPRINTF_2"); +vrfy_errsym(10088, 10088, "E_FSCAN_1"); +vrfy_errsym(10089, 10089, "E_FSCAN_2"); +vrfy_errsym(10090, 10090, "E_STRSCAN"); +vrfy_errsym(10091, 10091, "E_FSCANF_1"); +vrfy_errsym(10092, 10092, "E_FSCANF_2"); +vrfy_errsym(10093, 10093, "E_FSCANF_3"); +vrfy_errsym(10094, 10094, "E_FSCANF_4"); +vrfy_errsym(10095, 10095, "E_STRSCANF_1"); +vrfy_errsym(10096, 10096, "E_STRSCANF_2"); +vrfy_errsym(10097, 10097, "E_STRSCANF_3"); +vrfy_errsym(10098, 10098, "E_STRSCANF_4"); +vrfy_errsym(10099, 10099, "E_SCANF_1"); +vrfy_errsym(10100, 10100, "E_SCANF_2"); +vrfy_errsym(10101, 10101, "E_SCANF_3"); +vrfy_errsym(10102, 10102, "E_FTELL_1"); +vrfy_errsym(10103, 10103, "E_FTELL_2"); +vrfy_errsym(10104, 10104, "E_FSEEK_1"); +vrfy_errsym(10105, 10105, "E_FSEEK_2"); +vrfy_errsym(10106, 10106, "E_FSEEK_3"); +vrfy_errsym(10107, 10107, "E_FSIZE_1"); +vrfy_errsym(10108, 10108, "E_FSIZE_2"); +vrfy_errsym(10109, 10109, "E_FEOF_1"); +vrfy_errsym(10110, 10110, "E_FEOF_2"); +vrfy_errsym(10111, 10111, "E_FERROR_1"); +vrfy_errsym(10112, 10112, "E_FERROR_2"); +vrfy_errsym(10113, 10113, "E_UNGETC_1"); +vrfy_errsym(10114, 10114, "E_UNGETC_2"); +vrfy_errsym(10115, 10115, "E_UNGETC_3"); +vrfy_errsym(10116, 10116, "E_BIGEXP"); +vrfy_errsym(10117, 10117, "E_ISATTY_1"); +vrfy_errsym(10118, 10118, "E_ISATTY_2"); +vrfy_errsym(10119, 10119, "E_ACCESS_1"); +vrfy_errsym(10120, 10120, "E_ACCESS_2"); +vrfy_errsym(10121, 10121, "E_SEARCH_1"); +vrfy_errsym(10122, 10122, "E_SEARCH_2"); +vrfy_errsym(10123, 10123, "E_SEARCH_3"); +vrfy_errsym(10124, 10124, "E_SEARCH_4"); +vrfy_errsym(10125, 10125, "E_SEARCH_5"); +vrfy_errsym(10126, 10126, "E_SEARCH_6"); +vrfy_errsym(10127, 10127, "E_RSEARCH_1"); +vrfy_errsym(10128, 10128, "E_RSEARCH_2"); +vrfy_errsym(10129, 10129, "E_RSEARCH_3"); +vrfy_errsym(10130, 10130, "E_RSEARCH_4"); +vrfy_errsym(10131, 10131, "E_RSEARCH_5"); +vrfy_errsym(10132, 10132, "E_RSEARCH_6"); +vrfy_errsym(10133, 10133, "E_MANYOPEN"); +vrfy_errsym(10134, 10134, "E_REWIND_2"); +vrfy_errsym(10135, 10135, "E_STRERROR_1"); +vrfy_errsym(10136, 10136, "E_STRERROR_2"); +vrfy_errsym(10137, 10137, "E_COS_1"); +vrfy_errsym(10138, 10138, "E_COS_2"); +vrfy_errsym(10139, 10139, "E_SIN_1"); +vrfy_errsym(10140, 10140, "E_SIN_2"); +vrfy_errsym(10141, 10141, "E_EVAL_2"); +vrfy_errsym(10142, 10142, "E_ARG_1"); +vrfy_errsym(10143, 10143, "E_ARG_2"); +vrfy_errsym(10144, 10144, "E_POLAR_1"); +vrfy_errsym(10145, 10145, "E_POLAR_2"); +vrfy_errsym(10146, 10146, "E_FCNT"); +vrfy_errsym(10147, 10147, "E_MATFILL_1"); +vrfy_errsym(10148, 10148, "E_MATFILL_2"); +vrfy_errsym(10149, 10149, "E_MATDIM"); +vrfy_errsym(10150, 10150, "E_MATSUM"); +vrfy_errsym(10151, 10151, "E_ISIDENT"); +vrfy_errsym(10152, 10152, "E_MATTRANS_1"); +vrfy_errsym(10153, 10153, "E_MATTRANS_2"); +vrfy_errsym(10154, 10154, "E_DET_1"); +vrfy_errsym(10155, 10155, "E_DET_2"); +vrfy_errsym(10156, 10156, "E_DET_3"); +vrfy_errsym(10157, 10157, "E_MATMIN_1"); +vrfy_errsym(10158, 10158, "E_MATMIN_2"); +vrfy_errsym(10159, 10159, "E_MATMIN_3"); +vrfy_errsym(10160, 10160, "E_MATMAX_1"); +vrfy_errsym(10161, 10161, "E_MATMAX_2"); +vrfy_errsym(10162, 10162, "E_MATMAX_3"); +vrfy_errsym(10163, 10163, "E_CP_1"); +vrfy_errsym(10164, 10164, "E_CP_2"); +vrfy_errsym(10165, 10165, "E_CP_3"); +vrfy_errsym(10166, 10166, "E_DP_1"); +vrfy_errsym(10167, 10167, "E_DP_2"); +vrfy_errsym(10168, 10168, "E_DP_3"); +vrfy_errsym(10169, 10169, "E_STRLEN"); +vrfy_errsym(10170, 10170, "E_STRCAT"); +vrfy_errsym(10171, 10171, "E_SUBSTR_1"); +vrfy_errsym(10172, 10172, "E_SUBSTR_2"); +vrfy_errsym(10173, 10173, "E_CHAR"); +vrfy_errsym(10174, 10174, "E_ORD"); +vrfy_errsym(10175, 10175, "E_INSERT_1"); +vrfy_errsym(10176, 10176, "E_INSERT_2"); +vrfy_errsym(10177, 10177, "E_PUSH"); +vrfy_errsym(10178, 10178, "E_APPEND"); +vrfy_errsym(10179, 10179, "E_DELETE_1"); +vrfy_errsym(10180, 10180, "E_DELETE_2"); +vrfy_errsym(10181, 10181, "E_POP"); +vrfy_errsym(10182, 10182, "E_REMOVE"); +vrfy_errsym(10183, 10183, "E_LN_1"); +vrfy_errsym(10184, 10184, "E_LN_2"); +vrfy_errsym(10185, 10185, "E_ERROR_1"); +vrfy_errsym(10186, 10186, "E_ERROR_2"); +vrfy_errsym(10187, 10187, "E_EVAL_3"); +vrfy_errsym(10188, 10188, "E_EVAL_4"); +vrfy_errsym(10189, 10189, "E_RM_1"); +vrfy_errsym(10190, 10190, "E_RM_2"); +vrfy_errsym(10191, 10191, "E_RDPERM"); +vrfy_errsym(10192, 10192, "E_WRPERM"); +vrfy_errsym(10193, 10193, "E_EXPERM"); +vrfy_errsym(10194, 10194, "E_MIN"); +vrfy_errsym(10195, 10195, "E_MAX"); +vrfy_errsym(10196, 10196, "E_LISTMIN"); +vrfy_errsym(10197, 10197, "E_LISTMAX"); +vrfy_errsym(10198, 10198, "E_SIZE"); +vrfy_errsym(10199, 10199, "E_NO_C_ARG"); +vrfy_errsym(10200, 10200, "E_NO_CUSTOM"); +vrfy_errsym(10201, 10201, "E_UNK_CUSTOM"); +vrfy_errsym(10202, 10202, "E_BLK_1"); +vrfy_errsym(10203, 10203, "E_BLK_2"); +vrfy_errsym(10204, 10204, "E_BLK_3"); +vrfy_errsym(10205, 10205, "E_BLK_4"); +vrfy_errsym(10206, 10206, "E_BLKFREE_1"); +vrfy_errsym(10207, 10207, "E_BLKFREE_2"); +vrfy_errsym(10208, 10208, "E_BLKFREE_3"); +vrfy_errsym(10209, 10209, "E_BLKFREE_4"); +vrfy_errsym(10210, 10210, "E_BLKFREE_5"); +vrfy_errsym(10211, 10211, "E_BLOCKS_1"); +vrfy_errsym(10212, 10212, "E_BLOCKS_2"); +vrfy_errsym(10213, 10213, "E_COPY_01"); +vrfy_errsym(10214, 10214, "E_COPY_02"); +vrfy_errsym(10215, 10215, "E_COPY_03"); +vrfy_errsym(10216, 10216, "E_COPY_04"); +vrfy_errsym(10217, 10217, "E_COPY_05"); +vrfy_errsym(10218, 10218, "E_COPY_06"); +vrfy_errsym(10219, 10219, "E_COPY_07"); +vrfy_errsym(10220, 10220, "E_COPY_08"); +vrfy_errsym(10221, 10221, "E_COPY_09"); +vrfy_errsym(10222, 10222, "E_COPY_10"); +vrfy_errsym(10223, 10223, "E_COPY_11"); +vrfy_errsym(10224, 10224, "E_COPY_12"); +vrfy_errsym(10225, 10225, "E_COPY_13"); +vrfy_errsym(10226, 10226, "E_COPY_14"); +vrfy_errsym(10227, 10227, "E_COPY_15"); +vrfy_errsym(10228, 10228, "E_COPY_16"); +vrfy_errsym(10229, 10229, "E_COPY_17"); +vrfy_errsym(10230, 10230, "E_COPYF_1"); +vrfy_errsym(10231, 10231, "E_COPYF_2"); +vrfy_errsym(10232, 10232, "E_COPYF_3"); +vrfy_errsym(10233, 10233, "E_COPYF_4"); +vrfy_errsym(10234, 10234, "E_PROTECT_1"); +vrfy_errsym(10235, 10235, "E_PROTECT_2"); +vrfy_errsym(10236, 10236, "E_PROTECT_3"); +vrfy_errsym(10237, 10237, "E_MATFILL_3"); +vrfy_errsym(10238, 10238, "E_MATFILL_4"); +vrfy_errsym(10239, 10239, "E_MATTRACE_1"); +vrfy_errsym(10240, 10240, "E_MATTRACE_2"); +vrfy_errsym(10241, 10241, "E_MATTRACE_3"); +vrfy_errsym(10242, 10242, "E_TAN_1"); +vrfy_errsym(10243, 10243, "E_TAN_2"); +vrfy_errsym(10244, 10244, "E_COT_1"); +vrfy_errsym(10245, 10245, "E_COT_2"); +vrfy_errsym(10246, 10246, "E_SEC_1"); +vrfy_errsym(10247, 10247, "E_SEC_2"); +vrfy_errsym(10248, 10248, "E_CSC_1"); +vrfy_errsym(10249, 10249, "E_CSC_2"); +vrfy_errsym(10250, 10250, "E_SINH_1"); +vrfy_errsym(10251, 10251, "E_SINH_2"); +vrfy_errsym(10252, 10252, "E_COSH_1"); +vrfy_errsym(10253, 10253, "E_COSH_2"); +vrfy_errsym(10254, 10254, "E_TANH_1"); +vrfy_errsym(10255, 10255, "E_TANH_2"); +vrfy_errsym(10256, 10256, "E_COTH_1"); +vrfy_errsym(10257, 10257, "E_COTH_2"); +vrfy_errsym(10258, 10258, "E_SECH_1"); +vrfy_errsym(10259, 10259, "E_SECH_2"); +vrfy_errsym(10260, 10260, "E_CSCH_1"); +vrfy_errsym(10261, 10261, "E_CSCH_2"); +vrfy_errsym(10262, 10262, "E_ASIN_1"); +vrfy_errsym(10263, 10263, "E_ASIN_2"); +vrfy_errsym(10264, 10264, "E_ACOS_1"); +vrfy_errsym(10265, 10265, "E_ACOS_2"); +vrfy_errsym(10266, 10266, "E_ATAN_1"); +vrfy_errsym(10267, 10267, "E_ATAN_2"); +vrfy_errsym(10268, 10268, "E_ACOT_1"); +vrfy_errsym(10269, 10269, "E_ACOT_2"); +vrfy_errsym(10270, 10270, "E_ASEC_1"); +vrfy_errsym(10271, 10271, "E_ASEC_2"); +vrfy_errsym(10272, 10272, "E_ACSC_1"); +vrfy_errsym(10273, 10273, "E_ACSC_2"); +vrfy_errsym(10274, 10274, "E_ASINH_1"); +vrfy_errsym(10275, 10275, "E_ASINH_2"); +vrfy_errsym(10276, 10276, "E_ACOSH_1"); +vrfy_errsym(10277, 10277, "E_ACOSH_2"); +vrfy_errsym(10278, 10278, "E_ATANH_1"); +vrfy_errsym(10279, 10279, "E_ATANH_2"); +vrfy_errsym(10280, 10280, "E_ACOTH_1"); +vrfy_errsym(10281, 10281, "E_ACOTH_2"); +vrfy_errsym(10282, 10282, "E_ASECH_1"); +vrfy_errsym(10283, 10283, "E_ASECH_2"); +vrfy_errsym(10284, 10284, "E_ACSCH_1"); +vrfy_errsym(10285, 10285, "E_ACSCH_2"); +vrfy_errsym(10286, 10286, "E_GD_1"); +vrfy_errsym(10287, 10287, "E_GD_2"); +vrfy_errsym(10288, 10288, "E_AGD_1"); +vrfy_errsym(10289, 10289, "E_AGD_2"); +vrfy_errsym(10290, 10290, "E_LOGINF"); +vrfy_errsym(10291, 10291, "E_STRADD"); +vrfy_errsym(10292, 10292, "E_STRMUL"); +vrfy_errsym(10293, 10293, "E_STRNEG"); +vrfy_errsym(10294, 10294, "E_STRSUB"); +vrfy_errsym(10295, 10295, "E_BIT_1"); +vrfy_errsym(10296, 10296, "E_BIT_2"); +vrfy_errsym(10297, 10297, "E_SETBIT_1"); +vrfy_errsym(10298, 10298, "E_SETBIT_2"); +vrfy_errsym(10299, 10299, "E_SETBIT_3"); +vrfy_errsym(10300, 10300, "E_OR"); +vrfy_errsym(10301, 10301, "E_AND"); +vrfy_errsym(10302, 10302, "E_STROR"); +vrfy_errsym(10303, 10303, "E_STRAND"); +vrfy_errsym(10304, 10304, "E_XOR"); +vrfy_errsym(10305, 10305, "E_COMP"); +vrfy_errsym(10306, 10306, "E_STRDIFF"); +vrfy_errsym(10307, 10307, "E_STRCOMP"); +vrfy_errsym(10308, 10308, "E_SEG_1"); +vrfy_errsym(10309, 10309, "E_SEG_2"); +vrfy_errsym(10310, 10310, "E_SEG_3"); +vrfy_errsym(10311, 10311, "E_STRSEG"); +vrfy_errsym(10312, 10312, "E_HIGHBIT_1"); +vrfy_errsym(10313, 10313, "E_HIGHBIT_2"); +vrfy_errsym(10314, 10314, "E_LOWBIT_1"); +vrfy_errsym(10315, 10315, "E_LOWBIT_2"); +vrfy_errsym(10316, 10316, "E_CONTENT"); +vrfy_errsym(10317, 10317, "E_HASHOP"); +vrfy_errsym(10318, 10318, "E_HEAD_1"); +vrfy_errsym(10319, 10319, "E_HEAD_2"); +vrfy_errsym(10320, 10320, "E_STRHEAD"); +vrfy_errsym(10321, 10321, "E_TAIL_1"); +vrfy_errsym(10322, 10322, "E_TAIL_2"); +vrfy_errsym(10323, 10323, "E_STRTAIL"); +vrfy_errsym(10324, 10324, "E_STRSHIFT"); +vrfy_errsym(10325, 10325, "E_STRCMP"); +vrfy_errsym(10326, 10326, "E_STRNCMP"); +vrfy_errsym(10327, 10327, "E_XOR_1"); +vrfy_errsym(10328, 10328, "E_XOR_2"); +vrfy_errsym(10329, 10329, "E_STRCPY"); +vrfy_errsym(10330, 10330, "E_STRNCPY"); +vrfy_errsym(10331, 10331, "E_BACKSLASH"); +vrfy_errsym(10332, 10332, "E_SETMINUS"); +vrfy_errsym(10333, 10333, "E_INDICES_1"); +vrfy_errsym(10334, 10334, "E_INDICES_2"); +vrfy_errsym(10335, 10335, "E_EXP_3"); +vrfy_errsym(10336, 10336, "E_SINH_3"); +vrfy_errsym(10337, 10337, "E_COSH_3"); +vrfy_errsym(10338, 10338, "E_SIN_3"); +vrfy_errsym(10339, 10339, "E_COS_3"); +vrfy_errsym(10340, 10340, "E_GD_3"); +vrfy_errsym(10341, 10341, "E_AGD_3"); +vrfy_errsym(10342, 10342, "E_POWER_4"); +vrfy_errsym(10343, 10343, "E_ROOT_4"); +vrfy_errsym(10344, 10344, "E_DGT_1"); +vrfy_errsym(10345, 10345, "E_DGT_2"); +vrfy_errsym(10346, 10346, "E_DGT_3"); +vrfy_errsym(10347, 10347, "E_PLCS_1"); +vrfy_errsym(10348, 10348, "E_PLCS_2"); +vrfy_errsym(10349, 10349, "E_DGTS_1"); +vrfy_errsym(10350, 10350, "E_DGTS_2"); +vrfy_errsym(10351, 10351, "E_ILOG"); +vrfy_errsym(10352, 10352, "E_ILOGB"); +vrfy_errsym(10353, 10353, "E_IBASE10_LOG"); +vrfy_errsym(10354, 10354, "E_IBASE2_LOG"); +vrfy_errsym(10355, 10355, "E_COMB_1"); +vrfy_errsym(10356, 10356, "E_COMB_2"); +vrfy_errsym(10357, 10357, "E_CTLN"); +vrfy_errsym(10358, 10358, "E_BERN"); +vrfy_errsym(10359, 10359, "E_EULER"); +vrfy_errsym(10360, 10360, "E_SLEEP"); +vrfy_errsym(10361, 10361, "E_TTY"); +vrfy_errsym(10362, 10362, "E_ASSIGN_1"); +vrfy_errsym(10363, 10363, "E_ASSIGN_2"); +vrfy_errsym(10364, 10364, "E_ASSIGN_3"); +vrfy_errsym(10365, 10365, "E_ASSIGN_4"); +vrfy_errsym(10366, 10366, "E_ASSIGN_5"); +vrfy_errsym(10367, 10367, "E_ASSIGN_6"); +vrfy_errsym(10368, 10368, "E_ASSIGN_7"); +vrfy_errsym(10369, 10369, "E_ASSIGN_8"); +vrfy_errsym(10370, 10370, "E_ASSIGN_9"); +vrfy_errsym(10371, 10371, "E_SWAP_1"); +vrfy_errsym(10372, 10372, "E_SWAP_2"); +vrfy_errsym(10373, 10373, "E_SWAP_3"); +vrfy_errsym(10374, 10374, "E_QUOMOD_1"); +vrfy_errsym(10375, 10375, "E_QUOMOD_2"); +vrfy_errsym(10376, 10376, "E_QUOMOD_3"); +vrfy_errsym(10377, 10377, "E_PREINC_1"); +vrfy_errsym(10378, 10378, "E_PREINC_2"); +vrfy_errsym(10379, 10379, "E_PREINC_3"); +vrfy_errsym(10380, 10380, "E_PREDEC_1"); +vrfy_errsym(10381, 10381, "E_PREDEC_2"); +vrfy_errsym(10382, 10382, "E_PREDEC_3"); +vrfy_errsym(10383, 10383, "E_POSTINC_1"); +vrfy_errsym(10384, 10384, "E_POSTINC_2"); +vrfy_errsym(10385, 10385, "E_POSTINC_3"); +vrfy_errsym(10386, 10386, "E_POSTDEC_1"); +vrfy_errsym(10387, 10387, "E_POSTDEC_2"); +vrfy_errsym(10388, 10388, "E_POSTDEC_3"); +vrfy_errsym(10389, 10389, "E_INIT_01"); +vrfy_errsym(10390, 10390, "E_INIT_02"); +vrfy_errsym(10391, 10391, "E_INIT_03"); +vrfy_errsym(10392, 10392, "E_INIT_04"); +vrfy_errsym(10393, 10393, "E_INIT_05"); +vrfy_errsym(10394, 10394, "E_INIT_06"); +vrfy_errsym(10395, 10395, "E_INIT_07"); +vrfy_errsym(10396, 10396, "E_INIT_08"); +vrfy_errsym(10397, 10397, "E_INIT_09"); +vrfy_errsym(10398, 10398, "E_INIT_10"); +vrfy_errsym(10399, 10399, "E_LIST_1"); +vrfy_errsym(10400, 10400, "E_LIST_2"); +vrfy_errsym(10401, 10401, "E_LIST_3"); +vrfy_errsym(10402, 10402, "E_LIST_4"); +vrfy_errsym(10403, 10403, "E_LIST_5"); +vrfy_errsym(10404, 10404, "E_LIST_6"); +vrfy_errsym(10405, 10405, "E_MODIFY_1"); +vrfy_errsym(10406, 10406, "E_MODIFY_2"); +vrfy_errsym(10407, 10407, "E_MODIFY_3"); +vrfy_errsym(10408, 10408, "E_MODIFY_4"); +vrfy_errsym(10409, 10409, "E_MODIFY_5"); +vrfy_errsym(10410, 10410, "E_FPATHOPEN_1"); +vrfy_errsym(10411, 10411, "E_FPATHOPEN_2"); +vrfy_errsym(10412, 10412, "E_LOG_1"); +vrfy_errsym(10413, 10413, "E_LOG_2"); +vrfy_errsym(10414, 10414, "E_LOG_3"); +vrfy_errsym(10415, 10415, "E_FGETFILE_1"); +vrfy_errsym(10416, 10416, "E_FGETFILE_2"); +vrfy_errsym(10417, 10417, "E_FGETFILE_3"); +vrfy_errsym(10418, 10418, "E_ESTR"); +vrfy_errsym(10419, 10419, "E_STRCASECMP"); +vrfy_errsym(10420, 10420, "E_STRNCASECMP"); +vrfy_errsym(10421, 10421, "E_ISUPPER"); +vrfy_errsym(10422, 10422, "E_ISLOWER"); +vrfy_errsym(10423, 10423, "E_ISALNUM"); +vrfy_errsym(10424, 10424, "E_ISALPHA"); +vrfy_errsym(10425, 10425, "E_ISASCII"); +vrfy_errsym(10426, 10426, "E_ISCNTRL"); +vrfy_errsym(10427, 10427, "E_ISDIGIT"); +vrfy_errsym(10428, 10428, "E_ISGRAPH"); +vrfy_errsym(10429, 10429, "E_ISPRINT"); +vrfy_errsym(10430, 10430, "E_ISPUNCT"); +vrfy_errsym(10431, 10431, "E_ISSPACE"); +vrfy_errsym(10432, 10432, "E_ISXDIGIT"); +vrfy_errsym(10433, 10433, "E_STRTOUPPER"); +vrfy_errsym(10434, 10434, "E_STRTOLOWER"); +vrfy_errsym(10435, 10435, "E_TAN_3"); +vrfy_errsym(10436, 10436, "E_TAN_4"); +vrfy_errsym(10437, 10437, "E_COT_3"); +vrfy_errsym(10438, 10438, "E_COT_4"); +vrfy_errsym(10439, 10439, "E_SEC_3"); +vrfy_errsym(10440, 10440, "E_CSC_3"); +vrfy_errsym(10441, 10441, "E_TANH_3"); +vrfy_errsym(10442, 10442, "E_TANH_4"); +vrfy_errsym(10443, 10443, "E_COTH_3"); +vrfy_errsym(10444, 10444, "E_COTH_4"); +vrfy_errsym(10445, 10445, "E_SECH_3"); +vrfy_errsym(10446, 10446, "E_CSCH_3"); +vrfy_errsym(10447, 10447, "E_ASIN_3"); +vrfy_errsym(10448, 10448, "E_ACOS_3"); +vrfy_errsym(10449, 10449, "E_ASINH_3"); +vrfy_errsym(10450, 10450, "E_ACOSH_3"); +vrfy_errsym(10451, 10451, "E_ATAN_3"); +vrfy_errsym(10452, 10452, "E_ACOT_3"); +vrfy_errsym(10453, 10453, "E_ASEC_3"); +vrfy_errsym(10454, 10454, "E_ACSC_3"); +vrfy_errsym(10455, 10455, "E_ATANH_3"); +vrfy_errsym(10456, 10456, "E_ACOTH_3"); +vrfy_errsym(10457, 10457, "E_ASECH_3"); +vrfy_errsym(10458, 10458, "E_ACSCH_3"); +vrfy_errsym(10459, 10459, "E_D2R_1"); +vrfy_errsym(10460, 10460, "E_D2R_2"); +vrfy_errsym(10461, 10461, "E_R2D_1"); +vrfy_errsym(10462, 10462, "E_R2D_2"); +vrfy_errsym(10463, 10463, "E_G2R_1"); +vrfy_errsym(10464, 10464, "E_G2R_2"); +vrfy_errsym(10465, 10465, "E_R2G_1"); +vrfy_errsym(10466, 10466, "E_R2G_2"); +vrfy_errsym(10467, 10467, "E_D2G_1"); +vrfy_errsym(10468, 10468, "E_G2D_1"); +vrfy_errsym(10469, 10469, "E_D2DMS_1"); +vrfy_errsym(10470, 10470, "E_D2DMS_2"); +vrfy_errsym(10471, 10471, "E_D2DMS_3"); +vrfy_errsym(10472, 10472, "E_D2DMS_4"); +vrfy_errsym(10473, 10473, "E_D2DM_1"); +vrfy_errsym(10474, 10474, "E_D2DM_2"); +vrfy_errsym(10475, 10475, "E_D2DM_3"); +vrfy_errsym(10476, 10476, "E_D2DM_4"); +vrfy_errsym(10477, 10477, "E_G2GMS_1"); +vrfy_errsym(10478, 10478, "E_G2GMS_2"); +vrfy_errsym(10479, 10479, "E_G2GMS_3"); +vrfy_errsym(10480, 10480, "E_G2GMS_4"); +vrfy_errsym(10481, 10481, "E_G2GM_1"); +vrfy_errsym(10482, 10482, "E_G2GM_2"); +vrfy_errsym(10483, 10483, "E_G2GM_3"); +vrfy_errsym(10484, 10484, "E_G2GM_4"); +vrfy_errsym(10485, 10485, "E_H2HMS_1"); +vrfy_errsym(10486, 10486, "E_H2HMS_2"); +vrfy_errsym(10487, 10487, "E_H2HMS_3"); +vrfy_errsym(10488, 10488, "E_H2HMS_4"); +vrfy_errsym(10489, 10489, "E_H2HM_1"); +vrfy_errsym(10490, 10490, "E_H2HM_2"); +vrfy_errsym(10491, 10491, "E_H2HM_3"); +vrfy_errsym(10492, 10492, "E_H2HM_4"); +vrfy_errsym(10493, 10493, "E_DMS2D_1"); +vrfy_errsym(10494, 10494, "E_DMS2D_2"); +vrfy_errsym(10495, 10495, "E_DM2D_1"); +vrfy_errsym(10496, 10496, "E_DM2D_2"); +vrfy_errsym(10497, 10497, "E_GMS2G_1"); +vrfy_errsym(10498, 10498, "E_GMS2G_2"); +vrfy_errsym(10499, 10499, "E_GM2G_1"); +vrfy_errsym(10500, 10500, "E_GM2G_2"); +vrfy_errsym(10501, 10501, "E_HMS2H_1"); +vrfy_errsym(10502, 10502, "E_HMS2H_2"); +vrfy_errsym(10503, 10503, "E_HM2H_1"); +vrfy_errsym(10504, 10504, "E_HM2H_2"); +vrfy_errsym(10505, 10505, "E_LOG2_1"); +vrfy_errsym(10506, 10506, "E_LOG2_2"); +vrfy_errsym(10507, 10507, "E_LOG2_3"); +vrfy_errsym(10508, 10508, "E_LOGN_1"); +vrfy_errsym(10509, 10509, "E_LOGN_2"); +vrfy_errsym(10510, 10510, "E_LOGN_3"); +vrfy_errsym(10511, 10511, "E_LOGN_4"); +vrfy_errsym(10512, 10512, "E_LOGN_5"); +vrfy_errsym(10513, 10513, "E_VERSIN_1"); +vrfy_errsym(10514, 10514, "E_VERSIN_2"); +vrfy_errsym(10515, 10515, "E_VERSIN_3"); +vrfy_errsym(10516, 10516, "E_AVERSIN_1"); +vrfy_errsym(10517, 10517, "E_AVERSIN_2"); +vrfy_errsym(10518, 10518, "E_AVERSIN_3"); +vrfy_errsym(10519, 10519, "E_COVERSIN_1"); +vrfy_errsym(10520, 10520, "E_COVERSIN_2"); +vrfy_errsym(10521, 10521, "E_COVERSIN_3"); +vrfy_errsym(10522, 10522, "E_ACOVERSIN_1"); +vrfy_errsym(10523, 10523, "E_ACOVERSIN_2"); +vrfy_errsym(10524, 10524, "E_ACOVERSIN_3"); +vrfy_errsym(10525, 10525, "E_VERCOS_1"); +vrfy_errsym(10526, 10526, "E_VERCOS_2"); +vrfy_errsym(10527, 10527, "E_VERCOS_3"); +vrfy_errsym(10528, 10528, "E_AVERCOS_1"); +vrfy_errsym(10529, 10529, "E_AVERCOS_2"); +vrfy_errsym(10530, 10530, "E_AVERCOS_3"); +vrfy_errsym(10531, 10531, "E_COVERCOS_1"); +vrfy_errsym(10532, 10532, "E_COVERCOS_2"); +vrfy_errsym(10533, 10533, "E_COVERCOS_3"); +vrfy_errsym(10534, 10534, "E_ACOVERCOS_1"); +vrfy_errsym(10535, 10535, "E_ACOVERCOS_2"); +vrfy_errsym(10536, 10536, "E_ACOVERCOS_3"); +vrfy_errsym(10537, 10537, "E_TAN_5"); +vrfy_errsym(10538, 10538, "E_COT_5"); +vrfy_errsym(10539, 10539, "E_COT_6"); +vrfy_errsym(10540, 10540, "E_SEC_5"); +vrfy_errsym(10541, 10541, "E_CSC_5"); +vrfy_errsym(10542, 10542, "E_CSC_6"); +vrfy_errsym(10543, 10543, "E_ERROR_3"); +vrfy_errsym(10544, 10544, "E_ERROR_4"); +vrfy_errsym(10545, 10545, "E_STRERROR_3"); +vrfy_errsym(10546, 10546, "E_STRERROR_4"); +vrfy_errsym(10547, 10547, "E_STRERROR_5"); +vrfy_errsym(10548, 10548, "E_ERRNO_1"); +vrfy_errsym(10549, 10549, "E_ERRNO_2"); +vrfy_errsym(10550, 10550, "E_ERRNO_3"); +vrfy_errsym(10551, 10551, "E_ERRNO_4"); +vrfy_errsym(10552, 10552, "E_ERRSYM_1"); +vrfy_errsym(10553, 10553, "E_ERRSYM_2"); +vrfy_errsym(10554, 10554, "E_ERRSYM_3"); +vrfy_errsym(10555, 10555, "E_ERRSYM_4"); +vrfy_errsym(10556, 10556, "E_ERRSYM_5"); + +/* ************************************************************** */ +/* NOTE: Reserve thru test 10998 for calc computation error codes */ +/* ************************************************************** */ + +print '10999: End of E_STRING values for calc computation error codes'; + + /* ************************************************* */ /* NOTE: ==> Room for new tests 11000-98899 here <== */ /* ************************************************* */ diff --git a/errtbl.c b/errtbl.c index e864997..09b05c8 100644 --- a/errtbl.c +++ b/errtbl.c @@ -735,7 +735,7 @@ 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 errors start 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" }, diff --git a/errtbl.h b/errtbl.h index c743ed9..3481f89 100644 --- a/errtbl.h +++ b/errtbl.h @@ -48,7 +48,7 @@ * primary error code defines */ #define E__NONE 0 /* calc_errno cleared: libc errno codes above here */ -#define E__BASE 10000 /* calc errors start above here */ +#define E__BASE 10000 /* calc computation error codes start above here */ #define E__USERDEF 20000 /* user defined error codes start here */ #define E__USERMAX 32767 /* maximum user defined error code */