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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [libiberty/] [strerror.c] - Blame information for rev 1776

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

Line No. Rev Author Line
1 578 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_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 
  int value;            /* The numeric value from <errno.h> */
62 
  const char *name;     /* The equivalent symbolic value */
63 
#ifndef HAVE_SYS_ERRLIST
64 
  const char *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 
static int sys_nerr;
466 
static const char **sys_errlist;
467 
 
468 
#else
469 
 
470 
extern int sys_nerr;
471 
extern char *sys_errlist[];
472 
 
473 
#endif
474 
 
475 
 
476 
/*
477 
 
478 
NAME
479 
 
480 
        init_error_tables -- initialize the name and message tables
481 
 
482 
SYNOPSIS
483 
 
484 
        static void init_error_tables ();
485 
 
486 
DESCRIPTION
487 
 
488 
        Using the error_table, which is initialized at compile time, generate
489 
        the error_names and the sys_errlist (if needed) tables, which are
490 
        indexed at runtime by a specific errno value.
491 
 
492 
BUGS
493 
 
494 
        The initialization of the tables may fail under low memory conditions,
495 
        in which case we don't do anything particularly useful, but we don't
496 
        bomb either.  Who knows, it might succeed at a later point if we free
497 
        some memory in the meantime.  In any case, the other routines know
498 
        how to deal with lack of a table after trying to initialize it.  This
499 
        may or may not be considered to be a bug, that we don't specifically
500 
        warn about this particular failure mode.
501 
 
502 
*/
503 
 
504 
static void
505 
init_error_tables ()
506 
{
507 
  const struct error_info *eip;
508 
  int nbytes;
509 
 
510 
  /* If we haven't already scanned the error_table once to find the maximum
511 
     errno value, then go find it now. */
512 
 
513 
  if (num_error_names == 0)
514 
    {
515 
      for (eip = error_table; eip -> name != NULL; eip++)
516 
        {
517 
          if (eip -> value >= num_error_names)
518 
            {
519 
              num_error_names = eip -> value + 1;
520 
            }
521 
        }
522 
    }
523 
 
524 
  /* Now attempt to allocate the error_names table, zero it out, and then
525 
     initialize it from the statically initialized error_table. */
526 
 
527 
  if (error_names == NULL)
528 
    {
529 
      nbytes = num_error_names * sizeof (char *);
530 
      if ((error_names = (const char **) malloc (nbytes)) != NULL)
531 
        {
532 
          memset (error_names, 0, nbytes);
533 
          for (eip = error_table; eip -> name != NULL; eip++)
534 
            {
535 
              error_names[eip -> value] = eip -> name;
536 
            }
537 
        }
538 
    }
539 
 
540 
#ifndef HAVE_SYS_ERRLIST
541 
 
542 
  /* Now attempt to allocate the sys_errlist table, zero it out, and then
543 
     initialize it from the statically initialized error_table. */
544 
 
545 
  if (sys_errlist == NULL)
546 
    {
547 
      nbytes = num_error_names * sizeof (char *);
548 
      if ((sys_errlist = (const char **) malloc (nbytes)) != NULL)
549 
        {
550 
          memset (sys_errlist, 0, nbytes);
551 
          sys_nerr = num_error_names;
552 
          for (eip = error_table; eip -> name != NULL; eip++)
553 
            {
554 
              sys_errlist[eip -> value] = eip -> msg;
555 
            }
556 
        }
557 
    }
558 
 
559 
#endif
560 
 
561 
}
562 
 
563 
/*
564 
 
565 
NAME
566 
 
567 
        errno_max -- return the max errno value
568 
 
569 
SYNOPSIS
570 
 
571 
        int errno_max ();
572 
 
573 
DESCRIPTION
574 
 
575 
        Returns the maximum errno value for which a corresponding symbolic
576 
        name or message is available.  Note that in the case where
577 
        we use the sys_errlist supplied by the system, it is possible for
578 
        there to be more symbolic names than messages, or vice versa.
579 
        In fact, the manual page for perror(3C) explicitly warns that one
580 
        should check the size of the table (sys_nerr) before indexing it,
581 
        since new error codes may be added to the system before they are
582 
        added to the table.  Thus sys_nerr might be smaller than value
583 
        implied by the largest errno value defined in <errno.h>.
584 
 
585 
        We return the maximum value that can be used to obtain a meaningful
586 
        symbolic name or message.
587 
 
588 
*/
589 
 
590 
int
591 
errno_max ()
592 
{
593 
  int maxsize;
594 
 
595 
  if (error_names == NULL)
596 
    {
597 
      init_error_tables ();
598 
    }
599 
  maxsize = MAX (sys_nerr, num_error_names);
600 
  return (maxsize - 1);
601 
}
602 
 
603 
#ifndef HAVE_STRERROR
604 
 
605 
/*
606 
 
607 
NAME
608 
 
609 
        strerror -- map an error number to an error message string
610 
 
611 
SYNOPSIS
612 
 
613 
        char *strerror (int errnoval)
614 
 
615 
DESCRIPTION
616 
 
617 
        Maps an errno number to an error message string, the contents of
618 
        which are implementation defined.  On systems which have the external
619 
        variables sys_nerr and sys_errlist, these strings will be the same
620 
        as the ones used by perror().
621 
 
622 
        If the supplied error number is within the valid range of indices
623 
        for the sys_errlist, but no message is available for the particular
624 
        error number, then returns the string "Error NUM", where NUM is the
625 
        error number.
626 
 
627 
        If the supplied error number is not a valid index into sys_errlist,
628 
        returns NULL.
629 
 
630 
        The returned string is only guaranteed to be valid only until the
631 
        next call to strerror.
632 
 
633 
*/
634 
 
635 
char *
636 
strerror (errnoval)
637 
  int errnoval;
638 
{
639 
  char *msg;
640 
  static char buf[32];
641 
 
642 
#ifndef HAVE_SYS_ERRLIST
643 
 
644 
  if (error_names == NULL)
645 
    {
646 
      init_error_tables ();
647 
    }
648 
 
649 
#endif
650 
 
651 
  if ((errnoval < 0) || (errnoval >= sys_nerr))
652 
    {
653 
#ifdef EVMSERR
654 
      if (errnoval == evmserr.value)
655 
        msg = evmserr.msg;
656 
      else
657 
#endif
658 
      /* Out of range, just return NULL */
659 
      msg = NULL;
660 
    }
661 
  else if ((sys_errlist == NULL) || (sys_errlist[errnoval] == NULL))
662 
    {
663 
      /* In range, but no sys_errlist or no entry at this index. */
664 
      sprintf (buf, "Error %d", errnoval);
665 
      msg = buf;
666 
    }
667 
  else
668 
    {
669 
      /* In range, and a valid message.  Just return the message. */
670 
      msg = (char *) sys_errlist[errnoval];
671 
    }
672 
 
673 
  return (msg);
674 
}
675 
 
676 
#endif  /* ! HAVE_STRERROR */
677 
 
678 
 
679 
/*
680 
 
681 
NAME
682 
 
683 
        strerrno -- map an error number to a symbolic name string
684 
 
685 
SYNOPSIS
686 
 
687 
        const char *strerrno (int errnoval)
688 
 
689 
DESCRIPTION
690 
 
691 
        Given an error number returned from a system call (typically
692 
        returned in errno), returns a pointer to a string containing the
693 
        symbolic name of that error number, as found in <errno.h>.
694 
 
695 
        If the supplied error number is within the valid range of indices
696 
        for symbolic names, but no name is available for the particular
697 
        error number, then returns the string "Error NUM", where NUM is
698 
        the error number.
699 
 
700 
        If the supplied error number is not within the range of valid
701 
        indices, then returns NULL.
702 
 
703 
BUGS
704 
 
705 
        The contents of the location pointed to are only guaranteed to be
706 
        valid until the next call to strerrno.
707 
 
708 
*/
709 
 
710 
const char *
711 
strerrno (errnoval)
712 
  int errnoval;
713 
{
714 
  const char *name;
715 
  static char buf[32];
716 
 
717 
  if (error_names == NULL)
718 
    {
719 
      init_error_tables ();
720 
    }
721 
 
722 
  if ((errnoval < 0) || (errnoval >= num_error_names))
723 
    {
724 
#ifdef EVMSERR
725 
      if (errnoval == evmserr.value)
726 
        name = evmserr.name;
727 
      else
728 
#endif
729 
      /* Out of range, just return NULL */
730 
      name = NULL;
731 
    }
732 
  else if ((error_names == NULL) || (error_names[errnoval] == NULL))
733 
    {
734 
      /* In range, but no error_names or no entry at this index. */
735 
      sprintf (buf, "Error %d", errnoval);
736 
      name = (const char *) buf;
737 
    }
738 
  else
739 
    {
740 
      /* In range, and a valid name.  Just return the name. */
741 
      name = error_names[errnoval];
742 
    }
743 
 
744 
  return (name);
745 
}
746 
 
747 
/*
748 
 
749 
NAME
750 
 
751 
        strtoerrno -- map a symbolic errno name to a numeric value
752 
 
753 
SYNOPSIS
754 
 
755 
        int strtoerrno (char *name)
756 
 
757 
DESCRIPTION
758 
 
759 
        Given the symbolic name of a error number, map it to an errno value.
760 
        If no translation is found, returns 0.
761 
 
762 
*/
763 
 
764 
int
765 
strtoerrno (name)
766 
     const char *name;
767 
{
768 
  int errnoval = 0;
769 
 
770 
  if (name != NULL)
771 
    {
772 
      if (error_names == NULL)
773 
        {
774 
          init_error_tables ();
775 
        }
776 
      for (errnoval = 0; errnoval < num_error_names; errnoval++)
777 
        {
778 
          if ((error_names[errnoval] != NULL) &&
779 
              (strcmp (name, error_names[errnoval]) == 0))
780 
            {
781 
              break;
782 
            }
783 
        }
784 
      if (errnoval == num_error_names)
785 
        {
786 
#ifdef EVMSERR
787 
          if (strcmp (name, evmserr.name) == 0)
788 
            errnoval = evmserr.value;
789 
          else
790 
#endif
791 
          errnoval = 0;
792 
        }
793 
    }
794 
  return (errnoval);
795 
}
796 
 
797 
 
798 
/* A simple little main that does nothing but print all the errno translations
799 
   if MAIN is defined and this file is compiled and linked. */
800 
 
801 
#ifdef MAIN
802 
 
803 
#include <stdio.h>
804 
 
805 
int
806 
main ()
807 
{
808 
  int errn;
809 
  int errnmax;
810 
  const char *name;
811 
  char *msg;
812 
  char *strerror ();
813 
 
814 
  errnmax = errno_max ();
815 
  printf ("%d entries in names table.\n", num_error_names);
816 
  printf ("%d entries in messages table.\n", sys_nerr);
817 
  printf ("%d is max useful index.\n", errnmax);
818 
 
819 
  /* Keep printing values until we get to the end of *both* tables, not
820 
     *either* table.  Note that knowing the maximum useful index does *not*
821 
     relieve us of the responsibility of testing the return pointer for
822 
     NULL. */
823 
 
824 
  for (errn = 0; errn <= errnmax; errn++)
825 
    {
826 
      name = strerrno (errn);
827 
      name = (name == NULL) ? "<NULL>" : name;
828 
      msg = strerror (errn);
829 
      msg = (msg == NULL) ? "<NULL>" : msg;
830 
      printf ("%-4d%-18s%s\n", errn, name, msg);
831 
    }
832 
 
833 
  return 0;
834 
}
835 
 
836 
#endif

powered by: WebSVN 2.1.0

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