head 1.1; branch 1.1.1; access ; symbols ECOS_2_0:1.1.1.1 OPENCORES_ECOS_2_0:1.1.1; locks ; strict; comment @# @; 1.1 date 2004.02.14.13.25.41; author phoenix; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 2004.02.14.13.25.41; author phoenix; state Exp; branches ; next ; desc @@ 1.1 log @Initial revision @ text @# eCos saved configuration # ---- commands -------------------------------------------------------- # This section contains information about the savefile format. # It should not be edited. Any modifications made to this section # may make it impossible for the configuration tools to read # the savefile. cdl_savefile_version 1; cdl_savefile_command cdl_savefile_version {}; cdl_savefile_command cdl_savefile_command {}; cdl_savefile_command cdl_configuration { description hardware template package }; cdl_savefile_command cdl_package { value_source user_value wizard_value inferred_value }; cdl_savefile_command cdl_component { value_source user_value wizard_value inferred_value }; cdl_savefile_command cdl_option { value_source user_value wizard_value inferred_value }; cdl_savefile_command cdl_interface { value_source user_value wizard_value inferred_value }; # ---- toplevel -------------------------------------------------------- # This section defines the toplevel configuration object. The only # values that can be changed are the name of the configuration and # the description field. It is not possible to modify the target, # the template or the set of packages simply by editing the lines # below because these changes have wide-ranging effects. Instead # the appropriate tools should be used to make such modifications. cdl_configuration eCos { description "" ; # These fields should not be modified. hardware ORP ; template default ; package -hardware CYGPKG_HAL_OPENRISC current ; package -hardware CYGPKG_HAL_OPENRISC_ORP current ; package -hardware CYGPKG_DEVS_FLASH_OPENRISC_ORP current ; package -hardware CYGPKG_DEVS_FLASH_AMD_AM29XXXXX v2_0 ; package -template CYGPKG_HAL v2_0 ; package -template CYGPKG_IO v2_0 ; package -template CYGPKG_IO_SERIAL v2_0 ; package -template CYGPKG_INFRA v2_0 ; package -template CYGPKG_KERNEL v2_0 ; package -template CYGPKG_MEMALLOC v2_0 ; package -template CYGPKG_ISOINFRA v2_0 ; package -template CYGPKG_LIBC v2_0 ; package -template CYGPKG_LIBC_I18N v2_0 ; package -template CYGPKG_LIBC_SETJMP v2_0 ; package -template CYGPKG_LIBC_SIGNALS v2_0 ; package -template CYGPKG_LIBC_STARTUP v2_0 ; package -template CYGPKG_LIBC_STDIO v2_0 ; package -template CYGPKG_LIBC_STDLIB v2_0 ; package -template CYGPKG_LIBC_STRING v2_0 ; package -template CYGPKG_LIBC_TIME v2_0 ; package -template CYGPKG_LIBM v2_0 ; package -template CYGPKG_IO_WALLCLOCK v2_0 ; package -template CYGPKG_ERROR v2_0 ; }; # ---- conflicts ------------------------------------------------------- # There are no conflicts. # ---- contents -------------------------------------------------------- # > # > # Global build options # Global build options including control over # compiler flags, linker flags and choice of toolchain. # cdl_component CYGBLD_GLOBAL_OPTIONS { # There is no associated value. # The following properties are affected by this value }; # > # Global command prefix # This option specifies the command prefix used when # invoking the build tools. # cdl_option CYGBLD_GLOBAL_COMMAND_PREFIX { # Flavor: data # No user value, uncomment the following line to provide one. # user_value or32-elf # value_source default # Default value: or32-elf }; # Global compiler flags # This option controls the global compiler flags which # are used to compile all packages by # default. Individual packages may define # options which override these global flags. # cdl_option CYGBLD_GLOBAL_CFLAGS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "-msoft-float -Wall -Wpointer-arith -Wstrict-prototypes -Winline -Wundef -Woverloaded-virtual -g -O2 -fno-omit-frame-pointer -fno-rtti -fno-exceptions -fvtable-gc -finit-priority" # value_source default # Default value: "-msoft-float -Wall -Wpointer-arith -Wstrict-prototypes -Winline -Wundef -Woverloaded-virtual -g -O2 -fno-omit-frame-pointer -fno-rtti -fno-exceptions -fvtable-gc -finit-priority" # The following properties are affected by this value # option CYGBLD_INFRA_CFLAGS_WARNINGS_AS_ERRORS # Requires: is_substr(CYGBLD_GLOBAL_CFLAGS, " -Werror") # option CYGBLD_INFRA_CFLAGS_PIPE # Requires: is_substr(CYGBLD_GLOBAL_CFLAGS, " -pipe") }; # Global linker flags # This option controls the global linker flags. Individual # packages may define options which override these global flags. # cdl_option CYGBLD_GLOBAL_LDFLAGS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "-msoft-float -g -nostdlib -Wl,--gc-sections -Wl,-static" # value_source default # Default value: "-msoft-float -g -nostdlib -Wl,--gc-sections -Wl,-static" }; # Build GDB stub ROM image # This option enables the building of the GDB stubs for the # board. The common HAL controls takes care of most of the # build process, but the final conversion from ELF image to # binary data is handled by the platform CDL, allowing # relocation of the data if necessary. # cdl_option CYGBLD_BUILD_GDB_STUBS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYG_HAL_STARTUP == "ROM" # CYG_HAL_STARTUP == ROM # --> 1 # Requires: CYGSEM_HAL_ROM_MONITOR # CYGSEM_HAL_ROM_MONITOR == 1 # --> 1 # Requires: CYGBLD_BUILD_COMMON_GDB_STUBS # CYGBLD_BUILD_COMMON_GDB_STUBS == 0 # --> 0 # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 # Requires: ! CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT == 0 # --> 1 # Requires: ! CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT # CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT == 1 # --> 0 # Requires: ! CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT # CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT == 1 # --> 0 # Requires: ! CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM # CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM == 1 # --> 0 }; # Build common GDB stub ROM image # Unless a target board has specific requirements to the # stub implementation, it can use a simple common stub. # This option, which gets enabled by platform HALs as # appropriate, controls the building of the common stub. # cdl_option CYGBLD_BUILD_COMMON_GDB_STUBS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: CYGBLD_BUILD_COMMON_GDB_STUBS }; # < # Redboot HAL options # This option lists the target's requirements for a valid Redboot # configuration. # cdl_component CYGPKG_REDBOOT_HAL_OPTIONS { # This option is not active # ActiveIf constraint: CYGPKG_REDBOOT # CYGPKG_REDBOOT (unknown) == 0 # --> 0 # There is no associated value. }; # > # Build Redboot ROM binary image # This option enables the conversion of the Redboot ELF # image to a binary image suitable for ROM programming. # cdl_option CYGBLD_BUILD_REDBOOT_BIN { # This option is not active # The parent CYGPKG_REDBOOT_HAL_OPTIONS is not active # ActiveIf constraint: CYGBLD_BUILD_REDBOOT # CYGBLD_BUILD_REDBOOT (unknown) == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Flash memory support for OpenRISC ORP # cdl_package CYGPKG_DEVS_FLASH_OPENRISC_ORP { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This option is not active # ActiveIf constraint: CYGPKG_IO_FLASH # CYGPKG_IO_FLASH (unknown) == 0 # --> 0 # This value cannot be modified here. # Flavor: booldata # Current value: 1 current # Requires: CYGPKG_HAL_OPENRISC_ORP # CYGPKG_HAL_OPENRISC_ORP == current # --> 1 # Requires: CYGHWR_DEVS_FLASH_AMD_AM29LV160 # CYGHWR_DEVS_FLASH_AMD_AM29LV160 == 0 # --> 0 }; # > # AMD AM29LV160 driver required # cdl_interface CYGINT_DEVS_FLASH_AMD_AM29XXXXX_REQUIRED { # Implemented by CYGPKG_DEVS_FLASH_OPENRISC_ORP, inactive, enabled # This option is not active # The parent CYGPKG_DEVS_FLASH_OPENRISC_ORP is not active # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # package CYGPKG_DEVS_FLASH_AMD_AM29XXXXX # ActiveIf: CYGINT_DEVS_FLASH_AMD_AM29XXXXX_REQUIRED }; # < # AMD AM29XXXXX FLASH memory support # FLASH memory device support for AMD AM29XXXXX # cdl_package CYGPKG_DEVS_FLASH_AMD_AM29XXXXX { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This option is not active # ActiveIf constraint: CYGPKG_IO_FLASH # CYGPKG_IO_FLASH (unknown) == 0 # --> 0 # ActiveIf constraint: CYGINT_DEVS_FLASH_AMD_AM29XXXXX_REQUIRED # CYGINT_DEVS_FLASH_AMD_AM29XXXXX_REQUIRED == 0 # --> 0 # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGINT_DEVS_FLASH_AMD_VARIANTS != 0 # CYGINT_DEVS_FLASH_AMD_VARIANTS == 0 # --> 0 }; # > # Number of included variants # cdl_interface CYGINT_DEVS_FLASH_AMD_VARIANTS { # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29F040B, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29LV160, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29LV320D, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29LV200, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_ST_M29W200B, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29LV640, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29DL322D, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29DL323D, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29DL324D, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29DL640D, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29F800, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_AM29LV800, inactive, disabled # Implemented by CYGHWR_DEVS_FLASH_AMD_TC58FVB800, inactive, disabled # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # package CYGPKG_DEVS_FLASH_AMD_AM29XXXXX # Requires: CYGINT_DEVS_FLASH_AMD_VARIANTS != 0 }; # AMD AM29F040B flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AMD29F040B # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29F040B { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29LV160 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AMD29LV160 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV160 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # package CYGPKG_DEVS_FLASH_OPENRISC_ORP # Requires: CYGHWR_DEVS_FLASH_AMD_AM29LV160 }; # AMD AM29LV320 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AMD29LV320 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV320D { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29LV200 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AMD29LV200 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV200 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # ST M29W200B flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the ST M29W200B part. This # memory device is pin- and software compatible with the # AMD AM29LV200 device. # cdl_option CYGHWR_DEVS_FLASH_ST_M29W200B { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29LV640 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AMD29LV640 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV640 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29DL322D flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29DL322D # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL322D { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29DL323D flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29DL323D # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL323D { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29DL324D flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29DL324D # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL324D { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29DL640D flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29DL640D # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL640D { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29F800 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29F800 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29F800 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # AMD AM29LV800 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the AM29LV800 # part in the family. # cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV800 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Toshiba TC58FVB800 flash memory support # When this option is enabled, the AMD flash driver will be # able to recognize and handle the Toshiba TC58FVB800. # cdl_option CYGHWR_DEVS_FLASH_AMD_TC58FVB800 { # This option is not active # The parent CYGPKG_DEVS_FLASH_AMD_AM29XXXXX is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # < # eCos HAL # doc: ref/the-ecos-hardware-abstraction-layer.html # The eCos HAL package provide a porting layer for # higher-level parts of the system such as the kernel and the # C library. Each installation should have HAL packages for # one or more architectures, and for each architecture there # may be one or more supported platforms. It is necessary to # select one target architecture and one platform for that # architecture. There are also a number of configuration # options that are common to all HAL packages. # cdl_package CYGPKG_HAL { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_INFRA # CYGPKG_INFRA == v2_0 # --> 1 # The following properties are affected by this value }; # > # Platform-independent HAL options # A number of configuration options are common to most or all # HAL packages, for example options controlling how much state # should be saved during a context switch. The implementations # of these options will vary from architecture to architecture. # cdl_component CYGPKG_HAL_COMMON { # There is no associated value. }; # > # Provide eCos kernel support # The HAL can be configured to either support the full eCos # kernel, or to support only very simple applications which do # not require a full kernel. If kernel support is not required # then some of the startup, exception, and interrupt handling # code can be eliminated. # cdl_option CYGFUN_HAL_COMMON_KERNEL_SUPPORT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # HAL exception support # When a processor exception occurs, for example an attempt to # execute an illegal instruction or to perform a divide by # zero, this exception may be handled in a number of different # ways. If the target system has gdb support then typically # the exception will be handled by gdb code. Otherwise if the # HAL exception support is enabled then the HAL will invoke a # routine deliver_exception(). Typically this routine will be # provided by the eCos kernel, but it is possible for # application code to provide its own implementation. If the # HAL exception support is not enabled and a processor # exception occurs then the behaviour of the system is # undefined. # cdl_option CYGPKG_HAL_EXCEPTIONS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGPKG_KERNEL_EXCEPTIONS # CYGPKG_KERNEL_EXCEPTIONS == 1 # --> 1 # Requires: CYGPKG_KERNEL_EXCEPTIONS # CYGPKG_KERNEL_EXCEPTIONS == 1 # --> 1 # The following properties are affected by this value # component CYGPKG_KERNEL_EXCEPTIONS # Requires: CYGPKG_HAL_EXCEPTIONS }; # Stop calling constructors early # This option supports environments where some constructors # must be run in the context of a thread rather than at # simple system startup time. A boolean flag named # cyg_hal_stop_constructors is set to 1 when constructors # should no longer be invoked. It is up to some other # package to deal with the rest of the constructors. # In the current version this is only possible with the # C library. # cdl_option CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS # CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS == 0 # --> 0 # The following properties are affected by this value # option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS # Requires: CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG }; # HAL uses the MMU and allows for CDL manipulation of it's use # cdl_interface CYGINT_HAL_SUPPORTS_MMU_TABLES { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGSEM_HAL_INSTALL_MMU_TABLES # ActiveIf: CYGINT_HAL_SUPPORTS_MMU_TABLES }; # Install MMU tables. # This option controls whether this application installs # its own Memory Management Unit (MMU) tables, or relies on the # existing environment to run. # cdl_option CYGSEM_HAL_INSTALL_MMU_TABLES { # This option is not active # ActiveIf constraint: CYGINT_HAL_SUPPORTS_MMU_TABLES # CYGINT_HAL_SUPPORTS_MMU_TABLES == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYG_HAL_STARTUP != "RAM" # CYG_HAL_STARTUP == ROM # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_STATIC_MMU_TABLES # Requires: CYGSEM_HAL_INSTALL_MMU_TABLES }; # Use static MMU tables. # This option defines an environment where any Memory # Management Unit (MMU) tables are constant. Normally used by ROM # based environments, this provides a way to save RAM usage which # would otherwise be required for these tables. # cdl_option CYGSEM_HAL_STATIC_MMU_TABLES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGSEM_HAL_INSTALL_MMU_TABLES # CYGSEM_HAL_INSTALL_MMU_TABLES == 0 # --> 0 }; # Route diagnostic output to debug channel # If not inheriting the console setup from the ROM monitor, # it is possible to redirect diagnostic output to the debug # channel by enabling this option. Depending on the debugger # used it may also be necessary to select a mangler for the # output to be displayed by the debugger. # cdl_component CYGDBG_HAL_DIAG_TO_DEBUG_CHAN { # ActiveIf constraint: !CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE # CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE == 0 # --> 1 # ActiveIf constraint: CYGPKG_HAL_ARM || CYGPKG_HAL_POWERPC_MPC8xx || CYGPKG_HAL_V85X_V850 || CYGSEM_HAL_VIRTUAL_VECTOR_DIAG # CYGPKG_HAL_ARM (unknown) == 0 # CYGPKG_HAL_POWERPC_MPC8xx (unknown) == 0 # CYGPKG_HAL_V85X_V850 (unknown) == 0 # CYGSEM_HAL_VIRTUAL_VECTOR_DIAG == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: (CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS || CYG_HAL_STARTUP == "RAM") ? 1 : 0 # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # CYG_HAL_STARTUP == ROM # --> 0 # The following properties are affected by this value # option CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE # Calculated: !CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE && !CYGDBG_HAL_DIAG_TO_DEBUG_CHAN }; # > # Mangler used on diag output # It is sometimes necessary to mangle (encode) the # diag ASCII text output in order for it to show up at the # other end. In particular, GDB may silently ignore raw # ASCII text. # cdl_option CYGSEM_HAL_DIAG_MANGLER { # This option is not active # The parent CYGDBG_HAL_DIAG_TO_DEBUG_CHAN is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value GDB # value_source default # Default value: GDB # Legal values: "GDB" "None" }; # < # < # HAL interrupt handling # A number of configuration options related to interrupt # handling are common to most or all HAL packages, even though # the implementations will vary from architecture to # architecture. # cdl_component CYGPKG_HAL_COMMON_INTERRUPTS { # There is no associated value. }; # > # Use separate stack for interrupts # When an interrupt occurs this interrupt can be handled either # on the current stack or on a separate stack maintained by the # HAL. Using a separate stack requires a small number of extra # instructions in the interrupt handling code, but it has the # advantage that it is no longer necessary to allow extra space # in every thread stack for the interrupt handlers. The amount # of extra space required depends on the interrupt handlers # that are being used. # cdl_option CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Interrupt stack size # This configuration option specifies the stack size in bytes # for the interrupt stack. Typically this should be a multiple # of 16, but the exact requirements will vary from architecture # to architecture. The interrupt stack serves two separate # purposes. It is used as the stack during system # initialization. In addition, if the interrupt system is # configured to use a separate stack then all interrupts will # be processed on this stack. The exact memory requirements # will vary from application to application, and will depend # heavily on whether or not other interrupt-related options, # for example nested interrupts, are enabled. On most targets, # in a configuration with no kernel this stack will also be # the stack used to invoke the application, and must obviously # be appropriately large in that case. # cdl_option CYGNUM_HAL_COMMON_INTERRUPTS_STACK_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 4096 # value_source default # Default value: CYGPKG_KERNEL ? 4096 : 32768 # CYGPKG_KERNEL == v2_0 # --> 4096 # Legal values: 1024 to 1048576 }; # Allow nested interrupts # When an interrupt occurs the HAL interrupt handling code can # either leave interrupts disabled for the duration of the # interrupt handling code, or by doing some extra work it can # reenable interrupts before invoking the interrupt handler and # thus allow nested interrupts to happen. If all the interrupt # handlers being used are small and do not involve any loops # then it is usually better to disallow nested interrupts. # However if any of the interrupt handlers are more complicated # than nested interrupts will usually be required. # cdl_option CYGSEM_HAL_COMMON_INTERRUPTS_ALLOW_NESTING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Save minimum context on interrupt # The HAL interrupt handling code can exploit the calling conventions # defined for a given architecture to reduce the amount of state # that has to be saved. Generally this improves performance and # reduces code size. However it can make source-level debugging # more difficult. # cdl_option CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: ! CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT }; # Chain all interrupts together # Interrupts can be attached to vectors either singly, or be # chained together. The latter is necessary if there is no way # of discovering which device has interrupted without # inspecting the device itself. It can also reduce the amount # of RAM needed for interrupt decoding tables and code. # cdl_option CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGIMP_KERNEL_INTERRUPTS_CHAIN # Requires: CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN }; # Ignore spurious [fleeting] interrupts # On some hardware, interrupt sources may not be de-bounced or # de-glitched. Rather than try to handle these interrupts (no # handling may be possible), this option allows the HAL to simply # ignore them. In most cases, if the interrupt is real it will # reoccur in a detectable form. # cdl_option CYGIMP_HAL_COMMON_INTERRUPTS_IGNORE_SPURIOUS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # HAL context switch support # A number of configuration options related to thread contexts # are common to most or all HAL packages, even though the # implementations will vary from architecture to architecture. # cdl_component CYGPKG_HAL_COMMON_CONTEXT { # There is no associated value. # The following properties are affected by this value }; # > # Use minimum thread context # The thread context switch code can exploit the calling # conventions defined for a given architecture to reduce the # amount of state that has to be saved during a context # switch. Generally this improves performance and reduces # code size. However it can make source-level debugging more # difficult. # cdl_option CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: ! CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM }; # < # Explicit control over cache behaviour # These options let the default behaviour of the caches # be easily configurable. # cdl_component CYGPKG_HAL_CACHE_CONTROL { # There is no associated value. }; # > # Enable DATA cache on startup # Enabling this option will cause the data cache to be enabled # as soon as practicable when eCos starts up. One would choose # to disable this if the data cache cannot safely be turned on, # such as a case where the cache(s) require additional platform # specific setup. # cdl_component CYGSEM_HAL_ENABLE_DCACHE_ON_STARTUP { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # DATA cache mode on startup # This option controls the mode the cache will be set to # when enabled on startup. # cdl_option CYGSEM_HAL_DCACHE_STARTUP_MODE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value COPYBACK # value_source default # Default value: COPYBACK # Legal values: "COPYBACK" "WRITETHRU" }; # < # Enable INSTRUCTION cache on startup # Enabling this option will cause the instruction cache to be enabled # as soon as practicable when eCos starts up. One would choose # to disable this if the instruction cache cannot safely be turned on, # such as a case where the cache(s) require additional platform # specific setup. # cdl_option CYGSEM_HAL_ENABLE_ICACHE_ON_STARTUP { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Source-level debugging support # If the source level debugger gdb is to be used for debugging # application code then it may be necessary to configure in support # for this in the HAL. # cdl_component CYGPKG_HAL_DEBUG { # There is no associated value. }; # > # Support for GDB stubs # The HAL implements GDB stubs for the target. # cdl_interface CYGINT_HAL_DEBUG_GDB_STUBS { # Implemented by CYGPKG_HAL_OPENRISC_ORP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # ActiveIf: CYGINT_HAL_DEBUG_GDB_STUBS }; # Include GDB stubs in HAL # This option causes a set of GDB stubs to be included into the # system. On some target systems the GDB support will be # provided by other means, for example by a ROM monitor. On # other targets, especially when building a ROM-booting system, # the necessary support has to go into the target library # itself. When GDB stubs are include in a configuration, HAL # serial drivers must also be included. # cdl_option CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS { # ActiveIf constraint: CYGINT_HAL_DEBUG_GDB_STUBS # CYGINT_HAL_DEBUG_GDB_STUBS == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: ! CYGSEM_HAL_USE_ROM_MONITOR # CYGSEM_HAL_USE_ROM_MONITOR == 0 # --> 1 # Requires: !CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # CYGSEM_HAL_VIRTUAL_VECTOR_DIAG == 1 # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS == 1 # --> 1 # The following properties are affected by this value # component CYGDBG_HAL_DIAG_TO_DEBUG_CHAN # DefaultValue: (CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS || CYG_HAL_STARTUP == "RAM") ? 1 : 0 # option CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # DefaultValue: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT # ActiveIf: CYGSEM_HAL_USE_ROM_MONITOR || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT # DefaultValue: !CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGBLD_BUILD_COMMON_GDB_STUBS # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGPKG_HAL_GDB_FILEIO # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGBLD_BUILD_GDB_STUBS # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS }; # Support for external break support in GDB stubs # The HAL implements external break (or asynchronous interrupt) # in the GDB stubs for the target. # cdl_interface CYGINT_HAL_DEBUG_GDB_STUBS_BREAK { # Implemented by CYGPKG_HAL_OPENRISC_ORP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # ActiveIf: CYGINT_HAL_DEBUG_GDB_STUBS_BREAK }; # Include GDB external break support for stubs # This option causes the GDB stub to add a serial interrupt handler # which will listen for GDB break packets. This lets you stop the # target asynchronously when using GDB, usually by hitting Control+C # or pressing the STOP button. This option differs from # CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT in that it is used when # GDB stubs are present. # cdl_option CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT { # ActiveIf constraint: CYGINT_HAL_DEBUG_GDB_STUBS_BREAK # CYGINT_HAL_DEBUG_GDB_STUBS_BREAK == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT # Requires: !CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # option CYGBLD_BUILD_GDB_STUBS # Requires: ! CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT }; # Platform does not support CTRLC # cdl_interface CYGINT_HAL_DEBUG_GDB_CTRLC_UNSUPPORTED { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT # ActiveIf: CYGINT_HAL_DEBUG_GDB_CTRLC_UNSUPPORTED == 0 }; # Include GDB external break support when no stubs # This option adds an interrupt handler for the GDB serial line # which will listen for GDB break packets. This lets you stop the # target asynchronously when using GDB, usually by hitting Control+C # or pressing the STOP button. This option differs from # CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT in that it is used when the GDB # stubs are NOT present. # cdl_option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT { # This option is not active # ActiveIf constraint: CYGSEM_HAL_USE_ROM_MONITOR || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGSEM_HAL_USE_ROM_MONITOR == 0 # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 # ActiveIf constraint: CYGINT_HAL_DEBUG_GDB_CTRLC_UNSUPPORTED == 0 # CYGINT_HAL_DEBUG_GDB_CTRLC_UNSUPPORTED == 0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: !CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 1 # Requires: !CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT # CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT == 0 # --> 1 }; # Include GDB multi-threading debug support # This option enables some extra HAL code which is needed # to support multi-threaded source level debugging. # cdl_option CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT { # ActiveIf constraint: CYGSEM_HAL_ROM_MONITOR || CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT # CYGSEM_HAL_ROM_MONITOR == 1 # CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: ! CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT # option CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT # Requires: CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT }; # Number of times to retry sending a $O packet # This option controls the number of attempts that eCos programs # will make to send a $O packet to a host GDB process. If it is # set non-zero, then the target process will attempt to resend the # $O packet data up to this number of retries. Caution: use of # this option is not recommended as it can thoroughly confuse the # host GDB process. # cdl_option CYGNUM_HAL_DEBUG_GDB_PROTOCOL_RETRIES { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Timeout period for GDB packets # This option controls the time (in milliseconds) that eCos programs # will wait for a response when sending packets to a host GDB process. # If this time elapses, then the packet will be resent, up to some # maximum number of times (CYGNUM_HAL_DEBUG_GDB_PROTOCOL_RETRIES). # cdl_option CYGNUM_HAL_DEBUG_GDB_PROTOCOL_TIMEOUT { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 500 # value_source default # Default value: 500 }; # < # ROM monitor support # Support for ROM monitors can be built in to your application. # It may also be relevant to build your application as a ROM monitor # itself. Such options are contained here if relevant for your chosen # platform. The options and ROM monitors available to choose are # platform-dependent. # cdl_component CYGPKG_HAL_ROM_MONITOR { # There is no associated value. # The following properties are affected by this value }; # > # Target has virtual vector support # cdl_interface CYGINT_HAL_VIRTUAL_VECTOR_SUPPORT { # Implemented by CYGPKG_HAL_OPENRISC_ORP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # The following properties are affected by this value # component CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT # ActiveIf: CYGINT_HAL_VIRTUAL_VECTOR_SUPPORT }; # Target supports baud rate control via vectors # Whether this target supports the __COMMCTL_GETBAUD # and __COMMCTL_SETBAUD virtual vector comm control operations. # cdl_interface CYGINT_HAL_VIRTUAL_VECTOR_COMM_BAUD_SUPPORT { # Implemented by CYGPKG_HAL_OPENRISC_ORP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # The following properties are affected by this value }; # Enable use of virtual vector calling interface # Virtual vector support allows the HAL to let the ROM # monitor handle certain operations. The virtual vector table # defines a calling interface between applications running in # RAM and the ROM monitor. # cdl_component CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT { # ActiveIf constraint: CYGINT_HAL_VIRTUAL_VECTOR_SUPPORT # CYGINT_HAL_VIRTUAL_VECTOR_SUPPORT == 1 # --> 1 # Calculated value: 1 # Flavor: bool # Current value: 1 }; # > # Inherit console settings from ROM monitor # When this option is set, the application will inherit # the console as set up by the ROM monitor. This means # that the application will use whatever channel and # mangling style was used by the ROM monitor when # the application was launched. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE { # This option is not active # ActiveIf constraint: CYGSEM_HAL_USE_ROM_MONITOR # CYGSEM_HAL_USE_ROM_MONITOR == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: !CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS == 1 # --> 0 # The following properties are affected by this value # component CYGDBG_HAL_DIAG_TO_DEBUG_CHAN # ActiveIf: !CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE # option CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE # Calculated: !CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE && !CYGDBG_HAL_DIAG_TO_DEBUG_CHAN }; # Debug channel is configurable # This option is a configuration hint - it is enabled # when the HAL initialization code will make use # of the debug channel configuration option. # cdl_option CYGPRI_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_CONFIGURABLE { # Calculated value: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS == 1 # Flavor: bool # Current value: 1 # The following properties are affected by this value # option CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL # ActiveIf: CYGPRI_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_CONFIGURABLE }; # Console channel is configurable # This option is a configuration hint - it is enabled # when the HAL initialization code will make use # of the console channel configuration option. # cdl_option CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE { # Calculated value: !CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE && !CYGDBG_HAL_DIAG_TO_DEBUG_CHAN # CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE == 0 # CYGDBG_HAL_DIAG_TO_DEBUG_CHAN == 0 # Flavor: bool # Current value: 1 # The following properties are affected by this value # option CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL # ActiveIf: CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE }; # Initialize whole of virtual vector table # This option will cause the whole of the virtual # vector table to be initialized with dummy values on # startup. When this option is enabled, all the # options below must also be enabled - or the # table would be empty when the application # launches. # On targets where older ROM monitors without # virtual vector support may still be in use, it is # necessary for RAM applictions to initialize the # table (since all HAL diagnostics and debug IO # happens via the table). # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYG_HAL_STARTUP != "RAM" || !CYGSEM_HAL_USE_ROM_MONITOR # CYG_HAL_STARTUP == ROM # CYGSEM_HAL_USE_ROM_MONITOR == 0 # --> 1 # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET == 1 # --> 1 # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US == 1 # --> 1 # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE == 1 # --> 1 # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA == 1 # --> 1 # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS == 1 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # ActiveIf: !CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_VERSION # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS }; # Claim virtual vector table entries by default # By default most virtual vectors will be claimed by # RAM startup configurations, meaning that the RAM # application will provide the services. The # exception is COMMS support (HAL # diagnostics/debugging IO) which is left in the # control of the ROM monitor. # The reasoning behind this is to get as much of the # code exercised during regular development so it # is known to be working the few times a new ROM # monitor or a ROM production configuration is used # - COMMS are excluded only by necessity in order to # avoid breaking an existing debugger connections # (there may be ways around this). # For production RAM configurations this option can # be switched off, causing the appliction to rely on # the ROM monitor for these services, thus # saving some space. # Individual vectors may also be left unclaimed, # controlled by the below options (meaning that the # associated service provided by the ROM monitor # will be used). # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT { # This option is not active # ActiveIf constraint: !CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA # DefaultValue: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT }; # Claim reset virtual vectors # This option will cause the reset and kill_by_reset # virtual vectors to be claimed. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT == 0 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET }; # Claim version virtual vectors # This option will cause the version # virtual vectors to be claimed. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_VERSION { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # --> 1 }; # Claim delay_us virtual vector # This option will cause the delay_us # virtual vector to be claimed. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT == 0 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US }; # Claim cache virtual vectors # This option will cause the cache virtual vectors # to be claimed. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT == 0 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_CACHE }; # Claim data virtual vectors # This option will cause the data virtual vectors # to be claimed. At present there is only one, used # by the RedBoot ethernet driver to share diag output. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DEFAULT == 0 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA }; # Claim comms virtual vectors # This option will cause the communication tables # that are part of the virtual vectors mechanism to # be claimed. Note that doing this may cause an # existing ROM monitor communication connection to # be closed. For this reason, the option is disabled # per default for normal application # configurations. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE == 1 # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 1 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # Requires: !CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # option CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE # DefaultValue: !CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # option CYGPRI_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_CONFIGURABLE # Calculated: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # Requires: CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS }; # Do diagnostic IO via virtual vector table # All HAL IO happens via the virtual vector table / comm # tables when those tables are supported by the HAL. # If so desired, the low-level IO functions can # still be provided by the RAM application by # enabling the CLAIM_COMMS option. # cdl_option CYGSEM_HAL_VIRTUAL_VECTOR_DIAG { # Calculated value: 1 # Flavor: bool # Current value: 1 # The following properties are affected by this value # component CYGDBG_HAL_DIAG_TO_DEBUG_CHAN # ActiveIf: CYGPKG_HAL_ARM || CYGPKG_HAL_POWERPC_MPC8xx || CYGPKG_HAL_V85X_V850 || CYGSEM_HAL_VIRTUAL_VECTOR_DIAG # option CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # Requires: !CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS }; # < # Work with a ROM monitor # Support can be enabled for three different varieties of ROM monitor. # This support changes various eCos semantics such as the encoding # of diagnostic output, or the overriding of hardware interrupt # vectors. # Firstly there is "Generic" support which prevents the HAL # from overriding the hardware vectors that it does not use, to # instead allow an installed ROM monitor to handle them. This is # the most basic support which is likely to be common to most # implementations of ROM monitor. # "CygMon" provides support for the Cygnus ROM Monitor. # And finally, "GDB_stubs" provides support when GDB stubs are # included in the ROM monitor or boot ROM. # cdl_option CYGSEM_HAL_USE_ROM_MONITOR { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: CYG_HAL_STARTUP == "RAM" ? "CygMon" : 0 # CYG_HAL_STARTUP == ROM # --> 0 0 # Legal values: "Generic" "CygMon" "GDB_stubs" # Requires: CYG_HAL_STARTUP == "RAM" # CYG_HAL_STARTUP == ROM # --> 0 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # Requires: ! CYGSEM_HAL_USE_ROM_MONITOR # option CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT # ActiveIf: CYGSEM_HAL_USE_ROM_MONITOR || CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # option CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE # ActiveIf: CYGSEM_HAL_USE_ROM_MONITOR # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # DefaultValue: CYG_HAL_STARTUP != "RAM" || !CYGSEM_HAL_USE_ROM_MONITOR }; # Behave as a ROM monitor # Enable this option if this program is to be used as a ROM monitor, # i.e. applications will be loaded into RAM on the board, and this # ROM monitor may process exceptions or interrupts generated from the # application. This enables features such as utilizing a separate # interrupt stack when exceptions are generated. # cdl_option CYGSEM_HAL_ROM_MONITOR { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYG_HAL_STARTUP == "ROM" # CYG_HAL_STARTUP == ROM # --> 1 # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: CYGSEM_HAL_ROM_MONITOR # option CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT # ActiveIf: CYGSEM_HAL_ROM_MONITOR || CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT }; # < # Platform defined I/O channels. # Platforms which provide additional I/O channels can implement # this interface, indicating that the function plf_if_init() # needs to be called. # cdl_interface CYGINT_HAL_PLF_IF_INIT { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Platform IDE I/O support. # Platforms which provide IDE controllers can implement # this interface, indicating that IDE I/O macros are # available. # cdl_interface CYGINT_HAL_PLF_IF_IDE { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # File I/O operations via GDB # This option enables support for various file I/O # operations using the GDB remote protocol to communicate # with GDB. The operations are then performed on the # debugging host by proxy. These operations are only # currently available by using a system call interface # to RedBoot. This may change in the future. # cdl_option CYGPKG_HAL_GDB_FILEIO { # This option is not active # ActiveIf constraint: CYGSEM_REDBOOT_BSP_SYSCALLS # CYGSEM_REDBOOT_BSP_SYSCALLS (unknown) == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS # CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS == 0 # --> 0 }; # Build Compiler sanity checking tests # Enabling this option causes compiler tests to be built. # cdl_option CYGPKG_HAL_BUILD_COMPILER_TESTS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # component CYGPKG_HAL_TESTS # Calculated: "tests/context tests/basic" # . ((!CYGINT_HAL_TESTS_NO_CACHES) ? " tests/cache" : "") # . ((CYGPKG_HAL_BUILD_COMPILER_TESTS) ? " tests/cpp1 tests/vaargs" : "") # . ((!CYGVAR_KERNEL_COUNTERS_CLOCK) ? " tests/intr" : "") }; # Common HAL tests # This option specifies the set of tests for the common HAL. # cdl_component CYGPKG_HAL_TESTS { # Calculated value: "tests/context tests/basic" # . ((!CYGINT_HAL_TESTS_NO_CACHES) ? " tests/cache" : "") # . ((CYGPKG_HAL_BUILD_COMPILER_TESTS) ? " tests/cpp1 tests/vaargs" : "") # . ((!CYGVAR_KERNEL_COUNTERS_CLOCK) ? " tests/intr" : "") # CYGINT_HAL_TESTS_NO_CACHES == 0 # CYGPKG_HAL_BUILD_COMPILER_TESTS == 0 # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # Flavor: data # Current_value: tests/context tests/basic tests/cache }; # > # Interface for cache presence # Some architectures and/or platforms do not have caches. By # implementing this interface, these can disable the various # cache-related tests. # cdl_interface CYGINT_HAL_TESTS_NO_CACHES { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # The following properties are affected by this value # component CYGPKG_HAL_TESTS # Calculated: "tests/context tests/basic" # . ((!CYGINT_HAL_TESTS_NO_CACHES) ? " tests/cache" : "") # . ((CYGPKG_HAL_BUILD_COMPILER_TESTS) ? " tests/cpp1 tests/vaargs" : "") # . ((!CYGVAR_KERNEL_COUNTERS_CLOCK) ? " tests/intr" : "") # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # }; # < # OpenRISC architecture # The OpenRISC architecture HAL package provides generic support # for this processor architecture. It is also necessary to # select a specific target platform HAL package. # cdl_package CYGPKG_HAL_OPENRISC { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 current # The following properties are affected by this value }; # > # Linker script # cdl_option CYGBLD_LINKER_SCRIPT { # Calculated value: "src/openrisc.ld" # Flavor: data # Current_value: src/openrisc.ld }; # CPU frequency # This option contains the frequency of the CPU in MegaHertz. # Choose the frequency to match the processor you have. This # may affect thing like serial device, interval clock and # memory access speed settings. # cdl_option CYGHWR_HAL_OPENRISC_CPU_FREQ { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 104 # value_source default # Default value: 104 # Legal values: 0 to 1000000 # The following properties are affected by this value # option CYGNUM_HAL_RTC_PERIOD # DefaultValue: CYGHWR_HAL_OPENRISC_CPU_FREQ * 1000000 / CYGNUM_HAL_RTC_DENOMINATOR }; # OpenRISC Reference Platform # The ORP HAL package should be used when targetting the # OpenRISC Reference Platform. # cdl_package CYGPKG_HAL_OPENRISC_ORP { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 current # The following properties are affected by this value # package CYGPKG_DEVS_FLASH_OPENRISC_ORP # Requires: CYGPKG_HAL_OPENRISC_ORP }; # > # Startup type # Selects whether code initially runs from ROM or RAM. In the case of ROM startup, # it's possible for the code to be copied into RAM and executed there. # cdl_component CYG_HAL_STARTUP { # Flavor: data # No user value, uncomment the following line to provide one. # user_value ROM # value_source default # Default value: ROM # Legal values: "RAM" "ROM" # The following properties are affected by this value # option CYGBLD_BUILD_GDB_STUBS # Requires: CYG_HAL_STARTUP == "ROM" # component CYGHWR_MEMORY_LAYOUT # Calculated: CYG_HAL_STARTUP == "RAM" ? "openrisc_orp_ram" : "openrisc_orp_rom" # option CYGHWR_MEMORY_LAYOUT_LDI # Calculated: CYG_HAL_STARTUP == "RAM" ? "" : "" # option CYGHWR_MEMORY_LAYOUT_H # Calculated: CYG_HAL_STARTUP == "RAM" ? "" : "" # option CYGSEM_HAL_USE_ROM_MONITOR # DefaultValue: CYG_HAL_STARTUP == "RAM" ? "CygMon" : 0 # option CYGSEM_HAL_USE_ROM_MONITOR # Requires: CYG_HAL_STARTUP == "RAM" # option CYGSEM_HAL_ROM_MONITOR # Requires: CYG_HAL_STARTUP == "ROM" # option CYGSEM_HAL_INSTALL_MMU_TABLES # DefaultValue: CYG_HAL_STARTUP != "RAM" # component CYGDBG_HAL_DIAG_TO_DEBUG_CHAN # DefaultValue: (CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS || CYG_HAL_STARTUP == "RAM") ? 1 : 0 # option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE # DefaultValue: CYG_HAL_STARTUP != "RAM" || !CYGSEM_HAL_USE_ROM_MONITOR }; # Diagnostic serial port baud rate # This option selects the baud rate used for the diagnostic console. # Note: this should match the value chosen for the GDB port if the # diagnostic and GDB port are the same. # Note: very high baud rates are useful during simulation. # cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 115200 # value_source default # Default value: 115200 # Legal values: 9600 19200 38400 57600 115200 230400 460800 921600 }; # GDB serial port baud rate # This option controls the baud rate used for the GDB connection. # Note: very high baud rates are useful during simulation. # cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_BAUD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 115200 # value_source default # Default value: 115200 # Legal values: 9600 19200 38400 57600 115200 230400 460800 921600 }; # Real-time clock constants. # cdl_component CYGNUM_HAL_RTC_CONSTANTS { # There is no associated value. }; # > # Real-time clock numerator # cdl_option CYGNUM_HAL_RTC_NUMERATOR { # Calculated value: 1000000000 # Flavor: data # Current_value: 1000000000 }; # Real-time clock denominator # cdl_option CYGNUM_HAL_RTC_DENOMINATOR { # Calculated value: 100 # Flavor: data # Current_value: 100 # The following properties are affected by this value # option CYGNUM_HAL_RTC_PERIOD # DefaultValue: CYGHWR_HAL_OPENRISC_CPU_FREQ * 1000000 / CYGNUM_HAL_RTC_DENOMINATOR }; # Real-time clock period # The tick timer facility is used # to drive the eCos kernel RTC. The count register # increments at the CPU clock speed. By default, 100 Hz # cdl_option CYGNUM_HAL_RTC_PERIOD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 1040000 # value_source default # Default value: CYGHWR_HAL_OPENRISC_CPU_FREQ * 1000000 / CYGNUM_HAL_RTC_DENOMINATOR # CYGHWR_HAL_OPENRISC_CPU_FREQ == 104 # CYGNUM_HAL_RTC_DENOMINATOR == 100 # --> 1040000 }; # < # Number of breakpoints supported by the HAL. # This option determines the number of breakpoints supported by the HAL. # cdl_option CYGNUM_HAL_BREAKPOINT_LIST_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 25 # value_source default # Default value: 25 }; # Number of communication channels on the board # cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL # LegalValues: 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 # option CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL # LegalValues: 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 }; # Debug serial port # The ORP platform has at least one serial port, but it can potentially have several. # This option chooses which port will be used to connect to a host # running GDB. # cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL { # ActiveIf constraint: CYGPRI_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_CONFIGURABLE # CYGPRI_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_CONFIGURABLE == 1 # --> 1 # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 # CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS == 1 }; # Diagnostic serial port # The ORP platform has at least one serial port, but it can potentially have several. # This option chooses which port will be used for diagnostic output. # cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL { # ActiveIf constraint: CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE # CYGPRI_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_CONFIGURABLE == 1 # --> 1 # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 # CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS == 1 }; # Memory layout # cdl_component CYGHWR_MEMORY_LAYOUT { # Calculated value: CYG_HAL_STARTUP == "RAM" ? "openrisc_orp_ram" : "openrisc_orp_rom" # CYG_HAL_STARTUP == ROM # Flavor: data # Current_value: openrisc_orp_rom }; # > # Memory layout linker script fragment # cdl_option CYGHWR_MEMORY_LAYOUT_LDI { # Calculated value: CYG_HAL_STARTUP == "RAM" ? "" : "" # CYG_HAL_STARTUP == ROM # Flavor: data # Current_value: }; # Memory layout header file # cdl_option CYGHWR_MEMORY_LAYOUT_H { # Calculated value: CYG_HAL_STARTUP == "RAM" ? "" : "" # CYG_HAL_STARTUP == ROM # Flavor: data # Current_value: }; # < # < # < # < # I/O sub-system # doc: ref/io.html # The eCos system is supplied with a number of different # device drivers. This option enables the basic I/O system # support which is the basis for all drivers. # cdl_package CYGPKG_IO { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ERROR # CYGPKG_ERROR == v2_0 # --> 1 # The following properties are affected by this value # package CYGPKG_IO_SERIAL # ActiveIf: CYGPKG_IO # package CYGPKG_LIBC_STDIO # Requires: CYGPKG_IO }; # > # Debug I/O sub-system # This option enables verbose messages to be displayed on the # system 'diag' device during I/O system initialization. # cdl_option CYGDBG_IO_INIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Basic support for file based I/O # This option control support for simple file I/O primitives. It is only # present if the FILEIO package is not included. # cdl_component CYGPKG_IO_FILE_SUPPORT { # ActiveIf constraint: !CYGPKG_IO_FILEIO # CYGPKG_IO_FILEIO (unknown) == 0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Number of open files # This option controls the number of open files. # cdl_option CYGPKG_IO_NFILE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 16 # value_source default # Default value: 16 }; # < # < # Serial device drivers # doc: ref/io.html # This option enables drivers for basic I/O services on # serial devices. # cdl_package CYGPKG_IO_SERIAL { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # ActiveIf constraint: CYGPKG_IO # CYGPKG_IO == v2_0 # --> 1 # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ERROR # CYGPKG_ERROR == v2_0 # --> 1 }; # > # Support non-blocking read and write calls # This option enables extra code in the generic serial driver # which allows clients to switch read() and write() call # semantics from blocking to non-blocking. # cdl_option CYGOPT_IO_SERIAL_SUPPORT_NONBLOCKING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Driver requires block transfer callback functions # Some low-level drivers can be optimized to transfer blocks # of data instead of a single character at a time. These usually # rely on a hardware FIFO of some sort. # cdl_interface CYGINT_IO_SERIAL_BLOCK_TRANSFER { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Serial driver supports line status # cdl_interface CYGINT_IO_SERIAL_LINE_STATUS_HW { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # Requires: CYGINT_IO_SERIAL_LINE_STATUS_HW > 0 # option CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # DefaultValue: 0 != CYGINT_IO_SERIAL_LINE_STATUS_HW }; # Support line status callbacks # This option indicates that if the serial driver supports it, # serial line status and modem status information should be # propagated to higher layers via callbacks. # cdl_option CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 != CYGINT_IO_SERIAL_LINE_STATUS_HW # CYGINT_IO_SERIAL_LINE_STATUS_HW == 0 # --> 0 # Requires: CYGINT_IO_SERIAL_LINE_STATUS_HW > 0 # CYGINT_IO_SERIAL_LINE_STATUS_HW == 0 # --> 0 # The following properties are affected by this value # option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW # Requires: CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW # DefaultValue: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 ? CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS : 0 }; # Flow control # This component contains options related to flow control. # cdl_component CYGPKG_IO_SERIAL_FLOW_CONTROL { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: (CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE || CYGOPT_IO_SERIAL_FLOW_CONTROL_HW) # CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE == 0 # CYGOPT_IO_SERIAL_FLOW_CONTROL_HW == 0 # --> 0 }; # > # Software flow control # This component enables support of software flow control. # cdl_component CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE { # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # component CYGPKG_IO_SERIAL_FLOW_CONTROL # Requires: (CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE || CYGOPT_IO_SERIAL_FLOW_CONTROL_HW) }; # > # Start character # This option specifies the ascii character used to # indicate that transmission should start. # cdl_option CYGDAT_IO_SERIAL_FLOW_CONTROL_XON_CHAR { # This option is not active # The parent CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE is not active # Flavor: data # No user value, uncomment the following line to provide one. # user_value 17 # value_source default # Default value: 17 # Legal values: 0 to 255 }; # Stop character # This option specifies the ascii character used to # indicate that transmission should stop. # cdl_option CYGDAT_IO_SERIAL_FLOW_CONTROL_XOFF_CHAR { # This option is not active # The parent CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE is not active # Flavor: data # No user value, uncomment the following line to provide one. # user_value 19 # value_source default # Default value: 19 # Legal values: 0 to 255 }; # < # Hardware flow control # If the hardware supports it, this option allows hardware # flow control to be enabled. This may be in the form of # either or both of RTS/CTS, or DSR/DTR flow control. # cdl_option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW { # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # ActiveIf constraint: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 # CYGINT_IO_SERIAL_FLOW_CONTROL_HW == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 ? CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS : 0 # CYGINT_IO_SERIAL_FLOW_CONTROL_HW == 0 # CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS == 0 # --> 0 # Requires: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 # CYGINT_IO_SERIAL_FLOW_CONTROL_HW == 0 # --> 0 # Requires: CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS == 0 # --> 0 # The following properties are affected by this value # component CYGPKG_IO_SERIAL_FLOW_CONTROL # Requires: (CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE || CYGOPT_IO_SERIAL_FLOW_CONTROL_HW) }; # Serial h/w supports hardware flow control # cdl_interface CYGINT_IO_SERIAL_FLOW_CONTROL_HW { # No options implement this inferface # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW # ActiveIf: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 # option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW # Requires: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 # option CYGOPT_IO_SERIAL_FLOW_CONTROL_HW # DefaultValue: CYGINT_IO_SERIAL_FLOW_CONTROL_HW > 0 ? CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS : 0 }; # Default flow control method # This option allows a default flow control method # to be defined. Combinations of flow control methods # may also be set, but this is only possible by # using the cyg_io_set_config() API in source code. # cdl_option CYGDAT_IO_SERIAL_FLOW_CONTROL_DEFAULT { # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value NONE # value_source default # Default value: NONE # Legal values: "NONE" "XONXOFF" "RTSCTS" "DSRDTR" }; # Rx flow control low water mark # This sets the water mark used for determining # when to disable flow control, expressed # as a percentage of the buffer size. When the # receive buffer size is lower than this percentage, # if the transmitter had previously been throttled, it # will now be informed it can restart. # cdl_option CYGNUM_IO_SERIAL_FLOW_CONTROL_LOW_WATER_PERCENT { # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 33 # value_source default # Default value: 33 # Legal values: 1 to 100 # The following properties are affected by this value # option CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT # Requires: CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT >= CYGNUM_IO_SERIAL_FLOW_CONTROL_LOW_WATER_PERCENT }; # Rx flow control high water mark # This sets the water mark used for determining # when to enable flow control, expressed # as a percentage of the buffer size. When the # receive buffer size exceeds this percentage, # signals are sent to the transmitter to tell it # to throttle tranmission. # cdl_option CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT { # This option is not active # The parent CYGPKG_IO_SERIAL_FLOW_CONTROL is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 66 # value_source default # Default value: 66 # Legal values: 1 to 100 # Requires: CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT >= CYGNUM_IO_SERIAL_FLOW_CONTROL_LOW_WATER_PERCENT # CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT == 0 # CYGNUM_IO_SERIAL_FLOW_CONTROL_LOW_WATER_PERCENT == 0 # --> 1 # The following properties are affected by this value # option CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT # Requires: CYGNUM_IO_SERIAL_FLOW_CONTROL_HIGH_WATER_PERCENT >= CYGNUM_IO_SERIAL_FLOW_CONTROL_LOW_WATER_PERCENT }; # < # TTY-mode serial device drivers # This option enables a simple terminal-like device driver # that can be used for serial devices that interact with humans, # such as a system console. # cdl_component CYGPKG_IO_SERIAL_TTY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # HAL/diag serial device driver # This option enables the use of the HAL diagnostic channel # via the standard I/O drivers. # cdl_component CYGPKG_IO_SERIAL_HALDIAG { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGPKG_IO_SERIAL_HALDIAG }; # Console device name # This option selects the TTY device to use for the console. # cdl_option CYGDAT_IO_SERIAL_TTY_CONSOLE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ttydiag\"" # value_source default # Default value: "\"/dev/ttydiag\"" # The following properties are affected by this value # option CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE # DefaultValue: CYGDAT_IO_SERIAL_TTY_CONSOLE }; # TTY mode HAL/diag channel # This option causes '/dev/ttydiag' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TTY_TTYDIAG { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # TTY mode channel #0 # This option causes '/dev/tty0' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TTY_TTY0 { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # TTY mode channel #0 device # This option selects the physical device to use for # '/dev/tty0'. # cdl_option CYGDAT_IO_SERIAL_TTY_TTY0_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TTY_TTY0 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser0\"" # value_source default # Default value: "\"/dev/ser0\"" }; # < # TTY mode channel #1 # This option causes '/dev/tty1' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TTY_TTY1 { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # TTY mode channel #1 device # This option selects the physical device to use for # '/dev/tty1'. # cdl_option CYGDAT_IO_SERIAL_TTY_TTY1_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TTY_TTY1 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser1\"" # value_source default # Default value: "\"/dev/ser1\"" }; # < # TTY mode channel #2 # This option causes '/dev/tty2' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TTY_TTY2 { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # TTY mode channel #2 device # This option selects the physical device to use for # '/dev/tty2'. # cdl_option CYGDAT_IO_SERIAL_TTY_TTY2_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TTY_TTY2 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser2\"" # value_source default # Default value: "\"/dev/ser2\"" }; # < # < # Termios compatible TTY drivers # This option enables terminal drivers compatible with # POSIX termios. # cdl_component CYGPKG_IO_SERIAL_TERMIOS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 != CYGPKG_ISOINFRA && 0 != CYGPKG_IO_FILEIO && 0 != CYGINT_ISO_ERRNO_CODES && 0 != CYGINT_ISO_ERRNO # CYGPKG_ISOINFRA == v2_0 # CYGPKG_IO_FILEIO (unknown) == 0 # CYGINT_ISO_ERRNO_CODES == 1 # CYGINT_ISO_ERRNO == 1 # --> 0 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGPKG_IO_FILEIO # CYGPKG_IO_FILEIO (unknown) == 0 # --> 0 # Requires: CYGINT_ISO_ERRNO_CODES # CYGINT_ISO_ERRNO_CODES == 1 # --> 1 # Requires: CYGINT_ISO_ERRNO # CYGINT_ISO_ERRNO == 1 # --> 1 # Requires: CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 }; # > # Interface for termios tty driver file enabling # cdl_interface CYGINT_IO_SERIAL_TERMIOS_TERMIOS_TTY { # Implemented by CYGPKG_IO_SERIAL_TERMIOS_TERMIOS0, inactive, disabled # Implemented by CYGPKG_IO_SERIAL_TERMIOS_TERMIOS1, inactive, disabled # Implemented by CYGPKG_IO_SERIAL_TERMIOS_TERMIOS2, inactive, disabled # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGBLD_IO_SERIAL_TERMIOS_TERMIOS_TTY # ActiveIf: CYGINT_IO_SERIAL_TERMIOS_TERMIOS_TTY > 0 }; # Build termios tty driver file # cdl_option CYGBLD_IO_SERIAL_TERMIOS_TERMIOS_TTY { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # ActiveIf constraint: CYGINT_IO_SERIAL_TERMIOS_TERMIOS_TTY > 0 # CYGINT_IO_SERIAL_TERMIOS_TERMIOS_TTY == 0 # --> 0 # Calculated value: 1 # Flavor: bool # Current value: 1 }; # Termios TTY channel #0 # This option causes '/dev/termios0' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TERMIOS_TERMIOS0 { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Termios TTY channel #0 device # This option selects the physical device to use for # '/dev/termios0'. # cdl_option CYGDAT_IO_SERIAL_TERMIOS_TERMIOS0_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS0 is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS0 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser0\"" # value_source default # Default value: "\"/dev/ser0\"" }; # < # Termios TTY channel #1 # This option causes '/dev/termios1' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TERMIOS_TERMIOS1 { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Termios TTY channel #1 device # This option selects the physical device to use for # '/dev/termios1'. # cdl_option CYGDAT_IO_SERIAL_TERMIOS_TERMIOS1_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS1 is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS1 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser1\"" # value_source default # Default value: "\"/dev/ser1\"" }; # < # Termios TTY channel #2 # This option causes '/dev/termios2' to be included in the standard # drivers. # cdl_component CYGPKG_IO_SERIAL_TERMIOS_TERMIOS2 { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Termios TTY channel #2 device # This option selects the physical device to use for # '/dev/termios2'. # cdl_option CYGDAT_IO_SERIAL_TERMIOS_TERMIOS2_DEV { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS2 is not active # The parent CYGPKG_IO_SERIAL_TERMIOS_TERMIOS2 is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ser2\"" # value_source default # Default value: "\"/dev/ser2\"" }; # < # Support signals # This option selects whether those parts of the termios # interface involving signals is supported. This includes # BRKINT mode, the INTR and QUIT characters, and whether # SIGHUP is sent on terminal close. # cdl_option CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS { # This option is not active # The parent CYGPKG_IO_SERIAL_TERMIOS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGINT_ISO_SIGNAL_NUMBERS != 0 && CYGINT_ISO_SIGNAL_IMPL != 0 # CYGINT_ISO_SIGNAL_NUMBERS == 1 # CYGINT_ISO_SIGNAL_IMPL == 1 # --> 1 # Requires: CYGINT_ISO_SIGNAL_NUMBERS # CYGINT_ISO_SIGNAL_NUMBERS == 1 # --> 1 # Requires: CYGINT_ISO_SIGNAL_IMPL # CYGINT_ISO_SIGNAL_IMPL == 1 # --> 1 }; # < # Hardware serial device drivers # This option enables the hardware device drivers # for the current platform. # cdl_component CYGPKG_IO_SERIAL_DEVICES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGPKG_IO_SERIAL_TESTS # Calculated: CYGPKG_IO_SERIAL_DEVICES ? "tests/serial1 tests/serial2 tests/serial3 tests/serial4 tests/serial5 tests/tty1 tests/tty2 tests/flow1 tests/flow2" : "" }; # Build extra serial tests # This option enables the building of some extra tests which # can be used when testing / debugging serial drivers. These # are not built by default since they do not use the dedicated # testing infrastructure. # cdl_option CYGBLD_IO_SERIAL_EXTRA_TESTS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Serial device driver build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_IO_SERIAL_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the serial device drivers. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_IO_SERIAL_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the serial device drivers. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_IO_SERIAL_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Serial device driver tests # This option specifies the set of tests for the serial device drivers. # cdl_option CYGPKG_IO_SERIAL_TESTS { # Calculated value: CYGPKG_IO_SERIAL_DEVICES ? "tests/serial1 tests/serial2 tests/serial3 tests/serial4 tests/serial5 tests/tty1 tests/tty2 tests/flow1 tests/flow2" : "" # CYGPKG_IO_SERIAL_DEVICES == 0 # Flavor: data # Current_value: }; # < # Enable serial device select support # This option enables support for the select() API function on all # serial devices. # cdl_option CYGPKG_IO_SERIAL_SELECT_SUPPORT { # This option is not active # ActiveIf constraint: CYGPKG_IO_FILEIO # CYGPKG_IO_FILEIO (unknown) == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_IO_FILEIO # CYGPKG_IO_FILEIO (unknown) == 0 # --> 0 }; # Serial testing specification # cdl_component CYGPKG_IO_SERIAL_TEST_SPECS { # Calculated value: 1 # Flavor: bool # Current value: 1 }; # > # Skip 9600 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_9600 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 14400 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_14400 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 19200 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_19200 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 38400 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_38400 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 57600 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_57600 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 115200 baud testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_115200 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip even-parity testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_PARITY_EVEN { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip odd-parity testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_PARITY_ODD { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # Skip 2-stop bit testing # cdl_interface CYGINT_IO_SERIAL_TEST_SKIP_STOP_2 { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 }; # < # < # Infrastructure # Common types and useful macros. # Tracing and assertion facilities. # Package startup options. # cdl_package CYGPKG_INFRA { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # package CYGPKG_HAL # Requires: CYGPKG_INFRA }; # > # Asserts & Tracing # The eCos source code contains a significant amount of # internal debugging support, in the form of assertions and # tracing. # Assertions check at runtime that various conditions are as # expected; if not, execution is halted. # Tracing takes the form of text messages that are output # whenever certain events occur, or whenever functions are # called or return. # The most important property of these checks and messages is # that they are not required for the program to run. # It is prudent to develop software with assertions enabled, # but disable them when making a product release, thus # removing the overhead of that checking. # It is possible to enable assertions and tracing # independently. # There are also options controlling the exact behaviour of # the assertion and tracing facilities, thus giving users # finer control over the code and data size requirements. # cdl_component CYGPKG_INFRA_DEBUG { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # component CYGFUN_KERNEL_THREADS_STACK_CHECKING # ActiveIf: CYGPKG_INFRA_DEBUG # component CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT # DefaultValue: 0 != CYGPKG_INFRA_DEBUG # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # }; # > # Use asserts # If this option is defined, asserts in the code are tested. # Assert functions (CYG_ASSERT()) are defined in # 'include/cyg/infra/cyg_ass.h' within the 'install' tree. # If it is not defined, these result in no additional # object code and no checking of the asserted conditions. # cdl_component CYGDBG_USE_ASSERTS { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: 1 == CYGINT_INFRA_DEBUG_TRACE_IMPL # CYGINT_INFRA_DEBUG_TRACE_IMPL == 0 # --> 0 # The following properties are affected by this value # component CYGFUN_KERNEL_THREADS_STACK_CHECKING # ActiveIf: CYGDBG_USE_ASSERTS # option CYGDBG_MEMALLOC_ALLOCATOR_DLMALLOC_DEBUG # Requires: CYGDBG_USE_ASSERTS # option CYGDBG_MEMALLOC_ALLOCATOR_DLMALLOC_DEBUG # DefaultValue: 0 != CYGDBG_USE_ASSERTS # option CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL # Requires: CYGDBG_USE_ASSERTS }; # > # Preconditions # This option allows individual control of preconditions. # A precondition is one type of assert, which it is # useful to control separately from more general asserts. # The function is CYG_PRECONDITION(condition,msg). # cdl_option CYGDBG_INFRA_DEBUG_PRECONDITIONS { # This option is not active # The parent CYGDBG_USE_ASSERTS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Postconditions # This option allows individual control of postconditions. # A postcondition is one type of assert, which it is # useful to control separately from more general asserts. # The function is CYG_POSTCONDITION(condition,msg). # cdl_option CYGDBG_INFRA_DEBUG_POSTCONDITIONS { # This option is not active # The parent CYGDBG_USE_ASSERTS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Loop invariants # This option allows individual control of loop invariants. # A loop invariant is one type of assert, which it is # useful to control separately from more general asserts, # particularly since a loop invariant is typically evaluated # a great many times when used correctly. # The function is CYG_LOOP_INVARIANT(condition,msg). # cdl_option CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS { # This option is not active # The parent CYGDBG_USE_ASSERTS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Use assert text # All assertions within eCos contain a text message # which should give some information about the condition # being tested. # These text messages will end up being embedded in the # application image and hence there is a significant penalty # in terms of image size. # It is possible to suppress the use of these messages by # disabling this option. # This results in smaller code size, but there is less # human-readable information if an assertion actually gets # triggered. # cdl_option CYGDBG_INFRA_DEBUG_ASSERT_MESSAGE { # This option is not active # The parent CYGDBG_USE_ASSERTS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Use tracing # If this option is defined, tracing operations # result in output or logging, depending on other options. # This may have adverse effects on performance, if the time # taken to output message overwhelms the available CPU # power or output bandwidth. # Trace functions (CYG_TRACE()) are defined in # 'include/cyg/infra/cyg_trac.h' within the 'install' tree. # If it is not defined, these result in no additional # object code and no trace information. # cdl_component CYGDBG_USE_TRACING { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: 1 == CYGINT_INFRA_DEBUG_TRACE_IMPL # CYGINT_INFRA_DEBUG_TRACE_IMPL == 0 # --> 0 # The following properties are affected by this value # option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_SIZE # ActiveIf: CYGDBG_USE_TRACING # option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_WRAP # ActiveIf: CYGDBG_USE_TRACING # option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_HALT # ActiveIf: CYGDBG_USE_TRACING # option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_PRINT # ActiveIf: CYGDBG_USE_TRACING # option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_PRINT_ON_ASSERT # ActiveIf: CYGDBG_USE_TRACING # option CYGDBG_KERNEL_TRACE_TIMESLICE # ActiveIf: CYGDBG_USE_TRACING # component CYGPKG_LIBM_TRACE # Requires: CYGDBG_USE_TRACING }; # > # Trace function reports # This option allows individual control of # function entry/exit tracing, independent of # more general tracing output. # This may be useful to remove clutter from a # trace log. # cdl_option CYGDBG_INFRA_DEBUG_FUNCTION_REPORTS { # This option is not active # The parent CYGDBG_USE_TRACING is not active # The parent CYGDBG_USE_TRACING is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Use trace text # All trace calls within eCos contain a text message # which should give some information about the circumstances. # These text messages will end up being embedded in the # application image and hence there is a significant penalty # in terms of image size. # It is possible to suppress the use of these messages by # disabling this option. # This results in smaller code size, but there is less # human-readable information available in the trace output, # possibly only filenames and line numbers. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_MESSAGE { # This option is not active # The parent CYGDBG_USE_TRACING is not active # The parent CYGDBG_USE_TRACING is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Trace output implementations # cdl_interface CYGINT_INFRA_DEBUG_TRACE_IMPL { # Implemented by CYGDBG_INFRA_DEBUG_TRACE_ASSERT_NULL, inactive, disabled # Implemented by CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE, inactive, disabled # Implemented by CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY, inactive, disabled # Implemented by CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER, inactive, enabled # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # component CYGDBG_USE_ASSERTS # Requires: 1 == CYGINT_INFRA_DEBUG_TRACE_IMPL # component CYGDBG_USE_TRACING # Requires: 1 == CYGINT_INFRA_DEBUG_TRACE_IMPL }; # Null output # A null output module which is useful when # debugging interactively; the output routines # can be breakpointed rather than have them actually # 'print' something. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_ASSERT_NULL { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Simple output # An output module which produces simple output # from tracing and assertion events. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGDBG_KERNEL_TRACE_TIMESLICE # Requires: !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE }; # Fancy output # An output module which produces fancy output # from tracing and assertion events. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGDBG_KERNEL_TRACE_TIMESLICE # Requires: !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY }; # Buffered tracing # An output module which buffers output # from tracing and assertion events. The stored # messages are output when an assert fires, or # CYG_TRACE_PRINT() (defined in ) # is called. # Of course, there will only be stored messages # if tracing per se (CYGDBG_USE_TRACING) # is enabled above. # cdl_component CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Trace buffer size # The size of the trace buffer. This counts the number # of trace records stored. When the buffer fills it # either wraps, stops recording, or generates output. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_SIZE { # This option is not active # The parent CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: data # No user value, uncomment the following line to provide one. # user_value 32 # value_source default # Default value: 32 # Legal values: 5 to 65535 }; # Wrap trace buffer when full # When the trace buffer has filled with records it # starts again at the beginning. Hence only the last # CYGDBG_INFRA_DEBUG_TRACE_BUFFER_SIZE messages will # be recorded. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_WRAP { # This option is not active # The parent CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Halt trace buffer when full # When the trace buffer has filled with records it # stops recording. Hence only the first # CYGDBG_INFRA_DEBUG_TRACE_BUFFER_SIZE messages will # be recorded. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_HALT { # This option is not active # The parent CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Print trace buffer when full # When the trace buffer has filled with records it # prints the contents of the buffer. The buffer is then # emptied and the system continues. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_PRINT { # This option is not active # The parent CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Print trace buffer on assert fail # When an assertion fails the trace buffer will be # printed to the default diagnostic device. # cdl_option CYGDBG_INFRA_DEBUG_TRACE_BUFFER_PRINT_ON_ASSERT { # This option is not active # The parent CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Use function names # All trace and assert calls within eCos contain a # reference to the builtin macro '__PRETTY_FUNCTION__', # which evaluates to a string containing # the name of the current function. # This is useful when reading a trace log. # It is possible to suppress the use of the function name # by disabling this option. # This results in smaller code size, but there is less # human-readable information available in the trace output, # possibly only filenames and line numbers. # cdl_option CYGDBG_INFRA_DEBUG_FUNCTION_PSEUDOMACRO { # This option is not active # The parent CYGPKG_INFRA_DEBUG is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Startup options # Some packages require a startup routine to be called. # This can be carried out by application code, by supplying # a routine called cyg_package_start() which calls the # appropriate package startup routine(s). # Alternatively, this routine can be constructed automatically # and configured to call the startup routines of your choice. # cdl_component CYGPKG_INFRA_STARTUP { # There is no associated value. }; # > # Start uITRON subsystem # Generate a call to initialize the # uITRON compatibility subsystem # within the system version of cyg_package_start(). # This enables compatibility with uITRON. # You must configure uITRON with the correct tasks before # starting the uItron subsystem. # If this is disabled, and you want to use uITRON, # you must call cyg_uitron_start() from your own # cyg_package_start() or cyg_userstart(). # cdl_option CYGSEM_START_UITRON_COMPATIBILITY { # This option is not active # ActiveIf constraint: CYGPKG_UITRON # CYGPKG_UITRON (unknown) == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGPKG_UITRON # CYGPKG_UITRON (unknown) == 0 # --> 0 }; # < # Smaller slower memcpy() # Enabling this option causes the implementation of # the standard memcpy() routine to reduce code # size at the expense of execution speed. This # option is automatically enabled with the use of # the -Os option to the compiler. Also note that # the compiler will try to use its own builtin # version of memcpy() if possible, ignoring the # implementation in this package, unless given # the -fno-builtin compiler option. # cdl_option CYGIMP_INFRA_PREFER_SMALL_TO_FAST_MEMCPY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Smaller slower memset() # Enabling this option causes the implementation of # the standard memset() routine to reduce code # size at the expense of execution speed. This # option is automatically enabled with the use of # the -Os option to the compiler. Also note that # the compiler will try to use its own builtin # version of memset() if possible, ignoring the # implementation in this package, unless given # the -fno-builtin compiler option. # cdl_option CYGIMP_INFRA_PREFER_SMALL_TO_FAST_MEMSET { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Provide empty C++ delete functions # To deal with virtual destructors, where the correct delete() # function must be called for the derived class in question, the # underlying delete is called when needed, from destructors. This # is regardless of whether the destructor is called by delete itself. # So there is a reference to delete() from all destructors. The # default builtin delete() attempts to call free() if there is # one defined. So, if you have destructors, and you have free(), # as in malloc() and free(), any destructor counts as a reference # to free(). So the dynamic memory allocation code is linked # in regardless of whether it gets explicitly called. This # increases code and data size needlessly. # To defeat this undesirable behaviour, we define empty versions # of delete and delete. But doing this prevents proper use # of dynamic memory in C++ programs via C++'s new and delete # operators. # Therefore, this option is provided # for explicitly disabling the provision of these empty functions, # so that new and delete can be used, if that is what is required. # cdl_option CYGFUN_INFRA_EMPTY_DELETE_FUNCTIONS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Provide dummy abort() function # This option controls the inclusion of a dummy abort() function. # Parts of the C and C++ compiler runtime systems contain references # to abort(), particulary in the C++ exception handling code. It is # not possible to eliminate these references, so this dummy function # in included to satisfy them. It is not expected that this function # will ever be called, so its current behaviour is to simply loop. # cdl_option CYGFUN_INFRA_DUMMY_ABORT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: CYGINT_ISO_EXIT == 0 # CYGINT_ISO_EXIT == 1 # --> 0 # Requires: !CYGINT_ISO_EXIT # CYGINT_ISO_EXIT == 1 # --> 0 }; # Provide dummy strlen() function # This option controls the inclusion of a dummy strlen() function. # Parts of the C and C++ compiler runtime systems contain references # to strlen(), particulary in the C++ exception handling code. It is # not possible to eliminate these references, so this dummy function # in included to satisfy them. While it is not expected that this function # will ever be called, it is functional but uses the simplest, smallest # algorithm. There is a faster version of strlen() in the C library. # cdl_option CYGFUN_INFRA_DUMMY_STRLEN { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: CYGINT_ISO_STRING_STRFUNCS == 0 # CYGINT_ISO_STRING_STRFUNCS == 1 # --> 0 # Requires: !CYGINT_ISO_STRING_STRFUNCS # CYGINT_ISO_STRING_STRFUNCS == 1 # --> 0 }; # Make all compiler warnings show as errors # Enabling this option will cause all compiler warnings to show # as errors and bring the library build to a halt. This is used # to ensure that the code base is warning free, and thus ensure # that newly introduced warnings stand out and get fixed before # they show up as weird run-time behavior. # cdl_option CYGBLD_INFRA_CFLAGS_WARNINGS_AS_ERRORS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: is_substr(CYGBLD_GLOBAL_CFLAGS, " -Werror") # CYGBLD_GLOBAL_CFLAGS == "-msoft-float -Wall -Wpointer-arith -Wstrict-prototypes -Winline -Wundef -Woverloaded-virtual -g -O2 -fno-omit-frame-pointer -fno-rtti -fno-exceptions -fvtable-gc -finit-priority" # --> 0 }; # Make compiler and assembler communicate by pipe # Enabling this option will cause the compiler to feed the # assembly output the the assembler via a pipe instead of # via a temporary file. This normally reduces the build # time. # cdl_option CYGBLD_INFRA_CFLAGS_PIPE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: is_substr(CYGBLD_GLOBAL_CFLAGS, " -pipe") # CYGBLD_GLOBAL_CFLAGS == "-msoft-float -Wall -Wpointer-arith -Wstrict-prototypes -Winline -Wundef -Woverloaded-virtual -g -O2 -fno-omit-frame-pointer -fno-rtti -fno-exceptions -fvtable-gc -finit-priority" # --> 0 }; # Infra build options # Package specific build options including control over # compiler flags used only in building this package. # cdl_component CYGPKG_INFRA_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the eCos infra package. These flags are used # in addition to the set of global flags. # cdl_option CYGPKG_INFRA_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the eCos infra package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_INFRA_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed linker flags # This option modifies the set of linker flags for # building the eCos infra package tests. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_INFRA_LDFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value -Wl,--gc-sections # value_source default # Default value: -Wl,--gc-sections }; # Additional linker flags # This option modifies the set of linker flags for # building the eCos infra package tests. These flags are added to # the set of global flags if present. # cdl_option CYGPKG_INFRA_LDFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value -Wl,--fatal-warnings # value_source default # Default value: -Wl,--fatal-warnings }; # Infra package tests # cdl_option CYGPKG_INFRA_TESTS { # Calculated value: "" # Flavor: data # Current_value: }; # < # < # eCos kernel # doc: ref/kernel.html # This package contains the core functionality of the eCos # kernel. It relies on functionality provided by various HAL # packages and by the eCos infrastructure. In turn the eCos # kernel provides support for other packages such as the device # drivers and the uITRON compatibility layer. # cdl_package CYGPKG_KERNEL { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # option CYGFUN_HAL_COMMON_KERNEL_SUPPORT # Requires: CYGPKG_KERNEL # option CYGFUN_HAL_COMMON_KERNEL_SUPPORT # DefaultValue: CYGPKG_KERNEL # option CYGNUM_HAL_COMMON_INTERRUPTS_STACK_SIZE # DefaultValue: CYGPKG_KERNEL ? 4096 : 32768 # option CYGSEM_MEMALLOC_ALLOCATOR_FIXED_THREADAWARE # ActiveIf: CYGPKG_KERNEL # option CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_THREADAWARE # ActiveIf: CYGPKG_KERNEL # option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE # ActiveIf: CYGPKG_KERNEL # option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE # Requires: CYGPKG_KERNEL # option CYGSEM_MEMALLOC_ALLOCATOR_SEPMETA_THREADAWARE # ActiveIf: CYGPKG_KERNEL # option CYGFUN_MEMALLOC_KAPI # ActiveIf: CYGPKG_KERNEL # option CYGSEM_LIBC_SIGNALS_THREAD_SAFE # Requires: CYGPKG_KERNEL # option CYGSEM_LIBC_STARTUP_MAIN_INITCONTEXT # DefaultValue: 0 == CYGPKG_KERNEL && 0 == # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # component CYGSEM_LIBC_STARTUP_MAIN_THREAD # Requires: CYGPKG_KERNEL # component CYGSEM_LIBC_STARTUP_MAIN_THREAD # DefaultValue: 0 != CYGPKG_KERNEL && 0 == CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # option CYGSEM_LIBC_EXIT_STOPS_SYSTEM # Requires: CYGPKG_KERNEL # option CYGSEM_LIBC_STDIO_THREAD_SAFE_STREAMS # Requires: CYGPKG_KERNEL # option CYGSEM_LIBC_STDIO_THREAD_SAFE_STREAMS # DefaultValue: 0 != CYGPKG_KERNEL # option CYGSEM_LIBC_STRING_PER_THREAD_STRTOK # ActiveIf: CYGPKG_KERNEL # option CYGPKG_WALLCLOCK_EMULATE # Requires: CYGPKG_KERNEL # option CYGIMP_WALLCLOCK_NONE # DefaultValue: !CYGPKG_KERNEL && 0 == CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS # option CYGPKG_IO_WALLCLOCK_TESTS # Calculated: CYGPKG_KERNEL ? "tests/wallclock tests/wallclock2" : "" }; # > # Kernel interrupt handling # doc: ref/kernel-interrupts.html # The majority of configuration options related to interrupt # handling are in the HAL packages, since usually the code has # to be platform-specific. There are a number of options # provided within the kernel related to slightly higher-level # concepts, for example Delayed Service Routines. # cdl_component CYGPKG_KERNEL_INTERRUPTS { # There is no associated value. # The following properties are affected by this value # option CYGDBG_KERNEL_INSTRUMENT_INTR # ActiveIf: CYGPKG_KERNEL_INTERRUPTS }; # > # Use delayed service routines (DSRs) # In eCos the recommended way to handle device interrupts is to # do a minimum amount of work inside the low level interrupt # handler itself, and instead do as much as possible in a # Delayed Service Routine or DSR. If an application does not # make use of DSRs directly or indirectly then it is possible # to disable the DSR support completely, which reduces the # overheads of context switches and interrupt handling. Note # that the kernel real-time clock makes use of DSRs, as do many # of the device drivers. # cdl_component CYGIMP_KERNEL_INTERRUPTS_DSRS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGVAR_KERNEL_COUNTERS_CLOCK # Requires: CYGIMP_KERNEL_INTERRUPTS_DSRS }; # > # cdl_interface CYGINT_KERNEL_INTERRUPTS_DSRS { # Implemented by CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST, active, enabled # Implemented by CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 == CYGINT_KERNEL_INTERRUPTS_DSRS # CYGINT_KERNEL_INTERRUPTS_DSRS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_KERNEL_INTERRUPTS_DSRS # Requires: 1 == CYGINT_KERNEL_INTERRUPTS_DSRS }; # Use linked lists for DSRs # When DSR support is enabled the kernel must keep track of all # the DSRs that are pending. This information can be kept in a # fixed-size table or in a linked list. The list implementation # requires that the kernel disable interrupts for a very short # period of time outside interrupt handlers, but there is no # possibility of a table overflow occurring. # cdl_option CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Use fixed-size table for DSRs # When DSR support is enabled the kernel must keep track of all # the DSRs that are pending. This information can be kept in a # fixed-size table or in a linked list. The table # implementation involves a very small risk of overflow at # run-time if a given interrupt source is able to have more # than one pending DSR. However it has the advantage that # the kernel does not need to disable interrupts outside # interrupt handlers. # cdl_component CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Number of entries in fixed-size DSR table # When DSR support is enabled the kernel must keep track of all # the DSRs that are pending. One approach involves a fixed-size # table, which involves a very small risk of overflow at # run-time. By increasing the table size it is possible to reduce # this risk. # cdl_option CYGNUM_KERNEL_INTERRUPTS_DSRS_TABLE_SIZE { # This option is not active # The parent CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 32 # value_source default # Default value: 32 # Legal values: 2 to 1024 }; # < # Chain all interrupts together # Interrupts can be attached to vectors either singly, or be # chained together. The latter is necessary if there is no way # of discovering which device has interrupted without # inspecting the device itself. It can also reduce the amount # of RAM needed for interrupt decoding tables and code. # cdl_option CYGIMP_KERNEL_INTERRUPTS_CHAIN { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN # CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN == 0 # --> 0 }; # < # < # Exception handling # doc: ref/kernel-exceptions.html # In the context of the eCos kernel exceptions are unexpected # events detected by the hardware, for example an attempt to # execute an illegal instruction. There is no relation with # other forms of exception, for example the catch and throw # facilities of languages like C++. It is possible to disable # all support for exceptions and thus save some memory. # cdl_component CYGPKG_KERNEL_EXCEPTIONS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_HAL_EXCEPTIONS # CYGPKG_HAL_EXCEPTIONS == 1 # --> 1 # The following properties are affected by this value # option CYGPKG_HAL_EXCEPTIONS # Requires: CYGPKG_KERNEL_EXCEPTIONS # option CYGPKG_HAL_EXCEPTIONS # DefaultValue: CYGPKG_KERNEL_EXCEPTIONS }; # > # Decode exception types in kernel # On targets where several different types of exception are # possible, for example executing an illegal instruction and # division by zero, it is possible for the kernel to do some # decoding of the exception type and deliver the different # types of exception to different handlers in the application # code. Alternatively the kernel can simply pass all # exceptions directly to application code, leaving the # decoding to be done by the application # cdl_option CYGSEM_KERNEL_EXCEPTIONS_DECODE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # component CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS # Requires: CYGSEM_KERNEL_EXCEPTIONS_DECODE }; # Use global exception handlers # In the context of the eCos kernel exceptions are # unexpected events detected by the hardware, for # example an attempt to execute an illegal # instruction. If the kernel is configured # to support exceptions then two implementations are # possible. The default implementation involves a single set # of exception handlers that are in use for the entire # system. The alternative implementation allows different # exception handlers to be specified for each thread. # cdl_option CYGSEM_KERNEL_EXCEPTIONS_GLOBAL { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # component CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS # Requires: CYGSEM_KERNEL_EXCEPTIONS_GLOBAL }; # < # Kernel schedulers # doc: ref/kernel-overview.html#KERNEL-OVERVIEW-SCHEDULERS # The eCos kernel provides a choice of schedulers. In addition # there are a number of configuration options to control the # detailed behaviour of these schedulers. # cdl_component CYGPKG_KERNEL_SCHED { # There is no associated value. # The following properties are affected by this value # option CYGDBG_KERNEL_INSTRUMENT_SCHED # ActiveIf: CYGPKG_KERNEL_SCHED }; # > # Number of schedulers in this configuration # cdl_interface CYGINT_KERNEL_SCHEDULER { # Implemented by CYGSEM_KERNEL_SCHED_MLQUEUE, active, enabled # Implemented by CYGSEM_KERNEL_SCHED_BITMAP, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 == CYGINT_KERNEL_SCHEDULER # CYGINT_KERNEL_SCHEDULER == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_KERNEL_SCHEDULER # Requires: 1 == CYGINT_KERNEL_SCHEDULER }; # Non-zero if the active schedule only has unique priorities # Not all schedulers allow mutiple threads to use the same # priority. That property is signalled via this option, allowing # scheduler and tests to behave accordingly. # cdl_interface CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES { # Implemented by CYGSEM_KERNEL_SCHED_BITMAP, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL # Requires: CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0 }; # Multi-level queue scheduler # The multi-level queue scheduler supports multiple priority # levels and multiple threads at each priority level. # Preemption between priority levels is automatic. Timeslicing # within a given priority level is controlled by a separate # configuration option. # cdl_component CYGSEM_KERNEL_SCHED_MLQUEUE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGPRI_KERNEL_SCHED_IMPL_HXX # Calculated: CYGSEM_KERNEL_SCHED_BITMAP ? "" : CYGSEM_KERNEL_SCHED_MLQUEUE ? "" : CYGSEM_KERNEL_SCHED_LOTTERY ? "" : "!!!-- Configuration broken - no scheduler selected --!!!" # component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL # ActiveIf: CYGSEM_KERNEL_SCHED_MLQUEUE }; # > # Output timeslices when tracing # When tracing is enabled, output trace messages every # timeslice. This can be quite verbose so is disabled by # default. # cdl_option CYGDBG_KERNEL_TRACE_TIMESLICE { # This option is not active # ActiveIf constraint: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE # CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE == 0 # --> 1 # Requires: !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY # CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY == 0 # --> 1 }; # < # Bitmap scheduler # The bitmap scheduler supports multiple priority levels but # only one thread can exist at each priority level. This means # that scheduling decisions are very simple and hence the # scheduler is efficient. Preemption between priority levels is # automatic. Timeslicing within a given priority level is # irrelevant since there can be only one thread at each # priority level. # cdl_option CYGSEM_KERNEL_SCHED_BITMAP { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: !CYGPKG_KERNEL_SMP_SUPPORT # CYGPKG_KERNEL_SMP_SUPPORT == 0 # --> 1 # The following properties are affected by this value # option CYGPRI_KERNEL_SCHED_IMPL_HXX # Calculated: CYGSEM_KERNEL_SCHED_BITMAP ? "" : CYGSEM_KERNEL_SCHED_MLQUEUE ? "" : CYGSEM_KERNEL_SCHED_LOTTERY ? "" : "!!!-- Configuration broken - no scheduler selected --!!!" # component CYGSEM_KERNEL_SCHED_TIMESLICE # Requires: !CYGSEM_KERNEL_SCHED_BITMAP }; # Scheduler header file # This option sets a preprocessor symbol which names the header # file for the selected scheduler. It is used internally by the # common scheduler code to include the correct header file. # cdl_option CYGPRI_KERNEL_SCHED_IMPL_HXX { # Calculated value: CYGSEM_KERNEL_SCHED_BITMAP ? "" : CYGSEM_KERNEL_SCHED_MLQUEUE ? "" : CYGSEM_KERNEL_SCHED_LOTTERY ? "" : "!!!-- Configuration broken - no scheduler selected --!!!" # CYGSEM_KERNEL_SCHED_BITMAP == 0 # CYGSEM_KERNEL_SCHED_MLQUEUE == 1 # CYGSEM_KERNEL_SCHED_LOTTERY (unknown) == 0 # Flavor: data # Current_value: }; # Number of priority levels # This option controls the number of priority levels that are # available. For some types of scheduler including the bitmap # scheduler this may impose an upper bound on the number of # threads in the system. For other schedulers such as the # mlqueue scheduler the number of threads is independent from # the number of priority levels. Note that the lowest priority # level is normally used only by the idle thread, although # application threads can run at this priority if necessary. # cdl_component CYGNUM_KERNEL_SCHED_PRIORITIES { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 32 # value_source default # Default value: 32 # Legal values: 1 to 32 # The following properties are affected by this value # option CYGIMP_IDLE_THREAD_YIELD # ActiveIf: (CYGNUM_KERNEL_SCHED_PRIORITIES == 1) # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT_PRIORITY # LegalValues: 0 to CYGNUM_KERNEL_SCHED_PRIORITIES - 1 }; # > # Bitmap size # This option automatically defines the size of bitmap # used to track occupied priority levels. # cdl_option CYGNUM_KERNEL_SCHED_BITMAP_SIZE { # Calculated value: "CYGNUM_KERNEL_SCHED_PRIORITIES" # Flavor: data # Current_value: CYGNUM_KERNEL_SCHED_PRIORITIES }; # Dequeue oldest threads first # With this option enabled, threads queued in a thread queue # will be dequeued in priority order, rather than last in, # first out (LIFO). Threads of equal priority are dequeued # oldest first. The only exception is the scheduler run # queues where order is less important as each is already # sorted by priority. Note that this makes the thread queueing # less deterministic. # cdl_option CYGIMP_KERNEL_SCHED_SORTED_QUEUES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # Scheduler timeslicing # Some schedulers including the mlqueue scheduler support # timeslicing. This means that the kernel will check regularly # whether or not there is another runnable thread with the # same priority, and if there is such a thread there will be # an automatic context switch. Not all applications require # timeslicing, for example because every thread performs a # blocking operation regularly. For these applications it is # possible to disable timeslicing, which reduces the overheads # associated with timer interrupts. # cdl_component CYGSEM_KERNEL_SCHED_TIMESLICE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: !CYGSEM_KERNEL_SCHED_BITMAP # CYGSEM_KERNEL_SCHED_BITMAP == 0 # --> 1 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 }; # > # Number of clock ticks between timeslices # Assuming timeslicing is enabled, how frequently should it # take place? The value of this option corresponds to the # number of clock ticks that should occur before a timeslice # takes place, so increasing the value reduces the frequency # of timeslices. # cdl_option CYGNUM_KERNEL_SCHED_TIMESLICE_TICKS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 5 # value_source default # Default value: 5 # Legal values: 1 to 65535 }; # Support runtime enable of timeslice per-thread # This option makes timslicing a per-thread runtime # option. When enabled, threads may have timeslicing # turned on or off dynamically. This is generally used # by higher level APIs (such as POSIX) to implement # differing scheduling policies. # cdl_option CYGSEM_KERNEL_SCHED_TIMESLICE_ENABLE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: false # false (unknown) == 0 # --> 0 }; # < # Enable ASR support # This component controls support for Asynchronous Service # Routines (ASRs). This is a function that may be called # from the scheduler when it has just exited the scheduler # lock. This is primarily for use by API compatibility layers. # cdl_component CYGSEM_KERNEL_SCHED_ASR_SUPPORT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: false # false (unknown) == 0 # --> 0 }; # > # Make ASR function global # This option controls whether the ASR function is shared by # all threads, or whether each thread may have its own ASR # function. # cdl_option CYGSEM_KERNEL_SCHED_ASR_GLOBAL { # This option is not active # The parent CYGSEM_KERNEL_SCHED_ASR_SUPPORT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: true # true (unknown) == 0 # --> 0 }; # Make ASR data global # This option controls whether the ASR data is shared by # all threads, or whether each thread may have its own ASR # data. This is independent of the previous option because # it may be useful to pass per-thread data to a shared ASR # function. # cdl_option CYGSEM_KERNEL_SCHED_ASR_DATA_GLOBAL { # This option is not active # The parent CYGSEM_KERNEL_SCHED_ASR_SUPPORT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: true # true (unknown) == 0 # --> 0 }; # < # < # SMP support # cdl_component CYGPKG_KERNEL_SMP_SUPPORT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGPKG_HAL_SMP_SUPPORT # CYGPKG_HAL_SMP_SUPPORT (unknown) == 0 # --> 0 # The following properties are affected by this value # option CYGSEM_KERNEL_SCHED_BITMAP # Requires: !CYGPKG_KERNEL_SMP_SUPPORT # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # }; # Counters and clocks # doc: ref/kernel-counters.html # The counter objects provided by the kernel provide an # abstraction of the clock facility that is generally provided. # Application code can associate alarms with counters, where an # alarm is identified by the number of ticks until it triggers, # the action to be taken on triggering, and whether or not the # alarm should be repeated. # cdl_component CYGPKG_KERNEL_COUNTERS { # There is no associated value. }; # > # Provide real-time clock # On all current target systems the kernel can provide a # real-time clock. This clock serves two purposes. First it is # necessary to support clock and alarm related functions. # Second it is needed to implement timeslicing in some of the # schedulers including the mlqueue scheduler. If the # application does not require any of these facilities then it # is possible to disable the real time clock support # completely. # cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGIMP_KERNEL_INTERRUPTS_DSRS # CYGIMP_KERNEL_INTERRUPTS_DSRS == 1 # --> 1 # The following properties are affected by this value # component CYGSEM_KERNEL_SCHED_TIMESLICE # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # component CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # option CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # option CYGFUN_KERNEL_THREADS_TIMER # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # option CYGDBG_KERNEL_INSTRUMENT_CLOCK # ActiveIf: CYGVAR_KERNEL_COUNTERS_CLOCK # option CYGDBG_KERNEL_INSTRUMENT_ALARM # ActiveIf: CYGVAR_KERNEL_COUNTERS_CLOCK # option CYGDBG_KERNEL_INSTRUMENT_SMP # ActiveIf: CYGVAR_KERNEL_COUNTERS_CLOCK # component CYGPKG_HAL_TESTS # Calculated: "tests/context tests/basic" # . ((!CYGINT_HAL_TESTS_NO_CACHES) ? " tests/cache" : "") # . ((CYGPKG_HAL_BUILD_COMPILER_TESTS) ? " tests/cpp1 tests/vaargs" : "") # . ((!CYGVAR_KERNEL_COUNTERS_CLOCK) ? " tests/intr" : "") # option CYGSEM_LIBC_TIME_CLOCK_WORKING # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK }; # Override default clock settings # The kernel has default settings for the clock interrupt # frequency. These settings will vary from platform to # platform, but typically there will be a 100 clock interrupts # every second. It is possible to change this frequency, but # it requires some knowledge of the target hardware. # cdl_component CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # The following properties are affected by this value # option CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION # Calculated: CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? "{CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR, CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR}" : "{CYGNUM_HAL_RTC_NUMERATOR, CYGNUM_HAL_RTC_DENOMINATOR}" # option CYGNUM_KERNEL_COUNTERS_RTC_PERIOD # Calculated: CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? "CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD" : "CYGNUM_HAL_RTC_PERIOD" }; # > # Clock hardware initialization value # During system initialization this value is used to initialize # the clock hardware. The exact meaning of the value and the # range of legal values therefore depends on the target hardware, # and the hardware documentation should be consulted for further # details. In addition the clock resolution numerator and # denominator values should be updated. Typical values for # this option would be 150000 on the MN10300 stdeval1 board, # 15625 on the tx39 jmr3904 board, and 20833 on the powerpc # cogent board. # cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD { # This option is not active # The parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 9999 # value_source default # Default value: 9999 # Legal values: 1 to 0x7fffffff }; # Clock resolution numerator # If a non-default clock interrupt frequency is used then it # is necessary to specify the clock resolution explicitly. # This resolution involves two separate values, the numerator # and the denominator. The result of dividing the numerator by # the denominator should correspond to the number of # nanoseconds between clock interrupts. For example a # numerator of 1000000000 and a denominator of 100 means that # there are 10000000 nanoseconds (or 10 milliseconds) between # clock interrupts. Expressing the resolution as a fraction # should minimize clock drift even for frequencies that cannot # be expressed as a simple integer. For example a frequency of # 60Hz corresponds to a clock resolution of 16666666.66... # nanoseconds. This can be expressed accurately as 1000000000 # over 60. # cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR { # This option is not active # The parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 1000000000 # value_source default # Default value: 1000000000 # Legal values: 1 to 0x7fffffff }; # Clock resolution denominator # If a non-default clock interrupt frequency is used then it # is necessary to specify the clock resolution explicitly. # This resolution involves two separate values, the numerator # and the denominator. The result of dividing the numerator by # the denominator should correspond to the number of # nanoseconds between clock interrupts. For example a # numerator of 1000000000 and a denominator of 100 means that # there are 10000000 nanoseconds (or 10 milliseconds) between # clock interrupts. Expressing the resolution as a fraction # should minimize clock drift even for frequencies that cannot # be expressed as a simple integer. For example a frequency of # 60Hz corresponds to a clock resolution of 16666666.66... # nanoseconds. This can be expressed accurately as 1000000000 # over 60. # cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR { # This option is not active # The parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 100 # value_source default # Default value: 100 # Legal values: 1 to 0x7fffffff }; # < # cdl_interface CYGINT_KERNEL_COUNTERS { # Implemented by CYGIMP_KERNEL_COUNTERS_SINGLE_LIST, active, enabled # Implemented by CYGIMP_KERNEL_COUNTERS_MULTI_LIST, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 == CYGINT_KERNEL_COUNTERS # CYGINT_KERNEL_COUNTERS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_KERNEL_COUNTERS # Requires: 1 == CYGINT_KERNEL_COUNTERS }; # Implement counters using a single list # There are two different implementations of the counter # objects. The first implementation stores all alarms in a # single linked list. The alternative implementation uses a # table of linked lists. A single list is more efficient in # terms of memory usage and is generally adequate when the # application only makes use of a small number of alarms. # cdl_option CYGIMP_KERNEL_COUNTERS_SINGLE_LIST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Implement counters using a table of lists # There are two different implementations of the counter # objects. The first implementation stores all alarms in a # single linked list. The alternative implementation uses a # table of linked lists, with the size of the table being a # separate configurable option. For more complicated # operations it is better to have a table of lists since this # reduces the amount of computation whenever the timer goes # off. Assuming a table size of 8 (the default value) on # average the timer code will only need to check 1/8 of the # pending alarms instead of all of them. # cdl_component CYGIMP_KERNEL_COUNTERS_MULTI_LIST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Size of counter list table # If counters are implemented using an array of linked lists # then this option controls the size of the array. A larger # size reduces the amount of computation that needs to take # place whenever the timer goes off, but requires extra # memory. # cdl_option CYGNUM_KERNEL_COUNTERS_MULTI_LIST_SIZE { # This option is not active # The parent CYGIMP_KERNEL_COUNTERS_MULTI_LIST is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 8 # value_source default # Default value: 8 # Legal values: 1 to 1024 }; # < # Sort the counter list # Sorting the counter lists reduces the amount of work that # has to be done when a counter tick is processed, since the # next alarm to expire is always at the front of the list. # However, it makes adding an alarm to the list more expensive # since a search must be done for the correct place to put it. # Many alarms are used to implement timeouts, which seldom trigger, # so it is worthwhile optimizing this case. For this reason # sorted list are disabled by default. # cdl_option CYGIMP_KERNEL_COUNTERS_SORT_LIST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Measure real-time [clock] interrupt latency # Measure the interrupt latency as seen by the real-time clock # timer interrupt. This requires hardware support, defined by # the HAL_CLOCK_LATENCY() macro. # cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # The following properties are affected by this value # option CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY # option CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY # DefaultValue: CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY }; # Measure real-time [clock] DSR latency # Measure the DSR latency as seen by the real-time clock # timer interrupt. This requires hardware support, defined by # the HAL_CLOCK_LATENCY() macro. # cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY # CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY == 0 # --> 0 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY # CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY == 0 # --> 0 }; # RTC resolution # This option automatically defines the tuple which is used to # initialize the RTC resolution, consisting of a numerator and # denominator. For more information, see the option to # override default clock settings # (CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE) and associated options. # cdl_option CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION { # Calculated value: CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? "{CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR, CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR}" : "{CYGNUM_HAL_RTC_NUMERATOR, CYGNUM_HAL_RTC_DENOMINATOR}" # CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE == 0 # Flavor: data # Current_value: {CYGNUM_HAL_RTC_NUMERATOR, CYGNUM_HAL_RTC_DENOMINATOR} }; # RTC period # This option automatically defines the RTC period to be used in # setting the system clock hardware. For more information, see the # option to override default clock settings # (CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE) and associated options. # cdl_option CYGNUM_KERNEL_COUNTERS_RTC_PERIOD { # Calculated value: CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? "CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD" : "CYGNUM_HAL_RTC_PERIOD" # CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE == 0 # Flavor: data # Current_value: CYGNUM_HAL_RTC_PERIOD }; # < # Thread-related options # There are a number of configuration options related to the # implementation of threads, for example whether or not the # eCos kernel supports per-thread data. # cdl_component CYGPKG_KERNEL_THREADS { # There is no associated value. # The following properties are affected by this value # option CYGDBG_KERNEL_INSTRUMENT_THREAD # ActiveIf: CYGPKG_KERNEL_THREADS }; # > # Allow per-thread timers # This option controls whether or not the kernel should support # per-thread clock and alarm related functions. Also some of # the synchronization primitives such as semaphore and # condition variable timed wait operations require per-thread # timer support. If none of these facilities are required then # the option can be disabled. # cdl_option CYGFUN_KERNEL_THREADS_TIMER { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # The following properties are affected by this value # option CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT # Requires: CYGFUN_KERNEL_THREADS_TIMER # option CYGSEM_LIBC_TIME_CLOCK_WORKING # Requires: CYGFUN_KERNEL_THREADS_TIMER }; # Support optional name for each thread # Threads may optionally be supplied with a name string that is # used to identify them during debugging. This name is only # present if `this option is defined. Disabling it reduces both # code and data size. # cdl_option CYGVAR_KERNEL_THREADS_NAME { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Keep track of all threads using a linked list # Threads may optionally be placed on a housekeeping list so # that all threads may be located easily. This is useful mainly # in conjunction with source-level debugging. # cdl_option CYGVAR_KERNEL_THREADS_LIST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGFUN_KERNEL_ALL_THREADS_STACK_CHECKING # Requires: CYGVAR_KERNEL_THREADS_LIST # option CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT # Requires: CYGVAR_KERNEL_THREADS_LIST }; # Keep track of the base of each thread's stack # This option makes the kernel keep track of the lower limit on # each thread's stack. It allows the kernel to adjust the lower # limit, thus making space for per-thread data. Note that it # does not imply any form of run-time stack overflow checking. # cdl_option CYGFUN_KERNEL_THREADS_STACK_LIMIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # component CYGVAR_KERNEL_THREADS_DATA # Requires: CYGFUN_KERNEL_THREADS_STACK_LIMIT }; # Check thread stacks for overflows # This option enables a variety of checks for stack overflow # including signatures at the top and base of thread stacks, # which are asserted for correctness whenever a thread switches. # cdl_component CYGFUN_KERNEL_THREADS_STACK_CHECKING { # This option is not active # ActiveIf constraint: CYGPKG_INFRA_DEBUG # CYGPKG_INFRA_DEBUG == 0 # --> 0 # ActiveIf constraint: CYGDBG_USE_ASSERTS # CYGDBG_USE_ASSERTS == 0 # --> 0 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Check all threads whenever possible # This option enables more active checking of all threads for # wrongdoing. In theory, checking threads other than the old and new # executing threads in a thread-switch is pointless, because no other # thread has run, so no other stack can be exceeded. But errors such # as memory scribbling, dangling pointers, overlapping use of store # or errors accessing objects adjacent to a stack which can be very # hard to find can be detected this way, saving debug time. # cdl_option CYGFUN_KERNEL_ALL_THREADS_STACK_CHECKING { # This option is not active # The parent CYGFUN_KERNEL_THREADS_STACK_CHECKING is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_THREADS_LIST # CYGVAR_KERNEL_THREADS_LIST == 1 # --> 1 }; # Signature size in bytes, at stack top and bottom # This is the size of the area reserved for a signature at the top # and bottom of all stacks. It also provides a buffer zone for # detecting overflow before external objects are corrupted, hence the # ability to vary it here. But if you are short of stack, increasing # this value will make the overflow more, not less likely, of course. # cdl_option CYGNUM_KERNEL_THREADS_STACK_CHECK_DATA_SIZE { # This option is not active # The parent CYGFUN_KERNEL_THREADS_STACK_CHECKING is not active # Flavor: data # No user value, uncomment the following line to provide one. # user_value 32 # value_source default # Default value: 32 # Legal values: 8 to 512 }; # < # Measure stack usage # This option allows measurement of each thread's stack by initializing # it to a predefined value at thread creation time. Later use of the # cyg_thread_measure_stack_usage() function allows the maximum stack # usage of the thread so far to be obtained. Note that this is not # necessarily the true maximum stack usage that the thread will ever # use since all that has been measured is the stack usage corresponding # to the code path followed this time, and not the code path that may # be followed in future. # cdl_component CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 != CYGPKG_INFRA_DEBUG # CYGPKG_INFRA_DEBUG == 0 # --> 0 }; # > # Output stack usage on thread exit # This will output the measured stack usage on the diagnostic # output when a thread exits. # cdl_option CYGDBG_KERNEL_THREADS_STACK_MEASUREMENT_VERBOSE_EXIT { # This option is not active # The parent CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # Support for per-thread data # doc: ref/kernel-thread-data.html # It is possible for the kernel to support per-thread data, in # other words an area of memory specific to each thread which # can be used to store data for that thread. This per-thread # data can be used by applications or by other packages such as # the ISO C library. # cdl_component CYGVAR_KERNEL_THREADS_DATA { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_KERNEL_THREADS_STACK_LIMIT # CYGFUN_KERNEL_THREADS_STACK_LIMIT == 1 # --> 1 # The following properties are affected by this value # option CYGSEM_LIBC_I18N_PER_THREAD_MB # Requires: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_LIBC_PER_THREAD_RAND # Requires: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_LIBC_STRING_PER_THREAD_STRTOK # Requires: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_LIBC_STRING_PER_THREAD_STRTOK # DefaultValue: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE # Requires: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_LIBM_THREAD_SAFE_GAMMA_FUNCTIONS # Requires: CYGVAR_KERNEL_THREADS_DATA # option CYGSEM_ERROR_PER_THREAD_ERRNO # Requires: CYGVAR_KERNEL_THREADS_DATA }; # > # Number of words of per-thread data # It is possible for the kernel to support per-thread data, in # other words an area of memory specific to each thread which # can be used to store data for that thread. This per-thread # data can be used by applications or by other packages such as # the ISO C library. This configuration option controls the # number of words of per-thread data that the kernel will # allow. In the current implementation a bitmask is used to identify # used per-thread data slots and so the maximum legal value must # remain 32. # cdl_option CYGNUM_KERNEL_THREADS_DATA_MAX { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 6 # value_source default # Default value: 6 # Legal values: 4 to 32 }; # Bitmap of preallocated slots of thread data # Per thread data options. Per thread data support is based loosely # on that defined by POSIX. Each thread has an array of slots, up to # CYGNUM_KERNEL_THREADS_DATA_MAX, that may contain data. Some of the # slots have been preallocated to specific packages. Others may be # allocated dynamically. # cdl_component CYGNUM_KERNEL_THREADS_DATA_ALL { # Calculated value: 15 # Flavor: data # Current_value: 15 }; # > # Slot 0 preallocated for the kernel # This option defines the index of a per-thread data # slot which is reserved by # the eCos kernel # for private use. # cdl_option CYGNUM_KERNEL_THREADS_DATA_KERNEL { # Calculated value: 0 # Flavor: data # Current_value: 0 }; # Slot 1 preallocated for uITRON # This option defines the index of a per-thread data # slot which is reserved by # the uITRON compatibility layer # for private use. # cdl_option CYGNUM_KERNEL_THREADS_DATA_ITRON { # Calculated value: 1 # Flavor: data # Current_value: 1 }; # Slot 2 preallocated for errno # This option defines the index of a per-thread data # slot which is reserved for use by an errno variable. # cdl_option CYGNUM_KERNEL_THREADS_DATA_ERRNO { # Calculated value: 2 # Flavor: data # Current_value: 2 }; # Slot 3 preallocated for POSIX # This option defines the index of a per-thread data # slot which is reserved by # POSIX # for private use. # cdl_option CYGNUM_KERNEL_THREADS_DATA_POSIX { # Calculated value: 3 # Flavor: data # Current_value: 3 }; # < # < # Thread destructors # doc: ref/kernel-thread-destructors.html # This option enables support for registered destructor functions to # be called on thread exit. # cdl_component CYGPKG_KERNEL_THREADS_DESTRUCTORS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # > # Number of possible destructors # This option gives the number of possible destructors allowed. # Increasing this will increase the size of every # thread control structure if per-thread destructors are # enabled. # cdl_option CYGNUM_KERNEL_THREADS_DESTRUCTORS { # This option is not active # The parent CYGPKG_KERNEL_THREADS_DESTRUCTORS is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 8 # value_source default # Default value: 8 # Legal values: 1 to 65535 }; # Per-thread destructors # Enabling this option makes the thread destructors a per-thread # property, with each thread having its own list of destructors. # Disabling this option makes the thread destructor list # global so all threads have the same destructors. # cdl_option CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD { # This option is not active # The parent CYGPKG_KERNEL_THREADS_DESTRUCTORS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Stack size for the idle thread # This configuration option specifies the stack size in bytes # for the idle thread. Unless the HAL is configured to use a # separate interrupt stack this size must be sufficient to meet # the requirements of all interrupt handlers - these # requirements are cumulative if nested interrupted are # enabled. Depending on the target architecture, the stack size # typically has to be a multiple of eight or sixteen bytes. # This will be overridden where it is used if the # architectural HAL requires a minimum stack size # to handle interrupts correctly. # cdl_option CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 2048 # value_source default # Default value: 2048 # Legal values: 512 to 65536 }; # Maximal suspend count # This option provides for an assertion that the count value for # counted thread suspends do not exceed set limits. This is to help # with debugging, to allow a runaway loop, for example, to be # detected more easily. # If the option is not defined, no assert is included. Whether asserts # are themselves included depends on infrastructure configury in # infra.h # cdl_option CYGNUM_KERNEL_MAX_SUSPEND_COUNT_ASSERT { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 500 # value_source default # Default value: 500 }; # Maximal wake count # This option provides for an assertion that the count value for # counted thread wakeups do not exceed set limits. This is to # help with debugging, to allow a runaaway loop, for example, to # be detected more easily. # If the option is not defined, no assert is included. Whether asserts # are themselves included depends on infrastructure configury in # infra.h # cdl_option CYGNUM_KERNEL_MAX_COUNTED_WAKE_COUNT_ASSERT { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 500 # value_source default # Default value: 500 }; # Idle thread must always yield # If the scheduler configuration only has a single priority # level, then the idle thread must yield each time around its loop. # cdl_option CYGIMP_IDLE_THREAD_YIELD { # This option is not active # ActiveIf constraint: (CYGNUM_KERNEL_SCHED_PRIORITIES == 1) # CYGNUM_KERNEL_SCHED_PRIORITIES == 32 # --> 0 # Calculated value: 1 # Flavor: bool # Current value: 1 }; # < # Synchronization primitives # The eCos kernel supports a number of different # synchronization primitives such as mutexes, semaphores, # condition variables, and message boxes. There are # configuration options to control the exact behaviour of some # of these synchronization primitives. # cdl_component CYGPKG_KERNEL_SYNCH { # There is no associated value. # The following properties are affected by this value # option CYGDBG_KERNEL_INSTRUMENT_MUTEX # ActiveIf: CYGPKG_KERNEL_SYNCH # option CYGDBG_KERNEL_INSTRUMENT_CONDVAR # ActiveIf: CYGPKG_KERNEL_SYNCH # option CYGDBG_KERNEL_INSTRUMENT_BINSEM # ActiveIf: CYGPKG_KERNEL_SYNCH # option CYGDBG_KERNEL_INSTRUMENT_CNTSEM # ActiveIf: CYGPKG_KERNEL_SYNCH # option CYGDBG_KERNEL_INSTRUMENT_MBOXT # ActiveIf: CYGPKG_KERNEL_SYNCH }; # > # Priority inversion protection protocols # doc: ref/kernel-mutexes.html # This component controls the protocols used to protect mutexes against # priority inversion. If this option is enabled it defines which # algorithm is used to implement this protection. At present only # one such algorithm is defined: "SIMPLE". The implementation # will only work in the mlqueue scheduler, and it does not handle the # rare case of nested mutexes completely correctly. However it is # both fast and deterministic. # cdl_component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL { # ActiveIf constraint: CYGSEM_KERNEL_SCHED_MLQUEUE # CYGSEM_KERNEL_SCHED_MLQUEUE == 1 # --> 1 # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 1 SIMPLE # value_source default # Default value: 1 SIMPLE # Legal values: "SIMPLE" # Requires: CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0 # CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0 # --> 1 }; # > # Enable priority inheritance protocol # This option enables priority inheritance protocol. This protocol # causes the owner of a mutex to be executed at the highest priority # of the threads waiting for access to the mutex. # cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT # DefaultValue: CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT ? # "INHERIT" : # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING ? # "CEILING" : "NONE" }; # Enable priority ceiling protocol # This option enables priority ceiling protocol. This protocol # causes the owner of a mutex to be executed at a priority # associated with the mutex. # cdl_component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT_PRIORITY # ActiveIf: CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT # DefaultValue: CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT ? # "INHERIT" : # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING ? # "CEILING" : "NONE" }; # > # Default priority ceiling # This option defines the default priority ceiling to be # used if the chosen default priority inversion protocol is # priority ceoptioniling protocol. The default value for this is zero, # making all such mutexes boost threads to the maximum priority. # cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT_PRIORITY { # ActiveIf constraint: CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING == 1 # --> 1 # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to CYGNUM_KERNEL_SCHED_PRIORITIES - 1 # CYGNUM_KERNEL_SCHED_PRIORITIES == 32 }; # < # No priority inversion protocol # This option enables the ability to have no priority inversion protocol. # It is equivalent to disabling the priority inversion protocol at # the top level, but is necessary for the runtime and default # selection options. # cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_NONE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Default priority inversion protocol # This option defines the default inversion protocol used for mutexes that # are created without an explicit protocol being specified. The protocol # chosen by default is to use priority inheritance if it is present otherwise # priority ceiling, or none if neither is present. # cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT { # ActiveIf constraint: CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 # CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT == 3 # --> 1 # Flavor: data # No user value, uncomment the following line to provide one. # user_value INHERIT # value_source default # Default value: CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT ? # "INHERIT" : # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING ? # "CEILING" : "NONE" # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT == 1 # CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING == 1 # --> INHERIT # Legal values: "INHERIT" "CEILING" "NONE" }; # Specify mutex priority inversion protocol at runtime # This option controls whether the priority inversion protocol used by # a mutex can be specified when that mutex is created. # cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC { # ActiveIf constraint: CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 # CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT == 3 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Number of protocols selected # cdl_interface CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT { # Implemented by CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT, active, enabled # Implemented by CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING, active, enabled # Implemented by CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_NONE, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 3 # The following properties are affected by this value # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT # ActiveIf: CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 # option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC # ActiveIf: CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 }; # < # Message box blocking put support # doc: ref/kernel-mail-boxes.html # Message boxes can support three different versions of the # put-message operation. The first is tryput(), which will fail # if the message box is already full. The other two are the # ordinary put() function which will block if the message box # is full, and a timed put() operation which will block for # upto a certain length of time if the message box is currently # full. The blocking versions require extra memory in the # message box data structure and extra code in the other # message box functions, so they can be disabled if the # application does not require them. If this option is enabled # then the system will always provide the blocking put() # function, and it will also provide the timed put() function # if thread timers are enabled. # cdl_option CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Message box queue size # doc: ref/kernel-mail-boxes.html # This configuration option controls the number of messages # that can be queued in a message box before a non-blocking # put() operation will fail or a blocking put() operation will # block. The cost in memory is one pointer per message box for # each possible message. # cdl_option CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 10 # value_source default # Default value: 10 # Legal values: 1 to 65535 }; # Condition variable timed-wait support # doc: ref/kernel-condition-variables.html # This option enables the condition variable timed wait # facility. # cdl_option CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_KERNEL_THREADS_TIMER # CYGFUN_KERNEL_THREADS_TIMER == 1 # --> 1 }; # Condition variable explicit mutex wait support # doc: ref/kernel-condition-variables.html # This option enables the condition variable explicit mutex wait # facility. By default condition variables in eCos are created with # a statically associated mutex. This option permits wait (and timed wait # if CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT is enabled) to provide a # different mutex as an argument. This makes no difference to the semantics # the wait operation except that a different mutex will be used during it. # cdl_option CYGMFN_KERNEL_SYNCH_CONDVAR_WAIT_MUTEX { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Avoid inlines in mqueue implementation # With this option disabled, the 'mqueue' message queue implementation # provides most of its implementation via inlines. However this can # adversely affect code size in application that make lots of mqueue # calls from different places, so enabling this option provides # non-inline versions to be used instead. # cdl_option CYGIMP_KERNEL_SYNCH_MQUEUE_NOT_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # Kernel instrumentation # The current release of the kernel contains an initial version # of instrumentation support. The various parts of the kernel # will invoke instrumentation routines whenever appropriate # events occur, and these will be stored in a circular buffer # for later reference. # cdl_component CYGPKG_KERNEL_INSTRUMENT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # }; # > # Use buffer provided by the application # In most circumstances the kernel should provide the # instrumentation circular buffer itself. Occasionally # application code may wish to provide the buffer instead, # giving the application code more convenient access to the # buffer. This also makes it possible to put the circular # buffer in special areas of memory, for example a region that # is shared with the host. # cdl_option CYGVAR_KERNEL_INSTRUMENT_EXTERNAL_BUFFER { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Size of instrumentation buffer size # If kernel instrumentation is enabled then the instrumentation # data goes into a circular buffer. A larger buffer allows # more data to be stored, but at a significant cost in memory. # The value of this option corresponds to the number of entries # in the table, and typically each entry will require 16 bytes # of memory. # cdl_option CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 256 # value_source default # Default value: 256 # Legal values: 16 to 0x100000 }; # Wrap instrument buffer # When the instrumentation buffer is full it can either be restarted # from the beginning, overwriting older data, or it can stop at the # end. The former is useful if you want to look at the last entries # made while the latter is useful if you want to look at the first # few. # cdl_option CYGDBG_KERNEL_INSTRUMENT_BUFFER_WRAP { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Perform selective instrumentation # The kernel can either collect all instrumentation events, or # it can filter out events at runtime based on a set of flags. # For example it would be possible to decide at runtime that # only scheduler and interrupt instrumentation flags are of # interest and that all other flags should be ignored. This # flag mechanism involves extra code and processor cycle # overhead in the instrumentation code, so it can be disabled # if the application developer is interested in all # instrumentation events. # cdl_option CYGDBG_KERNEL_INSTRUMENT_FLAGS { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument the scheduler # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the scheduling code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_SCHED { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SCHED # CYGPKG_KERNEL_SCHED == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument thread operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the code that manipulates threads. # cdl_option CYGDBG_KERNEL_INSTRUMENT_THREAD { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_THREADS # CYGPKG_KERNEL_THREADS == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument interrupts # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the interrupt handling code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_INTR { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_INTERRUPTS # CYGPKG_KERNEL_INTERRUPTS == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument mutex operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the mutex code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_MUTEX { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SYNCH # CYGPKG_KERNEL_SYNCH == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument condition variable operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the condition variable code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_CONDVAR { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SYNCH # CYGPKG_KERNEL_SYNCH == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument binary semaphore operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the binary semaphore code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_BINSEM { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SYNCH # CYGPKG_KERNEL_SYNCH == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument counting semaphore operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the counting semaphore code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_CNTSEM { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SYNCH # CYGPKG_KERNEL_SYNCH == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument message box operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the message box code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_MBOXT { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGPKG_KERNEL_SYNCH # CYGPKG_KERNEL_SYNCH == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument clock operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the real-time clock code. # cdl_option CYGDBG_KERNEL_INSTRUMENT_CLOCK { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument alarm-related operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the code related to alarm operations. # cdl_option CYGDBG_KERNEL_INSTRUMENT_ALARM { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Instrument SMP-related operations # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not instrumentation support is compiled into # the code related to SMP operations. # cdl_option CYGDBG_KERNEL_INSTRUMENT_SMP { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # ActiveIf constraint: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Support application-level instrumentation # It is possible to perform selective instrumentation at # run-time. It is also possible to disable instrumentation # in various kernel components at compile-time, thus # reducing the code size overheads. This option controls # whether or not application-level instrumentation gets # compiled in. # cdl_option CYGDBG_KERNEL_INSTRUMENT_USER { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Print user friendly instrument messages # Include code which will convert the instrument type field # into a more human understandable string # cdl_component CYGDBG_KERNEL_INSTRUMENT_MSGS { # This option is not active # The parent CYGPKG_KERNEL_INSTRUMENT is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Rebuild the header file # Make (using a shell script) include/cyg/kernel/instrument_desc.h in # your build tree; this is normally simply copied from the repository. # If you make a permanent change to include/instrmnt.h, such that # instrument_desc.h needs updating, it's up to you to first delete the # master file # ECOS_REPOSITORY/kernel/VERSION/include/instrument_desc.h # in your source repository, make the new version by enabling this # option then copy the new file # back from your build place to its source in # ECOS_REPOSITORY/kernel/VERSION/include/instrument_desc.h # and/or commit this to any version control system that you use. # cdl_option CYGDBG_KERNEL_INSTRUMENT_MSGS_BUILD_HEADERFILE { # This option is not active # The parent CYGDBG_KERNEL_INSTRUMENT_MSGS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Build the host tool to print out a dump # Generate a host program which can dump the instrumentation # data in a human readable format. You have to somehow get the # instrumentation buffer into a file on the host. 'Exercise for # the reader' as university lecturers tend to say. # cdl_component CYGDBG_KERNEL_INSTRUMENT_BUILD_HOST_DUMP { # This option is not active # The parent CYGDBG_KERNEL_INSTRUMENT_MSGS is not active # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # < # Source-level debugging support # If the source level debugger gdb is to be used for debugging # application code then it may be necessary to configure in support # for this in the kernel. # cdl_component CYGPKG_KERNEL_DEBUG { # There is no associated value. }; # > # Include GDB multi-threading debug support # This option enables some extra kernel code which is needed # to support multi-threaded source level debugging. # cdl_option CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGVAR_KERNEL_THREADS_LIST # CYGVAR_KERNEL_THREADS_LIST == 1 # --> 1 # Requires: CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT # CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT == 1 # --> 1 # The following properties are affected by this value # option CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT # ActiveIf: CYGSEM_HAL_ROM_MONITOR || CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT }; # < # Kernel APIs # The eCos kernel is implemented in C++, so a C++ interface # to the kernel is always available. There is also an optional # C API. Additional API's may be provided in future versions. # cdl_component CYGPKG_KERNEL_API { # There is no associated value. }; # > # Provide C API # The eCos kernel is implemented in C++, but there is an # optional C API for use by application code. This C API can be # disabled if the application code does not invoke the kernel # directly, but instead uses higher level code such as the # uITRON compatibility layer. # cdl_option CYGFUN_KERNEL_API_C { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # # option CYGPKG_KERNEL_TESTS # Calculated: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # # option CYGFUN_MEMALLOC_KAPI # DefaultValue: CYGFUN_KERNEL_API_C }; # < # Kernel build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_KERNEL_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the eCos kernel. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_KERNEL_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the eCos kernel. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_KERNEL_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Kernel tests # This option specifies the set of tests for the eCos kernel. # cdl_option CYGPKG_KERNEL_TESTS { # Calculated value: # "tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2" # . ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "") # . ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "") # . ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "") # . ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "") # # CYGFUN_KERNEL_API_C == 1 # CYGPKG_INFRA_DEBUG == 0 # CYGPKG_KERNEL_INSTRUMENT == 0 # CYGFUN_KERNEL_API_C == 1 # CYGPKG_KERNEL_SMP_SUPPORT == 0 # CYGFUN_KERNEL_API_C == 1 # CYGINT_HAL_TESTS_NO_CACHES == 0 # CYGFUN_KERNEL_API_C == 1 # Flavor: data # Current_value: tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2 tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest tests/dhrystone tests/kcache1 tests/kcache2 }; # < # < # Dynamic memory allocation # This package provides memory allocator infrastructure required for # dynamic memory allocators, including the ISO standard malloc # interface. It also contains some sample implementations. # cdl_package CYGPKG_MEMALLOC { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 }; # > # Memory allocator implementations # This component contains configuration options related to the # various memory allocators available. # cdl_component CYGPKG_MEMALLOC_ALLOCATORS { # There is no associated value. }; # > # Fixed block allocator # This component contains configuration options related to the # fixed block memory allocator. # cdl_component CYGPKG_MEMALLOC_ALLOCATOR_FIXED { # There is no associated value. }; # > # Make thread safe # With this option enabled, this allocator will be # made thread-safe. Additionally allocation functions # are made available that allow a thread to wait # until memory is available. # cdl_option CYGSEM_MEMALLOC_ALLOCATOR_FIXED_THREADAWARE { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Simple variable block allocator # This component contains configuration options related to the # simple variable block memory allocator. This allocator is not # very fast, and in particular does not scale well with large # numbers of allocations. It is however very compact in terms of # code size and does not have very much overhead per allocation. # cdl_component CYGPKG_MEMALLOC_ALLOCATOR_VARIABLE { # There is no associated value. }; # > # Make thread safe # With this option enabled, this allocator will be # made thread-safe. Additionally allocation functions # are added that allow a thread to wait until memory # are made available that allow a thread to wait # until memory is available. # cdl_option CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_THREADAWARE { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Coalesce memory # The variable-block memory allocator can perform coalescing # of memory whenever the application code releases memory back # to the pool. This coalescing reduces the possibility of # memory fragmentation problems, but involves extra code and # processor cycles. # cdl_option CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_COALESCE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGIMP_MEMALLOC_MALLOC_VARIABLE_SIMPLE # Requires: CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_COALESCE }; # < # Doug Lea's malloc # This component contains configuration options related to the # port of Doug Lea's memory allocator, normally known as # dlmalloc. dlmalloc has a reputation for being both fast # and space-conserving, as well as resisting fragmentation well. # It is a common choice for a general purpose allocator and # has been used in both newlib and Linux glibc. # cdl_component CYGPKG_MEMALLOC_ALLOCATOR_DLMALLOC { # There is no associated value. }; # > # Debug build # Doug Lea's malloc implementation has substantial amounts # of internal checking in order to verify the operation # and consistency of the allocator. However this imposes # substantial overhead on each operation. Therefore this # checking may be individually disabled. # cdl_option CYGDBG_MEMALLOC_ALLOCATOR_DLMALLOC_DEBUG { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 != CYGDBG_USE_ASSERTS # CYGDBG_USE_ASSERTS == 0 # --> 0 # Requires: CYGDBG_USE_ASSERTS # CYGDBG_USE_ASSERTS == 0 # --> 0 }; # Make thread safe # With this option enabled, this allocator will be # made thread-safe. Additionally allocation functions # are made available that allow a thread to wait # until memory is available. # cdl_option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # Support more than one instance # Having this option disabled allows important # implementation structures to be declared as a single # static instance, allowing faster access. However this # would fail if there is more than one instance of # the dlmalloc allocator class. Therefore this option can # be enabled if multiple instances are required. Note: as # a special case, if this allocator is used as the # implementation of malloc, and it can be determined there # is more than one malloc pool, then this option will be # silently enabled. # cdl_option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_SAFE_MULTIPLE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Use system memcpy() and memset() # This may be used to control whether memset() and memcpy() # are used within the implementation. The alternative is # to use some macro equivalents, which some people report # are faster in some circumstances. # cdl_option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_USE_MEMCPY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 }; # < # Variable block allocator with separate metadata # This component contains configuration options related to the # variable block memory allocator with separate metadata. # cdl_component CYGPKG_MEMALLOC_ALLOCATOR_SEPMETA { # There is no associated value. }; # > # Make thread safe # With this option enabled, this allocator will be # made thread-safe. Additionally allocation functions # are made available that allow a thread to wait # until memory is available. # cdl_option CYGSEM_MEMALLOC_ALLOCATOR_SEPMETA_THREADAWARE { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # < # Kernel C API support for memory allocation # This option must be enabled to provide the extensions required # to support integration into the kernel C API. # cdl_option CYGFUN_MEMALLOC_KAPI { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGFUN_KERNEL_API_C # CYGFUN_KERNEL_API_C == 1 # --> 1 }; # malloc(0) returns NULL # This option controls the behavior of malloc(0) ( or calloc with # either argument 0 ). It is permitted by the standard to return # either a NULL pointer or a unique pointer. Enabling this option # forces a NULL pointer to be returned. # cdl_option CYGSEM_MEMALLOC_MALLOC_ZERO_RETURNS_NULL { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # malloc() and supporting allocators # This component enables support for dynamic memory # allocation as supplied by the functions malloc(), # free(), calloc() and realloc(). As these # functions are often used, but can have quite an # overhead, disabling them here can ensure they # cannot even be used accidentally when static # allocation is preferred. Within this component are # various allocators that can be selected for use # as the underlying implementation of the dynamic # allocation functions. # cdl_component CYGPKG_MEMALLOC_MALLOC_ALLOCATORS { # ActiveIf constraint: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Use external heap definition # This option allows other components in the # system to override the default system # provision of heap memory pools. This should # be set to a header which provides the equivalent # definitions to . # cdl_component CYGBLD_MEMALLOC_MALLOC_EXTERNAL_HEAP_H { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # malloc() allocator implementations # cdl_interface CYGINT_MEMALLOC_MALLOC_ALLOCATORS { # Implemented by CYGIMP_MEMALLOC_MALLOC_VARIABLE_SIMPLE, active, disabled # Implemented by CYGIMP_MEMALLOC_MALLOC_DLMALLOC, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: CYGINT_MEMALLOC_MALLOC_ALLOCATORS == 1 # CYGINT_MEMALLOC_MALLOC_ALLOCATORS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_MEMALLOC_MALLOC_ALLOCATORS # Requires: CYGINT_MEMALLOC_MALLOC_ALLOCATORS == 1 }; # malloc() implementation instantiation data # Memory allocator implementations that are capable of being # used underneath malloc() must be instantiated. The code # to do this is set in this option. It is only intended to # be set by the implementation, not the user. # cdl_option CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER { # Flavor: data # No user value, uncomment the following line to provide one. # user_value # value_source default # Default value: # The following properties are affected by this value # option CYGIMP_MEMALLOC_MALLOC_VARIABLE_SIMPLE # Requires: CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == "" # option CYGIMP_MEMALLOC_MALLOC_DLMALLOC # Requires: CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == "" }; # Simple variable block implementation # This causes malloc() to use the simple # variable block allocator. # cdl_option CYGIMP_MEMALLOC_MALLOC_VARIABLE_SIMPLE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == "" # CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == # --> 0 # Requires: CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_COALESCE # CYGSEM_MEMALLOC_ALLOCATOR_VARIABLE_COALESCE == 1 # --> 1 }; # Doug Lea's malloc implementation # This causes malloc() to use a version of Doug Lea's # malloc (dlmalloc) as the underlying implementation. # cdl_option CYGIMP_MEMALLOC_MALLOC_DLMALLOC { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == "" # CYGBLD_MEMALLOC_MALLOC_IMPLEMENTATION_HEADER == # --> 1 }; # < # Size of the fallback dynamic memory pool in bytes # If *no* heaps are configured in your memory layout, # dynamic memory allocation by # malloc() and calloc() must be from a fixed-size, # contiguous memory pool (note here that it is the # pool that is of a fixed size, but malloc() is still # able to allocate variable sized chunks of memory # from it). This option is the size # of that pool, in bytes. Note that not all of # this is available for programs to # use - some is needed for internal information # about memory regions, and some may be lost to # ensure that memory allocation only returns # memory aligned on word (or double word) # boundaries - a very common architecture # constraint. # cdl_option CYGNUM_MEMALLOC_FALLBACK_MALLOC_POOL_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 16384 # value_source default # Default value: 16384 # Legal values: 32 to 0x7fffffff }; # Common memory allocator package build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_MEMALLOC_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building this package. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_MEMALLOC_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building this package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_MEMALLOC_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Tests # This option specifies the set of tests for this package. # cdl_option CYGPKG_MEMALLOC_TESTS { # Calculated value: "tests/dlmalloc1 tests/dlmalloc2 tests/heaptest tests/kmemfix1 tests/kmemvar1 tests/malloc1 tests/malloc2 tests/malloc3 tests/malloc4 tests/memfix1 tests/memfix2 tests/memvar1 tests/memvar2 tests/realloc tests/sepmeta1 tests/sepmeta2" # Flavor: data # Current_value: tests/dlmalloc1 tests/dlmalloc2 tests/heaptest tests/kmemfix1 tests/kmemvar1 tests/malloc1 tests/malloc2 tests/malloc3 tests/malloc4 tests/memfix1 tests/memfix2 tests/memvar1 tests/memvar2 tests/realloc tests/sepmeta1 tests/sepmeta2 }; # < # < # ISO C and POSIX infrastructure # eCos supports implementations of ISO C libraries and POSIX # implementations. This package provides infrastructure used by # all such implementations. # cdl_package CYGPKG_ISOINFRA { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # component CYGPKG_IO_SERIAL_TERMIOS # Requires: CYGPKG_ISOINFRA # component CYGPKG_IO_SERIAL_TERMIOS # DefaultValue: 0 != CYGPKG_ISOINFRA && 0 != CYGPKG_IO_FILEIO && 0 != CYGINT_ISO_ERRNO_CODES && 0 != CYGINT_ISO_ERRNO # option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_USE_MEMCPY # Requires: CYGPKG_ISOINFRA # option CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_USE_MEMCPY # DefaultValue: 0 != CYGPKG_ISOINFRA # component CYGPKG_MEMALLOC_MALLOC_ALLOCATORS # ActiveIf: CYGPKG_ISOINFRA # package CYGPKG_LIBC_I18N # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_SETJMP # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_SIGNALS # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_STARTUP # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_STDIO # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_STDLIB # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_STRING # Requires: CYGPKG_ISOINFRA # package CYGPKG_LIBC_TIME # Requires: CYGPKG_ISOINFRA }; # > # Startup and termination # cdl_component CYGPKG_ISO_STARTUP { # There is no associated value. }; # > # main() startup implementations # Implementations of this interface arrange for a user-supplied # main() to be called in an ISO compatible environment. # cdl_interface CYGINT_ISO_MAIN_STARTUP { # Implemented by CYGPKG_LIBC_STARTUP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_MAIN_STARTUP # CYGINT_ISO_MAIN_STARTUP == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_MAIN_STARTUP # Requires: 1 >= CYGINT_ISO_MAIN_STARTUP }; # environ implementations # Implementations of this interface provide the environ # variable required by POSIX. # cdl_interface CYGINT_ISO_ENVIRON { # Implemented by CYGPKG_LIBC_STARTUP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_ENVIRON # CYGINT_ISO_ENVIRON == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_ENVIRON # Requires: 1 >= CYGINT_ISO_ENVIRON }; # < # ctype.h functions # cdl_component CYGPKG_ISO_CTYPE_H { # There is no associated value. }; # > # Number of implementations of ctype functions # cdl_interface CYGINT_ISO_CTYPE { # Implemented by CYGPKG_LIBC_I18N, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_CTYPE # CYGINT_ISO_CTYPE == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_CTYPE # Requires: 1 >= CYGINT_ISO_CTYPE # package CYGPKG_LIBC_STDLIB # Requires: CYGINT_ISO_CTYPE # option CYGFUN_LIBC_STRING_BSD_FUNCS # Requires: CYGINT_ISO_CTYPE }; # Ctype implementation header # cdl_option CYGBLD_ISO_CTYPE_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGIMP_LIBC_I18N_CTYPE_INLINES # Requires: CYGBLD_ISO_CTYPE_HEADER == "" }; # < # Error handling # cdl_component CYGPKG_ISO_ERRNO { # There is no associated value. }; # > # Number of implementations of error codes # cdl_interface CYGINT_ISO_ERRNO_CODES { # Implemented by CYGPKG_ERROR, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_ERRNO_CODES # CYGINT_ISO_ERRNO_CODES == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_ERRNO_CODES # Requires: 1 >= CYGINT_ISO_ERRNO_CODES # component CYGPKG_IO_SERIAL_TERMIOS # Requires: CYGINT_ISO_ERRNO_CODES # component CYGPKG_IO_SERIAL_TERMIOS # DefaultValue: 0 != CYGPKG_ISOINFRA && 0 != CYGPKG_IO_FILEIO && 0 != CYGINT_ISO_ERRNO_CODES && 0 != CYGINT_ISO_ERRNO # option CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO # Requires: CYGINT_ISO_ERRNO_CODES # option CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO # Requires: CYGINT_ISO_ERRNO_CODES # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_ERRNO_CODES }; # Error codes implementation header # cdl_option CYGBLD_ISO_ERRNO_CODES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_ERROR # Requires: CYGBLD_ISO_ERRNO_CODES_HEADER == "" }; # Number of implementations of errno variable # cdl_interface CYGINT_ISO_ERRNO { # Implemented by CYGPKG_ERROR_ERRNO, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_ERRNO # CYGINT_ISO_ERRNO == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_ERRNO # Requires: 1 >= CYGINT_ISO_ERRNO # component CYGPKG_IO_SERIAL_TERMIOS # Requires: CYGINT_ISO_ERRNO # component CYGPKG_IO_SERIAL_TERMIOS # DefaultValue: 0 != CYGPKG_ISOINFRA && 0 != CYGPKG_IO_FILEIO && 0 != CYGINT_ISO_ERRNO_CODES && 0 != CYGINT_ISO_ERRNO # option CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO # Requires: CYGINT_ISO_ERRNO # option CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO # Requires: CYGINT_ISO_ERRNO # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_ERRNO }; # errno variable implementation header # cdl_option CYGBLD_ISO_ERRNO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # component CYGPKG_ERROR_ERRNO # Requires: CYGBLD_ISO_ERRNO_HEADER == "" }; # < # Locale-related functions # cdl_component CYGPKG_ISO_LOCALE { # There is no associated value. }; # > # Number of implementations of locale functions # cdl_interface CYGINT_ISO_LOCALE { # Implemented by CYGPKG_LIBC_I18N, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_LOCALE # CYGINT_ISO_LOCALE == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_LOCALE # Requires: 1 >= CYGINT_ISO_LOCALE }; # Locale implementation header # cdl_option CYGBLD_ISO_LOCALE_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Standard I/O-related functionality # cdl_component CYGPKG_ISO_STDIO { # There is no associated value. }; # > # Number of implementations of stdio file types # cdl_interface CYGINT_ISO_STDIO_FILETYPES { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_FILETYPES # CYGINT_ISO_STDIO_FILETYPES == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_FILETYPES # Requires: 1 >= CYGINT_ISO_STDIO_FILETYPES }; # Stdio file types implementation header # cdl_option CYGBLD_ISO_STDIO_FILETYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_FILETYPES_HEADER == "" }; # Stdio standard streams implementations # cdl_interface CYGINT_ISO_STDIO_STREAMS { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_STREAMS # CYGINT_ISO_STDIO_STREAMS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_STREAMS # Requires: 1 >= CYGINT_ISO_STDIO_STREAMS }; # Stdio standard streams implementation header # This header file must define stdin, stdout # and stderr. # cdl_option CYGBLD_ISO_STDIO_STREAMS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_STREAMS_HEADER == "" }; # Number of implementations of stdio file operations # cdl_interface CYGINT_ISO_STDIO_FILEOPS { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_STDIO_FILEOPS # CYGINT_ISO_STDIO_FILEOPS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_FILEOPS # Requires: 1 >= CYGINT_ISO_STDIO_FILEOPS }; # Stdio file operations implementation header # This header controls the file system operations on a file # such as remove(), rename(), tmpfile(), tmpnam() and associated # constants. # cdl_option CYGBLD_ISO_STDIO_FILEOPS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of stdio file access functionals # cdl_interface CYGINT_ISO_STDIO_FILEACCESS { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_FILEACCESS # CYGINT_ISO_STDIO_FILEACCESS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_FILEACCESS # Requires: 1 >= CYGINT_ISO_STDIO_FILEACCESS # option CYGSEM_LIBC_EXIT_CALLS_FFLUSH # Requires: CYGINT_ISO_STDIO_FILEACCESS # option CYGSEM_LIBC_EXIT_CALLS_FFLUSH # DefaultValue: 0 != CYGINT_ISO_STDIO_FILEACCESS }; # Stdio file access implementation header # This header controls the file access operations # such as fclose(), fflush(), fopen(), freopen(), setbuf(), # setvbuf(), and associated constants. # cdl_option CYGBLD_ISO_STDIO_FILEACCESS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_FILEACCESS_HEADER == "" }; # Number of implementations of stdio formatted I/O # cdl_interface CYGINT_ISO_STDIO_FORMATTED_IO { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_FORMATTED_IO # CYGINT_ISO_STDIO_FORMATTED_IO == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_FORMATTED_IO # Requires: 1 >= CYGINT_ISO_STDIO_FORMATTED_IO }; # Stdio formatted I/O implementation header # cdl_option CYGBLD_ISO_STDIO_FORMATTED_IO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_FORMATTED_IO_HEADER == "" }; # Number of implementations of stdio character I/O # cdl_interface CYGINT_ISO_STDIO_CHAR_IO { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_CHAR_IO # CYGINT_ISO_STDIO_CHAR_IO == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_CHAR_IO # Requires: 1 >= CYGINT_ISO_STDIO_CHAR_IO }; # Stdio character I/O implementation header # cdl_option CYGBLD_ISO_STDIO_CHAR_IO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_CHAR_IO_HEADER == "" }; # Number of implementations of stdio direct I/O # cdl_interface CYGINT_ISO_STDIO_DIRECT_IO { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_DIRECT_IO # CYGINT_ISO_STDIO_DIRECT_IO == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_DIRECT_IO # Requires: 1 >= CYGINT_ISO_STDIO_DIRECT_IO }; # Stdio direct I/O implementation header # cdl_option CYGBLD_ISO_STDIO_DIRECT_IO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_DIRECT_IO_HEADER == "" }; # Number of implementations of stdio file positioning # cdl_interface CYGINT_ISO_STDIO_FILEPOS { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_STDIO_FILEPOS # CYGINT_ISO_STDIO_FILEPOS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_FILEPOS # Requires: 1 >= CYGINT_ISO_STDIO_FILEPOS }; # Stdio file positioning implementation header # cdl_option CYGBLD_ISO_STDIO_FILEPOS { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of stdio error handling # cdl_interface CYGINT_ISO_STDIO_ERROR { # Implemented by CYGPKG_LIBC_STDIO, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_ERROR # CYGINT_ISO_STDIO_ERROR == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_ERROR # Requires: 1 >= CYGINT_ISO_STDIO_ERROR }; # Stdio error handling implementation header # cdl_option CYGBLD_ISO_STDIO_ERROR_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGBLD_ISO_STDIO_ERROR_HEADER == "" }; # POSIX fd-related function implementations # cdl_interface CYGINT_ISO_STDIO_POSIX_FDFUNCS { # Implemented by CYGPKG_LIBC_STDIO_OPEN, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STDIO_POSIX_FDFUNCS # CYGINT_ISO_STDIO_POSIX_FDFUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDIO_POSIX_FDFUNCS # Requires: 1 >= CYGINT_ISO_STDIO_POSIX_FDFUNCS }; # POSIX fd-related function implementation header # cdl_option CYGBLD_ISO_STDIO_POSIX_FDFUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Standard general utility functions # cdl_component CYGPKG_ISO_STDLIB { # There is no associated value. }; # > # String conversion function implementations # cdl_interface CYGINT_ISO_STDLIB_STRCONV { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_STRCONV # CYGINT_ISO_STDLIB_STRCONV == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDLIB_STRCONV # Requires: 1 >= CYGINT_ISO_STDLIB_STRCONV # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_STDLIB_STRCONV }; # String conversion function implementation header # cdl_option CYGBLD_ISO_STDLIB_STRCONV_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGIMP_LIBC_STDLIB_INLINE_ATOX # Requires: CYGBLD_ISO_STDLIB_STRCONV_HEADER == "" }; # String to FP conversion function implementations # cdl_interface CYGINT_ISO_STDLIB_STRCONV_FLOAT { # Implemented by CYGFUN_LIBC_strtod, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_STRCONV_FLOAT # CYGINT_ISO_STDLIB_STRCONV_FLOAT == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDLIB_STRCONV_FLOAT # Requires: 1 >= CYGINT_ISO_STDLIB_STRCONV_FLOAT # option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT # Requires: CYGINT_ISO_STDLIB_STRCONV_FLOAT # option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT # DefaultValue: 0 != CYGPKG_LIBM && # 0 != CYGINT_ISO_STDLIB_STRCONV_FLOAT }; # String to FP conversion function implementation header # cdl_option CYGBLD_ISO_STDLIB_STRCONV_FLOAT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Random number generator implementations # cdl_interface CYGINT_ISO_RAND { # Implemented by CYGIMP_LIBC_RAND_SIMPLEST, active, disabled # Implemented by CYGIMP_LIBC_RAND_SIMPLE1, active, enabled # Implemented by CYGIMP_LIBC_RAND_KNUTH1, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_RAND # CYGINT_ISO_RAND == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_RAND # Requires: 1 >= CYGINT_ISO_RAND }; # Random number generator implementation header # cdl_option CYGBLD_ISO_RAND_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Malloc implementations # cdl_interface CYGINT_ISO_MALLOC { # Implemented by CYGPKG_MEMALLOC_MALLOC_ALLOCATORS, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_MALLOC # Requires: 1 >= CYGINT_ISO_MALLOC # component CYGPKG_IO_SERIAL_TERMIOS # Requires: CYGINT_ISO_MALLOC # option CYGSEM_LIBC_STDIO_SETVBUF_MALLOC # Requires: CYGINT_ISO_MALLOC # option CYGSEM_LIBC_STDIO_SETVBUF_MALLOC # DefaultValue: 0 != CYGINT_ISO_MALLOC # option CYGPKG_LIBC_STDIO_OPEN # Requires: CYGINT_ISO_MALLOC # option CYGPKG_LIBC_STDIO_OPEN # DefaultValue: 0 != CYGINT_ISO_MALLOC }; # Malloc implementation header # cdl_option CYGBLD_ISO_MALLOC_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Mallinfo() implementations # cdl_interface CYGINT_ISO_MALLINFO { # Implemented by CYGPKG_MEMALLOC_MALLOC_ALLOCATORS, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_MALLINFO # CYGINT_ISO_MALLINFO == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_MALLINFO # Requires: 1 >= CYGINT_ISO_MALLINFO }; # Mallinfo() implementation header # cdl_option CYGBLD_ISO_MALLINFO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Program exit functionality implementations # cdl_interface CYGINT_ISO_EXIT { # Implemented by CYGPKG_LIBC_STARTUP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_EXIT # CYGINT_ISO_EXIT == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_EXIT # Requires: 1 >= CYGINT_ISO_EXIT # option CYGFUN_INFRA_DUMMY_ABORT # Requires: !CYGINT_ISO_EXIT # option CYGFUN_INFRA_DUMMY_ABORT # DefaultValue: CYGINT_ISO_EXIT == 0 }; # Program exit functionality implementation header # cdl_option CYGBLD_ISO_EXIT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Program environment implementations # cdl_interface CYGINT_ISO_STDLIB_ENVIRON { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_ENVIRON # CYGINT_ISO_STDLIB_ENVIRON == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDLIB_ENVIRON # Requires: 1 >= CYGINT_ISO_STDLIB_ENVIRON }; # Program environment implementation header # cdl_option CYGBLD_ISO_STDLIB_ENVIRON_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # system() implementations # cdl_interface CYGINT_ISO_STDLIB_SYSTEM { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_SYSTEM # CYGINT_ISO_STDLIB_SYSTEM == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDLIB_SYSTEM # Requires: 1 >= CYGINT_ISO_STDLIB_SYSTEM }; # system() implementation header # cdl_option CYGBLD_ISO_STDLIB_SYSTEM_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # bsearch() implementations # cdl_interface CYGINT_ISO_BSEARCH { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_BSEARCH # CYGINT_ISO_BSEARCH == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_BSEARCH # Requires: 1 >= CYGINT_ISO_BSEARCH }; # bsearch() implementation header # cdl_option CYGBLD_ISO_BSEARCH_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # qsort() implementations # cdl_interface CYGINT_ISO_QSORT { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_QSORT # CYGINT_ISO_STDLIB_QSORT (unknown) == 0 # --> 1 # The following properties are affected by this value }; # qsort() implementation header # cdl_option CYGBLD_ISO_QSORT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # abs()/labs() implementations # cdl_interface CYGINT_ISO_ABS { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_ABS # CYGINT_ISO_STDLIB_ABS (unknown) == 0 # --> 1 # The following properties are affected by this value # package CYGPKG_LIBC_TIME # Requires: CYGINT_ISO_ABS }; # abs()/labs() implementation header # cdl_option CYGBLD_ISO_STDLIB_ABS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGIMP_LIBC_STDLIB_INLINE_ABS # Requires: CYGBLD_ISO_STDLIB_ABS_HEADER == "" }; # div()/ldiv() implementations # cdl_interface CYGINT_ISO_DIV { # Implemented by CYGPKG_LIBC_STDLIB, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_DIV # CYGINT_ISO_STDLIB_DIV (unknown) == 0 # --> 1 # The following properties are affected by this value # package CYGPKG_LIBC_TIME # Requires: CYGINT_ISO_DIV }; # div()/ldiv() implementation header # cdl_option CYGBLD_ISO_STDLIB_DIV_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGIMP_LIBC_STDLIB_INLINE_DIV # Requires: CYGBLD_ISO_STDLIB_DIV_HEADER == "" }; # Header defining the implementation's MB_CUR_MAX # cdl_option CYGBLD_ISO_STDLIB_MB_CUR_MAX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 # The following properties are affected by this value # interface CYGINT_LIBC_I18N_MB_REQUIRED # Requires: CYGBLD_ISO_STDLIB_MB_CUR_MAX_HEADER == "" }; # Multibyte character implementations # cdl_interface CYGINT_ISO_STDLIB_MULTIBYTE { # Implemented by CYGPKG_LIBC_I18N, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_STDLIB_MULTIBYTE # CYGINT_ISO_STDLIB_MULTIBYTE == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STDLIB_MULTIBYTE # Requires: 1 >= CYGINT_ISO_STDLIB_MULTIBYTE }; # Multibyte character implementation header # cdl_option CYGBLD_ISO_STDLIB_MULTIBYTE_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # String functions # cdl_component CYGPKG_ISO_STRING { # There is no associated value. }; # > # Number of implementations of strerror() function # cdl_interface CYGINT_ISO_STRERROR { # Implemented by CYGPKG_ERROR_STRERROR, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRERROR # CYGINT_ISO_STRERROR == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRERROR # Requires: 1 >= CYGINT_ISO_STRERROR # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_STRERROR }; # strerror() implementation header # cdl_option CYGBLD_ISO_STRERROR_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGPKG_ERROR_STRERROR # Requires: CYGBLD_ISO_STRERROR_HEADER == "" }; # memcpy() implementation header # cdl_option CYGBLD_ISO_MEMCPY_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # memset() implementation header # cdl_option CYGBLD_ISO_MEMSET_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of strtok_r() function # cdl_interface CYGINT_ISO_STRTOK_R { # Implemented by CYGPKG_LIBC_STRING, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRTOK_R # CYGINT_ISO_STRTOK_R == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRTOK_R # Requires: 1 >= CYGINT_ISO_STRTOK_R }; # strtok_r() implementation header # cdl_option CYGBLD_ISO_STRTOK_R_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STRING # Requires: CYGBLD_ISO_STRTOK_R_HEADER == "" }; # Number of implementations of locale-specific string functions # This covers locale-dependent string functions such as strcoll() # and strxfrm(). # cdl_interface CYGINT_ISO_STRING_LOCALE_FUNCS { # Implemented by CYGPKG_LIBC_STRING, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRING_LOCALE_FUNCS # CYGINT_ISO_STRING_LOCALE_FUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRING_LOCALE_FUNCS # Requires: 1 >= CYGINT_ISO_STRING_LOCALE_FUNCS }; # Locale-specific string functions' implementation header # This covers locale-dependent string functions such as strcoll() # and strxfrm(). # cdl_option CYGBLD_ISO_STRING_LOCALE_FUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STRING # Requires: CYGBLD_ISO_STRING_LOCALE_FUNCS_HEADER == "" }; # Number of implementations of BSD string functions # cdl_interface CYGINT_ISO_STRING_BSD_FUNCS { # Implemented by CYGFUN_LIBC_STRING_BSD_FUNCS, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRING_BSD_FUNCS # CYGINT_ISO_STRING_BSD_FUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRING_BSD_FUNCS # Requires: 1 >= CYGINT_ISO_STRING_BSD_FUNCS }; # BSD string functions' implementation header # cdl_option CYGBLD_ISO_STRING_BSD_FUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # option CYGFUN_LIBC_STRING_BSD_FUNCS # Requires: CYGBLD_ISO_STRING_BSD_FUNCS_HEADER == "" }; # Number of implementations of other mem*() functions # cdl_interface CYGINT_ISO_STRING_MEMFUNCS { # Implemented by CYGPKG_LIBC_STRING, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRING_MEMFUNCS # CYGINT_ISO_STRING_MEMFUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRING_MEMFUNCS # Requires: 1 >= CYGINT_ISO_STRING_MEMFUNCS # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_STRING_MEMFUNCS }; # Other mem*() functions' implementation header # cdl_option CYGBLD_ISO_STRING_MEMFUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STRING # Requires: CYGBLD_ISO_STRING_MEMFUNCS_HEADER == "" }; # Number of implementations of other ISO C str*() functions # This covers the other str*() functions defined by ISO C. # cdl_interface CYGINT_ISO_STRING_STRFUNCS { # Implemented by CYGPKG_LIBC_STRING, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_STRING_STRFUNCS # CYGINT_ISO_STRING_STRFUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_STRING_STRFUNCS # Requires: 1 >= CYGINT_ISO_STRING_STRFUNCS # option CYGFUN_INFRA_DUMMY_STRLEN # Requires: !CYGINT_ISO_STRING_STRFUNCS # option CYGFUN_INFRA_DUMMY_STRLEN # DefaultValue: CYGINT_ISO_STRING_STRFUNCS == 0 # package CYGPKG_LIBC_STDIO # Requires: CYGINT_ISO_STRING_STRFUNCS # package CYGPKG_LIBC_STDLIB # Requires: CYGINT_ISO_STRING_STRFUNCS }; # Other ISO C str*() functions' implementation header # This covers the other str*() functions defined by ISO C. # cdl_option CYGBLD_ISO_STRING_STRFUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_STRING # Requires: CYGBLD_ISO_STRING_STRFUNCS_HEADER == "" }; # < # Clock and time functionality # cdl_component CYGPKG_ISO_TIME { # There is no associated value. }; # > # time_t implementation header # cdl_option CYGBLD_ISO_TIME_T_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # clock_t implementation header # cdl_option CYGBLD_ISO_CLOCK_T_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # struct timeval implementation header # cdl_option CYGBLD_ISO_STRUCTTIMEVAL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of POSIX timer types # cdl_interface CYGINT_ISO_POSIX_TIMER_TYPES { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_TIMER_TYPES # CYGINT_ISO_POSIX_TIMER_TYPES == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_TIMER_TYPES # Requires: 1 >= CYGINT_ISO_POSIX_TIMER_TYPES }; # POSIX timer types implementation header # cdl_option CYGBLD_ISO_POSIX_TIMER_TYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of POSIX clock types # cdl_interface CYGINT_ISO_POSIX_CLOCK_TYPES { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_CLOCK_TYPES # CYGINT_ISO_POSIX_CLOCK_TYPES == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_CLOCK_TYPES # Requires: 1 >= CYGINT_ISO_POSIX_CLOCK_TYPES }; # POSIX clock types implementation header # cdl_option CYGBLD_ISO_POSIX_CLOCK_TYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of ISO C types # cdl_interface CYGINT_ISO_C_TIME_TYPES { # Implemented by CYGPKG_LIBC_TIME, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_C_TIME_TYPES # CYGINT_ISO_C_TIME_TYPES == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_C_TIME_TYPES # Requires: 1 >= CYGINT_ISO_C_TIME_TYPES }; # ISO C time types implementation header # cdl_option CYGBLD_ISO_C_TIME_TYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_TIME # Requires: CYGBLD_ISO_C_TIME_TYPES_HEADER == "" }; # Number of implementations of POSIX timers # cdl_interface CYGINT_ISO_POSIX_TIMERS { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_TIMERS # CYGINT_ISO_POSIX_TIMERS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_TIMERS # Requires: 1 >= CYGINT_ISO_POSIX_TIMERS }; # POSIX timer implementation header # cdl_option CYGBLD_ISO_POSIX_TIMERS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of POSIX clocks # cdl_interface CYGINT_ISO_POSIX_CLOCKS { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_CLOCKS # CYGINT_ISO_POSIX_CLOCKS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_CLOCKS # Requires: 1 >= CYGINT_ISO_POSIX_CLOCKS }; # POSIX clocks implementation header # cdl_option CYGBLD_ISO_POSIX_CLOCKS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Number of implementations of ISO C clock functions # cdl_interface CYGINT_ISO_C_CLOCK_FUNCS { # Implemented by CYGPKG_LIBC_TIME, active, enabled # This value cannot be modified here. # Flavor: booldata # Current value: 1 1 # Requires: 1 >= CYGINT_ISO_C_CLOCK_FUNCS # CYGINT_ISO_C_CLOCK_FUNCS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_C_CLOCK_FUNCS # Requires: 1 >= CYGINT_ISO_C_CLOCK_FUNCS }; # ISO C clock functions' implementation header # cdl_option CYGBLD_ISO_C_CLOCK_FUNCS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_TIME # Requires: CYGBLD_ISO_C_CLOCK_FUNCS_HEADER == "" }; # Number of implementations of tzset() function # cdl_interface CYGINT_ISO_TZSET { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_TZSET # CYGINT_ISO_TZSET == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_TZSET # Requires: 1 >= CYGINT_ISO_TZSET }; # tzset() implementation header # cdl_option CYGBLD_ISO_TZSET_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Signal functionality # cdl_component CYGPKG_ISO_SIGNAL { # There is no associated value. }; # > # Number of implementations of signal numbers # cdl_interface CYGINT_ISO_SIGNAL_NUMBERS { # Implemented by CYGPKG_LIBC_SIGNALS, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_SIGNAL_NUMBERS # CYGINT_ISO_SIGNAL_NUMBERS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SIGNAL_NUMBERS # Requires: 1 >= CYGINT_ISO_SIGNAL_NUMBERS # option CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS # Requires: CYGINT_ISO_SIGNAL_NUMBERS # option CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS # DefaultValue: CYGINT_ISO_SIGNAL_NUMBERS != 0 && CYGINT_ISO_SIGNAL_IMPL != 0 }; # Signal numbering implementation header # This header provides the mapping of signal # names (e.g. SIGBUS) to numbers. # cdl_option CYGBLD_ISO_SIGNAL_NUMBERS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_SIGNALS # Requires: CYGBLD_ISO_SIGNAL_NUMBERS_HEADER == "" }; # Number of signal implementations # cdl_interface CYGINT_ISO_SIGNAL_IMPL { # Implemented by CYGPKG_LIBC_SIGNALS, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_SIGNAL_IMPL # CYGINT_ISO_SIGNAL_IMPL == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SIGNAL_IMPL # Requires: 1 >= CYGINT_ISO_SIGNAL_IMPL # option CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS # Requires: CYGINT_ISO_SIGNAL_IMPL # option CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS # DefaultValue: CYGINT_ISO_SIGNAL_NUMBERS != 0 && CYGINT_ISO_SIGNAL_IMPL != 0 }; # Signals implementation header # cdl_option CYGBLD_ISO_SIGNAL_IMPL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_SIGNALS # Requires: CYGBLD_ISO_SIGNAL_IMPL_HEADER == "" }; # POSIX real time signals feature test macro # This defines the POSIX feature test macro # that indicates that the POSIX real time signals # are present. # cdl_interface CYGINT_POSIX_REALTIME_SIGNALS { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_POSIX_REALTIME_SIGNALS # CYGINT_POSIX_REALTIME_SIGNALS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_POSIX_REALTIME_SIGNALS # Requires: 1 >= CYGINT_POSIX_REALTIME_SIGNALS }; # < # Non-local jumps functionality # cdl_component CYGPKG_ISO_SETJMP { # There is no associated value. }; # > # setjmp() / longjmp() implementations # cdl_interface CYGINT_ISO_SETJMP { # Implemented by CYGPKG_LIBC_SETJMP, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 >= CYGINT_ISO_SETJMP # CYGINT_ISO_SETJMP == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SETJMP # Requires: 1 >= CYGINT_ISO_SETJMP }; # setjmp() / longjmp() implementation header # cdl_option CYGBLD_ISO_SETJMP_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # The inferred value should not be edited directly. inferred_value 1 # value_source inferred # Default value: 0 0 # The following properties are affected by this value # package CYGPKG_LIBC_SETJMP # Requires: CYGBLD_ISO_SETJMP_HEADER == "" }; # sigsetjmp() / siglongjmp() implementations # cdl_interface CYGINT_ISO_SIGSETJMP { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_SIGSETJMP # CYGINT_ISO_SIGSETJMP == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SIGSETJMP # Requires: 1 >= CYGINT_ISO_SIGSETJMP }; # sigsetjmp() / siglongjmp() implementation header # cdl_option CYGBLD_ISO_SIGSETJMP_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Assertions implementation header # cdl_option CYGBLD_ISO_ASSERT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX file control # This covers the POSIX file control definitions, # normally found in # cdl_component CYGPKG_ISO_POSIX_FCNTL { # There is no associated value. }; # > # POSIX open flags implementation header # cdl_option CYGBLD_ISO_OFLAG_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX fcntl() implementations # cdl_interface CYGINT_ISO_FCNTL { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_FCNTL # CYGINT_ISO_FCNTL == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_FCNTL # Requires: 1 >= CYGINT_ISO_FCNTL }; # POSIX fcntl() implementation header # cdl_option CYGBLD_ISO_FCNTL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX file open implementations # cdl_interface CYGINT_ISO_OPEN { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_OPEN # CYGINT_ISO_OPEN == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_OPEN # Requires: 1 >= CYGINT_ISO_OPEN }; # POSIX file open implementation header # cdl_option CYGBLD_ISO_OPEN_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # definitions implementation header # cdl_option CYGBLD_ISO_STAT_DEFS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX directory reading implementation # cdl_interface CYGINT_ISO_DIRENT { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_DIRENT # CYGINT_ISO_DIRENT == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_DIRENT # Requires: 1 >= CYGINT_ISO_DIRENT }; # definitions implementation header # cdl_option CYGBLD_ISO_DIRENT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX contents # This covers the types required by POSIX to be in # # cdl_component CYGPKG_ISO_POSIX_TYPES { # There is no associated value. }; # > # POSIX thread types implementations # cdl_interface CYGINT_ISO_PTHREADTYPES { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_PTHREADTYPES # CYGINT_ISO_PTHREADTYPES == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_PTHREADTYPES # Requires: 1 >= CYGINT_ISO_PTHREADTYPES # interface CYGINT_ISO_PMUTEXTYPES # Requires: 1 >= CYGINT_ISO_PTHREADTYPES }; # POSIX thread types implementation header # cdl_option CYGBLD_ISO_PTHREADTYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX mutex types implementations # cdl_interface CYGINT_ISO_PMUTEXTYPES { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_PTHREADTYPES # CYGINT_ISO_PTHREADTYPES == 0 # --> 1 }; # POSIX mutex types implementation header # cdl_option CYGBLD_ISO_PMUTEXTYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # ssize_t implementation header # cdl_option CYGBLD_ISO_SSIZE_T_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Filesystem types implementation header # cdl_option CYGBLD_ISO_FSTYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # gid_t, pid_t, uid_t implementation header # cdl_option CYGBLD_ISO_SCHEDTYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Non-POSIX contents # This covers the extra types required by non-POSIX # packages to be in . These would normally # only be visible if _POSIX_SOURCE is not defined. # cdl_component CYGPKG_ISO_EXTRA_TYPES { # There is no associated value. }; # > # BSD compatible types # cdl_interface CYGINT_ISO_BSDTYPES { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_BSDTYPES # CYGINT_ISO_BSDTYPES == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_BSDTYPES # Requires: 1 >= CYGINT_ISO_BSDTYPES }; # BSD types header # cdl_option CYGBLD_ISO_BSDTYPES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Utsname structure # cdl_component CYGPKG_ISO_UTSNAME { # There is no associated value. }; # > # Utsname header # cdl_option CYGBLD_ISO_UTSNAME_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # POSIX scheduler # cdl_component CYGPKG_ISO_SCHED { # There is no associated value. }; # > # POSIX scheduler implementations # cdl_interface CYGINT_ISO_SCHED_IMPL { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_SCHED_IMPL # CYGINT_ISO_SCHED_IMPL == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SCHED_IMPL # Requires: 1 >= CYGINT_ISO_SCHED_IMPL }; # POSIX scheduler implementation header # cdl_option CYGBLD_ISO_SCHED_IMPL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # POSIX semaphores # cdl_component CYGPKG_ISO_SEMAPHORES { # There is no associated value. }; # > # POSIX semaphore implementations # cdl_interface CYGINT_ISO_SEMAPHORES { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_SEMAPHORES # CYGINT_ISO_SEMAPHORES == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SEMAPHORES # Requires: 1 >= CYGINT_ISO_SEMAPHORES }; # POSIX semaphore implementation header # cdl_option CYGBLD_ISO_SEMAPHORES_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # POSIX message queues # cdl_component CYGPKG_ISO_MQUEUE { # There is no associated value. }; # > # Implementations # cdl_interface CYGINT_ISO_MQUEUE { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_MQUEUE # CYGINT_ISO_MQUEUE == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_MQUEUE # Requires: 1 >= CYGINT_ISO_MQUEUE # option CYGNUM_ISO_MQUEUE_OPEN_MAX # ActiveIf: CYGINT_ISO_MQUEUE # option CYGNUM_ISO_MQUEUE_PRIO_MAX # ActiveIf: CYGINT_ISO_MQUEUE }; # Implementation header # cdl_option CYGBLD_ISO_MQUEUE_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Maximum number of open message queues # cdl_option CYGNUM_ISO_MQUEUE_OPEN_MAX { # This option is not active # ActiveIf constraint: CYGINT_ISO_MQUEUE # CYGINT_ISO_MQUEUE == 0 # --> 0 # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: CYGNUM_POSIX_MQUEUE_OPEN_MAX > 0 ? CYGNUM_POSIX_MQUEUE_OPEN_MAX : 0 # CYGNUM_POSIX_MQUEUE_OPEN_MAX (unknown) == 0 # CYGNUM_POSIX_MQUEUE_OPEN_MAX (unknown) == 0 # --> 0 0 }; # Maximum number of message priorities # cdl_option CYGNUM_ISO_MQUEUE_PRIO_MAX { # This option is not active # ActiveIf constraint: CYGINT_ISO_MQUEUE # CYGINT_ISO_MQUEUE == 0 # --> 0 # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 1 65535 # value_source default # Default value: 1 65535 }; # < # POSIX threads # cdl_component CYGPKG_ISO_PTHREAD { # There is no associated value. }; # > # POSIX pthread implementations # cdl_interface CYGINT_ISO_PTHREAD_IMPL { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_PTHREAD_IMPL # CYGINT_ISO_PTHREAD_IMPL == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_PTHREAD_IMPL # Requires: 1 >= CYGINT_ISO_PTHREAD_IMPL }; # POSIX pthread implementation header # cdl_option CYGBLD_ISO_PTHREAD_IMPL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX mutex/cond var implementations # cdl_interface CYGINT_ISO_PTHREAD_MUTEX { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_PTHREAD_MUTEX # CYGINT_ISO_PTHREAD_MUTEX == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_PTHREAD_MUTEX # Requires: 1 >= CYGINT_ISO_PTHREAD_MUTEX }; # POSIX mutex/cond var implementation header # cdl_option CYGBLD_ISO_PTHREAD_MUTEX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Limits # cdl_component CYGPKG_ISO_LIMITS { # There is no associated value. }; # > # POSIX pthread limits implementations # cdl_interface CYGINT_ISO_POSIX_LIMITS { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_POSIX_LIMITS # CYGINT_ISO_POSIX_LIMITS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_LIMITS # Requires: 1 >= CYGINT_ISO_POSIX_LIMITS }; # POSIX pthread limits implementation header # cdl_option CYGBLD_ISO_POSIX_LIMITS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # OPEN_MAX implementation header # cdl_option CYGBLD_ISO_OPEN_MAX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # LINK_MAX implementation header # cdl_option CYGBLD_ISO_LINK_MAX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # NAME_MAX implementation header # cdl_option CYGBLD_ISO_NAME_MAX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # PATH_MAX implementation header # cdl_option CYGBLD_ISO_PATH_MAX_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # POSIX termios # cdl_component CYGPKG_ISO_TERMIOS { # There is no associated value. }; # > # POSIX termios implementations # cdl_interface CYGINT_ISO_TERMIOS { # Implemented by CYGPKG_IO_SERIAL_TERMIOS, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_TERMIOS # CYGINT_ISO_TERMIOS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_TERMIOS # Requires: 1 >= CYGINT_ISO_TERMIOS }; # POSIX termios implementation header # cdl_option CYGBLD_ISO_TERMIOS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Dynamic load API # cdl_component CYGPKG_ISO_DLFCN { # There is no associated value. }; # > # Dynamic load implementations # cdl_interface CYGINT_ISO_DLFCN { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # Requires: 1 >= CYGINT_ISO_DLFCN # CYGINT_ISO_DLFCN == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_DLFCN # Requires: 1 >= CYGINT_ISO_DLFCN }; # Dynamic load implementation header # cdl_option CYGBLD_ISO_DLFCN_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # UNIX standard functions # cdl_component CYGPKG_ISO_UNISTD { # There is no associated value. }; # > # POSIX timer operations implementations # cdl_interface CYGINT_ISO_POSIX_TIMER_OPS { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_TIMER_OPS # CYGINT_ISO_POSIX_TIMER_OPS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_TIMER_OPS # Requires: 1 >= CYGINT_ISO_POSIX_TIMER_OPS }; # POSIX timer operations implementation header # cdl_option CYGBLD_ISO_POSIX_TIMER_OPS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # POSIX sleep() implementations # cdl_interface CYGINT_ISO_POSIX_SLEEP { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POSIX_SLEEP # CYGINT_ISO_POSIX_SLEEP == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POSIX_SLEEP # Requires: 1 >= CYGINT_ISO_POSIX_SLEEP }; # POSIX sleep() implementation header # cdl_option CYGBLD_ISO_POSIX_SLEEP_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # select()/poll() functions # cdl_component CYGPKG_ISO_SELECT { # There is no associated value. }; # > # select() implementations # cdl_interface CYGINT_ISO_SELECT { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_SELECT # CYGINT_ISO_SELECT == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_SELECT # Requires: 1 >= CYGINT_ISO_SELECT }; # select() implementation header # cdl_option CYGBLD_ISO_SELECT_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # poll() implementations # cdl_interface CYGINT_ISO_POLL { # No options implement this inferface # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: 1 >= CYGINT_ISO_POLL # CYGINT_ISO_POLL == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_POLL # Requires: 1 >= CYGINT_ISO_POLL }; # poll() implementation header # cdl_option CYGBLD_ISO_POLL_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # NetDB utility functions # cdl_component CYGPKG_ISO_NETDB { # There is no associated value. }; # > # DNS implementations # cdl_interface CYGINT_ISO_DNS { # No options implement this inferface # This value cannot be modified here. # Flavor: bool # Current value: 0 # Requires: 1 >= CYGINT_ISO_DNS # CYGINT_ISO_DNS == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_DNS # Requires: 1 >= CYGINT_ISO_DNS }; # DNS implementation header # cdl_option CYGBLD_ISO_DNS_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Protocol network database implementations # cdl_interface CYGINT_ISO_NETDB_PROTO { # No options implement this inferface # This value cannot be modified here. # Flavor: bool # Current value: 0 # Requires: 1 >= CYGINT_ISO_NETDB_PROTO # CYGINT_ISO_NETDB_PROTO == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_NETDB_PROTO # Requires: 1 >= CYGINT_ISO_NETDB_PROTO }; # Protocol network database implementation header # cdl_option CYGBLD_ISO_NETDB_PROTO_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # Services network database implementations # cdl_interface CYGINT_ISO_NETDB_SERV { # No options implement this inferface # This value cannot be modified here. # Flavor: bool # Current value: 0 # Requires: 1 >= CYGINT_ISO_NETDB_SERV # CYGINT_ISO_NETDB_SERV == 0 # --> 1 # The following properties are affected by this value # interface CYGINT_ISO_NETDB_SERV # Requires: 1 >= CYGINT_ISO_NETDB_SERV }; # Services network database implementation header # cdl_option CYGBLD_ISO_NETDB_SERV_HEADER { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 0 0 # value_source default # Default value: 0 0 }; # < # Build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_ISOINFRA_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the ISO C and POSIX infrastructure package. # These flags are used in addition to the set of global flags. # cdl_option CYGPKG_ISOINFRA_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the ISO C and POSIX infrastructure package. # These flags are removed from the set of global flags # if present. # cdl_option CYGPKG_ISOINFRA_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # < # < # ISO C library # doc: ref/libc.html # The packages under this package enable compatibility with the ISO C # standard - ISO/IEC 9899:1990. This allows the user application to use # well known standard C library functions, and in eCos starts a thread # to invoke the user function main(). This package is a top-level placeholder # to contain the implementations. # cdl_package CYGPKG_LIBC { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # component CYGNUM_LIBM_COMPATIBILITY # Requires: CYGPKG_LIBC }; # > # ISO C library internationalization functions # doc: ref/libc.html # This package provides internationalization functions specified by the # ISO C standard - ISO/IEC 9899:1990. These include locale-related # functionality and functionality. # cdl_package CYGPKG_LIBC_I18N { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # The following properties are affected by this value # package CYGPKG_LIBC_STDIO # Requires: CYGPKG_LIBC_I18N }; # > # Supported locales # These options determine which locales other than the "C" locale # are supported and hence contribute to the size of the executable. # cdl_component CYGPKG_LIBC_I18N_LOCALES { # There is no associated value. }; # > # Support for multiple locales required # cdl_interface CYGINT_LIBC_I18N_MB_REQUIRED { # Implemented by CYGFUN_LIBC_I18N_LOCALE_C_SJIS, active, disabled # Implemented by CYGFUN_LIBC_I18N_LOCALE_C_JIS, active, disabled # Implemented by CYGFUN_LIBC_I18N_LOCALE_C_EUCJP, active, disabled # This value cannot be modified here. # Flavor: booldata # Current value: 0 0 # Requires: CYGBLD_ISO_STDLIB_MB_CUR_MAX_HEADER == "" # CYGBLD_ISO_STDLIB_MB_CUR_MAX_HEADER == 0 # --> 0 # The following properties are affected by this value }; # C-SJIS locale support # This option controls if the "C-SJIS" locale will be # supported by setlocale(). The locale is a hybrid locale # that is mostly the "C" locale with Japanese SJIS multibyte # support added. # cdl_option CYGFUN_LIBC_I18N_LOCALE_C_SJIS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # LegalValues: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) to 0x7fffffff # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # DefaultValue: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) }; # C-JIS locale support # This option controls if the "C-JIS" locale will be # supported by setlocale(). The locale is a hybrid locale # that is mostly the "C" locale with Japanese JIS multibyte # support added. # cdl_option CYGFUN_LIBC_I18N_LOCALE_C_JIS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # LegalValues: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) to 0x7fffffff # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # DefaultValue: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) }; # C-EUCJP locale support # This option controls if the "C-EUCJP" locale will be # supported by setlocale(). The locale is a hybrid locale # that is mostly the "C" locale with Japanese EUCJP multibyte # support added. # cdl_option CYGFUN_LIBC_I18N_LOCALE_C_EUCJP { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # LegalValues: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) to 0x7fffffff # option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE # DefaultValue: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) }; # < # Per-thread multibyte state # This option controls whether the multibyte character # handling functions mblen(), mbtowc(), and wctomb(), # have their state recorded on a per-thread # basis rather than global. If this option is # disabled, some per-thread space can be saved. # Enabling this option will use three slots # of kernel per-thread data. You should ensure you # have enough slots configured for all your # per-thread data. # cdl_option CYGSEM_LIBC_I18N_PER_THREAD_MB { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 }; # Size of locale name strings # This option controls the maximum size of # locale names and is used, among other things # to instantiate a static string used # as a return value from the # setlocale() function. When requesting the # current locale settings with LC_ALL, a string # must be constructed to contain this data, rather # than just returning a constant string. This # string data is stored in the static string. # This depends on the length of locale names, # hence this option. If just the C locale is # present, this option can be set as low as 2. # cdl_option CYGNUM_LIBC_I18N_MAX_LOCALE_NAME_SIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 2 # value_source default # Default value: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) # CYGFUN_LIBC_I18N_LOCALE_C_EUCJP == 0 # CYGFUN_LIBC_I18N_LOCALE_C_SJIS == 0 # CYGFUN_LIBC_I18N_LOCALE_C_JIS == 0 # --> 2 # Legal values: (CYGFUN_LIBC_I18N_LOCALE_C_EUCJP ? 8 : (CYGFUN_LIBC_I18N_LOCALE_C_SJIS ? 7 : (CYGFUN_LIBC_I18N_LOCALE_C_JIS ? 6 : 2))) to 0x7fffffff # CYGFUN_LIBC_I18N_LOCALE_C_EUCJP == 0 # CYGFUN_LIBC_I18N_LOCALE_C_SJIS == 0 # CYGFUN_LIBC_I18N_LOCALE_C_JIS == 0 }; # Inline versions of functions # This option chooses whether the simple character # classification and conversion functions (e.g. # isupper(), isalpha(), toupper(), etc.) # from are available as inline # functions. This may improve performance and as # the functions are small, may even improve code # size. # cdl_option CYGIMP_LIBC_I18N_CTYPE_INLINES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_CTYPE_HEADER == "" # CYGBLD_ISO_CTYPE_HEADER == # --> 1 }; # C library i18n functions build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_I18N_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_I18N_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_I18N_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library i18n function tests # This option specifies the set of tests for the C library # i18n functions. # cdl_option CYGPKG_LIBC_I18N_TESTS { # Calculated value: "tests/ctype tests/setlocale tests/i18nmb" # Flavor: data # Current_value: tests/ctype tests/setlocale tests/i18nmb }; # < # < # ISO C library setjmp/longjmp functions # doc: ref/libc.html # This package provides non-local jumps based on setjmp() and # longjmp() in as specified by the ISO C # standard - ISO/IEC 9899:1990. # cdl_package CYGPKG_LIBC_SETJMP { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGBLD_ISO_SETJMP_HEADER == "" # CYGBLD_ISO_SETJMP_HEADER == # --> 1 }; # > # C library setjmp build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_SETJMP_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building this package. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_SETJMP_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building this package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_SETJMP_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library setjmp tests # This option specifies the set of tests for this package. # cdl_option CYGPKG_LIBC_SETJMP_TESTS { # Calculated value: "tests/setjmp" # Flavor: data # Current_value: tests/setjmp }; # < # < # ISO C library signal functions # doc: ref/libc.html # This component controls signal functionality, # as implemented in ISO/IEC 9899:1990 chapter 7.7 with # the signal() and raise() functions. As well as # allowing a program to send itself signals, it is # also possible to cause hardware exceptions to # be signalled to the program in a similar way. # cdl_package CYGPKG_LIBC_SIGNALS { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGBLD_ISO_SIGNAL_NUMBERS_HEADER == "" # CYGBLD_ISO_SIGNAL_NUMBERS_HEADER == # --> 1 # Requires: CYGBLD_ISO_SIGNAL_IMPL_HEADER == "" # CYGBLD_ISO_SIGNAL_IMPL_HEADER == # --> 1 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 }; # > # Thread safe signals # Because signal handlers are global, and not # thread-specific (as mandated by POSIX 1003.1) # it is possible for multiple threads to clash # and corrupt data if setting the same signal # handler at the same time. With this option # enabled, a kernel mutex will be used to protect # the shared data. # cdl_option CYGSEM_LIBC_SIGNALS_THREAD_SAFE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # Hardware exceptions cause signals # This causes hardware exceptions like # arithmetic exceptions (e.g. divide by zero) # or bad memory accesses to be passed through as # signals. It is thus possible for a program to # handle these exceptions in a generic way using # the appropriate signal handlers. The details of # exactly which exceptions are passed through # under what circumstances depend on the # underlying HAL implementation. Consequently it # must be remembered that signal handlers cannot # be guaranteed to be invoked in the expected # circumstances if you do not know about the # underlying HAL implementation - it is possible # that the architecture is unable to detect that # exception. # cdl_component CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGSEM_KERNEL_EXCEPTIONS_GLOBAL # CYGSEM_KERNEL_EXCEPTIONS_GLOBAL == 1 # --> 1 # Requires: CYGSEM_KERNEL_EXCEPTIONS_DECODE # CYGSEM_KERNEL_EXCEPTIONS_DECODE == 0 # --> 0 # The following properties are affected by this value # option CYGPKG_LIBC_SIGNALS_TESTS # Calculated: # "tests/signal1" # . ((CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS) ? " tests/signal2" : "") # }; # > # Chain old exception handlers # When hardware exceptions are generated, it # is possible to chain into the old kernel exception # handler before calling any registered signal # handler. If this is not required, disable this # option and only the signal handler will be # called when this exception occurs. Disabling # this option will also save some space and code # usage. # cdl_option CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS { # This option is not active # The parent CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS is disabled # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Inline versions of functions # Some functions can be made inline instead of # being function calls. These can be set here. # cdl_component CYGPKG_LIBC_SIGNALS_INLINE { # There is no associated value. }; # > # raise() # Enabling this option makes raise() an inline function. # cdl_option CYGIMP_LIBC_SIGNALS_RAISE_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # signal() # Enabling this option makes signal() an inline function. # cdl_option CYGIMP_LIBC_SIGNALS_SIGNAL_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # < # Error handling # You may or may not want errno to be set by # certain functions. Not using errno could save # both space, code, and avoid worrying about # interactions between multiple threads when # setting it. # cdl_component CYGPKG_LIBC_SIGNALS_ERROR_HANDLING { # There is no associated value. }; # > # Bad signal fatal # 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. # cdl_option CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGDBG_USE_ASSERTS # CYGDBG_USE_ASSERTS == 0 # --> 0 }; # raise() sets errno # 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(). # cdl_option CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGINT_ISO_ERRNO # CYGINT_ISO_ERRNO == 1 # --> 1 # Requires: CYGINT_ISO_ERRNO_CODES # CYGINT_ISO_ERRNO_CODES == 1 # --> 1 }; # signal() sets errno # 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(). # cdl_option CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGINT_ISO_ERRNO # CYGINT_ISO_ERRNO == 1 # --> 1 # Requires: CYGINT_ISO_ERRNO_CODES # CYGINT_ISO_ERRNO_CODES == 1 # --> 1 }; # < # Tracing # These options control the trace output for the C # library internal signal implementation. # cdl_component CYGPKG_LIBC_SIGNALS_TRACING { # There is no associated value. }; # > # Default trace level for raise() # This gives the default tracing level for the # raise() function. Higher numbers are more # verbose. # cdl_option CYGNUM_LIBC_SIGNALS_RAISE_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # Default hardware exception handler trace level # This gives the default tracing level for the # hardware exception handler function (if enabled). # Higher numbers are more verbose. # cdl_option CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # < # C library signal functions build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_SIGNALS_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_SIGNALS_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_SIGNALS_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library signal function tests # This option specifies the set of tests for the C library # signal functions. # cdl_option CYGPKG_LIBC_SIGNALS_TESTS { # Calculated value: # "tests/signal1" # . ((CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS) ? " tests/signal2" : "") # # CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS == 0 # Flavor: data # Current_value: tests/signal1 }; # < # < # ISO environment startup/termination # doc: ref/c-library-startup.html # This package manages the control of the # environment (in the general sense) that an # application would require for full ISO C / POSIX # 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. # cdl_package CYGPKG_LIBC_STARTUP { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGINT_LIBC_STARTUP_CONTEXT == 1 # CYGINT_LIBC_STARTUP_CONTEXT == 1 # --> 1 }; # > # main() can be invoked elsewhere # Implementors of this interface show that they # allow main() to be invoked elsewhere. # cdl_interface CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE { # No options implement this inferface # This value cannot be modified here. # Flavor: bool # Current value: 0 # The following properties are affected by this value # option CYGSEM_LIBC_STARTUP_MAIN_INITCONTEXT # DefaultValue: 0 == CYGPKG_KERNEL && 0 == # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # component CYGSEM_LIBC_STARTUP_MAIN_THREAD # DefaultValue: 0 != CYGPKG_KERNEL && 0 == CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # option CYGSEM_LIBC_STARTUP_MAIN_OTHER # DefaultValue: 0 != CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # option CYGSEM_LIBC_STARTUP_MAIN_OTHER # Requires: CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE }; # Arguments to main() # 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. # cdl_option CYGDAT_LIBC_ARGUMENTS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "{\"\", NULL}" # value_source default # Default value: "{\"\", NULL}" }; # Startup context for main() # This component describes the options available for # what context main() is invoked in, such as in a thread # etc. # cdl_component CYGPKG_LIBC_STARTUP_CONTEXT { # There is no associated value. }; # > # Startup context implementors # cdl_interface CYGINT_LIBC_STARTUP_CONTEXT { # Implemented by CYGSEM_LIBC_STARTUP_MAIN_INITCONTEXT, active, disabled # Implemented by CYGSEM_LIBC_STARTUP_MAIN_THREAD, active, enabled # Implemented by CYGSEM_LIBC_STARTUP_MAIN_OTHER, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # The following properties are affected by this value # package CYGPKG_LIBC_STARTUP # Requires: CYGINT_LIBC_STARTUP_CONTEXT == 1 }; # Invoked from initialization context # With this option selected, main() will be # called via cyg_user_start() (unless the program # overrides the default cyg_user_start()). This # means it is run in the context of the system # initialization code, without the eCos kernel # scheduler running, and using the startup 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. # cdl_option CYGSEM_LIBC_STARTUP_MAIN_INITCONTEXT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 == CYGPKG_KERNEL && 0 == # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # CYGPKG_KERNEL == v2_0 # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE == 0 # --> 0 }; # Invoked as eCos thread # With this option selected, main() is invoked from an eCos # thread. # cdl_component CYGSEM_LIBC_STARTUP_MAIN_THREAD { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_KERNEL && 0 == CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # CYGPKG_KERNEL == v2_0 # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE == 0 # --> 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # The following properties are affected by this value # option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS # Requires: CYGSEM_LIBC_STARTUP_MAIN_THREAD || (CYGSEM_LIBC_STARTUP_MAIN_OTHER && CYGPKG_POSIX_PTHREAD) }; # > # System provides stack for main()'s thread # This option controls whether the stack of # main()'s thread is provided by the application or # provided by the system. When disabled, the # application must declare a pointer variable # cyg_libc_main_stack which is a pointer to an # appropriately aligned region of memory. The # application must also declare a variable of # type `int' called cyg_libc_main_stack_size # which contains the size of the stack in bytes. # This must be a multiple of 8. # cdl_option CYGSEM_LIBC_MAIN_STACK_FROM_SYSTEM { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Priority of main()'s thread # This option is used to provide the thread # priority which main()'s thread runs at. Be # sure to check that this number is appropriate # for the kernel scheduler chosen. Different # kernel schedulers impose different restrictions # on the usable priorities. # cdl_option CYGNUM_LIBC_MAIN_THREAD_PRIORITY { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 10 # value_source default # Default value: 10 # Legal values: 0 to 0x7fffffff }; # < # Invoked elsewhere # With this option selected, main() must be # invoked by a separate package, or by the user. # cdl_option CYGSEM_LIBC_STARTUP_MAIN_OTHER { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 != CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE == 0 # --> 0 # Requires: CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE # CYGINT_LIBC_STARTUP_EXTERNAL_INVOKE_MAIN_POSSIBLE == 0 # --> 0 # The following properties are affected by this value # option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS # Requires: CYGSEM_LIBC_STARTUP_MAIN_THREAD || (CYGSEM_LIBC_STARTUP_MAIN_OTHER && CYGPKG_POSIX_PTHREAD) }; # < # Don't allow main()'s stack size to be set # This interface describes whether the stack size # value set in this package is supported by the # implementation that invokes main. If not, that # option is disabled. # cdl_interface CYGINT_LIBC_STARTUP_MAIN_NO_STACK_SIZE { # Implemented by CYGSEM_LIBC_STARTUP_MAIN_INITCONTEXT, active, disabled # This value cannot be modified here. # Flavor: bool # Current value: 0 # The following properties are affected by this value # option CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE # ActiveIf: !CYGINT_LIBC_STARTUP_MAIN_NO_STACK_SIZE }; # main()'s default thread stack size # This option sets the size of the stack used # in the context that invokes main(). For example, # 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. This option cannot be set if the implementation # that invokes main() does not use it. # cdl_option CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE { # ActiveIf constraint: !CYGINT_LIBC_STARTUP_MAIN_NO_STACK_SIZE # CYGINT_LIBC_STARTUP_MAIN_NO_STACK_SIZE == 0 # --> 1 # Flavor: data # No user value, uncomment the following line to provide one. # user_value 8192 # value_source default # Default value: 8192 # Legal values: 16 to 0x7fffffff }; # Include atexit() function # 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. # cdl_component CYGFUN_LIBC_ATEXIT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # > # Number of functions atexit() supports # 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. # cdl_option CYGNUM_LIBC_ATEXIT_HANDLERS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 32 # value_source default # Default value: 32 # Legal values: 1 to 0x7fffffff }; # < # Make exit() call fflush() # This option will ensure that all output # streams are flushed when exitting using # exit() as prescribed by the ISO C standard. # cdl_option CYGSEM_LIBC_EXIT_CALLS_FFLUSH { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGINT_ISO_STDIO_FILEACCESS # CYGINT_ISO_STDIO_FILEACCESS == 1 # --> 1 # Requires: CYGINT_ISO_STDIO_FILEACCESS # CYGINT_ISO_STDIO_FILEACCESS == 1 # --> 1 }; # _exit() stops all threads # 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 # leave this option disabled. If there is no eCos # scheduler, then _exit() simply loops # irrespective of the setting of this option. # cdl_option CYGSEM_LIBC_EXIT_STOPS_SYSTEM { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # Default environment # 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. # cdl_option CYGDAT_LIBC_DEFAULT_ENVIRONMENT { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "{ NULL }" # value_source default # Default value: "{ NULL }" }; # Invoke default static constructors # 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. # cdl_option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG # CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG == 0 # --> 0 # Requires: CYGSEM_LIBC_STARTUP_MAIN_THREAD || (CYGSEM_LIBC_STARTUP_MAIN_OTHER && CYGPKG_POSIX_PTHREAD) # CYGSEM_LIBC_STARTUP_MAIN_THREAD == 1 # CYGSEM_LIBC_STARTUP_MAIN_OTHER == 0 # CYGPKG_POSIX_PTHREAD (unknown) == 0 # --> 1 # The following properties are affected by this value # option CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG # Requires: CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS }; # ISO environment startup/termination build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_STARTUP_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building this package. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_STARTUP_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building this package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_STARTUP_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # ISO environment startup/termination tests # This option specifies the set of tests for this package. # cdl_option CYGPKG_LIBC_STARTUP_TESTS { # Calculated value: "tests/atexit" # Flavor: data # Current_value: tests/atexit }; # < # < # ISO C library standard input/output functions # doc: ref/libc.html # This package provides standard input/output functions associated # with the header file as specified by the # ISO C standard - ISO/IEC 9899:1990. # cdl_package CYGPKG_LIBC_STDIO { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_IO # CYGPKG_IO == v2_0 # --> 1 # Requires: CYGPKG_IO_SERIAL_HALDIAG # CYGPKG_IO_SERIAL_HALDIAG == 1 # --> 1 # Requires: CYGPKG_LIBC_I18N # CYGPKG_LIBC_I18N == v2_0 # --> 1 # Requires: CYGBLD_ISO_STDIO_FILETYPES_HEADER == "" # CYGBLD_ISO_STDIO_FILETYPES_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_FILEACCESS_HEADER == "" # CYGBLD_ISO_STDIO_FILEACCESS_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_FORMATTED_IO_HEADER == "" # CYGBLD_ISO_STDIO_FORMATTED_IO_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_CHAR_IO_HEADER == "" # CYGBLD_ISO_STDIO_CHAR_IO_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_DIRECT_IO_HEADER == "" # CYGBLD_ISO_STDIO_DIRECT_IO_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_ERROR_HEADER == "" # CYGBLD_ISO_STDIO_ERROR_HEADER == # --> 1 # Requires: CYGBLD_ISO_STDIO_STREAMS_HEADER == "" # CYGBLD_ISO_STDIO_STREAMS_HEADER == # --> 1 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGINT_ISO_ERRNO_CODES # CYGINT_ISO_ERRNO_CODES == 1 # --> 1 # Requires: CYGINT_ISO_ERRNO # CYGINT_ISO_ERRNO == 1 # --> 1 # Requires: CYGINT_ISO_STRERROR # CYGINT_ISO_STRERROR == 1 # --> 1 # Requires: CYGINT_ISO_STRING_STRFUNCS # CYGINT_ISO_STRING_STRFUNCS == 1 # --> 1 # Requires: CYGINT_ISO_STRING_MEMFUNCS # CYGINT_ISO_STRING_MEMFUNCS == 1 # --> 1 # Requires: CYGINT_ISO_STDLIB_STRCONV # CYGINT_ISO_STDLIB_STRCONV == 1 # --> 1 # The following properties are affected by this value # option CYGSEM_LIBM_USE_STDERR # Requires: CYGPKG_LIBC_STDIO }; # > # Inline versions of functions # This option chooses whether some of the # particularly simple functions from # are available as inline # functions. This may improve performance, and as # the functions are small, may even improve code # size. # cdl_option CYGIMP_LIBC_STDIO_INLINES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Permitted number of open files # This option controls the guaranteed minimum # number of simultaneously open files. The ISO # C standard requires it to be defined (para # 7.9.1), and if strictly compliant, it must be # at least 8 (para 7.9.3). In practice it can be # as low as 3 - for stdin, stdout and stderr. # cdl_option FOPEN_MAX { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 8 # value_source default # Default value: 8 # Legal values: 3 to 0x7fffffff }; # Maximum length of filename # This option defines the maximum allowed size of # a filename in characters. The ISO C standard # requires it to be defined (para 7.9.1). # cdl_option FILENAME_MAX { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 16 # value_source default # Default value: 16 # Legal values: 1 to 0x7fffffff }; # Maximum length of filenames for temporary files # This option defines the maximum allowed size of # filenames for temporary files as generated by # tmpnam(). It is measured in characters, and the # ISO C standard requires it to be defined (para # 7.9.1). # cdl_option L_tmpnam { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 16 # value_source default # Default value: 16 # Legal values: 1 to 0x7fffffff }; # Unique file names generated by tmpnam() # This option defines the minimum number of # unique file names generated by tmpnam(). The # ISO C standard requires it to be defined (para # 7.9.1). # cdl_option TMP_MAX { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 0x7fffffff }; # Buffered I/O # This option controls whether input/output # through the functions is buffered. # This may save some memory per file. It # is equivalent to putting every file into # non-buffered mode (_IONBF) through setvbuf(), # except now it can never be altered back to # buffered mode. Disabling buffering is strictly # non-compliant with the ISO C standard. # cdl_component CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option BUFSIZ # Calculated: CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO ? CYGNUM_LIBC_STDIO_BUFSIZE : 0 # option CYGPKG_LIBC_STDIO_FILEIO # Requires: CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO }; # > # Default buffer size # This option defines the default size of buffer # used with calls to setbuf(), and is the default # size for buffered streams that have not had # either setbuf() or setvbuf() invoked on them. # It is exactly equivalent to the standard # constant BUFSIZ, except that it is 0 if # CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO is disabled. # The ISO C standard requires this to be defined # (para 7.9.1), and says it must be at least 256 # (para 7.9.2). # cdl_option CYGNUM_LIBC_STDIO_BUFSIZE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 256 # value_source default # Default value: 256 # Legal values: 1 to 0x7fffffff # The following properties are affected by this value # option BUFSIZ # Calculated: CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO ? CYGNUM_LIBC_STDIO_BUFSIZE : 0 }; # setbuf()/setvbuf() allows dynamic setting # This option controls whether I/O buffers are # implemented dynamically within the stdio # implementation. Otherwise they will be static, # and cannot be changed by setbuf()/setvbuf(). If # they are static (i.e. this option is disabled), # any attempt to use an arbitrary buffer size, or # to pass a user-supplied buffer to setbuf() or # setvbuf() will fail - the buffer is implemented # internally as a static array taking the size # of the configuration option BUFSIZ. The only # exception is if a user buffer is not supplied, # and the buffer size requested is less than # BUFSIZ. In this case, the buffer will # be configured to only use that amount of # buffering. However the unused memory left over # will NOT be freed. If this option is enabled, # then setvbuf() can be used to assign a user supplied # buffer to the stream. # Either setting can be considered to # be compliant with the ISO C standard. # cdl_option CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # The following properties are affected by this value # option CYGSEM_LIBC_STDIO_SETVBUF_MALLOC # Requires: CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF }; # setbuf()/setvbuf() uses malloc() # This option controls whether buffers set by setbuf() and # setvbuf() may be allocated using malloc(). # cdl_option CYGSEM_LIBC_STDIO_SETVBUF_MALLOC { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 # Requires: CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 # Requires: CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF # CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF == 1 # --> 1 }; # < # Default buffer size (BUFSIZ) # cdl_option BUFSIZ { # Calculated value: CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO ? CYGNUM_LIBC_STDIO_BUFSIZE : 0 # CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO == 1 # CYGNUM_LIBC_STDIO_BUFSIZE == 256 # Flavor: data # Current_value: 256 }; # Support for ungetc() # This option controls whether ungetc() is # supported. If not, then some space can be # saved, and speed is improved. Note that you # MUST have this defined if you want to use the # scanf() family of functions. # cdl_option CYGFUN_LIBC_STDIO_ungetc { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Dynamic opening/closing of files # fopen() and fclose() use dynamic memory # allocation routines to allocate memory for # new FILE structure pointers. If a malloc # implementation is available, this option # may be enabled to use # fopen() and fclose(). If disabled, only the # default console streams - stdin, stdout and # stderr - will be available. # cdl_option CYGPKG_LIBC_STDIO_OPEN { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 # Requires: CYGINT_ISO_MALLOC # CYGINT_ISO_MALLOC == 1 # --> 1 }; # Default console device # This option allows you to choose the # default console device. In the current # implementation, all these devices begin # with the prefix /dev/ and are followed by # the name of a device. The name of the device # depends on the device drivers you have # configured in your system. For example, # /dev/ttydiag could be the HAL diagnostic output # pseudo-device, or /dev/tty0 could be your # first serial driver, depending on your # configuration. # cdl_option CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "\"/dev/ttydiag\"" # value_source default # Default value: CYGDAT_IO_SERIAL_TTY_CONSOLE # CYGDAT_IO_SERIAL_TTY_CONSOLE == "\"/dev/ttydiag\"" # --> "\"/dev/ttydiag\"" }; # Floating point support # This component allows floating point support # to be enabled in certain standard I/O # functions. # cdl_component CYGPKG_LIBC_STDIO_FLOATING_POINT { # There is no associated value. }; # > # printf() family # This option enables the use of floating point # number output in the printf() family (i.e. # printf(), sprintf(), vprintf(), etc.) of # functions. A substantial amount of code space # can be saved if this option is disabled. If it # is disabled then floating point specifiers # (%e, %f, %g) are ignored, and nothing is # output. # cdl_option CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_LIBM # CYGPKG_LIBM == v2_0 # --> 1 # Requires: CYGPKG_LIBM # CYGPKG_LIBM == v2_0 # --> 1 }; # scanf() family # This option enables the use of floating point # number conversion in the scanf() family (i.e. # scanf(), sscanf(), vscanf(), etc.) of # functions. A substantial amount of code space # can be saved if this option is disabled. If it # is disabled then floating point specifiers # (%e, %f, %g) are ignored, and nothing is # converted. # cdl_option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_LIBM && # 0 != CYGINT_ISO_STDLIB_STRCONV_FLOAT # CYGPKG_LIBM == v2_0 # CYGINT_ISO_STDLIB_STRCONV_FLOAT == 1 # --> 1 # Requires: CYGPKG_LIBM # CYGPKG_LIBM == v2_0 # --> 1 # Requires: CYGINT_ISO_STDLIB_STRCONV_FLOAT # CYGINT_ISO_STDLIB_STRCONV_FLOAT == 1 # --> 1 }; # < # Thread safe I/O streams # doc: ref/libc-thread-safety.html # This option controls whether standard I/O streams # are thread-safe. Having this option set allows # the streams to be locked when accessed by # multiple threads simultaneously. # cdl_option CYGSEM_LIBC_STDIO_THREAD_SAFE_STREAMS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # C library stdio functions build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_STDIO_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_STDIO_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_STDIO_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library stdio function tests # This option specifies the set of tests for the C library # stdio functions. # cdl_option CYGPKG_LIBC_STDIO_TESTS { # Calculated value: "tests/sprintf1 tests/sprintf2 tests/sscanf tests/stdiooutput" # Flavor: data # Current_value: tests/sprintf1 tests/sprintf2 tests/sscanf tests/stdiooutput }; # < # Enable use of FILEIO package for IO operations. # cdl_option CYGPKG_LIBC_STDIO_FILEIO { # This option is not active # ActiveIf constraint: CYGPKG_IO_FILEIO # CYGPKG_IO_FILEIO (unknown) == 0 # --> 0 # Calculated value: 1 # Flavor: bool # Current value: 1 # Requires: CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO # CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO == 1 # --> 1 }; # < # ISO C library general utility functions # doc: ref/libc.html # This package provides general utility functions in # as specified by the ISO C standard - ISO/IEC 9899:1990. # cdl_package CYGPKG_LIBC_STDLIB { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGINT_ISO_CTYPE # CYGINT_ISO_CTYPE == 1 # --> 1 # Requires: CYGINT_ISO_STRING_STRFUNCS # CYGINT_ISO_STRING_STRFUNCS == 1 # --> 1 }; # > # Inline versions of functions # This option chooses whether some of the # particularly simple standard utility functions # from are available as inline # functions. This may improve performance, and as # the functions are small, may even improve code # size. # cdl_component CYGIMP_LIBC_STDLIB_INLINES { # There is no associated value. }; # > # abs() / labs() # cdl_option CYGIMP_LIBC_STDLIB_INLINE_ABS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_STDLIB_ABS_HEADER == "" # CYGBLD_ISO_STDLIB_ABS_HEADER == # --> 1 }; # div() / ldiv() # cdl_option CYGIMP_LIBC_STDLIB_INLINE_DIV { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_STDLIB_DIV_HEADER == "" # CYGBLD_ISO_STDLIB_DIV_HEADER == # --> 1 }; # atof() / atoi() / atol() # cdl_option CYGIMP_LIBC_STDLIB_INLINE_ATOX { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_STDLIB_STRCONV_HEADER == "" # CYGBLD_ISO_STDLIB_STRCONV_HEADER == # --> 1 }; # < # Random number generation # These options control the behaviour of the # functions rand(), srand() and rand_r() # cdl_component CYGPKG_LIBC_RAND { # There is no associated value. }; # > # Per-thread random seed # doc: ref/libc-thread-safety.html # This option controls whether the pseudo-random # number generation functions rand() and srand() # have their state recorded on a per-thread # basis rather than global. If this option is # disabled, some per-thread space can be saved. # Note there is also a POSIX-standard rand_r() # function to achieve a similar effect with user # support. Enabling this option will use one slot # of kernel per-thread data. You should ensure you # have enough slots configured for all your # per-thread data. # cdl_option CYGSEM_LIBC_PER_THREAD_RAND { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 }; # Random number seed # This selects the initial random number seed for # rand()'s pseudo-random number generator. For # strict ISO standard compliance, this should be 1, # as per section 7.10.2.2 of the standard. # cdl_option CYGNUM_LIBC_RAND_SEED { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Legal values: 0 to 0x7fffffff }; # Tracing level # Trace verbosity level for debugging the rand(), # srand() and rand_r() functions. Increase this # value to get additional trace output. # cdl_option CYGNUM_LIBC_RAND_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # Simplest implementation # This provides a very simple implementation of rand() # that does not perform well with randomness in the # lower significant bits. However it is exceptionally # fast. It uses the sample algorithm from the ISO C # standard itself. # cdl_option CYGIMP_LIBC_RAND_SIMPLEST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Simple implementation #1 # This provides a very simple implementation of rand() # based on the simplest implementation above. However # it does try to work around the lack of randomness # in the lower significant bits, at the expense of a # little speed. # cdl_option CYGIMP_LIBC_RAND_SIMPLE1 { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Knuth implementation #1 # This implements a slightly more complex algorithm # published in Donald E. Knuth's Art of Computer # Programming Vol.2 section 3.6 (p.185 in the 3rd ed.). # This produces better random numbers than the # simplest approach but is slower. # cdl_option CYGIMP_LIBC_RAND_KNUTH1 { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # < # Provides strtod() # This option allows use of the utility function # strtod() (and consequently atof()) to convert # from string to double precision floating point # numbers. Disabling this option removes the # dependency on the math library package. # cdl_option CYGFUN_LIBC_strtod { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 != CYGPKG_LIBM # CYGPKG_LIBM == v2_0 # --> 1 # Requires: CYGPKG_LIBM # CYGPKG_LIBM == v2_0 # --> 1 }; # bsearch() tracing level # Trace verbosity level for debugging the # binary search function bsearch(). Increase this # value to get additional trace output. # cdl_option CYGNUM_LIBC_BSEARCH_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # qsort() tracing level # Trace verbosity level for debugging the # quicksort function qsort(). Increase this value # to get additional trace output. # cdl_option CYGNUM_LIBC_QSORT_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # C library stdlib build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_STDLIB_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building this package. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_STDLIB_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building this package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_STDLIB_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library stdlib tests # This option specifies the set of tests for this package. # cdl_option CYGPKG_LIBC_STDLIB_TESTS { # Calculated value: "tests/abs tests/atoi tests/atol tests/bsearch tests/div tests/getenv tests/labs tests/ldiv tests/qsort tests/rand1 tests/rand2 tests/rand3 tests/rand4 tests/srand tests/strtol tests/strtoul" # Flavor: data # Current_value: tests/abs tests/atoi tests/atol tests/bsearch tests/div tests/getenv tests/labs tests/ldiv tests/qsort tests/rand1 tests/rand2 tests/rand3 tests/rand4 tests/srand tests/strtol tests/strtoul }; # < # < # ISO C library string functions # doc: ref/libc.html # This package provides string functions specified by the # ISO C standard - ISO/IEC 9899:1990. # cdl_package CYGPKG_LIBC_STRING { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGBLD_ISO_STRING_LOCALE_FUNCS_HEADER == "" # CYGBLD_ISO_STRING_LOCALE_FUNCS_HEADER == # --> 1 # Requires: CYGBLD_ISO_STRING_MEMFUNCS_HEADER == "" # CYGBLD_ISO_STRING_MEMFUNCS_HEADER == # --> 1 # Requires: CYGBLD_ISO_STRING_STRFUNCS_HEADER == "" # CYGBLD_ISO_STRING_STRFUNCS_HEADER == # --> 1 # Requires: CYGBLD_ISO_STRTOK_R_HEADER == "" # CYGBLD_ISO_STRTOK_R_HEADER == # --> 1 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 }; # > # Inline versions of functions # This option chooses whether some of the # particularly simple string functions from # are available as inline # functions. This may improve performance, and as # the functions are small, may even improve code # size. # cdl_option CYGIMP_LIBC_STRING_INLINES { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Optimize string functions for code size # This option tries to reduce string function # code size at the expense of execution speed. The # same effect can be produced if the code is # compiled with the -Os option to the compiler. # cdl_option CYGIMP_LIBC_STRING_PREFER_SMALL_TO_FAST { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Provide BSD compatibility functions # Enabling this option causes various compatibility functions # commonly found in the BSD UNIX operating system to be included. # These are functions such as bzero, bcmp, bcopy, bzero, strcasecmp, # strncasecmp, index, rindex and swab. # cdl_option CYGFUN_LIBC_STRING_BSD_FUNCS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_STRING_BSD_FUNCS_HEADER == "" # CYGBLD_ISO_STRING_BSD_FUNCS_HEADER == # --> 1 # Requires: CYGINT_ISO_CTYPE # CYGINT_ISO_CTYPE == 1 # --> 1 # The following properties are affected by this value # option CYGFUN_LIBC_TIME_POSIX # Requires: CYGFUN_LIBC_STRING_BSD_FUNCS }; # strtok # These options control the behaviour of the # strtok() and strtok_r() string tokenization # functions. # cdl_component CYGPKG_LIBC_STRING_STRTOK { # There is no associated value. }; # > # Per-thread strtok() # This option controls whether the string function # strtok() has its state recorded on a per-thread # basis rather than global. If this option is # disabled, some per-thread space can be saved. # Note there is also a POSIX-standard strtok_r() # function to achieve a similar effect with user # support. Enabling this option will use one slot # of kernel per-thread data. You should ensure you # have enough slots configured for all your # per-thread data. # cdl_option CYGSEM_LIBC_STRING_PER_THREAD_STRTOK { # ActiveIf constraint: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 }; # Tracing level # Trace verbosity level for debugging the # functions strtok() and strtok_r(). Increase this # value to get additional trace output. # cdl_option CYGNUM_LIBC_STRING_STRTOK_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # < # C library string functions build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_STRING_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_STRING_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_STRING_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library string function tests # This option specifies the set of tests for the C library # string functions. # cdl_option CYGPKG_LIBC_STRING_TESTS { # Calculated value: "tests/memchr tests/memcmp1 tests/memcmp2 tests/memcpy1 tests/memcpy2 tests/memmove1 tests/memmove2 tests/memset tests/strcat1 tests/strcat2 tests/strchr tests/strcmp1 tests/strcmp2 tests/strcoll1 tests/strcoll2 tests/strcpy1 tests/strcpy2 tests/strcspn tests/strcspn tests/strlen tests/strncat1 tests/strncat2 tests/strncpy1 tests/strncpy2 tests/strpbrk tests/strrchr tests/strspn tests/strstr tests/strtok tests/strxfrm1 tests/strxfrm2" # Flavor: data # Current_value: tests/memchr tests/memcmp1 tests/memcmp2 tests/memcpy1 tests/memcpy2 tests/memmove1 tests/memmove2 tests/memset tests/strcat1 tests/strcat2 tests/strchr tests/strcmp1 tests/strcmp2 tests/strcoll1 tests/strcoll2 tests/strcpy1 tests/strcpy2 tests/strcspn tests/strcspn tests/strlen tests/strncat1 tests/strncat2 tests/strncpy1 tests/strncpy2 tests/strpbrk tests/strrchr tests/strspn tests/strstr tests/strtok tests/strxfrm1 tests/strxfrm2 }; # < # < # ISO C library date and time functions # doc: ref/libc.html # This package provides time functions specified by the # ISO C standard - ISO/IEC 9899:1990. # cdl_package CYGPKG_LIBC_TIME { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGBLD_ISO_C_TIME_TYPES_HEADER == "" # CYGBLD_ISO_C_TIME_TYPES_HEADER == # --> 1 # Requires: CYGBLD_ISO_C_CLOCK_FUNCS_HEADER == "" # CYGBLD_ISO_C_CLOCK_FUNCS_HEADER == # --> 1 # Requires: CYGPKG_ISOINFRA # CYGPKG_ISOINFRA == v2_0 # --> 1 # Requires: CYGINT_ISO_DIV # CYGINT_ISO_DIV == 1 # --> 1 # Requires: CYGINT_ISO_ABS # CYGINT_ISO_ABS == 1 # --> 1 }; # > # Working clock() function # This option controls whether clock() will # actually try and determine the process time # usage. With this option disabled, clock() does # not disappear, but will permanently return # (clock_t)-1 as mandated by the ISO C standard. # cdl_option CYGSEM_LIBC_TIME_CLOCK_WORKING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_KERNEL_THREADS_TIMER # CYGFUN_KERNEL_THREADS_TIMER == 1 # --> 1 # Requires: CYGVAR_KERNEL_COUNTERS_CLOCK # CYGVAR_KERNEL_COUNTERS_CLOCK == 1 # --> 1 }; # Working time() function # This option controls whether time() will # actually try and determine the current calendar # time. With this option disabled, time() does # not disappear, but will permanently return # (time_t)-1 as mandated by the ISO C standard. # cdl_option CYGSEM_LIBC_TIME_TIME_WORKING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_IO_WALLCLOCK # CYGPKG_IO_WALLCLOCK == v2_0 # --> 1 }; # Working cyg_libc_time_settime() function # This option controls whether cyg_libc_time_settime() # will actually try and set the current calendar # time. With this option disabled, # cyg_libc_time_settime() does not disappear, but # will permanently return an error. # cdl_option CYGSEM_LIBC_TIME_SETTIME_WORKING { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGPKG_IO_WALLCLOCK # CYGPKG_IO_WALLCLOCK == v2_0 # --> 1 }; # POSIX time functions # Enabling this option allows the use of the # following functions defined in POSIX 1003.1: # asctime_r(), ctime_r(), gmtime_r(), strptime(), and # localtime_r(). # cdl_option CYGFUN_LIBC_TIME_POSIX { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_LIBC_STRING_BSD_FUNCS # CYGFUN_LIBC_STRING_BSD_FUNCS == 1 # --> 1 # The following properties are affected by this value # option CYGIMP_LIBC_TIME_ASCTIME_R_INLINE # Requires: CYGFUN_LIBC_TIME_POSIX # option CYGIMP_LIBC_TIME_CTIME_R_INLINE # Requires: CYGFUN_LIBC_TIME_POSIX # option CYGIMP_LIBC_TIME_GMTIME_R_INLINE # Requires: CYGFUN_LIBC_TIME_POSIX # option CYGIMP_LIBC_TIME_LOCALTIME_R_INLINE # Requires: CYGFUN_LIBC_TIME_POSIX # option CYGPKG_LIBC_TIME_TESTS # Calculated: # "tests/asctime tests/clock tests/ctime tests/gmtime tests/localtime tests/mktime tests/strftime tests/time " # . (CYGFUN_LIBC_TIME_POSIX ? "tests/strptime" : "") # }; # Single UNIX extensions # Enabling this option allows the use of # certain additional conversion specifiers # in the strftime function. # cdl_option CYGFUN_LIBC_TIME_SUS_EXTNS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Time zone offsets # These options control the default STandarD (STD) # and Daylight Savings Time (DST) # time offsets so that dates can be set correctly # for the local environment. # cdl_component CYGPKG_LIBC_TIME_ZONES { # There is no associated value. }; # > # Default Daylight Savings Time state # This option controls whether the initial # time environment is set up as STD, DST or # unknown. Use the value 1 for DST, 0 for STD, # and (-1) for unknown. This can also be set at # runtime using the cyg_libc_time_setdst() # function. # cdl_option CYGNUM_LIBC_TIME_DST_DEFAULT_STATE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value -1 # value_source default # Default value: -1 # Legal values: -1 to 1 }; # Default Standard Time offset # This option controls the offset from UTC in # seconds when in local Standard Time. This # value can be positive or negative. It # can also be set at run time using the # cyg_libc_time_setzoneoffsets() function. # cdl_option CYGNUM_LIBC_TIME_STD_DEFAULT_OFFSET { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: -90000 to 90000 }; # Default Daylight Savings Time offset # This option controls the offset from UTC in # seconds when in local Daylight Savings Time. This # value can be positive or negative. It # can also be set at run time using the # cyg_libc_time_setzoneoffsets() function. # cdl_option CYGNUM_LIBC_TIME_DST_DEFAULT_OFFSET { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 3600 # value_source default # Default value: 3600 # Legal values: -90000 to 90000 }; # < # Inline functions # These options control whether certain functions # are available in inline form. This may lead to # faster code at the expense of code space. But for # some functions, or some functions with constant # arguments, it may in fact lead to smaller code. # cdl_component CYGPKG_LIBC_TIME_INLINES { # There is no associated value. }; # > # asctime() # Allow the asctime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_ASCTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # ctime() # Allow the ctime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_CTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # difftime() # Allow the difftime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_DIFFTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # gmtime() # Allow the gmtime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_GMTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # localtime() # Allow the localtime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_LOCALTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # mktime() # Allow the mktime() function to be inlined # cdl_option CYGIMP_LIBC_TIME_MKTIME_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # asctime_r() # Allow the asctime_r() function to be inlined # cdl_option CYGIMP_LIBC_TIME_ASCTIME_R_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_LIBC_TIME_POSIX # CYGFUN_LIBC_TIME_POSIX == 1 # --> 1 }; # ctime_r() # Allow the ctime_r() function to be inlined # cdl_option CYGIMP_LIBC_TIME_CTIME_R_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_LIBC_TIME_POSIX # CYGFUN_LIBC_TIME_POSIX == 1 # --> 1 }; # gmtime_r() # Allow the gmtime_r() function to be inlined # cdl_option CYGIMP_LIBC_TIME_GMTIME_R_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_LIBC_TIME_POSIX # CYGFUN_LIBC_TIME_POSIX == 1 # --> 1 }; # localtime_r() # Allow the localtime_r() function to be inlined # cdl_option CYGIMP_LIBC_TIME_LOCALTIME_R_INLINE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGFUN_LIBC_TIME_POSIX # CYGFUN_LIBC_TIME_POSIX == 1 # --> 1 }; # < # clock() tracing level # Trace verbosity level for debugging the clock() # function. Increase this value to get # additional trace output when tracing is enabled. # cdl_option CYGNUM_LIBC_TIME_CLOCK_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # C library time functions build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBC_TIME_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBC_TIME_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value -Wno-format # value_source default # Default value: -Wno-format }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the C library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBC_TIME_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # C library time and date function tests # This option specifies the set of tests for the C library # time and date functions. # cdl_option CYGPKG_LIBC_TIME_TESTS { # Calculated value: # "tests/asctime tests/clock tests/ctime tests/gmtime tests/localtime tests/mktime tests/strftime tests/time " # . (CYGFUN_LIBC_TIME_POSIX ? "tests/strptime" : "") # # CYGFUN_LIBC_TIME_POSIX == 1 # Flavor: data # Current_value: tests/asctime tests/clock tests/ctime tests/gmtime tests/localtime tests/mktime tests/strftime tests/time tests/strptime }; # < # < # < # Math library # doc: ref/libc.html # ISO standard floating point mathematical library # containing many useful functions for mathematical # calculations. # cdl_package CYGPKG_LIBM { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # option CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT # Requires: CYGPKG_LIBM # option CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT # DefaultValue: 0 != CYGPKG_LIBM # option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT # Requires: CYGPKG_LIBM # option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT # DefaultValue: 0 != CYGPKG_LIBM && # 0 != CYGINT_ISO_STDLIB_STRCONV_FLOAT # option CYGFUN_LIBC_strtod # Requires: CYGPKG_LIBM # option CYGFUN_LIBC_strtod # DefaultValue: 0 != CYGPKG_LIBM }; # > # Compatibility mode # These options deal with behaviour related to # the various compatibility modes - POSIX, IEEE, # X/OPEN and SVID. # cdl_component CYGPKG_LIBM_COMPATIBILITY { # There is no associated value. }; # > # cdl_interface CYGINT_LIBM_COMPAT { # Implemented by CYGSEM_LIBM_COMPAT_IEEE_ONLY, active, disabled # Implemented by CYGNUM_LIBM_COMPATIBILITY, active, enabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 == CYGINT_LIBM_COMPAT # CYGINT_LIBM_COMPAT == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_LIBM_COMPAT # Requires: 1 == CYGINT_LIBM_COMPAT }; # IEEE-only # The math library can be hard-coded to only # behave in one compatibility mode - IEEE. This # cannot be changed at run-time. IEEE mode is the # most minimal of the compatibility modes, and so # this will best help code size and speed, as well # as omitting the code for other compatibility # modes. If not defined, the math library can be # set at run-time to any of the supported # compatibility modes. # cdl_option CYGSEM_LIBM_COMPAT_IEEE_ONLY { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # The following properties are affected by this value # option CYGSEM_LIBM_USE_STDERR # Requires: !CYGSEM_LIBM_COMPAT_IEEE_ONLY # option CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE # Requires: !CYGSEM_LIBM_COMPAT_IEEE_ONLY }; # Default mode # If you want to have support for more than one # compatibility mode settable at run-time, rather # than hard-coded IEEE mode, this component lets # you choose which mode should be the default. # cdl_component CYGNUM_LIBM_COMPATIBILITY { # Flavor: booldata # No user value, uncomment the following line to provide one. # user_value 1 POSIX # value_source default # Default value: 1 POSIX # Legal values: "POSIX" "IEEE" "XOPEN" "SVID" # Requires: CYGPKG_LIBC # CYGPKG_LIBC == v2_0 # --> 1 # The following properties are affected by this value # option CYGNUM_LIBM_COMPAT_DEFAULT # Calculated: CYGNUM_LIBM_COMPATIBILITY == "POSIX" ? "CYGNUM_LIBM_COMPAT_POSIX" : CYGNUM_LIBM_COMPATIBILITY == "IEEE" ? "CYGNUM_LIBM_COMPAT_IEEE" : CYGNUM_LIBM_COMPATIBILITY == "XOPEN" ? "CYGNUM_LIBM_COMPAT_XOPEN" : CYGNUM_LIBM_COMPATIBILITY == "SVID" ? "CYGNUM_LIBM_COMPAT_SVID" : "" # option CYGNUM_LIBM_COMPAT_DEFAULT # Calculated: CYGNUM_LIBM_COMPATIBILITY == "POSIX" ? "CYGNUM_LIBM_COMPAT_POSIX" : CYGNUM_LIBM_COMPATIBILITY == "IEEE" ? "CYGNUM_LIBM_COMPAT_IEEE" : CYGNUM_LIBM_COMPATIBILITY == "XOPEN" ? "CYGNUM_LIBM_COMPAT_XOPEN" : CYGNUM_LIBM_COMPATIBILITY == "SVID" ? "CYGNUM_LIBM_COMPAT_SVID" : "" # option CYGNUM_LIBM_COMPAT_DEFAULT # Calculated: CYGNUM_LIBM_COMPATIBILITY == "POSIX" ? "CYGNUM_LIBM_COMPAT_POSIX" : CYGNUM_LIBM_COMPATIBILITY == "IEEE" ? "CYGNUM_LIBM_COMPAT_IEEE" : CYGNUM_LIBM_COMPATIBILITY == "XOPEN" ? "CYGNUM_LIBM_COMPAT_XOPEN" : CYGNUM_LIBM_COMPATIBILITY == "SVID" ? "CYGNUM_LIBM_COMPAT_SVID" : "" # option CYGNUM_LIBM_COMPAT_DEFAULT # Calculated: CYGNUM_LIBM_COMPATIBILITY == "POSIX" ? "CYGNUM_LIBM_COMPAT_POSIX" : CYGNUM_LIBM_COMPATIBILITY == "IEEE" ? "CYGNUM_LIBM_COMPAT_IEEE" : CYGNUM_LIBM_COMPATIBILITY == "XOPEN" ? "CYGNUM_LIBM_COMPAT_XOPEN" : CYGNUM_LIBM_COMPATIBILITY == "SVID" ? "CYGNUM_LIBM_COMPAT_SVID" : "" }; # > # Numeric representation # This option automatically defines the default compatibility # mode for numeric representation in terms of the values used # to set that mode at run-time. # cdl_option CYGNUM_LIBM_COMPAT_DEFAULT { # Calculated value: CYGNUM_LIBM_COMPATIBILITY == "POSIX" ? "CYGNUM_LIBM_COMPAT_POSIX" : CYGNUM_LIBM_COMPATIBILITY == "IEEE" ? "CYGNUM_LIBM_COMPAT_IEEE" : CYGNUM_LIBM_COMPATIBILITY == "XOPEN" ? "CYGNUM_LIBM_COMPAT_XOPEN" : CYGNUM_LIBM_COMPATIBILITY == "SVID" ? "CYGNUM_LIBM_COMPAT_SVID" : "" # CYGNUM_LIBM_COMPATIBILITY == POSIX # CYGNUM_LIBM_COMPATIBILITY == POSIX # CYGNUM_LIBM_COMPATIBILITY == POSIX # CYGNUM_LIBM_COMPATIBILITY == POSIX # Flavor: data # Current_value: CYGNUM_LIBM_COMPAT_POSIX }; # < # SVID3-style scalb() # SVID3 defined the scalb() function as double # scalb(double, double) rather than double # scalb(double, int) which is used by IBM, DEC, and # probably others. Enabling this option chooses # the (double, double) version. Note there is a # function double scalbn(double, int) which is # unaffected by this choice. # cdl_option CYGFUN_LIBM_SVID3_scalb { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 }; # Reduce namespace pollution # If you do not want to use either the X/Open or # SVID3 compatibility modes, you may want to define # this option to reduce the chance of namespace # pollution. This is particularly likely to occur # here as these standards define symbols with # names that often appear in applications, such as # exception, DOMAIN, OVERFLOW, etc. If your # application also used these names, it may cause # problems. # cdl_option CYGSYM_LIBM_NO_XOPEN_SVID_NAMESPACE_POLLUTION { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 }; # Output to stderr for math errors # The SVID3 standard says that error # messages should be output on the stderr console # output stream. This option allows this ability # to be explicitly controlled. However, this still # only has an effect in SVID3 compatibility mode. # cdl_option CYGSEM_LIBM_USE_STDERR { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: !CYGSEM_LIBM_COMPAT_IEEE_ONLY # CYGSEM_LIBM_COMPAT_IEEE_ONLY == 0 # --> 1 # Requires: CYGPKG_LIBC_STDIO # CYGPKG_LIBC_STDIO == v2_0 # --> 1 }; # < # Thread safety # This option controls whether the C library has # support for thread safe operation in general. # This requires eCos kernel support for per-thread # data, and adjustment of the stack limit. # cdl_component CYGPKG_LIBM_THREAD_SAFETY { # There is no associated value. }; # > # Compatibility mode setting # This option makes the setting of the compatiblity # mode be a per-thread property. This directly # implies that it also becomes thread-safe. # cdl_option CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: !CYGSEM_LIBM_COMPAT_IEEE_ONLY # CYGSEM_LIBM_COMPAT_IEEE_ONLY == 0 # --> 1 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 # The following properties are affected by this value # option CYGNUM_LIBM_COMPATMODE_TRACE_LEVEL # Requires: CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE }; # gamma() and lgamma() # This option makes the gamma() and lgamma() # functions be thread-safe. Note that these # functions are identical - they take the log of # the absolute value of their argument. The sign # of the argument is stored in a variable called # signgam. Enabling this option makes signgam # a per-thread variable. Note there are also # gamma_r() and lgamma_r() alternatives that # allow signgam to be passed in by reference as # an argument. # cdl_option CYGSEM_LIBM_THREAD_SAFE_GAMMA_FUNCTIONS { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 # The following properties are affected by this value # option CYGNUM_LIBM_SIGNGAM_TRACE_LEVEL # Requires: CYGSEM_LIBM_THREAD_SAFE_GAMMA_FUNCTIONS }; # < # Tracing output levels in math library # Tracing support is useful for debugging. Some # Math library modules can be configured with # different levels of tracing verbosity. These # levels can be configured here. # cdl_component CYGPKG_LIBM_TRACE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Requires: CYGDBG_USE_TRACING # CYGDBG_USE_TRACING == 0 # --> 0 }; # > # Compatibility mode get/set # Trace level for debugging the getting and # setting of the compatibility mode when it is # configured to be thread-safe. # cdl_option CYGNUM_LIBM_COMPATMODE_TRACE_LEVEL { # This option is not active # The parent CYGPKG_LIBM_TRACE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 # Requires: CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE # CYGSEM_LIBM_THREAD_SAFE_COMPAT_MODE == 0 # --> 0 }; # signgam variable access # Trace level for debugging all accesses to the # signgam variable in thread-safe mode. # cdl_option CYGNUM_LIBM_SIGNGAM_TRACE_LEVEL { # This option is not active # The parent CYGPKG_LIBM_TRACE is disabled # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 # Requires: CYGSEM_LIBM_THREAD_SAFE_GAMMA_FUNCTIONS # CYGSEM_LIBM_THREAD_SAFE_GAMMA_FUNCTIONS == 0 # --> 0 }; # < # Bessel function limit of significance # For the Bessel functions (j0(), j1(), jn(), # y0(), y1(), yn()) this option defines the # maximum absolute value of the ordinate # before we assume total loss of significance. # This number must be a floating-point number (e.g. # contains a decimal point), and should be # large. # cdl_option X_TLOSS { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 1.41484755040569E+16 # value_source default # Default value: 1.41484755040569E+16 # Legal values: 1 to 1e308 }; # Math library build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_LIBM_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the math library. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_LIBM_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: ((0 == CYGPKG_HAL_I386) && (0 == CYGPKG_HAL_SYNTH_I386)) ? "" : "-ffloat-store" # CYGPKG_HAL_I386 (unknown) == 0 # CYGPKG_HAL_SYNTH_I386 (unknown) == 0 # --> "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the math library. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_LIBM_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Math library tests # This option specifies the set of tests for the math library. # cdl_option CYGPKG_LIBM_TESTS { # Calculated value: "tests/vectors/acos tests/vectors/asin tests/vectors/atan tests/vectors/atan2 tests/vectors/ceil tests/vectors/cos tests/vectors/cosh tests/vectors/exp tests/vectors/fabs tests/vectors/floor tests/vectors/fmod tests/vectors/frexp tests/vectors/ldexp tests/vectors/log tests/vectors/log10 tests/vectors/modf tests/vectors/pow tests/vectors/sin tests/vectors/sinh tests/vectors/sqrt tests/vectors/tan tests/vectors/tanh" # Flavor: data # Current_value: tests/vectors/acos tests/vectors/asin tests/vectors/atan tests/vectors/atan2 tests/vectors/ceil tests/vectors/cos tests/vectors/cosh tests/vectors/exp tests/vectors/fabs tests/vectors/floor tests/vectors/fmod tests/vectors/frexp tests/vectors/ldexp tests/vectors/log tests/vectors/log10 tests/vectors/modf tests/vectors/pow tests/vectors/sin tests/vectors/sinh tests/vectors/sqrt tests/vectors/tan tests/vectors/tanh }; # < # < # Wallclock device # The wallclock device provides real time stamps, as opposed # to the eCos kernel timers which typically just count the # number of clock ticks since the hardware was powered up. # Depending on the target platform this device may involve # interacting with a suitable clock chip, or it may be # emulated by using the kernel timers. # cdl_package CYGPKG_IO_WALLCLOCK { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # The following properties are affected by this value # option CYGSEM_LIBC_TIME_TIME_WORKING # Requires: CYGPKG_IO_WALLCLOCK # option CYGSEM_LIBC_TIME_SETTIME_WORKING # Requires: CYGPKG_IO_WALLCLOCK }; # > # Number of wallclock hardware implementations # cdl_interface CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGPKG_WALLCLOCK_EMULATE # DefaultValue: 0 == CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS # option CYGIMP_WALLCLOCK_NONE # DefaultValue: !CYGPKG_KERNEL && 0 == CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS }; # Number of wallclock implementations # cdl_interface CYGINT_WALLCLOCK_IMPLEMENTATIONS { # Implemented by CYGPKG_WALLCLOCK_EMULATE, active, enabled # Implemented by CYGIMP_WALLCLOCK_NONE, active, disabled # This value cannot be modified here. # Flavor: data # Current_value: 1 # Requires: 1 == CYGINT_WALLCLOCK_IMPLEMENTATIONS # CYGINT_WALLCLOCK_IMPLEMENTATIONS == 1 # --> 1 # The following properties are affected by this value # interface CYGINT_WALLCLOCK_IMPLEMENTATIONS # Requires: 1 == CYGINT_WALLCLOCK_IMPLEMENTATIONS }; # Wallclock driver supports set/get mode # cdl_interface CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED { # No options implement this inferface # This value cannot be modified here. # Flavor: data # Current_value: 0 # The following properties are affected by this value # option CYGSEM_WALLCLOCK_MODE # DefaultValue: CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED ? "set_get" : "init_get" # option CYGSEM_WALLCLOCK_MODE # Requires: CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED || CYGSEM_WALLCLOCK_MODE == "init_get" }; # Wallclock mode # The wallclock driver can be used in one of two # modes. Set/get mode allows time to be kept during power # off (assuming there's a battery backed clock). Init/get # mode is slightly smaller and can be used when there is no # battery backed clock - in this mode time 0 is the time of # the board power up. # cdl_option CYGSEM_WALLCLOCK_MODE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value init_get # value_source default # Default value: CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED ? "set_get" : "init_get" # CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED == 0 # --> init_get # Legal values: "init_get" "set_get" # Requires: CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED || CYGSEM_WALLCLOCK_MODE == "init_get" # CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED == 0 # CYGSEM_WALLCLOCK_MODE == init_get # --> 1 # The following properties are affected by this value # option CYGSEM_WALLCLOCK_MODE # Requires: CYGINT_WALLCLOCK_SET_GET_MODE_SUPPORTED || CYGSEM_WALLCLOCK_MODE == "init_get" # option CYGSEM_WALLCLOCK_SET_GET_MODE # Calculated: CYGSEM_WALLCLOCK_MODE == "set_get" ? 1 : 0 }; # Wallclock set/get mode # cdl_option CYGSEM_WALLCLOCK_SET_GET_MODE { # Calculated value: CYGSEM_WALLCLOCK_MODE == "set_get" ? 1 : 0 # CYGSEM_WALLCLOCK_MODE == init_get # Flavor: bool # Current value: 0 }; # Wallclock implementation # Implementations of the wallclock device. # cdl_component CYGPKG_IO_WALLCLOCK_IMPLEMENTATION { # There is no associated value. }; # > # Wallclock emulator # When this option is enabled, a wallclock device will be # emulated using the kernel real-time clock. # cdl_option CYGPKG_WALLCLOCK_EMULATE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 0 == CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS # CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS == 0 # --> 1 # Requires: CYGPKG_KERNEL # CYGPKG_KERNEL == v2_0 # --> 1 }; # No wallclock # Disables the wallclock. # cdl_option CYGIMP_WALLCLOCK_NONE { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: !CYGPKG_KERNEL && 0 == CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS # CYGPKG_KERNEL == v2_0 # CYGINT_WALLCLOCK_HW_IMPLEMENTATIONS == 0 # --> 0 }; # < # Wallclock build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_IO_WALLCLOCK_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the wallclock device. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_IO_WALLCLOCK_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the wallclock device. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_IO_WALLCLOCK_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Wallclock tests # This option specifies the set of tests for the # wallclock device. # cdl_option CYGPKG_IO_WALLCLOCK_TESTS { # Calculated value: CYGPKG_KERNEL ? "tests/wallclock tests/wallclock2" : "" # CYGPKG_KERNEL == v2_0 # Flavor: data # Current_value: tests/wallclock tests/wallclock2 }; # < # < # Common error code support # This package contains the common list of error and # status codes. It is held centrally to allow # packages to interchange error codes and status # codes in a common way, rather than each package # having its own conventions for error/status # reporting. The error codes are modelled on the # POSIX style naming e.g. EINVAL etc. This package # also provides the standard strerror() function to # convert error codes to textual representation, as # well as an implementation of the errno idiom. # cdl_package CYGPKG_ERROR { # Packages cannot be added or removed, nor can their version be changed, # simply by editing their value. Instead the appropriate configuration # should be used to perform these actions. # This value cannot be modified here. # Flavor: booldata # Current value: 1 v2_0 # Requires: CYGBLD_ISO_ERRNO_CODES_HEADER == "" # CYGBLD_ISO_ERRNO_CODES_HEADER == # --> 1 # The following properties are affected by this value # package CYGPKG_IO # Requires: CYGPKG_ERROR # package CYGPKG_IO_SERIAL # Requires: CYGPKG_ERROR }; # > # errno variable # This package controls the behaviour of the # errno variable (or more strictly, expression) # from . # cdl_component CYGPKG_ERROR_ERRNO { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_ERRNO_HEADER == "" # CYGBLD_ISO_ERRNO_HEADER == # --> 1 }; # > # Per-thread errno # This option controls whether the standard error # code reporting variable errno is a per-thread # variable, rather than global. # cdl_option CYGSEM_ERROR_PER_THREAD_ERRNO { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGVAR_KERNEL_THREADS_DATA # CYGVAR_KERNEL_THREADS_DATA == 1 # --> 1 }; # Tracing level # Trace verbosity level for debugging the errno # retrieval mechanism in errno.cxx. Increase this # value to get additional trace output. # cdl_option CYGNUM_ERROR_ERRNO_TRACE_LEVEL { # Flavor: data # No user value, uncomment the following line to provide one. # user_value 0 # value_source default # Default value: 0 # Legal values: 0 to 1 }; # < # strerror function # This package controls the presence and behaviour of the # strerror() function from # cdl_option CYGPKG_ERROR_STRERROR { # Flavor: bool # No user value, uncomment the following line to provide one. # user_value 1 # value_source default # Default value: 1 # Requires: CYGBLD_ISO_STRERROR_HEADER == "" # CYGBLD_ISO_STRERROR_HEADER == # --> 1 }; # Error package build options # Package specific build options including control over # compiler flags used only in building this package, # and details of which tests are built. # cdl_component CYGPKG_ERROR_OPTIONS { # There is no associated value. }; # > # Additional compiler flags # This option modifies the set of compiler flags for # building the error package. These flags are used in addition # to the set of global flags. # cdl_option CYGPKG_ERROR_CFLAGS_ADD { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # Suppressed compiler flags # This option modifies the set of compiler flags for # building the error package. These flags are removed from # the set of global flags if present. # cdl_option CYGPKG_ERROR_CFLAGS_REMOVE { # Flavor: data # No user value, uncomment the following line to provide one. # user_value "" # value_source default # Default value: "" }; # < # < # < @ 1.1.1.1 log @initial import of ecos-2.0 @ text @@