Symaptic: os/persistentdata/persistentstorage/sqlite3api/TEST/TCL/tcldistribution/generic/tclPosixStr.c@260cb5ec6c19

     1 /*

     2  * tclPosixStr.c --

     3  *

     4  *	This file contains procedures that generate strings

     5  *	corresponding to various POSIX-related codes, such

     6  *	as errno and signals.

     7  *

     8  * Copyright (c) 1991-1994 The Regents of the University of California.

     9  * Copyright (c) 1994-1996 Sun Microsystems, Inc.

    10  * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.

    11  *

    12  * See the file "license.terms" for information on usage and redistribution

    13  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

    14  *

    15  * RCS: @(#) $Id: tclPosixStr.c,v 1.9 2002/05/27 10:14:21 dkf Exp $

    16  */

    18 #include "tclInt.h"

    19 #include "tclPort.h"

    21 /*

    22  *----------------------------------------------------------------------

    23  *

    24  * Tcl_ErrnoId --

    25  *

    26  *	Return a textual identifier for the current errno value.

    27  *

    28  * Results:

    29  *	This procedure returns a machine-readable textual identifier

    30  *	that corresponds to the current errno value (e.g. "EPERM").

    31  *	The identifier is the same as the #define name in errno.h.

    32  *

    33  * Side effects:

    34  *	None.

    35  *

    36  *----------------------------------------------------------------------

    37  */

    39 EXPORT_C CONST char *

    40 Tcl_ErrnoId()

    41 {

    42     switch (errno) {

    43 #ifdef E2BIG

    44 	case E2BIG: return "E2BIG";

    45 #endif

    46 #ifdef EACCES

    47 	case EACCES: return "EACCES";

    48 #endif

    49 #ifdef EADDRINUSE

    50 	case EADDRINUSE: return "EADDRINUSE";

    51 #endif

    52 #ifdef EADDRNOTAVAIL

    53 	case EADDRNOTAVAIL: return "EADDRNOTAVAIL";

    54 #endif

    55 #ifdef EADV

    56 	case EADV: return "EADV";

    57 #endif

    58 #ifdef EAFNOSUPPORT

    59 	case EAFNOSUPPORT: return "EAFNOSUPPORT";

    60 #endif

    61 #ifdef EAGAIN

    62 	case EAGAIN: return "EAGAIN";

    63 #endif

    64 #ifdef EALIGN

    65 	case EALIGN: return "EALIGN";

    66 #endif

    67 #if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))

    68 	case EALREADY: return "EALREADY";

    69 #endif

    70 #ifdef EBADE

    71 	case EBADE: return "EBADE";

    72 #endif

    73 #ifdef EBADF

    74 	case EBADF: return "EBADF";

    75 #endif

    76 #ifdef EBADFD

    77 	case EBADFD: return "EBADFD";

    78 #endif

    79 #ifdef EBADMSG

    80 	case EBADMSG: return "EBADMSG";

    81 #endif

    82 #ifdef EBADR

    83 	case EBADR: return "EBADR";

    84 #endif

    85 #ifdef EBADRPC

    86 	case EBADRPC: return "EBADRPC";

    87 #endif

    88 #ifdef EBADRQC

    89 	case EBADRQC: return "EBADRQC";

    90 #endif

    91 #ifdef EBADSLT

    92 	case EBADSLT: return "EBADSLT";

    93 #endif

    94 #ifdef EBFONT

    95 	case EBFONT: return "EBFONT";

    96 #endif

    97 #ifdef EBUSY

    98 	case EBUSY: return "EBUSY";

    99 #endif

   100 #ifdef ECHILD

   101 	case ECHILD: return "ECHILD";

   102 #endif

   103 #ifdef ECHRNG

   104 	case ECHRNG: return "ECHRNG";

   105 #endif

   106 #ifdef ECOMM

   107 	case ECOMM: return "ECOMM";

   108 #endif

   109 #ifdef ECONNABORTED

   110 	case ECONNABORTED: return "ECONNABORTED";

   111 #endif

   112 #ifdef ECONNREFUSED

   113 	case ECONNREFUSED: return "ECONNREFUSED";

   114 #endif

   115 #ifdef ECONNRESET

   116 	case ECONNRESET: return "ECONNRESET";

   117 #endif

   118 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))

   119 	case EDEADLK: return "EDEADLK";

   120 #endif

   121 #if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))

   122 	case EDEADLOCK: return "EDEADLOCK";

   123 #endif

   124 #ifdef EDESTADDRREQ

   125 	case EDESTADDRREQ: return "EDESTADDRREQ";

   126 #endif

   127 #ifdef EDIRTY

   128 	case EDIRTY: return "EDIRTY";

   129 #endif

   130 #ifdef EDOM

   131 	case EDOM: return "EDOM";

   132 #endif

   133 #ifdef EDOTDOT

   134 	case EDOTDOT: return "EDOTDOT";

   135 #endif

   136 #ifdef EDQUOT

   137 	case EDQUOT: return "EDQUOT";

   138 #endif

   139 #ifdef EDUPPKG

   140 	case EDUPPKG: return "EDUPPKG";

   141 #endif

   142 #ifdef EEXIST

   143 	case EEXIST: return "EEXIST";

   144 #endif

   145 #ifdef EFAULT

   146 	case EFAULT: return "EFAULT";

   147 #endif

   148 #ifdef EFBIG

   149 	case EFBIG: return "EFBIG";

   150 #endif

   151 #ifdef EHOSTDOWN

   152 	case EHOSTDOWN: return "EHOSTDOWN";

   153 #endif

   154 #ifdef EHOSTUNREACH

   155 	case EHOSTUNREACH: return "EHOSTUNREACH";

   156 #endif

   157 #if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))

   158 	case EIDRM: return "EIDRM";

   159 #endif

   160 #ifdef EINIT

   161 	case EINIT: return "EINIT";

   162 #endif

   163 #ifdef EINPROGRESS

   164 	case EINPROGRESS: return "EINPROGRESS";

   165 #endif

   166 #ifdef EINTR

   167 	case EINTR: return "EINTR";

   168 #endif

   169 #ifdef EINVAL

   170 	case EINVAL: return "EINVAL";

   171 #endif

   172 #ifdef EIO

   173 	case EIO: return "EIO";

   174 #endif

   175 #ifdef EISCONN

   176 	case EISCONN: return "EISCONN";

   177 #endif

   178 #ifdef EISDIR

   179 	case EISDIR: return "EISDIR";

   180 #endif

   181 #ifdef EISNAME

   182 	case EISNAM: return "EISNAM";

   183 #endif

   184 #ifdef ELBIN

   185 	case ELBIN: return "ELBIN";

   186 #endif

   187 #ifdef EL2HLT

   188 	case EL2HLT: return "EL2HLT";

   189 #endif

   190 #ifdef EL2NSYNC

   191 	case EL2NSYNC: return "EL2NSYNC";

   192 #endif

   193 #ifdef EL3HLT

   194 	case EL3HLT: return "EL3HLT";

   195 #endif

   196 #ifdef EL3RST

   197 	case EL3RST: return "EL3RST";

   198 #endif

   199 #ifdef ELIBACC

   200 	case ELIBACC: return "ELIBACC";

   201 #endif

   202 #ifdef ELIBBAD

   203 	case ELIBBAD: return "ELIBBAD";

   204 #endif

   205 #ifdef ELIBEXEC

   206 	case ELIBEXEC: return "ELIBEXEC";

   207 #endif

   208 #ifdef ELIBMAX

   209 	case ELIBMAX: return "ELIBMAX";

   210 #endif

   211 #ifdef ELIBSCN

   212 	case ELIBSCN: return "ELIBSCN";

   213 #endif

   214 #ifdef ELNRNG

   215 	case ELNRNG: return "ELNRNG";

   216 #endif

   217 #if defined(ELOOP) && (!defined(ENOENT) || (ELOOP != ENOENT))

   218 	case ELOOP: return "ELOOP";

   219 #endif

   220 #ifdef EMFILE

   221 	case EMFILE: return "EMFILE";

   222 #endif

   223 #ifdef EMLINK

   224 	case EMLINK: return "EMLINK";

   225 #endif

   226 #ifdef EMSGSIZE

   227 	case EMSGSIZE: return "EMSGSIZE";

   228 #endif

   229 #ifdef EMULTIHOP

   230 	case EMULTIHOP: return "EMULTIHOP";

   231 #endif

   232 #ifdef ENAMETOOLONG

   233 	case ENAMETOOLONG: return "ENAMETOOLONG";

   234 #endif

   235 #ifdef ENAVAIL

   236 	case ENAVAIL: return "ENAVAIL";

   237 #endif

   238 #ifdef ENET

   239 	case ENET: return "ENET";

   240 #endif

   241 #ifdef ENETDOWN

   242 	case ENETDOWN: return "ENETDOWN";

   243 #endif

   244 #ifdef ENETRESET

   245 	case ENETRESET: return "ENETRESET";

   246 #endif

   247 #ifdef ENETUNREACH

   248 	case ENETUNREACH: return "ENETUNREACH";

   249 #endif

   250 #ifdef ENFILE

   251 	case ENFILE: return "ENFILE";

   252 #endif

   253 #ifdef ENOANO

   254 	case ENOANO: return "ENOANO";

   255 #endif

   256 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))

   257 	case ENOBUFS: return "ENOBUFS";

   258 #endif

   259 #ifdef ENOCSI

   260 	case ENOCSI: return "ENOCSI";

   261 #endif

   262 #if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))

   263 	case ENODATA: return "ENODATA";

   264 #endif

   265 #ifdef ENODEV

   266 	case ENODEV: return "ENODEV";

   267 #endif

   268 #ifdef ENOENT

   269 	case ENOENT: return "ENOENT";

   270 #endif

   271 #ifdef ENOEXEC

   272 	case ENOEXEC: return "ENOEXEC";

   273 #endif

   274 #ifdef ENOLCK

   275 	case ENOLCK: return "ENOLCK";

   276 #endif

   277 #ifdef ENOLINK

   278 	case ENOLINK: return "ENOLINK";

   279 #endif

   280 #ifdef ENOMEM

   281 	case ENOMEM: return "ENOMEM";

   282 #endif

   283 #ifdef ENOMSG

   284 	case ENOMSG: return "ENOMSG";

   285 #endif

   286 #ifdef ENONET

   287 	case ENONET: return "ENONET";

   288 #endif

   289 #ifdef ENOPKG

   290 	case ENOPKG: return "ENOPKG";

   291 #endif

   292 #ifdef ENOPROTOOPT

   293 	case ENOPROTOOPT: return "ENOPROTOOPT";

   294 #endif

   295 #ifdef ENOSPC

   296 	case ENOSPC: return "ENOSPC";

   297 #endif

   298 #if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))

   299 	case ENOSR: return "ENOSR";

   300 #endif

   301 #if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))

   302 	case ENOSTR: return "ENOSTR";

   303 #endif

   304 #ifdef ENOSYM

   305 	case ENOSYM: return "ENOSYM";

   306 #endif

   307 #ifdef ENOSYS

   308 	case ENOSYS: return "ENOSYS";

   309 #endif

   310 #ifdef ENOTBLK

   311 	case ENOTBLK: return "ENOTBLK";

   312 #endif

   313 #ifdef ENOTCONN

   314 	case ENOTCONN: return "ENOTCONN";

   315 #endif

   316 #ifdef ENOTDIR

   317 	case ENOTDIR: return "ENOTDIR";

   318 #endif

   319 #if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))

   320 	case ENOTEMPTY: return "ENOTEMPTY";

   321 #endif

   322 #ifdef ENOTNAM

   323 	case ENOTNAM: return "ENOTNAM";

   324 #endif

   325 #ifdef ENOTSOCK

   326 	case ENOTSOCK: return "ENOTSOCK";

   327 #endif

   328 #ifdef ENOTSUP

   329 	case ENOTSUP: return "ENOTSUP";

   330 #endif

   331 #ifdef ENOTTY

   332 	case ENOTTY: return "ENOTTY";

   333 #endif

   334 #ifdef ENOTUNIQ

   335 	case ENOTUNIQ: return "ENOTUNIQ";

   336 #endif

   337 #ifdef ENXIO

   338 	case ENXIO: return "ENXIO";

   339 #endif

   340 #if defined(EOPNOTSUPP) &&  (!defined(ENOTSUP) || (ENOTSUP != EOPNOTSUPP))

   341 	case EOPNOTSUPP: return "EOPNOTSUPP";

   342 #endif

   343 #if defined(EOVERFLOW) && ( !defined(EFBIG) || (EOVERFLOW != EFBIG) ) && ( !defined(EINVAL) || (EOVERFLOW != EINVAL) )

   344         case EOVERFLOW: return "EOVERFLOW";

   345 #endif

   346 #ifdef EPERM

   347 	case EPERM: return "EPERM";

   348 #endif

   349 #if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))

   350 	case EPFNOSUPPORT: return "EPFNOSUPPORT";

   351 #endif

   352 #ifdef EPIPE

   353 	case EPIPE: return "EPIPE";

   354 #endif

   355 #ifdef EPROCLIM

   356 	case EPROCLIM: return "EPROCLIM";

   357 #endif

   358 #ifdef EPROCUNAVAIL

   359 	case EPROCUNAVAIL: return "EPROCUNAVAIL";

   360 #endif

   361 #ifdef EPROGMISMATCH

   362 	case EPROGMISMATCH: return "EPROGMISMATCH";

   363 #endif

   364 #ifdef EPROGUNAVAIL

   365 	case EPROGUNAVAIL: return "EPROGUNAVAIL";

   366 #endif

   367 #ifdef EPROTO

   368 	case EPROTO: return "EPROTO";

   369 #endif

   370 #ifdef EPROTONOSUPPORT

   371 	case EPROTONOSUPPORT: return "EPROTONOSUPPORT";

   372 #endif

   373 #ifdef EPROTOTYPE

   374 	case EPROTOTYPE: return "EPROTOTYPE";

   375 #endif

   376 #ifdef ERANGE

   377 	case ERANGE: return "ERANGE";

   378 #endif

   379 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))

   380 	case EREFUSED: return "EREFUSED";

   381 #endif

   382 #ifdef EREMCHG

   383 	case EREMCHG: return "EREMCHG";

   384 #endif

   385 #ifdef EREMDEV

   386 	case EREMDEV: return "EREMDEV";

   387 #endif

   388 #ifdef EREMOTE

   389 	case EREMOTE: return "EREMOTE";

   390 #endif

   391 #ifdef EREMOTEIO

   392 	case EREMOTEIO: return "EREMOTEIO";

   393 #endif

   394 #ifdef EREMOTERELEASE

   395 	case EREMOTERELEASE: return "EREMOTERELEASE";

   396 #endif

   397 #ifdef EROFS

   398 	case EROFS: return "EROFS";

   399 #endif

   400 #ifdef ERPCMISMATCH

   401 	case ERPCMISMATCH: return "ERPCMISMATCH";

   402 #endif

   403 #ifdef ERREMOTE

   404 	case ERREMOTE: return "ERREMOTE";

   405 #endif

   406 #ifdef ESHUTDOWN

   407 	case ESHUTDOWN: return "ESHUTDOWN";

   408 #endif

   409 #ifdef ESOCKTNOSUPPORT

   410 	case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";

   411 #endif

   412 #ifdef ESPIPE

   413 	case ESPIPE: return "ESPIPE";

   414 #endif

   415 #ifdef ESRCH

   416 	case ESRCH: return "ESRCH";

   417 #endif

   418 #ifdef ESRMNT

   419 	case ESRMNT: return "ESRMNT";

   420 #endif

   421 #ifdef ESTALE

   422 	case ESTALE: return "ESTALE";

   423 #endif

   424 #ifdef ESUCCESS

   425 	case ESUCCESS: return "ESUCCESS";

   426 #endif

   427 #if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))

   428 	case ETIME: return "ETIME";

   429 #endif

   430 #if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))

   431 	case ETIMEDOUT: return "ETIMEDOUT";

   432 #endif

   433 #ifdef ETOOMANYREFS

   434 	case ETOOMANYREFS: return "ETOOMANYREFS";

   435 #endif

   436 #ifdef ETXTBSY

   437 	case ETXTBSY: return "ETXTBSY";

   438 #endif

   439 #ifdef EUCLEAN

   440 	case EUCLEAN: return "EUCLEAN";

   441 #endif

   442 #ifdef EUNATCH

   443 	case EUNATCH: return "EUNATCH";

   444 #endif

   445 #ifdef EUSERS

   446 	case EUSERS: return "EUSERS";

   447 #endif

   448 #ifdef EVERSION

   449 	case EVERSION: return "EVERSION";

   450 #endif

   451 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))

   452 	case EWOULDBLOCK: return "EWOULDBLOCK";

   453 #endif

   454 #ifdef EXDEV

   455 	case EXDEV: return "EXDEV";

   456 #endif

   457 #ifdef EXFULL

   458 	case EXFULL: return "EXFULL";

   459 #endif

   460     }

   461     return "unknown error";

   462 }

   464 /*

   465  *----------------------------------------------------------------------

   466  *

   467  * Tcl_ErrnoMsg --

   468  *

   469  *	Return a human-readable message corresponding to a given

   470  *	errno value.

   471  *

   472  * Results:

   473  *	The return value is the standard POSIX error message for

   474  *	errno.  This procedure is used instead of strerror because

   475  *	strerror returns slightly different values on different

   476  *	machines (e.g. different capitalizations), which cause

   477  *	problems for things such as regression tests.  This procedure

   478  *	provides messages for most standard errors, then it calls

   479  *	strerror for things it doesn't understand.

   480  *

   481  * Side effects:

   482  *	None.

   483  *

   484  *----------------------------------------------------------------------

   485  */

   487 EXPORT_C CONST char *

   488 Tcl_ErrnoMsg(err)

   489     int err;			/* Error number (such as in errno variable). */

   490 {

   491     switch (err) {

   492 #ifdef E2BIG

   493 	case E2BIG: return "argument list too long";

   494 #endif

   495 #ifdef EACCES

   496 	case EACCES: return "permission denied";

   497 #endif

   498 #ifdef EADDRINUSE

   499 	case EADDRINUSE: return "address already in use";

   500 #endif

   501 #ifdef EADDRNOTAVAIL

   502 	case EADDRNOTAVAIL: return "can't assign requested address";

   503 #endif

   504 #ifdef EADV

   505 	case EADV: return "advertise error";

   506 #endif

   507 #ifdef EAFNOSUPPORT

   508 	case EAFNOSUPPORT: return "address family not supported by protocol family";

   509 #endif

   510 #ifdef EAGAIN

   511 	case EAGAIN: return "resource temporarily unavailable";

   512 #endif

   513 #ifdef EALIGN

   514 	case EALIGN: return "EALIGN";

   515 #endif

   516 #if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))

   517 	case EALREADY: return "operation already in progress";

   518 #endif

   519 #ifdef EBADE

   520 	case EBADE: return "bad exchange descriptor";

   521 #endif

   522 #ifdef EBADF

   523 	case EBADF: return "bad file number";

   524 #endif

   525 #ifdef EBADFD

   526 	case EBADFD: return "file descriptor in bad state";

   527 #endif

   528 #ifdef EBADMSG

   529 	case EBADMSG: return "not a data message";

   530 #endif

   531 #ifdef EBADR

   532 	case EBADR: return "bad request descriptor";

   533 #endif

   534 #ifdef EBADRPC

   535 	case EBADRPC: return "RPC structure is bad";

   536 #endif

   537 #ifdef EBADRQC

   538 	case EBADRQC: return "bad request code";

   539 #endif

   540 #ifdef EBADSLT

   541 	case EBADSLT: return "invalid slot";

   542 #endif

   543 #ifdef EBFONT

   544 	case EBFONT: return "bad font file format";

   545 #endif

   546 #ifdef EBUSY

   547 	case EBUSY: return "file busy";

   548 #endif

   549 #ifdef ECHILD

   550 	case ECHILD: return "no children";

   551 #endif

   552 #ifdef ECHRNG

   553 	case ECHRNG: return "channel number out of range";

   554 #endif

   555 #ifdef ECOMM

   556 	case ECOMM: return "communication error on send";

   557 #endif

   558 #ifdef ECONNABORTED

   559 	case ECONNABORTED: return "software caused connection abort";

   560 #endif

   561 #ifdef ECONNREFUSED

   562 	case ECONNREFUSED: return "connection refused";

   563 #endif

   564 #ifdef ECONNRESET

   565 	case ECONNRESET: return "connection reset by peer";

   566 #endif

   567 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))

   568 	case EDEADLK: return "resource deadlock avoided";

   569 #endif

   570 #if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))

   571 	case EDEADLOCK: return "resource deadlock avoided";

   572 #endif

   573 #ifdef EDESTADDRREQ

   574 	case EDESTADDRREQ: return "destination address required";

   575 #endif

   576 #ifdef EDIRTY

   577 	case EDIRTY: return "mounting a dirty fs w/o force";

   578 #endif

   579 #ifdef EDOM

   580 	case EDOM: return "math argument out of range";

   581 #endif

   582 #ifdef EDOTDOT

   583 	case EDOTDOT: return "cross mount point";

   584 #endif

   585 #ifdef EDQUOT

   586 	case EDQUOT: return "disk quota exceeded";

   587 #endif

   588 #ifdef EDUPPKG

   589 	case EDUPPKG: return "duplicate package name";

   590 #endif

   591 #ifdef EEXIST

   592 	case EEXIST: return "file already exists";

   593 #endif

   594 #ifdef EFAULT

   595 	case EFAULT: return "bad address in system call argument";

   596 #endif

   597 #ifdef EFBIG

   598 	case EFBIG: return "file too large";

   599 #endif

   600 #ifdef EHOSTDOWN

   601 	case EHOSTDOWN: return "host is down";

   602 #endif

   603 #ifdef EHOSTUNREACH

   604 	case EHOSTUNREACH: return "host is unreachable";

   605 #endif

   606 #if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))

   607 	case EIDRM: return "identifier removed";

   608 #endif

   609 #ifdef EINIT

   610 	case EINIT: return "initialization error";

   611 #endif

   612 #ifdef EINPROGRESS

   613 	case EINPROGRESS: return "operation now in progress";

   614 #endif

   615 #ifdef EINTR

   616 	case EINTR: return "interrupted system call";

   617 #endif

   618 #ifdef EINVAL

   619 	case EINVAL: return "invalid argument";

   620 #endif

   621 #ifdef EIO

   622 	case EIO: return "I/O error";

   623 #endif

   624 #ifdef EISCONN

   625 	case EISCONN: return "socket is already connected";

   626 #endif

   627 #ifdef EISDIR

   628 	case EISDIR: return "illegal operation on a directory";

   629 #endif

   630 #ifdef EISNAME

   631 	case EISNAM: return "is a name file";

   632 #endif

   633 #ifdef ELBIN

   634 	case ELBIN: return "ELBIN";

   635 #endif

   636 #ifdef EL2HLT

   637 	case EL2HLT: return "level 2 halted";

   638 #endif

   639 #ifdef EL2NSYNC

   640 	case EL2NSYNC: return "level 2 not synchronized";

   641 #endif

   642 #ifdef EL3HLT

   643 	case EL3HLT: return "level 3 halted";

   644 #endif

   645 #ifdef EL3RST

   646 	case EL3RST: return "level 3 reset";

   647 #endif

   648 #ifdef ELIBACC

   649 	case ELIBACC: return "can not access a needed shared library";

   650 #endif

   651 #ifdef ELIBBAD

   652 	case ELIBBAD: return "accessing a corrupted shared library";

   653 #endif

   654 #ifdef ELIBEXEC

   655 	case ELIBEXEC: return "can not exec a shared library directly";

   656 #endif

   657 #ifdef ELIBMAX

   658 	case ELIBMAX: return

   659 		"attempting to link in more shared libraries than system limit";

   660 #endif

   661 #ifdef ELIBSCN

   662 	case ELIBSCN: return ".lib section in a.out corrupted";

   663 #endif

   664 #ifdef ELNRNG

   665 	case ELNRNG: return "link number out of range";

   666 #endif

   667 #if defined(ELOOP) && (!defined(ENOENT) || (ELOOP != ENOENT))

   668 	case ELOOP: return "too many levels of symbolic links";

   669 #endif

   670 #ifdef EMFILE

   671 	case EMFILE: return "too many open files";

   672 #endif

   673 #ifdef EMLINK

   674 	case EMLINK: return "too many links";

   675 #endif

   676 #ifdef EMSGSIZE

   677 	case EMSGSIZE: return "message too long";

   678 #endif

   679 #ifdef EMULTIHOP

   680 	case EMULTIHOP: return "multihop attempted";

   681 #endif

   682 #ifdef ENAMETOOLONG

   683 	case ENAMETOOLONG: return "file name too long";

   684 #endif

   685 #ifdef ENAVAIL

   686 	case ENAVAIL: return "not available";

   687 #endif

   688 #ifdef ENET

   689 	case ENET: return "ENET";

   690 #endif

   691 #ifdef ENETDOWN

   692 	case ENETDOWN: return "network is down";

   693 #endif

   694 #ifdef ENETRESET

   695 	case ENETRESET: return "network dropped connection on reset";

   696 #endif

   697 #ifdef ENETUNREACH

   698 	case ENETUNREACH: return "network is unreachable";

   699 #endif

   700 #ifdef ENFILE

   701 	case ENFILE: return "file table overflow";

   702 #endif

   703 #ifdef ENOANO

   704 	case ENOANO: return "anode table overflow";

   705 #endif

   706 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))

   707 	case ENOBUFS: return "no buffer space available";

   708 #endif

   709 #ifdef ENOCSI

   710 	case ENOCSI: return "no CSI structure available";

   711 #endif

   712 #if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))

   713 	case ENODATA: return "no data available";

   714 #endif

   715 #ifdef ENODEV

   716 	case ENODEV: return "no such device";

   717 #endif

   718 #ifdef ENOENT

   719 	case ENOENT: return "no such file or directory";

   720 #endif

   721 #ifdef ENOEXEC

   722 	case ENOEXEC: return "exec format error";

   723 #endif

   724 #ifdef ENOLCK

   725 	case ENOLCK: return "no locks available";

   726 #endif

   727 #ifdef ENOLINK

   728 	case ENOLINK: return "link has be severed";

   729 #endif

   730 #ifdef ENOMEM

   731 	case ENOMEM: return "not enough memory";

   732 #endif

   733 #ifdef ENOMSG

   734 	case ENOMSG: return "no message of desired type";

   735 #endif

   736 #ifdef ENONET

   737 	case ENONET: return "machine is not on the network";

   738 #endif

   739 #ifdef ENOPKG

   740 	case ENOPKG: return "package not installed";

   741 #endif

   742 #ifdef ENOPROTOOPT

   743 	case ENOPROTOOPT: return "bad protocol option";

   744 #endif

   745 #ifdef ENOSPC

   746 	case ENOSPC: return "no space left on device";

   747 #endif

   748 #if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))

   749 	case ENOSR: return "out of stream resources";

   750 #endif

   751 #if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))

   752 	case ENOSTR: return "not a stream device";

   753 #endif

   754 #ifdef ENOSYM

   755 	case ENOSYM: return "unresolved symbol name";

   756 #endif

   757 #ifdef ENOSYS

   758 	case ENOSYS: return "function not implemented";

   759 #endif

   760 #ifdef ENOTBLK

   761 	case ENOTBLK: return "block device required";

   762 #endif

   763 #ifdef ENOTCONN

   764 	case ENOTCONN: return "socket is not connected";

   765 #endif

   766 #ifdef ENOTDIR

   767 	case ENOTDIR: return "not a directory";

   768 #endif

   769 #if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))

   770 	case ENOTEMPTY: return "directory not empty";

   771 #endif

   772 #ifdef ENOTNAM

   773 	case ENOTNAM: return "not a name file";

   774 #endif

   775 #ifdef ENOTSOCK

   776 	case ENOTSOCK: return "socket operation on non-socket";

   777 #endif

   778 #ifdef ENOTSUP

   779 	case ENOTSUP: return "operation not supported";

   780 #endif

   781 #ifdef ENOTTY

   782 	case ENOTTY: return "inappropriate device for ioctl";

   783 #endif

   784 #ifdef ENOTUNIQ

   785 	case ENOTUNIQ: return "name not unique on network";

   786 #endif

   787 #ifdef ENXIO

   788 	case ENXIO: return "no such device or address";

   789 #endif

   790 #if defined(EOPNOTSUPP) &&  (!defined(ENOTSUP) || (ENOTSUP != EOPNOTSUPP))

   791 	case EOPNOTSUPP: return "operation not supported on socket";

   792 #endif

   793 #if defined(EOVERFLOW) && ( !defined(EFBIG) || (EOVERFLOW != EFBIG) ) && ( !defined(EINVAL) || (EOVERFLOW != EINVAL) )

   794         case EOVERFLOW: return "file too big";

   795 #endif

   796 #ifdef EPERM

   797 	case EPERM: return "not owner";

   798 #endif

   799 #if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))

   800 	case EPFNOSUPPORT: return "protocol family not supported";

   801 #endif

   802 #ifdef EPIPE

   803 	case EPIPE: return "broken pipe";

   804 #endif

   805 #ifdef EPROCLIM

   806 	case EPROCLIM: return "too many processes";

   807 #endif

   808 #ifdef EPROCUNAVAIL

   809 	case EPROCUNAVAIL: return "bad procedure for program";

   810 #endif

   811 #ifdef EPROGMISMATCH

   812 	case EPROGMISMATCH: return "program version wrong";

   813 #endif

   814 #ifdef EPROGUNAVAIL

   815 	case EPROGUNAVAIL: return "RPC program not available";

   816 #endif

   817 #ifdef EPROTO

   818 	case EPROTO: return "protocol error";

   819 #endif

   820 #ifdef EPROTONOSUPPORT

   821 	case EPROTONOSUPPORT: return "protocol not suppored";

   822 #endif

   823 #ifdef EPROTOTYPE

   824 	case EPROTOTYPE: return "protocol wrong type for socket";

   825 #endif

   826 #ifdef ERANGE

   827 	case ERANGE: return "math result unrepresentable";

   828 #endif

   829 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))

   830 	case EREFUSED: return "EREFUSED";

   831 #endif

   832 #ifdef EREMCHG

   833 	case EREMCHG: return "remote address changed";

   834 #endif

   835 #ifdef EREMDEV

   836 	case EREMDEV: return "remote device";

   837 #endif

   838 #ifdef EREMOTE

   839 	case EREMOTE: return "pathname hit remote file system";

   840 #endif

   841 #ifdef EREMOTEIO

   842 	case EREMOTEIO: return "remote i/o error";

   843 #endif

   844 #ifdef EREMOTERELEASE

   845 	case EREMOTERELEASE: return "EREMOTERELEASE";

   846 #endif

   847 #ifdef EROFS

   848 	case EROFS: return "read-only file system";

   849 #endif

   850 #ifdef ERPCMISMATCH

   851 	case ERPCMISMATCH: return "RPC version is wrong";

   852 #endif

   853 #ifdef ERREMOTE

   854 	case ERREMOTE: return "object is remote";

   855 #endif

   856 #ifdef ESHUTDOWN

   857 	case ESHUTDOWN: return "can't send afer socket shutdown";

   858 #endif

   859 #ifdef ESOCKTNOSUPPORT

   860 	case ESOCKTNOSUPPORT: return "socket type not supported";

   861 #endif

   862 #ifdef ESPIPE

   863 	case ESPIPE: return "invalid seek";

   864 #endif

   865 #ifdef ESRCH

   866 	case ESRCH: return "no such process";

   867 #endif

   868 #ifdef ESRMNT

   869 	case ESRMNT: return "srmount error";

   870 #endif

   871 #ifdef ESTALE

   872 	case ESTALE: return "stale remote file handle";

   873 #endif

   874 #ifdef ESUCCESS

   875 	case ESUCCESS: return "Error 0";

   876 #endif

   877 #if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))

   878 	case ETIME: return "timer expired";

   879 #endif

   880 #if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))

   881 	case ETIMEDOUT: return "connection timed out";

   882 #endif

   883 #ifdef ETOOMANYREFS

   884 	case ETOOMANYREFS: return "too many references: can't splice";

   885 #endif

   886 #ifdef ETXTBSY

   887 	case ETXTBSY: return "text file or pseudo-device busy";

   888 #endif

   889 #ifdef EUCLEAN

   890 	case EUCLEAN: return "structure needs cleaning";

   891 #endif

   892 #ifdef EUNATCH

   893 	case EUNATCH: return "protocol driver not attached";

   894 #endif

   895 #ifdef EUSERS

   896 	case EUSERS: return "too many users";

   897 #endif

   898 #ifdef EVERSION

   899 	case EVERSION: return "version mismatch";

   900 #endif

   901 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))

   902 	case EWOULDBLOCK: return "operation would block";

   903 #endif

   904 #ifdef EXDEV

   905 	case EXDEV: return "cross-domain link";

   906 #endif

   907 #ifdef EXFULL

   908 	case EXFULL: return "message tables full";

   909 #endif

   910 	default:

   911 #ifdef NO_STRERROR

   912 	    return "unknown POSIX error";

   913 #else

   914 	    return strerror(errno);

   915 #endif

   916     }

   917 }

   919 /*

   920  *----------------------------------------------------------------------

   921  *

   922  * Tcl_SignalId --

   923  *

   924  *	Return a textual identifier for a signal number.

   925  *

   926  * Results:

   927  *	This procedure returns a machine-readable textual identifier

   928  *	that corresponds to sig.  The identifier is the same as the

   929  *	#define name in signal.h.

   930  *

   931  * Side effects:

   932  *	None.

   933  *

   934  *----------------------------------------------------------------------

   935  */

   937 EXPORT_C CONST char *

   938 Tcl_SignalId(sig)

   939     int sig;			/* Number of signal. */

   940 {

   941     switch (sig) {

   942 #ifdef SIGABRT

   943 	case SIGABRT: return "SIGABRT";

   944 #endif

   945 #ifdef SIGALRM

   946 	case SIGALRM: return "SIGALRM";

   947 #endif

   948 #ifdef SIGBUS

   949 	case SIGBUS: return "SIGBUS";

   950 #endif

   951 #ifdef SIGCHLD

   952 	case SIGCHLD: return "SIGCHLD";

   953 #endif

   954 #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))

   955 	case SIGCLD: return "SIGCLD";

   956 #endif

   957 #ifdef SIGCONT

   958 	case SIGCONT: return "SIGCONT";

   959 #endif

   960 #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))

   961 	case SIGEMT: return "SIGEMT";

   962 #endif

   963 #ifdef SIGFPE

   964 	case SIGFPE: return "SIGFPE";

   965 #endif

   966 #ifdef SIGHUP

   967 	case SIGHUP: return "SIGHUP";

   968 #endif

   969 #ifdef SIGILL

   970 	case SIGILL: return "SIGILL";

   971 #endif

   972 #ifdef SIGINT

   973 	case SIGINT: return "SIGINT";

   974 #endif

   975 #ifdef SIGIO

   976 	case SIGIO: return "SIGIO";

   977 #endif

   978 #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGIOT != SIGABRT))

   979 	case SIGIOT: return "SIGIOT";

   980 #endif

   981 #ifdef SIGKILL

   982 	case SIGKILL: return "SIGKILL";

   983 #endif

   984 #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG)) && (!defined(SIGPROF) || (SIGLOST != SIGPROF)) && (!defined(SIGIO) || (SIGLOST != SIGIO))

   985 	case SIGLOST: return "SIGLOST";

   986 #endif

   987 #ifdef SIGPIPE

   988 	case SIGPIPE: return "SIGPIPE";

   989 #endif

   990 #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))

   991 	case SIGPOLL: return "SIGPOLL";

   992 #endif

   993 #ifdef SIGPROF

   994 	case SIGPROF: return "SIGPROF";

   995 #endif

   996 #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ)) && (!defined(SIGLOST) || (SIGPWR != SIGLOST))

   997 	case SIGPWR: return "SIGPWR";

   998 #endif

   999 #ifdef SIGQUIT

  1000 	case SIGQUIT: return "SIGQUIT";

  1001 #endif

  1002 #ifdef SIGSEGV

  1003 	case SIGSEGV: return "SIGSEGV";

  1004 #endif

  1005 #ifdef SIGSTOP

  1006 	case SIGSTOP: return "SIGSTOP";

  1007 #endif

  1008 #ifdef SIGSYS

  1009 	case SIGSYS: return "SIGSYS";

  1010 #endif

  1011 #ifdef SIGTERM

  1012 	case SIGTERM: return "SIGTERM";

  1013 #endif

  1014 #ifdef SIGTRAP

  1015 	case SIGTRAP: return "SIGTRAP";

  1016 #endif

  1017 #ifdef SIGTSTP

  1018 	case SIGTSTP: return "SIGTSTP";

  1019 #endif

  1020 #ifdef SIGTTIN

  1021 	case SIGTTIN: return "SIGTTIN";

  1022 #endif

  1023 #ifdef SIGTTOU

  1024 	case SIGTTOU: return "SIGTTOU";

  1025 #endif

  1026 #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))

  1027 	case SIGURG: return "SIGURG";

  1028 #endif

  1029 #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))

  1030 	case SIGUSR1: return "SIGUSR1";

  1031 #endif

  1032 #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))

  1033 	case SIGUSR2: return "SIGUSR2";

  1034 #endif

  1035 #ifdef SIGVTALRM

  1036 	case SIGVTALRM: return "SIGVTALRM";

  1037 #endif

  1038 #ifdef SIGWINCH

  1039 	case SIGWINCH: return "SIGWINCH";

  1040 #endif

  1041 #ifdef SIGXCPU

  1042 	case SIGXCPU: return "SIGXCPU";

  1043 #endif

  1044 #ifdef SIGXFSZ

  1045 	case SIGXFSZ: return "SIGXFSZ";

  1046 #endif

  1047     }

  1048     return "unknown signal";

  1049 }

  1051 /*

  1052  *----------------------------------------------------------------------

  1053  *

  1054  * Tcl_SignalMsg --

  1055  *

  1056  *	Return a human-readable message describing a signal.

  1057  *

  1058  * Results:

  1059  *	This procedure returns a string describing sig that should

  1060  *	make sense to a human.  It may not be easy for a machine

  1061  *	to parse.

  1062  *

  1063  * Side effects:

  1064  *	None.

  1065  *

  1066  *----------------------------------------------------------------------

  1067  */

  1069 EXPORT_C CONST char *

  1070 Tcl_SignalMsg(sig)

  1071     int sig;			/* Number of signal. */

  1072 {

  1073     switch (sig) {

  1074 #ifdef SIGABRT

  1075 	case SIGABRT: return "SIGABRT";

  1076 #endif

  1077 #ifdef SIGALRM

  1078 	case SIGALRM: return "alarm clock";

  1079 #endif

  1080 #ifdef SIGBUS

  1081 	case SIGBUS: return "bus error";

  1082 #endif

  1083 #ifdef SIGCHLD

  1084 	case SIGCHLD: return "child status changed";

  1085 #endif

  1086 #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))

  1087 	case SIGCLD: return "child status changed";

  1088 #endif

  1089 #ifdef SIGCONT

  1090 	case SIGCONT: return "continue after stop";

  1091 #endif

  1092 #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))

  1093 	case SIGEMT: return "EMT instruction";

  1094 #endif

  1095 #ifdef SIGFPE

  1096 	case SIGFPE: return "floating-point exception";

  1097 #endif

  1098 #ifdef SIGHUP

  1099 	case SIGHUP: return "hangup";

  1100 #endif

  1101 #ifdef SIGILL

  1102 	case SIGILL: return "illegal instruction";

  1103 #endif

  1104 #ifdef SIGINT

  1105 	case SIGINT: return "interrupt";

  1106 #endif

  1107 #ifdef SIGIO

  1108 	case SIGIO: return "input/output possible on file";

  1109 #endif

  1110 #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGABRT != SIGIOT))

  1111 	case SIGIOT: return "IOT instruction";

  1112 #endif

  1113 #ifdef SIGKILL

  1114 	case SIGKILL: return "kill signal";

  1115 #endif

  1116 #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG)) && (!defined(SIGPROF) || (SIGLOST != SIGPROF)) && (!defined(SIGIO) || (SIGLOST != SIGIO))

  1117 	case SIGLOST: return "resource lost";

  1118 #endif

  1119 #ifdef SIGPIPE

  1120 	case SIGPIPE: return "write on pipe with no readers";

  1121 #endif

  1122 #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))

  1123 	case SIGPOLL: return "input/output possible on file";

  1124 #endif

  1125 #ifdef SIGPROF

  1126 	case SIGPROF: return "profiling alarm";

  1127 #endif

  1128 #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ)) && (!defined(SIGLOST) || (SIGPWR != SIGLOST))

  1129 	case SIGPWR: return "power-fail restart";

  1130 #endif

  1131 #ifdef SIGQUIT

  1132 	case SIGQUIT: return "quit signal";

  1133 #endif

  1134 #ifdef SIGSEGV

  1135 	case SIGSEGV: return "segmentation violation";

  1136 #endif

  1137 #ifdef SIGSTOP

  1138 	case SIGSTOP: return "stop";

  1139 #endif

  1140 #ifdef SIGSYS

  1141 	case SIGSYS: return "bad argument to system call";

  1142 #endif

  1143 #ifdef SIGTERM

  1144 	case SIGTERM: return "software termination signal";

  1145 #endif

  1146 #ifdef SIGTRAP

  1147 	case SIGTRAP: return "trace trap";

  1148 #endif

  1149 #ifdef SIGTSTP

  1150 	case SIGTSTP: return "stop signal from tty";

  1151 #endif

  1152 #ifdef SIGTTIN

  1153 	case SIGTTIN: return "background tty read";

  1154 #endif

  1155 #ifdef SIGTTOU

  1156 	case SIGTTOU: return "background tty write";

  1157 #endif

  1158 #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))

  1159 	case SIGURG: return "urgent I/O condition";

  1160 #endif

  1161 #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))

  1162 	case SIGUSR1: return "user-defined signal 1";

  1163 #endif

  1164 #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))

  1165 	case SIGUSR2: return "user-defined signal 2";

  1166 #endif

  1167 #ifdef SIGVTALRM

  1168 	case SIGVTALRM: return "virtual time alarm";

  1169 #endif

  1170 #ifdef SIGWINCH

  1171 	case SIGWINCH: return "window changed";

  1172 #endif

  1173 #ifdef SIGXCPU

  1174 	case SIGXCPU: return "exceeded CPU time limit";

  1175 #endif

  1176 #ifdef SIGXFSZ

  1177 	case SIGXFSZ: return "exceeded file size limit";

  1178 #endif

  1179     }

  1180     return "unknown signal";

  1181 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--