libc.h

ecos为实时嵌入式操作系统

            parent        CYGPKG_LIBC_SIGNALS
        }

        cdl_option CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL {
            display       "Bad signal fatal"
            description   "Enabling this option will cause an assertion
                           failure if the signal handling code is
                           passed a bad signal. Otherwise an error will
                           be returned, or in the case of a
                           hardware-generated exception it will be silently
                           ignored."
            type          boolean
            requires      CYGDBG_USE_ASSERTS
            parent        CYGPKG_LIBC_SIGNALS_ERROR_HANDLING
        }

        cdl_option CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO {
            display       "raise() sets errno"
            description   "You may or may not want errno to be set by
                           raise() on error conditions. Not using errno
                           could save both space, code, and avoid worrying
                           about interactions between multiple threads when
                           setting it. Strictly ISO C does not mandate
                           that errno be set by raise()."
            type          boolean
            parent        CYGPKG_LIBC_SIGNALS_ERROR_HANDLING
        }

        cdl_option CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO {
            display       "signal() sets errno"
            description   "You may or may not want errno to be set by
                           signal() on error conditions. Not using errno
                           could save both space, code, and avoid worrying
                           about interactions between multiple threads when
                           setting it. Strictly ISO C mandates
                           that errno be set by signal()."
            type          boolean
            parent        CYGPKG_LIBC_SIGNALS_ERROR_HANDLING
        }

        cdl_component CYGPKG_LIBC_SIGNALS_TRACING {
            display       "Tracing"
            description   "These options control the trace output for the C
                           library internal signal implementation."
            type          dummy
            parent        CYGPKG_LIBC_SIGNALS
        }

        cdl_option CYGNUM_LIBC_SIGNALS_RAISE_TRACE_LEVEL {
            display       "Default trace level for raise()"
            description   "This gives the default tracing level for the
                           raise() function. Higher numbers are more
                           verbose."
            type          count
            legal_values  0 to 1
            parent        CYGPKG_LIBC_SIGNALS_TRACING
        }

        cdl_option CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL {
            display       "Default hardware exception handler trace level"
            description   "This gives the default tracing level for the
                           hardware exception handler function (if enabled).
                           Higher numbers are more verbose."
            type          count
            legal_values  0 to 1
            parent        CYGPKG_LIBC_SIGNALS_TRACING
        }

    }}CFG_DATA
*/

#define CYGPKG_LIBC_SIGNALS
#define CYGSEM_LIBC_SIGNALS_THREAD_SAFE
#undef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
#ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
# define CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS
#endif
#define CYGIMP_LIBC_SIGNALS_RAISE_INLINE
#define CYGIMP_LIBC_SIGNALS_SIGNAL_INLINE
#undef CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL
#define CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO
#define CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO
#define CYGNUM_LIBC_SIGNALS_RAISE_TRACE_LEVEL 0
#define CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL 0

//========================================================================

// STARTUP OPTIONS

/*
    {{CFG_DATA

        cdl_component CYGPKG_LIBC_STARTUP {
            display       "ISO C startup/termination"
            description   "This component manages the control of the
                           environment (in the general sense) that the
                           C library provides for use for full ISO C
                           compatibility, including a main() entry point
                           supplied with arguments and an environment
                           (as retrievable by the getenv() function).
                           It also includes at the other end of things,
                           what happens when main() returns or exit() is
                           called."
            doc           ref/ecos-ref/c-library-startup.html.html
            type          dummy
            parent        CYGPKG_LIBC
        }

        cdl_option CYGDAT_LIBC_ARGUMENTS {
            display       "Arguments to main()"
            description   "This option allows the setting of the arguments
                           to the main function. This only has any effect
                           when cyg_iso_c_start() is used to start the
                           ISO C compatibility. This will automatically
                           invoke main() in an ISO C compatible fashion.
                           This option is in fact used as argv, and so is
                           an n-tuple of string constants. The final
                           entry must be NULL. Conventionally if argv[0]
                           is supplied, it is used to inform the program
                           of its name."
            type          string
            parent        CYGPKG_LIBC_STARTUP
        }

        cdl_component CYGSEM_LIBC_STARTUP_MAIN_THREAD {
            display       "main() invoked as thread"
            description   "It is normally expected (e.g. in a POSIX 1003.1
                           environment) that main() is run in the context
                           of a thread just like any other thread. If this
                           option is disabled then main() will instead be
                           called in the context of the initialization
                           routines, without the scheduler running and
                           using the interrupt stack. This means that 
                           any functions that may require interactions
                           with a running kernel will not work (including
                           libc functions, if configured to be thread safe
                           for example), so you should restrict yourself
                           to only calling fully re-entrant functions from
                           within main() in this case."
            type          boolean
            requires      CYGPKG_KERNEL
            parent        CYGPKG_LIBC_STARTUP
        }

        cdl_option CYGNUM_LIBC_MAIN_STACK_SIZE {
            display        "main()'s thread stack size"
            description    "With an eCos kernel, when the cyg_iso_c_start()
                            function is used to invoke the user-supplied
                            main() function in an ISO C compatible fashion,
                            a separate thread is created to call main().
                            This option controls the size of that thread's
                            stack, which is allocated in the BSS. It
                            must be a multiple of 8. Note, a low number
                            here may be overriden by the HAL if there is
                            a minimum requirement to process interrupts
                            etc."
            type           count
            legal_values   16 to 0x7fffffff
            parent         CYGSEM_LIBC_STARTUP_MAIN_THREAD
        }

        cdl_component CYGFUN_LIBC_ATEXIT {
            display        "Include atexit() function"
            description    "This option enables the use of the atexit()
                            function, and ensure that the atexit handlers
                            are invoked from within exit() as defined in
                            the ISO C standard."
            type           boolean
            parent         CYGPKG_LIBC_STARTUP
        }

        cdl_option CYGNUM_LIBC_ATEXIT_HANDLERS {
            display        "Number of functions atexit() supports"
            description    "This option sets the number of functions
                            that atexit() has room for. In other words,
                            the number of separate atexit() calls that
                            can be made before calling exit() or returning
                            from main() ( in an environment controlled by
                            cyg_iso_c_start() ). For strict compliance
                            with the ISO C standard this should be at
                            least 32."
            type           count
            parent         CYGFUN_LIBC_ATEXIT
            legal_values   1 to 0x7fffffff
        }

        cdl_option CYGSEM_LIBC_EXIT_CALLS_FFLUSH {
            display        "Make exit() call fflush()"
            description    "This option will ensure that all output
                            streams are flushed when exitting using
                            exit() as prescribed by the ISO C standard."
            type           boolean
            parent         CYGPKG_LIBC_STARTUP
            requires       CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO
        }

        cdl_option CYGSEM_LIBC_EXIT_STOPS_SYSTEM {
            display        "_exit() stops all threads"
            description    "If this option is enabled then _exit(),
                            which is called from exit() which itself is
                            called on return from main(), stops the eCos
                            scheduler. For strict POSIX 1003.1
                            compatibility this would be the normal
                            behaviour. To allow the thread to simply
                            exit, without affecting other threads, simply
                            disable this option. If there is no eCos
                            scheduler, then _exit() simply loops
                            irrespective of the setting of this option."
            type           boolean
            parent         CYGPKG_LIBC_STARTUP
            requires       CYGPKG_KERNEL
        }

        cdl_component CYGPKG_LIBC_ENVIRONMENT {
            display       "Provide a system environment"
            description   "This option allows use of the getenv() function
                           and the global environment pointer
                           char **environ defined by POSIX 1003.1.
                           Disabling this saves a small amount of space."
            type          boolean
            parent        CYGPKG_LIBC_STARTUP
        }

        cdl_option CYGDAT_LIBC_DEFAULT_ENVIRONMENT {
            display       "Default environment"
            description   "This option allows the setting of the default
                           contents of the environment. This is in fact
                           the contents of the global environment pointer
                           char **environ defined by POSIX 1003.1. Strings
                           must be of the form NAME=VALUE, and the final
                           entry must be NULL."
            type          string
            parent        CYGPKG_LIBC_ENVIRONMENT
        }

        cdl_option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS {
            display        "Invoke default static constructors"
            description    "This option causes the C library to call
                            static constructors with default priority
                            from within the context of the main() thread,
                            working with the co-operation of the HAL.
                            This may be needed for environments that
                            expect static constructors to be run in a
                            thread context. Note that this uses an object
                            with priority 65534. Therefore do not use
                            priority 65534 for any other static objects
                            with this option enabled."
            type           boolean
            requires       CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG
            requires       CYGSEM_LIBC_STARTUP_MAIN_THREAD
            parent         CYGPKG_LIBC_STARTUP
        }

    }}CFG_DATA
*/

#define CYGDAT_LIBC_ARGUMENTS { "", NULL }

#define CYGSEM_LIBC_STARTUP_MAIN_THREAD

#ifdef CYGSEM_LIBC_STARTUP_MAIN_THREAD
#define CYGNUM_LIBC_MAIN_STACK_SIZE 8192
#endif

#define CYGFUN_LIBC_ATEXIT

#ifdef CYGFUN_LIBC_ATEXIT
#define CYGNUM_LIBC_ATEXIT_HANDLERS 32
#endif

#define CYGSEM_LIBC_EXIT_CALLS_FFLUSH

#undef CYGSEM_LIBC_EXIT_STOPS_SYSTEM

#define CYGPKG_LIBC_ENVIRONMENT

#define CYGDAT_LIBC_DEFAULT_ENVIRONMENT { NULL }

#undef CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS

//========================================================================

// ERRNO OPTIONS

/*
    {{CFG_DATA

        cdl_component CYGPKG_LIBC_ERRNO {
            display      "errno"
            description  "This package controls the behaviour of the
                          errno variable (or more strictly, expression)
                          from <errno.h>."
            type         dummy
            parent       CYGPKG_LIBC
        }
  
        cdl_option CYGSEM_LIBC_PER_THREAD_ERRNO {
            display      "Per-thread errno"
            description  "This option controls whether the standard error
                          code reporting variable errno is a per-thread