Annotation of src/external/gpl3/binutils.old/dist/libiberty/strerror.c, Revision 1.1
1.1 ! christos 1: /* Extended support for using errno values.
! 2: Written by Fred Fish. fnf@cygnus.com
! 3: This file is in the public domain. --Per Bothner. */
! 4:
! 5: #include "config.h"
! 6:
! 7: #ifdef HAVE_SYS_ERRLIST
! 8: /* Note that errno.h (not sure what OS) or stdio.h (BSD 4.4, at least)
! 9: might declare sys_errlist in a way that the compiler might consider
! 10: incompatible with our later declaration, perhaps by using const
! 11: attributes. So we hide the declaration in errno.h (if any) using a
! 12: macro. */
! 13: #define sys_nerr sys_nerr__
! 14: #define sys_errlist sys_errlist__
! 15: #endif
! 16:
! 17: #include "ansidecl.h"
! 18: #include "libiberty.h"
! 19:
! 20: #include <stdio.h>
! 21: #include <errno.h>
! 22:
! 23: #ifdef HAVE_SYS_ERRLIST
! 24: #undef sys_nerr
! 25: #undef sys_errlist
! 26: #endif
! 27:
! 28: /* Routines imported from standard C runtime libraries. */
! 29:
! 30: #ifdef HAVE_STDLIB_H
! 31: #include <stdlib.h>
! 32: #else
! 33: extern PTR malloc ();
! 34: #endif
! 35:
! 36: #ifdef HAVE_STRING_H
! 37: #include <string.h>
! 38: #else
! 39: extern PTR memset ();
! 40: #endif
! 41:
! 42: #ifndef MAX
! 43: # define MAX(a,b) ((a) > (b) ? (a) : (b))
! 44: #endif
! 45:
! 46: static void init_error_tables (void);
! 47:
! 48: /* Translation table for errno values. See intro(2) in most UNIX systems
! 49: Programmers Reference Manuals.
! 50:
! 51: Note that this table is generally only accessed when it is used at runtime
! 52: to initialize errno name and message tables that are indexed by errno
! 53: value.
! 54:
! 55: Not all of these errnos will exist on all systems. This table is the only
! 56: thing that should have to be updated as new error numbers are introduced.
! 57: It's sort of ugly, but at least its portable. */
! 58:
! 59: struct error_info
! 60: {
! 61: const int value; /* The numeric value from <errno.h> */
! 62: const char *const name; /* The equivalent symbolic value */
! 63: #ifndef HAVE_SYS_ERRLIST
! 64: const char *const msg; /* Short message about this value */
! 65: #endif
! 66: };
! 67:
! 68: #ifndef HAVE_SYS_ERRLIST
! 69: # define ENTRY(value, name, msg) {value, name, msg}
! 70: #else
! 71: # define ENTRY(value, name, msg) {value, name}
! 72: #endif
! 73:
! 74: static const struct error_info error_table[] =
! 75: {
! 76: #if defined (EPERM)
! 77: ENTRY(EPERM, "EPERM", "Not owner"),
! 78: #endif
! 79: #if defined (ENOENT)
! 80: ENTRY(ENOENT, "ENOENT", "No such file or directory"),
! 81: #endif
! 82: #if defined (ESRCH)
! 83: ENTRY(ESRCH, "ESRCH", "No such process"),
! 84: #endif
! 85: #if defined (EINTR)
! 86: ENTRY(EINTR, "EINTR", "Interrupted system call"),
! 87: #endif
! 88: #if defined (EIO)
! 89: ENTRY(EIO, "EIO", "I/O error"),
! 90: #endif
! 91: #if defined (ENXIO)
! 92: ENTRY(ENXIO, "ENXIO", "No such device or address"),
! 93: #endif
! 94: #if defined (E2BIG)
! 95: ENTRY(E2BIG, "E2BIG", "Arg list too long"),
! 96: #endif
! 97: #if defined (ENOEXEC)
! 98: ENTRY(ENOEXEC, "ENOEXEC", "Exec format error"),
! 99: #endif
! 100: #if defined (EBADF)
! 101: ENTRY(EBADF, "EBADF", "Bad file number"),
! 102: #endif
! 103: #if defined (ECHILD)
! 104: ENTRY(ECHILD, "ECHILD", "No child processes"),
! 105: #endif
! 106: #if defined (EWOULDBLOCK) /* Put before EAGAIN, sometimes aliased */
! 107: ENTRY(EWOULDBLOCK, "EWOULDBLOCK", "Operation would block"),
! 108: #endif
! 109: #if defined (EAGAIN)
! 110: ENTRY(EAGAIN, "EAGAIN", "No more processes"),
! 111: #endif
! 112: #if defined (ENOMEM)
! 113: ENTRY(ENOMEM, "ENOMEM", "Not enough space"),
! 114: #endif
! 115: #if defined (EACCES)
! 116: ENTRY(EACCES, "EACCES", "Permission denied"),
! 117: #endif
! 118: #if defined (EFAULT)
! 119: ENTRY(EFAULT, "EFAULT", "Bad address"),
! 120: #endif
! 121: #if defined (ENOTBLK)
! 122: ENTRY(ENOTBLK, "ENOTBLK", "Block device required"),
! 123: #endif
! 124: #if defined (EBUSY)
! 125: ENTRY(EBUSY, "EBUSY", "Device busy"),
! 126: #endif
! 127: #if defined (EEXIST)
! 128: ENTRY(EEXIST, "EEXIST", "File exists"),
! 129: #endif
! 130: #if defined (EXDEV)
! 131: ENTRY(EXDEV, "EXDEV", "Cross-device link"),
! 132: #endif
! 133: #if defined (ENODEV)
! 134: ENTRY(ENODEV, "ENODEV", "No such device"),
! 135: #endif
! 136: #if defined (ENOTDIR)
! 137: ENTRY(ENOTDIR, "ENOTDIR", "Not a directory"),
! 138: #endif
! 139: #if defined (EISDIR)
! 140: ENTRY(EISDIR, "EISDIR", "Is a directory"),
! 141: #endif
! 142: #if defined (EINVAL)
! 143: ENTRY(EINVAL, "EINVAL", "Invalid argument"),
! 144: #endif
! 145: #if defined (ENFILE)
! 146: ENTRY(ENFILE, "ENFILE", "File table overflow"),
! 147: #endif
! 148: #if defined (EMFILE)
! 149: ENTRY(EMFILE, "EMFILE", "Too many open files"),
! 150: #endif
! 151: #if defined (ENOTTY)
! 152: ENTRY(ENOTTY, "ENOTTY", "Not a typewriter"),
! 153: #endif
! 154: #if defined (ETXTBSY)
! 155: ENTRY(ETXTBSY, "ETXTBSY", "Text file busy"),
! 156: #endif
! 157: #if defined (EFBIG)
! 158: ENTRY(EFBIG, "EFBIG", "File too large"),
! 159: #endif
! 160: #if defined (ENOSPC)
! 161: ENTRY(ENOSPC, "ENOSPC", "No space left on device"),
! 162: #endif
! 163: #if defined (ESPIPE)
! 164: ENTRY(ESPIPE, "ESPIPE", "Illegal seek"),
! 165: #endif
! 166: #if defined (EROFS)
! 167: ENTRY(EROFS, "EROFS", "Read-only file system"),
! 168: #endif
! 169: #if defined (EMLINK)
! 170: ENTRY(EMLINK, "EMLINK", "Too many links"),
! 171: #endif
! 172: #if defined (EPIPE)
! 173: ENTRY(EPIPE, "EPIPE", "Broken pipe"),
! 174: #endif
! 175: #if defined (EDOM)
! 176: ENTRY(EDOM, "EDOM", "Math argument out of domain of func"),
! 177: #endif
! 178: #if defined (ERANGE)
! 179: ENTRY(ERANGE, "ERANGE", "Math result not representable"),
! 180: #endif
! 181: #if defined (ENOMSG)
! 182: ENTRY(ENOMSG, "ENOMSG", "No message of desired type"),
! 183: #endif
! 184: #if defined (EIDRM)
! 185: ENTRY(EIDRM, "EIDRM", "Identifier removed"),
! 186: #endif
! 187: #if defined (ECHRNG)
! 188: ENTRY(ECHRNG, "ECHRNG", "Channel number out of range"),
! 189: #endif
! 190: #if defined (EL2NSYNC)
! 191: ENTRY(EL2NSYNC, "EL2NSYNC", "Level 2 not synchronized"),
! 192: #endif
! 193: #if defined (EL3HLT)
! 194: ENTRY(EL3HLT, "EL3HLT", "Level 3 halted"),
! 195: #endif
! 196: #if defined (EL3RST)
! 197: ENTRY(EL3RST, "EL3RST", "Level 3 reset"),
! 198: #endif
! 199: #if defined (ELNRNG)
! 200: ENTRY(ELNRNG, "ELNRNG", "Link number out of range"),
! 201: #endif
! 202: #if defined (EUNATCH)
! 203: ENTRY(EUNATCH, "EUNATCH", "Protocol driver not attached"),
! 204: #endif
! 205: #if defined (ENOCSI)
! 206: ENTRY(ENOCSI, "ENOCSI", "No CSI structure available"),
! 207: #endif
! 208: #if defined (EL2HLT)
! 209: ENTRY(EL2HLT, "EL2HLT", "Level 2 halted"),
! 210: #endif
! 211: #if defined (EDEADLK)
! 212: ENTRY(EDEADLK, "EDEADLK", "Deadlock condition"),
! 213: #endif
! 214: #if defined (ENOLCK)
! 215: ENTRY(ENOLCK, "ENOLCK", "No record locks available"),
! 216: #endif
! 217: #if defined (EBADE)
! 218: ENTRY(EBADE, "EBADE", "Invalid exchange"),
! 219: #endif
! 220: #if defined (EBADR)
! 221: ENTRY(EBADR, "EBADR", "Invalid request descriptor"),
! 222: #endif
! 223: #if defined (EXFULL)
! 224: ENTRY(EXFULL, "EXFULL", "Exchange full"),
! 225: #endif
! 226: #if defined (ENOANO)
! 227: ENTRY(ENOANO, "ENOANO", "No anode"),
! 228: #endif
! 229: #if defined (EBADRQC)
! 230: ENTRY(EBADRQC, "EBADRQC", "Invalid request code"),
! 231: #endif
! 232: #if defined (EBADSLT)
! 233: ENTRY(EBADSLT, "EBADSLT", "Invalid slot"),
! 234: #endif
! 235: #if defined (EDEADLOCK)
! 236: ENTRY(EDEADLOCK, "EDEADLOCK", "File locking deadlock error"),
! 237: #endif
! 238: #if defined (EBFONT)
! 239: ENTRY(EBFONT, "EBFONT", "Bad font file format"),
! 240: #endif
! 241: #if defined (ENOSTR)
! 242: ENTRY(ENOSTR, "ENOSTR", "Device not a stream"),
! 243: #endif
! 244: #if defined (ENODATA)
! 245: ENTRY(ENODATA, "ENODATA", "No data available"),
! 246: #endif
! 247: #if defined (ETIME)
! 248: ENTRY(ETIME, "ETIME", "Timer expired"),
! 249: #endif
! 250: #if defined (ENOSR)
! 251: ENTRY(ENOSR, "ENOSR", "Out of streams resources"),
! 252: #endif
! 253: #if defined (ENONET)
! 254: ENTRY(ENONET, "ENONET", "Machine is not on the network"),
! 255: #endif
! 256: #if defined (ENOPKG)
! 257: ENTRY(ENOPKG, "ENOPKG", "Package not installed"),
! 258: #endif
! 259: #if defined (EREMOTE)
! 260: ENTRY(EREMOTE, "EREMOTE", "Object is remote"),
! 261: #endif
! 262: #if defined (ENOLINK)
! 263: ENTRY(ENOLINK, "ENOLINK", "Link has been severed"),
! 264: #endif
! 265: #if defined (EADV)
! 266: ENTRY(EADV, "EADV", "Advertise error"),
! 267: #endif
! 268: #if defined (ESRMNT)
! 269: ENTRY(ESRMNT, "ESRMNT", "Srmount error"),
! 270: #endif
! 271: #if defined (ECOMM)
! 272: ENTRY(ECOMM, "ECOMM", "Communication error on send"),
! 273: #endif
! 274: #if defined (EPROTO)
! 275: ENTRY(EPROTO, "EPROTO", "Protocol error"),
! 276: #endif
! 277: #if defined (EMULTIHOP)
! 278: ENTRY(EMULTIHOP, "EMULTIHOP", "Multihop attempted"),
! 279: #endif
! 280: #if defined (EDOTDOT)
! 281: ENTRY(EDOTDOT, "EDOTDOT", "RFS specific error"),
! 282: #endif
! 283: #if defined (EBADMSG)
! 284: ENTRY(EBADMSG, "EBADMSG", "Not a data message"),
! 285: #endif
! 286: #if defined (ENAMETOOLONG)
! 287: ENTRY(ENAMETOOLONG, "ENAMETOOLONG", "File name too long"),
! 288: #endif
! 289: #if defined (EOVERFLOW)
! 290: ENTRY(EOVERFLOW, "EOVERFLOW", "Value too large for defined data type"),
! 291: #endif
! 292: #if defined (ENOTUNIQ)
! 293: ENTRY(ENOTUNIQ, "ENOTUNIQ", "Name not unique on network"),
! 294: #endif
! 295: #if defined (EBADFD)
! 296: ENTRY(EBADFD, "EBADFD", "File descriptor in bad state"),
! 297: #endif
! 298: #if defined (EREMCHG)
! 299: ENTRY(EREMCHG, "EREMCHG", "Remote address changed"),
! 300: #endif
! 301: #if defined (ELIBACC)
! 302: ENTRY(ELIBACC, "ELIBACC", "Can not access a needed shared library"),
! 303: #endif
! 304: #if defined (ELIBBAD)
! 305: ENTRY(ELIBBAD, "ELIBBAD", "Accessing a corrupted shared library"),
! 306: #endif
! 307: #if defined (ELIBSCN)
! 308: ENTRY(ELIBSCN, "ELIBSCN", ".lib section in a.out corrupted"),
! 309: #endif
! 310: #if defined (ELIBMAX)
! 311: ENTRY(ELIBMAX, "ELIBMAX", "Attempting to link in too many shared libraries"),
! 312: #endif
! 313: #if defined (ELIBEXEC)
! 314: ENTRY(ELIBEXEC, "ELIBEXEC", "Cannot exec a shared library directly"),
! 315: #endif
! 316: #if defined (EILSEQ)
! 317: ENTRY(EILSEQ, "EILSEQ", "Illegal byte sequence"),
! 318: #endif
! 319: #if defined (ENOSYS)
! 320: ENTRY(ENOSYS, "ENOSYS", "Operation not applicable"),
! 321: #endif
! 322: #if defined (ELOOP)
! 323: ENTRY(ELOOP, "ELOOP", "Too many symbolic links encountered"),
! 324: #endif
! 325: #if defined (ERESTART)
! 326: ENTRY(ERESTART, "ERESTART", "Interrupted system call should be restarted"),
! 327: #endif
! 328: #if defined (ESTRPIPE)
! 329: ENTRY(ESTRPIPE, "ESTRPIPE", "Streams pipe error"),
! 330: #endif
! 331: #if defined (ENOTEMPTY)
! 332: ENTRY(ENOTEMPTY, "ENOTEMPTY", "Directory not empty"),
! 333: #endif
! 334: #if defined (EUSERS)
! 335: ENTRY(EUSERS, "EUSERS", "Too many users"),
! 336: #endif
! 337: #if defined (ENOTSOCK)
! 338: ENTRY(ENOTSOCK, "ENOTSOCK", "Socket operation on non-socket"),
! 339: #endif
! 340: #if defined (EDESTADDRREQ)
! 341: ENTRY(EDESTADDRREQ, "EDESTADDRREQ", "Destination address required"),
! 342: #endif
! 343: #if defined (EMSGSIZE)
! 344: ENTRY(EMSGSIZE, "EMSGSIZE", "Message too long"),
! 345: #endif
! 346: #if defined (EPROTOTYPE)
! 347: ENTRY(EPROTOTYPE, "EPROTOTYPE", "Protocol wrong type for socket"),
! 348: #endif
! 349: #if defined (ENOPROTOOPT)
! 350: ENTRY(ENOPROTOOPT, "ENOPROTOOPT", "Protocol option not available"),
! 351: #endif
! 352: #if defined (EPROTONOSUPPORT)
! 353: ENTRY(EPROTONOSUPPORT, "EPROTONOSUPPORT", "Protocol not supported"),
! 354: #endif
! 355: #if defined (ESOCKTNOSUPPORT)
! 356: ENTRY(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT", "Socket type not supported"),
! 357: #endif
! 358: #if defined (EOPNOTSUPP)
! 359: ENTRY(EOPNOTSUPP, "EOPNOTSUPP", "Operation not supported on transport endpoint"),
! 360: #endif
! 361: #if defined (EPFNOSUPPORT)
! 362: ENTRY(EPFNOSUPPORT, "EPFNOSUPPORT", "Protocol family not supported"),
! 363: #endif
! 364: #if defined (EAFNOSUPPORT)
! 365: ENTRY(EAFNOSUPPORT, "EAFNOSUPPORT", "Address family not supported by protocol"),
! 366: #endif
! 367: #if defined (EADDRINUSE)
! 368: ENTRY(EADDRINUSE, "EADDRINUSE", "Address already in use"),
! 369: #endif
! 370: #if defined (EADDRNOTAVAIL)
! 371: ENTRY(EADDRNOTAVAIL, "EADDRNOTAVAIL","Cannot assign requested address"),
! 372: #endif
! 373: #if defined (ENETDOWN)
! 374: ENTRY(ENETDOWN, "ENETDOWN", "Network is down"),
! 375: #endif
! 376: #if defined (ENETUNREACH)
! 377: ENTRY(ENETUNREACH, "ENETUNREACH", "Network is unreachable"),
! 378: #endif
! 379: #if defined (ENETRESET)
! 380: ENTRY(ENETRESET, "ENETRESET", "Network dropped connection because of reset"),
! 381: #endif
! 382: #if defined (ECONNABORTED)
! 383: ENTRY(ECONNABORTED, "ECONNABORTED", "Software caused connection abort"),
! 384: #endif
! 385: #if defined (ECONNRESET)
! 386: ENTRY(ECONNRESET, "ECONNRESET", "Connection reset by peer"),
! 387: #endif
! 388: #if defined (ENOBUFS)
! 389: ENTRY(ENOBUFS, "ENOBUFS", "No buffer space available"),
! 390: #endif
! 391: #if defined (EISCONN)
! 392: ENTRY(EISCONN, "EISCONN", "Transport endpoint is already connected"),
! 393: #endif
! 394: #if defined (ENOTCONN)
! 395: ENTRY(ENOTCONN, "ENOTCONN", "Transport endpoint is not connected"),
! 396: #endif
! 397: #if defined (ESHUTDOWN)
! 398: ENTRY(ESHUTDOWN, "ESHUTDOWN", "Cannot send after transport endpoint shutdown"),
! 399: #endif
! 400: #if defined (ETOOMANYREFS)
! 401: ENTRY(ETOOMANYREFS, "ETOOMANYREFS", "Too many references: cannot splice"),
! 402: #endif
! 403: #if defined (ETIMEDOUT)
! 404: ENTRY(ETIMEDOUT, "ETIMEDOUT", "Connection timed out"),
! 405: #endif
! 406: #if defined (ECONNREFUSED)
! 407: ENTRY(ECONNREFUSED, "ECONNREFUSED", "Connection refused"),
! 408: #endif
! 409: #if defined (EHOSTDOWN)
! 410: ENTRY(EHOSTDOWN, "EHOSTDOWN", "Host is down"),
! 411: #endif
! 412: #if defined (EHOSTUNREACH)
! 413: ENTRY(EHOSTUNREACH, "EHOSTUNREACH", "No route to host"),
! 414: #endif
! 415: #if defined (EALREADY)
! 416: ENTRY(EALREADY, "EALREADY", "Operation already in progress"),
! 417: #endif
! 418: #if defined (EINPROGRESS)
! 419: ENTRY(EINPROGRESS, "EINPROGRESS", "Operation now in progress"),
! 420: #endif
! 421: #if defined (ESTALE)
! 422: ENTRY(ESTALE, "ESTALE", "Stale NFS file handle"),
! 423: #endif
! 424: #if defined (EUCLEAN)
! 425: ENTRY(EUCLEAN, "EUCLEAN", "Structure needs cleaning"),
! 426: #endif
! 427: #if defined (ENOTNAM)
! 428: ENTRY(ENOTNAM, "ENOTNAM", "Not a XENIX named type file"),
! 429: #endif
! 430: #if defined (ENAVAIL)
! 431: ENTRY(ENAVAIL, "ENAVAIL", "No XENIX semaphores available"),
! 432: #endif
! 433: #if defined (EISNAM)
! 434: ENTRY(EISNAM, "EISNAM", "Is a named type file"),
! 435: #endif
! 436: #if defined (EREMOTEIO)
! 437: ENTRY(EREMOTEIO, "EREMOTEIO", "Remote I/O error"),
! 438: #endif
! 439: ENTRY(0, NULL, NULL)
! 440: };
! 441:
! 442: #ifdef EVMSERR
! 443: /* This is not in the table, because the numeric value of EVMSERR (32767)
! 444: lies outside the range of sys_errlist[]. */
! 445: static struct { int value; const char *name, *msg; }
! 446: evmserr = { EVMSERR, "EVMSERR", "VMS-specific error" };
! 447: #endif
! 448:
! 449: /* Translation table allocated and initialized at runtime. Indexed by the
! 450: errno value to find the equivalent symbolic value. */
! 451:
! 452: static const char **error_names;
! 453: static int num_error_names = 0;
! 454:
! 455: /* Translation table allocated and initialized at runtime, if it does not
! 456: already exist in the host environment. Indexed by the errno value to find
! 457: the descriptive string.
! 458:
! 459: We don't export it for use in other modules because even though it has the
! 460: same name, it differs from other implementations in that it is dynamically
! 461: initialized rather than statically initialized. */
! 462:
! 463: #ifndef HAVE_SYS_ERRLIST
! 464:
! 465: #define sys_nerr sys_nerr__
! 466: #define sys_errlist sys_errlist__
! 467: static int sys_nerr;
! 468: static const char **sys_errlist;
! 469:
! 470: #else
! 471:
! 472: extern int sys_nerr;
! 473: extern char *sys_errlist[];
! 474:
! 475: #endif
! 476:
! 477: /*
! 478:
! 479: NAME
! 480:
! 481: init_error_tables -- initialize the name and message tables
! 482:
! 483: SYNOPSIS
! 484:
! 485: static void init_error_tables ();
! 486:
! 487: DESCRIPTION
! 488:
! 489: Using the error_table, which is initialized at compile time, generate
! 490: the error_names and the sys_errlist (if needed) tables, which are
! 491: indexed at runtime by a specific errno value.
! 492:
! 493: BUGS
! 494:
! 495: The initialization of the tables may fail under low memory conditions,
! 496: in which case we don't do anything particularly useful, but we don't
! 497: bomb either. Who knows, it might succeed at a later point if we free
! 498: some memory in the meantime. In any case, the other routines know
! 499: how to deal with lack of a table after trying to initialize it. This
! 500: may or may not be considered to be a bug, that we don't specifically
! 501: warn about this particular failure mode.
! 502:
! 503: */
! 504:
! 505: static void
! 506: init_error_tables (void)
! 507: {
! 508: const struct error_info *eip;
! 509: int nbytes;
! 510:
! 511: /* If we haven't already scanned the error_table once to find the maximum
! 512: errno value, then go find it now. */
! 513:
! 514: if (num_error_names == 0)
! 515: {
! 516: for (eip = error_table; eip -> name != NULL; eip++)
! 517: {
! 518: if (eip -> value >= num_error_names)
! 519: {
! 520: num_error_names = eip -> value + 1;
! 521: }
! 522: }
! 523: }
! 524:
! 525: /* Now attempt to allocate the error_names table, zero it out, and then
! 526: initialize it from the statically initialized error_table. */
! 527:
! 528: if (error_names == NULL)
! 529: {
! 530: nbytes = num_error_names * sizeof (char *);
! 531: if ((error_names = (const char **) malloc (nbytes)) != NULL)
! 532: {
! 533: memset (error_names, 0, nbytes);
! 534: for (eip = error_table; eip -> name != NULL; eip++)
! 535: {
! 536: error_names[eip -> value] = eip -> name;
! 537: }
! 538: }
! 539: }
! 540:
! 541: #ifndef HAVE_SYS_ERRLIST
! 542:
! 543: /* Now attempt to allocate the sys_errlist table, zero it out, and then
! 544: initialize it from the statically initialized error_table. */
! 545:
! 546: if (sys_errlist == NULL)
! 547: {
! 548: nbytes = num_error_names * sizeof (char *);
! 549: if ((sys_errlist = (const char **) malloc (nbytes)) != NULL)
! 550: {
! 551: memset (sys_errlist, 0, nbytes);
! 552: sys_nerr = num_error_names;
! 553: for (eip = error_table; eip -> name != NULL; eip++)
! 554: {
! 555: sys_errlist[eip -> value] = eip -> msg;
! 556: }
! 557: }
! 558: }
! 559:
! 560: #endif
! 561:
! 562: }
! 563:
! 564: /*
! 565:
! 566:
! 567: @deftypefn Extension int errno_max (void)
! 568:
! 569: Returns the maximum @code{errno} value for which a corresponding
! 570: symbolic name or message is available. Note that in the case where we
! 571: use the @code{sys_errlist} supplied by the system, it is possible for
! 572: there to be more symbolic names than messages, or vice versa. In
! 573: fact, the manual page for @code{perror(3C)} explicitly warns that one
! 574: should check the size of the table (@code{sys_nerr}) before indexing
! 575: it, since new error codes may be added to the system before they are
! 576: added to the table. Thus @code{sys_nerr} might be smaller than value
! 577: implied by the largest @code{errno} value defined in @code{<errno.h>}.
! 578:
! 579: We return the maximum value that can be used to obtain a meaningful
! 580: symbolic name or message.
! 581:
! 582: @end deftypefn
! 583:
! 584: */
! 585:
! 586: int
! 587: errno_max (void)
! 588: {
! 589: int maxsize;
! 590:
! 591: if (error_names == NULL)
! 592: {
! 593: init_error_tables ();
! 594: }
! 595: maxsize = MAX (sys_nerr, num_error_names);
! 596: return (maxsize - 1);
! 597: }
! 598:
! 599: #ifndef HAVE_STRERROR
! 600:
! 601: /*
! 602:
! 603: @deftypefn Supplemental char* strerror (int @var{errnoval})
! 604:
! 605: Maps an @code{errno} number to an error message string, the contents
! 606: of which are implementation defined. On systems which have the
! 607: external variables @code{sys_nerr} and @code{sys_errlist}, these
! 608: strings will be the same as the ones used by @code{perror}.
! 609:
! 610: If the supplied error number is within the valid range of indices for
! 611: the @code{sys_errlist}, but no message is available for the particular
! 612: error number, then returns the string @samp{Error @var{num}}, where
! 613: @var{num} is the error number.
! 614:
! 615: If the supplied error number is not a valid index into
! 616: @code{sys_errlist}, returns @code{NULL}.
! 617:
! 618: The returned string is only guaranteed to be valid only until the
! 619: next call to @code{strerror}.
! 620:
! 621: @end deftypefn
! 622:
! 623: */
! 624:
! 625: char *
! 626: strerror (int errnoval)
! 627: {
! 628: const char *msg;
! 629: static char buf[32];
! 630:
! 631: #ifndef HAVE_SYS_ERRLIST
! 632:
! 633: if (error_names == NULL)
! 634: {
! 635: init_error_tables ();
! 636: }
! 637:
! 638: #endif
! 639:
! 640: if ((errnoval < 0) || (errnoval >= sys_nerr))
! 641: {
! 642: #ifdef EVMSERR
! 643: if (errnoval == evmserr.value)
! 644: msg = evmserr.msg;
! 645: else
! 646: #endif
! 647: /* Out of range, just return NULL */
! 648: msg = NULL;
! 649: }
! 650: else if ((sys_errlist == NULL) || (sys_errlist[errnoval] == NULL))
! 651: {
! 652: /* In range, but no sys_errlist or no entry at this index. */
! 653: sprintf (buf, "Error %d", errnoval);
! 654: msg = buf;
! 655: }
! 656: else
! 657: {
! 658: /* In range, and a valid message. Just return the message. */
! 659: msg = (char *) sys_errlist[errnoval];
! 660: }
! 661:
! 662: return (msg);
! 663: }
! 664:
! 665: #endif /* ! HAVE_STRERROR */
! 666:
! 667:
! 668: /*
! 669:
! 670: @deftypefn Replacement {const char*} strerrno (int @var{errnum})
! 671:
! 672: Given an error number returned from a system call (typically returned
! 673: in @code{errno}), returns a pointer to a string containing the
! 674: symbolic name of that error number, as found in @code{<errno.h>}.
! 675:
! 676: If the supplied error number is within the valid range of indices for
! 677: symbolic names, but no name is available for the particular error
! 678: number, then returns the string @samp{Error @var{num}}, where @var{num}
! 679: is the error number.
! 680:
! 681: If the supplied error number is not within the range of valid
! 682: indices, then returns @code{NULL}.
! 683:
! 684: The contents of the location pointed to are only guaranteed to be
! 685: valid until the next call to @code{strerrno}.
! 686:
! 687: @end deftypefn
! 688:
! 689: */
! 690:
! 691: const char *
! 692: strerrno (int errnoval)
! 693: {
! 694: const char *name;
! 695: static char buf[32];
! 696:
! 697: if (error_names == NULL)
! 698: {
! 699: init_error_tables ();
! 700: }
! 701:
! 702: if ((errnoval < 0) || (errnoval >= num_error_names))
! 703: {
! 704: #ifdef EVMSERR
! 705: if (errnoval == evmserr.value)
! 706: name = evmserr.name;
! 707: else
! 708: #endif
! 709: /* Out of range, just return NULL */
! 710: name = NULL;
! 711: }
! 712: else if ((error_names == NULL) || (error_names[errnoval] == NULL))
! 713: {
! 714: /* In range, but no error_names or no entry at this index. */
! 715: sprintf (buf, "Error %d", errnoval);
! 716: name = (const char *) buf;
! 717: }
! 718: else
! 719: {
! 720: /* In range, and a valid name. Just return the name. */
! 721: name = error_names[errnoval];
! 722: }
! 723:
! 724: return (name);
! 725: }
! 726:
! 727: /*
! 728:
! 729: @deftypefn Extension int strtoerrno (const char *@var{name})
! 730:
! 731: Given the symbolic name of a error number (e.g., @code{EACCES}), map it
! 732: to an errno value. If no translation is found, returns 0.
! 733:
! 734: @end deftypefn
! 735:
! 736: */
! 737:
! 738: int
! 739: strtoerrno (const char *name)
! 740: {
! 741: int errnoval = 0;
! 742:
! 743: if (name != NULL)
! 744: {
! 745: if (error_names == NULL)
! 746: {
! 747: init_error_tables ();
! 748: }
! 749: for (errnoval = 0; errnoval < num_error_names; errnoval++)
! 750: {
! 751: if ((error_names[errnoval] != NULL) &&
! 752: (strcmp (name, error_names[errnoval]) == 0))
! 753: {
! 754: break;
! 755: }
! 756: }
! 757: if (errnoval == num_error_names)
! 758: {
! 759: #ifdef EVMSERR
! 760: if (strcmp (name, evmserr.name) == 0)
! 761: errnoval = evmserr.value;
! 762: else
! 763: #endif
! 764: errnoval = 0;
! 765: }
! 766: }
! 767: return (errnoval);
! 768: }
! 769:
! 770:
! 771: /* A simple little main that does nothing but print all the errno translations
! 772: if MAIN is defined and this file is compiled and linked. */
! 773:
! 774: #ifdef MAIN
! 775:
! 776: #include <stdio.h>
! 777:
! 778: int
! 779: main (void)
! 780: {
! 781: int errn;
! 782: int errnmax;
! 783: const char *name;
! 784: const char *msg;
! 785: char *strerror ();
! 786:
! 787: errnmax = errno_max ();
! 788: printf ("%d entries in names table.\n", num_error_names);
! 789: printf ("%d entries in messages table.\n", sys_nerr);
! 790: printf ("%d is max useful index.\n", errnmax);
! 791:
! 792: /* Keep printing values until we get to the end of *both* tables, not
! 793: *either* table. Note that knowing the maximum useful index does *not*
! 794: relieve us of the responsibility of testing the return pointer for
! 795: NULL. */
! 796:
! 797: for (errn = 0; errn <= errnmax; errn++)
! 798: {
! 799: name = strerrno (errn);
! 800: name = (name == NULL) ? "<NULL>" : name;
! 801: msg = strerror (errn);
! 802: msg = (msg == NULL) ? "<NULL>" : msg;
! 803: printf ("%-4d%-18s%s\n", errn, name, msg);
! 804: }
! 805:
! 806: return 0;
! 807: }
! 808:
! 809: #endif
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to strerror.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / libiberty