Founder's Circle Exclusive Invitational

[fouderscircle]

You have been selected to receive this exclusive invitation. We promise that 
this email will be well worth your time to read. 

We are creating the world's largest organized group of Credit Card Members by 
offering a Free Credit Card with unprecedented benefits and we are paying out 
Millions of Referral Dollars to Card Members, Affiliates and Charities. 
Our Free Credit Card is accepted at more than 19 Million Locations Worldwide.
And it is truly Free. 

· Free from Sign-Up Fees 
· Free from Annual Fees 
· Free Reward Miles on ANY Airline 
· Up to Platinum Benefits for Free 

All of these benefits for Free... and we will be paying out Millions of 
Referral Dollars! Does your current Credit Card do that? 

Our Affiliates are happier people because you have the ability to reach 
Financial Independence through Our Referral Marketing Program. You have been 
selected to receive this exclusive invitation to become a Member of Our 
Founder's Circle. If you qualify, you will be one of the highest paid 
Affiliates in Our Referral Marketing Program. "If you're interested in learning 
more about Our Founder's Circle opportunity, simply send an email to: 

address@hidden 

with the words "MORE INFO" in the subject line".  
We will respond to you promptly with more information. 



From address@hidden Thu Mar 15 16:04:21 2001
Received: from hcna11.hii.com ([139.69.108.3])
        by fencepost.gnu.org with smtp (Exim 3.16 #1 (Debian))
        id 14deuy-00073r-00
        for <address@hidden>; Thu, 15 Mar 2001 16:04:20 -0500
Received: from 139.69.2.32 by hcna11.hii.com (InterScan E-Mail VirusWall NT); 
Thu, 15 Mar 2001 15:04:16 -0600 (Central Standard Time)
Received: from harnco-Message_Server by HCNA01
        with Novell_GroupWise; Thu, 15 Mar 2001 15:04:18 -0600
Message-Id: <address@hidden>
X-Mailer: Novell GroupWise 5.5.3
Date: Thu, 15 Mar 2001 15:04:07 -0600
From: "Scott Thomason" <address@hidden>
To: <address@hidden>
Subject: Make configure error on AIX 4.3.3 w/GCC 2.95.2.1
Mime-Version: 1.0
Content-Type: multipart/mixed; boundary="=_8FD40942.68097139"
Sender: address@hidden
Errors-To: address@hidden
X-BeenThere: address@hidden
X-Mailman-Version: 2.0.2
Precedence: bulk
List-Help: <mailto:address@hidden>
List-Post: <mailto:address@hidden>
List-Subscribe: <http://mail.gnu.org/mailman/listinfo/bug-make>,
        <mailto:address@hidden>
List-Id: Bug reports for the GNU implementation of make <bug-make.gnu.org>
List-Unsubscribe: <http://mail.gnu.org/mailman/listinfo/bug-make>,
        <mailto:address@hidden>
List-Archive: <http://mail.gnu.org/pipermail/bug-make/>

--=_8FD40942.68097139
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

The configure script doesn't work exactly right... I have to say:

export CFLAGS=3D"-DHAVE_LC_MESSAGES -DHAVE_SETLOCALE $CFLAGS"
./configure \
  --prefix=3D$BASE \
  --disable-nls

to make it compile. I've attached my config.h and config.log files.
---scott



--=_8FD40942.68097139
Content-Type: text/plain
Content-Disposition: attachment; filename="config.h"

/* config.h.  Generated automatically by configure.  */
/* config.h.in.  Generated automatically from configure.in by autoheader.  */

/* Define if on AIX 3.
   System headers sometimes define this.
   We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
#define _ALL_SOURCE 1
#endif

/* Define if using alloca.c.  */
/* #undef C_ALLOCA */

/* Define if the closedir function returns void instead of int.  */
/* #undef CLOSEDIR_VOID */

/* Define to empty if the keyword does not work.  */
/* #undef const */

/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
   This function is required for alloca.c support on those systems.  */
/* #undef CRAY_STACKSEG_END */

/* Define for DGUX with <sys/dg_sys_info.h>.  */
/* #undef DGUX */

/* Define if the `getloadavg' function needs to be run setuid or setgid.  */
#define GETLOADAVG_PRIVILEGED 1

/* Define to `int' if <sys/types.h> doesn't define.  */
/* #undef gid_t */

/* Define if you have alloca, as a function or macro.  */
#define HAVE_ALLOCA 1

/* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
/* #undef HAVE_ALLOCA_H */

/* Define if you don't have vprintf but do have _doprnt.  */
/* #undef HAVE_DOPRNT */

/* Define if your system has a working fnmatch function.  */
/* #undef HAVE_FNMATCH */

/* Define if your system has its own `getloadavg' function.  */
/* #undef HAVE_GETLOADAVG */

/* Define if you have the getmntent function.  */
/* #undef HAVE_GETMNTENT */

/* Define if the `long double' type works.  */
/* #undef HAVE_LONG_DOUBLE */

/* Define if you support file names longer than 14 characters.  */
/* #undef HAVE_LONG_FILE_NAMES */

/* Define if you have a working `mmap' system call.  */
/* #undef HAVE_MMAP */

/* Define if system calls automatically restart after interruption
   by a signal.  */
/* #undef HAVE_RESTARTABLE_SYSCALLS */

/* Define if your struct stat has st_blksize.  */
/* #undef HAVE_ST_BLKSIZE */

/* Define if your struct stat has st_blocks.  */
/* #undef HAVE_ST_BLOCKS */

/* Define if you have the strcoll function and it is properly defined.  */
#define HAVE_STRCOLL 1

/* Define if your struct stat has st_rdev.  */
/* #undef HAVE_ST_RDEV */

/* Define if you have the strftime function.  */
/* #undef HAVE_STRFTIME */

/* Define if you have the ANSI # stringizing operator in cpp. */
/* #undef HAVE_STRINGIZE */

/* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
#define HAVE_SYS_WAIT_H 1

/* Define if your struct tm has tm_zone.  */
/* #undef HAVE_TM_ZONE */

/* Define if you don't have tm_zone but do have the external array
   tzname.  */
/* #undef HAVE_TZNAME */

/* Define if you have <unistd.h>.  */
#define HAVE_UNISTD_H 1

/* Define if utime(file, NULL) sets file's timestamp to the present.  */
/* #undef HAVE_UTIME_NULL */

/* Define if you have <vfork.h>.  */
/* #undef HAVE_VFORK_H */

/* Define if you have the vprintf function.  */
#define HAVE_VPRINTF 1

/* Define if you have the wait3 system call.  */
#define HAVE_WAIT3 1

/* Define as __inline if that's what the C compiler calls it.  */
/* #undef inline */

/* Define if on MINIX.  */
/* #undef _MINIX */

/* Define if your struct nlist has an n_un member.  */
/* #undef NLIST_NAME_UNION */

/* Define if you have <nlist.h>.  */
#define NLIST_STRUCT 1

/* Define if your C compiler doesn't accept -c and -o together.  */
/* #undef NO_MINUS_C_MINUS_O */

/* Define to `int' if <sys/types.h> doesn't define.  */
/* #undef pid_t */

/* Define if the system does not provide POSIX.1 features except
   with this defined.  */
/* #undef _POSIX_1_SOURCE */

/* Define if you need to in order for stat and other things to work.  */
/* #undef _POSIX_SOURCE */

/* Define as the return type of signal handlers (int or void).  */
#define RETSIGTYPE void

/* Define if the setvbuf function takes the buffering type as its second
   argument and the buffer pointer as the third, as on System V
   before release 3.  */
/* #undef SETVBUF_REVERSED */

/* If using the C implementation of alloca, define if you know the
   direction of stack growth for your system; otherwise it will be
   automatically deduced at run-time.
 STACK_DIRECTION > 0 => grows toward higher addresses
 STACK_DIRECTION < 0 => grows toward lower addresses
 STACK_DIRECTION = 0 => direction of growth unknown
 */
/* #undef STACK_DIRECTION */

/* Define if the `S_IS*' macros in <sys/stat.h> do not work properly.  */
/* #undef STAT_MACROS_BROKEN */

/* Define if you have the ANSI C header files.  */
#define STDC_HEADERS 1

/* Define on System V Release 4.  */
/* #undef SVR4 */

/* Define if `sys_siglist' is declared by <signal.h>.  */
/* #undef SYS_SIGLIST_DECLARED */

/* Define to `int' if <sys/types.h> doesn't define.  */
/* #undef uid_t */

/* Define for Encore UMAX.  */
/* #undef UMAX */

/* Define for Encore UMAX 4.3 that has <inq_status/cpustats.h>
   instead of <sys/cpustats.h>.  */
/* #undef UMAX4_3 */

/* Define vfork as fork if vfork does not work.  */
/* #undef vfork */

/* Define to 1 if NLS is requested.  */
/* #undef ENABLE_NLS */

/* Define as 1 if you have dcgettext.  */
/* #undef HAVE_DCGETTEXT */

/* Define as 1 if you have gettext and don't want to use GNU gettext.  */
/* #undef HAVE_GETTEXT */

/* Define if your locale.h file contains LC_MESSAGES.  */
/* #undef HAVE_LC_MESSAGES */

/* Define to the installation directory for locales.  */
/* #undef LOCALEDIR */

/* Define as 1 if you have the stpcpy function.  */
/* #undef HAVE_STPCPY */

/* Define to the name of the SCCS `get' command.  */
#define SCCS_GET "get"

/* Define this if the SCCS `get' command understands the `-G<file>' option.  */
/* #undef SCCS_GET_MINUS_G */

/* Define this to enable job server support in GNU make.  */
#define MAKE_JOBSERVER 1

/* Define to be the nanoseconds member of struct stat's st_mtim,
   if it exists.  */
/* #undef ST_MTIM_NSEC */

/* Define this if the C library defines the variable `sys_siglist'.  */
#define HAVE_SYS_SIGLIST 1

/* Define this if the C library defines the variable `_sys_siglist'.  */
/* #undef HAVE__SYS_SIGLIST */

/* Define this if you have the `union wait' type in <sys/wait.h>.  */
/* #undef HAVE_UNION_WAIT */

/* Define to `unsigned long' or `unsigned long long'
   if <inttypes.h> doesn't define.  */
/* #undef uintmax_t */

/* Define if the system doesn't provide fd_set.  */
/* #undef fd_set */

/* Define the type of the first arg to select().  */
#define fd_set_size_t int

/* Define this if select() args need to be cast away from fd_set (HP-UX).  */
#define SELECT_FD_SET_CAST 

/* Define if you have the INTTYPES_H function.  */
#define HAVE_INTTYPES_H 1

/* Define if you have the clock_gettime function.  */
#define HAVE_CLOCK_GETTIME 1

/* Define if you have the dcgettext function.  */
/* #undef HAVE_DCGETTEXT */

/* Define if you have the dup2 function.  */
#define HAVE_DUP2 1

/* Define if you have the fdopen function.  */
#define HAVE_FDOPEN 1

/* Define if you have the getcwd function.  */
#define HAVE_GETCWD 1

/* Define if you have the getgroups function.  */
#define HAVE_GETGROUPS 1

/* Define if you have the gethostbyname function.  */
/* #undef HAVE_GETHOSTBYNAME */

/* Define if you have the gethostname function.  */
/* #undef HAVE_GETHOSTNAME */

/* Define if you have the getloadavg function.  */
/* #undef HAVE_GETLOADAVG */

/* Define if you have the gettext function.  */
/* #undef HAVE_GETTEXT */

/* Define if you have the memcpy function.  */
#define HAVE_MEMCPY 1

/* Define if you have the memmove function.  */
#define HAVE_MEMMOVE 1

/* Define if you have the mkstemp function.  */
#define HAVE_MKSTEMP 1

/* Define if you have the mktemp function.  */
#define HAVE_MKTEMP 1

/* Define if you have the pipe function.  */
#define HAVE_PIPE 1

/* Define if you have the psignal function.  */
#define HAVE_PSIGNAL 1

/* Define if you have the pstat_getdynamic function.  */
/* #undef HAVE_PSTAT_GETDYNAMIC */

/* Define if you have the select function.  */
#define HAVE_SELECT 1

/* Define if you have the setegid function.  */
#define HAVE_SETEGID 1

/* Define if you have the seteuid function.  */
#define HAVE_SETEUID 1

/* Define if you have the setlinebuf function.  */
#define HAVE_SETLINEBUF 1

/* Define if you have the setlocale function.  */
/* #undef HAVE_SETLOCALE */

/* Define if you have the setregid function.  */
#define HAVE_SETREGID 1

/* Define if you have the setreuid function.  */
#define HAVE_SETREUID 1

/* Define if you have the sigaction function.  */
#define HAVE_SIGACTION 1

/* Define if you have the sigsetmask function.  */
#define HAVE_SIGSETMASK 1

/* Define if you have the socket function.  */
/* #undef HAVE_SOCKET */

/* Define if you have the stpcpy function.  */
/* #undef HAVE_STPCPY */

/* Define if you have the strcasecmp function.  */
/* #undef HAVE_STRCASECMP */

/* Define if you have the strchr function.  */
#define HAVE_STRCHR 1

/* Define if you have the strdup function.  */
#define HAVE_STRDUP 1

/* Define if you have the strerror function.  */
#define HAVE_STRERROR 1

/* Define if you have the strsignal function.  */
/* #undef HAVE_STRSIGNAL */

/* Define if you have the wait3 function.  */
#define HAVE_WAIT3 1

/* Define if you have the waitpid function.  */
#define HAVE_WAITPID 1

/* Define if you have the <dirent.h> header file.  */
#define HAVE_DIRENT_H 1

/* Define if you have the <dmalloc.h> header file.  */
/* #undef HAVE_DMALLOC_H */

/* Define if you have the <fcntl.h> header file.  */
#define HAVE_FCNTL_H 1

/* Define if you have the <libintl.h> header file.  */
/* #undef HAVE_LIBINTL_H */

/* Define if you have the <limits.h> header file.  */
#define HAVE_LIMITS_H 1

/* Define if you have the <locale.h> header file.  */
/* #undef HAVE_LOCALE_H */

/* Define if you have the <mach/mach.h> header file.  */
/* #undef HAVE_MACH_MACH_H */

/* Define if you have the <memory.h> header file.  */
#define HAVE_MEMORY_H 1

/* Define if you have the <ndir.h> header file.  */
/* #undef HAVE_NDIR_H */

/* Define if you have the <stdlib.h> header file.  */
#define HAVE_STDLIB_H 1

/* Define if you have the <string.h> header file.  */
#define HAVE_STRING_H 1

/* Define if you have the <sys/dir.h> header file.  */
/* #undef HAVE_SYS_DIR_H */

/* Define if you have the <sys/ndir.h> header file.  */
/* #undef HAVE_SYS_NDIR_H */

/* Define if you have the <sys/param.h> header file.  */
#define HAVE_SYS_PARAM_H 1

/* Define if you have the <sys/select.h> header file.  */
#define HAVE_SYS_SELECT_H 1

/* Define if you have the <sys/socket.h> header file.  */
#define HAVE_SYS_SOCKET_H 1

/* Define if you have the <sys/time.h> header file.  */
#define HAVE_SYS_TIME_H 1

/* Define if you have the <sys/timeb.h> header file.  */
#define HAVE_SYS_TIMEB_H 1

/* Define if you have the <sys/types.h> header file.  */
#define HAVE_SYS_TYPES_H 1

/* Define if you have the <sys/wait.h> header file.  */
#define HAVE_SYS_WAIT_H 1

/* Define if you have the <unistd.h> header file.  */
#define HAVE_UNISTD_H 1

/* Define if you have the dgc library (-ldgc).  */
/* #undef HAVE_LIBDGC */

/* Define if you have the dmalloc library (-ldmalloc).  */
/* #undef HAVE_LIBDMALLOC */

/* Define if you have the kstat library (-lkstat).  */
/* #undef HAVE_LIBKSTAT */

/* Define if you have the posix4 library (-lposix4).  */
/* #undef HAVE_LIBPOSIX4 */

/* Define if you have the sun library (-lsun).  */
/* #undef HAVE_LIBSUN */

/* Name of package */
#define PACKAGE "make"

/* Version number of package */
#define VERSION "3.79"

/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */

/* Define to make fseeko etc. visible, on some hosts. */
/* #undef _LARGEFILE_SOURCE */

/* Define for large files, on AIX-style hosts. */
#define _LARGE_FILES 1

/* Build host information. */
#define MAKE_HOST "powerpc-ibm-aix4.3.3.0"


--=_8FD40942.68097139
Content-Type: application/octet-stream; name="config.log"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="config.log"
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--=_8FD40942.68097139--