OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [libiberty/] [strerror.c] - Blame information for rev 1772

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.