File Coverage

sysconf.c

Criterion	Covered	Total	%
statement	275	275	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	275	275	100.0

/* Generated */

missing_is_sorted = 0;

#ifdef _SC_2_CHAR_TERM
(void)hv_store(sc_table, "_SC_2_CHAR_TERM", 15, newSViv(_SC_2_CHAR_TERM), 0);
#else
missing[nr_missing++] = "_SC_2_CHAR_TERM";
#endif
#ifdef _SC_2_C_BIND
(void)hv_store(sc_table, "_SC_2_C_BIND", 12, newSViv(_SC_2_C_BIND), 0);
#else
missing[nr_missing++] = "_SC_2_C_BIND";
#endif
#ifdef _SC_2_C_CHAR_TERM
(void)hv_store(sc_table, "_SC_2_C_CHAR_TERM", 17, newSViv(_SC_2_C_CHAR_TERM), 0);
#else
missing[nr_missing++] = "_SC_2_C_CHAR_TERM";
#endif
#ifdef _SC_2_C_DEV
(void)hv_store(sc_table, "_SC_2_C_DEV", 11, newSViv(_SC_2_C_DEV), 0);
#else
missing[nr_missing++] = "_SC_2_C_DEV";
#endif
#ifdef _SC_2_C_VERSION
(void)hv_store(sc_table, "_SC_2_C_VERSION", 15, newSViv(_SC_2_C_VERSION), 0);
#else
missing[nr_missing++] = "_SC_2_C_VERSION";
#endif
#ifdef _SC_2_FORT_DEV
(void)hv_store(sc_table, "_SC_2_FORT_DEV", 14, newSViv(_SC_2_FORT_DEV), 0);
#else
missing[nr_missing++] = "_SC_2_FORT_DEV";
#endif
#ifdef _SC_2_FORT_RUN
(void)hv_store(sc_table, "_SC_2_FORT_RUN", 14, newSViv(_SC_2_FORT_RUN), 0);
#else
missing[nr_missing++] = "_SC_2_FORT_RUN";
#endif
#ifdef _SC_2_LOCALEDEF
(void)hv_store(sc_table, "_SC_2_LOCALEDEF", 15, newSViv(_SC_2_LOCALEDEF), 0);
#else
missing[nr_missing++] = "_SC_2_LOCALEDEF";
#endif
#ifdef _SC_2_PBS
(void)hv_store(sc_table, "_SC_2_PBS", 9, newSViv(_SC_2_PBS), 0);
#else
missing[nr_missing++] = "_SC_2_PBS";
#endif
#ifdef _SC_2_PBS_ACCOUNTING
(void)hv_store(sc_table, "_SC_2_PBS_ACCOUNTING", 20, newSViv(_SC_2_PBS_ACCOUNTING), 0);
#else
missing[nr_missing++] = "_SC_2_PBS_ACCOUNTING";
#endif
#ifdef _SC_2_PBS_CHECKPOINT
(void)hv_store(sc_table, "_SC_2_PBS_CHECKPOINT", 20, newSViv(_SC_2_PBS_CHECKPOINT), 0);
#else
missing[nr_missing++] = "_SC_2_PBS_CHECKPOINT";
#endif
#ifdef _SC_2_PBS_LOCATE
(void)hv_store(sc_table, "_SC_2_PBS_LOCATE", 16, newSViv(_SC_2_PBS_LOCATE), 0);
#else
missing[nr_missing++] = "_SC_2_PBS_LOCATE";
#endif
#ifdef _SC_2_PBS_MESSAGE
(void)hv_store(sc_table, "_SC_2_PBS_MESSAGE", 17, newSViv(_SC_2_PBS_MESSAGE), 0);
#else
missing[nr_missing++] = "_SC_2_PBS_MESSAGE";
#endif
#ifdef _SC_2_PBS_TRACK
(void)hv_store(sc_table, "_SC_2_PBS_TRACK", 15, newSViv(_SC_2_PBS_TRACK), 0);
#else
missing[nr_missing++] = "_SC_2_PBS_TRACK";
#endif
#ifdef _SC_2_SW_DEV
(void)hv_store(sc_table, "_SC_2_SW_DEV", 12, newSViv(_SC_2_SW_DEV), 0);
#else
missing[nr_missing++] = "_SC_2_SW_DEV";
#endif
#ifdef _SC_2_UPE
(void)hv_store(sc_table, "_SC_2_UPE", 9, newSViv(_SC_2_UPE), 0);
#else
missing[nr_missing++] = "_SC_2_UPE";
#endif
#ifdef _SC_2_VERSION
(void)hv_store(sc_table, "_SC_2_VERSION", 13, newSViv(_SC_2_VERSION), 0);
#else
missing[nr_missing++] = "_SC_2_VERSION";
#endif
#ifdef _SC_ADVISORY_INFO
(void)hv_store(sc_table, "_SC_ADVISORY_INFO", 17, newSViv(_SC_ADVISORY_INFO), 0);
#else
missing[nr_missing++] = "_SC_ADVISORY_INFO";
#endif
#ifdef _SC_AES_OS_VERSION
(void)hv_store(sc_table, "_SC_AES_OS_VERSION", 18, newSViv(_SC_AES_OS_VERSION), 0);
#else
missing[nr_missing++] = "_SC_AES_OS_VERSION";
#endif
#ifdef _SC_AIO_LISTIO_MAX
(void)hv_store(sc_table, "_SC_AIO_LISTIO_MAX", 18, newSViv(_SC_AIO_LISTIO_MAX), 0);
#else
missing[nr_missing++] = "_SC_AIO_LISTIO_MAX";
#endif
#ifdef _SC_AIO_MAX
(void)hv_store(sc_table, "_SC_AIO_MAX", 11, newSViv(_SC_AIO_MAX), 0);
#else
missing[nr_missing++] = "_SC_AIO_MAX";
#endif
#ifdef _SC_AIO_PRIO_DELTA_MAX
(void)hv_store(sc_table, "_SC_AIO_PRIO_DELTA_MAX", 22, newSViv(_SC_AIO_PRIO_DELTA_MAX), 0);
#else
missing[nr_missing++] = "_SC_AIO_PRIO_DELTA_MAX";
#endif
#ifdef _SC_AIX_HARDWARE_BITMODE
(void)hv_store(sc_table, "_SC_AIX_HARDWARE_BITMODE", 24, newSViv(_SC_AIX_HARDWARE_BITMODE), 0);
#else
missing[nr_missing++] = "_SC_AIX_HARDWARE_BITMODE";
#endif
#ifdef _SC_AIX_KERNEL_BITMODE
(void)hv_store(sc_table, "_SC_AIX_KERNEL_BITMODE", 22, newSViv(_SC_AIX_KERNEL_BITMODE), 0);
#else
missing[nr_missing++] = "_SC_AIX_KERNEL_BITMODE";
#endif
#ifdef _SC_AIX_MP_CAPABLE
(void)hv_store(sc_table, "_SC_AIX_MP_CAPABLE", 18, newSViv(_SC_AIX_MP_CAPABLE), 0);
#else
missing[nr_missing++] = "_SC_AIX_MP_CAPABLE";
#endif
#ifdef _SC_AIX_REALMEM
(void)hv_store(sc_table, "_SC_AIX_REALMEM", 15, newSViv(_SC_AIX_REALMEM), 0);
#else
missing[nr_missing++] = "_SC_AIX_REALMEM";
#endif
#ifdef _SC_AIX_UKEYS
(void)hv_store(sc_table, "_SC_AIX_UKEYS", 13, newSViv(_SC_AIX_UKEYS), 0);
#else
missing[nr_missing++] = "_SC_AIX_UKEYS";
#endif
#ifdef _SC_ARG_MAX
(void)hv_store(sc_table, "_SC_ARG_MAX", 11, newSViv(_SC_ARG_MAX), 0);
#else
missing[nr_missing++] = "_SC_ARG_MAX";
#endif
#ifdef _SC_ASYNCHRONOUS_IO
(void)hv_store(sc_table, "_SC_ASYNCHRONOUS_IO", 19, newSViv(_SC_ASYNCHRONOUS_IO), 0);
#else
missing[nr_missing++] = "_SC_ASYNCHRONOUS_IO";
#endif
#ifdef _SC_ATEXIT_MAX
(void)hv_store(sc_table, "_SC_ATEXIT_MAX", 14, newSViv(_SC_ATEXIT_MAX), 0);
#else
missing[nr_missing++] = "_SC_ATEXIT_MAX";
#endif
#ifdef _SC_AVPHYS_PAGES
(void)hv_store(sc_table, "_SC_AVPHYS_PAGES", 16, newSViv(_SC_AVPHYS_PAGES), 0);
#else
missing[nr_missing++] = "_SC_AVPHYS_PAGES";
#endif
#ifdef _SC_BARRIERS
(void)hv_store(sc_table, "_SC_BARRIERS", 12, newSViv(_SC_BARRIERS), 0);
#else
missing[nr_missing++] = "_SC_BARRIERS";
#endif
#ifdef _SC_BASE
(void)hv_store(sc_table, "_SC_BASE", 8, newSViv(_SC_BASE), 0);
#else
missing[nr_missing++] = "_SC_BASE";
#endif
#ifdef _SC_BC_BASE_MAX
(void)hv_store(sc_table, "_SC_BC_BASE_MAX", 15, newSViv(_SC_BC_BASE_MAX), 0);
#else
missing[nr_missing++] = "_SC_BC_BASE_MAX";
#endif
#ifdef _SC_BC_DIM_MAX
(void)hv_store(sc_table, "_SC_BC_DIM_MAX", 14, newSViv(_SC_BC_DIM_MAX), 0);
#else
missing[nr_missing++] = "_SC_BC_DIM_MAX";
#endif
#ifdef _SC_BC_SCALE_MAX
(void)hv_store(sc_table, "_SC_BC_SCALE_MAX", 16, newSViv(_SC_BC_SCALE_MAX), 0);
#else
missing[nr_missing++] = "_SC_BC_SCALE_MAX";
#endif
#ifdef _SC_BC_STRING_MAX
(void)hv_store(sc_table, "_SC_BC_STRING_MAX", 17, newSViv(_SC_BC_STRING_MAX), 0);
#else
missing[nr_missing++] = "_SC_BC_STRING_MAX";
#endif
#ifdef _SC_BD_DIM_MAX
(void)hv_store(sc_table, "_SC_BD_DIM_MAX", 14, newSViv(_SC_BD_DIM_MAX), 0);
#else
missing[nr_missing++] = "_SC_BD_DIM_MAX";
#endif
#ifdef _SC_CACHE_LINE
(void)hv_store(sc_table, "_SC_CACHE_LINE", 14, newSViv(_SC_CACHE_LINE), 0);
#else
missing[nr_missing++] = "_SC_CACHE_LINE";
#endif
#ifdef _SC_CG_SIMPLE_IMPL
(void)hv_store(sc_table, "_SC_CG_SIMPLE_IMPL", 18, newSViv(_SC_CG_SIMPLE_IMPL), 0);
#else
missing[nr_missing++] = "_SC_CG_SIMPLE_IMPL";
#endif
#ifdef _SC_CHARCLASS_NAME_MAX
(void)hv_store(sc_table, "_SC_CHARCLASS_NAME_MAX", 22, newSViv(_SC_CHARCLASS_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_CHARCLASS_NAME_MAX";
#endif
#ifdef _SC_CHAR_BIT
(void)hv_store(sc_table, "_SC_CHAR_BIT", 12, newSViv(_SC_CHAR_BIT), 0);
#else
missing[nr_missing++] = "_SC_CHAR_BIT";
#endif
#ifdef _SC_CHAR_MAX
(void)hv_store(sc_table, "_SC_CHAR_MAX", 12, newSViv(_SC_CHAR_MAX), 0);
#else
missing[nr_missing++] = "_SC_CHAR_MAX";
#endif
#ifdef _SC_CHAR_MIN
(void)hv_store(sc_table, "_SC_CHAR_MIN", 12, newSViv(_SC_CHAR_MIN), 0);
#else
missing[nr_missing++] = "_SC_CHAR_MIN";
#endif
#ifdef _SC_CHILD_MAX
(void)hv_store(sc_table, "_SC_CHILD_MAX", 13, newSViv(_SC_CHILD_MAX), 0);
#else
missing[nr_missing++] = "_SC_CHILD_MAX";
#endif
#ifdef _SC_CLK_TCK
(void)hv_store(sc_table, "_SC_CLK_TCK", 11, newSViv(_SC_CLK_TCK), 0);
#else
missing[nr_missing++] = "_SC_CLK_TCK";
#endif
#ifdef _SC_CLOCKS_PER_SEC
(void)hv_store(sc_table, "_SC_CLOCKS_PER_SEC", 18, newSViv(_SC_CLOCKS_PER_SEC), 0);
#else
missing[nr_missing++] = "_SC_CLOCKS_PER_SEC";
#endif
#ifdef _SC_CLOCK_SELECTION
(void)hv_store(sc_table, "_SC_CLOCK_SELECTION", 19, newSViv(_SC_CLOCK_SELECTION), 0);
#else
missing[nr_missing++] = "_SC_CLOCK_SELECTION";
#endif
#ifdef _SC_COHER_BLKSZ
(void)hv_store(sc_table, "_SC_COHER_BLKSZ", 15, newSViv(_SC_COHER_BLKSZ), 0);
#else
missing[nr_missing++] = "_SC_COHER_BLKSZ";
#endif
#ifdef _SC_COLL_WEIGHTS_MAX
(void)hv_store(sc_table, "_SC_COLL_WEIGHTS_MAX", 20, newSViv(_SC_COLL_WEIGHTS_MAX), 0);
#else
missing[nr_missing++] = "_SC_COLL_WEIGHTS_MAX";
#endif
#ifdef _SC_CPUID_MAX
(void)hv_store(sc_table, "_SC_CPUID_MAX", 13, newSViv(_SC_CPUID_MAX), 0);
#else
missing[nr_missing++] = "_SC_CPUID_MAX";
#endif
#ifdef _SC_CPUSET_SIZE
(void)hv_store(sc_table, "_SC_CPUSET_SIZE", 15, newSViv(_SC_CPUSET_SIZE), 0);
#else
missing[nr_missing++] = "_SC_CPUSET_SIZE";
#endif
#ifdef _SC_CPUTIME
(void)hv_store(sc_table, "_SC_CPUTIME", 11, newSViv(_SC_CPUTIME), 0);
#else
missing[nr_missing++] = "_SC_CPUTIME";
#endif
#ifdef _SC_CPU_KEYBITS1
(void)hv_store(sc_table, "_SC_CPU_KEYBITS1", 16, newSViv(_SC_CPU_KEYBITS1), 0);
#else
missing[nr_missing++] = "_SC_CPU_KEYBITS1";
#endif
#ifdef _SC_CPU_VERSION
(void)hv_store(sc_table, "_SC_CPU_VERSION", 15, newSViv(_SC_CPU_VERSION), 0);
#else
missing[nr_missing++] = "_SC_CPU_VERSION";
#endif
#ifdef _SC_C_LANG_SUPPORT
(void)hv_store(sc_table, "_SC_C_LANG_SUPPORT", 18, newSViv(_SC_C_LANG_SUPPORT), 0);
#else
missing[nr_missing++] = "_SC_C_LANG_SUPPORT";
#endif
#ifdef _SC_C_LANG_SUPPORT_R
(void)hv_store(sc_table, "_SC_C_LANG_SUPPORT_R", 20, newSViv(_SC_C_LANG_SUPPORT_R), 0);
#else
missing[nr_missing++] = "_SC_C_LANG_SUPPORT_R";
#endif
#ifdef _SC_DCACHE_ASSOC
(void)hv_store(sc_table, "_SC_DCACHE_ASSOC", 16, newSViv(_SC_DCACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_DCACHE_ASSOC";
#endif
#ifdef _SC_DCACHE_BLKSZ
(void)hv_store(sc_table, "_SC_DCACHE_BLKSZ", 16, newSViv(_SC_DCACHE_BLKSZ), 0);
#else
missing[nr_missing++] = "_SC_DCACHE_BLKSZ";
#endif
#ifdef _SC_DCACHE_LINESZ
(void)hv_store(sc_table, "_SC_DCACHE_LINESZ", 17, newSViv(_SC_DCACHE_LINESZ), 0);
#else
missing[nr_missing++] = "_SC_DCACHE_LINESZ";
#endif
#ifdef _SC_DCACHE_SZ
(void)hv_store(sc_table, "_SC_DCACHE_SZ", 13, newSViv(_SC_DCACHE_SZ), 0);
#else
missing[nr_missing++] = "_SC_DCACHE_SZ";
#endif
#ifdef _SC_DCACHE_TBLKSZ
(void)hv_store(sc_table, "_SC_DCACHE_TBLKSZ", 17, newSViv(_SC_DCACHE_TBLKSZ), 0);
#else
missing[nr_missing++] = "_SC_DCACHE_TBLKSZ";
#endif
#ifdef _SC_DELAYTIMER_MAX
(void)hv_store(sc_table, "_SC_DELAYTIMER_MAX", 18, newSViv(_SC_DELAYTIMER_MAX), 0);
#else
missing[nr_missing++] = "_SC_DELAYTIMER_MAX";
#endif
#ifdef _SC_DEVICE_IO
(void)hv_store(sc_table, "_SC_DEVICE_IO", 13, newSViv(_SC_DEVICE_IO), 0);
#else
missing[nr_missing++] = "_SC_DEVICE_IO";
#endif
#ifdef _SC_DEVICE_SPECIFIC
(void)hv_store(sc_table, "_SC_DEVICE_SPECIFIC", 19, newSViv(_SC_DEVICE_SPECIFIC), 0);
#else
missing[nr_missing++] = "_SC_DEVICE_SPECIFIC";
#endif
#ifdef _SC_DEVICE_SPECIFIC_R
(void)hv_store(sc_table, "_SC_DEVICE_SPECIFIC_R", 21, newSViv(_SC_DEVICE_SPECIFIC_R), 0);
#else
missing[nr_missing++] = "_SC_DEVICE_SPECIFIC_R";
#endif
#ifdef _SC_EQUIV_CLASS_MAX
(void)hv_store(sc_table, "_SC_EQUIV_CLASS_MAX", 19, newSViv(_SC_EQUIV_CLASS_MAX), 0);
#else
missing[nr_missing++] = "_SC_EQUIV_CLASS_MAX";
#endif
#ifdef _SC_EXPR_NEST_MAX
(void)hv_store(sc_table, "_SC_EXPR_NEST_MAX", 17, newSViv(_SC_EXPR_NEST_MAX), 0);
#else
missing[nr_missing++] = "_SC_EXPR_NEST_MAX";
#endif
#ifdef _SC_FD_MGMT
(void)hv_store(sc_table, "_SC_FD_MGMT", 11, newSViv(_SC_FD_MGMT), 0);
#else
missing[nr_missing++] = "_SC_FD_MGMT";
#endif
#ifdef _SC_FIFO
(void)hv_store(sc_table, "_SC_FIFO", 8, newSViv(_SC_FIFO), 0);
#else
missing[nr_missing++] = "_SC_FIFO";
#endif
#ifdef _SC_FILE_ATTRIBUTES
(void)hv_store(sc_table, "_SC_FILE_ATTRIBUTES", 19, newSViv(_SC_FILE_ATTRIBUTES), 0);
#else
missing[nr_missing++] = "_SC_FILE_ATTRIBUTES";
#endif
#ifdef _SC_FILE_LOCKING
(void)hv_store(sc_table, "_SC_FILE_LOCKING", 16, newSViv(_SC_FILE_LOCKING), 0);
#else
missing[nr_missing++] = "_SC_FILE_LOCKING";
#endif
#ifdef _SC_FILE_SYSTEM
(void)hv_store(sc_table, "_SC_FILE_SYSTEM", 15, newSViv(_SC_FILE_SYSTEM), 0);
#else
missing[nr_missing++] = "_SC_FILE_SYSTEM";
#endif
#ifdef _SC_FSYNC
(void)hv_store(sc_table, "_SC_FSYNC", 9, newSViv(_SC_FSYNC), 0);
#else
missing[nr_missing++] = "_SC_FSYNC";
#endif
#ifdef _SC_GETGR_R_SIZE_MAX
(void)hv_store(sc_table, "_SC_GETGR_R_SIZE_MAX", 20, newSViv(_SC_GETGR_R_SIZE_MAX), 0);
#else
missing[nr_missing++] = "_SC_GETGR_R_SIZE_MAX";
#endif
#ifdef _SC_GETPW_R_SIZE_MAX
(void)hv_store(sc_table, "_SC_GETPW_R_SIZE_MAX", 20, newSViv(_SC_GETPW_R_SIZE_MAX), 0);
#else
missing[nr_missing++] = "_SC_GETPW_R_SIZE_MAX";
#endif
#ifdef _SC_HOST_NAME_MAX
(void)hv_store(sc_table, "_SC_HOST_NAME_MAX", 17, newSViv(_SC_HOST_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_HOST_NAME_MAX";
#endif
#ifdef _SC_ICACHE_ASSOC
(void)hv_store(sc_table, "_SC_ICACHE_ASSOC", 16, newSViv(_SC_ICACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_ICACHE_ASSOC";
#endif
#ifdef _SC_ICACHE_BLKSZ
(void)hv_store(sc_table, "_SC_ICACHE_BLKSZ", 16, newSViv(_SC_ICACHE_BLKSZ), 0);
#else
missing[nr_missing++] = "_SC_ICACHE_BLKSZ";
#endif
#ifdef _SC_ICACHE_LINESZ
(void)hv_store(sc_table, "_SC_ICACHE_LINESZ", 17, newSViv(_SC_ICACHE_LINESZ), 0);
#else
missing[nr_missing++] = "_SC_ICACHE_LINESZ";
#endif
#ifdef _SC_ICACHE_SZ
(void)hv_store(sc_table, "_SC_ICACHE_SZ", 13, newSViv(_SC_ICACHE_SZ), 0);
#else
missing[nr_missing++] = "_SC_ICACHE_SZ";
#endif
#ifdef _SC_INT_MAX
(void)hv_store(sc_table, "_SC_INT_MAX", 11, newSViv(_SC_INT_MAX), 0);
#else
missing[nr_missing++] = "_SC_INT_MAX";
#endif
#ifdef _SC_INT_MIN
(void)hv_store(sc_table, "_SC_INT_MIN", 11, newSViv(_SC_INT_MIN), 0);
#else
missing[nr_missing++] = "_SC_INT_MIN";
#endif
#ifdef _SC_IOV_MAX
(void)hv_store(sc_table, "_SC_IOV_MAX", 11, newSViv(_SC_IOV_MAX), 0);
#else
missing[nr_missing++] = "_SC_IOV_MAX";
#endif
#ifdef _SC_IO_TYPE
(void)hv_store(sc_table, "_SC_IO_TYPE", 11, newSViv(_SC_IO_TYPE), 0);
#else
missing[nr_missing++] = "_SC_IO_TYPE";
#endif
#ifdef _SC_IPV6
(void)hv_store(sc_table, "_SC_IPV6", 8, newSViv(_SC_IPV6), 0);
#else
missing[nr_missing++] = "_SC_IPV6";
#endif
#ifdef _SC_JOB_CONTROL
(void)hv_store(sc_table, "_SC_JOB_CONTROL", 15, newSViv(_SC_JOB_CONTROL), 0);
#else
missing[nr_missing++] = "_SC_JOB_CONTROL";
#endif
#ifdef _SC_LARGE_PAGESIZE
(void)hv_store(sc_table, "_SC_LARGE_PAGESIZE", 18, newSViv(_SC_LARGE_PAGESIZE), 0);
#else
missing[nr_missing++] = "_SC_LARGE_PAGESIZE";
#endif
#ifdef _SC_LEVEL1_DCACHE_ASSOC
(void)hv_store(sc_table, "_SC_LEVEL1_DCACHE_ASSOC", 23, newSViv(_SC_LEVEL1_DCACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_DCACHE_ASSOC";
#endif
#ifdef _SC_LEVEL1_DCACHE_LINESIZE
(void)hv_store(sc_table, "_SC_LEVEL1_DCACHE_LINESIZE", 26, newSViv(_SC_LEVEL1_DCACHE_LINESIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_DCACHE_LINESIZE";
#endif
#ifdef _SC_LEVEL1_DCACHE_SIZE
(void)hv_store(sc_table, "_SC_LEVEL1_DCACHE_SIZE", 22, newSViv(_SC_LEVEL1_DCACHE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_DCACHE_SIZE";
#endif
#ifdef _SC_LEVEL1_ICACHE_ASSOC
(void)hv_store(sc_table, "_SC_LEVEL1_ICACHE_ASSOC", 23, newSViv(_SC_LEVEL1_ICACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_ICACHE_ASSOC";
#endif
#ifdef _SC_LEVEL1_ICACHE_LINESIZE
(void)hv_store(sc_table, "_SC_LEVEL1_ICACHE_LINESIZE", 26, newSViv(_SC_LEVEL1_ICACHE_LINESIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_ICACHE_LINESIZE";
#endif
#ifdef _SC_LEVEL1_ICACHE_SIZE
(void)hv_store(sc_table, "_SC_LEVEL1_ICACHE_SIZE", 22, newSViv(_SC_LEVEL1_ICACHE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL1_ICACHE_SIZE";
#endif
#ifdef _SC_LEVEL2_CACHE_ASSOC
(void)hv_store(sc_table, "_SC_LEVEL2_CACHE_ASSOC", 22, newSViv(_SC_LEVEL2_CACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_LEVEL2_CACHE_ASSOC";
#endif
#ifdef _SC_LEVEL2_CACHE_LINESIZE
(void)hv_store(sc_table, "_SC_LEVEL2_CACHE_LINESIZE", 25, newSViv(_SC_LEVEL2_CACHE_LINESIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL2_CACHE_LINESIZE";
#endif
#ifdef _SC_LEVEL2_CACHE_SIZE
(void)hv_store(sc_table, "_SC_LEVEL2_CACHE_SIZE", 21, newSViv(_SC_LEVEL2_CACHE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL2_CACHE_SIZE";
#endif
#ifdef _SC_LEVEL3_CACHE_ASSOC
(void)hv_store(sc_table, "_SC_LEVEL3_CACHE_ASSOC", 22, newSViv(_SC_LEVEL3_CACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_LEVEL3_CACHE_ASSOC";
#endif
#ifdef _SC_LEVEL3_CACHE_LINESIZE
(void)hv_store(sc_table, "_SC_LEVEL3_CACHE_LINESIZE", 25, newSViv(_SC_LEVEL3_CACHE_LINESIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL3_CACHE_LINESIZE";
#endif
#ifdef _SC_LEVEL3_CACHE_SIZE
(void)hv_store(sc_table, "_SC_LEVEL3_CACHE_SIZE", 21, newSViv(_SC_LEVEL3_CACHE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL3_CACHE_SIZE";
#endif
#ifdef _SC_LEVEL4_CACHE_ASSOC
(void)hv_store(sc_table, "_SC_LEVEL4_CACHE_ASSOC", 22, newSViv(_SC_LEVEL4_CACHE_ASSOC), 0);
#else
missing[nr_missing++] = "_SC_LEVEL4_CACHE_ASSOC";
#endif
#ifdef _SC_LEVEL4_CACHE_LINESIZE
(void)hv_store(sc_table, "_SC_LEVEL4_CACHE_LINESIZE", 25, newSViv(_SC_LEVEL4_CACHE_LINESIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL4_CACHE_LINESIZE";
#endif
#ifdef _SC_LEVEL4_CACHE_SIZE
(void)hv_store(sc_table, "_SC_LEVEL4_CACHE_SIZE", 21, newSViv(_SC_LEVEL4_CACHE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_LEVEL4_CACHE_SIZE";
#endif
#ifdef _SC_LIBC_VERSION
(void)hv_store(sc_table, "_SC_LIBC_VERSION", 16, newSViv(_SC_LIBC_VERSION), 0);
#else
missing[nr_missing++] = "_SC_LIBC_VERSION";
#endif
#ifdef _SC_LINE_MAX
(void)hv_store(sc_table, "_SC_LINE_MAX", 12, newSViv(_SC_LINE_MAX), 0);
#else
missing[nr_missing++] = "_SC_LINE_MAX";
#endif
#ifdef _SC_LOGIN_NAME_MAX
(void)hv_store(sc_table, "_SC_LOGIN_NAME_MAX", 18, newSViv(_SC_LOGIN_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_LOGIN_NAME_MAX";
#endif
#ifdef _SC_LOGNAME_MAX
(void)hv_store(sc_table, "_SC_LOGNAME_MAX", 15, newSViv(_SC_LOGNAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_LOGNAME_MAX";
#endif
#ifdef _SC_LONG_BIT
(void)hv_store(sc_table, "_SC_LONG_BIT", 12, newSViv(_SC_LONG_BIT), 0);
#else
missing[nr_missing++] = "_SC_LONG_BIT";
#endif
#ifdef _SC_LPAR_ENABLED
(void)hv_store(sc_table, "_SC_LPAR_ENABLED", 16, newSViv(_SC_LPAR_ENABLED), 0);
#else
missing[nr_missing++] = "_SC_LPAR_ENABLED";
#endif
#ifdef _SC_MAPPED_FILES
(void)hv_store(sc_table, "_SC_MAPPED_FILES", 16, newSViv(_SC_MAPPED_FILES), 0);
#else
missing[nr_missing++] = "_SC_MAPPED_FILES";
#endif
#ifdef _SC_MAXPID
(void)hv_store(sc_table, "_SC_MAXPID", 10, newSViv(_SC_MAXPID), 0);
#else
missing[nr_missing++] = "_SC_MAXPID";
#endif
#ifdef _SC_MAX_CPUS_PER_CG
(void)hv_store(sc_table, "_SC_MAX_CPUS_PER_CG", 19, newSViv(_SC_MAX_CPUS_PER_CG), 0);
#else
missing[nr_missing++] = "_SC_MAX_CPUS_PER_CG";
#endif
#ifdef _SC_MB_LEN_MAX
(void)hv_store(sc_table, "_SC_MB_LEN_MAX", 14, newSViv(_SC_MB_LEN_MAX), 0);
#else
missing[nr_missing++] = "_SC_MB_LEN_MAX";
#endif
#ifdef _SC_MEMLOCK
(void)hv_store(sc_table, "_SC_MEMLOCK", 11, newSViv(_SC_MEMLOCK), 0);
#else
missing[nr_missing++] = "_SC_MEMLOCK";
#endif
#ifdef _SC_MEMLOCK_RANGE
(void)hv_store(sc_table, "_SC_MEMLOCK_RANGE", 17, newSViv(_SC_MEMLOCK_RANGE), 0);
#else
missing[nr_missing++] = "_SC_MEMLOCK_RANGE";
#endif
#ifdef _SC_MEMORY_PROTECTION
(void)hv_store(sc_table, "_SC_MEMORY_PROTECTION", 21, newSViv(_SC_MEMORY_PROTECTION), 0);
#else
missing[nr_missing++] = "_SC_MEMORY_PROTECTION";
#endif
#ifdef _SC_MESSAGE_PASSING
(void)hv_store(sc_table, "_SC_MESSAGE_PASSING", 19, newSViv(_SC_MESSAGE_PASSING), 0);
#else
missing[nr_missing++] = "_SC_MESSAGE_PASSING";
#endif
#ifdef _SC_MONOTONIC_CLOCK
(void)hv_store(sc_table, "_SC_MONOTONIC_CLOCK", 19, newSViv(_SC_MONOTONIC_CLOCK), 0);
#else
missing[nr_missing++] = "_SC_MONOTONIC_CLOCK";
#endif
#ifdef _SC_MQ_OPEN_MAX
(void)hv_store(sc_table, "_SC_MQ_OPEN_MAX", 15, newSViv(_SC_MQ_OPEN_MAX), 0);
#else
missing[nr_missing++] = "_SC_MQ_OPEN_MAX";
#endif
#ifdef _SC_MQ_PRIO_MAX
(void)hv_store(sc_table, "_SC_MQ_PRIO_MAX", 15, newSViv(_SC_MQ_PRIO_MAX), 0);
#else
missing[nr_missing++] = "_SC_MQ_PRIO_MAX";
#endif
#ifdef _SC_MULTI_PROCESS
(void)hv_store(sc_table, "_SC_MULTI_PROCESS", 17, newSViv(_SC_MULTI_PROCESS), 0);
#else
missing[nr_missing++] = "_SC_MULTI_PROCESS";
#endif
#ifdef _SC_NACLS_MAX
(void)hv_store(sc_table, "_SC_NACLS_MAX", 13, newSViv(_SC_NACLS_MAX), 0);
#else
missing[nr_missing++] = "_SC_NACLS_MAX";
#endif
#ifdef _SC_NCGS_CONF
(void)hv_store(sc_table, "_SC_NCGS_CONF", 13, newSViv(_SC_NCGS_CONF), 0);
#else
missing[nr_missing++] = "_SC_NCGS_CONF";
#endif
#ifdef _SC_NCGS_ONLN
(void)hv_store(sc_table, "_SC_NCGS_ONLN", 13, newSViv(_SC_NCGS_ONLN), 0);
#else
missing[nr_missing++] = "_SC_NCGS_ONLN";
#endif
#ifdef _SC_NETWORKING
(void)hv_store(sc_table, "_SC_NETWORKING", 14, newSViv(_SC_NETWORKING), 0);
#else
missing[nr_missing++] = "_SC_NETWORKING";
#endif
#ifdef _SC_NGROUPS_MAX
(void)hv_store(sc_table, "_SC_NGROUPS_MAX", 15, newSViv(_SC_NGROUPS_MAX), 0);
#else
missing[nr_missing++] = "_SC_NGROUPS_MAX";
#endif
#ifdef _SC_NL_ARGMAX
(void)hv_store(sc_table, "_SC_NL_ARGMAX", 13, newSViv(_SC_NL_ARGMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_ARGMAX";
#endif
#ifdef _SC_NL_LANGMAX
(void)hv_store(sc_table, "_SC_NL_LANGMAX", 14, newSViv(_SC_NL_LANGMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_LANGMAX";
#endif
#ifdef _SC_NL_MSGMAX
(void)hv_store(sc_table, "_SC_NL_MSGMAX", 13, newSViv(_SC_NL_MSGMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_MSGMAX";
#endif
#ifdef _SC_NL_NMAX
(void)hv_store(sc_table, "_SC_NL_NMAX", 11, newSViv(_SC_NL_NMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_NMAX";
#endif
#ifdef _SC_NL_SETMAX
(void)hv_store(sc_table, "_SC_NL_SETMAX", 13, newSViv(_SC_NL_SETMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_SETMAX";
#endif
#ifdef _SC_NL_TEXTMAX
(void)hv_store(sc_table, "_SC_NL_TEXTMAX", 14, newSViv(_SC_NL_TEXTMAX), 0);
#else
missing[nr_missing++] = "_SC_NL_TEXTMAX";
#endif
#ifdef _SC_NPROCESSES
(void)hv_store(sc_table, "_SC_NPROCESSES", 14, newSViv(_SC_NPROCESSES), 0);
#else
missing[nr_missing++] = "_SC_NPROCESSES";
#endif
#ifdef _SC_NPROCESSORS_CONF
(void)hv_store(sc_table, "_SC_NPROCESSORS_CONF", 20, newSViv(_SC_NPROCESSORS_CONF), 0);
#else
missing[nr_missing++] = "_SC_NPROCESSORS_CONF";
#endif
#ifdef _SC_NPROCESSORS_MAX
(void)hv_store(sc_table, "_SC_NPROCESSORS_MAX", 19, newSViv(_SC_NPROCESSORS_MAX), 0);
#else
missing[nr_missing++] = "_SC_NPROCESSORS_MAX";
#endif
#ifdef _SC_NPROCESSORS_ONLN
(void)hv_store(sc_table, "_SC_NPROCESSORS_ONLN", 20, newSViv(_SC_NPROCESSORS_ONLN), 0);
#else
missing[nr_missing++] = "_SC_NPROCESSORS_ONLN";
#endif
#ifdef _SC_NUTC_OS_ALLOCGRANULARITY
(void)hv_store(sc_table, "_SC_NUTC_OS_ALLOCGRANULARITY", 28, newSViv(_SC_NUTC_OS_ALLOCGRANULARITY), 0);
#else
missing[nr_missing++] = "_SC_NUTC_OS_ALLOCGRANULARITY";
#endif
#ifdef _SC_NUTC_OS_PAGESIZE
(void)hv_store(sc_table, "_SC_NUTC_OS_PAGESIZE", 20, newSViv(_SC_NUTC_OS_PAGESIZE), 0);
#else
missing[nr_missing++] = "_SC_NUTC_OS_PAGESIZE";
#endif
#ifdef _SC_NUTC_OS_PLATFORM
(void)hv_store(sc_table, "_SC_NUTC_OS_PLATFORM", 20, newSViv(_SC_NUTC_OS_PLATFORM), 0);
#else
missing[nr_missing++] = "_SC_NUTC_OS_PLATFORM";
#endif
#ifdef _SC_NZERO
(void)hv_store(sc_table, "_SC_NZERO", 9, newSViv(_SC_NZERO), 0);
#else
missing[nr_missing++] = "_SC_NZERO";
#endif
#ifdef _SC_OPEN_MAX
(void)hv_store(sc_table, "_SC_OPEN_MAX", 12, newSViv(_SC_OPEN_MAX), 0);
#else
missing[nr_missing++] = "_SC_OPEN_MAX";
#endif
#ifdef _SC_PAGESIZE
(void)hv_store(sc_table, "_SC_PAGESIZE", 12, newSViv(_SC_PAGESIZE), 0);
#else
missing[nr_missing++] = "_SC_PAGESIZE";
#endif
#ifdef _SC_PAGE_SIZE
(void)hv_store(sc_table, "_SC_PAGE_SIZE", 13, newSViv(_SC_PAGE_SIZE), 0);
#else
missing[nr_missing++] = "_SC_PAGE_SIZE";
#endif
#ifdef _SC_PASS_MAX
(void)hv_store(sc_table, "_SC_PASS_MAX", 12, newSViv(_SC_PASS_MAX), 0);
#else
missing[nr_missing++] = "_SC_PASS_MAX";
#endif
#ifdef _SC_PHYS_PAGES
(void)hv_store(sc_table, "_SC_PHYS_PAGES", 14, newSViv(_SC_PHYS_PAGES), 0);
#else
missing[nr_missing++] = "_SC_PHYS_PAGES";
#endif
#ifdef _SC_PII
(void)hv_store(sc_table, "_SC_PII", 7, newSViv(_SC_PII), 0);
#else
missing[nr_missing++] = "_SC_PII";
#endif
#ifdef _SC_PII_INTERNET
(void)hv_store(sc_table, "_SC_PII_INTERNET", 16, newSViv(_SC_PII_INTERNET), 0);
#else
missing[nr_missing++] = "_SC_PII_INTERNET";
#endif
#ifdef _SC_PII_INTERNET_DGRAM
(void)hv_store(sc_table, "_SC_PII_INTERNET_DGRAM", 22, newSViv(_SC_PII_INTERNET_DGRAM), 0);
#else
missing[nr_missing++] = "_SC_PII_INTERNET_DGRAM";
#endif
#ifdef _SC_PII_INTERNET_STREAM
(void)hv_store(sc_table, "_SC_PII_INTERNET_STREAM", 23, newSViv(_SC_PII_INTERNET_STREAM), 0);
#else
missing[nr_missing++] = "_SC_PII_INTERNET_STREAM";
#endif
#ifdef _SC_PII_OSI
(void)hv_store(sc_table, "_SC_PII_OSI", 11, newSViv(_SC_PII_OSI), 0);
#else
missing[nr_missing++] = "_SC_PII_OSI";
#endif
#ifdef _SC_PII_OSI_CLTS
(void)hv_store(sc_table, "_SC_PII_OSI_CLTS", 16, newSViv(_SC_PII_OSI_CLTS), 0);
#else
missing[nr_missing++] = "_SC_PII_OSI_CLTS";
#endif
#ifdef _SC_PII_OSI_COTS
(void)hv_store(sc_table, "_SC_PII_OSI_COTS", 16, newSViv(_SC_PII_OSI_COTS), 0);
#else
missing[nr_missing++] = "_SC_PII_OSI_COTS";
#endif
#ifdef _SC_PII_OSI_M
(void)hv_store(sc_table, "_SC_PII_OSI_M", 13, newSViv(_SC_PII_OSI_M), 0);
#else
missing[nr_missing++] = "_SC_PII_OSI_M";
#endif
#ifdef _SC_PII_SOCKET
(void)hv_store(sc_table, "_SC_PII_SOCKET", 14, newSViv(_SC_PII_SOCKET), 0);
#else
missing[nr_missing++] = "_SC_PII_SOCKET";
#endif
#ifdef _SC_PII_XTI
(void)hv_store(sc_table, "_SC_PII_XTI", 11, newSViv(_SC_PII_XTI), 0);
#else
missing[nr_missing++] = "_SC_PII_XTI";
#endif
#ifdef _SC_PIPE
(void)hv_store(sc_table, "_SC_PIPE", 8, newSViv(_SC_PIPE), 0);
#else
missing[nr_missing++] = "_SC_PIPE";
#endif
#ifdef _SC_POLL
(void)hv_store(sc_table, "_SC_POLL", 8, newSViv(_SC_POLL), 0);
#else
missing[nr_missing++] = "_SC_POLL";
#endif
#ifdef _SC_PRIORITIZED_IO
(void)hv_store(sc_table, "_SC_PRIORITIZED_IO", 18, newSViv(_SC_PRIORITIZED_IO), 0);
#else
missing[nr_missing++] = "_SC_PRIORITIZED_IO";
#endif
#ifdef _SC_PRIORITY_
(void)hv_store(sc_table, "_SC_PRIORITY_", 13, newSViv(_SC_PRIORITY_), 0);
#else
missing[nr_missing++] = "_SC_PRIORITY_";
#endif
#ifdef _SC_PRIORITY_SCHEDULING
(void)hv_store(sc_table, "_SC_PRIORITY_SCHEDULING", 23, newSViv(_SC_PRIORITY_SCHEDULING), 0);
#else
missing[nr_missing++] = "_SC_PRIORITY_SCHEDULING";
#endif
#ifdef _SC_PROC_RSRC_MGR
(void)hv_store(sc_table, "_SC_PROC_RSRC_MGR", 17, newSViv(_SC_PROC_RSRC_MGR), 0);
#else
missing[nr_missing++] = "_SC_PROC_RSRC_MGR";
#endif
#ifdef _SC_RAW_SOCKETS
(void)hv_store(sc_table, "_SC_RAW_SOCKETS", 15, newSViv(_SC_RAW_SOCKETS), 0);
#else
missing[nr_missing++] = "_SC_RAW_SOCKETS";
#endif
#ifdef _SC_READER_WRITER_LOCKS
(void)hv_store(sc_table, "_SC_READER_WRITER_LOCKS", 23, newSViv(_SC_READER_WRITER_LOCKS), 0);
#else
missing[nr_missing++] = "_SC_READER_WRITER_LOCKS";
#endif
#ifdef _SC_REALTIME_SIGNALS
(void)hv_store(sc_table, "_SC_REALTIME_SIGNALS", 20, newSViv(_SC_REALTIME_SIGNALS), 0);
#else
missing[nr_missing++] = "_SC_REALTIME_SIGNALS";
#endif
#ifdef _SC_REENTRANT_FUNCTIONS
(void)hv_store(sc_table, "_SC_REENTRANT_FUNCTIONS", 23, newSViv(_SC_REENTRANT_FUNCTIONS), 0);
#else
missing[nr_missing++] = "_SC_REENTRANT_FUNCTIONS";
#endif
#ifdef _SC_REGEXP
(void)hv_store(sc_table, "_SC_REGEXP", 10, newSViv(_SC_REGEXP), 0);
#else
missing[nr_missing++] = "_SC_REGEXP";
#endif
#ifdef _SC_REGEX_VERSION
(void)hv_store(sc_table, "_SC_REGEX_VERSION", 17, newSViv(_SC_REGEX_VERSION), 0);
#else
missing[nr_missing++] = "_SC_REGEX_VERSION";
#endif
#ifdef _SC_RE_DUP_MAX
(void)hv_store(sc_table, "_SC_RE_DUP_MAX", 14, newSViv(_SC_RE_DUP_MAX), 0);
#else
missing[nr_missing++] = "_SC_RE_DUP_MAX";
#endif
#ifdef _SC_RTSIG_MAX
(void)hv_store(sc_table, "_SC_RTSIG_MAX", 13, newSViv(_SC_RTSIG_MAX), 0);
#else
missing[nr_missing++] = "_SC_RTSIG_MAX";
#endif
#ifdef _SC_SAVED_IDS
(void)hv_store(sc_table, "_SC_SAVED_IDS", 13, newSViv(_SC_SAVED_IDS), 0);
#else
missing[nr_missing++] = "_SC_SAVED_IDS";
#endif
#ifdef _SC_SCHAR_MAX
(void)hv_store(sc_table, "_SC_SCHAR_MAX", 13, newSViv(_SC_SCHAR_MAX), 0);
#else
missing[nr_missing++] = "_SC_SCHAR_MAX";
#endif
#ifdef _SC_SCHAR_MIN
(void)hv_store(sc_table, "_SC_SCHAR_MIN", 13, newSViv(_SC_SCHAR_MIN), 0);
#else
missing[nr_missing++] = "_SC_SCHAR_MIN";
#endif
#ifdef _SC_SECURITY_CLASS
(void)hv_store(sc_table, "_SC_SECURITY_CLASS", 18, newSViv(_SC_SECURITY_CLASS), 0);
#else
missing[nr_missing++] = "_SC_SECURITY_CLASS";
#endif
#ifdef _SC_SELECT
(void)hv_store(sc_table, "_SC_SELECT", 10, newSViv(_SC_SELECT), 0);
#else
missing[nr_missing++] = "_SC_SELECT";
#endif
#ifdef _SC_SEMAPHORES
(void)hv_store(sc_table, "_SC_SEMAPHORES", 14, newSViv(_SC_SEMAPHORES), 0);
#else
missing[nr_missing++] = "_SC_SEMAPHORES";
#endif
#ifdef _SC_SEM_NSEMS_MAX
(void)hv_store(sc_table, "_SC_SEM_NSEMS_MAX", 17, newSViv(_SC_SEM_NSEMS_MAX), 0);
#else
missing[nr_missing++] = "_SC_SEM_NSEMS_MAX";
#endif
#ifdef _SC_SEM_VALUE_MAX
(void)hv_store(sc_table, "_SC_SEM_VALUE_MAX", 17, newSViv(_SC_SEM_VALUE_MAX), 0);
#else
missing[nr_missing++] = "_SC_SEM_VALUE_MAX";
#endif
#ifdef _SC_SHARED_MEMORY_
(void)hv_store(sc_table, "_SC_SHARED_MEMORY_", 18, newSViv(_SC_SHARED_MEMORY_), 0);
#else
missing[nr_missing++] = "_SC_SHARED_MEMORY_";
#endif
#ifdef _SC_SHARED_MEMORY_OBJECTS
(void)hv_store(sc_table, "_SC_SHARED_MEMORY_OBJECTS", 25, newSViv(_SC_SHARED_MEMORY_OBJECTS), 0);
#else
missing[nr_missing++] = "_SC_SHARED_MEMORY_OBJECTS";
#endif
#ifdef _SC_SHELL
(void)hv_store(sc_table, "_SC_SHELL", 9, newSViv(_SC_SHELL), 0);
#else
missing[nr_missing++] = "_SC_SHELL";
#endif
#ifdef _SC_SHRT_MAX
(void)hv_store(sc_table, "_SC_SHRT_MAX", 12, newSViv(_SC_SHRT_MAX), 0);
#else
missing[nr_missing++] = "_SC_SHRT_MAX";
#endif
#ifdef _SC_SHRT_MIN
(void)hv_store(sc_table, "_SC_SHRT_MIN", 12, newSViv(_SC_SHRT_MIN), 0);
#else
missing[nr_missing++] = "_SC_SHRT_MIN";
#endif
#ifdef _SC_SIGNALS
(void)hv_store(sc_table, "_SC_SIGNALS", 11, newSViv(_SC_SIGNALS), 0);
#else
missing[nr_missing++] = "_SC_SIGNALS";
#endif
#ifdef _SC_SIGQUEUE_MAX
(void)hv_store(sc_table, "_SC_SIGQUEUE_MAX", 16, newSViv(_SC_SIGQUEUE_MAX), 0);
#else
missing[nr_missing++] = "_SC_SIGQUEUE_MAX";
#endif
#ifdef _SC_SINGLE_PROCESS
(void)hv_store(sc_table, "_SC_SINGLE_PROCESS", 18, newSViv(_SC_SINGLE_PROCESS), 0);
#else
missing[nr_missing++] = "_SC_SINGLE_PROCESS";
#endif
#ifdef _SC_SPAWN
(void)hv_store(sc_table, "_SC_SPAWN", 9, newSViv(_SC_SPAWN), 0);
#else
missing[nr_missing++] = "_SC_SPAWN";
#endif
#ifdef _SC_SPIN_LOCKS
(void)hv_store(sc_table, "_SC_SPIN_LOCKS", 14, newSViv(_SC_SPIN_LOCKS), 0);
#else
missing[nr_missing++] = "_SC_SPIN_LOCKS";
#endif
#ifdef _SC_SPLIT_CACHE
(void)hv_store(sc_table, "_SC_SPLIT_CACHE", 15, newSViv(_SC_SPLIT_CACHE), 0);
#else
missing[nr_missing++] = "_SC_SPLIT_CACHE";
#endif
#ifdef _SC_SPORADIC_SERVER
(void)hv_store(sc_table, "_SC_SPORADIC_SERVER", 19, newSViv(_SC_SPORADIC_SERVER), 0);
#else
missing[nr_missing++] = "_SC_SPORADIC_SERVER";
#endif
#ifdef _SC_SSIZE_MAX
(void)hv_store(sc_table, "_SC_SSIZE_MAX", 13, newSViv(_SC_SSIZE_MAX), 0);
#else
missing[nr_missing++] = "_SC_SSIZE_MAX";
#endif
#ifdef _SC_SS_REPL_MAX
(void)hv_store(sc_table, "_SC_SS_REPL_MAX", 15, newSViv(_SC_SS_REPL_MAX), 0);
#else
missing[nr_missing++] = "_SC_SS_REPL_MAX";
#endif
#ifdef _SC_STACK_PROT
(void)hv_store(sc_table, "_SC_STACK_PROT", 14, newSViv(_SC_STACK_PROT), 0);
#else
missing[nr_missing++] = "_SC_STACK_PROT";
#endif
#ifdef _SC_STREAMS
(void)hv_store(sc_table, "_SC_STREAMS", 11, newSViv(_SC_STREAMS), 0);
#else
missing[nr_missing++] = "_SC_STREAMS";
#endif
#ifdef _SC_STREAM_MAX
(void)hv_store(sc_table, "_SC_STREAM_MAX", 14, newSViv(_SC_STREAM_MAX), 0);
#else
missing[nr_missing++] = "_SC_STREAM_MAX";
#endif
#ifdef _SC_SYMLOOP_MAX
(void)hv_store(sc_table, "_SC_SYMLOOP_MAX", 15, newSViv(_SC_SYMLOOP_MAX), 0);
#else
missing[nr_missing++] = "_SC_SYMLOOP_MAX";
#endif
#ifdef _SC_SYNCHRONIZED_IO
(void)hv_store(sc_table, "_SC_SYNCHRONIZED_IO", 19, newSViv(_SC_SYNCHRONIZED_IO), 0);
#else
missing[nr_missing++] = "_SC_SYNCHRONIZED_IO";
#endif
#ifdef _SC_SYSTEM_DATABASE
(void)hv_store(sc_table, "_SC_SYSTEM_DATABASE", 19, newSViv(_SC_SYSTEM_DATABASE), 0);
#else
missing[nr_missing++] = "_SC_SYSTEM_DATABASE";
#endif
#ifdef _SC_SYSTEM_DATABASE_R
(void)hv_store(sc_table, "_SC_SYSTEM_DATABASE_R", 21, newSViv(_SC_SYSTEM_DATABASE_R), 0);
#else
missing[nr_missing++] = "_SC_SYSTEM_DATABASE_R";
#endif
#ifdef _SC_SYSTEM_ID
(void)hv_store(sc_table, "_SC_SYSTEM_ID", 13, newSViv(_SC_SYSTEM_ID), 0);
#else
missing[nr_missing++] = "_SC_SYSTEM_ID";
#endif
#ifdef _SC_THREADS
(void)hv_store(sc_table, "_SC_THREADS", 11, newSViv(_SC_THREADS), 0);
#else
missing[nr_missing++] = "_SC_THREADS";
#endif
#ifdef _SC_THREAD_
(void)hv_store(sc_table, "_SC_THREAD_", 11, newSViv(_SC_THREAD_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_";
#endif
#ifdef _SC_THREAD_ATTR_
(void)hv_store(sc_table, "_SC_THREAD_ATTR_", 16, newSViv(_SC_THREAD_ATTR_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_ATTR_";
#endif
#ifdef _SC_THREAD_ATTR_STACKADDR
(void)hv_store(sc_table, "_SC_THREAD_ATTR_STACKADDR", 25, newSViv(_SC_THREAD_ATTR_STACKADDR), 0);
#else
missing[nr_missing++] = "_SC_THREAD_ATTR_STACKADDR";
#endif
#ifdef _SC_THREAD_ATTR_STACKSIZE
(void)hv_store(sc_table, "_SC_THREAD_ATTR_STACKSIZE", 25, newSViv(_SC_THREAD_ATTR_STACKSIZE), 0);
#else
missing[nr_missing++] = "_SC_THREAD_ATTR_STACKSIZE";
#endif
#ifdef _SC_THREAD_CPUTIME
(void)hv_store(sc_table, "_SC_THREAD_CPUTIME", 18, newSViv(_SC_THREAD_CPUTIME), 0);
#else
missing[nr_missing++] = "_SC_THREAD_CPUTIME";
#endif
#ifdef _SC_THREAD_DATAKEYS_MAX
(void)hv_store(sc_table, "_SC_THREAD_DATAKEYS_MAX", 23, newSViv(_SC_THREAD_DATAKEYS_MAX), 0);
#else
missing[nr_missing++] = "_SC_THREAD_DATAKEYS_MAX";
#endif
#ifdef _SC_THREAD_DESTRUCTOR_
(void)hv_store(sc_table, "_SC_THREAD_DESTRUCTOR_", 22, newSViv(_SC_THREAD_DESTRUCTOR_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_DESTRUCTOR_";
#endif
#ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
(void)hv_store(sc_table, "_SC_THREAD_DESTRUCTOR_ITERATIONS", 32, newSViv(_SC_THREAD_DESTRUCTOR_ITERATIONS), 0);
#else
missing[nr_missing++] = "_SC_THREAD_DESTRUCTOR_ITERATIONS";
#endif
#ifdef _SC_THREAD_KEYS_MAX
(void)hv_store(sc_table, "_SC_THREAD_KEYS_MAX", 19, newSViv(_SC_THREAD_KEYS_MAX), 0);
#else
missing[nr_missing++] = "_SC_THREAD_KEYS_MAX";
#endif
#ifdef _SC_THREAD_PRIORITY_
(void)hv_store(sc_table, "_SC_THREAD_PRIORITY_", 20, newSViv(_SC_THREAD_PRIORITY_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PRIORITY_";
#endif
#ifdef _SC_THREAD_PRIORITY_SCHEDULING
(void)hv_store(sc_table, "_SC_THREAD_PRIORITY_SCHEDULING", 30, newSViv(_SC_THREAD_PRIORITY_SCHEDULING), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PRIORITY_SCHEDULING";
#endif
#ifdef _SC_THREAD_PRIO_
(void)hv_store(sc_table, "_SC_THREAD_PRIO_", 16, newSViv(_SC_THREAD_PRIO_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PRIO_";
#endif
#ifdef _SC_THREAD_PRIO_INHERIT
(void)hv_store(sc_table, "_SC_THREAD_PRIO_INHERIT", 23, newSViv(_SC_THREAD_PRIO_INHERIT), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PRIO_INHERIT";
#endif
#ifdef _SC_THREAD_PRIO_PROTECT
(void)hv_store(sc_table, "_SC_THREAD_PRIO_PROTECT", 23, newSViv(_SC_THREAD_PRIO_PROTECT), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PRIO_PROTECT";
#endif
#ifdef _SC_THREAD_PROCESS_
(void)hv_store(sc_table, "_SC_THREAD_PROCESS_", 19, newSViv(_SC_THREAD_PROCESS_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PROCESS_";
#endif
#ifdef _SC_THREAD_PROCESS_SHARED
(void)hv_store(sc_table, "_SC_THREAD_PROCESS_SHARED", 25, newSViv(_SC_THREAD_PROCESS_SHARED), 0);
#else
missing[nr_missing++] = "_SC_THREAD_PROCESS_SHARED";
#endif
#ifdef _SC_THREAD_ROBUST_PRIO_INHERIT
(void)hv_store(sc_table, "_SC_THREAD_ROBUST_PRIO_INHERIT", 30, newSViv(_SC_THREAD_ROBUST_PRIO_INHERIT), 0);
#else
missing[nr_missing++] = "_SC_THREAD_ROBUST_PRIO_INHERIT";
#endif
#ifdef _SC_THREAD_ROBUST_PRIO_PROTECT
(void)hv_store(sc_table, "_SC_THREAD_ROBUST_PRIO_PROTECT", 30, newSViv(_SC_THREAD_ROBUST_PRIO_PROTECT), 0);
#else
missing[nr_missing++] = "_SC_THREAD_ROBUST_PRIO_PROTECT";
#endif
#ifdef _SC_THREAD_SAFE_
(void)hv_store(sc_table, "_SC_THREAD_SAFE_", 16, newSViv(_SC_THREAD_SAFE_), 0);
#else
missing[nr_missing++] = "_SC_THREAD_SAFE_";
#endif
#ifdef _SC_THREAD_SAFE_FUNCTIONS
(void)hv_store(sc_table, "_SC_THREAD_SAFE_FUNCTIONS", 25, newSViv(_SC_THREAD_SAFE_FUNCTIONS), 0);
#else
missing[nr_missing++] = "_SC_THREAD_SAFE_FUNCTIONS";
#endif
#ifdef _SC_THREAD_SPORADIC_SERVER
(void)hv_store(sc_table, "_SC_THREAD_SPORADIC_SERVER", 26, newSViv(_SC_THREAD_SPORADIC_SERVER), 0);
#else
missing[nr_missing++] = "_SC_THREAD_SPORADIC_SERVER";
#endif
#ifdef _SC_THREAD_STACK_MIN
(void)hv_store(sc_table, "_SC_THREAD_STACK_MIN", 20, newSViv(_SC_THREAD_STACK_MIN), 0);
#else
missing[nr_missing++] = "_SC_THREAD_STACK_MIN";
#endif
#ifdef _SC_THREAD_THREADS_MAX
(void)hv_store(sc_table, "_SC_THREAD_THREADS_MAX", 22, newSViv(_SC_THREAD_THREADS_MAX), 0);
#else
missing[nr_missing++] = "_SC_THREAD_THREADS_MAX";
#endif
#ifdef _SC_TIMEOUTS
(void)hv_store(sc_table, "_SC_TIMEOUTS", 12, newSViv(_SC_TIMEOUTS), 0);
#else
missing[nr_missing++] = "_SC_TIMEOUTS";
#endif
#ifdef _SC_TIMERS
(void)hv_store(sc_table, "_SC_TIMERS", 10, newSViv(_SC_TIMERS), 0);
#else
missing[nr_missing++] = "_SC_TIMERS";
#endif
#ifdef _SC_TIMER_MAX
(void)hv_store(sc_table, "_SC_TIMER_MAX", 13, newSViv(_SC_TIMER_MAX), 0);
#else
missing[nr_missing++] = "_SC_TIMER_MAX";
#endif
#ifdef _SC_TRACE
(void)hv_store(sc_table, "_SC_TRACE", 9, newSViv(_SC_TRACE), 0);
#else
missing[nr_missing++] = "_SC_TRACE";
#endif
#ifdef _SC_TRACE_EVENT_FILTER
(void)hv_store(sc_table, "_SC_TRACE_EVENT_FILTER", 22, newSViv(_SC_TRACE_EVENT_FILTER), 0);
#else
missing[nr_missing++] = "_SC_TRACE_EVENT_FILTER";
#endif
#ifdef _SC_TRACE_EVENT_NAME_MAX
(void)hv_store(sc_table, "_SC_TRACE_EVENT_NAME_MAX", 24, newSViv(_SC_TRACE_EVENT_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_TRACE_EVENT_NAME_MAX";
#endif
#ifdef _SC_TRACE_INHERIT
(void)hv_store(sc_table, "_SC_TRACE_INHERIT", 17, newSViv(_SC_TRACE_INHERIT), 0);
#else
missing[nr_missing++] = "_SC_TRACE_INHERIT";
#endif
#ifdef _SC_TRACE_LOG
(void)hv_store(sc_table, "_SC_TRACE_LOG", 13, newSViv(_SC_TRACE_LOG), 0);
#else
missing[nr_missing++] = "_SC_TRACE_LOG";
#endif
#ifdef _SC_TRACE_NAME_MAX
(void)hv_store(sc_table, "_SC_TRACE_NAME_MAX", 18, newSViv(_SC_TRACE_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_TRACE_NAME_MAX";
#endif
#ifdef _SC_TRACE_SYS_MAX
(void)hv_store(sc_table, "_SC_TRACE_SYS_MAX", 17, newSViv(_SC_TRACE_SYS_MAX), 0);
#else
missing[nr_missing++] = "_SC_TRACE_SYS_MAX";
#endif
#ifdef _SC_TRACE_USER_EVENT_MAX
(void)hv_store(sc_table, "_SC_TRACE_USER_EVENT_MAX", 24, newSViv(_SC_TRACE_USER_EVENT_MAX), 0);
#else
missing[nr_missing++] = "_SC_TRACE_USER_EVENT_MAX";
#endif
#ifdef _SC_TTY_NAME_MAX
(void)hv_store(sc_table, "_SC_TTY_NAME_MAX", 16, newSViv(_SC_TTY_NAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_TTY_NAME_MAX";
#endif
#ifdef _SC_TYPED_MEMORY_OBJECTS
(void)hv_store(sc_table, "_SC_TYPED_MEMORY_OBJECTS", 24, newSViv(_SC_TYPED_MEMORY_OBJECTS), 0);
#else
missing[nr_missing++] = "_SC_TYPED_MEMORY_OBJECTS";
#endif
#ifdef _SC_TZNAME_MAX
(void)hv_store(sc_table, "_SC_TZNAME_MAX", 14, newSViv(_SC_TZNAME_MAX), 0);
#else
missing[nr_missing++] = "_SC_TZNAME_MAX";
#endif
#ifdef _SC_T_IOV_MAX
(void)hv_store(sc_table, "_SC_T_IOV_MAX", 13, newSViv(_SC_T_IOV_MAX), 0);
#else
missing[nr_missing++] = "_SC_T_IOV_MAX";
#endif
#ifdef _SC_UCHAR_MAX
(void)hv_store(sc_table, "_SC_UCHAR_MAX", 13, newSViv(_SC_UCHAR_MAX), 0);
#else
missing[nr_missing++] = "_SC_UCHAR_MAX";
#endif
#ifdef _SC_UINT_MAX
(void)hv_store(sc_table, "_SC_UINT_MAX", 12, newSViv(_SC_UINT_MAX), 0);
#else
missing[nr_missing++] = "_SC_UINT_MAX";
#endif
#ifdef _SC_UIO_MAXIOV
(void)hv_store(sc_table, "_SC_UIO_MAXIOV", 14, newSViv(_SC_UIO_MAXIOV), 0);
#else
missing[nr_missing++] = "_SC_UIO_MAXIOV";
#endif
#ifdef _SC_ULONG_MAX
(void)hv_store(sc_table, "_SC_ULONG_MAX", 13, newSViv(_SC_ULONG_MAX), 0);
#else
missing[nr_missing++] = "_SC_ULONG_MAX";
#endif
#ifdef _SC_USER_GROUPS
(void)hv_store(sc_table, "_SC_USER_GROUPS", 15, newSViv(_SC_USER_GROUPS), 0);
#else
missing[nr_missing++] = "_SC_USER_GROUPS";
#endif
#ifdef _SC_USER_GROUPS_R
(void)hv_store(sc_table, "_SC_USER_GROUPS_R", 17, newSViv(_SC_USER_GROUPS_R), 0);
#else
missing[nr_missing++] = "_SC_USER_GROUPS_R";
#endif
#ifdef _SC_USHRT_MAX
(void)hv_store(sc_table, "_SC_USHRT_MAX", 13, newSViv(_SC_USHRT_MAX), 0);
#else
missing[nr_missing++] = "_SC_USHRT_MAX";
#endif
#ifdef _SC_V6_ILP32_OFF32
(void)hv_store(sc_table, "_SC_V6_ILP32_OFF32", 18, newSViv(_SC_V6_ILP32_OFF32), 0);
#else
missing[nr_missing++] = "_SC_V6_ILP32_OFF32";
#endif
#ifdef _SC_V6_ILP32_OFFBIG
(void)hv_store(sc_table, "_SC_V6_ILP32_OFFBIG", 19, newSViv(_SC_V6_ILP32_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_V6_ILP32_OFFBIG";
#endif
#ifdef _SC_V6_LP64_OFF64
(void)hv_store(sc_table, "_SC_V6_LP64_OFF64", 17, newSViv(_SC_V6_LP64_OFF64), 0);
#else
missing[nr_missing++] = "_SC_V6_LP64_OFF64";
#endif
#ifdef _SC_V6_LPBIG_OFFBIG
(void)hv_store(sc_table, "_SC_V6_LPBIG_OFFBIG", 19, newSViv(_SC_V6_LPBIG_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_V6_LPBIG_OFFBIG";
#endif
#ifdef _SC_V7_ILP32_OFF32
(void)hv_store(sc_table, "_SC_V7_ILP32_OFF32", 18, newSViv(_SC_V7_ILP32_OFF32), 0);
#else
missing[nr_missing++] = "_SC_V7_ILP32_OFF32";
#endif
#ifdef _SC_V7_ILP32_OFFBIG
(void)hv_store(sc_table, "_SC_V7_ILP32_OFFBIG", 19, newSViv(_SC_V7_ILP32_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_V7_ILP32_OFFBIG";
#endif
#ifdef _SC_V7_LP64_OFF64
(void)hv_store(sc_table, "_SC_V7_LP64_OFF64", 17, newSViv(_SC_V7_LP64_OFF64), 0);
#else
missing[nr_missing++] = "_SC_V7_LP64_OFF64";
#endif
#ifdef _SC_V7_LPBIG_OFFBIG
(void)hv_store(sc_table, "_SC_V7_LPBIG_OFFBIG", 19, newSViv(_SC_V7_LPBIG_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_V7_LPBIG_OFFBIG";
#endif
#ifdef _SC_VERSION
(void)hv_store(sc_table, "_SC_VERSION", 11, newSViv(_SC_VERSION), 0);
#else
missing[nr_missing++] = "_SC_VERSION";
#endif
#ifdef _SC_WORD_BIT
(void)hv_store(sc_table, "_SC_WORD_BIT", 12, newSViv(_SC_WORD_BIT), 0);
#else
missing[nr_missing++] = "_SC_WORD_BIT";
#endif
#ifdef _SC_XBS5_ILP32_OFF32
(void)hv_store(sc_table, "_SC_XBS5_ILP32_OFF32", 20, newSViv(_SC_XBS5_ILP32_OFF32), 0);
#else
missing[nr_missing++] = "_SC_XBS5_ILP32_OFF32";
#endif
#ifdef _SC_XBS5_ILP32_OFFBIG
(void)hv_store(sc_table, "_SC_XBS5_ILP32_OFFBIG", 21, newSViv(_SC_XBS5_ILP32_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_XBS5_ILP32_OFFBIG";
#endif
#ifdef _SC_XBS5_LP64_OFF64
(void)hv_store(sc_table, "_SC_XBS5_LP64_OFF64", 19, newSViv(_SC_XBS5_LP64_OFF64), 0);
#else
missing[nr_missing++] = "_SC_XBS5_LP64_OFF64";
#endif
#ifdef _SC_XBS5_LPBIG_OFFBIG
(void)hv_store(sc_table, "_SC_XBS5_LPBIG_OFFBIG", 21, newSViv(_SC_XBS5_LPBIG_OFFBIG), 0);
#else
missing[nr_missing++] = "_SC_XBS5_LPBIG_OFFBIG";
#endif
#ifdef _SC_XOPEN_CRYPT
(void)hv_store(sc_table, "_SC_XOPEN_CRYPT", 15, newSViv(_SC_XOPEN_CRYPT), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_CRYPT";
#endif
#ifdef _SC_XOPEN_ENH_I18N
(void)hv_store(sc_table, "_SC_XOPEN_ENH_I18N", 18, newSViv(_SC_XOPEN_ENH_I18N), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_ENH_I18N";
#endif
#ifdef _SC_XOPEN_LEGACY
(void)hv_store(sc_table, "_SC_XOPEN_LEGACY", 16, newSViv(_SC_XOPEN_LEGACY), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_LEGACY";
#endif
#ifdef _SC_XOPEN_REALTIME
(void)hv_store(sc_table, "_SC_XOPEN_REALTIME", 18, newSViv(_SC_XOPEN_REALTIME), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_REALTIME";
#endif
#ifdef _SC_XOPEN_REALTIME_
(void)hv_store(sc_table, "_SC_XOPEN_REALTIME_", 19, newSViv(_SC_XOPEN_REALTIME_), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_REALTIME_";
#endif
#ifdef _SC_XOPEN_REALTIME_THREADS
(void)hv_store(sc_table, "_SC_XOPEN_REALTIME_THREADS", 26, newSViv(_SC_XOPEN_REALTIME_THREADS), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_REALTIME_THREADS";
#endif
#ifdef _SC_XOPEN_SHM
(void)hv_store(sc_table, "_SC_XOPEN_SHM", 13, newSViv(_SC_XOPEN_SHM), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_SHM";
#endif
#ifdef _SC_XOPEN_STREAMS
(void)hv_store(sc_table, "_SC_XOPEN_STREAMS", 17, newSViv(_SC_XOPEN_STREAMS), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_STREAMS";
#endif
#ifdef _SC_XOPEN_UNIX
(void)hv_store(sc_table, "_SC_XOPEN_UNIX", 14, newSViv(_SC_XOPEN_UNIX), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_UNIX";
#endif
#ifdef _SC_XOPEN_VERSION
(void)hv_store(sc_table, "_SC_XOPEN_VERSION", 17, newSViv(_SC_XOPEN_VERSION), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_VERSION";
#endif
#ifdef _SC_XOPEN_XCU_VERSION
(void)hv_store(sc_table, "_SC_XOPEN_XCU_VERSION", 21, newSViv(_SC_XOPEN_XCU_VERSION), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_XCU_VERSION";
#endif
#ifdef _SC_XOPEN_XPG
(void)hv_store(sc_table, "_SC_XOPEN_XPG", 13, newSViv(_SC_XOPEN_XPG), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_XPG";
#endif
#ifdef _SC_XOPEN_XPG2
(void)hv_store(sc_table, "_SC_XOPEN_XPG2", 14, newSViv(_SC_XOPEN_XPG2), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_XPG2";
#endif
#ifdef _SC_XOPEN_XPG3
(void)hv_store(sc_table, "_SC_XOPEN_XPG3", 14, newSViv(_SC_XOPEN_XPG3), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_XPG3";
#endif
#ifdef _SC_XOPEN_XPG4
(void)hv_store(sc_table, "_SC_XOPEN_XPG4", 14, newSViv(_SC_XOPEN_XPG4), 0);
#else
missing[nr_missing++] = "_SC_XOPEN_XPG4";
#endif