Mercurial > flash_v2
annotate packages/language/c/libc/current/include/pkgconf/libc.h @ 42:94fd8fbfe8fe ecos-sw-1999-10-05
Merge from eCos master repository on 1999-10-05-12:38:44-BST
| author | jlarmour |
|---|---|
| date | Tue, 05 Oct 1999 12:09:26 +0000 |
| parents | 443894e2e912 |
| children | 41bd4f3a90de |
| rev | line source |
|---|---|
| 0 | 1 #ifndef CYGONCE_PKGCONF_LIBC_H |
| 2 #define CYGONCE_PKGCONF_LIBC_H | |
| 3 //======================================================================== | |
| 4 // | |
| 5 // libc.h | |
| 6 // | |
| 7 // Configuration header for the ANSI standard C library | |
| 8 // | |
| 9 //======================================================================== | |
| 10 //####COPYRIGHTBEGIN#### | |
| 11 // | |
| 12 // ------------------------------------------- | |
| 13 // The contents of this file are subject to the Cygnus eCos Public License | |
| 14 // Version 1.0 (the "License"); you may not use this file except in | |
| 15 // compliance with the License. You may obtain a copy of the License at | |
| 16 // http://sourceware.cygnus.com/ecos | |
| 17 // | |
| 18 // Software distributed under the License is distributed on an "AS IS" | |
| 19 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the | |
| 20 // License for the specific language governing rights and limitations under | |
| 21 // the License. | |
| 22 // | |
| 23 // The Original Code is eCos - Embedded Cygnus Operating System, released | |
| 24 // September 30, 1998. | |
| 25 // | |
| 26 // The Initial Developer of the Original Code is Cygnus. Portions created | |
| 2 | 27 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. |
| 0 | 28 // ------------------------------------------- |
| 29 // | |
| 30 //####COPYRIGHTEND#### | |
| 31 //======================================================================== | |
| 32 //#####DESCRIPTIONBEGIN#### | |
| 33 // | |
| 34 // Author(s): jlarmour | |
| 2 | 35 // Contributors: jlarmour |
| 36 // Date: 1999-01-20 | |
| 0 | 37 // Purpose: Configuration of the ISO C library |
| 38 // Description: The preprocessor defines here can be used to configure | |
| 39 // the ISO C library, preferably with a graphical tool, | |
| 40 // but also manually if required. | |
| 41 // Usage: #include <pkgconf/libc.h> | |
| 42 // | |
| 43 // | |
| 44 //####DESCRIPTIONEND#### | |
| 45 // | |
| 46 //======================================================================== | |
| 47 | |
| 48 // INCLUDES | |
| 49 | |
| 50 // Include system configuration file to work out whether the C library is | |
| 51 // to be included at all | |
| 52 #include <pkgconf/system.h> | |
| 53 | |
| 54 /* | |
| 55 {{CFG_DATA | |
| 56 | |
| 57 cdl_package CYGPKG_LIBC { | |
| 2 | 58 display "C library" |
| 0 | 59 description "This package enables compatibility with the ISO |
| 60 C standard - ISO/IEC 9899:1990. This allows the | |
| 61 user application to use well known standard | |
| 62 C library functions, and in eCos starts a | |
| 63 thread to invoke the user function main()" | |
| 64 type boolean | |
| 2 | 65 requires CYGPKG_ERROR |
| 66 doc ref/ecos-ref/the-iso-standard-c-and-math-libraries.html | |
| 0 | 67 } |
| 68 | |
| 69 }}CFG_DATA | |
| 70 */ | |
| 71 | |
| 72 //======================================================================== | |
| 73 | |
| 74 // CTYPE CONFIGURATION OPTIONS | |
| 75 | |
| 76 /* | |
| 77 {{CFG_DATA | |
| 78 cdl_option CYGIMP_LIBC_CTYPE_INLINES { | |
| 79 display "Inline versions of <ctype.h> functions" | |
| 80 description "This option chooses whether the simple character | |
| 81 classification and conversion functions (e.g. | |
| 82 isupper(), isalpha(), toupper(), etc.) | |
| 83 from <ctype.h> are available as inline | |
| 84 functions. This may improve performance and as | |
| 85 the functions are small, may even improve code | |
| 86 size." | |
| 87 type boolean | |
| 88 parent CYGPKG_LIBC | |
| 89 } | |
| 90 }}CFG_DATA | |
| 91 */ | |
| 92 | |
| 93 #define CYGIMP_LIBC_CTYPE_INLINES | |
| 94 | |
| 95 //======================================================================== | |
| 96 | |
| 97 // STRING CONFIGURATION OPTIONS | |
| 98 | |
| 99 /* | |
| 100 {{CFG_DATA | |
| 101 cdl_component CYGPKG_LIBC_STRING { | |
| 102 display "String functions" | |
| 103 description "Options associated with the standard string | |
| 104 functions" | |
| 105 type dummy | |
| 106 parent CYGPKG_LIBC | |
| 107 } | |
| 108 | |
| 109 cdl_option CYGIMP_LIBC_STRING_INLINES { | |
| 110 display "Inline versions of <string.h> functions" | |
| 111 description "This option chooses whether some of the | |
| 112 particularly simple string functions from | |
| 113 <string.h> are available as inline | |
| 114 functions. This may improve performance, and as | |
| 115 the functions are small, may even improve code | |
| 116 size." | |
| 117 type boolean | |
| 118 parent CYGPKG_LIBC_STRING | |
| 119 } | |
| 120 | |
| 121 cdl_component CYGPKG_LIBC_STRING_OPTIMIZATIONS { | |
| 122 display "Options for string function optimization" | |
| 123 description "This component lets you choose between different | |
| 124 implementations of the string functions with | |
| 125 different tradeoffs. Most of the string | |
| 126 functions can be implemented in two ways. One | |
| 127 approach is geared towards smaller code size, | |
| 128 while the other tries to improve execution speed | |
| 129 at the expense of code size. " | |
| 130 type dummy | |
| 2 | 131 parent CYGPKG_LIBC_STRING |
| 0 | 132 } |
| 133 | |
| 134 cdl_option CYGIMP_LIBC_STRING_PREFER_FAST { | |
| 135 display "Fast" | |
| 136 description "This option improves string function execution | |
| 137 speed at the expense of code size. This | |
| 138 option is overriden if the code is | |
| 139 compiled with the -Os option to the compiler." | |
| 140 type radio | |
| 141 parent CYGPKG_LIBC_STRING_OPTIMIZATIONS | |
| 142 } | |
| 143 | |
| 144 cdl_option CYGIMP_LIBC_STRING_PREFER_SMALL { | |
| 145 display "Small" | |
| 146 description "This option tries to reduce string function | |
| 147 code size at the expense of execution speed. The | |
| 148 same effect can be produced if the code is | |
| 149 compiled with the -Os option to the compiler." | |
| 150 type radio | |
| 151 parent CYGPKG_LIBC_STRING_OPTIMIZATIONS | |
| 152 } | |
| 153 | |
| 2 | 154 cdl_component CYGPKG_LIBC_STRING_STRTOK { |
| 155 display "strtok" | |
| 156 description "These options control the behaviour of the | |
| 157 strtok() and strtok_r() string tokenization | |
| 158 functions." | |
| 159 type dummy | |
| 160 parent CYGPKG_LIBC_STRING | |
| 161 } | |
| 162 | |
| 163 cdl_option CYGSEM_LIBC_PER_THREAD_STRTOK { | |
| 164 display "Per-thread strtok()" | |
| 165 description "This option controls whether the string function | |
| 166 strtok() has its state recorded on a per-thread | |
| 167 basis rather than global. If this option is | |
| 168 disabled, some per-thread space can be saved. | |
| 169 Note there is also a POSIX-standard strtok_r() | |
| 170 function to achieve a similar effect with user | |
| 171 support. Enabling this option will use one slot | |
| 172 of kernel per-thread data. You should ensure you | |
| 173 have enough slots configured for all your | |
| 174 per-thread data." | |
| 175 doc ref/ecos-ref/c-and-math-library-overview-thread-safety.html | |
| 176 type boolean | |
| 177 parent CYGPKG_LIBC_STRING_STRTOK | |
| 178 requires CYGVAR_KERNEL_THREADS_DATA | |
| 179 } | |
| 180 | |
| 181 cdl_option CYGNUM_LIBC_STRTOK_TRACE_LEVEL { | |
| 182 display "Tracing level" | |
| 183 description "Trace verbosity level for debugging the <string.h> | |
| 184 functions strtok() and strtok_r(). Increase this | |
| 185 value to get additional trace output." | |
| 186 type count | |
| 187 legal_values 0 to 1 | |
| 188 parent CYGPKG_LIBC_STRING_STRTOK | |
| 189 } | |
| 190 | |
| 0 | 191 }}CFG_DATA |
| 192 */ | |
| 193 | |
| 194 #define CYGIMP_LIBC_STRING_INLINES | |
| 195 | |
| 196 #undef CYGIMP_LIBC_STRING_PREFER_SMALL | |
| 197 | |
| 198 #define CYGIMP_LIBC_STRING_PREFER_FAST | |
| 199 | |
| 200 #ifdef CYGIMP_LIBC_STRING_PREFER_SMALL | |
| 201 # define CYGIMP_LIBC_STRING_PREFER_SMALL_TO_FAST | |
| 202 #endif | |
| 203 | |
| 2 | 204 #undef CYGSEM_LIBC_PER_THREAD_STRTOK |
| 205 | |
| 206 #define CYGNUM_LIBC_STRTOK_TRACE_LEVEL 0 | |
| 207 | |
| 0 | 208 //======================================================================== |
| 209 | |
| 210 // SETJMP CONFIGURATION OPTIONS | |
| 211 | |
| 212 /* | |
| 213 {{CFG_DATA | |
| 214 cdl_option CYGIMP_LIBC_SETJMP_INLINES { | |
| 215 display "Inline version of the longjmp() function" | |
| 216 description "This option chooses whether the longjmp() function | |
| 217 is available as an inline function. This may | |
| 218 improve performance, and as the function is small | |
| 219 may even improve code size. " | |
| 220 type boolean | |
| 221 parent CYGPKG_LIBC | |
| 222 } | |
| 223 }}CFG_DATA | |
| 224 */ | |
| 225 | |
| 226 #define CYGIMP_LIBC_SETJMP_INLINES | |
| 227 | |
| 228 //======================================================================== | |
| 229 | |
| 230 // STDLIB CONFIGURATION OPTIONS | |
| 231 | |
| 232 | |
| 233 /* | |
| 234 {{CFG_DATA | |
| 235 cdl_component CYGPKG_LIBC_STDLIB { | |
| 236 display "Standard utility functions" | |
| 237 description "Options associated with the standard utility | |
| 238 functions in <stdlib.h>" | |
| 239 type dummy | |
| 240 parent CYGPKG_LIBC | |
| 241 } | |
| 242 | |
| 243 cdl_option CYGIMP_LIBC_STDLIB_INLINES { | |
| 244 display "Inline versions of <stdlib.h> functions" | |
| 245 description "This option chooses whether some of the | |
| 246 particularly simple standard utility functions | |
| 247 from <stdlib.h> are available as inline | |
| 248 functions. This may improve performance, and as | |
| 249 the functions are small, may even improve code | |
| 250 size." | |
| 251 type boolean | |
| 252 parent CYGPKG_LIBC_STDLIB | |
| 253 } | |
| 254 | |
| 255 cdl_component CYGPKG_LIBC_RAND { | |
| 2 | 256 display "Random number generation" |
| 257 description "These options control the behaviour of the | |
| 258 functions rand(), srand() and rand_r()" | |
| 259 type dummy | |
| 260 parent CYGPKG_LIBC_STDLIB | |
| 261 } | |
| 262 | |
| 263 cdl_option CYGSEM_LIBC_PER_THREAD_RAND { | |
| 264 display "Per-thread random seed" | |
| 265 description "This option controls whether the pseudo-random | |
| 266 number generation functions rand() and srand() | |
| 267 have their state recorded on a per-thread | |
| 268 basis rather than global. If this option is | |
| 269 disabled, some per-thread space can be saved. | |
| 270 Note there is also a POSIX-standard rand_r() | |
| 271 function to achieve a similar effect with user | |
| 272 support. Enabling this option will use one slot | |
| 273 of kernel per-thread data. You should ensure you | |
| 274 have enough slots configured for all your | |
| 275 per-thread data." | |
| 276 doc ref/ecos-ref/c-and-math-library-overview-thread-safety.html | |
| 277 type boolean | |
| 278 requires CYGVAR_KERNEL_THREADS_DATA | |
| 279 parent CYGPKG_LIBC_RAND | |
| 0 | 280 } |
| 281 | |
| 282 cdl_option CYGNUM_LIBC_RAND_SEED { | |
| 283 display "Random number seed" | |
| 284 description "This selects the initial random number seed for | |
| 285 rand()'s pseudo-random number generator. For | |
| 286 strict ISO standard compliance, this should be 1, | |
| 287 as per section 7.10.2.2 of the standard." | |
| 288 type count | |
| 289 legal_values 0 to 0x7fffffff | |
| 290 parent CYGPKG_LIBC_RAND | |
| 291 } | |
| 292 | |
| 2 | 293 cdl_option CYGNUM_LIBC_RAND_TRACE_LEVEL { |
| 294 display "Tracing level" | |
| 295 description "Trace verbosity level for debugging the rand(), | |
| 296 srand() and rand_r() functions. Increase this | |
| 297 value to get additional trace output." | |
| 298 type count | |
| 299 legal_values 0 to 1 | |
| 300 parent CYGPKG_LIBC_RAND | |
| 301 } | |
| 302 | |
| 303 cdl_option CYGIMP_LIBC_RAND_SIMPLEST { | |
| 304 display "Simplest implementation" | |
| 305 description "This provides a very simple implementation of rand() | |
| 306 that does not perform well with randomness in the | |
| 307 lower significant bits. However it is exceptionally | |
| 308 fast. It uses the sample algorithm from the ISO C | |
| 309 standard itself." | |
| 310 type radio | |
| 311 parent CYGPKG_LIBC_RAND | |
| 312 } | |
| 313 | |
| 314 cdl_option CYGIMP_LIBC_RAND_SIMPLE1 { | |
| 315 display "Simple implementation #1" | |
| 316 description "This provides a very simple implementation of rand() | |
| 317 based on the simplest implementation above. However | |
| 318 it does try to work around the lack of randomness | |
| 319 in the lower significant bits, at the expense of a | |
| 320 little speed." | |
| 321 type radio | |
| 322 parent CYGPKG_LIBC_RAND | |
| 323 } | |
| 324 | |
| 325 cdl_option CYGIMP_LIBC_RAND_KNUTH1 { | |
| 326 display "Knuth implementation #1" | |
| 327 description "This implements a slightly more complex algorithm | |
| 328 published in Donald E. Knuth's Art of Computer | |
| 329 Programming Vol.2 section 3.6 (p.185 in the 3rd ed.). | |
| 330 This produces better random numbers than the | |
| 331 simplest approach but is slower." | |
| 332 type radio | |
| 333 parent CYGPKG_LIBC_RAND | |
| 334 } | |
| 335 | |
| 0 | 336 cdl_component CYGPKG_LIBC_MALLOC { |
| 337 display "Support for dynamic memory allocation" | |
| 338 description "This enables support for dynamic memory | |
| 339 allocation as supplied by the functions malloc(), | |
| 340 free(), calloc() and realloc(). As these | |
| 341 functions are often used, but can have quite an | |
| 342 overhead, disabling them here can ensure they | |
| 343 cannot even be used accidentally when static | |
| 344 allocation is preferred." | |
| 345 type boolean | |
| 346 parent CYGPKG_LIBC_STDLIB | |
| 347 requires CYGPKG_KERNEL | |
| 348 } | |
| 349 | |
| 350 cdl_option CYGNUM_LIBC_MALLOC_MEMPOOL_SIZE { | |
| 351 display "Size of the dynamic memory pool in bytes" | |
| 352 description "At this stage, dynamic memory allocation by | |
| 353 malloc() and calloc() must be from a fixed-size, | |
| 2 | 354 contiguous memory pool (note here that it is the |
| 355 pool that is of a fixed size, but malloc() is still | |
| 356 able to allocate variable sized chunks of memory | |
| 357 from it). This option is the size | |
| 0 | 358 of that pool, in bytes. Note that not all of |
| 359 this is available for programs to | |
| 360 use - some is needed for internal information | |
| 361 about memory regions, and some may be lost to | |
| 362 ensure that memory allocation only returns | |
| 363 memory aligned on word (or double word) | |
| 364 boundaries - a very common architecture | |
| 365 constraint." | |
| 366 type count | |
| 367 legal_values 32 to 0x7fffffff | |
| 368 parent CYGPKG_LIBC_MALLOC | |
| 369 } | |
| 370 | |
| 371 cdl_option CYGIMP_LIBC_MALLOC_CXX_DELETE_CALLS_FREE { | |
| 372 display "Support for C++ delete operator" | |
| 373 description "C++ new and delete operators can call | |
| 374 the C library's malloc() and free() implicitly. | |
| 375 If this is what is required, enable this option. | |
| 376 However, if enabled, the dynamic memory allocation | |
| 377 code is always linked in to the application, | |
| 378 even if it is not explicitly called and new/delete | |
| 379 are not used. | |
| 380 This increases code and data size needlessly." | |
| 381 type bool | |
| 382 parent CYGPKG_LIBC_MALLOC | |
| 383 } | |
| 384 | |
| 385 cdl_option CYGFUN_LIBC_strtod { | |
| 386 display "Provides strtod() and atof()" | |
| 387 description "This option allows use of the utility function | |
| 388 strtod() (and consequently atof()) to convert | |
| 389 from string to double precision floating point | |
| 390 numbers. Disabling this option removes the | |
| 391 dependency on the math library package." | |
| 392 type boolean | |
| 393 parent CYGPKG_LIBC_STDLIB | |
| 394 requires CYGPKG_LIBM | |
| 395 } | |
| 396 | |
| 2 | 397 cdl_option CYGNUM_LIBC_BSEARCH_TRACE_LEVEL { |
| 398 display "bsearch() tracing level" | |
| 399 description "Trace verbosity level for debugging the <stdlib.h> | |
| 400 binary search function bsearch(). Increase this | |
| 401 value to get additional trace output." | |
| 402 type count | |
| 403 legal_values 0 to 1 | |
| 404 parent CYGPKG_LIBC_STDLIB | |
| 405 } | |
| 406 | |
| 407 cdl_option CYGNUM_LIBC_QSORT_TRACE_LEVEL { | |
| 408 display "qsort() tracing level" | |
| 409 description "Trace verbosity level for debugging the <stdlib.h> | |
| 410 quicksort function qsort(). Increase this value | |
| 411 to get additional trace output." | |
| 412 type count | |
| 413 legal_values 0 to 1 | |
| 414 parent CYGPKG_LIBC_STDLIB | |
| 415 } | |
| 416 | |
| 0 | 417 }}CFG_DATA |
| 418 */ | |
| 419 | |
| 420 #define CYGIMP_LIBC_STDLIB_INLINES | |
| 421 | |
| 2 | 422 #undef CYGSEM_LIBC_PER_THREAD_RAND |
| 423 | |
| 424 #define CYGNUM_LIBC_RAND_SEED 1 | |
| 425 | |
| 426 #define CYGNUM_LIBC_RAND_TRACE_LEVEL 0 | |
| 0 | 427 |
| 2 | 428 #undef CYGIMP_LIBC_RAND_SIMPLEST |
| 429 | |
| 430 #define CYGIMP_LIBC_RAND_SIMPLE1 | |
| 431 | |
| 432 #undef CYGIMP_LIBC_RAND_KNUTH1 | |
| 0 | 433 |
| 434 #define CYGPKG_LIBC_MALLOC | |
| 435 | |
| 436 #ifdef CYGPKG_LIBC_MALLOC | |
| 437 | |
| 438 #undef CYGIMP_LIBC_MALLOC_CXX_DELETE_CALLS_FREE | |
| 439 | |
| 2 | 440 #define CYGNUM_LIBC_MALLOC_MEMPOOL_SIZE 16384 |
| 0 | 441 |
| 442 #endif // ifdef CYGPKG_LIBC_MALLOC | |
| 443 | |
| 444 #define CYGFUN_LIBC_strtod | |
| 445 | |
| 2 | 446 #define CYGNUM_LIBC_BSEARCH_TRACE_LEVEL 0 |
| 447 | |
| 448 #define CYGNUM_LIBC_QSORT_TRACE_LEVEL 0 | |
| 449 | |
| 0 | 450 #ifdef CYGFUN_LIBC_strtod |
| 451 # ifndef CYGPKG_LIBM | |
| 452 # error You must enable the Math library package to use strtod() or atof() | |
| 453 # endif | |
| 454 #endif | |
| 455 | |
| 456 //======================================================================== | |
| 457 | |
| 458 // STDIO CONFIGURATION OPTIONS | |
| 459 | |
| 460 /* | |
| 461 {{CFG_DATA | |
| 462 cdl_component CYGPKG_LIBC_STDIO { | |
| 463 display "Standard Input/Output functions" | |
| 464 description "This enables support for standard I/O functions | |
| 465 from <stdio.h>." | |
| 466 type boolean | |
| 467 parent CYGPKG_LIBC | |
| 2 | 468 requires CYGPKG_IO |
| 0 | 469 } |
| 470 | |
| 471 cdl_option CYGIMP_LIBC_STDIO_INLINES { | |
| 472 display "Inline versions of <stdio.h> functions" | |
| 473 description "This option chooses whether some of the | |
| 474 particularly simple functions from | |
| 475 <stdio.h> are available as inline | |
| 476 functions. This may improve performance, and as | |
| 477 the functions are small, may even improve code | |
| 478 size." | |
| 479 type boolean | |
| 480 parent CYGPKG_LIBC_STDIO | |
| 481 } | |
| 482 | |
| 483 cdl_option FOPEN_MAX { | |
| 484 display "Permitted number of open files" | |
| 485 description "This option controls the guaranteed minimum | |
| 486 number of simultaneously open files. The ISO | |
| 487 C standard requires it to be defined (para | |
| 488 7.9.1), and if strictly compliant, it must be | |
| 489 at least 8 (para 7.9.3). In practice it can be | |
| 490 as low as 3 - for stdin, stdout and stderr." | |
| 491 type count | |
| 492 legal_values 3 to 0x7fffffff | |
| 493 parent CYGPKG_LIBC_STDIO | |
| 494 } | |
| 495 | |
| 496 cdl_option FILENAME_MAX { | |
| 497 display "Maximum length of filename" | |
| 498 description "This option defines the maximum allowed size of | |
| 499 a filename in characters. The ISO C standard | |
| 500 requires it to be defined (para 7.9.1)." | |
| 501 type count | |
| 502 legal_values 1 to 0x7fffffff | |
| 503 parent CYGPKG_LIBC_STDIO | |
| 504 } | |
| 505 | |
| 506 cdl_option L_tmpnam { | |
| 507 display "Maximum length of filenames for temporary files" | |
| 508 description "This option defines the maximum allowed size of | |
| 509 filenames for temporary files as generated by | |
| 510 tmpnam(). It is measured in characters, and the | |
| 511 ISO C standard requires it to be defined (para | |
| 512 7.9.1)." | |
| 2 | 513 type count |
| 514 legal_values 1 to 0x7fffffff | |
| 515 parent CYGPKG_LIBC_STDIO | |
| 0 | 516 } |
| 517 | |
| 518 cdl_option TMP_MAX { | |
| 519 display "Unique file names generated by tmpnam()" | |
| 520 description "This option defines the minimum number of | |
| 521 unique file names generated by tmpnam(). The | |
| 522 ISO C standard requires it to be defined (para | |
| 523 7.9.1)." | |
| 524 type count | |
| 525 legal_values 0 to 0x7fffffff | |
| 526 parent CYGPKG_LIBC_STDIO | |
| 527 } | |
| 528 | |
| 529 cdl_component CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO { | |
| 530 display "Buffered I/O" | |
| 531 description "This option controls whether input/output | |
| 532 through the <stdio.h> functions is buffered. | |
| 533 This may save some memory per file. It | |
| 534 is equivalent to putting every file into | |
| 535 non-buffered mode (_IONBF) through setvbuf(), | |
| 536 except now it can never be altered back to | |
| 537 buffered mode. Disabling buffering is strictly | |
| 538 non-compliant with the ISO C standard." | |
| 539 type boolean | |
| 540 parent CYGPKG_LIBC_STDIO | |
| 541 } | |
| 542 | |
| 543 cdl_option CYGNUM_LIBC_STDIO_BUFSIZE { | |
| 544 display "Default buffer size" | |
| 545 description "This option defines the default size of buffer | |
| 546 used with calls to setbuf(), and is the default | |
| 547 size for buffered streams that have not had | |
| 548 either setbuf() or setvbuf() invoked on them. | |
| 549 It is exactly equivalent to the standard | |
| 2 | 550 constant BUFSIZ, except that it is 0 if |
| 0 | 551 CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO is disabled. |
| 552 The ISO C standard requires this to be defined | |
| 553 (para 7.9.1), and says it must be at least 256 | |
| 554 (para 7.9.2)." | |
| 555 type count | |
| 556 legal_values 1 to 0x7fffffff | |
| 557 parent CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO | |
| 558 } | |
| 559 | |
| 560 cdl_option CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF { | |
| 561 display "setbuf()/setvbuf() uses malloc()" | |
| 562 description "This option controls whether I/O buffers are | |
| 563 implemented dynamically within the stdio | |
| 564 implementation. Otherwise they will be static, | |
| 565 and cannot be changed by setbuf()/setvbuf(). If | |
| 566 they are static (i.e. this option is disabled), | |
| 567 any attempt to use an arbitrary buffer size, or | |
| 568 to pass a user-supplied buffer to setbuf() or | |
| 569 setvbuf() will fail - the buffer is implemented | |
| 570 internally as a static array of taking the size | |
| 2 | 571 of the configuration option BUFSIZ. The only |
| 0 | 572 exception is if a user buffer is not supplied, |
| 573 and the buffer size requested is less than | |
| 2 | 574 BUFSIZ. In this case, the buffer will |
| 0 | 575 be configured to only use that amount of |
| 576 buffering. However the unused memory left over | |
| 577 will NOT be freed. If this option is enabled, | |
| 578 then CYGPKG_LIBC_MALLOC must also | |
| 579 be enabled. Either setting can be considered to | |
| 580 be compliant with the ISO C standard." | |
| 581 type boolean | |
| 582 parent CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO | |
| 583 requires CYGPKG_LIBC_MALLOC | |
| 584 } | |
| 585 | |
| 586 cdl_option CYGFUN_LIBC_STDIO_ungetc { | |
| 587 display "Support for ungetc()" | |
| 588 description "This option controls whether ungetc() is | |
| 589 supported. If not, then some space can be | |
| 590 saved, and speed is improved. Note that you | |
| 591 MUST have this defined if you want to use the | |
| 592 scanf() family of functions." | |
| 593 type boolean | |
| 594 parent CYGPKG_LIBC_STDIO | |
| 595 } | |
| 596 | |
| 597 cdl_option CYGPKG_LIBC_STDIO_OPEN { | |
| 598 display "Dynamic opening/closing of files" | |
| 599 description "fopen() and fclose() use dynamic memory | |
| 600 allocation routines to allocate memory for | |
| 601 new FILE structure pointers. This option, | |
| 602 along with CYGPKG_LIBC_MALLOC, should be | |
| 603 enabled to use | |
| 604 fopen() and fclose(). If disabled, only the | |
| 605 default console streams - stdin, stdout and | |
| 606 stderr - will be available." | |
| 607 type boolean | |
| 608 parent CYGPKG_LIBC_STDIO | |
| 609 requires CYGPKG_LIBC_MALLOC | |
| 610 } | |
| 611 | |
| 612 cdl_option CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE { | |
| 613 display "Default console device" | |
| 614 description "This option allows you to choose the | |
| 615 default console device. In the current | |
| 616 implementation, all these devices begin | |
| 617 with the prefix /dev/ and are followed by | |
| 2 | 618 the name of a device. The name of the device |
| 619 depends on the device drivers you have | |
| 620 configured in your system. For example, | |
|
42
94fd8fbfe8fe
Merge from eCos master repository on 1999-10-05-12:38:44-BST
jlarmour
parents:
2
diff
changeset
|
621 /dev/ttydiag could be the HAL diagnostic output |
| 2 | 622 pseudo-device, or /dev/tty0 could be your |
| 623 first serial driver, depending on your | |
| 624 configuration." | |
| 0 | 625 type string |
| 626 parent CYGPKG_LIBC_STDIO | |
| 627 } | |
| 628 | |
| 629 cdl_component CYGPKG_LIBC_STDIO_FLOATING_POINT { | |
| 630 display "Floating point support" | |
| 631 description "This component allows floating point support | |
| 632 to be enabled in certain standard I/O | |
| 633 functions." | |
| 634 type dummy | |
| 635 parent CYGPKG_LIBC_STDIO | |
| 636 } | |
| 637 | |
| 638 cdl_option CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT { | |
| 639 display "printf() family" | |
| 640 description "This option enables the use of floating point | |
| 641 number output in the printf() family (i.e. | |
| 642 printf(), sprintf(), vprintf(), etc.) of | |
| 643 functions. A substantial amount of code space | |
| 644 can be saved if this option is disabled. If it | |
| 645 is disabled then floating point specifiers | |
| 646 (%e, %f, %g) are ignored, and nothing is | |
| 647 output." | |
| 648 type boolean | |
| 649 parent CYGPKG_LIBC_STDIO_FLOATING_POINT | |
| 650 requires CYGPKG_LIBM | |
| 651 } | |
| 652 | |
| 653 cdl_option CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT { | |
| 654 display "scanf() family" | |
| 655 description "This option enables the use of floating point | |
| 656 number conversion in the scanf() family (i.e. | |
| 657 scanf(), sscanf(), vscanf(), etc.) of | |
| 658 functions. A substantial amount of code space | |
| 659 can be saved if this option is disabled. If it | |
| 660 is disabled then floating point specifiers | |
| 661 (%e, %f, %g) are ignored, and nothing is | |
| 662 converted." | |
| 663 type boolean | |
| 664 parent CYGPKG_LIBC_STDIO_FLOATING_POINT | |
| 665 requires CYGPKG_LIBM | |
| 666 requires CYGFUN_LIBC_strtod | |
| 667 } | |
| 668 | |
| 2 | 669 cdl_option CYGSEM_LIBC_STDIO_THREAD_SAFE_STREAMS { |
| 670 display "Thread safe I/O streams" | |
| 671 description "This option controls whether standard I/O streams | |
| 672 are thread-safe. Having this option set allows | |
| 673 the streams to be locked when accessed by | |
| 674 multiple threads simultaneously." | |
| 675 doc ref/ecos-ref/c-and-math-library-overview-thread-safety.html | |
| 676 type boolean | |
| 677 parent CYGPKG_LIBC_STDIO | |
| 678 requires CYGPKG_KERNEL | |
| 679 } | |
| 680 | |
| 0 | 681 }}CFG_DATA |
| 682 */ | |
| 683 | |
| 684 #define CYGPKG_LIBC_STDIO | |
| 685 | |
| 686 #ifdef CYGPKG_LIBC_STDIO | |
| 687 | |
| 2 | 688 #ifndef CYGPKG_IO |
| 0 | 689 # error You must have generic device driver support enabled for C library \ |
| 690 standard I/O | |
| 691 #endif | |
| 692 | |
| 693 #define CYGIMP_LIBC_STDIO_INLINES | |
| 694 | |
| 695 #define FOPEN_MAX 8 | |
| 696 | |
| 697 #define FILENAME_MAX 16 | |
| 698 | |
| 699 #define L_tmpnam 16 | |
| 700 | |
| 701 #define TMP_MAX 0 | |
| 702 | |
| 703 #define CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO | |
| 704 | |
| 705 #define CYGNUM_LIBC_STDIO_BUFSIZE 256 | |
| 706 | |
| 707 #ifdef CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO | |
| 2 | 708 # define BUFSIZ CYGNUM_LIBC_STDIO_BUFSIZE |
| 0 | 709 #else |
| 2 | 710 # define BUFSIZ 0 |
| 0 | 711 #endif |
| 712 | |
| 713 #undef CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF | |
| 714 | |
| 715 #ifdef CYGSEM_LIBC_STDIO_DYNAMIC_SETVBUF | |
| 716 # ifndef CYGPKG_LIBC_MALLOC | |
| 717 # error You must have malloc() support if you want dynamic setvbuf \ | |
| 718 support in the C library | |
| 719 # endif | |
| 720 #endif | |
| 721 | |
| 722 #define CYGFUN_LIBC_STDIO_ungetc | |
| 723 | |
| 724 #define CYGPKG_LIBC_STDIO_OPEN | |
| 725 | |
| 726 #ifdef CYGPKG_LIBC_STDIO_OPEN | |
| 727 # ifndef CYGPKG_LIBC_MALLOC | |
| 728 # error You must have malloc() support if you want to use fopen() | |
| 729 # endif | |
| 730 #endif | |
| 731 | |
| 732 // We define a default console so that the console is defined | |
| 733 // statically, to prevent the requirement of dynamic memory allocation, and | |
| 734 // since there is generally only one relevant console which exists for the | |
| 735 // lifetime of the system. See the device driver documentation and examine | |
| 736 // your configuration to find out which device names are available. The | |
| 737 // device names should be prefixed with "/dev/". | |
| 738 // | |
| 739 // So what is the name of the device that is the default console device | |
| 2 | 740 |
|
42
94fd8fbfe8fe
Merge from eCos master repository on 1999-10-05-12:38:44-BST
jlarmour
parents:
2
diff
changeset
|
741 #define CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE "/dev/ttydiag" |
| 0 | 742 |
| 743 #define CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT | |
| 744 | |
| 745 #ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT | |
| 746 # ifndef CYGPKG_LIBM | |
| 747 # error You must enable the Math library to use floating point in the \ | |
| 748 *printf() functions | |
| 749 # endif | |
| 750 #endif | |
| 751 | |
| 752 #define CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT | |
| 753 | |
| 754 #ifdef CYGSEM_LIBC_STDIO_SCANF_FLOATING_POINT | |
| 755 # ifndef CYGFUN_LIBC_strtod // libm is implicit with this | |
| 756 # error You must enable the use of strtod and the math library to use \ | |
| 757 floating point in the *scanf() functions | |
| 758 # endif | |
| 759 #endif | |
| 760 | |
| 761 #endif // ifdef CYGPKG_LIBC_STDIO | |
| 762 | |
| 763 #define CYGSEM_LIBC_STDIO_THREAD_SAFE_STREAMS | |
| 764 | |
| 765 //======================================================================== | |
| 766 | |
| 767 // INTERNATIONALIZATION AND LOCALIZATION OPTIONS | |
| 768 | |
| 769 /* | |
| 770 | |
| 771 {{CFG_DATA | |
| 772 | |
| 773 cdl_option CYGNUM_LIBC_MAX_LOCALE_NAME_SIZE { | |
| 774 display "Size of locale name strings" | |
| 775 description "This option controls the maximum size of | |
| 776 locale names and is used, among other things | |
| 777 to instantiate a static string used | |
| 778 as a return value from the | |
| 779 setlocale() function. When requesting the | |
| 780 current locale settings with LC_ALL, a string | |
| 781 must be constructed to contain this data, rather | |
| 782 than just returning a constant string. This | |
| 783 string data is stored in the static string. | |
| 784 This depends on the length of locale names, | |
| 785 hence this option. If just the C locale is | |
| 786 present, this option can be set as low as 2." | |
| 787 type count | |
| 788 legal_values 2 to 0x7fffffff | |
| 789 parent CYGPKG_LIBC | |
| 790 } | |
| 791 | |
| 792 }}CFG_DATA | |
| 793 | |
| 794 */ | |
| 795 | |
| 796 #define CYGNUM_LIBC_MAX_LOCALE_NAME_SIZE 16 | |
| 797 | |
| 798 //======================================================================== | |
| 799 | |
| 2 | 800 // SIGNAL CONFIGURATION OPTIONS |
| 801 | |
| 802 /* | |
| 803 {{CFG_DATA | |
| 804 cdl_component CYGPKG_LIBC_SIGNALS { | |
| 805 display "Signals" | |
| 806 description "This component controls signal functionality, | |
| 807 as implemented in ISO C chapter 7.7 with the | |
| 808 signal() and raise() functions. As well as | |
| 809 allowing a program to send itself signals, it is | |
| 810 also possible to cause hardware exceptions to | |
| 811 be signalled to the program in a similar way." | |
| 812 type boolean | |
| 813 parent CYGPKG_LIBC | |
| 814 } | |
| 815 | |
| 816 cdl_option CYGSEM_LIBC_SIGNALS_THREAD_SAFE { | |
| 817 display "Thread safe signals" | |
| 818 description "Because signal handlers are global, and not | |
| 819 thread-specific (as mandated by POSIX 1003.1) | |
| 820 it is possible for multiple threads to clash | |
| 821 and corrupt data if setting the same signal | |
| 822 handler at the same time. With this option | |
| 823 enabled, a kernel mutex will be used to protect | |
| 824 the shared data." | |
| 825 type boolean | |
| 826 requires CYGPKG_KERNEL | |
| 827 parent CYGPKG_LIBC_SIGNALS | |
| 828 } | |
| 829 | |
| 830 cdl_component CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS { | |
| 831 display "Hardware exceptions cause signals" | |
| 832 description "This causes hardware exceptions like | |
| 833 arithmetic exceptions (e.g. divide by zero) | |
| 834 or bad memory accesses to be passed through as | |
| 835 signals. It is thus possible for a program to | |
| 836 handle these exceptions in a generic way using | |
| 837 the appropriate signal handlers. The details of | |
| 838 exactly which exceptions are passed through | |
| 839 under what circumstances depend on the | |
| 840 underlying HAL implementation. Consequently it | |
| 841 must be remembered that signal handlers cannot | |
| 842 be guaranteed to be invoked in the expected | |
| 843 circumstances if you do not know about the | |
| 844 underlying HAL implementation - it is possible | |
| 845 that the architecture is unable to detect that | |
| 846 exception." | |
| 847 type boolean | |
| 848 requires CYGSEM_KERNEL_EXCEPTIONS_GLOBAL | |
| 849 requires CYGSEM_KERNEL_EXCEPTIONS_DECODE | |
| 850 parent CYGPKG_LIBC_SIGNALS | |
| 851 } | |
| 852 | |
| 853 cdl_option CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS { | |
| 854 display "Chain old exception handlers" | |
| 855 description "When hardware exceptions are generated, it | |
| 856 is possible to chain into the old kernel exception | |
| 857 handler before calling any registered signal | |
| 858 handler. If this is not required, disable this | |
| 859 option and only the signal handler will be | |
| 860 called when this exception occurs. Disabling | |
| 861 this option will also save some space and code | |
| 862 usage." | |
| 863 type boolean | |
| 864 requires !CYGPKG_HAL_I386_LINUX | |
| 865 parent CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS | |
| 866 } | |
| 867 | |
| 868 cdl_component CYGPKG_LIBC_SIGNALS_INLINE { | |
| 869 display "Inline versions of functions" | |
| 870 description "Some functions can be made inline instead of | |
| 871 being function calls. These can be set here." | |
| 872 type dummy | |
| 873 parent CYGPKG_LIBC_SIGNALS | |
| 874 } | |
| 875 | |
| 876 cdl_option CYGIMP_LIBC_SIGNALS_RAISE_INLINE { | |
| 877 display "raise()" | |
| 878 description "Enabling this option makes raise() an inline | |
| 879 function." | |
| 880 type boolean | |
| 881 parent CYGPKG_LIBC_SIGNALS_INLINE | |
| 882 } | |
| 883 | |
| 884 cdl_option CYGIMP_LIBC_SIGNALS_SIGNAL_INLINE { | |
| 885 display "signal()" | |
| 886 description "Enabling this option makes signal() an inline | |
| 887 function." | |
| 888 type boolean | |
| 889 parent CYGPKG_LIBC_SIGNALS_INLINE | |
| 890 } | |
| 891 | |
| 892 cdl_component CYGPKG_LIBC_SIGNALS_ERROR_HANDLING { | |
| 893 display "Error handling" | |
| 894 description "You may or may not want errno to be set by | |
| 895 certain functions. Not using errno could save | |
| 896 both space, code, and avoid worrying about | |
| 897 interactions between multiple threads when | |
| 898 setting it." | |
| 899 type dummy | |
| 900 parent CYGPKG_LIBC_SIGNALS | |
| 901 } | |
| 902 | |
| 903 cdl_option CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL { | |
| 904 display "Bad signal fatal" | |
| 905 description "Enabling this option will cause an assertion | |
| 906 failure if the signal handling code is | |
| 907 passed a bad signal. Otherwise an error will | |
| 908 be returned, or in the case of a | |
| 909 hardware-generated exception it will be silently | |
| 910 ignored." | |
| 911 type boolean | |
| 912 requires CYGDBG_USE_ASSERTS | |
| 913 parent CYGPKG_LIBC_SIGNALS_ERROR_HANDLING | |
| 914 } | |
| 915 | |
| 916 cdl_option CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO { | |
| 917 display "raise() sets errno" | |
| 918 description "You may or may not want errno to be set by | |
| 919 raise() on error conditions. Not using errno | |
| 920 could save both space, code, and avoid worrying | |
| 921 about interactions between multiple threads when | |
| 922 setting it. Strictly ISO C does not mandate | |
| 923 that errno be set by raise()." | |
| 924 type boolean | |
| 925 parent CYGPKG_LIBC_SIGNALS_ERROR_HANDLING | |
| 926 } | |
| 927 | |
| 928 cdl_option CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO { | |
| 929 display "signal() sets errno" | |
| 930 description "You may or may not want errno to be set by | |
| 931 signal() on error conditions. Not using errno | |
| 932 could save both space, code, and avoid worrying | |
| 933 about interactions between multiple threads when | |
| 934 setting it. Strictly ISO C mandates | |
| 935 that errno be set by signal()." | |
| 936 type boolean | |
| 937 parent CYGPKG_LIBC_SIGNALS_ERROR_HANDLING | |
| 938 } | |
| 939 | |
| 940 cdl_component CYGPKG_LIBC_SIGNALS_TRACING { | |
| 941 display "Tracing" | |
| 942 description "These options control the trace output for the C | |
| 943 library internal signal implementation." | |
| 944 type dummy | |
| 945 parent CYGPKG_LIBC_SIGNALS | |
| 946 } | |
| 947 | |
| 948 cdl_option CYGNUM_LIBC_SIGNALS_RAISE_TRACE_LEVEL { | |
| 949 display "Default trace level for raise()" | |
| 950 description "This gives the default tracing level for the | |
| 951 raise() function. Higher numbers are more | |
| 952 verbose." | |
| 953 type count | |
| 954 legal_values 0 to 1 | |
| 955 parent CYGPKG_LIBC_SIGNALS_TRACING | |
| 956 } | |
| 957 | |
| 958 cdl_option CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL { | |
| 959 display "Default hardware exception handler trace level" | |
| 960 description "This gives the default tracing level for the | |
| 961 hardware exception handler function (if enabled). | |
| 962 Higher numbers are more verbose." | |
| 963 type count | |
| 964 legal_values 0 to 1 | |
| 965 parent CYGPKG_LIBC_SIGNALS_TRACING | |
| 966 } | |
| 967 | |
| 968 }}CFG_DATA | |
| 969 */ | |
| 970 | |
| 971 #define CYGPKG_LIBC_SIGNALS | |
| 972 #define CYGSEM_LIBC_SIGNALS_THREAD_SAFE | |
| 973 #undef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS | |
| 974 #ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS | |
| 975 # define CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS | |
| 976 #endif | |
| 977 #define CYGIMP_LIBC_SIGNALS_RAISE_INLINE | |
| 978 #define CYGIMP_LIBC_SIGNALS_SIGNAL_INLINE | |
| 979 #undef CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL | |
| 980 #define CYGSEM_LIBC_SIGNALS_RAISE_SETS_ERRNO | |
| 981 #define CYGSEM_LIBC_SIGNALS_SIGNAL_SETS_ERRNO | |
| 982 #define CYGNUM_LIBC_SIGNALS_RAISE_TRACE_LEVEL 0 | |
| 983 #define CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL 0 | |
| 984 | |
| 985 //======================================================================== | |
| 986 | |
| 0 | 987 // STARTUP OPTIONS |
| 988 | |
| 989 /* | |
| 990 {{CFG_DATA | |
| 991 | |
| 992 cdl_component CYGPKG_LIBC_STARTUP { | |
| 993 display "ISO C startup/termination" | |
| 994 description "This component manages the control of the | |
| 995 environment (in the general sense) that the | |
| 996 C library provides for use for full ISO C | |
| 997 compatibility, including a main() entry point | |
| 998 supplied with arguments and an environment | |
| 999 (as retrievable by the getenv() function). | |
| 1000 It also includes at the other end of things, | |
| 1001 what happens when main() returns or exit() is | |
| 1002 called." | |
| 2 | 1003 doc ref/ecos-ref/c-library-startup.html.html |
| 0 | 1004 type dummy |
| 1005 parent CYGPKG_LIBC | |
| 1006 } | |
| 1007 | |
| 1008 cdl_option CYGDAT_LIBC_ARGUMENTS { | |
| 1009 display "Arguments to main()" | |
| 1010 description "This option allows the setting of the arguments | |
| 1011 to the main function. This only has any effect | |
| 1012 when cyg_iso_c_start() is used to start the | |
| 1013 ISO C compatibility. This will automatically | |
| 1014 invoke main() in an ISO C compatible fashion. | |
| 1015 This option is in fact used as argv, and so is | |
| 1016 an n-tuple of string constants. The final | |
| 1017 entry must be NULL. Conventionally if argv[0] | |
| 1018 is supplied, it is used to inform the program | |
| 1019 of its name." | |
| 1020 type string | |
| 1021 parent CYGPKG_LIBC_STARTUP | |
| 1022 } | |
| 1023 | |
| 2 | 1024 cdl_component CYGSEM_LIBC_STARTUP_MAIN_THREAD { |
| 1025 display "main() invoked as thread" | |
| 1026 description "It is normally expected (e.g. in a POSIX 1003.1 | |
| 1027 environment) that main() is run in the context | |
| 1028 of a thread just like any other thread. If this | |
| 1029 option is disabled then main() will instead be | |
| 1030 called in the context of the initialization | |
| 1031 routines, without the scheduler running and | |
| 1032 using the interrupt stack. This means that | |
| 1033 any functions that may require interactions | |
| 1034 with a running kernel will not work (including | |
| 1035 libc functions, if configured to be thread safe | |
| 1036 for example), so you should restrict yourself | |
| 1037 to only calling fully re-entrant functions from | |
| 1038 within main() in this case." | |
| 1039 type boolean | |
| 1040 requires CYGPKG_KERNEL | |
| 1041 parent CYGPKG_LIBC_STARTUP | |
| 1042 } | |
| 1043 | |
| 0 | 1044 cdl_option CYGNUM_LIBC_MAIN_STACK_SIZE { |
| 1045 display "main()'s thread stack size" | |
| 1046 description "With an eCos kernel, when the cyg_iso_c_start() | |
| 1047 function is used to invoke the user-supplied | |
| 1048 main() function in an ISO C compatible fashion, | |
| 1049 a separate thread is created to call main(). | |
| 1050 This option controls the size of that thread's | |
| 1051 stack, which is allocated in the BSS. It | |
| 2 | 1052 must be a multiple of 8. Note, a low number |
| 1053 here may be overriden by the HAL if there is | |
| 1054 a minimum requirement to process interrupts | |
| 1055 etc." | |
| 0 | 1056 type count |
| 1057 legal_values 16 to 0x7fffffff | |
| 2 | 1058 parent CYGSEM_LIBC_STARTUP_MAIN_THREAD |
| 1059 } | |
| 1060 | |
| 1061 cdl_component CYGFUN_LIBC_ATEXIT { | |
| 1062 display "Include atexit() function" | |
| 1063 description "This option enables the use of the atexit() | |
| 1064 function, and ensure that the atexit handlers | |
| 1065 are invoked from within exit() as defined in | |
| 1066 the ISO C standard." | |
| 1067 type boolean | |
| 0 | 1068 parent CYGPKG_LIBC_STARTUP |
| 1069 } | |
| 1070 | |
| 1071 cdl_option CYGNUM_LIBC_ATEXIT_HANDLERS { | |
| 1072 display "Number of functions atexit() supports" | |
| 1073 description "This option sets the number of functions | |
| 1074 that atexit() has room for. In other words, | |
| 1075 the number of separate atexit() calls that | |
| 1076 can be made before calling exit() or returning | |
| 1077 from main() ( in an environment controlled by | |
| 1078 cyg_iso_c_start() ). For strict compliance | |
| 1079 with the ISO C standard this should be at | |
| 1080 least 32." | |
| 1081 type count | |
| 2 | 1082 parent CYGFUN_LIBC_ATEXIT |
| 1083 legal_values 1 to 0x7fffffff | |
| 1084 } | |
| 1085 | |
| 1086 cdl_option CYGSEM_LIBC_EXIT_CALLS_FFLUSH { | |
| 1087 display "Make exit() call fflush()" | |
| 1088 description "This option will ensure that all output | |
| 1089 streams are flushed when exitting using | |
| 1090 exit() as prescribed by the ISO C standard." | |
| 1091 type boolean | |
| 0 | 1092 parent CYGPKG_LIBC_STARTUP |
| 2 | 1093 requires CYGSEM_LIBC_STDIO_WANT_BUFFERED_IO |
| 0 | 1094 } |
| 1095 | |
| 1096 cdl_option CYGSEM_LIBC_EXIT_STOPS_SYSTEM { | |
| 1097 display "_exit() stops all threads" | |
| 1098 description "If this option is enabled then _exit(), | |
| 1099 which is called from exit() which itself is | |
| 1100 called on return from main(), stops the eCos | |
| 1101 scheduler. For strict POSIX 1003.1 | |
| 1102 compatibility this would be the normal | |
| 1103 behaviour. To allow the thread to simply | |
| 1104 exit, without affecting other threads, simply | |
| 1105 disable this option. If there is no eCos | |
| 1106 scheduler, then _exit() simply loops | |
| 1107 irrespective of the setting of this option." | |
| 1108 type boolean | |
| 1109 parent CYGPKG_LIBC_STARTUP | |
| 1110 requires CYGPKG_KERNEL | |
| 1111 } | |
| 1112 | |
| 1113 cdl_component CYGPKG_LIBC_ENVIRONMENT { | |
| 1114 display "Provide a system environment" | |
| 1115 description "This option allows use of the getenv() function | |
| 1116 and the global environment pointer | |
| 1117 char **environ defined by POSIX 1003.1. | |
| 1118 Disabling this saves a small amount of space." | |
| 1119 type boolean | |
| 1120 parent CYGPKG_LIBC_STARTUP | |
| 1121 } | |
| 1122 | |
| 1123 cdl_option CYGDAT_LIBC_DEFAULT_ENVIRONMENT { | |
| 1124 display "Default environment" | |
| 1125 description "This option allows the setting of the default | |
| 1126 contents of the environment. This is in fact | |
| 1127 the contents of the global environment pointer | |
| 1128 char **environ defined by POSIX 1003.1. Strings | |
| 1129 must be of the form NAME=VALUE, and the final | |
| 1130 entry must be NULL." | |
| 1131 type string | |
| 1132 parent CYGPKG_LIBC_ENVIRONMENT | |
| 1133 } | |
| 1134 | |
| 2 | 1135 cdl_option CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS { |
| 1136 display "Invoke default static constructors" | |
| 1137 description "This option causes the C library to call | |
| 1138 static constructors with default priority | |
| 1139 from within the context of the main() thread, | |
| 1140 working with the co-operation of the HAL. | |
| 1141 This may be needed for environments that | |
| 1142 expect static constructors to be run in a | |
| 1143 thread context. Note that this uses an object | |
| 1144 with priority 65534. Therefore do not use | |
| 1145 priority 65534 for any other static objects | |
| 1146 with this option enabled." | |
| 1147 type boolean | |
| 1148 requires CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG | |
| 1149 requires CYGSEM_LIBC_STARTUP_MAIN_THREAD | |
| 1150 parent CYGPKG_LIBC_STARTUP | |
| 1151 } | |
| 1152 | |
| 0 | 1153 }}CFG_DATA |
| 1154 */ | |
| 1155 | |
| 1156 #define CYGDAT_LIBC_ARGUMENTS { "", NULL } | |
| 1157 | |
| 2 | 1158 #define CYGSEM_LIBC_STARTUP_MAIN_THREAD |
| 1159 | |
| 1160 #ifdef CYGSEM_LIBC_STARTUP_MAIN_THREAD | |
| 1161 #define CYGNUM_LIBC_MAIN_STACK_SIZE 8192 | |
| 1162 #endif | |
| 0 | 1163 |
| 2 | 1164 #define CYGFUN_LIBC_ATEXIT |
| 1165 | |
| 1166 #ifdef CYGFUN_LIBC_ATEXIT | |
| 0 | 1167 #define CYGNUM_LIBC_ATEXIT_HANDLERS 32 |
| 2 | 1168 #endif |
| 1169 | |
| 1170 #define CYGSEM_LIBC_EXIT_CALLS_FFLUSH | |
| 0 | 1171 |
| 1172 #undef CYGSEM_LIBC_EXIT_STOPS_SYSTEM | |
| 1173 | |
| 1174 #define CYGPKG_LIBC_ENVIRONMENT | |
| 1175 | |
| 1176 #define CYGDAT_LIBC_DEFAULT_ENVIRONMENT { NULL } | |
| 1177 | |
| 2 | 1178 #undef CYGSEM_LIBC_INVOKE_DEFAULT_STATIC_CONSTRUCTORS |
| 0 | 1179 |
| 1180 //======================================================================== | |
| 1181 | |
| 2 | 1182 // ERRNO OPTIONS |
| 0 | 1183 |
| 1184 /* | |
| 1185 {{CFG_DATA | |
| 1186 | |
| 2 | 1187 cdl_component CYGPKG_LIBC_ERRNO { |
| 1188 display "errno" | |
| 1189 description "This package controls the behaviour of the | |
| 1190 errno variable (or more strictly, expression) | |
| 1191 from <errno.h>." | |
| 1192 type dummy | |
| 0 | 1193 parent CYGPKG_LIBC |
| 1194 } | |
| 2 | 1195 |
| 1196 cdl_option CYGSEM_LIBC_PER_THREAD_ERRNO { | |
| 1197 display "Per-thread errno" | |
| 1198 description "This option controls whether the standard error | |
| 1199 code reporting variable errno is a per-thread | |
| 1200 variable, rather than global. Enabling this | |
| 1201 option will use one slot of kernel per-thread data. | |
| 1202 You should ensure you have enough slots configured | |
| 1203 for all your per-thread data." | |
| 1204 doc ref/ecos-ref/c-and-math-library-overview-thread-safety.html | |
| 1205 type boolean | |
| 1206 requires CYGVAR_KERNEL_THREADS_DATA | |
| 1207 parent CYGPKG_LIBC_ERRNO | |
| 0 | 1208 } |
| 1209 | |
| 1210 cdl_option CYGNUM_LIBC_ERRNO_TRACE_LEVEL { | |
| 2 | 1211 display "Tracing level" |
| 1212 description "Trace verbosity level for debugging the errno | |
| 1213 retrieval mechanism in errno.cxx. Increase this | |
| 1214 value to get additional trace output." | |
| 0 | 1215 type count |
| 1216 legal_values 0 to 1 | |
| 2 | 1217 parent CYGPKG_LIBC_ERRNO |
| 0 | 1218 } |
| 1219 | |
| 1220 }}CFG_DATA | |
| 1221 */ | |
| 1222 | |
| 2 | 1223 #define CYGSEM_LIBC_PER_THREAD_ERRNO |
| 0 | 1224 |
| 1225 #define CYGNUM_LIBC_ERRNO_TRACE_LEVEL 0 | |
| 1226 | |
| 1227 | |
| 1228 //======================================================================== | |
| 1229 | |
| 2 | 1230 // TIME OPTIONS |
| 1231 | |
| 1232 /* | |
| 1233 {{CFG_DATA | |
| 1234 | |
| 1235 cdl_component CYGPKG_LIBC_TIME { | |
| 1236 display "Date/Time" | |
| 1237 description "Options for date and time related functions | |
| 1238 from <time.h>" | |
| 1239 type dummy | |
| 1240 parent CYGPKG_LIBC | |
| 1241 } | |
| 1242 | |
| 1243 cdl_option CYGSEM_LIBC_TIME_CLOCK_WORKING { | |
| 1244 display "Working clock() function" | |
| 1245 description "This option controls whether clock() will | |
| 1246 actually try and determine the process time | |
| 1247 usage. With this option disabled, clock() does | |
| 1248 not disappear, but will permanently return | |
| 1249 (clock_t)-1 as mandated by the ISO C standard." | |
| 1250 type boolean | |
| 1251 requires CYGFUN_KERNEL_THREADS_TIMER | |
| 1252 requires CYGVAR_KERNEL_COUNTERS_CLOCK | |
| 1253 parent CYGPKG_LIBC_TIME | |
| 1254 } | |
| 1255 | |
| 1256 cdl_option CYGSEM_LIBC_TIME_TIME_WORKING { | |
| 1257 display "Working time() function" | |
| 1258 description "This option controls whether time() will | |
| 1259 actually try and determine the current calendar | |
| 1260 time. With this option disabled, time() does | |
| 1261 not disappear, but will permanently return | |
| 1262 (time_t)-1 as mandated by the ISO C standard." | |
| 1263 type boolean | |
| 1264 requires CYGPKG_DEVICES_WALLCLOCK | |
| 1265 parent CYGPKG_LIBC_TIME | |
| 1266 } | |
| 1267 | |
| 1268 cdl_option CYGSEM_LIBC_TIME_SETTIME_WORKING { | |
| 1269 display "Working cyg_libc_time_settime() function" | |
| 1270 description "This option controls whether cyg_libc_time_settime() | |
| 1271 will actually try and set the current calendar | |
| 1272 time. With this option disabled, | |
| 1273 cyg_libc_time_settime() does not disappear, but | |
| 1274 will permanently return an error." | |
| 1275 type boolean | |
| 1276 requires CYGPKG_DEVICES_WALLCLOCK | |
| 1277 parent CYGPKG_LIBC_TIME | |
| 1278 } | |
| 1279 | |
| 1280 cdl_option CYGFUN_LIBC_TIME_POSIX { | |
| 1281 display "POSIX time functions" | |
| 1282 description "Enabling this option allows the use of the | |
| 1283 following functions defined in POSIX 1003.1: | |
| 1284 asctime_r(), ctime_r(), gmtime_r(), and | |
| 1285 localtime_r()." | |
| 1286 type boolean | |
| 1287 parent CYGPKG_LIBC_TIME | |
| 1288 } | |
| 1289 | |
| 1290 cdl_component CYGPKG_LIBC_TIME_ZONES { | |
| 1291 display "Time zone offsets" | |
| 1292 description "These options control the default STandarD (STD) | |
| 1293 and Daylight Savings Time (DST) | |
| 1294 time offsets so that dates can be set correctly | |
| 1295 for the local environment." | |
| 1296 type dummy | |
| 1297 parent CYGPKG_LIBC_TIME | |
| 1298 } | |
| 1299 | |
| 1300 cdl_option CYGNUM_LIBC_TIME_DST_DEFAULT_STATE { | |
| 1301 display "Default Daylight Savings Time state" | |
| 1302 description "This option controls whether the initial | |
| 1303 time environment is set up as STD, DST or | |
| 1304 unknown. Use the value 1 for DST, 0 for STD, | |
| 1305 and (-1) for unknown. This can also be set at | |
| 1306 runtime using the cyg_libc_time_setdst() | |
| 1307 function." | |
| 1308 type count | |
| 1309 legal_values -1 to 1 | |
| 1310 parent CYGPKG_LIBC_TIME_ZONES | |
| 1311 } | |
| 1312 | |
| 1313 cdl_option CYGNUM_LIBC_TIME_STD_DEFAULT_OFFSET { | |
| 1314 display "Default Standard Time offset" | |
| 1315 description "This option controls the offset from UTC in | |
| 1316 seconds when in local Standard Time. This | |
| 1317 value can be positive or negative. It | |
| 1318 can also be set at run time using the | |
| 1319 cyg_libc_time_setzoneoffsets() function." | |
| 1320 type count | |
| 1321 legal_values -90000 to 90000 | |
| 1322 parent CYGPKG_LIBC_TIME_ZONES | |
| 1323 } | |
| 1324 | |
| 1325 cdl_option CYGNUM_LIBC_TIME_DST_DEFAULT_OFFSET { | |
| 1326 display "Default Daylight Savings Time offset" | |
| 1327 description "This option controls the offset from UTC in | |
| 1328 seconds when in local Daylight Savings Time. This | |
| 1329 value can be positive or negative. It | |
| 1330 can also be set at run time using the | |
| 1331 cyg_libc_time_setzoneoffsets() function." | |
| 1332 type count | |
| 1333 legal_values -90000 to 90000 | |
| 1334 parent CYGPKG_LIBC_TIME_ZONES | |
| 1335 } | |
| 1336 | |
| 1337 | |
| 1338 cdl_component CYGPKG_LIBC_TIME_INLINES { | |
| 1339 display "Inline functions" | |
| 1340 description "These options control whether certain functions | |
| 1341 are available in inline form. This may lead to | |
| 1342 faster code at the expense of code space. But for | |
| 1343 some functions, or some functions with constant | |
| 1344 arguments, it may in fact lead to smaller code." | |
| 1345 type dummy | |
| 1346 parent CYGPKG_LIBC_TIME | |
| 1347 } | |
| 1348 | |
| 1349 cdl_option CYGIMP_LIBC_TIME_ASCTIME_INLINE { | |
| 1350 display "asctime()" | |
| 1351 description "Allow the asctime() function to be inlined" | |
| 1352 type boolean | |
| 1353 parent CYGPKG_LIBC_TIME_INLINES | |
| 1354 } | |
| 1355 | |
| 1356 cdl_option CYGIMP_LIBC_TIME_CTIME_INLINE { | |
| 1357 display "ctime()" | |
| 1358 description "Allow the ctime() function to be inlined" | |
| 1359 type boolean | |
| 1360 parent CYGPKG_LIBC_TIME_INLINES | |
| 1361 } | |
| 1362 | |
| 1363 cdl_option CYGIMP_LIBC_TIME_DIFFTIME_INLINE { | |
| 1364 display "difftime()" | |
| 1365 description "Allow the difftime() function to be inlined" | |
| 1366 type boolean | |
| 1367 parent CYGPKG_LIBC_TIME_INLINES | |
| 1368 } | |
| 1369 | |
| 1370 cdl_option CYGIMP_LIBC_TIME_GMTIME_INLINE { | |
| 1371 display "gmtime()" | |
| 1372 description "Allow the gmtime() function to be inlined" | |
| 1373 type boolean | |
| 1374 parent CYGPKG_LIBC_TIME_INLINES | |
| 1375 } | |
| 1376 | |
| 1377 cdl_option CYGIMP_LIBC_TIME_LOCALTIME_INLINE { | |
| 1378 display "localtime()" | |
| 1379 description "Allow the localtime() function to be inlined" | |
| 1380 type boolean | |
| 1381 parent CYGPKG_LIBC_TIME_INLINES | |
| 1382 } | |
| 1383 | |
| 1384 cdl_option CYGIMP_LIBC_TIME_MKTIME_INLINE { | |
| 1385 display "mktime()" | |
| 1386 description "Allow the mktime() function to be inlined" | |
| 1387 type boolean | |
| 1388 parent CYGPKG_LIBC_TIME_INLINES | |
| 1389 } | |
| 1390 | |
| 1391 cdl_option CYGIMP_LIBC_TIME_ASCTIME_R_INLINE { | |
| 1392 display "asctime_r()" | |
| 1393 description "Allow the asctime_r() function to be inlined" | |
| 1394 type boolean | |
| 1395 requires CYGFUN_LIBC_TIME_POSIX | |
| 1396 parent CYGPKG_LIBC_TIME_INLINES | |
| 1397 } | |
| 1398 | |
| 1399 cdl_option CYGIMP_LIBC_TIME_CTIME_R_INLINE { | |
| 1400 display "ctime_r()" | |
| 1401 description "Allow the ctime_r() function to be inlined" | |
| 1402 type boolean | |
| 1403 requires CYGFUN_LIBC_TIME_POSIX | |
| 1404 parent CYGPKG_LIBC_TIME_INLINES | |
| 1405 } | |
| 1406 | |
| 1407 cdl_option CYGIMP_LIBC_TIME_GMTIME_R_INLINE { | |
| 1408 display "gmtime_r()" | |
| 1409 description "Allow the gmtime_r() function to be inlined" | |
| 1410 type boolean | |
| 1411 requires CYGFUN_LIBC_TIME_POSIX | |
| 1412 parent CYGPKG_LIBC_TIME_INLINES | |
| 1413 } | |
| 1414 | |
| 1415 cdl_option CYGIMP_LIBC_TIME_LOCALTIME_R_INLINE { | |
| 1416 display "localtime_r()" | |
| 1417 description "Allow the localtime_r() function to be inlined" | |
| 1418 type boolean | |
| 1419 requires CYGFUN_LIBC_TIME_POSIX | |
| 1420 parent CYGPKG_LIBC_TIME_INLINES | |
| 1421 } | |
| 1422 | |
| 1423 # FIXME: Also want "inline all" and "don't inline any" options which requires | |
| 1424 # (or not) all the above, but | |
| 1425 # if we do that then we will require the ones that also depend on | |
| 1426 # CYGFUN_LIBC_TIME_POSIX :-( Wait for full CDL to fix this | |
| 1427 | |
| 1428 cdl_option CYGNUM_LIBC_TIME_CLOCK_TRACE_LEVEL { | |
| 1429 display "clock() tracing level" | |
| 1430 description "Trace verbosity level for debugging the clock() | |
| 1431 function. Increase this value to get | |
| 1432 additional trace output when tracing is enabled." | |
| 1433 type count | |
| 1434 legal_values 0 to 1 | |
| 1435 parent CYGPKG_LIBC_TIME | |
| 1436 } | |
| 1437 | |
| 1438 }}CFG_DATA | |
| 1439 */ | |
| 1440 | |
| 1441 #define CYGSEM_LIBC_TIME_CLOCK_WORKING | |
| 1442 #define CYGSEM_LIBC_TIME_TIME_WORKING | |
| 1443 #define CYGSEM_LIBC_TIME_SETTIME_WORKING | |
| 1444 #define CYGFUN_LIBC_TIME_POSIX | |
| 1445 #define CYGNUM_LIBC_TIME_DST_DEFAULT_STATE (-1) | |
| 1446 #define CYGNUM_LIBC_TIME_STD_DEFAULT_OFFSET 0 | |
| 1447 #define CYGNUM_LIBC_TIME_DST_DEFAULT_OFFSET 3600 | |
| 1448 #define CYGNUM_LIBC_TIME_CLOCK_TRACE_LEVEL 0 | |
| 1449 #define CYGIMP_LIBC_TIME_ASCTIME_INLINE | |
| 1450 #define CYGIMP_LIBC_TIME_CTIME_INLINE | |
| 1451 #define CYGIMP_LIBC_TIME_DIFFTIME_INLINE | |
| 1452 #define CYGIMP_LIBC_TIME_GMTIME_INLINE | |
| 1453 #define CYGIMP_LIBC_TIME_LOCALTIME_INLINE | |
| 1454 #define CYGIMP_LIBC_TIME_MKTIME_INLINE | |
| 1455 #define CYGIMP_LIBC_TIME_ASCTIME_R_INLINE | |
| 1456 #define CYGIMP_LIBC_TIME_CTIME_R_INLINE | |
| 1457 #define CYGIMP_LIBC_TIME_GMTIME_R_INLINE | |
| 1458 #define CYGIMP_LIBC_TIME_LOCALTIME_R_INLINE | |
| 1459 | |
| 1460 //======================================================================== | |
| 1461 | |
| 1462 // MISCELLANEOUS DEFINES | |
| 1463 | |
| 0 | 1464 |
| 1465 // These are not really adjustable by the user. Do not change these unless | |
| 1466 // you know what you are doing! | |
| 1467 | |
| 1468 // How to define inline functions | |
| 1469 #define CYGPRI_LIBC_INLINE extern __inline__ | |
| 1470 | |
| 2 | 1471 // The following isn't supported yet - I'm leaving it for now |
| 1472 #ifdef __GNUC__xxxxxx | |
| 1473 # define CYGPRI_LIBC_ATTRIB_FORMAT_STRFTIME \ | |
| 1474 __attribute__ ((format (strftime, 3))) | |
| 1475 #else | |
| 1476 # define CYGPRI_LIBC_ATTRIB_FORMAT_STRFTIME | |
| 1477 #endif | |
| 1478 | |
| 1479 // The following are only for compatibility, and will eventually be removed | |
| 1480 // once they are eliminated entirely from the code base | |
| 1481 | |
| 1482 #define CYGPRI_LIBC_WEAK CYGBLD_ATTRIB_WEAK | |
| 0 | 1483 |
| 1484 // How to define aliases | |
| 2 | 1485 #define CYGPRI_LIBC_ALIAS(__symbol__) __attribute__ ((alias (__symbol__))) |
| 0 | 1486 |
| 2 | 1487 # define CYGPRI_LIBC_WEAK_ALIAS(__symbol__) \ |
| 1488 CYGBLD_ATTRIB_WEAK CYGPRI_LIBC_ALIAS(__symbol__) | |
| 0 | 1489 |
| 1490 // How to define functions that don't return | |
| 2 | 1491 #define CYGPRI_LIBC_NORETURN CYGBLD_ATTRIB_NORET |
| 0 | 1492 |
| 1493 #endif // CYGONCE_PKGCONF_LIBC_H multiple inclusion protection | |
| 1494 | |
| 1495 // EOF libc.h |