From 9bab7d304e9d976439384a38480f8c04eceef2dc Mon Sep 17 00:00:00 2001 From: Ingo Albrecht Date: Mon, 19 Jul 2010 02:51:00 +0200 Subject: dietlibc: some more support code (enough to build and link lua) --- src/target/firmware/lib/Makefile | 2 +- src/target/firmware/lib/errlist.c | 1466 +++++++++++++++++++++++++++++++++++++ src/target/firmware/lib/system.c | 37 + 3 files changed, 1504 insertions(+), 1 deletion(-) create mode 100644 src/target/firmware/lib/errlist.c diff --git a/src/target/firmware/lib/Makefile b/src/target/firmware/lib/Makefile index b7cb061e..5eaa37a4 100644 --- a/src/target/firmware/lib/Makefile +++ b/src/target/firmware/lib/Makefile @@ -1,7 +1,7 @@ LIBRARIES+=mini mini_DIR=lib -mini_SRCS=system.c console.c ctors.c \ +mini_SRCS=system.c console.c ctors.c errlist.c \ changebit.S clearbit.S setbit.S testchangebit.S testclearbit.S testsetbit.S diff --git a/src/target/firmware/lib/errlist.c b/src/target/firmware/lib/errlist.c new file mode 100644 index 00000000..519a7502 --- /dev/null +++ b/src/target/firmware/lib/errlist.c @@ -0,0 +1,1466 @@ +/* This file is generated from errno.texi by errlist.awk. */ + +#include +#include + +#ifndef ERR_REMAP +# define ERR_REMAP(n) n +#endif + +#if 0 +#if !defined EMIT_ERR_MAX && !defined ERRLIST_NO_COMPAT +# include +#endif +#ifdef ERR_MAX +# define ERRLIST_SIZE ERR_MAX + 1 +#else +# define ERRLIST_SIZE +#endif +#endif + +#define ERRLIST_SIZE __SYS_NERR + +#define N_(s) s + +const char *const sys_errlist[ERRLIST_SIZE] = + { + [0] = N_("Success"), +#ifdef EPERM +/* +TRANS Operation not permitted; only the owner of the file (or other resource) +TRANS or processes with special privileges can perform the operation. */ + [ERR_REMAP (EPERM)] = N_("Operation not permitted"), +# if EPERM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPERM +# endif +#endif +#ifdef ENOENT +/* +TRANS No such file or directory. This is a ``file doesn't exist'' error +TRANS for ordinary files that are referenced in contexts where they are +TRANS expected to already exist. */ + [ERR_REMAP (ENOENT)] = N_("No such file or directory"), +# if ENOENT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOENT +# endif +#endif +#ifdef ESRCH +/* +TRANS No process matches the specified process ID. */ + [ERR_REMAP (ESRCH)] = N_("No such process"), +# if ESRCH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESRCH +# endif +#endif +#ifdef EINTR +/* +TRANS Interrupted function call; an asynchronous signal occurred and prevented +TRANS completion of the call. When this happens, you should try the call +TRANS again. +TRANS +TRANS You can choose to have functions resume after a signal that is handled, +TRANS rather than failing with @code{EINTR}; see @ref{Interrupted +TRANS Primitives}. */ + [ERR_REMAP (EINTR)] = N_("Interrupted system call"), +# if EINTR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EINTR +# endif +#endif +#ifdef EIO +/* +TRANS Input/output error; usually used for physical read or write errors. */ + [ERR_REMAP (EIO)] = N_("Input/output error"), +# if EIO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EIO +# endif +#endif +#ifdef ENXIO +/* +TRANS No such device or address. The system tried to use the device +TRANS represented by a file you specified, and it couldn't find the device. +TRANS This can mean that the device file was installed incorrectly, or that +TRANS the physical device is missing or not correctly attached to the +TRANS computer. */ + [ERR_REMAP (ENXIO)] = N_("No such device or address"), +# if ENXIO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENXIO +# endif +#endif +#ifdef E2BIG +/* +TRANS Argument list too long; used when the arguments passed to a new program +TRANS being executed with one of the @code{exec} functions (@pxref{Executing a +TRANS File}) occupy too much memory space. This condition never arises in the +TRANS GNU system. */ + [ERR_REMAP (E2BIG)] = N_("Argument list too long"), +# if E2BIG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX E2BIG +# endif +#endif +#ifdef ENOEXEC +/* +TRANS Invalid executable file format. This condition is detected by the +TRANS @code{exec} functions; see @ref{Executing a File}. */ + [ERR_REMAP (ENOEXEC)] = N_("Exec format error"), +# if ENOEXEC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOEXEC +# endif +#endif +#ifdef EBADF +/* +TRANS Bad file descriptor; for example, I/O on a descriptor that has been +TRANS closed or reading from a descriptor open only for writing (or vice +TRANS versa). */ + [ERR_REMAP (EBADF)] = N_("Bad file descriptor"), +# if EBADF > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADF +# endif +#endif +#ifdef ECHILD +/* +TRANS There are no child processes. This error happens on operations that are +TRANS supposed to manipulate child processes, when there aren't any processes +TRANS to manipulate. */ + [ERR_REMAP (ECHILD)] = N_("No child processes"), +# if ECHILD > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECHILD +# endif +#endif +#ifdef EDEADLK +/* +TRANS Deadlock avoided; allocating a system resource would have resulted in a +TRANS deadlock situation. The system does not guarantee that it will notice +TRANS all such situations. This error means you got lucky and the system +TRANS noticed; it might just hang. @xref{File Locks}, for an example. */ + [ERR_REMAP (EDEADLK)] = N_("Resource deadlock avoided"), +# if EDEADLK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDEADLK +# endif +#endif +#ifdef ENOMEM +/* +TRANS No memory available. The system cannot allocate more virtual memory +TRANS because its capacity is full. */ + [ERR_REMAP (ENOMEM)] = N_("Cannot allocate memory"), +# if ENOMEM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOMEM +# endif +#endif +#ifdef EACCES +/* +TRANS Permission denied; the file permissions do not allow the attempted operation. */ + [ERR_REMAP (EACCES)] = N_("Permission denied"), +# if EACCES > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EACCES +# endif +#endif +#ifdef EFAULT +/* +TRANS Bad address; an invalid pointer was detected. +TRANS In the GNU system, this error never happens; you get a signal instead. */ + [ERR_REMAP (EFAULT)] = N_("Bad address"), +# if EFAULT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EFAULT +# endif +#endif +#ifdef ENOTBLK +/* +TRANS A file that isn't a block special file was given in a situation that +TRANS requires one. For example, trying to mount an ordinary file as a file +TRANS system in Unix gives this error. */ + [ERR_REMAP (ENOTBLK)] = N_("Block device required"), +# if ENOTBLK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTBLK +# endif +#endif +#ifdef EBUSY +/* +TRANS Resource busy; a system resource that can't be shared is already in use. +TRANS For example, if you try to delete a file that is the root of a currently +TRANS mounted filesystem, you get this error. */ + [ERR_REMAP (EBUSY)] = N_("Device or resource busy"), +# if EBUSY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBUSY +# endif +#endif +#ifdef EEXIST +/* +TRANS File exists; an existing file was specified in a context where it only +TRANS makes sense to specify a new file. */ + [ERR_REMAP (EEXIST)] = N_("File exists"), +# if EEXIST > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EEXIST +# endif +#endif +#ifdef EXDEV +/* +TRANS An attempt to make an improper link across file systems was detected. +TRANS This happens not only when you use @code{link} (@pxref{Hard Links}) but +TRANS also when you rename a file with @code{rename} (@pxref{Renaming Files}). */ + [ERR_REMAP (EXDEV)] = N_("Invalid cross-device link"), +# if EXDEV > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EXDEV +# endif +#endif +#ifdef ENODEV +/* +TRANS The wrong type of device was given to a function that expects a +TRANS particular sort of device. */ + [ERR_REMAP (ENODEV)] = N_("No such device"), +# if ENODEV > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENODEV +# endif +#endif +#ifdef ENOTDIR +/* +TRANS A file that isn't a directory was specified when a directory is required. */ + [ERR_REMAP (ENOTDIR)] = N_("Not a directory"), +# if ENOTDIR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTDIR +# endif +#endif +#ifdef EISDIR +/* +TRANS File is a directory; you cannot open a directory for writing, +TRANS or create or remove hard links to it. */ + [ERR_REMAP (EISDIR)] = N_("Is a directory"), +# if EISDIR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EISDIR +# endif +#endif +#ifdef EINVAL +/* +TRANS Invalid argument. This is used to indicate various kinds of problems +TRANS with passing the wrong argument to a library function. */ + [ERR_REMAP (EINVAL)] = N_("Invalid argument"), +# if EINVAL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EINVAL +# endif +#endif +#ifdef EMFILE +/* +TRANS The current process has too many files open and can't open any more. +TRANS Duplicate descriptors do count toward this limit. +TRANS +TRANS In BSD and GNU, the number of open files is controlled by a resource +TRANS limit that can usually be increased. If you get this error, you might +TRANS want to increase the @code{RLIMIT_NOFILE} limit or make it unlimited; +TRANS @pxref{Limits on Resources}. */ + [ERR_REMAP (EMFILE)] = N_("Too many open files"), +# if EMFILE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EMFILE +# endif +#endif +#ifdef ENFILE +/* +TRANS There are too many distinct file openings in the entire system. Note +TRANS that any number of linked channels count as just one file opening; see +TRANS @ref{Linked Channels}. This error never occurs in the GNU system. */ + [ERR_REMAP (ENFILE)] = N_("Too many open files in system"), +# if ENFILE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENFILE +# endif +#endif +#ifdef ENOTTY +/* +TRANS Inappropriate I/O control operation, such as trying to set terminal +TRANS modes on an ordinary file. */ + [ERR_REMAP (ENOTTY)] = N_("Inappropriate ioctl for device"), +# if ENOTTY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTTY +# endif +#endif +#ifdef ETXTBSY +/* +TRANS An attempt to execute a file that is currently open for writing, or +TRANS write to a file that is currently being executed. Often using a +TRANS debugger to run a program is considered having it open for writing and +TRANS will cause this error. (The name stands for ``text file busy''.) This +TRANS is not an error in the GNU system; the text is copied as necessary. */ + [ERR_REMAP (ETXTBSY)] = N_("Text file busy"), +# if ETXTBSY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ETXTBSY +# endif +#endif +#ifdef EFBIG +/* +TRANS File too big; the size of a file would be larger than allowed by the system. */ + [ERR_REMAP (EFBIG)] = N_("File too large"), +# if EFBIG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EFBIG +# endif +#endif +#ifdef ENOSPC +/* +TRANS No space left on device; write operation on a file failed because the +TRANS disk is full. */ + [ERR_REMAP (ENOSPC)] = N_("No space left on device"), +# if ENOSPC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOSPC +# endif +#endif +#ifdef ESPIPE +/* +TRANS Invalid seek operation (such as on a pipe). */ + [ERR_REMAP (ESPIPE)] = N_("Illegal seek"), +# if ESPIPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESPIPE +# endif +#endif +#ifdef EROFS +/* +TRANS An attempt was made to modify something on a read-only file system. */ + [ERR_REMAP (EROFS)] = N_("Read-only file system"), +# if EROFS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EROFS +# endif +#endif +#ifdef EMLINK +/* +TRANS Too many links; the link count of a single file would become too large. +TRANS @code{rename} can cause this error if the file being renamed already has +TRANS as many links as it can take (@pxref{Renaming Files}). */ + [ERR_REMAP (EMLINK)] = N_("Too many links"), +# if EMLINK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EMLINK +# endif +#endif +#ifdef EPIPE +/* +TRANS Broken pipe; there is no process reading from the other end of a pipe. +TRANS Every library function that returns this error code also generates a +TRANS @code{SIGPIPE} signal; this signal terminates the program if not handled +TRANS or blocked. Thus, your program will never actually see @code{EPIPE} +TRANS unless it has handled or blocked @code{SIGPIPE}. */ + [ERR_REMAP (EPIPE)] = N_("Broken pipe"), +# if EPIPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPIPE +# endif +#endif +#ifdef EDOM +/* +TRANS Domain error; used by mathematical functions when an argument value does +TRANS not fall into the domain over which the function is defined. */ + [ERR_REMAP (EDOM)] = N_("Numerical argument out of domain"), +# if EDOM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDOM +# endif +#endif +#ifdef ERANGE +/* +TRANS Range error; used by mathematical functions when the result value is +TRANS not representable because of overflow or underflow. */ + [ERR_REMAP (ERANGE)] = N_("Numerical result out of range"), +# if ERANGE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ERANGE +# endif +#endif +#ifdef EAGAIN +/* +TRANS Resource temporarily unavailable; the call might work if you try again +TRANS later. The macro @code{EWOULDBLOCK} is another name for @code{EAGAIN}; +TRANS they are always the same in the GNU C library. +TRANS +TRANS This error can happen in a few different situations: +TRANS +TRANS @itemize @bullet +TRANS @item +TRANS An operation that would block was attempted on an object that has +TRANS non-blocking mode selected. Trying the same operation again will block +TRANS until some external condition makes it possible to read, write, or +TRANS connect (whatever the operation). You can use @code{select} to find out +TRANS when the operation will be possible; @pxref{Waiting for I/O}. +TRANS +TRANS @strong{Portability Note:} In many older Unix systems, this condition +TRANS was indicated by @code{EWOULDBLOCK}, which was a distinct error code +TRANS different from @code{EAGAIN}. To make your program portable, you should +TRANS check for both codes and treat them the same. +TRANS +TRANS @item +TRANS A temporary resource shortage made an operation impossible. @code{fork} +TRANS can return this error. It indicates that the shortage is expected to +TRANS pass, so your program can try the call again later and it may succeed. +TRANS It is probably a good idea to delay for a few seconds before trying it +TRANS again, to allow time for other processes to release scarce resources. +TRANS Such shortages are usually fairly serious and affect the whole system, +TRANS so usually an interactive program should report the error to the user +TRANS and return to its command loop. +TRANS @end itemize */ + [ERR_REMAP (EAGAIN)] = N_("Resource temporarily unavailable"), +# if EAGAIN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EAGAIN +# endif +#endif +#if defined (EWOULDBLOCK) && EWOULDBLOCK != EAGAIN +/* +TRANS In the GNU C library, this is another name for @code{EAGAIN} (above). +TRANS The values are always the same, on every operating system. +TRANS +TRANS C libraries in many older Unix systems have @code{EWOULDBLOCK} as a +TRANS separate error code. */ + [ERR_REMAP (EWOULDBLOCK)] = N_("Operation would block"), +# if EWOULDBLOCK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EWOULDBLOCK +# endif +#endif +#ifdef EINPROGRESS +/* +TRANS An operation that cannot complete immediately was initiated on an object +TRANS that has non-blocking mode selected. Some functions that must always +TRANS block (such as @code{connect}; @pxref{Connecting}) never return +TRANS @code{EAGAIN}. Instead, they return @code{EINPROGRESS} to indicate that +TRANS the operation has begun and will take some time. Attempts to manipulate +TRANS the object before the call completes return @code{EALREADY}. You can +TRANS use the @code{select} function to find out when the pending operation +TRANS has completed; @pxref{Waiting for I/O}. */ + [ERR_REMAP (EINPROGRESS)] = N_("Operation now in progress"), +# if EINPROGRESS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EINPROGRESS +# endif +#endif +#ifdef EALREADY +/* +TRANS An operation is already in progress on an object that has non-blocking +TRANS mode selected. */ + [ERR_REMAP (EALREADY)] = N_("Operation already in progress"), +# if EALREADY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EALREADY +# endif +#endif +#ifdef ENOTSOCK +/* +TRANS A file that isn't a socket was specified when a socket is required. */ + [ERR_REMAP (ENOTSOCK)] = N_("Socket operation on non-socket"), +# if ENOTSOCK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTSOCK +# endif +#endif +#ifdef EMSGSIZE +/* +TRANS The size of a message sent on a socket was larger than the supported +TRANS maximum size. */ + [ERR_REMAP (EMSGSIZE)] = N_("Message too long"), +# if EMSGSIZE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EMSGSIZE +# endif +#endif +#ifdef EPROTOTYPE +/* +TRANS The socket type does not support the requested communications protocol. */ + [ERR_REMAP (EPROTOTYPE)] = N_("Protocol wrong type for socket"), +# if EPROTOTYPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROTOTYPE +# endif +#endif +#ifdef ENOPROTOOPT +/* +TRANS You specified a socket option that doesn't make sense for the +TRANS particular protocol being used by the socket. @xref{Socket Options}. */ + [ERR_REMAP (ENOPROTOOPT)] = N_("Protocol not available"), +# if ENOPROTOOPT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOPROTOOPT +# endif +#endif +#ifdef EPROTONOSUPPORT +/* +TRANS The socket domain does not support the requested communications protocol +TRANS (perhaps because the requested protocol is completely invalid). +TRANS @xref{Creating a Socket}. */ + [ERR_REMAP (EPROTONOSUPPORT)] = N_("Protocol not supported"), +# if EPROTONOSUPPORT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROTONOSUPPORT +# endif +#endif +#ifdef ESOCKTNOSUPPORT +/* +TRANS The socket type is not supported. */ + [ERR_REMAP (ESOCKTNOSUPPORT)] = N_("Socket type not supported"), +# if ESOCKTNOSUPPORT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESOCKTNOSUPPORT +# endif +#endif +#ifdef EOPNOTSUPP +/* +TRANS The operation you requested is not supported. Some socket functions +TRANS don't make sense for all types of sockets, and others may not be +TRANS implemented for all communications protocols. In the GNU system, this +TRANS error can happen for many calls when the object does not support the +TRANS particular operation; it is a generic indication that the server knows +TRANS nothing to do for that call. */ + [ERR_REMAP (EOPNOTSUPP)] = N_("Operation not supported"), +# if EOPNOTSUPP > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EOPNOTSUPP +# endif +#endif +#ifdef EPFNOSUPPORT +/* +TRANS The socket communications protocol family you requested is not supported. */ + [ERR_REMAP (EPFNOSUPPORT)] = N_("Protocol family not supported"), +# if EPFNOSUPPORT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPFNOSUPPORT +# endif +#endif +#ifdef EAFNOSUPPORT +/* +TRANS The address family specified for a socket is not supported; it is +TRANS inconsistent with the protocol being used on the socket. @xref{Sockets}. */ + [ERR_REMAP (EAFNOSUPPORT)] = N_("Address family not supported by protocol"), +# if EAFNOSUPPORT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EAFNOSUPPORT +# endif +#endif +#ifdef EADDRINUSE +/* +TRANS The requested socket address is already in use. @xref{Socket Addresses}. */ + [ERR_REMAP (EADDRINUSE)] = N_("Address already in use"), +# if EADDRINUSE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EADDRINUSE +# endif +#endif +#ifdef EADDRNOTAVAIL +/* +TRANS The requested socket address is not available; for example, you tried +TRANS to give a socket a name that doesn't match the local host name. +TRANS @xref{Socket Addresses}. */ + [ERR_REMAP (EADDRNOTAVAIL)] = N_("Cannot assign requested address"), +# if EADDRNOTAVAIL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EADDRNOTAVAIL +# endif +#endif +#ifdef ENETDOWN +/* +TRANS A socket operation failed because the network was down. */ + [ERR_REMAP (ENETDOWN)] = N_("Network is down"), +# if ENETDOWN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENETDOWN +# endif +#endif +#ifdef ENETUNREACH +/* +TRANS A socket operation failed because the subnet containing the remote host +TRANS was unreachable. */ + [ERR_REMAP (ENETUNREACH)] = N_("Network is unreachable"), +# if ENETUNREACH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENETUNREACH +# endif +#endif +#ifdef ENETRESET +/* +TRANS A network connection was reset because the remote host crashed. */ + [ERR_REMAP (ENETRESET)] = N_("Network dropped connection on reset"), +# if ENETRESET > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENETRESET +# endif +#endif +#ifdef ECONNABORTED +/* +TRANS A network connection was aborted locally. */ + [ERR_REMAP (ECONNABORTED)] = N_("Software caused connection abort"), +# if ECONNABORTED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECONNABORTED +# endif +#endif +#ifdef ECONNRESET +/* +TRANS A network connection was closed for reasons outside the control of the +TRANS local host, such as by the remote machine rebooting or an unrecoverable +TRANS protocol violation. */ + [ERR_REMAP (ECONNRESET)] = N_("Connection reset by peer"), +# if ECONNRESET > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECONNRESET +# endif +#endif +#ifdef ENOBUFS +/* +TRANS The kernel's buffers for I/O operations are all in use. In GNU, this +TRANS error is always synonymous with @code{ENOMEM}; you may get one or the +TRANS other from network operations. */ + [ERR_REMAP (ENOBUFS)] = N_("No buffer space available"), +# if ENOBUFS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOBUFS +# endif +#endif +#ifdef EISCONN +/* +TRANS You tried to connect a socket that is already connected. +TRANS @xref{Connecting}. */ + [ERR_REMAP (EISCONN)] = N_("Transport endpoint is already connected"), +# if EISCONN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EISCONN +# endif +#endif +#ifdef ENOTCONN +/* +TRANS The socket is not connected to anything. You get this error when you +TRANS try to transmit data over a socket, without first specifying a +TRANS destination for the data. For a connectionless socket (for datagram +TRANS protocols, such as UDP), you get @code{EDESTADDRREQ} instead. */ + [ERR_REMAP (ENOTCONN)] = N_("Transport endpoint is not connected"), +# if ENOTCONN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTCONN +# endif +#endif +#ifdef EDESTADDRREQ +/* +TRANS No default destination address was set for the socket. You get this +TRANS error when you try to transmit data over a connectionless socket, +TRANS without first specifying a destination for the data with @code{connect}. */ + [ERR_REMAP (EDESTADDRREQ)] = N_("Destination address required"), +# if EDESTADDRREQ > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDESTADDRREQ +# endif +#endif +#ifdef ESHUTDOWN +/* +TRANS The socket has already been shut down. */ + [ERR_REMAP (ESHUTDOWN)] = N_("Cannot send after transport endpoint shutdown"), +# if ESHUTDOWN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESHUTDOWN +# endif +#endif +#ifdef ETOOMANYREFS +/* +TRANS ??? */ + [ERR_REMAP (ETOOMANYREFS)] = N_("Too many references: cannot splice"), +# if ETOOMANYREFS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ETOOMANYREFS +# endif +#endif +#ifdef ETIMEDOUT +/* +TRANS A socket operation with a specified timeout received no response during +TRANS the timeout period. */ + [ERR_REMAP (ETIMEDOUT)] = N_("Connection timed out"), +# if ETIMEDOUT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ETIMEDOUT +# endif +#endif +#ifdef ECONNREFUSED +/* +TRANS A remote host refused to allow the network connection (typically because +TRANS it is not running the requested service). */ + [ERR_REMAP (ECONNREFUSED)] = N_("Connection refused"), +# if ECONNREFUSED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECONNREFUSED +# endif +#endif +#ifdef ELOOP +/* +TRANS Too many levels of symbolic links were encountered in looking up a file name. +TRANS This often indicates a cycle of symbolic links. */ + [ERR_REMAP (ELOOP)] = N_("Too many levels of symbolic links"), +# if ELOOP > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELOOP +# endif +#endif +#ifdef ENAMETOOLONG +/* +TRANS Filename too long (longer than @code{PATH_MAX}; @pxref{Limits for +TRANS Files}) or host name too long (in @code{gethostname} or +TRANS @code{sethostname}; @pxref{Host Identification}). */ + [ERR_REMAP (ENAMETOOLONG)] = N_("File name too long"), +# if ENAMETOOLONG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENAMETOOLONG +# endif +#endif +#ifdef EHOSTDOWN +/* +TRANS The remote host for a requested network connection is down. */ + [ERR_REMAP (EHOSTDOWN)] = N_("Host is down"), +# if EHOSTDOWN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EHOSTDOWN +# endif +#endif +#ifdef EHOSTUNREACH +/* +TRANS The remote host for a requested network connection is not reachable. */ + [ERR_REMAP (EHOSTUNREACH)] = N_("No route to host"), +# if EHOSTUNREACH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EHOSTUNREACH +# endif +#endif +#ifdef ENOTEMPTY +/* +TRANS Directory not empty, where an empty directory was expected. Typically, +TRANS this error occurs when you are trying to delete a directory. */ + [ERR_REMAP (ENOTEMPTY)] = N_("Directory not empty"), +# if ENOTEMPTY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTEMPTY +# endif +#endif +#ifdef EPROCLIM +/* +TRANS This means that the per-user limit on new process would be exceeded by +TRANS an attempted @code{fork}. @xref{Limits on Resources}, for details on +TRANS the @code{RLIMIT_NPROC} limit. */ + [ERR_REMAP (EPROCLIM)] = N_("Too many processes"), +# if EPROCLIM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROCLIM +# endif +#endif +#ifdef EUSERS +/* +TRANS The file quota system is confused because there are too many users. +TRANS @c This can probably happen in a GNU system when using NFS. */ + [ERR_REMAP (EUSERS)] = N_("Too many users"), +# if EUSERS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EUSERS +# endif +#endif +#ifdef EDQUOT +/* +TRANS The user's disk quota was exceeded. */ + [ERR_REMAP (EDQUOT)] = N_("Disk quota exceeded"), +# if EDQUOT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDQUOT +# endif +#endif +#ifdef ESTALE +/* +TRANS Stale NFS file handle. This indicates an internal confusion in the NFS +TRANS system which is due to file system rearrangements on the server host. +TRANS Repairing this condition usually requires unmounting and remounting +TRANS the NFS file system on the local host. */ + [ERR_REMAP (ESTALE)] = N_("Stale NFS file handle"), +# if ESTALE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESTALE +# endif +#endif +#ifdef EREMOTE +/* +TRANS An attempt was made to NFS-mount a remote file system with a file name that +TRANS already specifies an NFS-mounted file. +TRANS (This is an error on some operating systems, but we expect it to work +TRANS properly on the GNU system, making this error code impossible.) */ + [ERR_REMAP (EREMOTE)] = N_("Object is remote"), +# if EREMOTE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EREMOTE +# endif +#endif +#ifdef EBADRPC +/* +TRANS ??? */ + [ERR_REMAP (EBADRPC)] = N_("RPC struct is bad"), +# if EBADRPC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADRPC +# endif +#endif +#ifdef ERPCMISMATCH +/* +TRANS ??? */ + [ERR_REMAP (ERPCMISMATCH)] = N_("RPC version wrong"), +# if ERPCMISMATCH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ERPCMISMATCH +# endif +#endif +#ifdef EPROGUNAVAIL +/* +TRANS ??? */ + [ERR_REMAP (EPROGUNAVAIL)] = N_("RPC program not available"), +# if EPROGUNAVAIL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROGUNAVAIL +# endif +#endif +#ifdef EPROGMISMATCH +/* +TRANS ??? */ + [ERR_REMAP (EPROGMISMATCH)] = N_("RPC program version wrong"), +# if EPROGMISMATCH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROGMISMATCH +# endif +#endif +#ifdef EPROCUNAVAIL +/* +TRANS ??? */ + [ERR_REMAP (EPROCUNAVAIL)] = N_("RPC bad procedure for program"), +# if EPROCUNAVAIL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROCUNAVAIL +# endif +#endif +#ifdef ENOLCK +/* +TRANS No locks available. This is used by the file locking facilities; see +TRANS @ref{File Locks}. This error is never generated by the GNU system, but +TRANS it can result from an operation to an NFS server running another +TRANS operating system. */ + [ERR_REMAP (ENOLCK)] = N_("No locks available"), +# if ENOLCK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOLCK +# endif +#endif +#ifdef EFTYPE +/* +TRANS Inappropriate file type or format. The file was the wrong type for the +TRANS operation, or a data file had the wrong format. +TRANS +TRANS On some systems @code{chmod} returns this error if you try to set the +TRANS sticky bit on a non-directory file; @pxref{Setting Permissions}. */ + [ERR_REMAP (EFTYPE)] = N_("Inappropriate file type or format"), +# if EFTYPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EFTYPE +# endif +#endif +#ifdef EAUTH +/* +TRANS ??? */ + [ERR_REMAP (EAUTH)] = N_("Authentication error"), +# if EAUTH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EAUTH +# endif +#endif +#ifdef ENEEDAUTH +/* +TRANS ??? */ + [ERR_REMAP (ENEEDAUTH)] = N_("Need authenticator"), +# if ENEEDAUTH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENEEDAUTH +# endif +#endif +#ifdef ENOSYS +/* +TRANS Function not implemented. This indicates that the function called is +TRANS not implemented at all, either in the C library itself or in the +TRANS operating system. When you get this error, you can be sure that this +TRANS particular function will always fail with @code{ENOSYS} unless you +TRANS install a new version of the C library or the operating system. */ + [ERR_REMAP (ENOSYS)] = N_("Function not implemented"), +# if ENOSYS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOSYS +# endif +#endif +#if defined (ENOTSUP) && ENOTSUP != EOPNOTSUPP +/* +TRANS Not supported. A function returns this error when certain parameter +TRANS values are valid, but the functionality they request is not available. +TRANS This can mean that the function does not implement a particular command +TRANS or option value or flag bit at all. For functions that operate on some +TRANS object given in a parameter, such as a file descriptor or a port, it +TRANS might instead mean that only @emph{that specific object} (file +TRANS descriptor, port, etc.) is unable to support the other parameters given; +TRANS different file descriptors might support different ranges of parameter +TRANS values. +TRANS +TRANS If the entire function is not available at all in the implementation, +TRANS it returns @code{ENOSYS} instead. */ + [ERR_REMAP (ENOTSUP)] = N_("Not supported"), +# if ENOTSUP > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTSUP +# endif +#endif +#ifdef EILSEQ +/* +TRANS While decoding a multibyte character the function came along an invalid +TRANS or an incomplete sequence of bytes or the given wide character is invalid. */ + [ERR_REMAP (EILSEQ)] = N_("Invalid or incomplete multibyte or wide character"), +# if EILSEQ > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EILSEQ +# endif +#endif +#ifdef EBACKGROUND +/* +TRANS In the GNU system, servers supporting the @code{term} protocol return +TRANS this error for certain operations when the caller is not in the +TRANS foreground process group of the terminal. Users do not usually see this +TRANS error because functions such as @code{read} and @code{write} translate +TRANS it into a @code{SIGTTIN} or @code{SIGTTOU} signal. @xref{Job Control}, +TRANS for information on process groups and these signals. */ + [ERR_REMAP (EBACKGROUND)] = N_("Inappropriate operation for background process"), +# if EBACKGROUND > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBACKGROUND +# endif +#endif +#ifdef EDIED +/* +TRANS In the GNU system, opening a file returns this error when the file is +TRANS translated by a program and the translator program dies while starting +TRANS up, before it has connected to the file. */ + [ERR_REMAP (EDIED)] = N_("Translator died"), +# if EDIED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDIED +# endif +#endif +#ifdef ED +/* +TRANS The experienced user will know what is wrong. +TRANS @c This error code is a joke. Its perror text is part of the joke. +TRANS @c Don't change it. */ + [ERR_REMAP (ED)] = N_("?"), +# if ED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ED +# endif +#endif +#ifdef EGREGIOUS +/* +TRANS You did @strong{what}? */ + [ERR_REMAP (EGREGIOUS)] = N_("You really blew it this time"), +# if EGREGIOUS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EGREGIOUS +# endif +#endif +#ifdef EIEIO +/* +TRANS Go home and have a glass of warm, dairy-fresh milk. */ + [ERR_REMAP (EIEIO)] = N_("Computer bought the farm"), +# if EIEIO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EIEIO +# endif +#endif +#ifdef EGRATUITOUS +/* +TRANS This error code has no purpose. */ + [ERR_REMAP (EGRATUITOUS)] = N_("Gratuitous error"), +# if EGRATUITOUS > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EGRATUITOUS +# endif +#endif +#ifdef EBADMSG +/* */ + [ERR_REMAP (EBADMSG)] = N_("Bad message"), +# if EBADMSG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADMSG +# endif +#endif +#ifdef EIDRM +/* */ + [ERR_REMAP (EIDRM)] = N_("Identifier removed"), +# if EIDRM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EIDRM +# endif +#endif +#ifdef EMULTIHOP +/* */ + [ERR_REMAP (EMULTIHOP)] = N_("Multihop attempted"), +# if EMULTIHOP > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EMULTIHOP +# endif +#endif +#ifdef ENODATA +/* */ + [ERR_REMAP (ENODATA)] = N_("No data available"), +# if ENODATA > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENODATA +# endif +#endif +#ifdef ENOLINK +/* */ + [ERR_REMAP (ENOLINK)] = N_("Link has been severed"), +# if ENOLINK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOLINK +# endif +#endif +#ifdef ENOMSG +/* */ + [ERR_REMAP (ENOMSG)] = N_("No message of desired type"), +# if ENOMSG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOMSG +# endif +#endif +#ifdef ENOSR +/* */ + [ERR_REMAP (ENOSR)] = N_("Out of streams resources"), +# if ENOSR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOSR +# endif +#endif +#ifdef ENOSTR +/* */ + [ERR_REMAP (ENOSTR)] = N_("Device not a stream"), +# if ENOSTR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOSTR +# endif +#endif +#ifdef EOVERFLOW +/* */ + [ERR_REMAP (EOVERFLOW)] = N_("Value too large for defined data type"), +# if EOVERFLOW > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EOVERFLOW +# endif +#endif +#ifdef EPROTO +/* */ + [ERR_REMAP (EPROTO)] = N_("Protocol error"), +# if EPROTO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EPROTO +# endif +#endif +#ifdef ETIME +/* */ + [ERR_REMAP (ETIME)] = N_("Timer expired"), +# if ETIME > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ETIME +# endif +#endif +#ifdef ECANCELED +/* +TRANS Operation canceled; an asynchronous operation was canceled before it +TRANS completed. @xref{Asynchronous I/O}. When you call @code{aio_cancel}, +TRANS the normal result is for the operations affected to complete with this +TRANS error; @pxref{Cancel AIO Operations}. */ + [ERR_REMAP (ECANCELED)] = N_("Operation canceled"), +# if ECANCELED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECANCELED +# endif +#endif +#ifdef ERESTART +/* */ + [ERR_REMAP (ERESTART)] = N_("Interrupted system call should be restarted"), +# if ERESTART > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ERESTART +# endif +#endif +#ifdef ECHRNG +/* */ + [ERR_REMAP (ECHRNG)] = N_("Channel number out of range"), +# if ECHRNG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECHRNG +# endif +#endif +#ifdef EL2NSYNC +/* */ + [ERR_REMAP (EL2NSYNC)] = N_("Level 2 not synchronized"), +# if EL2NSYNC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EL2NSYNC +# endif +#endif +#ifdef EL3HLT +/* */ + [ERR_REMAP (EL3HLT)] = N_("Level 3 halted"), +# if EL3HLT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EL3HLT +# endif +#endif +#ifdef EL3RST +/* */ + [ERR_REMAP (EL3RST)] = N_("Level 3 reset"), +# if EL3RST > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EL3RST +# endif +#endif +#ifdef ELNRNG +/* */ + [ERR_REMAP (ELNRNG)] = N_("Link number out of range"), +# if ELNRNG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELNRNG +# endif +#endif +#ifdef EUNATCH +/* */ + [ERR_REMAP (EUNATCH)] = N_("Protocol driver not attached"), +# if EUNATCH > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EUNATCH +# endif +#endif +#ifdef ENOCSI +/* */ + [ERR_REMAP (ENOCSI)] = N_("No CSI structure available"), +# if ENOCSI > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOCSI +# endif +#endif +#ifdef EL2HLT +/* */ + [ERR_REMAP (EL2HLT)] = N_("Level 2 halted"), +# if EL2HLT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EL2HLT +# endif +#endif +#ifdef EBADE +/* */ + [ERR_REMAP (EBADE)] = N_("Invalid exchange"), +# if EBADE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADE +# endif +#endif +#ifdef EBADR +/* */ + [ERR_REMAP (EBADR)] = N_("Invalid request descriptor"), +# if EBADR > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADR +# endif +#endif +#ifdef EXFULL +/* */ + [ERR_REMAP (EXFULL)] = N_("Exchange full"), +# if EXFULL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EXFULL +# endif +#endif +#ifdef ENOANO +/* */ + [ERR_REMAP (ENOANO)] = N_("No anode"), +# if ENOANO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOANO +# endif +#endif +#ifdef EBADRQC +/* */ + [ERR_REMAP (EBADRQC)] = N_("Invalid request code"), +# if EBADRQC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADRQC +# endif +#endif +#ifdef EBADSLT +/* */ + [ERR_REMAP (EBADSLT)] = N_("Invalid slot"), +# if EBADSLT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADSLT +# endif +#endif +#if defined (EDEADLOCK) && EDEADLOCK != EDEADLK +/* */ + [ERR_REMAP (EDEADLOCK)] = N_("File locking deadlock error"), +# if EDEADLOCK > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDEADLOCK +# endif +#endif +#ifdef EBFONT +/* */ + [ERR_REMAP (EBFONT)] = N_("Bad font file format"), +# if EBFONT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBFONT +# endif +#endif +#ifdef ENONET +/* */ + [ERR_REMAP (ENONET)] = N_("Machine is not on the network"), +# if ENONET > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENONET +# endif +#endif +#ifdef ENOPKG +/* */ + [ERR_REMAP (ENOPKG)] = N_("Package not installed"), +# if ENOPKG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOPKG +# endif +#endif +#ifdef EADV +/* */ + [ERR_REMAP (EADV)] = N_("Advertise error"), +# if EADV > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EADV +# endif +#endif +#ifdef ESRMNT +/* */ + [ERR_REMAP (ESRMNT)] = N_("Srmount error"), +# if ESRMNT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESRMNT +# endif +#endif +#ifdef ECOMM +/* */ + [ERR_REMAP (ECOMM)] = N_("Communication error on send"), +# if ECOMM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ECOMM +# endif +#endif +#ifdef EDOTDOT +/* */ + [ERR_REMAP (EDOTDOT)] = N_("RFS specific error"), +# if EDOTDOT > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EDOTDOT +# endif +#endif +#ifdef ENOTUNIQ +/* */ + [ERR_REMAP (ENOTUNIQ)] = N_("Name not unique on network"), +# if ENOTUNIQ > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTUNIQ +# endif +#endif +#ifdef EBADFD +/* */ + [ERR_REMAP (EBADFD)] = N_("File descriptor in bad state"), +# if EBADFD > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EBADFD +# endif +#endif +#ifdef EREMCHG +/* */ + [ERR_REMAP (EREMCHG)] = N_("Remote address changed"), +# if EREMCHG > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EREMCHG +# endif +#endif +#ifdef ELIBACC +/* */ + [ERR_REMAP (ELIBACC)] = N_("Can not access a needed shared library"), +# if ELIBACC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELIBACC +# endif +#endif +#ifdef ELIBBAD +/* */ + [ERR_REMAP (ELIBBAD)] = N_("Accessing a corrupted shared library"), +# if ELIBBAD > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELIBBAD +# endif +#endif +#ifdef ELIBSCN +/* */ + [ERR_REMAP (ELIBSCN)] = N_(".lib section in a.out corrupted"), +# if ELIBSCN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELIBSCN +# endif +#endif +#ifdef ELIBMAX +/* */ + [ERR_REMAP (ELIBMAX)] = N_("Attempting to link in too many shared libraries"), +# if ELIBMAX > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELIBMAX +# endif +#endif +#ifdef ELIBEXEC +/* */ + [ERR_REMAP (ELIBEXEC)] = N_("Cannot exec a shared library directly"), +# if ELIBEXEC > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ELIBEXEC +# endif +#endif +#ifdef ESTRPIPE +/* */ + [ERR_REMAP (ESTRPIPE)] = N_("Streams pipe error"), +# if ESTRPIPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ESTRPIPE +# endif +#endif +#ifdef EUCLEAN +/* */ + [ERR_REMAP (EUCLEAN)] = N_("Structure needs cleaning"), +# if EUCLEAN > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EUCLEAN +# endif +#endif +#ifdef ENOTNAM +/* */ + [ERR_REMAP (ENOTNAM)] = N_("Not a XENIX named type file"), +# if ENOTNAM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTNAM +# endif +#endif +#ifdef ENAVAIL +/* */ + [ERR_REMAP (ENAVAIL)] = N_("No XENIX semaphores available"), +# if ENAVAIL > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENAVAIL +# endif +#endif +#ifdef EISNAM +/* */ + [ERR_REMAP (EISNAM)] = N_("Is a named type file"), +# if EISNAM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EISNAM +# endif +#endif +#ifdef EREMOTEIO +/* */ + [ERR_REMAP (EREMOTEIO)] = N_("Remote I/O error"), +# if EREMOTEIO > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EREMOTEIO +# endif +#endif +#ifdef ENOMEDIUM +/* */ + [ERR_REMAP (ENOMEDIUM)] = N_("No medium found"), +# if ENOMEDIUM > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOMEDIUM +# endif +#endif +#ifdef EMEDIUMTYPE +/* */ + [ERR_REMAP (EMEDIUMTYPE)] = N_("Wrong medium type"), +# if EMEDIUMTYPE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EMEDIUMTYPE +# endif +#endif +#ifdef ENOKEY +/* */ + [ERR_REMAP (ENOKEY)] = N_("Required key not available"), +# if ENOKEY > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOKEY +# endif +#endif +#ifdef EKEYEXPIRED +/* */ + [ERR_REMAP (EKEYEXPIRED)] = N_("Key has expired"), +# if EKEYEXPIRED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EKEYEXPIRED +# endif +#endif +#ifdef EKEYREVOKED +/* */ + [ERR_REMAP (EKEYREVOKED)] = N_("Key has been revoked"), +# if EKEYREVOKED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EKEYREVOKED +# endif +#endif +#ifdef EKEYREJECTED +/* */ + [ERR_REMAP (EKEYREJECTED)] = N_("Key was rejected by service"), +# if EKEYREJECTED > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EKEYREJECTED +# endif +#endif +#ifdef EOWNERDEAD +/* */ + [ERR_REMAP (EOWNERDEAD)] = N_("Owner died"), +# if EOWNERDEAD > ERR_MAX +# undef ERR_MAX +# define ERR_MAX EOWNERDEAD +# endif +#endif +#ifdef ENOTRECOVERABLE +/* */ + [ERR_REMAP (ENOTRECOVERABLE)] = N_("State not recoverable"), +# if ENOTRECOVERABLE > ERR_MAX +# undef ERR_MAX +# define ERR_MAX ENOTRECOVERABLE +# endif +#endif + }; diff --git a/src/target/firmware/lib/system.c b/src/target/firmware/lib/system.c index 2c44aada..9c6c6859 100644 --- a/src/target/firmware/lib/system.c +++ b/src/target/firmware/lib/system.c @@ -49,6 +49,25 @@ int munmap(void *addr, size_t length) { return 0; } +int fstat(int fd, struct stat *buf) { + errno = ENOENT; + return -1; +} + +int __libc_open(const char *pathname, int flags) { + errno = ENOENT; + return -1; +} + +int __libc_close(int fd) { + return 0; +} + +ssize_t __libc_read(int fd, void *buf, size_t count) { + errno = ENOTSUP; + return -1; +} + ssize_t __libc_write(int fd, const void *buf, size_t count) { char c; int i; @@ -76,3 +95,21 @@ void _exit(int status) { puts("Program exit\n"); while(1) { } } + +int __rt_sigprocmask(int how, const sigset_t *set, sigset_t *oldsetm, long nr) { + return 0; +} + + +/* XXX: very bad */ + +double floor(double x) { + return 0.0; +} +double log(double x) { + return 0.0; +} +double exp(double x) { + return 0.0; +} + -- cgit v1.2.3