const type: ccConfigType

Structure to describe C compiler and runtime library.

var boolean: WITH_STRI_CAPACITY

TRUE if the Seed7 runtime library uses strings with capacity. The capacity of a string can be larger than its size. Strings with capacity can be enlarged without calling realloc().

var boolean: WITH_RTL_ARRAY_CAPACITY

TRUE if the Seed7 runtime library uses arrays with capacity. The capacity of an array can be larger than its size. Arrayss with capacity can be enlarged without calling realloc().

var boolean: ALLOW_STRITYPE_SLICES

TRUE if the actual characters of a string can be stored elsewhere. This allows string slices without the need to copy characters.

var boolean: ALLOW_BSTRITYPE_SLICES

TRUE if the actual characters of a bstring can be stored elsewhere. This allows bstring slices without the need to copy characters.

var boolean: RSHIFT_DOES_SIGN_EXTEND

TRUE if right shifts preserve the sign of negative signed integers. The C standard specifies that the right shift of signed integers is implementation defined, if the shifted values are negative.

var boolean: TWOS_COMPLEMENT_INTTYPE

TRUE if signed integers are represented as twos complement numbers. This allows some simplified range checks in compiled programs.

var boolean: LITTLE_ENDIAN_INTTYPE

TRUE if the byte ordering of integers is little endian. With little endian byte ordering it is possible to get the elements of a union by casting the union to the desired element type.

var boolean: FLOAT_COMPARISON_OKAY

TRUE if float comparisons with NaN and negative zero work okay. A comparison between NaN and any other value should return FALSE. Negative zero should be considered as identical to positive zero. Comparison refers to comparisons with == < > <= or >= . If FLOAT_COMPARISON_OKAY is FALSE fltEq(), fltLt(), fltGt(), fltLe() and fltGe() should be used to do comparisons of float values.

var boolean: POW_FUNCTION_OKAY

TRUE if pow() works okay for a base of zero, one and NaN. If it is FALSE fltPow() should be used instead of pow().

var boolean: FMOD_FUNCTION_OKAY

TRUE if fmod() works okay for Infinity, NaN and zero. If it is FALSE fltRem() should be used instead of fmod().

var boolean: SQRT_FUNCTION_OKAY

TRUE if sqrt() works okay for a negative argument and NaN. If it is FALSE fltSqrt() should be used instead of sqrt().

var boolean: EXP_FUNCTION_OKAY

TRUE if exp() works okay for NaN. If it is FALSE fltExp() should be used instead of exp().

var boolean: LOG_FUNCTION_OKAY

TRUE if log() works okay for zero, negative values and NaN. If it is FALSE fltLog() should be used instead of log().

var boolean: LOG10_FUNCTION_OKAY

TRUE if log10() works okay for zero, negative values and NaN. If it is FALSE fltLog10() should be used instead of log10().

var boolean: LOG1P_FUNCTION_OKAY

TRUE if log1p() works okay for -1.0, values < -1.0 and NaN. If it is FALSE fltLog1p() should be used instead of log1p().

var boolean: LOG2_FUNCTION_OKAY

TRUE if log2() works okay for zero, negative values and NaN. If it is FALSE fltLog2() should be used instead of log2().

var boolean: LDEXP_FUNCTION_OKAY

TRUE if ldexp() works okay for NaN. If it is FALSE fltLdexp() should be used instead of lsexp().

var boolean: FREXP_FUNCTION_OKAY

TRUE if frexp() works okay for Infinity, NaN and subnormal numbers. If it is FALSE fltDecompose() should be used instead of frexp().

var boolean: HAS_SIGSETJMP

TRUE if the functions sigsetjmp() and siglongjmp() are available. If it is FALSE the functions setjmp() and longjmp() must be used instead.

var boolean: CHECK_INT_DIV_BY_ZERO

TRUE if integer divisions must be checked for a division by zero. This applies to the division operations div and mdiv. The generated C code should, if a division by zero occurs, raise the exception NUMERIC_ERROR instead of doing the illegal divide operation. If CHECK_INT_DIV_BY_ZERO is FALSE a division by zero always triggers SIGFPE. SIGFPE is caught by the Seed7 run-time library and triggers a NUMERIC_ERROR.

var boolean: CHECK_INT_DIV_ZERO_BY_ZERO

TRUE if the C expression 0/0 might not trigger SIGFPE. C compilers assume that so called "undefined behavior" will not happen. According to the C standard a division by 0 triggers undefined behavior. This way a C compiler is allowed to optimize the expressions 0/0 and 0/variable to 0. Likewise the expression variable/variable can be optimized to 1. In Seed7 a division by zero is defined behavior, since it raises the exception NUMERIC_ERROR. This configuration setting applies to the division operations div and mdiv. The generated C code should, if a division by zero occurs, raise the exception NUMERIC_ERROR instead of allowing the C compiler to do its optimization.

var boolean: CHECK_INT_REM_BY_ZERO

TRUE if integer remainder must be checked for a division by zero. This applies to the division operations rem and mod. The generated C code should, if a remainder by zero occurs, raise the exception NUMERIC_ERROR instead of doing the illegal divide operation. If CHECK_INT_REM_BY_ZERO is FALSE a remainder by zero always triggers SIGFPE. SIGFPE is caught by the Seed7 run-time library and triggers a NUMERIC_ERROR.

var boolean: CHECK_INT_REM_ZERO_BY_ZERO

TRUE if the C expression 0%0 might not trigger SIGFPE. C compilers assume that so called "undefined behavior" will not happen. According to the C standard a division by 0 triggers undefined behavior. This way a C compiler is allowed to optimize the expressions 0%0 and 0%variable to 0. Likewise the expression variable%variable can be optimized to 0. In Seed7 a division by zero is defined behavior, since it raises the exception NUMERIC_ERROR. This configuration setting applies to the division operations rem and mod. The generated C code should, if a division by zero occurs, raise the exception NUMERIC_ERROR instead of allowing the C compiler to do its optimization.

var boolean: FLOAT_ZERO_DIV_ERROR

TRUE if floating point divisions by zero cause compilation errors. Some C compilers check if the dividend is 0.0 and classify a floating point division by zero as fatal compilation error. Some C compilers even trigger wrong behavior if the dividend is 0.0. In this case FLOAT_ZERO_DIV_ERROR is also TRUE. If FLOAT_ZERO_DIV_ERROR is TRUE the generated C code should avoid divisions by zero and generate code to return Infinity, -Infinity or NaN instead.

var boolean: CHECK_FLOAT_DIV_BY_ZERO

TRUE if floating point divisions by zero don't conform to IEEE 754. According to IEEE 754 a floating point division by zero should return Infinity, -Infinity or NaN. In this case the compiler generates C code, which checks all float divisions ( / and /:= ) for division by zero. The generated C code should return Infinity, -Infinity or NaN instead of doing the divide operation.

var boolean: HAS_EXP2

TRUE if the C function exp2() is present.

var boolean: HAS_EXP10

TRUE if the C function exp10() is present.

var boolean: HAS_EXPM1

TRUE if the C function expm1() is present.

var boolean: HAS_CBRT

TRUE if the C function cbrt() is present.

var boolean: LIMITED_CSTRI_LITERAL_LEN

TRUE if the C compiler limits the length of string literals. Some C compilers limit the maximum string literal length. There are limits of 2,048 bytes and 16,384 (16K) bytes. The actual limit is not interesting, but the fact that a limit exists or does not exist.

var boolean: SWITCH_WORKS_FOR_INT64TYPE

TRUE if switch statements work with 64-bit values. If it is FALSE a switch statement with a 64-bit value triggers a compile error.

var boolean: STMT_BLOCK_IN_PARENTHESES_OK

TRUE if a compound statement is allowed in a parentesized expression. If it is FALSE a compound statement block in a parentesized expression triggers a compile error.

var boolean: CC_SOURCE_UTF8

TRUE if #line directives can use UTF-8 encoded file names. The file names from #line directives are used by the debugger to allow source code debugging.

var boolean: USE_WMAIN

TRUE if the main function is named wmain. This is a way to support Unicode command line arguments under Windows. An alternate way to support Unicode command line arguments under Windows uses the functions getUtf16Argv() and freeUtf16Argv() (both defined in "cmd_win.c").

var boolean: USE_WINMAIN

TRUE if the main function is named WinMain.

var boolean: USE_START_MAIN

TRUE if the main function invokes startMain after a button click. If a start button exists the main function will wait for a click on this button. Afterwards startMain is invoked. If no start button exists startMain is invoked immediately.

var boolean: USE_DO_EXIT

TRUE if the main function must be terminated with doExit().

var boolean: FLOATTYPE_DOUBLE

TRUE if the type floatType is double. If it is FALSE floatType is float.

var integer: INTTYPE_SIZE

Size of the type intType in bits (either 32 or 64). A typedef can define intType as int32Type respectively int64Type.

var integer: FLOATTYPE_SIZE

Size of the type floatType in bits.

var integer: POINTER_SIZE

Size of a pointer in bits.

var integer: GENERIC_SIZE

The maximum of INTTYPE_SIZE, FLOATTYPE_SIZE and POINTER_SIZE. This is also the size in bits of the types rtlValueUnion, rtlObjectType and genericType (defined in data_rtl.h).

var integer: INT_SIZE

Size of the type int in bits.

var integer: INT_MIN

Minimum value of the type int.

var integer: INT_MAX

Maximum value of the type int.

var integer: LONG_SIZE

Size of the type long in bits.

var integer: FLOATTYPE_MANTISSA_BITS

Number of mantissa bits in the binary floatType representation.

var integer: FLOATTYPE_EXPONENT_OFFSET

Exponent offset in the binary floatType representation. To get the actual exponent the offset must be subtracted.

var integer: INT_RANGE_IN_FLOATTYPE_MAX

Maximum from the continuous range of integers that map to floats. All integers from -INT_RANGE_IN_FLOATTYPE_MAX to INT_RANGE_IN_FLOATTYPE_MAX can be converted to floatType and back to intType without loss.

var integer: MINIMUM_TRUNC_ARGUMENT

Minimum value that trunc() or round() can convert. Values below MINIMUM_TRUNC_ARGUMENT raise RANGE_ERROR, if trunc() or round() is applied to them.

var integer: MAXIMUM_TRUNC_ARGUMENT

Maximum value that trunc() or round() can convert. Values above MAXIMUM_TRUNC_ARGUMENT raise RANGE_ERROR, if trunc() or round() is applied to them.

var integer: PIXEL_ALPHA_MASK

Mask for the alpha channel in a pixel. 0 if there is no alpha channel.

var integer: PIXEL_RED_MASK

Mask for the red color in a pixel. 0 if there is no mapping and drwRgbColor() should be used.

var integer: PIXEL_GREEN_MASK

Mask for the green color in a pixel. 0 if there is no mapping and drwRgbColor() should be used.

var integer: PIXEL_BLUE_MASK

Mask for the blue color in a pixel. 0 if there is no mapping and drwRgbColor() should be used.

var string: RGB_TO_PIXEL_FLAG_NAME

Name of the variable deciding between macro and drwRgbColor(). "" if no variable needs to be checked.

var integer: POINT_LIST_INT_SIZE

Size of an integer in a pointList object. A pointList consists of (x, y) coordinate pairs where each x and y has the size POINT_LIST_INT_SIZE.

var boolean: POINT_LIST_ABSOLUTE

TRUE if a pointList uses absolute coordinates. If it is FALSE the first (x, y) coordinate pair is absolute and the remaining (x, y) coordinates are relative to the previous coordinate pair.

var integer: RAND_MULTIPLIER

Multiplier for the linear congruential generator. A well known pseudorandom number generator algorithm.

var integer: RAND_INCREMENT

Increment for the linear congruential generator. A well known pseudorandom number generator algorithm.

var string: BOOLTYPE

Name of a type for the boolean values 0 and 1. The runtime library and the compiler use a typedef to define the type boolType with BOOLTYPE.

var string: INT32TYPE

Name of a signed integer type that is 32 bits wide. The runtime library and the compiler use a typedef to define the type int32Type with INT32TYPE.

var string: UINT32TYPE

Name of an unsigned integer type that is 32 bits wide. The runtime library and the compiler use a typedef to define the type uint32Type with UINT32TYPE.

var string: INT64TYPE

Name of a signed integer type that is 64 bits wide. The runtime library and the compiler use a typedef to define the type int64Type with INT64TYPE.

var string: UINT64TYPE

Name of an unsigned integer type that is 64 bits wide. The runtime library and the compiler use a typedef to define the type uint64Type with UINT64TYPE.

var string: INT128TYPE

Name of a signed integer type that is 128 bits wide. The runtime library and the compiler use a typedef to define the type int128Type with INT128TYPE. Empty string if there is no 128-bit signed integer type.

var string: UINT128TYPE

Name of an unsigned integer type that is 128 bits wide. The runtime library and the compiler use a typedef to define the type uint128Type with UINT128TYPE. Empty string if there is no 128-bit unsigned integer type.

var string: INT32TYPE_LITERAL_SUFFIX

The suffix used by the literals of the 32 bits wide integer type.

var string: INT64TYPE_LITERAL_SUFFIX

The suffix used by the literals of the 64 bits wide integer type.

var string: MACRO_DEFS

Definition of several macros (likely, unlikely, noreturn).

var string: OVERFLOW_SIGNAL

Name of the signal that is raised if a signed integer overflow occurs. OVERFLOW_SIGNAL is an empty string, if a signed integer overflow does not raise a signal. The C compiler option CC_OPT_TRAP_OVERFLOW is used to generate traps for signed integer overflow.

var string: BUILTIN_ADD_OVERFLOW

Name of a C compiler builtin function to add with overflow check. Empty string if there is no such builtin function.

var string: BUILTIN_SUB_OVERFLOW

Name of a C compiler builtin function to subtract with overflow check. Empty string if there is no such builtin function.

var string: BUILTIN_MULT_OVERFLOW

Name of a C compiler builtin function to multiply with overflow check. Empty string if there is no such builtin function.

var integer: INT_DIV_OVERFLOW

Defines what happens in case of an integer division overflow. An integer division can overflow with integer.first div -1. In this case the following things can happen:

• 0 it triggers an endless loop.
• 1 it triggers a popup window.
• 2 it returns integer.first.
• 3 it returns some other value.
• 4 it raises SIGFPE.
• 5 it raises SIGILL.
• 6 it raises SIGABRT.
• 7 it raises SIGTRAP.

In case of 0 (endless loop) the compiler must always check for an integer division overflow.

var integer: INT_REM_OVERFLOW

Defines what happens in case of an integer remainder overflow. An integer remainder can overflow with integer.first rem -1. In this case the following things can happen:

• 0 it triggers an endless loop.
• 1 it triggers a popup window.
• 2 it returns 0.
• 3 it returns some other value.
• 4 it raises SIGFPE.
• 5 it raises SIGILL.
• 6 it raises SIGABRT.
• 7 it raises SIGTRAP.

In case of 0 (endless loop) the compiler must always check for an integer remainder overflow.

var string: OBJECT_FILE_EXTENSION

The extension used by the C compiler for object files. Several object files and libraries are linked together to an executable. Under Linux/Unix/BSD this is usually ".o". Under Windows this is ".o" for MinGW and Cygwin, but ".obj" for other compilers.

var string: LIBRARY_FILE_EXTENSION

The extension used by the linker for static libraries. Several object files can be grouped to a library. Under Linux/Unix/BSD this is usually ".a". Under Windows this is ".a" for MinGW and Cygwin, but ".lib" for other linkers.

var string: EXECUTABLE_FILE_EXTENSION

The extension used by the operating system for executables. Since executable extensions are not used under Linux/Unix/BSD it is "" for them. Under Windows the value ".exe" is used.

var string: LINKED_PROGRAM_EXTENSION

The extension of the file produced by linking a program. Normally this is identical to the EXECUTABLE_FILE_EXTENSION, but in case of Emscripten this is independent from the EXECUTABLE_FILE_EXTENSION.

var string: CC_ENVIRONMENT_INI

Path to an INI file with the environment for the C compiler. If it is "" the C compiler does not need environment settings.

var string: C_COMPILER

Command to call the stand-alone C compiler and linker. Most IDEs provide also a stand-alone compiler/linker.

var boolean: CALL_C_COMPILER_FROM_SHELL

TRUE if C compiler and linker must be called via the shell. If it is FALSE C compiler and linker processes are started direct.

var array string: CC_OPT_DEBUG_INFO

C compiler option to add source level debugging information. With this option source level debugging information is added to the object file.

var string: CC_OPT_LINK_TIME_OPTIMIZATION

C compiler option to do link time optimization. If it is "" the C compiler does not support link time optimization.

var string: CC_OPT_NO_WARNINGS

C compiler option to suppress all warnings.

var array string: CC_OPT_OPTIMIZE_1

C compiler option to optimize with a level of -O1.

var array string: CC_OPT_OPTIMIZE_2

C compiler option to optimize with a level of -O2.

var array string: CC_OPT_OPTIMIZE_3

C compiler option to optimize with a level of -O3.

var string: CC_OPT_TRAP_OVERFLOW

C compiler option to generate traps for signed integer overflow. An integer overflow in the compiled program will trigger the signal defined with OVERFLOW_SIGNAL. CC_OPT_TRAP_OVERFLOW is an empty string, if the C compiler does not support such an option or if traps would not lead to a performance advantage.

var string: CC_OPT_VERSION_INFO

C compiler option to write the C compiler version information.

var array string: CC_FLAGS

C compiler flags to be used if C programs are compiled.

var integer: CC_ERROR_FILEDES

File descriptor to which the C compiler writes errors. The MSVC stand-alone C compiler (CL) writes the error messages to standard output (file descriptor 1). The C compilers of Linux/Unix/BSD and the compilers from MinGW and Cygwin write the error messages to the error output (file descriptor 2).

var integer: CC_VERSION_INFO_FILEDES

File descriptor to which the C compiler writes its version info.

var string: LINKER_OPT_DEBUG_INFO

Linker option to add source level debugging information. With this option source level debugging information is added to the executable file. (e.g.: "-Z7" or "-v"). Many compiler/linker combinations don't need this option to do source level debugging (use "").

var boolean: LINKER_OPT_LTO_MANDATORY

TRUE if linking always requires the option CC_OPT_LINK_TIME_OPTIMIZATION.

var string: LINKER_OPT_NO_DEBUG_INFO

Linker option to be used without source level debugging. This option can strip debug information (e.g.: "-Wl,--strip-debug").

var string: LINKER_OPT_OUTPUT_FILE

Linker option to provide the output filename (e.g.: "-o "). If no such option exists the value of LINKER_OPT_OUTPUT_FILE should be "". In this case it is assumed that the linker replaces the OBJECT_FILE_EXTENSION of the file with the LINKED_PROGRAM_EXTENSION.

var string: LINKER_OPT_SPECIAL_LIB

Linker option that needs to precede the special library. If no special library exists LINKER_OPT_SPECIAL_LIB is "".

var string: LINKER_OPT_STACK_SIZE

Linker option to specify the stack size of the executable. The argument for LINKER_OPT_STACK_SIZE is the stack size in bytes as decimal number. It must follow LINKER_OPT_STACK_SIZE immediately. The Seed7 compiler uses an argument of either DEFAULT_STACK_SIZE or the value specified with the -S Seed7 compiler option. If no linker option for the stack size exists LINKER_OPT_STACK_SIZE is "".

var array string: LINKER_FLAGS

Standard linker options to link a compiled program. This contains options, that the linker always uses, and which are not covered by other LINKER_OPT_... settings.

var integer: DEFAULT_STACK_SIZE

Default stack size for a compiled executable. This value is used, if the Seed7 compiler is invoked without -S. If LINKER_OPT_STACK_SIZE exists DEFAULT_STACK_SIZE is used as argument for the stack size. Additionally DEFAULT_STACK_SIZE is used as argument for setupStack().

var array string: SYSTEM_LIBS

Options to link system libraries to a compiled program. This is intended for options to link libraries required by the Seed7 runtime library. E.g. libraries for socket.

var array string: SYSTEM_BIGINT_LIBS

Options to link system bigint libraries to a compiled program. This is intended for options to link libraries required by the Seed7 bigint.s7i runtime library (e.g.: "-lgmp").

var array string: SYSTEM_CONSOLE_LIBS

Options to link system console libraries to a compiled program. This is intended for options to link libraries required by the Seed7 console runtime library (e.g.: "-lncurses").

var array string: SYSTEM_DATABASE_LIBS

Options to link system database ibraries to a compiled program. This is intended for options to link libraries required by the Seed7 database runtime libraries (e.g.: "-lmysqlclient").

var array string: SYSTEM_DRAW_LIBS

Options to link system graphic libraries to a compiled program. This is intended for options to link libraries required by the Seed7 graphic runtime library (e.g.: "-lX11").

var array string: SYSTEM_MATH_LIBS

Options to link system mathematic libraries to a compiled program. This is intended for options to link libraries required by the Seed7 math.s7i runtime library. (e.g.: "-lm").

var string: SEED7_LIB

Name of the Seed7 runtime library (e.g.: "seed7_05.a").

var string: DRAW_LIB

Name of the Seed7 graphic runtime library (e.g.: "s7_draw.a").

var string: CONSOLE_LIB

Name of the Seed7 text console runtime library (e.g.: "s7_con.a").

var string: DATABASE_LIB

Name of the Seed7 database runtime library (e.g.: "s7_db.a").

var string: COMP_DATA_LIB

Name of the Seed7 compiler data runtime library (e.g.: "s7_data.a").

var string: COMPILER_LIB

Name of the Seed7 compiler runtime library (e.g.: "s7_comp.a").

var string: SPECIAL_LIB

Name of the special library (e.g.: "pre_js.js").

var string: S7_LIB_DIR

Directory containing the Seed7 runtime libraries. This path uses the standard path representation (a slash is used as path separator and instead of a drive letter like "C:" the path "/c" is used).

var integer: VERSION_REVISION_LEVEL

The current version revision level of interpreter and compiler. The versioning of Seed7 interpreter and compiler use the pattern major.minor.revision (e.g.: 5.1.4). The revision level is incremented automatically with every compilation of the Seed7 interpreter. This configuration value allows that interpreter and compiler share the same revision.

var string: REDIRECT_FILEDES_1

Shell parameter to redirect to the file descriptor 1. Under Linux/Unix/BSD and Windows this is ">". The file to which the standard output should be redirected must be appended. E.g.: >myFile.

var string: REDIRECT_FILEDES_2

Shell parameter to redirect to the file descriptor 2. Under Linux/Unix/BSD and Windows this is "2>". The file to which the error output should be redirected must be appended. E.g.: 2>myFile.

var string: NULL_DEVICE

Name of the NULL device to be used in shell command redirections. Under Linux/Unix/BSD this is "/dev/null". Under Windows this is "NUL:".

var string: INTTYPE_LITERAL_SUFFIX

The suffix used by the literals of the type intType.

var ccConfigType: ccConf

Structure with configuration values for C compiler and runtime.

const func ccConfigType: getBuiltInConfig

Determine the built-in (hard-coded) C compiler configuration values.

Returns:

a structure with the built-in configuration values.