gnu/dist/gdb6/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 "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