home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / libg++-2.7.1-base.tgz / libg++-2.7.1-src.tar / fsf / libg++ / libio / gen-params < prev    next >
Text File  |  1995-11-03  |  21KB  |  682 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 this library; see the file COPYING.  If not, write to the Free
  17. # Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 cc ; 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.       if [ -n "`${SED} -n -e 's/ virtual table/nope/p' <TMP`" ] ; then
  112.     ${CONFIG_NM} --no-cplus dummy.o >TMP 2>/dev/null ||
  113.       ${CONFIG_NM} --no-demangle dummy.o >TMP 2>/dev/null ||
  114.       ${CONFIG_NM} dummy.o >TMP 2>/dev/null
  115.       fi
  116.       # First we look for a pattern that matches historical output from g++.
  117.       # We surround the actual label name by <> to separate it from
  118.       # other nm junk. 
  119.       ${SED} -n -e 's/_*vt[$_.]7*filebuf/<&>/p' <TMP >dummy.out
  120.       # For paranoia's sake (e.g. if we're using some other C++ compiler)
  121.       # we try a more general pattern, and append the result.
  122.       grep -v foo <TMP \
  123.     | ${SED} -n -e 's/[a-zA-Z0-9_.$]*filebuf[a-zA-Z0-9_.$]*/<&>/p' \
  124.     >>dummy.out
  125.       # Now we get rid of the <>, and any other junk on the nm output line.
  126.       # (We get rid of <filebuf> in case nm included debugging output for
  127.       # class filebuf itself.)  Finally, we select the first line of
  128.       # the result, and hope that's what we wanted!
  129.       vtab_name=`${SED} -n -e '/<filebuf>/d' -e 's/^.*<\(.*\)>.*$/\1/p' \
  130.         <dummy.out | ${SED} -n -e '1p'`
  131.       case "${vtab_name}" in
  132.         *7filebuf) echo "#define ${macro_prefix}VTABLE_LABEL_HAS_LENGTH 1" ;;
  133.         *) echo "#define ${macro_prefix}VTABLE_LABEL_HAS_LENGTH 0" ;;
  134.       esac
  135.       VTABLE_LABEL_PREFIX=`echo $vtab_name | ${SED} -e 's/7*filebuf//'`
  136.     fi
  137.     echo "#define ${macro_prefix}VTABLE_LABEL_PREFIX" '"'"${VTABLE_LABEL_PREFIX}"'"'
  138.     if [ "${VTABLE_LABEL_PREFIX}" = "__vt_" -o \
  139.         "${VTABLE_LABEL_PREFIX}" = "___vt_" ] ; then
  140.       echo "#define ${macro_prefix}USING_THUNKS"
  141.     fi
  142.  
  143.     # VTABLE_LABEL_PREFIX_ID is the same as VTABLE_LABEL_PREFIX,
  144.     # but the former is a C identifier, while the latter is a quoted
  145.     # st
  146.     if [ -z ""`echo ${VTABLE_LABEL_PREFIX} | ${SED} -e 's/[a-zA-Z0-9_]//g'` ] ; then
  147.       if [ "${NAMES_HAVE_UNDERSCORE}" = "1" ] ; then
  148.     VTABLE_LABEL_PREFIX=`echo ${VTABLE_LABEL_PREFIX} | ${SED} -e 's/^_//'`
  149.       fi
  150.       echo "#define ${macro_prefix}VTABLE_LABEL_PREFIX_ID ${VTABLE_LABEL_PREFIX}"
  151.     fi
  152.  
  153. #    if test -n "${DOLLAR_IN_LABEL}" ; then
  154. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL ${DOLLAR_IN_LABEL}"
  155. #    elif test "`${CONFIG_NM} dummy.o | grep 'vt[$$]7filebuf'`" != ""; then
  156. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 1"
  157. #    elif test "`${CONFIG_NM} dummy.o | grep 'vt[.]7filebuf'`" != ""; then
  158. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 0"
  159. #    elif test "`${CONFIG_NM} dummy.o | grep 'vtbl__7filebuf'`" != ""; then
  160. #      echo "#define ${macro_prefix}DOLLAR_IN_LABEL 0"
  161. #    else
  162. #      echo "gen-params: ${CONFIG_NM} failed to find vt[.\$]filebuf in dummy.o!" 1>&2; exit 1
  163. #    fi
  164.   else
  165.     # The compile failed for some reason (no C++?)
  166.     echo "gen-params: could not compile dummy.C with ${CXX}" 1>&2; exit 1;
  167.   fi
  168. fi
  169.  
  170. # A little test program to check if struct stat has st_blksize.
  171. cat >dummy.c <<!EOF!
  172. #include <sys/types.h>
  173. #include <sys/stat.h>
  174. int BLKSIZE(struct stat *st)
  175. {
  176.     return st->st_blksize;
  177. }
  178. !EOF!
  179.  
  180. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  181.   echo "#define ${macro_prefix}HAVE_ST_BLKSIZE 1"
  182. else
  183.   echo "#define ${macro_prefix}HAVE_ST_BLKSIZE 0"
  184. fi
  185.  
  186. # Next, generate definitions for the standard types (such as mode_t)
  187. # compatible with those in the standard C header files.
  188. # It works by a dummy program through the C pre-processor, and then
  189. # using sed to search for typedefs in the output.
  190.  
  191. for hdr in wchar wctype; do
  192.   eval $hdr=0
  193.   cat >dummy.c <<EOF
  194. #include <${hdr}.h>
  195. EOF
  196.   if ${CPP} dummy.c >/dev/null 2>&1 ; then eval $hdr=1; fi
  197. done
  198.  
  199. cat >dummy.c <<!EOF!
  200. #include <sys/types.h>
  201. #include <stddef.h>
  202. #ifdef __STDC__
  203. #include <stdarg.h>
  204. #else /* !__STDC__ */
  205. #include <varargs.h>
  206. #endif /* __STDC__ */
  207. #include <stdio.h>
  208. #include <time.h>
  209. #include <signal.h>
  210. #ifdef __STDC__
  211. #include <limits.h>
  212. #endif
  213. #if WCHAR == 1
  214. #include <wchar.h>
  215. #endif
  216. #if WCTYPE == 1
  217. #include <wctype.h>
  218. #endif
  219. #ifdef size_t
  220. typedef size_t Xsize_t;
  221. #elif defined(__SIZE_TYPE__)
  222. typedef __SIZE_TYPE__ Xsize_t;
  223. #endif
  224. #ifdef ptrdiff_t
  225. typedef ptrdiff_t Xptrdiff_t;
  226. #elif defined(__PTRDIFF_TYPE__)
  227. typedef __PTRDIFF_TYPE__ Xptrdiff_t;
  228. #endif
  229. #ifdef wchar_t
  230. typedef wchar_t Xwchar_t;
  231. #elif defined(__WCHAR_TYPE__)
  232. typedef __WCHAR_TYPE__ Xwchar_t;
  233. #endif
  234. #ifdef va_list
  235. typedef va_list XXXva_list;
  236. #endif
  237. #ifdef BUFSIZ
  238. long XBUFSIZ=BUFSIZ;
  239. #endif
  240. #ifdef FOPEN_MAX
  241. long XFOPEN_MAX=FOPEN_MAX;
  242. #endif
  243. #ifdef FILENAME_MAX
  244. long XFILENAME_MAX=FILENAME_MAX;
  245. #endif
  246. #ifdef SHRT_MAX
  247. long XSHRT_MAX=SHRT_MAX;
  248. #endif
  249. #ifdef INT_MAX
  250. long XINT_MAX=INT_MAX;
  251. #endif
  252. #ifdef LONG_MAX
  253. long XLONG_MAX=LONG_MAX;
  254. #endif
  255. #ifdef LONG_LONG_MAX
  256. long XLONG_LONG_MAX=LONG_LONG_MAX;
  257. #endif
  258. !EOF!
  259.  
  260. if ${CPP} dummy.c -DWCHAR=$wchar -DWCTYPE=$wctype >TMP ; then true
  261. else
  262.   echo "gen-params: could not invoke ${CPP} on dummy.c" 1>&2 ; exit 1
  263. fi
  264. tr '    ' ' ' <TMP >dummy.out
  265.  
  266. 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 int16_t uint16_t int32_t uint_32_t u_int16_t u_int32_t; do
  267.     IMPORTED=`eval 'echo $'"$TYPE"`
  268.     if [ -n "${IMPORTED}" ] ; then
  269.     eval "$TYPE='$IMPORTED'"
  270.     else
  271.     t=$TYPE
  272.     VALUE=''
  273.  
  274.     # Follow `typedef VALUE TYPE' chains, but don't loop indefinitely.
  275.     for iteration in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
  276.         # Search dummy.out for a typedef for X*$t.
  277.         sed_script="
  278.         /.*typedef  *\\(.*[^ ]\\)  *X*$t *;.*/{s||\1|;p;q;}
  279.         /.*typedef  *\\(.*[^ a-zA-Z0-9_]\\)X*$t *;.*/{s||\1|;p;q;}
  280.         "
  281.         t=`${SED} -n "$sed_script" <dummy.out`
  282.         case "$t" in
  283.           '')
  284.         break;;
  285.           *)
  286.         # Found a type $t; save it in VALUE.
  287.         VALUE=$t
  288.         # If it won't cause problems in matching,
  289.         # look for a typedef for it in turn.
  290.         case "$VALUE" in
  291.           *.* | */* | *\ * | *\** | *\[* | *\\*) break;;
  292.         esac;;
  293.         esac
  294.     done
  295.  
  296.     case "$VALUE" in
  297.       ?*) eval "$TYPE=\"$VALUE\""
  298.     esac
  299.     fi
  300. done
  301.  
  302. cat <<!EOF!
  303. typedef ${clock_t-int /* default */} ${macro_prefix}clock_t;
  304. typedef ${dev_t-int /* default */} ${macro_prefix}dev_t;
  305. typedef ${fpos_t-long /* default */} ${macro_prefix}fpos_t;
  306. typedef ${gid_t-int /* default */} ${macro_prefix}gid_t;
  307. typedef ${ino_t-int /* default */} ${macro_prefix}ino_t;
  308. typedef ${mode_t-int /* default */} ${macro_prefix}mode_t;
  309. typedef ${nlink_t-int /* default */} ${macro_prefix}nlink_t;
  310. typedef ${off_t-long /* default */} ${macro_prefix}off_t;
  311. typedef ${pid_t-int /* default */} ${macro_prefix}pid_t;
  312. #ifndef __PTRDIFF_TYPE__
  313. #define __PTRDIFF_TYPE__ ${ptrdiff_t-long int /* default */}
  314. #endif
  315. typedef __PTRDIFF_TYPE__ ${macro_prefix}ptrdiff_t;
  316. typedef ${sigset_t-int /* default */} ${macro_prefix}sigset_t;
  317. #ifndef __SIZE_TYPE__
  318. #define __SIZE_TYPE__ ${size_t-unsigned long /* default */}
  319. #endif
  320. typedef __SIZE_TYPE__ ${macro_prefix}size_t;
  321. typedef ${time_t-int /* default */} ${macro_prefix}time_t;
  322. typedef ${uid_t-int /* default */} ${macro_prefix}uid_t;
  323. typedef ${wchar_t-int /* default */} ${macro_prefix}wchar_t;
  324. !EOF!
  325.  
  326.  
  327. # ssize_t is the signed version of size_t
  328. if [ -n "${ssize_t}" ] ; then
  329.     echo "typedef ${ssize_t} ${macro_prefix}ssize_t;"
  330. elif [ -z "${size_t}" ] ; then
  331.     echo "typedef long ${macro_prefix}ssize_t;"
  332. else
  333.     # Remove "unsigned" from ${size_t} to get ${ssize_t}.
  334.     tmp="`echo ${size_t} | ${SED} -e 's|unsigned||g' -e 's|  | |g'`"
  335.     if [ -z "$tmp" ] ; then
  336.     tmp=int
  337.     else
  338.     # check $tmp doesn't conflict with <unistd.h>
  339.     echo "#include <unistd.h>
  340.     extern $tmp read();" >dummy.c
  341.     ${CC} -c dummy.c >/dev/null 2>&1 || tmp=int
  342.     fi
  343.     echo "typedef $tmp /* default */ ${macro_prefix}ssize_t;"
  344. fi
  345.  
  346. # wint_t is often the integral type to which wchar_t promotes.
  347. if [ -z "${wint_t}" ] ; then
  348.   for TYPE in int 'unsigned int' 'long int' 'long unsigned int'; do
  349.     cat >dummy.C <<!EOF!
  350. #ifndef __WCHAR_TYPE__
  351. #define __WCHAR_TYPE__ ${wchar_t-int /* default */}
  352. #endif
  353. typedef __WCHAR_TYPE__ ${macro_prefix}wchar_t;
  354. void foo ($TYPE);
  355. void foo (double);
  356. void bar (${macro_prefix}wchar_t w)
  357. {
  358.   foo (w);
  359. }
  360. !EOF!
  361.     if ${CXX} -c dummy.C >/dev/null 2>&1 ; then  
  362.       wint_t="$TYPE /* default */"
  363.       break
  364.     fi
  365.   done
  366. fi
  367. echo "typedef ${wint_t-int /* wchar_t is broken */} ${macro_prefix}wint_t;"
  368.  
  369. # va_list can cause problems (e.g. some systems have va_list as a struct).
  370. # Check to see if ${va_list-char*} really is compatible with stdarg.h.
  371. cat >dummy.C <<!EOF!
  372. #define X_va_list ${va_list-char* /* default */}
  373. extern long foo(X_va_list ap); /* Check that X_va_list compiles on its own */
  374. extern "C" {
  375. #include <stdarg.h>
  376. }
  377. long foo(X_va_list ap) { return va_arg(ap, long); }
  378. long bar(int i, ...)
  379. { va_list ap; long j; va_start(ap, i); j = foo(ap); va_end(ap); return j; }
  380. !EOF!
  381. if ${CXX} -c dummy.C >/dev/null 2>&1 ; then
  382.   # Ok: We have something that works.
  383.   echo "typedef ${va_list-char* /* default */} ${macro_prefix}va_list;"
  384. else
  385.   # No, it breaks.  Indicate that <stdarg.h> must be included.
  386.   echo "#define ${macro_prefix}NEED_STDARG_H
  387. #define ${macro_prefix}va_list va_list"
  388. fi
  389.  
  390. cat >dummy.c <<!EOF!
  391. #include <signal.h>
  392. extern int (*signal())();
  393. extern int dummy (int);
  394. main()
  395. {
  396.     int (*oldsig)(int) = signal (1, dummy);
  397.     (void) signal (2, oldsig);
  398.     return 0;
  399. }
  400. !EOF!
  401. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  402.   echo "#define ${macro_prefix}signal_return_type int"
  403. else
  404.   echo "#define ${macro_prefix}signal_return_type void"
  405. fi
  406.  
  407. # check sprintf return type
  408.  
  409. cat >dummy.c <<!EOF!
  410. #include <stdio.h>
  411. extern int sprintf(); char buf[100];
  412. int main() { return sprintf(buf, "%d", 34); }
  413. !EOF!
  414. if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  415.   echo "#define ${macro_prefix}sprintf_return_type int"
  416. else
  417.   echo "#define ${macro_prefix}sprintf_return_type char*"
  418. fi
  419.  
  420. # Look for some standard macros.
  421. for NAME in BUFSIZ FOPEN_MAX FILENAME_MAX NULL; do
  422.     IMPORTED=`eval 'echo $'"$NAME"`
  423.     if [ -n "${IMPORTED}" ] ; then
  424.     eval "$NAME='$IMPORTED /* specified */"
  425.     else
  426.     rm -f TMP
  427.     ${SED} -n -e 's| *;|;|g' -e "s|long X${NAME}= *\(.*\);|\1|w TMP" \
  428.       <dummy.out>/dev/null
  429.     # Now select the first definition.
  430.     if [ -s TMP ]; then
  431.         eval "$NAME='"`${SED} -e '2,$d' <TMP`"'"
  432.     fi
  433.     fi
  434. done
  435.  
  436. # These macros must be numerical constants; strip any trailing 'L's.
  437. for NAME in SHRT_MAX INT_MAX LONG_MAX LONG_LONG_MAX; do
  438.     IMPORTED=`eval 'echo $'"$NAME"`
  439.     if [ -n "${IMPORTED}" ] ; then
  440.     eval "$NAME='$IMPORTED /* specified */"
  441.     else
  442.     rm -f TMP
  443.     ${SED} -n -e 's| *;|;|g' -e "s|long X${NAME}= *\([0-9]*\)L* *;|\1|w TMP" \
  444.       <dummy.out>/dev/null
  445.     # Now select the first definition.
  446.     if [ -s TMP ]; then
  447.         eval "$NAME='"`${SED} -e '2,$d' <TMP`"'"
  448.     fi
  449.     fi
  450. done
  451.  
  452. # Figure out integral type sizes.
  453.  
  454. default_int16='short /* deduction failed */'
  455. default_int32='long /* deduction failed */'
  456. INT16=32767
  457. INT32=2147483647
  458.  
  459. if [ "${SHRT_MAX}" = $INT16 ] ; then
  460.   default_int16='short /* deduced */'
  461.   if [ "${LONG_MAX}" = $INT32 ] ; then
  462.     default_int32='long /* deduced */'
  463.   elif [ "${INT_MAX}" = $INT32 ] ; then
  464.     default_int32='int /* deduced */'
  465.   fi
  466. fi
  467.  
  468. [ -n "$u_int16_t" ] && uint16_t="$u_int16_t"
  469. [ -n "$u_int32_t" ] && uint32_t="$u_int32_t"
  470.  
  471. [ -z  "$int16_t" ] &&  int16_t="$default_int16"
  472. [ -z "$uint16_t" ] && uint16_t="unsigned $int16_t"
  473. [ -z  "$int32_t" ] &&  int32_t="$default_int32"
  474. [ -z "$uint32_t" ] && uint32_t="unsigned $int32_t"
  475.  
  476. cat <<!EOF!
  477.  
  478. #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
  479. typedef          int   ${macro_prefix}int8_t __attribute__((__mode__(__QI__)));
  480. typedef unsigned int  ${macro_prefix}uint8_t __attribute__((__mode__(__QI__)));
  481. typedef          int  ${macro_prefix}int16_t __attribute__((__mode__(__HI__)));
  482. typedef unsigned int ${macro_prefix}uint16_t __attribute__((__mode__(__HI__)));
  483. typedef          int  ${macro_prefix}int32_t __attribute__((__mode__(__SI__)));
  484. typedef unsigned int ${macro_prefix}uint32_t __attribute__((__mode__(__SI__)));
  485. typedef          int  ${macro_prefix}int64_t __attribute__((__mode__(__DI__)));
  486. typedef unsigned int ${macro_prefix}uint64_t __attribute__((__mode__(__DI__)));
  487. #else
  488. typedef  $int16_t  ${macro_prefix}int16_t;
  489. typedef $uint16_t ${macro_prefix}uint16_t;
  490. typedef  $int32_t  ${macro_prefix}int32_t;
  491. typedef $uint32_t ${macro_prefix}uint32_t;
  492. #endif
  493.  
  494. #define ${macro_prefix}BUFSIZ ${BUFSIZ-1024 /* default */}
  495. #define ${macro_prefix}FOPEN_MAX ${FOPEN_MAX-32 /* default */}
  496. #define ${macro_prefix}FILENAME_MAX ${FILENAME_MAX-1024 /* default */}
  497. #define ${macro_prefix}NULL ${NULL-0 /* default */}
  498. #if defined (__cplusplus) || defined (__STDC__)
  499. #define ${macro_prefix}ARGS(ARGLIST) ARGLIST
  500. #else
  501. #define ${macro_prefix}ARGS(ARGLIST) ()
  502. #endif
  503. #if !defined (__GNUG__) || defined (__STRICT_ANSI__)
  504. #define ${macro_prefix}NO_NRV
  505. #endif
  506. #if !defined (__GNUG__)
  507. #define _G_NO_EXTERN_TEMPLATES
  508. #endif
  509. !EOF!
  510.  
  511. rm -f dummy.c dummy.o dummy.h
  512.  
  513. if test -n "${HAVE_ATEXIT}" ; then
  514.  echo "#define ${macro_prefix}HAVE_ATEXIT ${HAVE_ATEXIT}"
  515. else
  516.   cat >dummy.c <<!EOF!
  517. #include <stdlib.h>
  518. int main()
  519. {
  520.   atexit (0);
  521. }
  522. !EOF!
  523.   if ${CC} dummy.c >/dev/null 2>&1 ; then
  524.     echo "#define ${macro_prefix}HAVE_ATEXIT 1"
  525.   else
  526.     echo "#define ${macro_prefix}HAVE_ATEXIT 0"
  527.   fi
  528. fi
  529.  
  530.  
  531. # *** Check for presence of certain include files ***
  532.  
  533. # check for sys/resource.h
  534.  
  535. if test -n "${HAVE_SYS_RESOURCE}" ; then
  536.  echo "#define ${macro_prefix}HAVE_SYS_RESOURCE ${HAVE_SYS_RESOURCE}"
  537. else
  538.   cat >dummy.c <<!EOF!
  539. #include <sys/types.h>
  540. #include <sys/time.h>
  541. #include <sys/resource.h>
  542.   int main()
  543.   {
  544.     struct rusage res;
  545.     getrusage(RUSAGE_SELF, &res);
  546.     return (int)(res.ru_utime.tv_sec + (res.ru_utime.tv_usec / 1000000.0));
  547.   }
  548. !EOF!
  549.   # Note: We link because some systems have sys/resource, but not getrusage().
  550.   if ${CC} dummy.c >/dev/null 2>&1 ; then
  551.     echo "#define ${macro_prefix}HAVE_SYS_RESOURCE 1"
  552.   else
  553.     echo "#define ${macro_prefix}HAVE_SYS_RESOURCE 0"
  554.   fi
  555. fi
  556.  
  557. # check for struct tms in sys/times.h
  558.  
  559. if test -n "${HAVE_SYS_TIMES}" ; then
  560.  echo "#define ${macro_prefix}HAVE_SYS_TIMES ${HAVE_SYS_TIMES}"
  561. else
  562.  cat >dummy.c <<!EOF!
  563. #include <sys/types.h>
  564. #include <sys/times.h>
  565.   int main()
  566.   {
  567.     struct tms s;
  568.     return s.tms_utime;
  569.   }
  570. !EOF!
  571.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  572.     echo "#define ${macro_prefix}HAVE_SYS_TIMES 1"
  573.   else
  574.     echo "#define ${macro_prefix}HAVE_SYS_TIMES 0"
  575.   fi
  576. fi
  577.  
  578. # check for sys/socket.h
  579.  
  580. if test -n "${HAVE_SYS_SOCKET}" ; then
  581.  echo "#define ${macro_prefix}HAVE_SYS_SOCKET ${HAVE_SYS_SOCKET}"
  582. else
  583.   echo '#include <sys/types.h>' >dummy.c
  584.   echo '#include <sys/socket.h>' >>dummy.c
  585.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  586.     echo "#define ${macro_prefix}HAVE_SYS_SOCKET 1"
  587.   else
  588.     echo "#define ${macro_prefix}HAVE_SYS_SOCKET 0"
  589.   fi
  590. fi
  591.  
  592. # check for sys/cdefs.h
  593.  
  594. if test -n "${HAVE_SYS_CDEFS}" ; then
  595.  echo "#define ${macro_prefix}HAVE_SYS_CDEFS ${HAVE_SYS_CDEFS}"
  596. else
  597.   echo '#include <sys/cdefs.h>' >dummy.c
  598.   echo 'extern int myfunc __P((int, int));' >>dummy.c
  599.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  600.     echo "#define ${macro_prefix}HAVE_SYS_CDEFS 1"
  601.   else
  602.     echo "#define ${macro_prefix}HAVE_SYS_CDEFS 0"
  603.   fi
  604. fi
  605.  
  606. # Check for a (Posix-compatible) sys/wait.h */
  607.  
  608. if test -n "${HAVE_SYS_WAIT}" ; then
  609.  echo "#define ${macro_prefix}HAVE_SYS_WAIT ${HAVE_SYS_WAIT}"
  610. else
  611.   cat >dummy.c <<!EOF!
  612. #include <sys/types.h>
  613. #include <sys/wait.h>
  614.   int f() { int i; wait(&i); return i; }
  615. !EOF!
  616.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  617.     echo "#define ${macro_prefix}HAVE_SYS_WAIT 1"
  618.   else
  619.     echo "#define ${macro_prefix}HAVE_SYS_WAIT 0"
  620.   fi
  621. fi
  622.  
  623. if test -n "${HAVE_UNISTD}" ; then
  624.  echo "#define ${macro_prefix}HAVE_UNISTD ${HAVE_UNISTD}"
  625. else
  626.   echo '#include <unistd.h>' >dummy.c
  627.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  628.     echo "#define ${macro_prefix}HAVE_UNISTD 1"
  629.   else
  630.     echo "#define ${macro_prefix}HAVE_UNISTD 0"
  631.   fi
  632. fi
  633.  
  634. if test -n "${HAVE_DIRENT}" ; then
  635.  echo "#define ${macro_prefix}HAVE_DIRENT ${HAVE_DIRENT}"
  636. else
  637.   echo '#include <sys/types.h>
  638. #include <dirent.h>' >dummy.c
  639.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  640.     echo "#define ${macro_prefix}HAVE_DIRENT 1"
  641.   else
  642.     echo "#define ${macro_prefix}HAVE_DIRENT 0"
  643.   fi
  644. fi
  645.  
  646. if test -n "${HAVE_CURSES}" ; then
  647.  echo "#define ${macro_prefix}HAVE_CURSES ${HAVE_CURSES}"
  648. else
  649.   echo '#include <curses.h>' >dummy.c
  650.   if ${CC} -c dummy.c >/dev/null 2>&1 ; then
  651.     echo "#define ${macro_prefix}HAVE_CURSES 1"
  652.   else
  653.     echo "#define ${macro_prefix}HAVE_CURSES 0"
  654.   fi
  655. fi
  656.  
  657. # There is no test for this at the moment; it is just set by the
  658. # configuration files.
  659. if test -n "${MATH_H_INLINES}" ; then
  660.   echo "#define ${macro_prefix}MATH_H_INLINES ${MATH_H_INLINES}"
  661. else
  662.   echo "#define ${macro_prefix}MATH_H_INLINES 0"
  663. fi
  664.  
  665. if test -n "${HAVE_BOOL}" ; then
  666.  echo "#define ${macro_prefix}HAVE_BOOL ${HAVE_BOOL}"
  667. else
  668.   echo 'bool i=true,j=false;' >dummy.C
  669.   if ${CXX} -c dummy.C >/dev/null 2>&1 ; then
  670.     echo "#define ${macro_prefix}HAVE_BOOL 1"
  671.   else
  672.     echo "#define ${macro_prefix}HAVE_BOOL 0"
  673.   fi
  674. fi
  675.  
  676. # Uncomment the following line if you don't have working templates.
  677. # echo "#define ${macro_prefix}NO_TEMPLATES"
  678.  
  679. rm -f dummy.C dummy.o dummy.c dummy.out TMP core a.out
  680.  
  681. echo "#endif /* !${macro_prefix}config_h */"
  682.