libiberty/strerror.c

   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 "ansidecl.h"
   6 #include "libiberty.h"
   7
   8 #include "config.h"
   9
  10 #ifdef HAVE_SYS_ERRLIST
  11 /* Note that errno.h (not sure what OS) or stdio.h (BSD 4.4, at least)
  12    might declare sys_errlist in a way that the compiler might consider
  13    incompatible with our later declaration, perhaps by using const
  14    attributes.  So we hide the declaration in errno.h (if any) using a
  15    macro. */
  16 #define sys_nerr sys_nerr__
  17 #define sys_errlist sys_errlist__
  18 #endif
  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 PARAMS ((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 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 ()
 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 ()
 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 (errnoval)
 627   int errnoval;
 628 {
 629   const char *msg;
 630   static char buf[32];
 631
 632 #ifndef HAVE_SYS_ERRLIST
 633
 634   if (error_names == NULL)
 635     {
 636       init_error_tables ();
 637     }
 638
 639 #endif
 640
 641   if ((errnoval < 0) || (errnoval >= sys_nerr))
 642     {
 643 #ifdef EVMSERR
 644       if (errnoval == evmserr.value)
 645         msg = evmserr.msg;
 646       else
 647 #endif
 648       /* Out of range, just return NULL */
 649       msg = NULL;
 650     }
 651   else if ((sys_errlist == NULL) || (sys_errlist[errnoval] == NULL))
 652     {
 653       /* In range, but no sys_errlist or no entry at this index. */
 654       sprintf (buf, "Error %d", errnoval);
 655       msg = buf;
 656     }
 657   else
 658     {
 659       /* In range, and a valid message.  Just return the message. */
 660       msg = (char *) sys_errlist[errnoval];
 661     }
 662
 663   return (msg);
 664 }
 665
 666 #endif  /* ! HAVE_STRERROR */
 667
 668
 669 /*
 670
 671 @deftypefn Replacement {const char*} strerrno (int @var{errnum})
 672
 673 Given an error number returned from a system call (typically returned
 674 in @code{errno}), returns a pointer to a string containing the
 675 symbolic name of that error number, as found in @code{<errno.h>}.
 676
 677 If the supplied error number is within the valid range of indices for
 678 symbolic names, but no name is available for the particular error
 679 number, then returns the string @samp{Error @var{num}}, where @var{num}
 680 is the error number.
 681
 682 If the supplied error number is not within the range of valid
 683 indices, then returns @code{NULL}.
 684
 685 The contents of the location pointed to are only guaranteed to be
 686 valid until the next call to @code{strerrno}.
 687
 688 @end deftypefn
 689
 690 */
 691
 692 const char *
 693 strerrno (errnoval)
 694   int errnoval;
 695 {
 696   const char *name;
 697   static char buf[32];
 698
 699   if (error_names == NULL)
 700     {
 701       init_error_tables ();
 702     }
 703
 704   if ((errnoval < 0) || (errnoval >= num_error_names))
 705     {
 706 #ifdef EVMSERR
 707       if (errnoval == evmserr.value)
 708         name = evmserr.name;
 709       else
 710 #endif
 711       /* Out of range, just return NULL */
 712       name = NULL;
 713     }
 714   else if ((error_names == NULL) || (error_names[errnoval] == NULL))
 715     {
 716       /* In range, but no error_names or no entry at this index. */
 717       sprintf (buf, "Error %d", errnoval);
 718       name = (const char *) buf;
 719     }
 720   else
 721     {
 722       /* In range, and a valid name.  Just return the name. */
 723       name = error_names[errnoval];
 724     }
 725
 726   return (name);
 727 }
 728
 729 /*
 730
 731 @deftypefn Extension int strtoerrno (const char *@var{name})
 732
 733 Given the symbolic name of a error number (e.g., @code{EACCES}), map it
 734 to an errno value.  If no translation is found, returns 0.
 735
 736 @end deftypefn
 737
 738 */
 739
 740 int
 741 strtoerrno (name)
 742      const char *name;
 743 {
 744   int errnoval = 0;
 745
 746   if (name != NULL)
 747     {
 748       if (error_names == NULL)
 749         {
 750           init_error_tables ();
 751         }
 752       for (errnoval = 0; errnoval < num_error_names; errnoval++)
 753         {
 754           if ((error_names[errnoval] != NULL) &&
 755               (strcmp (name, error_names[errnoval]) == 0))
 756             {
 757               break;
 758             }
 759         }
 760       if (errnoval == num_error_names)
 761         {
 762 #ifdef EVMSERR
 763           if (strcmp (name, evmserr.name) == 0)
 764             errnoval = evmserr.value;
 765           else
 766 #endif
 767           errnoval = 0;
 768         }
 769     }
 770   return (errnoval);
 771 }
 772
 773
 774 /* A simple little main that does nothing but print all the errno translations
 775    if MAIN is defined and this file is compiled and linked. */
 776
 777 #ifdef MAIN
 778
 779 #include <stdio.h>
 780
 781 int
 782 main ()
 783 {
 784   int errn;
 785   int errnmax;
 786   const char *name;
 787   const char *msg;
 788   char *strerror ();
 789
 790   errnmax = errno_max ();
 791   printf ("%d entries in names table.\n", num_error_names);
 792   printf ("%d entries in messages table.\n", sys_nerr);
 793   printf ("%d is max useful index.\n", errnmax);
 794
 795   /* Keep printing values until we get to the end of *both* tables, not
 796      *either* table.  Note that knowing the maximum useful index does *not*
 797      relieve us of the responsibility of testing the return pointer for
 798      NULL. */
 799
 800   for (errn = 0; errn <= errnmax; errn++)
 801     {
 802       name = strerrno (errn);
 803       name = (name == NULL) ? "<NULL>" : name;
 804       msg = strerror (errn);
 805       msg = (msg == NULL) ? "<NULL>" : msg;
 806       printf ("%-4d%-18s%s\n", errn, name, msg);
 807     }
 808
 809   return 0;
 810 }
 811
 812 #endif