home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / src / amiga / libg++-2.6.2-src.lha / libg++-2.6.2 / libio / gen-params < prev    next >
Encoding:
Text File  |  1994-12-18  |  19.2 KB  |  639 lines
  1. #!/bin/sh
  2. # Copyright (C) 1992, 1993, 1994 Free Software Foundation
  3. # 
  4. # This file is part of the GNU IO Library.  This library is free
  5. # software; you can redistribute it and/or modify it under the
  6. # terms of the GNU General Public License as published by the
  7. # Free Software Foundation; either version 2, or (at your option)
  8. # any later version.
  9. # 
  10. # This library is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. # 
  15. # You should have received a copy of the GNU General Public License
  16. # along with GNU CC; see the file COPYING.  If not, write to
  17. # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. #    Written by Per Bothner (bothner@cygnus.com)
  20.  
  21. # This is a shell-script that figures out various things about a
  22. # system, and writes (to stdout) a C-style include files with
  23. # suitable definitions, including all the standard Posix types.
  24. # It works by compiling various test programs -- some are run through
  25. # the C pre-processor, and the output examined.
  26. # The test programs are only compiled, not executed, so the script
  27. # should even if you're cross-compiling.
  28. # It uses $CC (which defaults to cc) to compile C programs (extension .c),
  29. # and $CXX (which defaults to gcc) to compile C++ programs (extension .C).
  30. # The shell-script is written for libg++.a.
  31.  
  32. # Usage: gen-params [NAME1=name1 ...]
  33. # - where an assignment (such as size_t="unsigned int" means to
  34. # use that value, instead of trying to figure it out.
  35.  
  36. # Uncomment following line for debugging
  37. # set -x
  38.  
  39. SED=sed
  40.  
  41. # Evaluate the arguments (which should be assignments):
  42. for arg in "$@"; do
  43.   # Quote arg (i.e. FOO=bar => FOO='bar'), then eval it.
  44.   eval `echo "$arg" | ${SED} -e "s|^\(.*\)=\(.*\)|\1='\2'|"`
  45. done
  46.  
  47. macro_prefix=${macro_prefix-"_G_"}
  48. rootdir=`pwd`/..
  49. gccdir=${gccdir-${rootdir}/gcc}
  50. binutilsdir=${binutilsdir-${rootdir}/binutils}
  51. CC=${CC-`if [ -f ${gccdir}/xgcc ] ; \
  52.     then echo ${gccdir}/xgcc -B${gccdir}/ ; \
  53.     else echo gcc ; fi`}
  54. CXX=${CXX-`if [ -f ${gccdir}/xgcc ] ; \
  55.     then echo ${gccdir}/xgcc -B${gccdir}/ ; \
  56.     else echo gcc ; fi`}
  57. CPP=${CPP-`echo ${CC} -E`}
  58. CONFIG_NM=${CONFIG_NM-`if [ -f ${binutilsdir}/nm.new ] ; \
  59.     then echo ${binutilsdir}/nm.new ; \
  60.     else echo nm ; fi`}
  61.  
  62. cat <<!EOF!
  63. /* AUTOMATICALLY GENERATED; DO NOT EDIT! */ 
  64. #ifndef ${macro_prefix}config_h
  65. #define ${macro_prefix}config_h
  66. !EOF!
  67.  
  68. if [ x"${LIB_VERSION}" != "x" ] ; then
  69.   echo "#define ${macro_prefix}LIB_VERSION" '"'${LIB_VERSION}'"'
  70. fi
  71.  
  72. # This program is used to test if the compiler prepends '_' before identifiers.
  73. # It is also used to check the g++ uses '$' or '.' various places.
  74.  
  75. if test -z "${NAMES_HAVE_UNDERSCORE}" -o -z "${DOLLAR_IN_LABEL}" \
  76.     -o -z "${VTABLE_LABEL_PREFIX}"; then
  77.   cat >dummy.h <<!EOF!
  78. #ifdef __GNUG__
  79. #pragma interface
  80. #endif
  81.   struct filebuf {
  82.       virtual int foo();
  83.   };
  84. !EOF!
  85.   cat >dummy.C <<!EOF!
  86. #ifdef __GNUG__
  87. #pragma implementation
  88. #endif
  89. #include "dummy.h"
  90.   int filebuf::foo() { return 0; }
  91.   extern "C" int FUNC(int);
  92.   int FUNC(int i) { return i+10; }
  93. !EOF!
  94.  
  95.   if ${CXX} -O -c dummy.C ; then
  96.     if test -z "${NAMES_HAVE_UNDERSCORE}" ; then
  97.       if test "`${CONFIG_NM} dummy.o | grep _FUNC`" != ""; then
  98.         NAMES_HAVE_UNDERSCORE=1
  99.       elif test "`${CONFIG_NM} dummy.o | grep FUNC`" != ""; then
  100.         NAMES_HAVE_UNDERSCORE=0
  101.       else
  102.         echo "${CONFIG_NM} failed to find FUNC in dummy.o!" 1>&2; exit -1;
  103.       fi
  104.     fi
  105.     echo "#define ${macro_prefix}NAMES_HAVE_UNDERSCORE ${NAMES_HAVE_UNDERSCORE}"
  106.  
  107.     if test -z "${VTABLE_LABEL_PREFIX}" ; then
  108.       # Determine how virtual function tables are named.  This is fragile,
  109.       # because different nm's produce output in different formats.
  110.       ${CONFIG_NM} dummy.o >TMP
  111.       # First we look for a pattern that matches historical output from g++.
  112.       # We surround the actual label name by <> to separate it from
  113.       # other nm junk. 
  114.       ${SED} -n -e 's/_*vt[$_.]7*filebuf/<&>/p' <TMP >dummy.out
  115.       # For paranoia's sake (e.g. if we're using some other C++ compiler)
  116.       # we try a more general pattern, and append the result.
  117.       grep -v foo <TMP \
  118.     | ${SED} -n -e 's/[a-zA-Z0-9_.$]*filebuf[a-zA-Z0-9_.$]*/<&>/p' \
  119.     >>dummy.out
  120.       # Now we get rid of the <>, and any other junk on the nm output line.
  121.       # (We get rid of <filebuf> in case nm included debugging output for
  122.       # class filebuf itself.)  Finally, we select the first line of
  123.       # the result, and hope that's what we wanted!
  124.       vtab_name=`${SED} -n -e '/<filebuf>/d' -e 's/^.*<\(.*\)>.*$/\1/p' \
  125.         <dummy.out | ${SED} -n -e '1p'`
  126.       case "${vtab_name}" in
  127.         *7filebuf) echo "#define ${macro_prefix}VTABLE_LABEL_HAS_LENGTH 1" ;;
  128.         *) echo "#define ${macro_prefix}VTABLE_LABEL_HAS_LENGTH 0" ;;
  129.       esac
  130.       VTABLE_LABEL_PREFIX=`echo $vtab_name | sed -e 's/7*filebuf//'`
  131.     fi
  132.     echo "#define ${macro_prefix}VTABLE_LABEL_PREFIX" '"'"${VTABLE_LABEL_PREFIX}"'"'
  133.     if [ "${VTABLE_LABEL_PREFIX}" = "__vt_" -o \
  134.         "${VTABLE_LABEL_PREFIX}" = "___vt_" ] ; then
  135.       echo "#define ${macro_prefix}USING_THUNKS"
  136.     fi
  137.  
  138.     # VTABLE_LABEL_PREFIX_ID is the same as VTABLE_LABEL_PREFIX,
  139.     # but the former is a C identifier, while the latter is a quoted
  140.     # st
  141.     if [ -z ""`echo ${VTABLE_LABEL_PREFIX} | sed -e 's/[a-zA-Z0-9_]//g'` ] ; then
  142.       if [ "${NAMES_HAVE_UNDERSCORE}" = "1" ] ; then
  143.     VTABLE_LABEL_PREFIX=`echo ${VTABLE_LABEL_PREFIX} | sed -e 's/^_//'`
  144.       fi
  145.       echo "#define ${macro_prefix}VTABLE_LABEL_PREFIX_ID ${VTABLE_LABEL_PREFIX}"
  146.     fi
  147.  
  148. #    if test -n "${DOLLAR_IN_LABEL}" ; then
  149. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL ${DOLLAR_IN_LABEL}"
  150. #    elif test "`${CONFIG_NM} dummy.o | grep 'vt[$$]7filebuf'`" != ""; then
  151. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 1"
  152. #    elif test "`${CONFIG_NM} dummy.o | grep 'vt[.]7filebuf'`" != ""; then
  153. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 0"
  154. #    elif test "`${CONFIG_NM} dummy.o | grep 'vtbl__7filebuf'`" != ""; then
  155. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 0"
  156. #    else
  157. #      echo "gen-params: ${CONFIG_NM} failed to find vt[.\$]filebuf in dummy.o!" 1>&2; exit 1
  158. #    fi
  159.   else
  160.     # The compile failed for some reason (no C++?)
  161.     echo "gen-params: could not compile dummy.C with ${CXX}" 1>&2; exit 1;
  162.   fi
  163. fi
  164.  
  165. # A little test program to check if struct stat has st_blksize.
  166. cat >dummy.c <<!EOF!
  167. #include <sys/types.h>
  168. #include <sys/stat.h>
  169. int BLKSIZE(struct stat *st)
  170. {
  171.     return st->st_blksize;
  172. }
  173. !EOF!
  174.  
  175. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  176.   echo "#define ${macro_prefix}HAVE_ST_BLKSIZE 1"
  177. else
  178.   echo "#define ${macro_prefix}HAVE_ST_BLKSIZE 0"
  179. fi
  180.  
  181. # Next, generate definitions for the standard types (such as mode_t)
  182. # compatible with those in the standard C header files.
  183. # It works by a dummy program through the C pre-processor, and then
  184. # using sed to search for typedefs in the output.
  185.  
  186. for hdr in wchar wctype; do
  187.   eval $hdr=0
  188.   cat >dummy.c <<EOF
  189. #include <${hdr}.h>
  190. EOF
  191.   if ${CPP} dummy.c >/dev/null 2>&1 ; then eval $hdr=1; fi
  192. done
  193.  
  194. cat >dummy.c <<!EOF!
  195. #include <sys/types.h>
  196. #include <stddef.h>
  197. #include <stdarg.h>
  198. #include <stdio.h>
  199. #include <time.h>
  200. #include <signal.h>
  201. #ifdef __STDC__
  202. #include <limits.h>
  203. #endif
  204. #if WCHAR == 1
  205. #include <wchar.h>
  206. #endif
  207. #if WCTYPE == 1
  208. #include <wctype.h>
  209. #endif
  210. #ifdef size_t
  211. typedef size_t Xsize_t;
  212. #elif defined(__SIZE_TYPE__)
  213. typedef __SIZE_TYPE__ Xsize_t;
  214. #endif
  215. #ifdef ptrdiff_t
  216. typedef ptrdiff_t Xptrdiff_t;
  217. #elif defined(__PTRDIFF_TYPE__)
  218. typedef __PTRDIFF_TYPE__ Xptrdiff_t;
  219. #endif
  220. #ifdef wchar_t
  221. typedef wchar_t Xwchar_t;
  222. #elif defined(__WCHAR_TYPE__)
  223. typedef __WCHAR_TYPE__ Xwchar_t;
  224. #endif
  225. #ifdef va_list
  226. typedef va_list XXXva_list;
  227. #endif
  228. #ifdef BUFSIZ
  229. long XBUFSIZ=BUFSIZ;
  230. #endif
  231. #ifdef FOPEN_MAX
  232. long XFOPEN_MAX=FOPEN_MAX;
  233. #endif
  234. #ifdef FILENAME_MAX
  235. long XFILENAME_MAX=FILENAME_MAX;
  236. #endif
  237. #ifdef SHRT_MAX
  238. long XSHRT_MAX=SHRT_MAX;
  239. #endif
  240. #ifdef INT_MAX
  241. long XINT_MAX=INT_MAX;
  242. #endif
  243. #ifdef LONG_MAX
  244. long XLONG_MAX=LONG_MAX;
  245. #endif
  246. #ifdef LONG_LONG_MAX
  247. long XLONG_LONG_MAX=LONG_LONG_MAX;
  248. #endif
  249. !EOF!
  250.  
  251. if ${CPP} dummy.c -DWCHAR=$wchar -DWCTYPE=$wctype >TMP ; then true
  252. else
  253.   echo "gen-params: could not invoke ${CPP} on dummy.c" 1>&2 ; exit 1
  254. fi
  255. tr '    ' ' ' <TMP >dummy.out
  256.  
  257. for TYPE in dev_t clock_t fpos_t gid_t ino_t mode_t nlink_t off_t pid_t ptrdiff_t sigset_t size_t ssize_t time_t uid_t va_list wchar_t wint_t int8_t uint8_t int16_t uint16_t int32_t uint_32_t int64_t uint64_t; do
  258.     IMPORTED=`eval 'echo $'"$TYPE"`
  259.     if [ -n "${IMPORTED}" ] ; then
  260.     eval "$TYPE='$IMPORTED"
  261.     else
  262.     # Search dummy.out for a typedef for $TYPE, and write it out
  263.     # to TMP in #define syntax.
  264.     rm -f TMP
  265.     ${SED} -n -e "s|.*typedef  *\(.*\) X*$TYPE *;.*|\1|w TMP" \
  266.       <dummy.out>/dev/null
  267.     # Now select the first definition.
  268.         if [ -s TMP ]; then
  269.         # VALUE is now the typedef'd definition of $TYPE.
  270.             eval "VALUE='`${SED} -e 's| *$||' -e '2,$d' <TMP`'"
  271.         # Unless VALUE contains a blank, look for a typedef for it
  272.         # in turn (this could be a loop, but that would be over-kill).
  273.         if echo $VALUE | grep " " >/dev/null ; then true
  274.         else
  275.         rm -f TMP
  276.         ${SED} -n -e "s|.*typedef[     ][     ]*\(.*[^a-zA-Z0-9_]\)${VALUE}[     ]*;.*|\1|w TMP" <dummy.out>/dev/null
  277.         if [ -s TMP ]; then
  278.             eval "VALUE='`${SED} -e '2,$d' -e 's|[     ]*$||' <TMP`'"
  279.         fi
  280.         fi
  281.         eval "$TYPE='$VALUE'"
  282.     fi
  283.     fi
  284. done
  285.  
  286. cat <<!EOF!
  287. typedef ${clock_t-int /* default */} ${macro_prefix}clock_t;
  288. typedef ${dev_t-int /* default */} ${macro_prefix}dev_t;
  289. typedef ${fpos_t-long /* default */} ${macro_prefix}fpos_t;
  290. typedef ${gid_t-int /* default */} ${macro_prefix}gid_t;
  291. typedef ${ino_t-int /* default */} ${macro_prefix}ino_t;
  292. typedef ${mode_t-int /* default */} ${macro_prefix}mode_t;
  293. typedef ${nlink_t-int /* default */} ${macro_prefix}nlink_t;
  294. typedef ${off_t-long /* default */} ${macro_prefix}off_t;
  295. typedef ${pid_t-int /* default */} ${macro_prefix}pid_t;
  296. #ifndef __PTRDIFF_TYPE__
  297. #define __PTRDIFF_TYPE__ ${ptrdiff_t-long int /* default */}
  298. #endif
  299. typedef __PTRDIFF_TYPE__ ${macro_prefix}ptrdiff_t;
  300. typedef ${sigset_t-int /* default */} ${macro_prefix}sigset_t;
  301. #ifndef __SIZE_TYPE__
  302. #define __SIZE_TYPE__ ${size_t-unsigned long /* default */}
  303. #endif
  304. typedef __SIZE_TYPE__ ${macro_prefix}size_t;
  305. typedef ${time_t-int /* default */} ${macro_prefix}time_t;
  306. typedef ${uid_t-int /* default */} ${macro_prefix}uid_t;
  307. #ifndef __WCHAR_TYPE__
  308. #define __WCHAR_TYPE__ ${wchar_t-int /* default */}
  309. #endif
  310. typedef __WCHAR_TYPE__ ${macro_prefix}wchar_t;
  311. !EOF!
  312.  
  313.  
  314. # ssize_t is the signed version of size_t
  315. if [ -n "${ssize_t}" ] ; then
  316.     echo "typedef ${ssize_t} ${macro_prefix}ssize_t;"
  317. elif [ -z "${size_t}" ] ; then
  318.     echo "typedef long ${macro_prefix}ssize_t;"
  319. else
  320.     # Remove "unsigned" from ${size_t} to get ${ssize_t}.
  321.     tmp="`echo ${size_t} | ${SED} -e 's|unsigned||g' -e 's|  | |g'`"
  322.     if [ -z "$tmp" ] ; then
  323.     tmp=int
  324.     else
  325.     # check $tmp doesn't conflict with <unistd.h>
  326.     echo "#include <unistd.h>
  327.     extern $tmp read();" >dummy.c
  328.     ${CC} -c dummy.c >/dev/null 2>&1 || tmp=int
  329.     fi
  330.     echo "typedef $tmp /* default */ ${macro_prefix}ssize_t;"
  331. fi
  332.  
  333. # wint_t is often the integral type to which wchar_t promotes.
  334. if [ -n "${wint_t}" ] ; then
  335.   echo "typedef ${wint_t} ${macro_prefix}wint_t;"
  336. else
  337.   for TYPE in int 'unsigned int' 'long int' 'long unsigned int'; do
  338.     cat >dummy.C <<!EOF!
  339. #ifndef __WCHAR_TYPE__
  340. #define __WCHAR_TYPE__ ${wchar_t-int /* default */}
  341. #endif
  342. typedef __WCHAR_TYPE__ ${macro_prefix}wchar_t;
  343. void foo ($TYPE);
  344. void foo (double);
  345. void bar (${macro_prefix}wchar_t w)
  346. {
  347.   foo (w);
  348. }
  349. !EOF!
  350.     if ${CXX} -c dummy.C >/dev/null 2>&1 ; then  
  351.       echo "typedef $TYPE /* default */ ${macro_prefix}wint_t;"
  352.       break
  353.     fi
  354.   done
  355. fi
  356.  
  357. # va_list can cause problems (e.g. some systems have va_list as a struct).
  358. # Check to see if ${va_list-char*} really is compatible with stdarg.h.
  359. cat >dummy.C <<!EOF!
  360. #define X_va_list ${va_list-char* /* default */}
  361. extern long foo(X_va_list ap); /* Check that X_va_list compiles on its own */
  362. extern "C" {
  363. #include <stdarg.h>
  364. }
  365. long foo(X_va_list ap) { return va_arg(ap, long); }
  366. long bar(int i, ...)
  367. { va_list ap; long j; va_start(ap, i); j = foo(ap); va_end(ap); return j; }
  368. !EOF!
  369. if ${CXX} -c dummy.C >/dev/null 2>&1 ; then
  370.   # Ok: We have something that works.
  371.   echo "typedef ${va_list-char* /* default */} ${macro_prefix}va_list;"
  372. else
  373.   # No, it breaks.  Indicate that <stdarg.h> must be included.
  374.   echo "#define ${macro_prefix}NEED_STDARG_H
  375. #define ${macro_prefix}va_list va_list"
  376. fi
  377.  
  378. cat >dummy.c <<!EOF!
  379. #include <signal.h>
  380. extern int (*signal())();
  381. extern int dummy (int);
  382. main()
  383. {
  384.     int (*oldsig)(int) = signal (1, dummy);
  385.     (void) signal (2, oldsig);
  386.     return 0;
  387. }
  388. !EOF!
  389. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  390.   echo "#define ${macro_prefix}signal_return_type int"
  391. else
  392.   echo "#define ${macro_prefix}signal_return_type void"
  393. fi
  394.  
  395. # check sprintf return type
  396.  
  397. cat >dummy.c <<!EOF!
  398. #include <stdio.h>
  399. extern int sprintf(); char buf[100];
  400. int main() { return sprintf(buf, "%d", 34); }
  401. !EOF!
  402. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  403.   echo "#define ${macro_prefix}sprintf_return_type int"
  404. else
  405.   echo "#define ${macro_prefix}sprintf_return_type char*"
  406. fi
  407.  
  408. # Look for some standard macros.
  409. for NAME in BUFSIZ FOPEN_MAX FILENAME_MAX NULL; do
  410.     IMPORTED=`eval 'echo $'"$NAME"`
  411.     if [ -n "${IMPORTED}" ] ; then
  412.     eval "$NAME='$IMPORTED /* specified */"
  413.     else
  414.     rm -f TMP
  415.     ${SED} -n -e 's| *;|;|g' -e "s|long X${NAME}= *\(.*\);|\1|w TMP" \
  416.       <dummy.out>/dev/null
  417.     # Now select the first definition.
  418.     if [ -s TMP ]; then
  419.         eval "$NAME='"`${SED} -e '2,$d' <TMP`"'"
  420.     fi
  421.     fi
  422. done
  423.  
  424. # These macros must be numerical constants; strip any trailing 'L's.
  425. for NAME in SHRT_MAX INT_MAX LONG_MAX LONG_LONG_MAX; do
  426.     IMPORTED=`eval 'echo $'"$NAME"`
  427.     if [ -n "${IMPORTED}" ] ; then
  428.     eval "$NAME='$IMPORTED /* specified */"
  429.     else
  430.     rm -f TMP
  431.     ${SED} -n -e 's| *;|;|g' -e "s|long X${NAME}= *\([0-9]*\)L* *;|\1|w TMP" \
  432.       <dummy.out>/dev/null
  433.     # Now select the first definition.
  434.     if [ -s TMP ]; then
  435.         eval "$NAME='"`${SED} -e '2,$d' <TMP`"'"
  436.     fi
  437.     fi
  438. done
  439.  
  440. # Figure out integral type sizes.
  441.  
  442. default_int16=
  443. default_int32=
  444. default_int64=
  445. INT16=32767
  446. INT32=2147483647
  447. INT64=9223372036854775807
  448.  
  449. if [ "${SHRT_MAX}" = $INT16 ] ; then
  450.   default_int16=short
  451.   if [ "${LONG_MAX}" = $INT32 ] ; then
  452.     default_int32=long
  453.     if [ "${LONG_LONG_MAX}" = $INT64 ] ; then
  454.       # Most Unices, DOS
  455.       default_int64="long long"
  456.     fi
  457.   elif [ "${INT_MAX}" = $INT32 ] ; then
  458.     default_int32=int
  459.     if [ "${LONG_MAX}" = $INT64 ] ; then
  460.       # Some 64-bit Unices, like OSF/1 on the Alpha
  461.       default_int64=long
  462.     fi
  463.   fi
  464. fi
  465.  
  466. if [ -n "${int64_t-${default_int64}}" ] ; then
  467.   int64_lines="#define HAVE_INT64
  468. typedef ${int64_t-${default_int64}} ${macro_prefix}int64_t;
  469. typedef ${uint64_t-unsigned ${default_int64}} ${macro_prefix}uint64_t;"
  470.   if [ "${default_int64}" = "long long" ] ; then
  471.     int64_lines="#if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(_NO_LONGLONG)
  472. ${int64_lines}
  473. #endif"
  474.   fi
  475. fi
  476.  
  477. cat <<!EOF!
  478. #ifdef __STDC__
  479. typedef ${int8_t-signed char} ${macro_prefix}int8_t;
  480. #endif
  481. typedef ${uint8_t-unsigned char} ${macro_prefix}uint8_t;
  482. typedef ${int16_t-${default_int16-short}} ${macro_prefix}int16_t;
  483. typedef ${uint16_t-unsigned ${default_int16-short}} ${macro_prefix}uint16_t;
  484. typedef ${int32_t-${default_int32-int}} ${macro_prefix}int32_t;
  485. typedef ${uint32_t-unsigned ${default_int32-int}} ${macro_prefix}uint32_t;
  486. ${int64_lines}
  487. #define ${macro_prefix}BUFSIZ ${BUFSIZ-1024 /* default */}
  488. #define ${macro_prefix}FOPEN_MAX ${FOPEN_MAX-32 /* default */}
  489. #define ${macro_prefix}FILENAME_MAX ${FILENAME_MAX-1024 /* default */}
  490. #define ${macro_prefix}NULL ${NULL-0 /* default */}
  491. #if defined (__cplusplus) || defined (__STDC__)
  492. #define ${macro_prefix}ARGS(ARGLIST) ARGLIST
  493. #else
  494. #define ${macro_prefix}ARGS(ARGLIST) ()
  495. #endif
  496. #if !defined (__GNUG__) || defined (__STRICT_ANSI__)
  497. #define ${macro_prefix}NO_NRV
  498. #endif
  499. #if !defined (__GNUG__)
  500. #define _G_NO_EXTERN_TEMPLATES
  501. #endif
  502. !EOF!
  503.  
  504. rm -f dummy.c dummy.o dummy.h
  505.  
  506. if test -n "${HAVE_ATEXIT}" ; then
  507.  echo "#define ${macro_prefix}HAVE_ATEXIT ${HAVE_ATEXIT}"
  508. else
  509.   cat >dummy.c <<!EOF!
  510. #include <stdlib.h>
  511. int main()
  512. {
  513.   atexit (0);
  514. }
  515. !EOF!
  516.   if ${CC} dummy.c >/dev/null 2>&1 ; then
  517.     echo "#define ${macro_prefix}HAVE_ATEXIT 1"
  518.   else
  519.     echo "#define ${macro_prefix}HAVE_ATEXIT 0"
  520.   fi
  521. fi
  522.  
  523.  
  524. # *** Check for presence of certain include files ***
  525.  
  526. # check for sys/resource.h
  527.  
  528. if test -n "${HAVE_SYS_RESOURCE}" ; then
  529.  echo "#define ${macro_prefix}HAVE_SYS_RESOURCE ${HAVE_SYS_RESOURCE}"
  530. else
  531.   cat >dummy.c <<!EOF!
  532. #include <sys/time.h>
  533. #include <sys/resource.h>
  534.   int main()
  535.   {
  536.     struct rusage res;
  537.     getrusage(RUSAGE_SELF, &res);
  538.     return (int)(res.ru_utime.tv_sec + (res.ru_utime.tv_usec / 1000000.0));
  539.   }
  540. !EOF!
  541.   # Note: We link because some systems have sys/resource, but not getrusage().
  542.   if ${CC} dummy.c >/dev/null 2>&1 ; then
  543.     echo "#define ${macro_prefix}HAVE_SYS_RESOURCE 1"
  544.   else
  545.     echo "#define ${macro_prefix}HAVE_SYS_RESOURCE 0"
  546.   fi
  547. fi
  548.  
  549. # check for sys/socket.h
  550.  
  551. if test -n "${HAVE_SYS_SOCKET}" ; then
  552.  echo "#define ${macro_prefix}HAVE_SYS_SOCKET ${HAVE_SYS_SOCKET}"
  553. else
  554.   echo '#include <sys/types.h>' >dummy.c
  555.   echo '#include <sys/socket.h>' >>dummy.c
  556.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  557.     echo "#define ${macro_prefix}HAVE_SYS_SOCKET 1"
  558.   else
  559.     echo "#define ${macro_prefix}HAVE_SYS_SOCKET 0"
  560.   fi
  561. fi
  562.  
  563. # Check for a (Posix-compatible) sys/wait.h */
  564.  
  565. if test -n "${HAVE_SYS_WAIT}" ; then
  566.  echo "#define ${macro_prefix}HAVE_SYS_WAIT ${HAVE_SYS_WAIT}"
  567. else
  568.   cat >dummy.c <<!EOF!
  569. #include <sys/types.h>
  570. #include <sys/wait.h>
  571.   int f() { int i; wait(&i); return i; }
  572. !EOF!
  573.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  574.     echo "#define ${macro_prefix}HAVE_SYS_WAIT 1"
  575.   else
  576.     echo "#define ${macro_prefix}HAVE_SYS_WAIT 0"
  577.   fi
  578. fi
  579.  
  580. if test -n "${HAVE_UNISTD}" ; then
  581.  echo "#define ${macro_prefix}HAVE_UNISTD ${HAVE_UNISTD}"
  582. else
  583.   echo '#include <unistd.h>' >dummy.c
  584.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  585.     echo "#define ${macro_prefix}HAVE_UNISTD 1"
  586.   else
  587.     echo "#define ${macro_prefix}HAVE_UNISTD 0"
  588.   fi
  589. fi
  590.  
  591. if test -n "${HAVE_DIRENT}" ; then
  592.  echo "#define ${macro_prefix}HAVE_DIRENT ${HAVE_DIRENT}"
  593. else
  594.   echo '#include <sys/types.h>
  595. #include <dirent.h>' >dummy.c
  596.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  597.     echo "#define ${macro_prefix}HAVE_DIRENT 1"
  598.   else
  599.     echo "#define ${macro_prefix}HAVE_DIRENT 0"
  600.   fi
  601. fi
  602.  
  603. if test -n "${HAVE_CURSES}" ; then
  604.  echo "#define ${macro_prefix}HAVE_CURSES ${HAVE_CURSES}"
  605. else
  606.   echo '#include <curses.h>' >dummy.c
  607.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  608.     echo "#define ${macro_prefix}HAVE_CURSES 1"
  609.   else
  610.     echo "#define ${macro_prefix}HAVE_CURSES 0"
  611.   fi
  612. fi
  613.  
  614. # There is no test for this at the moment; it is just set by the
  615. # configuration files.
  616. if test -n "${MATH_H_INLINES}" ; then
  617.   echo "#define ${macro_prefix}MATH_H_INLINES ${MATH_H_INLINES}"
  618. else
  619.   echo "#define ${macro_prefix}MATH_H_INLINES 0"
  620. fi
  621.  
  622. if test -n "${HAVE_BOOL}" ; then
  623.  echo "#define ${macro_prefix}HAVE_BOOL ${HAVE_BOOL}"
  624. else
  625.   echo 'bool i=true,j=false;' >dummy.C
  626.   if ${CXX} -c dummy.C >/dev/null 2>&1 ; then
  627.     echo "#define ${macro_prefix}HAVE_BOOL 1"
  628.   else
  629.     echo "#define ${macro_prefix}HAVE_BOOL 0"
  630.   fi
  631. fi
  632.  
  633. # Uncomment the following line if you don't have working templates.
  634. # echo "#define ${macro_prefix}NO_TEMPLATES"
  635.  
  636. rm -f dummy.C dummy.o dummy.c dummy.out TMP core a.out
  637.  
  638. echo "#endif /* !${macro_prefix}config_h */"
  639.