libc/unistd/sysconf.c

   1 /* Copyright (C) 1991, 93, 95, 96, 97, 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public License as
   6    published by the Free Software Foundation; either version 2 of the
   7    License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public
  15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 #define _XOPEN_SOURCE  500
  20 #include <features.h>
  21 #include <errno.h>
  22 #include <limits.h>
  23 #include <grp.h>
  24 #include <pwd.h>
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <time.h>
  29 #include <unistd.h>
  30 #include <sys/sysinfo.h>
  31 #include <sys/types.h>
  32 #include <regex.h>
  33
  34 #ifndef __UCLIBC_CLK_TCK_CONST
  35 #error __UCLIBC_CLK_TCK_CONST not defined!
  36 #endif
  37
  38 extern int getpagesize (void);
  39 extern int getdtablesize (void);
  40
  41 /***********************************************************************/
  42 /*
  43  * Manuel Novoa III        Jan 2001
  44  *
  45  * On i386, the switch-based implementation generates 796 bytes of code.
  46  * However, many of the return values are repeats.  By collecting these
  47  * repeats and moving to a table-based implementation, we generate 283
  48  * bytes on i386 (-Os -fomit-frame-pointer).
  49  */
  50 #ifndef _UCLIBC_GENERATE_SYSCONF_MAIN
  51
  52 #ifdef _UCLIBC_GENERATE_SYSCONF_ARCH
  53 /*
  54  * Set some errno's so the auto-gen code knows what it is dealing with.
  55  *    1) ENOSYS signifies that we're returning a default value.
  56  *       This is just extra info for development.
  57  *    2) EISNAM signifies that the value returned varies at runtime.
  58  *
  59  * Option: GETPAGESIZE_IS_DYNAMIC
  60  *    The current implementation of getpagesize in uClibc returns
  61  *    a constant.  The pagesize on the target arch should not vary,
  62  *    so it should be safe to set this as 0.
  63  */
  64 #define RETURN_NEG_1 __set_errno(ENOSYS); return -1
  65 #define RETURN_FUNCTION(f) __set_errno(EISNAM); return (long int) #f
  66 #define GETPAGESIZE_IS_DYNAMIC 0
  67 #else
  68 #define RETURN_NEG_1 return -1
  69 #define RETURN_FUNCTION(f) return f;
  70 #endif /* _UCLIBC_GENERATE_SYSCONF_ARCH */
  71
  72 /* Get the value of the system variable NAME.  */
  73 long int __sysconf(int name)
  74 {
  75   switch (name)
  76     {
  77     default:
  78       __set_errno(EINVAL);
  79       return -1;
  80
  81     case _SC_ARG_MAX:
  82 #ifdef  ARG_MAX
  83       return ARG_MAX;
  84 #else
  85       RETURN_NEG_1;
  86 #endif
  87
  88     case _SC_CHILD_MAX:
  89 #ifdef  CHILD_MAX
  90       return CHILD_MAX;
  91 #else
  92       RETURN_NEG_1;
  93 #endif
  94
  95     case _SC_CLK_TCK:
  96       /* Can't use CLK_TCK here since that calls __sysconf(_SC_CLK_TCK) */
  97       return __UCLIBC_CLK_TCK_CONST;
  98
  99     case _SC_NGROUPS_MAX:
 100 #ifdef  NGROUPS_MAX
 101       return NGROUPS_MAX;
 102 #else
 103       RETURN_NEG_1;
 104 #endif
 105
 106     case _SC_OPEN_MAX:
 107 #if 1
 108       RETURN_FUNCTION(getdtablesize());
 109 #else
 110       RETURN_NEG_1;
 111 #endif
 112
 113     case _SC_STREAM_MAX:
 114 #ifdef  STREAM_MAX
 115       return STREAM_MAX;
 116 #else
 117       return FOPEN_MAX;
 118 #endif
 119
 120     case _SC_TZNAME_MAX:
 121 #if 0
 122       RETURN_FUNCTION(tzname_max ());
 123 #else
 124 /*       RETURN_NEG_1; */
 125       return _POSIX_TZNAME_MAX;
 126 #endif
 127
 128     case _SC_JOB_CONTROL:
 129 #ifdef  _POSIX_JOB_CONTROL
 130       return 1;
 131 #else
 132       RETURN_NEG_1;
 133 #endif
 134
 135     case _SC_SAVED_IDS:
 136 #ifdef  _POSIX_SAVED_IDS
 137       return 1;
 138 #else
 139       RETURN_NEG_1;
 140 #endif
 141
 142     case _SC_REALTIME_SIGNALS:
 143 #ifdef  _POSIX_REALTIME_SIGNALS
 144       return 1;
 145 #else
 146       RETURN_NEG_1;
 147 #endif
 148
 149     case _SC_PRIORITY_SCHEDULING:
 150 #ifdef  _POSIX_PRIORITY_SCHEDULING
 151       return 1;
 152 #else
 153       RETURN_NEG_1;
 154 #endif
 155
 156     case _SC_TIMERS:
 157 #ifdef  _POSIX_TIMERS
 158       return 1;
 159 #else
 160       RETURN_NEG_1;
 161 #endif
 162
 163     case _SC_ASYNCHRONOUS_IO:
 164 #ifdef  _POSIX_ASYNCHRONOUS_IO
 165       return 1;
 166 #else
 167       RETURN_NEG_1;
 168 #endif
 169
 170     case _SC_PRIORITIZED_IO:
 171 #ifdef  _POSIX_PRIORITIZED_IO
 172       return 1;
 173 #else
 174       RETURN_NEG_1;
 175 #endif
 176
 177     case _SC_SYNCHRONIZED_IO:
 178 #ifdef  _POSIX_SYNCHRONIZED_IO
 179       return 1;
 180 #else
 181       RETURN_NEG_1;
 182 #endif
 183
 184     case _SC_FSYNC:
 185 #ifdef  _POSIX_FSYNC
 186       return 1;
 187 #else
 188       RETURN_NEG_1;
 189 #endif
 190
 191     case _SC_MAPPED_FILES:
 192 #ifdef  _POSIX_MAPPED_FILES
 193       return 1;
 194 #else
 195       RETURN_NEG_1;
 196 #endif
 197
 198     case _SC_MEMLOCK:
 199 #ifdef  _POSIX_MEMLOCK
 200       return 1;
 201 #else
 202       RETURN_NEG_1;
 203 #endif
 204
 205     case _SC_MEMLOCK_RANGE:
 206 #ifdef  _POSIX_MEMLOCK_RANGE
 207       return 1;
 208 #else
 209       RETURN_NEG_1;
 210 #endif
 211
 212     case _SC_MEMORY_PROTECTION:
 213 #ifdef  _POSIX_MEMORY_PROTECTION
 214       return 1;
 215 #else
 216       RETURN_NEG_1;
 217 #endif
 218
 219     case _SC_MESSAGE_PASSING:
 220 #ifdef  _POSIX_MESSAGE_PASSING
 221       return 1;
 222 #else
 223       RETURN_NEG_1;
 224 #endif
 225
 226     case _SC_SEMAPHORES:
 227 #ifdef  _POSIX_SEMAPHORES
 228       return 1;
 229 #else
 230       RETURN_NEG_1;
 231 #endif
 232
 233     case _SC_SHARED_MEMORY_OBJECTS:
 234 #ifdef  _POSIX_SHARED_MEMORY_OBJECTS
 235       return 1;
 236 #else
 237       RETURN_NEG_1;
 238 #endif
 239
 240     case _SC_VERSION:
 241       return _POSIX_VERSION;
 242
 243     case _SC_PAGESIZE:
 244 #if defined(GETPAGESIZE_IS_DYNAMIC) && (GETPAGESIZE_IS_DYNAMIC == 1)
 245       RETURN_FUNCTION(getpagesize());
 246 #else
 247       return getpagesize();             /* note: currently this is not dynamic */
 248 #endif
 249
 250     case _SC_AIO_LISTIO_MAX:
 251 #ifdef  AIO_LISTIO_MAX
 252       return AIO_LISTIO_MAX;
 253 #else
 254       RETURN_NEG_1;
 255 #endif
 256
 257     case _SC_AIO_MAX:
 258 #ifdef  AIO_MAX
 259       return AIO_MAX;
 260 #else
 261       RETURN_NEG_1;
 262 #endif
 263
 264     case _SC_AIO_PRIO_DELTA_MAX:
 265 #ifdef  AIO_PRIO_DELTA_MAX
 266       return AIO_PRIO_DELTA_MAX;
 267 #else
 268       RETURN_NEG_1;
 269 #endif
 270
 271     case _SC_DELAYTIMER_MAX:
 272 #ifdef  DELAYTIMER_MAX
 273       return DELAYTIMER_MAX;
 274 #else
 275       RETURN_NEG_1;
 276 #endif
 277
 278     case _SC_MQ_OPEN_MAX:
 279 #ifdef  MQ_OPEN_MAX
 280       return MQ_OPEN_MAX;
 281 #else
 282       RETURN_NEG_1;
 283 #endif
 284
 285     case _SC_MQ_PRIO_MAX:
 286 #ifdef  MQ_PRIO_MAX
 287       return MQ_PRIO_MAX;
 288 #else
 289       RETURN_NEG_1;
 290 #endif
 291
 292     case _SC_RTSIG_MAX:
 293 #ifdef  RTSIG_MAX
 294       return RTSIG_MAX;
 295 #else
 296       RETURN_NEG_1;
 297 #endif
 298
 299     case _SC_SEM_NSEMS_MAX:
 300 #ifdef  SEM_NSEMS_MAX
 301       return SEM_NSEMS_MAX;
 302 #else
 303       RETURN_NEG_1;
 304 #endif
 305
 306     case _SC_SEM_VALUE_MAX:
 307 #ifdef  SEM_VALUE_MAX
 308       return SEM_VALUE_MAX;
 309 #else
 310       RETURN_NEG_1;
 311 #endif
 312
 313     case _SC_SIGQUEUE_MAX:
 314 #ifdef  SIGQUEUE_MAX
 315       return SIGQUEUE_MAX;
 316 #else
 317       RETURN_NEG_1;
 318 #endif
 319
 320     case _SC_TIMER_MAX:
 321 #ifdef  TIMER_MAX
 322       return TIMER_MAX;
 323 #else
 324       RETURN_NEG_1;
 325 #endif
 326
 327     case _SC_BC_BASE_MAX:
 328 #ifdef  BC_BASE_MAX
 329       return BC_BASE_MAX;
 330 #else
 331       RETURN_NEG_1;
 332 #endif
 333
 334     case _SC_BC_DIM_MAX:
 335 #ifdef  BC_DIM_MAX
 336       return BC_DIM_MAX;
 337 #else
 338       RETURN_NEG_1;
 339 #endif
 340
 341     case _SC_BC_SCALE_MAX:
 342 #ifdef  BC_SCALE_MAX
 343       return BC_SCALE_MAX;
 344 #else
 345       RETURN_NEG_1;
 346 #endif
 347
 348     case _SC_BC_STRING_MAX:
 349 #ifdef  BC_STRING_MAX
 350       return BC_STRING_MAX;
 351 #else
 352       RETURN_NEG_1;
 353 #endif
 354
 355     case _SC_COLL_WEIGHTS_MAX:
 356 #ifdef  COLL_WEIGHTS_MAX
 357       return COLL_WEIGHTS_MAX;
 358 #else
 359       RETURN_NEG_1;
 360 #endif
 361
 362     case _SC_EQUIV_CLASS_MAX:
 363 #ifdef  EQUIV_CLASS_MAX
 364       return EQUIV_CLASS_MAX;
 365 #else
 366       RETURN_NEG_1;
 367 #endif
 368
 369     case _SC_EXPR_NEST_MAX:
 370 #ifdef  EXPR_NEST_MAX
 371       return EXPR_NEST_MAX;
 372 #else
 373       RETURN_NEG_1;
 374 #endif
 375
 376     case _SC_LINE_MAX:
 377 #ifdef  LINE_MAX
 378       return LINE_MAX;
 379 #else
 380       RETURN_NEG_1;
 381 #endif
 382
 383     case _SC_RE_DUP_MAX:
 384 #ifdef  RE_DUP_MAX
 385       return RE_DUP_MAX;
 386 #else
 387       RETURN_NEG_1;
 388 #endif
 389
 390     case _SC_CHARCLASS_NAME_MAX:
 391 #ifdef  CHARCLASS_NAME_MAX
 392       return CHARCLASS_NAME_MAX;
 393 #else
 394       RETURN_NEG_1;
 395 #endif
 396
 397     case _SC_PII:
 398 #ifdef  _POSIX_PII
 399       return 1;
 400 #else
 401       RETURN_NEG_1;
 402 #endif
 403
 404     case _SC_PII_XTI:
 405 #ifdef  _POSIX_PII_XTI
 406       return 1;
 407 #else
 408       RETURN_NEG_1;
 409 #endif
 410
 411     case _SC_PII_SOCKET:
 412 #ifdef  _POSIX_PII_SOCKET
 413       return 1;
 414 #else
 415       RETURN_NEG_1;
 416 #endif
 417
 418     case _SC_PII_INTERNET:
 419 #ifdef  _POSIX_PII_INTERNET
 420       return 1;
 421 #else
 422       RETURN_NEG_1;
 423 #endif
 424
 425     case _SC_PII_OSI:
 426 #ifdef  _POSIX_PII_OSI
 427       return 1;
 428 #else
 429       RETURN_NEG_1;
 430 #endif
 431
 432     case _SC_POLL:
 433 #ifdef  _POSIX_POLL
 434       return 1;
 435 #else
 436       RETURN_NEG_1;
 437 #endif
 438
 439     case _SC_SELECT:
 440 #ifdef  _POSIX_SELECT
 441       return 1;
 442 #else
 443       RETURN_NEG_1;
 444 #endif
 445
 446     case _SC_UIO_MAXIOV:
 447 #ifdef  UIO_MAXIOV
 448       return UIO_MAXIOV;
 449 #else
 450       RETURN_NEG_1;
 451 #endif
 452
 453     case _SC_PII_INTERNET_STREAM:
 454 #ifdef  _POSIX_PII_INTERNET_STREAM
 455       return 1;
 456 #else
 457       RETURN_NEG_1;
 458 #endif
 459
 460     case _SC_PII_INTERNET_DGRAM:
 461 #ifdef  _POSIX_PII_INTERNET_DGRAM
 462       return 1;
 463 #else
 464       RETURN_NEG_1;
 465 #endif
 466
 467     case _SC_PII_OSI_COTS:
 468 #ifdef  _POSIX_PII_OSI_COTS
 469       return 1;
 470 #else
 471       RETURN_NEG_1;
 472 #endif
 473
 474     case _SC_PII_OSI_CLTS:
 475 #ifdef  _POSIX_PII_OSI_CLTS
 476       return 1;
 477 #else
 478       RETURN_NEG_1;
 479 #endif
 480
 481     case _SC_PII_OSI_M:
 482 #ifdef  _POSIX_PII_OSI_M
 483       return 1;
 484 #else
 485       RETURN_NEG_1;
 486 #endif
 487
 488     case _SC_T_IOV_MAX:
 489 #ifdef  _T_IOV_MAX
 490       return _T_IOV_MAX;
 491 #else
 492       RETURN_NEG_1;
 493 #endif
 494
 495     case _SC_2_VERSION:
 496       return _POSIX2_VERSION;
 497
 498     case _SC_2_C_BIND:
 499 #ifdef  _POSIX2_C_BIND
 500       return _POSIX2_C_BIND;
 501 #else
 502       RETURN_NEG_1;
 503 #endif
 504
 505     case _SC_2_C_DEV:
 506 #ifdef  _POSIX2_C_DEV
 507       return _POSIX2_C_DEV;
 508 #else
 509       RETURN_NEG_1;
 510 #endif
 511
 512     case _SC_2_C_VERSION:
 513 #ifdef  _POSIX2_C_VERSION
 514       return _POSIX2_C_VERSION;
 515 #else
 516       RETURN_NEG_1;
 517 #endif
 518
 519     case _SC_2_FORT_DEV:
 520 #ifdef  _POSIX2_FORT_DEV
 521       return _POSIX2_FORT_DEV;
 522 #else
 523       RETURN_NEG_1;
 524 #endif
 525
 526     case _SC_2_FORT_RUN:
 527 #ifdef  _POSIX2_FORT_RUN
 528       return _POSIX2_FORT_RUN;
 529 #else
 530       RETURN_NEG_1;
 531 #endif
 532
 533     case _SC_2_LOCALEDEF:
 534 #ifdef  _POSIX2_LOCALEDEF
 535       return _POSIX2_LOCALEDEF;
 536 #else
 537       RETURN_NEG_1;
 538 #endif
 539
 540     case _SC_2_SW_DEV:
 541 #ifdef  _POSIX2_SW_DEV
 542       return _POSIX2_SW_DEV;
 543 #else
 544       RETURN_NEG_1;
 545 #endif
 546
 547     case _SC_2_CHAR_TERM:
 548 #ifdef  _POSIX2_CHAR_TERM
 549       return _POSIX2_CHAR_TERM;
 550 #else
 551       RETURN_NEG_1;
 552 #endif
 553
 554     case _SC_2_UPE:
 555 #ifdef  _POSIX2_UPE
 556       return _POSIX2_UPE;
 557 #else
 558       RETURN_NEG_1;
 559 #endif
 560
 561       /* POSIX 1003.1c (POSIX Threads).  */
 562     case _SC_THREADS:
 563 #ifdef  _POSIX_THREADS
 564       return 1;
 565 #else
 566       RETURN_NEG_1;
 567 #endif
 568
 569     case _SC_THREAD_SAFE_FUNCTIONS:
 570 #ifdef  _POSIX_THREAD_SAFE_FUNCTIONS
 571       return 1;
 572 #else
 573       RETURN_NEG_1;
 574 #endif
 575
 576     case _SC_GETGR_R_SIZE_MAX:
 577 #ifdef  NSS_BUFLEN_GROUP
 578       return NSS_BUFLEN_GROUP;
 579 #else
 580       RETURN_NEG_1;
 581 #endif
 582
 583     case _SC_GETPW_R_SIZE_MAX:
 584 #ifdef  NSS_BUFLEN_PASSWD
 585       return NSS_BUFLEN_PASSWD;
 586 #else
 587       RETURN_NEG_1;
 588 #endif
 589
 590     case _SC_LOGIN_NAME_MAX:
 591 #ifdef  _POSIX_LOGIN_NAME_MAX
 592       return _POSIX_LOGIN_NAME_MAX;
 593 #else
 594       RETURN_NEG_1;
 595 #endif
 596
 597     case _SC_TTY_NAME_MAX:
 598 #ifdef  _POSIX_TTY_NAME_MAX
 599       return _POSIX_TTY_NAME_MAX;
 600 #else
 601       RETURN_NEG_1;
 602 #endif
 603
 604     case _SC_THREAD_DESTRUCTOR_ITERATIONS:
 605 #ifdef  _POSIX_THREAD_DESTRUCTOR_ITERATIONS
 606       return _POSIX_THREAD_DESTRUCTOR_ITERATIONS;
 607 #else
 608       RETURN_NEG_1;
 609 #endif
 610
 611     case _SC_THREAD_KEYS_MAX:
 612 #ifdef  PTHREAD_KEYS_MAX
 613       return PTHREAD_KEYS_MAX;
 614 #else
 615       RETURN_NEG_1;
 616 #endif
 617
 618     case _SC_THREAD_STACK_MIN:
 619 #ifdef  PTHREAD_STACK_MIN
 620       return PTHREAD_STACK_MIN;
 621 #else
 622       RETURN_NEG_1;
 623 #endif
 624
 625     case _SC_THREAD_THREADS_MAX:
 626 #ifdef  PTHREAD_THREADS_MAX
 627       return PTHREAD_THREADS_MAX;
 628 #else
 629       RETURN_NEG_1;
 630 #endif
 631
 632     case _SC_THREAD_ATTR_STACKADDR:
 633 #ifdef  _POSIX_THREAD_ATTR_STACKADDR
 634       return 1;
 635 #else
 636       RETURN_NEG_1;
 637 #endif
 638
 639     case _SC_THREAD_ATTR_STACKSIZE:
 640 #ifdef  _POSIX_THREAD_ATTR_STACKSIZE
 641       return 1;
 642 #else
 643       RETURN_NEG_1;
 644 #endif
 645
 646     case _SC_THREAD_PRIORITY_SCHEDULING:
 647 #ifdef  _POSIX_THREAD_PRIORITY_SCHEDULING
 648       return 1;
 649 #else
 650       RETURN_NEG_1;
 651 #endif
 652
 653     case _SC_THREAD_PRIO_INHERIT:
 654 #ifdef  _POSIX_THREAD_PRIO_INHERIT
 655       return 1;
 656 #else
 657       RETURN_NEG_1;
 658 #endif
 659
 660     case _SC_THREAD_PRIO_PROTECT:
 661 #ifdef  _POSIX_THREAD_PRIO_PROTECT
 662       return 1;
 663 #else
 664       RETURN_NEG_1;
 665 #endif
 666
 667     case _SC_THREAD_PROCESS_SHARED:
 668 #ifdef  _POSIX_THREAD_PROCESS_SHARED
 669       return 1;
 670 #else
 671       RETURN_NEG_1;
 672 #endif
 673
 674     case _SC_NPROCESSORS_CONF:
 675 #if 0
 676       RETURN_FUNCTION(get_nprocs_conf());
 677 #else
 678       /* this is a hack.  for now always claim we have exactly one cpu */
 679       return 1;
 680 #endif
 681
 682     case _SC_NPROCESSORS_ONLN:
 683 #if 0
 684       RETURN_FUNCTION(get_nprocs());
 685 #else
 686       /* this is a hack.  for now always claim we have exactly one cpu */
 687       return 1;
 688 #endif
 689
 690     case _SC_PHYS_PAGES:
 691 #if 0
 692       RETURN_FUNCTION(get_phys_pages());
 693 #else
 694       RETURN_NEG_1;
 695 #endif
 696
 697     case _SC_AVPHYS_PAGES:
 698 #if 0
 699       RETURN_FUNCTION(get_avphys_pages());
 700 #else
 701       RETURN_NEG_1;
 702 #endif
 703
 704     case _SC_ATEXIT_MAX:
 705       return __UCLIBC_MAX_ATEXIT;
 706
 707     case _SC_PASS_MAX:
 708       /* We have no limit but since the return value might be used to
 709          allocate a buffer we restrict the value.  */
 710       return BUFSIZ;
 711
 712     case _SC_XOPEN_VERSION:
 713       return _XOPEN_VERSION;
 714
 715     case _SC_XOPEN_XCU_VERSION:
 716       return _XOPEN_XCU_VERSION;
 717
 718     case _SC_XOPEN_UNIX:
 719       return _XOPEN_UNIX;
 720
 721     case _SC_XOPEN_CRYPT:
 722 #ifdef  _XOPEN_CRYPT
 723       return _XOPEN_CRYPT;
 724 #else
 725       RETURN_NEG_1;
 726 #endif
 727
 728     case _SC_XOPEN_ENH_I18N:
 729 #ifdef  _XOPEN_ENH_I18N
 730       return _XOPEN_ENH_I18N;
 731 #else
 732       RETURN_NEG_1;
 733 #endif
 734
 735     case _SC_XOPEN_SHM:
 736 #ifdef  _XOPEN_SHM
 737       return _XOPEN_SHM;
 738 #else
 739       RETURN_NEG_1;
 740 #endif
 741
 742     case _SC_XOPEN_XPG2:
 743 #ifdef  _XOPEN_XPG2
 744       return _XOPEN_XPG2;
 745 #else
 746       RETURN_NEG_1;
 747 #endif
 748
 749     case _SC_XOPEN_XPG3:
 750 #ifdef  _XOPEN_XPG3
 751       return _XOPEN_XPG3;
 752 #else
 753       RETURN_NEG_1;
 754 #endif
 755
 756     case _SC_XOPEN_XPG4:
 757 #ifdef  _XOPEN_XPG4
 758       return _XOPEN_XPG4;
 759 #else
 760       RETURN_NEG_1;
 761 #endif
 762
 763     case _SC_CHAR_BIT:
 764       return CHAR_BIT;
 765
 766     case _SC_CHAR_MAX:
 767       return CHAR_MAX;
 768
 769     case _SC_CHAR_MIN:
 770       return CHAR_MIN;
 771
 772     case _SC_INT_MAX:
 773       return INT_MAX;
 774
 775     case _SC_INT_MIN:
 776       return INT_MIN;
 777
 778     case _SC_LONG_BIT:
 779       return sizeof (long int) * CHAR_BIT;
 780
 781     case _SC_WORD_BIT:
 782       return sizeof (int) * CHAR_BIT;
 783
 784     case _SC_MB_LEN_MAX:
 785       return MB_LEN_MAX;
 786
 787     case _SC_NZERO:
 788       return NZERO;
 789
 790     case _SC_SSIZE_MAX:
 791       return _POSIX_SSIZE_MAX;
 792
 793     case _SC_SCHAR_MAX:
 794       return SCHAR_MAX;
 795
 796     case _SC_SCHAR_MIN:
 797       return SCHAR_MIN;
 798
 799     case _SC_SHRT_MAX:
 800       return SHRT_MAX;
 801
 802     case _SC_SHRT_MIN:
 803       return SHRT_MIN;
 804
 805     case _SC_UCHAR_MAX:
 806       return UCHAR_MAX;
 807
 808     case _SC_UINT_MAX:
 809       return UINT_MAX;
 810
 811     case _SC_ULONG_MAX:
 812       return ULONG_MAX;
 813
 814     case _SC_USHRT_MAX:
 815       return USHRT_MAX;
 816
 817     case _SC_NL_ARGMAX:
 818 #ifdef  NL_ARGMAX
 819       return NL_ARGMAX;
 820 #else
 821       RETURN_NEG_1;
 822 #endif
 823
 824     case _SC_NL_LANGMAX:
 825 #ifdef  NL_LANGMAX
 826       return NL_LANGMAX;
 827 #else
 828       RETURN_NEG_1;
 829 #endif
 830
 831     case _SC_NL_MSGMAX:
 832 #ifdef  NL_MSGMAX
 833       return NL_MSGMAX;
 834 #else
 835       RETURN_NEG_1;
 836 #endif
 837
 838     case _SC_NL_NMAX:
 839 #ifdef  NL_NMAX
 840       return NL_NMAX;
 841 #else
 842       RETURN_NEG_1;
 843 #endif
 844
 845     case _SC_NL_SETMAX:
 846 #ifdef  NL_SETMAX
 847       return NL_SETMAX;
 848 #else
 849       RETURN_NEG_1;
 850 #endif
 851
 852     case _SC_NL_TEXTMAX:
 853 #ifdef  NL_TEXTMAX
 854       return NL_TEXTMAX;
 855 #else
 856       RETURN_NEG_1;
 857 #endif
 858
 859     case _SC_XBS5_ILP32_OFF32:
 860 #ifdef _XBS5_ILP32_OFF32
 861       return _XBS5_ILP32_OFF32;
 862 #else
 863       RETURN_NEG_1;
 864 #endif
 865     case _SC_XBS5_ILP32_OFFBIG:
 866 #ifdef _XBS5_ILP32_OFFBIG
 867       return _XBS5_ILP32_OFFBIG;
 868 #else
 869       RETURN_NEG_1;
 870 #endif
 871     case _SC_XBS5_LP64_OFF64:
 872 #ifdef _XBS5_LP64_OFF64
 873       return _XBS5_LP64_OFF64;
 874 #else
 875       RETURN_NEG_1;
 876 #endif
 877     case _SC_XBS5_LPBIG_OFFBIG:
 878 #ifdef _XBS5_LPBIG_OFFBIG
 879       return _XBS5_LPBIG_OFFBIG;
 880 #else
 881       RETURN_NEG_1;
 882 #endif
 883
 884     case _SC_XOPEN_LEGACY:
 885       return _XOPEN_LEGACY;
 886
 887     case _SC_XOPEN_REALTIME:
 888 #ifdef _XOPEN_REALTIME
 889       return _XOPEN_REALTIME;
 890 #else
 891       RETURN_NEG_1;
 892 #endif
 893     case _SC_XOPEN_REALTIME_THREADS:
 894 #ifdef _XOPEN_REALTIME_THREADS
 895       return _XOPEN_REALTIME_THREADS;
 896 #else
 897       RETURN_NEG_1;
 898 #endif
 899     }
 900 }
 901 weak_alias(__sysconf, sysconf);
 902
 903 #endif /* _UCLIBC_GENERATE_SYSCONF_MAIN */
 904 /***********************************************************************/
 905 #ifdef _UCLIBC_GENERATE_SYSCONF_MAIN
 906
 907 static long int ret_vals[_UCLIBC_SYSCONF_NUM_VALID_ARGS];
 908
 909 static const char *type_str[] = {
 910         "char", "short", "int", "long"
 911 };
 912
 913 static const char *type_fmt[] = { " %4ld", " %6ld", " %8ld", " %8ld" };
 914 static const int type_mod[] = { 13, 9, 6, 6 };
 915
 916 static int find_or_add_in_table(int index, long int val, int *table,
 917                                                                 int *num_in_table, int add_flag)
 918 {
 919         int i;
 920
 921         for (i=0 ; i<*num_in_table ; i++) {
 922                 if (ret_vals[table[i]] == val) {
 923                         return i;
 924                 }
 925         }
 926         if (add_flag) {
 927                 table[(*num_in_table)++] = index;
 928                 return i;
 929         } else {
 930                 return -1;
 931         }
 932 }
 933
 934
 935 int main(void)
 936 {
 937         long int r;
 938         int type_table[5][_UCLIBC_SYSCONF_NUM_VALID_ARGS];
 939         int ret_type[_UCLIBC_SYSCONF_NUM_VALID_ARGS];
 940         int num_type[5];
 941         int i, j, k, code;
 942
 943         for (i=0 ; i<5 ; i++) {
 944                 num_type[i] = 0;
 945         }
 946
 947         for (i=0; i<_UCLIBC_SYSCONF_NUM_VALID_ARGS ; i++) {
 948                 __set_errno(0);
 949                 r = ret_vals[i] = sysconf(i);
 950                 switch(errno) {
 951                         case EINVAL:            /* we're missing a case! */
 952                                 fprintf(stderr,"sysconf.c is broken! case %d missing!\n", i);
 953                                 return EXIT_FAILURE;
 954                         case EISNAM:            /* function */
 955                                 find_or_add_in_table(i,r,type_table[4],num_type+4,1);
 956                                 ret_type[i] = 4;
 957                                 break;
 958                         case ENOSYS:            /* defaults to -1 */
 959                                 /* why does this break for shared???? */
 960                                 fprintf(stderr,"gen_sysconf advisory --"
 961                                                 "case %d defaults to -1\n", i);
 962                                 /* fall through */
 963                         case 0:
 964                                 if ((r>=CHAR_MIN) && (r<=CHAR_MAX)) {
 965                                         ret_type[i] = 0;
 966                                         find_or_add_in_table(i,r,type_table[0],num_type+0,1);
 967                                 } else if ((r>=SHRT_MIN) && (r<=SHRT_MAX)) {
 968                                         ret_type[i] = 1;
 969                                         find_or_add_in_table(i,r,type_table[1],num_type+1,1);
 970                                 } else if ((r>=INT_MIN) && (r<=INT_MAX)) {
 971                                         ret_type[i] = 2;
 972                                         find_or_add_in_table(i,r,type_table[2],num_type+2,1);
 973                                 } else {
 974                                         ret_type[i] = 3;
 975                                         find_or_add_in_table(i,r,type_table[3],num_type+3,1);
 976                                 }
 977                                 break;
 978                         default:
 979                                 fprintf(stderr,"sysconf.c is broken! errno = %d!\n", errno);
 980                                 break;
 981                 }
 982         }
 983
 984         printf("#include <errno.h>\n#include <unistd.h>\n#include <limits.h>\n\n");
 985
 986         printf("static const unsigned char index[%d] = {",
 987                    _UCLIBC_SYSCONF_NUM_VALID_ARGS);
 988         for (i=0 ; i<_UCLIBC_SYSCONF_NUM_VALID_ARGS ; i++) {
 989                 if (i) printf(",");
 990                 if (i%15 == 0) printf("\n");
 991                 code = 0;
 992                 for (j=0 ; j<4 ; j++) {
 993                         k = find_or_add_in_table(i,ret_vals[i],type_table[j],num_type+j,0);
 994                         if (k>=0) {
 995                                 code += k;
 996                                 break;
 997                         }
 998                         code += num_type[j];
 999                 }
1000                 printf(" %3d", code);
1001         }
1002         printf("\n};\n\n");
1003
1004         for (j=0 ; j < 4 ; j++) {
1005                 if (num_type[j]) {
1006                         printf("static const %s %s_vals[%d] = {",
1007                                    type_str[j], type_str[j], num_type[j]);
1008                         for (i = 0 ; i<num_type[j] ; i++) {
1009                                 if (i) printf(",");
1010                                 if (i%13 == 0) printf("\n");
1011                                 if (ret_vals[type_table[j][i]] == INT_MIN) {
1012                                         printf("%12s","INT_MIN");
1013                                 } else {
1014                                         printf(type_fmt[j], ret_vals[type_table[j][i]]);
1015                                 }
1016
1017                         }
1018                         printf("\n};\n\n");
1019                 }
1020         }
1021
1022         printf("long int sysconf(int name)\n{\n\tint i;\n\n"
1023                    "\tif ((name < 0) || (name >= %d)) {\n"
1024                    "\t\terrno=EINVAL;\n"
1025                    "\t\treturn -1;\n"
1026                    "\t}\n\n", _UCLIBC_SYSCONF_NUM_VALID_ARGS);
1027
1028         printf("\ti = index[name];\n\n");
1029         k = 0;
1030         for (i=0 ; i<4 ; i++) {
1031                 if (num_type[i]) {
1032                         if (k>0) {
1033                                 printf("\ti -= %d;\n", k);
1034                         }
1035                         printf("\tif (i < %d) {\n"
1036                                    "\t\treturn %s_vals[i];\n"
1037                                    "\t}\n\n",
1038                                    num_type[i], type_str[i]);
1039                         k = num_type[i];
1040                 }
1041         }
1042
1043         if (num_type[4]) {
1044                 if (k>0) {
1045                         printf("\ti -= %d;\n", k);
1046                 }
1047                 printf("\tswitch(i) {\n");
1048                 for (i = 0 ; i<num_type[4] ; i++) {
1049                         printf("\t\tcase %d:\n"
1050                                    "\t\t\treturn %s;\n",
1051                                    i, (const char *)ret_vals[type_table[4][i]]);
1052                 }
1053                 printf("\t}\n\n");
1054         }
1055
1056         printf("\treturn -1;\n"
1057                    "}\n");
1058
1059
1060         return EXIT_SUCCESS;
1061 }
1062 /***********************************************************************/
1063 #endif