nuttx/libc/Kconfig

#
# For a description of the syntax of this configuration file,
# see misc/tools/kconfig-language.txt.
#

comment "Standard C Library Options"

config STDIO_BUFFER_SIZE
	int "C STDIO buffer size"
	default 64
	---help---
		Size of buffers using within the C buffered I/O interfaces.
		(printf, putchar, fwrite, etc.).

config STDIO_LINEBUFFER
	bool "STDIO line buffering"
	default y
	---help---
		Flush buffer I/O whenever a newline character is found in
		the output data stream.

config NUNGET_CHARS
	int "Number unget() characters"
	default 2
	---help---
		Number of characters that can be buffered by ungetc() (Only if NFILE_STREAMS > 0)

config LIB_HOMEDIR
	string "Home directory"
	default "/"
	depends on !DISABLE_ENVIRON
	---help---
		The home directory to use with operations like such as 'cd ~'

source libc/math/Kconfig

config NOPRINTF_FIELDWIDTH
	bool "Disable sprintf support fieldwidth"
	default n
	---help---
		sprintf-related logic is a little smaller if we do not support field
		widths.

config LIBC_FLOATINGPOINT
	bool "Enable floating point in printf"
	default n
	---help---
		By default, floating point
		support in printf, sscanf, etc. is disabled.

config LIBC_IOCTL_VARIADIC
	bool "Enable variadic ioctl()"
	default n
	---help---
		By default, NuttX implements the "old style," three-parameter,
		ioctl() interface with this function prototype:

			int ioctl(int fd, int req, unsigned long arg);

		That function is implemented as part of the VFS.  If
		LIBC_IOCTL_VARIADIC is selected, then an additional compatibility
		layer will be provided in the C library.  The enabled, then function
		prototype will become:

			int ioctl(int fd, int req, ...);

		The ioctl() is not controlled by any standard so it is really
		arbitrary which format you used.  You may select the variadic
		function prototype with this option.  That will slightly increase
		code size and ioctl() processing time.  It will not support a
		variable number of arguments and it still always expects to see a
		third argument of type 'unsigned long'.  The only benefit of this
		alternative function signature is that it may provide greater
		compatibility if you are porting code from other platforms that use
		the variadic ioctl() function.

		WARNING:  Use of this option could cause subtle system errors is
		the third argument is omitted or if the sizeof the thread argument
		is anything other than sizeof (unsigned long).  Most small integers
		will be promoted to 'int'.  The following assertion appears in ioctl():

			DEBUGASSERT(sizeof(int)        == sizeof(unsigned long) &&
			            sizeof(FAR void *) == sizeof(unsigned long));

		Do not enable this option if the above is not true.  32-bit ARM
		should pass this test with all three types having sizeof(type) == 4
		bytes.  'float' should also be tested.  But 'long long' and 'double'
		are out of the question!  Don't event try to pass them.

		And what will happen if no third argument is passed?  In most cases,
		this should just result in a garbage value for arg.  But you may
		discover cases where something worse happens!

config LIB_RAND_ORDER
	int "Order of the random number generate"
	default 1
	range 1 3
	---help---
		The order of the random number generator. 1=fast but very bad random
		numbers, 3=slow but very good random numbers.

choice
	prompt "Newline Options"
	default EOL_IS_EITHER_CRLF
	---help---
		This selection determines the line terminating character that is used.
		Some environments may return CR as end-of-line, others LF, and others
		both.  If not specified, the default is either CR or LF (but not both)
		as the line terminating charactor.

config EOL_IS_CR
	bool "EOL is CR"

config EOL_IS_LF
	bool "EOL is LF"

config EOL_IS_BOTH_CRLF
	bool "EOL is CR and LF"

config EOL_IS_EITHER_CRLF
	bool "EOL is CR or LF"

endchoice

config LIBC_EXECFUNCS
	bool "Enable exec[l|v] / posix_spawn() Support"
	default n
	depends on !BINFMT_DISABLE
	---help---
		Enable support for the exec[l|v] family of functions that can be
		used to start other programs, terminating the current program and
		the posix_spawn() familty of functions that can be used start other
		programs without terminating the current program.  The typical
		usage of the exec[l|v] functions is (1) first call vfork() to create
		a new thread, then (2) call exec[l|v] to replace the new thread with
		a program from the file system.

		NOTE 1: This two step process start is completely unnecessary in
		NuttX and is provided only for compatibily with Unix systems.  These
		functions are essentially just wrapper functions that (1) call the
		non-standard binfmt function 'exec', and then (2) exit(0).  Since
		the new thread will be terminated by the exec[l|v] call, it really
		served no purpose other than to suport Unix compatility.

		The posix_spawn() functions do not have this inefficiency.

		NOTE 2: Support for exec[l|v] and posix_spawn() is conditional
		because they require additional support for symbol tables that
		will not be available in the typical system.

if LIBC_EXECFUNCS

config EXECFUNCS_HAVE_SYMTAB
	bool "Have symbol table"
	default n if BUILD_KERNEL
	default y if !BUILD_KERNEL
	---help---
		If you have a system symbol table, then you must select this
		option in order to use it.  Symbol tables are required in most
		cases in order to like executable programs to the base code.

if EXECFUNCS_HAVE_SYMTAB
config EXECFUNCS_SYMTAB
	string "Symbol table used by exec[l|v]"
	default "g_symtab"
	---help---
		The exec[l|v] and posix_spawn() functions are wrapper functions that
		call the non-standard binfmt function 'exec').  The binfmt
		function 'exec' needs to have (1) a symbol table that provides the
		list of symbols exported by the base code, and (2) the number of
		symbols in that table.  This selection provides the name of that
		symbol table.

config EXECFUNCS_NSYMBOLS
	int "Number of Symbols in the Table"
	default 0
	---help---
		The exec[l|v] and posix_spawn() functions are wrapper functions that
		call the non-standard binfmt function 'exec').  The binfmt
		function 'exec' needs to have (1) a symbol table that provides the
		list of symbols exported by the base code, and (2) the number of
		symbols in that table.  This selection provides the number of
		symbols in the symbol table.

endif # EXECFUNCS_HAVE_SYMTAB
endif # LIBC_EXECFUNCS

config POSIX_SPAWN_PROXY_STACKSIZE
	int "Spawn Stack Size"
	default 1024
	---help---
		If posix_spawn[p]() and task_spawn() use I/O redirection options,
		they will require an intermediary/proxy task to muck with the file
		descriptors.  This configuration item specifies the stack size
		used for the proxy. Default: 1024 bytes.

config TASK_SPAWN_DEFAULT_STACKSIZE
	int "Default task_spawn Stack Size"
	default 2048
	depends on !ARCH_ADDRENV
	---help---
		The actual size to use for the child task's stack can be set with
		task_spawnattr_setstacksize().  This value specifies the default
		stack size to use if task_spawnattr_setstacksize() is not used.
		Default: 2048.

config LIBC_STRERROR
	bool "Enable strerror"
	default n
	---help---
		strerror() is useful because it decodes 'errno' values into a human readable
		strings.  But it can also require a lot of memory.  If this option is selected,
		strerror() will still exist in the build but it will not decode error values.
		This option should be used by other logic to decide if it should use strerror()
		or not.  For example, the NSH application will not use strerror() if this
		option is not selected; perror() will not use strerror() is this option is not
		selected (see also NSH_STRERROR).

config LIBC_STRERROR_SHORT
	bool "Use short error descriptions in strerror()"
	default n
	depends on LIBC_STRERROR
	---help---
		If this option is selected, then strerror() will use a shortened string when
		it decodes the error.  Specifically, strerror() is simply use the string that
		is the common name for the error.  For example, the 'errno' value of 2 will
		produce the string "No such file or directory" is LIBC_STRERROR_SHORT
		is not defined but the string "ENOENT" is LIBC_STRERROR_SHORT is defined.

config LIBC_PERROR_STDOUT
	bool "perror() to stdout"
	default n
	---help---
		POSIX requires that perror() provide its output on stderr.  This option may
		be defined, however, to provide perror() output that is serialized with
		other stdout messages.

config LIBC_TMPDIR
	string "Temporary file directory"
	default "/tmp"
	depends on FS_WRITABLE
		---help---
		If a write-able file system is selected, this string will be
		provided to specify the full path to a directory where temporary
		files can be created.  This would be a good application of RAM disk:
		To provide temporary storage for application data.

config LIBC_MAX_TMPFILE
	int "Maximum size of a temporary file path"
	default 32
	depends on FS_WRITABLE
		---help---
		If a write-able file system is selected, then temporary file may be
		supported at the path provided by LIBC_TMPDIR.  The tmpnam() interface
		keeps a static copy of this last filename produced; this value is the
		maximum size of that last filename.  This size is the size of the full
		file path.

config ARCH_LOWPUTC
	bool "Low-level console output"
	default "y"
	---help---
		architecture supports low-level, boot time console output

config LIBC_LOCALTIME
	bool "localtime API call support"
	default "n"
	depends on !DISABLE_ENVIRON
	---help---
		localtime API call support

		Logic currently depends on file system support with, at a minimum, these
		files in the zoneinfo directory:  GMT and posixrules.  An additional
		timezone file is required for any additional, local time zone(s) and the
		environment variable TZ must be set to the name of that timezone file
		when tzset() is called.

		See https://www.iana.org/time-zones

if LIBC_LOCALTIME

config LIBC_TZ_MAX_TIMES
	int "Maximum number of times in timezone"
	default 370
	---help---
		Timezone files with more than this number of times will not be usedi
		(tmecnt).

		Warning: Some files in IANA TZ database include many more times than
		this.  The current posixrules file, for example, has timecnt = 236.
		The value of TX_MAX_ITMES in the tzfile.h header file on my Linux
		system is 370.  You may want to reduce this value for a smaller
		footprint.

config LIBC_TZ_MAX_TYPES
	int "Maximum number of TZ types"
	default 20
	---help---
		Maximum number of local time types.  You may want to reduce this value
		for a smaller footprint.

config LIBC_TZDIR
	string "zoneinfo directory path"
	default "/etc/zoneinfo"
	---help---
		This is the full path to the location where the TZ database is expected
		to be found.

endif

config TIME_EXTENDED
	bool "Add day of week, year support"
	default "n"
	depends on !LIBC_LOCALTIME
	---help---
		Selecting TIME_EXTENDED adds tm_wday, tm_yday and tm_isdst
		to the tm struct. This allows integration with 3rd party libraries
		that expect the tm struct to contain these members.

		Note: tm_isdst is always 0

config LIB_SENDFILE_BUFSIZE
	int "sendfile() buffer size"
	default 512
	---help---
		Size of the I/O buffer to allocate in sendfile().  Default: 512b

config ARCH_ROMGETC
	bool "Support for ROM string access"
	default n
	---help---
		In Harvard architectures, data accesses and instruction accesses
		occur on different buses, perhaps concurrently.  All data accesses
		are performed on the data bus unless special machine instructions
		are used to read data from the instruction address space.  Also, in
		the typical MCU, the available SRAM data memory is much smaller that
		the non-volatile FLASH instruction memory.  So if the application
		requires many constant strings, the only practical solution may be
		to store those constant strings in FLASH memory where they can only
		be accessed using architecture-specific machine instructions.

		If ARCH_ROMGETC is defined, then the architecture logic must export
		the function up_romgetc().  up_romgetc() will simply read one byte
		of data from the instruction space.

		If ARCH_ROMGETC is selected, certain C stdio functions are effected: (1)
		All format strings in printf, fprintf, sprintf, etc. are assumed to lie
		in FLASH (string arguments for %s are still assumed to reside in SRAM).
		And (2), the string argument to puts and fputs is assumed to reside
		in FLASH.  Clearly, these assumptions may have to modified for the
		particular needs of your environment.  There is no "one-size-fits-all"
		solution for this problem.

config ARCH_OPTIMIZED_FUNCTIONS
	bool "Enable arch optimized functions"
	default n
	---help---
		Allow for architecture optimized implementations of certain library
		functions.  Architecture-specific implementations can improve overall
		system performance.

if ARCH_OPTIMIZED_FUNCTIONS

config ARCH_MEMCPY
	bool "memcpy()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of memcpy().

config MEMCPY_VIK
	bool "Vik memcpy()"
	default n
	depends on !ARCH_MEMCPY
	---help---
		Select this option to use the optimized memcpy() function by Daniel Vik.
		Select this option for improved performance at the expense of increased
		size. See licensing information in the top-level COPYING file.

if MEMCPY_VIK

config MEMCPY_PRE_INC_PTRS
	bool "Pre-increment pointers"
	default n
	---help---
		Use pre-increment of pointers. Default is post increment of pointers.

config MEMCPY_INDEXED_COPY
	bool "Array indexing"
	default y
	---help---
		Copying data using array indexing. Using this option, disables the
		MEMCPY_PRE_INC_PTRS option.

config MEMCPY_64BIT
	bool "64-bit memcpy()"
	default n
	---help---
		Compiles memcpy() for architectures that suppport 64-bit operations
		efficiently.

endif # MEMCPY_VIK

config ARCH_MEMCMP
	bool "memcmp()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of memcmp().

config ARCH_MEMMOVE
	bool "memmove()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of memmove().

config ARCH_MEMSET
	bool "memset()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of memset().

config MEMSET_OPTSPEED
	bool "Optimize memset() for speed"
	default n
	depends on !ARCH_MEMSET
	---help---
		Select this option to use a version of memcpy() optimized for speed.
		Default: memcpy() is optimized for size.

config MEMSET_64BIT
	bool "64-bit memset()"
	default n
	depends on MEMSET_OPTSPEED
	---help---
		Compiles memset() for architectures that suppport 64-bit operations
		efficiently.

config ARCH_STRCHR
	bool "strchr()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strchr().

config ARCH_STRCMP
	bool "strcmp()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strcmp().

config ARCH_STRCPY
	bool "strcpy()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strcpy().

config ARCH_STRNCPY
	bool "strncpy()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strncpy().

config ARCH_STRLEN
	bool "strlen"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strlen().

config ARCH_STRNLEN
	bool "strlen()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of strnlen().

config ARCH_BZERO
	bool "bzero()"
	default n
	---help---
		Select this option if the architecture provides an optimized version
		of bzero().

endif # ARCH_OPTIMIZED_FUNCTIONS

comment "Non-standard Library Support"

if BUILD_PROTECTED || BUILD_KERNEL

config LIB_USRWORK
	bool "User mode worker thread"
	default n
	depends on !DISABLE_SIGNALS
	---help---
		User space work queues can also be made available for deferred
		processing in the NuttX kernel build.

if LIB_USRWORK

config LIB_USRWORKPRIORITY
	int "User mode priority worker thread priority"
	default 100
	---help---
		The execution priority of the user-mode priority worker thread.  Default: 100

config LIB_USRWORKPERIOD
	int "User mode worker thread period"
	default 100000
	---help---
		How often the lower priority worker thread checks for work in units
		of microseconds. Default: 100*1000 (100 MS).

config LIB_USRWORKSTACKSIZE
	int "User mode worker thread stack size"
	default 2048
	---help---
		The stack size allocated for the lower priority worker thread.  Default: 2K.

endif # LIB_USRWORK
endif # BUILD_PROTECTED || BUILD_KERNEL

config LIB_KBDCODEC
	bool "Keyboard CODEC"
	default n
	---help---
		In NuttX, a keyboard/keypad driver is simply a character driver that
		may have an (optional) encoding/decoding layer on the data returned
		by the character driver. A keyboard may return simple text data
		(alphabetic, numeric, and punctuaction) or control characters
		(enter, control-C, etc.).  However, in addition, most keyboards
		support actions that cannot be represented as text data. Such
		actions include things like cursor controls (home, up arrow,
		page down, etc.), editing functions (insert, delete, etc.), volume
		controls, (mute, volume up, etc.) and other special functions.
		Some special encoding may be required to multiplex these two classes
		of data.

		This option enables the functions that implement the encoding and
		decoding of keyboard data.  These are the interfaces prototyped in
		include/nuttx/input/kbd_codec.h.  While not correctly a part of
		the C library, it is included here because the decoding side of this
		interface must be accessible by end user programs.

config LIB_SLCDCODEC
	bool "Segment LCD CODEC"
	default n
	---help---
		In NuttX, a character-oriented, segment LCD (SLCD) driver is simply
		a character device that may have an (optional) encoding/decoding
		layer on the data provided to the SLCD driver.  The application may
		provide simple text data (alphabetic, numeric, and punctuaction) or
		control characters (enter, control-C, etc.).  However, in addition,
		most SLCDs support actions that cannot be represented as text data.
		Such actions include things like cursor controls (home, up arrow,
		page down, etc.) and other special functions (e.g., blinking).  Some
		special encoding may be required to multiplex these two classes of
		data.

		This option enables the functions that implement the encoding and
		decoding of SLCD data.  These are the interfaces prototyped in
		include/nuttx/lcd/slcd_codec.h.  While not correctly a part of the C
		library, it is included here because the encoding side of this
		interface must be accessible by end user programs.