[BACK]Return to getconf.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / getconf

Diff for /src/usr.bin/getconf/getconf.c between version 1.12 and 1.13

version 1.12, 2009/10/27 23:59:38 version 1.13, 2013/03/02 05:33:41
Line 50 
Line 50 
 #include <errno.h>  #include <errno.h>
   
 static void usage(void);  static void usage(void);
   static void list_var(int);
   static int compilation_spec_valid(const char *);
   
 struct conf_variable  struct conf_variable
 {  {
Line 58 
Line 60 
   long value;    long value;
 };  };
   
   
   #define constant_row(name)               { #name, CONSTANT, name },
   #define sysconf_row(name)                { #name, SYSCONF,  _SC_##name },
   #define pathconf_row(name)               { #name, PATHCONF, _PC_##name },
   #define confstr_row(name)                { #name, CONFSTR,  _CS_##name },
   #define posix_constant_row(name)         { #name, CONSTANT, _POSIX_##name },
   #define posix_confstr_row(name)          { #name, CONFSTR,  _CS_POSIX_##name },
   #define compat_posix2_sysconf_row(name)  { #name, SYSCONF,  _SC_2_##name },
   #define compat_posix2_constant_row(name) { #name, CONSTANT, _POSIX2_##name },
   
   /* Some sysconf variables don't follow the pattern of the others */
   #define posix2_sysconf_row(name) \
                           { "_POSIX2_" #name, SYSCONF,  _SC_2_##name },
   #define posix2_pathconf_row(name) \
                           { "_POSIX2_" #name, PATHCONF,  _PC_2_##name },
   #define pthread_sysconf_row(name) \
                           { "_PTHREAD_" #name, SYSCONF,  _SC_THREAD_##name },
   #define xopen_sysconf_row(name) \
                           { "_XOPEN_" #name, SYSCONF,  _SC_XOPEN_##name },
   
 const struct conf_variable conf_table[] =  const struct conf_variable conf_table[] =
 {  {
   { "PATH",                     CONFSTR,        _CS_PATH                },    /* Configuration strings */
     confstr_row(PATH)
     confstr_row(V7_ENV)
     confstr_row(V6_ENV)
   
   /* Utility Limit Minimum Values */    /* Symbolic Utility Limits */
   { "POSIX2_BC_BASE_MAX",       CONSTANT,       _POSIX2_BC_BASE_MAX     },    sysconf_row(BC_BASE_MAX)
   { "POSIX2_BC_DIM_MAX",        CONSTANT,       _POSIX2_BC_DIM_MAX      },    sysconf_row(BC_DIM_MAX)
   { "POSIX2_BC_SCALE_MAX",      CONSTANT,       _POSIX2_BC_SCALE_MAX    },    sysconf_row(BC_SCALE_MAX)
   { "POSIX2_BC_STRING_MAX",     CONSTANT,       _POSIX2_BC_STRING_MAX   },    sysconf_row(BC_STRING_MAX)
   { "POSIX2_COLL_WEIGHTS_MAX",  CONSTANT,       _POSIX2_COLL_WEIGHTS_MAX },    sysconf_row(COLL_WEIGHTS_MAX)
   { "POSIX2_EXPR_NEST_MAX",     CONSTANT,       _POSIX2_EXPR_NEST_MAX   },    sysconf_row(EXPR_NEST_MAX)
   { "POSIX2_LINE_MAX",          CONSTANT,       _POSIX2_LINE_MAX        },    sysconf_row(LINE_MAX)
   { "POSIX2_RE_DUP_MAX",        CONSTANT,       _POSIX2_RE_DUP_MAX      },    sysconf_row(RE_DUP_MAX)
   { "POSIX2_VERSION",           CONSTANT,       _POSIX2_VERSION         },  
   
   /* POSIX.1 Minimum Values */    /* POSIX.1 Configurable System Variables */
   { "_POSIX_ARG_MAX",           CONSTANT,       _POSIX_ARG_MAX          },    sysconf_row(AIO_LISTIO_MAX)
   { "_POSIX_CHILD_MAX",         CONSTANT,       _POSIX_CHILD_MAX        },    sysconf_row(AIO_MAX)
   { "_POSIX_LINK_MAX",          CONSTANT,       _POSIX_LINK_MAX         },    sysconf_row(AIO_PRIO_DELTA_MAX)
   { "_POSIX_MAX_CANON",         CONSTANT,       _POSIX_MAX_CANON        },    sysconf_row(ARG_MAX)
   { "_POSIX_MAX_INPUT",         CONSTANT,       _POSIX_MAX_INPUT        },    sysconf_row(CHILD_MAX)
   { "_POSIX_NAME_MAX",          CONSTANT,       _POSIX_NAME_MAX         },    sysconf_row(CLK_TCK)
   { "_POSIX_NGROUPS_MAX",       CONSTANT,       _POSIX_NGROUPS_MAX      },    sysconf_row(NGROUPS_MAX)
   { "_POSIX_OPEN_MAX",          CONSTANT,       _POSIX_OPEN_MAX         },    sysconf_row(OPEN_MAX)
   { "_POSIX_PATH_MAX",          CONSTANT,       _POSIX_PATH_MAX         },    sysconf_row(STREAM_MAX)
   { "_POSIX_PIPE_BUF",          CONSTANT,       _POSIX_PIPE_BUF         },    sysconf_row(TZNAME_MAX)
   { "_POSIX_SSIZE_MAX",         CONSTANT,       _POSIX_SSIZE_MAX        },    sysconf_row(PAGE_SIZE)
   { "_POSIX_STREAM_MAX",        CONSTANT,       _POSIX_STREAM_MAX       },    sysconf_row(PAGESIZE)
   { "_POSIX_TZNAME_MAX",        CONSTANT,       _POSIX_TZNAME_MAX       },  
   
   /* Symbolic Utility Limits */    sysconf_row(SEM_NSEMS_MAX)
   { "BC_BASE_MAX",              SYSCONF,        _SC_BC_BASE_MAX         },    sysconf_row(SEM_VALUE_MAX)
   { "BC_DIM_MAX",               SYSCONF,        _SC_BC_DIM_MAX          },    sysconf_row(HOST_NAME_MAX)
   { "BC_SCALE_MAX",             SYSCONF,        _SC_BC_SCALE_MAX        },    sysconf_row(LOGIN_NAME_MAX)
   { "BC_STRING_MAX",            SYSCONF,        _SC_BC_STRING_MAX       },  
   { "COLL_WEIGHTS_MAX",         SYSCONF,        _SC_COLL_WEIGHTS_MAX    },  
   { "EXPR_NEST_MAX",            SYSCONF,        _SC_EXPR_NEST_MAX       },  
   { "LINE_MAX",                 SYSCONF,        _SC_LINE_MAX            },  
   { "RE_DUP_MAX",               SYSCONF,        _SC_RE_DUP_MAX          },  
   
   /* Optional Facility Configuration Values */    sysconf_row(ATEXIT_MAX)
 #if 0    sysconf_row(DELAYTIMER_MAX)
   { "POSIX2_C_BIND",            SYSCONF,        ???                     },    sysconf_row(IOV_MAX)
 #endif    sysconf_row(MQ_OPEN_MAX)
   { "POSIX2_C_DEV",             SYSCONF,        _SC_2_C_DEV             },    sysconf_row(MQ_PRIO_MAX)
   { "POSIX2_CHAR_TERM",         SYSCONF,        _SC_2_CHAR_TERM         },    sysconf_row(RTSIG_MAX)
   { "POSIX2_FORT_DEV",          SYSCONF,        _SC_2_FORT_DEV          },    sysconf_row(SIGQUEUE_MAX)
   { "POSIX2_FORT_RUN",          SYSCONF,        _SC_2_FORT_RUN          },    sysconf_row(SYMLOOP_MAX)
   { "POSIX2_LOCALEDEF",         SYSCONF,        _SC_2_LOCALEDEF         },    sysconf_row(TIMER_MAX)
   { "POSIX2_SW_DEV",            SYSCONF,        _SC_2_SW_DEV            },    sysconf_row(TTY_NAME_MAX)
   { "POSIX2_UPE",               SYSCONF,        _SC_2_UPE               },  
   
     posix2_sysconf_row(PBS)
     posix2_sysconf_row(PBS_ACCOUNTING)
     posix2_sysconf_row(PBS_CHECKPOINT)
     posix2_sysconf_row(PBS_LOCATE)
     posix2_sysconf_row(PBS_MESSAGE)
     posix2_sysconf_row(PBS_TRACK)
   
     pthread_sysconf_row(DESTRUCTOR_ITERATIONS)
     pthread_sysconf_row(KEYS_MAX)
     pthread_sysconf_row(STACK_MIN)
     pthread_sysconf_row(THREADS_MAX)
   
     xopen_sysconf_row(SHM)
     xopen_sysconf_row(CRYPT)
     xopen_sysconf_row(ENH_I18N)
     xopen_sysconf_row(REALTIME)
     xopen_sysconf_row(REALTIME_THREADS)
     xopen_sysconf_row(STREAMS)
     xopen_sysconf_row(UNIX)
     xopen_sysconf_row(UUCP)
     xopen_sysconf_row(VERSION)
   
     pathconf_row(FILESIZEBITS)
     pathconf_row(LINK_MAX)
     pathconf_row(MAX_CANON)
     pathconf_row(MAX_INPUT)
     pathconf_row(NAME_MAX)
     pathconf_row(PATH_MAX)
     pathconf_row(PIPE_BUF)
     pathconf_row(SYMLINK_MAX)
   
     posix2_pathconf_row(SYMLINKS)
   
     constant_row(_POSIX2_CHARCLASS_NAME_MAX)
     constant_row(_POSIX2_RE_DUP_MAX)
     constant_row(_XOPEN_IOV_MAX)
     constant_row(_XOPEN_NAME_MAX)
     constant_row(_XOPEN_PATH_MAX)
   
     { NULL }
   };
   
   /*
    * Lots of names have a leading "_POSIX_", so put them in a table with
    * that prefix trimmed
    */
   const char uposix_prefix[] = "_POSIX_";
   const struct conf_variable uposix_conf_table[] =
   {
     /* POSIX.1 Maximum Values */
     posix_constant_row(CLOCKRES_MIN)
   
     /* POSIX.1 Minimum Values */
     /*posix_constant_row(AIO_LISTIO_MAX)*/
     /*posix_constant_row(AIO_MAX)*/
     posix_constant_row(ARG_MAX)
     posix_constant_row(ARG_MAX)
     posix_constant_row(CHILD_MAX)
     /*posix_constant_row(DELAYTIMER_MAX)*/
     posix_constant_row(HOST_NAME_MAX)
     posix_constant_row(LINK_MAX)
     posix_constant_row(LOGIN_NAME_MAX)
     posix_constant_row(MAX_CANON)
     posix_constant_row(MAX_INPUT)
     /*posix_constant_row(MQ_OPEN_MAX)*/
     /*posix_constant_row(MQ_PRIO_MAX)*/
     posix_constant_row(NAME_MAX)
     posix_constant_row(NGROUPS_MAX)
     posix_constant_row(OPEN_MAX)
     posix_constant_row(PATH_MAX)
     posix_constant_row(PIPE_BUF)
     posix_constant_row(RE_DUP_MAX)
     /*posix_constant_row(RTSIG_MAX)*/
     posix_constant_row(SEM_NSEMS_MAX)
     posix_constant_row(SEM_VALUE_MAX)
     /*posix_constant_row(SIGQUEUE_MAX)*/
     posix_constant_row(SSIZE_MAX)
     /*posix_constant_row(SS_REPL_MAX)*/
     posix_constant_row(STREAM_MAX)
     posix_constant_row(SYMLINK_MAX)
     posix_constant_row(SYMLOOP_MAX)
     posix_constant_row(THREAD_DESTRUCTOR_ITERATIONS)
     posix_constant_row(THREAD_KEYS_MAX)
     posix_constant_row(THREAD_THREADS_MAX)
     /*posix_constant_row(TIMER_MAX)*/
     posix_constant_row(TTY_NAME_MAX)
     posix_constant_row(TZNAME_MAX)
   
   /* POSIX.1 Configurable System Variables */    /* POSIX.1 Configurable System Variables */
   { "ARG_MAX",                  SYSCONF,        _SC_ARG_MAX             },    sysconf_row(JOB_CONTROL)
   { "CHILD_MAX",                SYSCONF,        _SC_CHILD_MAX           },    sysconf_row(SAVED_IDS)
   { "CLK_TCK",                  SYSCONF,        _SC_CLK_TCK             },    sysconf_row(VERSION)
   { "NGROUPS_MAX",              SYSCONF,        _SC_NGROUPS_MAX         },    sysconf_row(FSYNC)
   { "OPEN_MAX",                 SYSCONF,        _SC_OPEN_MAX            },    sysconf_row(MONOTONIC_CLOCK)
   { "STREAM_MAX",               SYSCONF,        _SC_STREAM_MAX          },    sysconf_row(THREAD_SAFE_FUNCTIONS)
   { "TZNAME_MAX",               SYSCONF,        _SC_TZNAME_MAX          },    sysconf_row(ADVISORY_INFO)
   { "_POSIX_JOB_CONTROL",       SYSCONF,        _SC_JOB_CONTROL         },    sysconf_row(BARRIERS)
   { "_POSIX_SAVED_IDS",         SYSCONF,        _SC_SAVED_IDS           },    sysconf_row(ASYNCHRONOUS_IO)
   { "_POSIX_VERSION",           SYSCONF,        _SC_VERSION             },    sysconf_row(CLOCK_SELECTION)
     sysconf_row(CPUTIME)
     sysconf_row(IPV6)
     sysconf_row(MAPPED_FILES)
     sysconf_row(MEMLOCK)
     sysconf_row(MEMLOCK_RANGE)
     sysconf_row(MEMORY_PROTECTION)
     sysconf_row(MESSAGE_PASSING)
     sysconf_row(PRIORITIZED_IO)
     sysconf_row(PRIORITY_SCHEDULING)
     sysconf_row(RAW_SOCKETS)
     sysconf_row(READER_WRITER_LOCKS)
     sysconf_row(REALTIME_SIGNALS)
     sysconf_row(REGEXP)
     sysconf_row(SEMAPHORES)
     sysconf_row(SHARED_MEMORY_OBJECTS)
     sysconf_row(SHELL)
     sysconf_row(SPAWN)
     sysconf_row(SPIN_LOCKS)
     sysconf_row(SPORADIC_SERVER)
     sysconf_row(SS_REPL_MAX)
     sysconf_row(SYNCHRONIZED_IO)
     sysconf_row(THREAD_ATTR_STACKADDR)
     sysconf_row(THREAD_ATTR_STACKSIZE)
     sysconf_row(THREAD_CPUTIME)
     sysconf_row(THREAD_PRIO_INHERIT)
     sysconf_row(THREAD_PRIO_PROTECT)
     sysconf_row(THREAD_PRIORITY_SCHEDULING)
     sysconf_row(THREAD_PROCESS_SHARED)
     sysconf_row(THREAD_ROBUST_PRIO_INHERIT)
     sysconf_row(THREAD_SPORADIC_SERVER)
     sysconf_row(THREADS)
     sysconf_row(TIMEOUTS)
     sysconf_row(TIMERS)
     sysconf_row(TRACE)
     sysconf_row(TRACE_EVENT_FILTER)
     sysconf_row(TRACE_EVENT_NAME_MAX)
     sysconf_row(TRACE_INHERIT)
     sysconf_row(TRACE_LOG)
     sysconf_row(TRACE_NAME_MAX)
     sysconf_row(TRACE_SYS_MAX)
     sysconf_row(TRACE_USER_EVENT_MAX)
     sysconf_row(TYPED_MEMORY_OBJECTS)
   
   { "LINK_MAX",                 PATHCONF,       _PC_LINK_MAX            },    /*
   { "MAX_CANON",                PATHCONF,       _PC_MAX_CANON           },     * If new compilation specification are added (V8_*?) then add them
   { "MAX_INPUT",                PATHCONF,       _PC_MAX_INPUT           },     * to the compilation_specs array below too
   { "NAME_MAX",                 PATHCONF,       _PC_NAME_MAX            },     */
   { "PATH_MAX",                 PATHCONF,       _PC_PATH_MAX            },    sysconf_row(V7_ILP32_OFF32)
   { "PIPE_BUF",                 PATHCONF,       _PC_PIPE_BUF            },    sysconf_row(V7_ILP32_OFFBIG)
   { "_POSIX_CHOWN_RESTRICTED",  PATHCONF,       _PC_CHOWN_RESTRICTED    },    sysconf_row(V7_LP64_OFF64)
   { "_POSIX_NO_TRUNC",          PATHCONF,       _PC_NO_TRUNC            },    sysconf_row(V7_LPBIG_OFFBIG)
   { "_POSIX_VDISABLE",          PATHCONF,       _PC_VDISABLE            },    sysconf_row(V6_ILP32_OFF32)
     sysconf_row(V6_ILP32_OFFBIG)
     sysconf_row(V6_LP64_OFF64)
     sysconf_row(V6_LPBIG_OFFBIG)
   
     /* POSIX.1 Configurable Path Variables */
     pathconf_row(CHOWN_RESTRICTED)
     pathconf_row(NO_TRUNC)
     pathconf_row(VDISABLE)
     pathconf_row(ASYNC_IO)
     pathconf_row(PRIO_IO)
     pathconf_row(SYNC_IO)
     /*pathconf_row(TIMESTAMP_RESOLUTION)*/
   
   { NULL }    { NULL }
 };  };
   
   /*
    * Then there are the "POSIX_*" values
    */
   const char posix_prefix[] = "POSIX_";
   const struct conf_variable posix_conf_table[] =
   {
     pathconf_row(ALLOC_SIZE_MIN)
     pathconf_row(REC_INCR_XFER_SIZE)
     pathconf_row(REC_MAX_XFER_SIZE)
     pathconf_row(REC_MIN_XFER_SIZE)
     pathconf_row(REC_XFER_ALIGN)
   
     posix_confstr_row(V7_ILP32_OFF32_CFLAGS)
     posix_confstr_row(V7_ILP32_OFF32_LDFLAGS)
     posix_confstr_row(V7_ILP32_OFF32_LIBS)
     posix_confstr_row(V7_ILP32_OFFBIG_CFLAGS)
     posix_confstr_row(V7_ILP32_OFFBIG_LDFLAGS)
     posix_confstr_row(V7_ILP32_OFFBIG_LIBS)
     posix_confstr_row(V7_LP64_OFF64_CFLAGS)
     posix_confstr_row(V7_LP64_OFF64_LDFLAGS)
     posix_confstr_row(V7_LP64_OFF64_LIBS)
     posix_confstr_row(V7_LPBIG_OFFBIG_CFLAGS)
     posix_confstr_row(V7_LPBIG_OFFBIG_LDFLAGS)
     posix_confstr_row(V7_LPBIG_OFFBIG_LIBS)
     posix_confstr_row(V7_THREADS_CFLAGS)
     posix_confstr_row(V7_THREADS_LDFLAGS)
     posix_confstr_row(V7_WIDTH_RESTRICTED_ENVS)
     posix_confstr_row(V6_ILP32_OFF32_CFLAGS)
     posix_confstr_row(V6_ILP32_OFF32_LDFLAGS)
     posix_confstr_row(V6_ILP32_OFF32_LIBS)
     posix_confstr_row(V6_ILP32_OFFBIG_CFLAGS)
     posix_confstr_row(V6_ILP32_OFFBIG_LDFLAGS)
     posix_confstr_row(V6_ILP32_OFFBIG_LIBS)
     posix_confstr_row(V6_LP64_OFF64_CFLAGS)
     posix_confstr_row(V6_LP64_OFF64_LDFLAGS)
     posix_confstr_row(V6_LP64_OFF64_LIBS)
     posix_confstr_row(V6_LPBIG_OFFBIG_CFLAGS)
     posix_confstr_row(V6_LPBIG_OFFBIG_LDFLAGS)
     posix_confstr_row(V6_LPBIG_OFFBIG_LIBS)
     posix_confstr_row(V6_WIDTH_RESTRICTED_ENVS)
   
     { NULL }
   };
   
   /*
    * Finally, there are variables that are accepted with a prefix
    * of either "_POSIX2_" or "POSIX2_"
    */
   const char compat_posix2_prefix[] = "POSIX2_";
   const struct conf_variable compat_posix2_conf_table[] =
   {
     /* Optional Facility Configuration Values */
     compat_posix2_sysconf_row(VERSION)
     compat_posix2_sysconf_row(C_BIND)
     compat_posix2_sysconf_row(C_DEV)
     compat_posix2_sysconf_row(CHAR_TERM)
     compat_posix2_sysconf_row(FORT_DEV)
     compat_posix2_sysconf_row(FORT_RUN)
     compat_posix2_sysconf_row(LOCALEDEF)
     compat_posix2_sysconf_row(SW_DEV)
     compat_posix2_sysconf_row(UPE)
   
     /* Utility Limit Minimum Values */
     compat_posix2_constant_row(BC_BASE_MAX)
     compat_posix2_constant_row(BC_DIM_MAX)
     compat_posix2_constant_row(BC_SCALE_MAX)
     compat_posix2_constant_row(BC_STRING_MAX)
     compat_posix2_constant_row(COLL_WEIGHTS_MAX)
     compat_posix2_constant_row(EXPR_NEST_MAX)
     compat_posix2_constant_row(LINE_MAX)
     compat_posix2_constant_row(RE_DUP_MAX)
   
     { NULL }
   };
   
   #undef constant_row
   #undef sysconf_row
   #undef pathconf_row
   #undef confstr_row
   #undef posix_constant_row
   #undef posix_confstr_row
   #undef compat_posix2_sysconf_row
   #undef compat_posix2_constant_row
   
   
   /*
    * What values are possibly accepted by the -v option?
    * These are implied to have a prefix of posix_prefix
    */
   const char *compilation_specs[] = {
     "V7_ILP32_OFF32",
     "V7_ILP32_OFFBIG",
     "V7_LP64_OFF64",
     "V7_LPBIG_OFFBIG",
     "V6_ILP32_OFF32",
     "V6_ILP32_OFFBIG",
     "V6_LP64_OFF64",
     "V6_LPBIG_OFFBIG",
     NULL
   };
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
Line 148 
Line 407 
   
         setlocale(LC_ALL, "");          setlocale(LC_ALL, "");
   
         while ((ch = getopt(argc, argv, "")) != -1) {          while ((ch = getopt(argc, argv, "lLv:")) != -1) {
                 switch (ch) {                  switch (ch) {
                   case 'l':       /* nonstandard: list system variables */
                           list_var(0);
                           return (0);
                   case 'L':       /* nonstandard: list path variables */
                           list_var(1);
                           return (0);
                   case 'v':
                           if (! compilation_spec_valid(optarg))
                                   errx(1, "%s: unknown specification", optarg);
                           break;
                 case '?':                  case '?':
                 default:                  default:
                         usage();                          usage();
Line 163 
Line 432 
                 /* NOTREACHED */                  /* NOTREACHED */
         }          }
   
         for (cp = conf_table; cp->name != NULL; cp++) {          /* pick a table based on a possible prefix */
                 if (strcmp(*argv, cp->name) == 0)          if (strncmp(*argv, uposix_prefix, sizeof(uposix_prefix) - 1) == 0) {
                   cp = uposix_conf_table;
                   slen = sizeof(uposix_prefix) - 1;
           } else if (strncmp(*argv, posix_prefix,
               sizeof(posix_prefix) - 1) == 0) {
                   cp = posix_conf_table;
                   slen = sizeof(posix_prefix) - 1;
           } else {
                   cp = conf_table;
                   slen = 0;
           }
   
           /* scan the table */
           for (; cp->name != NULL; cp++)
                   if (strcmp(*argv + slen, cp->name) == 0)
                         break;                          break;
   
           /*
            * If no match, then make a final check against
            * compat_posix2_conf_table, with special magic to accept/skip
            * a leading underbar
            */
           slen = argv[0][0] == '_';
           if (cp->name == NULL && strncmp(*argv + slen, compat_posix2_prefix,
               sizeof(compat_posix2_prefix) - 1) == 0) {
                   slen += sizeof(compat_posix2_prefix) - 1;
                   for (cp = compat_posix2_conf_table; cp->name != NULL; cp++) {
                           if (strcmp(*argv + slen, cp->name) == 0)
                                   break;
                   }
         }          }
   
         if (cp->name == NULL) {          if (cp->name == NULL) {
                 errx(1, "%s: unknown variable", *argv);                  errx(1, "%s: unknown variable", *argv);
                 /* NOTREACHED */                  /* NOTREACHED */
Line 238 
Line 536 
 {  {
         extern char *__progname;          extern char *__progname;
   
         (void)fprintf(stderr, "usage: %s name [pathname]\n", __progname);          (void)fprintf(stderr, "usage: %s [-lL] [-v spec] name [pathname]\n",
               __progname);
         exit(1);          exit(1);
   }
   
   static void
   list_var(int do_pathconf)
   {
           const struct conf_variable *cp;
   
           for (cp = uposix_conf_table; cp->name != NULL; cp++)
                   if ((cp->type == PATHCONF) == do_pathconf)
                           printf("%s%s\n", uposix_prefix, cp->name);
           for (cp = posix_conf_table; cp->name != NULL; cp++)
                   if ((cp->type == PATHCONF) == do_pathconf)
                           printf("%s%s\n", posix_prefix, cp->name);
           for (cp = conf_table; cp->name != NULL; cp++)
                   if ((cp->type == PATHCONF) == do_pathconf)
                           printf("%s\n", cp->name);
           for (cp = compat_posix2_conf_table; cp->name != NULL; cp++)
                   if ((cp->type == PATHCONF) == do_pathconf)
                           printf("_%s%s\n", compat_posix2_prefix, cp->name);
   }
   
   static int
   compilation_spec_valid(const char *spec)
   {
           const char **sp;
           const struct conf_variable *cp;
   
           if (strncmp(spec, posix_prefix, sizeof(posix_prefix) - 1) != 0)
                   return (0);
   
           spec += sizeof(posix_prefix) - 1;
           for (sp = compilation_specs; *sp != NULL; sp++)
                   if (strcmp(spec, *sp) == 0)
                           break;
           if (*sp == NULL)
                   return (0);
   
           for (cp = uposix_conf_table; cp->name != NULL; cp++)
                   if (strcmp(spec, cp->name) == 0 && cp->type == SYSCONF)
                           return (sysconf(cp->value) != -1);
   
           return (0);
 }  }
Legend:
Removed from v.1.12  
changed lines
  Added in v.1.13