[perl5.git] / cflags.SH

#!/bin/sh

# Generate the cflags script, which is used to determine what cflags
# to pass to the compiler for compiling the core perl.
#
# This does NOT affect the XS compilation (ext, dist, cpan)
# since that uses %Config values directly.
#
# For example, since -Wall adds -Wunused-*, a bare -Wall (without
# amending that with -Wno-unused-..., or with the PERL_UNUSED_...)
# would be too much for XS code because there are too many generated
# but often unused things.
#
# We create a temporary test C program and repeatedly compile it with
# various candidate flags, and from the compiler output, determine what
# flags are supported.
#
# From this we initialise the following variables in the cflags script:
#
#   $myccflags (possibly edited version of $Config{ccflags})
#   $warn
#   $stdflags
#   $extra
#   $_exe

case $PERL_CONFIG_SH in
'')
	if test -f config.sh; then TOP=.;
	elif test -f ../config.sh; then TOP=..;
	elif test -f ../../config.sh; then TOP=../..;
	elif test -f ../../../config.sh; then TOP=../../..;
	elif test -f ../../../../config.sh; then TOP=../../../..;
	else
		echo "Can't find config.sh."; exit 1
	fi
	. $TOP/config.sh
	;;
esac
# This forces SH files to create target in same directory as SH file.
# This is so that make depend always knows where to find SH derivatives.
case "$0" in
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac

if test -f config_h.SH -a ! -f config.h; then
    . ./config_h.SH
    CONFIG_H=already-done
fi

warn=''

# Add -Wall for the core modules iff gcc and not already -Wall
case "$gccversion" in
'') ;;
Intel*) ;; # The Intel C++ plays gcc on TV but is not really it.
*)  case "$ccflags" in
    *-Wall*) ;;
    *) warn="$warn -Wall" ;;
    esac
    ;;
esac

# Create a test source file for testing what options can be fed to
# gcc in this system; include a selection of most common and commonly
# hairy include files.

cat >_cflags.c <<__EOT__
#include "EXTERN.h"
#include "perl.h"
/* The stdio.h, errno.h, and setjmp.h should be there in any ANSI C89. */
#include <stdio.h>
#include <errno.h>
#include <setjmp.h>
/* Just in case the inclusion of perl.h did not
 * pull in enough system headers, let's try again. */
#ifdef I_STDLIB
#include <stdlib.h>
#endif
#ifdef I_STDDEF
#include <stddef.h>
#endif
#ifdef I_STDARG
#include <stdarg.h>
#endif
#ifdef I_LIMITS
#include <limits.h>
#endif
#ifdef I_DIRENT
#include <dirent.h>
#endif
#ifdef I_UNISTD
#include <unistd.h>
#endif
#ifdef I_SYS_TYPES
#include <sys/types.h>
#endif
#ifdef I_SYS_PARAM
#include <sys/param.h>
#endif
#ifdef I_SYS_RESOURCE
#include <sys/resource.h>
#endif
#ifdef I_SYS_SELECT
#include <sys/select.h>
#endif
#if defined(HAS_SOCKET) && !defined(VMS) && !defined(WIN32) /* See perl.h. */
#include <sys/socket.h>
#endif
#ifdef I_SYS_STAT
#include <sys/stat.h>
#endif
#ifdef I_SYS_TIME
#include <sys/time.h>
#endif
#ifdef I_SYS_TIMES
#include <sys/times.h>
#endif
#ifdef I_SYS_WAIT
#include <sys/wait.h>
#endif
/* The gcc -ansi can cause a lot of noise in Solaris because of:
 /usr/include/sys/resource.h:148: warning: 'struct rlimit64' declared inside parameter list
 */
int main(int argc, char *argv[]) {

/* Add here test code found to be problematic in some gcc platform. */

/* Off_t/off_t is a struct in Solaris with largefiles, and with gcc -ansi
 * that struct cannot be compared in some gcc releases with a flat
 * integer, such as a STRLEN. */

  IV iv;
  Off_t t0a = 2;
  STRLEN t0b = 3;
  int t0c = (STRLEN)t0a == t0b;

  printf("%s: %d\n", argv[0], argc);

/* In FreeBSD 6.2 (and probably other releases too), with -Duse64bitint,
   perl will use atoll(3).  However, that declaration is hidden in <stdlib.h>
   if we force the compiler to use -std=c89 mode.
*/
  iv = Atol("42");

  return (!t0c && (iv == 42)) ? 0 : -1; /* Try to avoid 'unused' warnings. */
}
__EOT__

stdflags=''

# Further gcc warning options.  Build up a list of options that work.
# Note that some problems may only show up with combinations of options,
# e.g. a warning might show up only with -Wall -ansi, not with either
# one individually.
# TODO:  Ponder whether to migrate this back to Configure so hints files can
# tweak it.  Also, be paranoid about whether results we've deduced in Configure
# (especially about things like long long, which are not in C89) will still be
# valid if we now add flags like -std=c89.

pedantic=''
case "$gccansipedantic" in
define) pedantic='-pedantic' ;;
esac

case "$gccversion" in
'') ;;
[12]*) ;; # gcc versions 1 (gasp!) and 2 are not good for this.
Intel*) ;; # # Is that you, Intel C++?
#
# NOTE 1: the -std=c89 without -pedantic is a bit pointless.
# Just -std=c89 means "if there is room for interpretation,
# interpret the C89 way."  It does NOT mean "strict C89" on its own.
# You need to add the -pedantic for that.  To do this with Configure,
# do -Dgccansipedantic (note that the -ansi is included in any case,
# the option is a bit oddly named, for historical reasons.)
#
# NOTE 2: -pedantic necessitates adding a couple of flags:
# * -PERL_GCC_PEDANTIC so that the perl code can adapt: there's nothing
#   added by gcc itself to indicate pedanticness.
# * -Wno-overlength-strings under -DDEBUGGING because quite many of
#   the LEAVE_with_name() and assert() calls generate string literals
#   longer then the ANSI minimum of 509 bytes.
#
# NOTE 3: the relative order of these options matters:
# -Wextra before -W, and -pedantic* before -Werror=d-a-s.
#
*)  for opt in -ansi -std=c89 $pedantic \
		-Werror=declaration-after-statement \
		-Wextra -W \
		-Wc++-compat -Wwrite-strings
    do
       case " $ccflags " in
       *" $opt "*) ;; # Skip if already there.
       *) rm -f _cflags$_exe
	  flags="-DPERL_NO_INLINE_FUNCTIONS $ccflags $warn $stdflags $opt"
	  case "$opt" in
	  *-pedantic*) flags="$flags -DPERL_GCC_PEDANTIC" ;;
	  esac
          # echo "opt = $opt, flags = $flags"
          cmd="$cc $flags _cflags.c -o _cflags$_exe"
          out="`$cmd 2>&1`"
          # echo "$cmd --> $out"
          case "$out" in
          *"unrecognized"*) ;;
          *"unknown"*) ;;
          *"implicit declaration"*) ;; # Was something useful hidden?
          *"Invalid"*) ;;
          *"is valid for C"*) ;;
          *) if test -x _cflags$_exe
             then
               case "$opt" in
               -std*)
                 echo "cflags.SH: Adding $opt."
                 stdflags="$stdflags $opt"
                 ;;
               *) case "$opt" in
                  -W)
                    # -Wextra is the modern form of -W, so add
                    # -W only if -Wextra is not there already.
                    case " $warn " in
                    *-Wextra*) ;;
                    *)
                      echo "cflags.SH: Adding $opt."
                      warn="$warn $opt"
                      ;;
                    esac
                    ;;
		  -Werror=declaration-after-statement)
                    # -pedantic* (with -std=c89) covers -Werror=d-a-s.
                    case "$stdflags$warn" in
                    *-std=c89*-pedantic*|*-pedantic*-std=c89*) ;;
                    *)
                      echo "cflags.SH: Adding $opt."
                      warn="$warn $opt"
                      ;;
                    esac
		    ;;
                  *)
                     echo "cflags.SH: Adding $opt."
                     warn="$warn $opt"
                     ;;
                  esac
               esac
             fi
             ;;
          esac
          ;;
       esac
       case "$ccflags$warn" in
       *-pedantic*)
         overlength=''
         case "$ccflags$optimize" in
         *-DDEBUGGING*) overlength='-Wno-overlength-strings' ;;
         esac
         for opt2 in -DPERL_GCC_PEDANTIC $overlength
         do
	   case "$ccflags$warn" in
	   *"$opt2"*) ;;
	   *) echo "cflags.SH: Adding $opt2 because of -pedantic."
	      warn="$warn $opt2" ;;
           esac
         done
         ;;
       esac
    done
    ;;
esac
rm -f _cflags.c _cflags$_exe

case "$gccversion" in
'') ;;
*)
  case "$warn$ccflags" in
  *-pedantic*)
    # If we have -Duse64bitint (or equivalent) in effect and the quadtype
    # has become 'long long', gcc -pedantic* becomes unbearable
    # (moreso when combined with -Wall) because long long and LL and %lld|%Ld
    # become warn-worthy.  So let's drop the -pedantic in that case.
    #
    # Similarly, since 'long long' isn't part of C89, FreeBSD 6.2 headers
    # don't declare atoll() under -std=c89, but we need it.  In general,
    # insisting on -std=c89 is inconsistent with insisting on using
    # 'long long'. So drop -std=c89 and -ansi as well if we're using
    # 'long long' as our main integral type.
    #
    # usedtrace (DTrace) uses unportable features (dollars in identifiers,
    # and gcc statement expressions), it is just easier to turn off pedantic.
    remove=''
    case "$quadtype:$ivtype:$sPRId64:$usedtrace" in
    *"long long"*|*lld*|*Ld*) remove='long long' ;;
    *) case "$usedtrace" in
       define) remove='usedtrace' ;;
       esac
       ;;
    esac
    case "$remove" in
    '') ;;
    *) echo "cflags.SH: Removing -pedantic*, -std=c89, and -ansi because of $remove."
      ccflags=`echo $ccflags|sed -e 's/-pedantic-errors/ /' -e 's/-pedantic/ /' -e 's/-std=c89/ /' -e 's/-ansi/ /' -e 's/-DPERL_GCC_PEDANTIC/ /'`
      warn=`echo $warn|sed -e 's/-pedantic-errors/ /' -e 's/-pedantic/ /' -e 's/-ansi/ /' -e 's/-DPERL_GCC_PEDANTIC/ /'`
      stdflags=`echo $stdflags|sed -e 's/-std=c89/ /'`
      ;;
    esac
    ;;
  esac
  ;;
esac

case "$cc" in
*g++*)
  # Extra paranoia in case people have bad canned ccflags:
  # bad in the sense that the flags are accepted by g++,
  # but then whined about.
  #
  # -Werror=d-a-s option is valid for g++, by definition,
  # but we remove it just for cleanliness and shorter command lines.
  for f in -Wdeclaration-after-statement \
		-Werror=declaration-after-statement \
		-Wc++-compat \
		-std=c89
  do
    case "$ccflags$warn" in
    *"$f"*)
      echo "cflags.SH: Removing $f because of g++."
      ccflags=`echo $ccflags|sed 's/$f/ /'`
      warn=`echo $warn|sed 's/$f/ /'`
      ;;
    esac
  done
  ;;
esac

for f in -Wdeclaration-after-statement -Werror=declaration-after-statement
do
  case "$cppflags" in
  *"$f"*)
    echo "cflags.SH: Removing $f from cppflags."
    cppflags=`echo $cppflags|sed 's/$f/ /'` ;;
  esac
done

echo "cflags.SH: cc       = $cc"
echo "cflags.SH: ccflags  = $ccflags"
echo "cflags.SH: stdflags = $stdflags"
echo "cflags.SH: optimize = $optimize"
echo "cflags.SH: warn     = $warn"

# Code to set any extra flags here.
extra=''

echo "Extracting cflags (with variable substitutions)"
# This section of the file will have variable substitutions done on it.
# Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
# Protect any dollar signs and backticks that you do not want interpreted
# by putting a backslash in front.  You may delete these comments.
rm -f cflags
$spitshell >cflags <<!GROK!THIS!
$startsh

# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!

# This file is generated by cflags.SH

# Used to restore possible edits by cflags.SH.
myccflags="$ccflags"
# Extra warnings, used e.g. for gcc.
warn="$warn"
# Extra standardness.
stdflags="$stdflags"
# Extra extra.
extra="$extra"
# what do executables look like?
_exe="$_exe"

!GROK!THIS!

# In the following dollars and backticks do not need the extra backslash.
$spitshell >>cflags <<'!NO!SUBS!'
case $PERL_CONFIG_SH in
'')
	if test -f config.sh; then TOP=.;
	elif test -f ../config.sh; then TOP=..;
	elif test -f ../../config.sh; then TOP=../..;
	elif test -f ../../../config.sh; then TOP=../../..;
	elif test -f ../../../../config.sh; then TOP=../../../..;
	else
		echo "Can't find config.sh."; exit 1
	fi
	. $TOP/config.sh
        ccflags="$myccflags"  # Restore possible edits by cflags.SH.
	;;
esac

# syntax: cflags [optimize=XXX] [file[.suffix]] ...
#   displays the proposed compiler command line for each 'file'
#
#   with no file, dispalys it for all *.c files.
#   The optimise=XXX arg (if present) is evalled, setting the default
#   value of the $optimise variable, which is output on the command line
#   (but which may be overridden for specific files below)

case "X$1" in
Xoptimize=*|X"optimize=*")
	eval "$1"
	shift
	;;
esac

case $# in
0) set *.c; echo "The current C flags are:" ;;
esac

set `echo "$* " | sed -e 's/\.[oc] / /g' -e 's/\.obj / /g' -e "s/\\$obj_ext / /g"`

for file do

    case "$#" in
    1) ;;
    *) echo $n "    $file.c	$c" ;;
    esac

    # allow variables like toke_cflags to be evaluated

    if echo $file | grep -v / >/dev/null
    then
      eval 'eval ${'"${file}_cflags"'-""}'
    fi

    # or customize here

    case "$file" in
    *) ;;

    # Customization examples follow.
    #
    # The examples are intentionally unreachable as the '*)' case above always
    # matches. To use them, move before the '*)' and edit as appropriate.
    # It is not a good idea to set ccflags to an absolute value here, as it
    # often contains general -D defines which are needed for correct
    # compilation. It is better to edit ccflags as shown, using interpolation
    # to add flags, or sed to remove flags.

    av) ccflags=`echo $ccflags | sed -e s/-pipe//` ;;
    deb) ccflags="$ccflags -fno-jump-tables" ;;
    hv) warn=`echo $warn | sed -e s/-Wextra//` ;;
    toke) optimize=-O0 ;;
    esac

    # Can we perhaps use $ansi2knr here
    echo "$cc -c -DPERL_CORE $ccflags $stdflags $optimize $warn $extra"

    . $TOP/config.sh

    # end per file behaviour
done
!NO!SUBS!
chmod 755 cflags
$eunicefix cflags
Commit	Line	Data
1f00b0d6 S	1	#!/bin/sh
1f00b0d6 S	2
cb9238a7	3	# Generate the cflags script, which is used to determine what cflags
ea14a82d JH	4	# to pass to the compiler for compiling the core perl.
	5	#
	6	# This does NOT affect the XS compilation (ext, dist, cpan)
	7	# since that uses %Config values directly.
	8	#
	9	# For example, since -Wall adds -Wunused-*, a bare -Wall (without
	10	# amending that with -Wno-unused-..., or with the PERL_UNUSED_...)
	11	# would be too much for XS code because there are too many generated
	12	# but often unused things.
	13	#
	14	# We create a temporary test C program and repeatedly compile it with
cb9238a7 DM	15	# various candidate flags, and from the compiler output, determine what
cb9238a7 DM	16	# flags are supported.
ea14a82d	17	#
cb9238a7 DM	18	# From this we initialise the following variables in the cflags script:
cb9238a7 DM	19	#
ea14a82d	20	# $myccflags (possibly edited version of $Config{ccflags})
cb9238a7 DM	21	# $warn
	22	# $stdflags
	23	# $extra
	24	# $_exe
	25
a02608de	26	case $PERL_CONFIG_SH in
1c3d792e	27	'')
a0d0e21e LW	28	if test -f config.sh; then TOP=.;
	29	elif test -f ../config.sh; then TOP=..;
	30	elif test -f ../../config.sh; then TOP=../..;
	31	elif test -f ../../../config.sh; then TOP=../../..;
	32	elif test -f ../../../../config.sh; then TOP=../../../..;
	33	else
	34	echo "Can't find config.sh."; exit 1
	35	fi
	36	. $TOP/config.sh
	37	;;
1c3d792e	38	esac
44213caa DM	39	# This forces SH files to create target in same directory as SH file.
44213caa DM	40	# This is so that make depend always knows where to find SH derivatives.
1c3d792e LW	41	case "$0" in
	42	/) cd `expr X$0 : 'X\(.*\)/'` ;;
	43	esac
bc730b18	44
37723ebb	45	if test -f config_h.SH -a ! -f config.h; then
6ef8aa7c	46	. ./config_h.SH
11e2f395	47	CONFIG_H=already-done
6ef8aa7c RGS	48	fi
6ef8aa7c RGS	49
bc730b18 JH	50	warn=''
	51
	52	# Add -Wall for the core modules iff gcc and not already -Wall
	53	case "$gccversion" in
	54	'') ;;
	55	Intel*) ;; # The Intel C++ plays gcc on TV but is not really it.
	56	*) case "$ccflags" in
	57	-Wall) ;;
	58	*) warn="$warn -Wall" ;;
	59	esac
	60	;;
	61	esac
	62
a07cd53d JH	63	# Create a test source file for testing what options can be fed to
	64	# gcc in this system; include a selection of most common and commonly
	65	# hairy include files.
	66
	67	cat >_cflags.c <<__EOT__
	68	#include "EXTERN.h"
	69	#include "perl.h"
	70	/* The stdio.h, errno.h, and setjmp.h should be there in any ANSI C89. */
	71	#include <stdio.h>
	72	#include <errno.h>
	73	#include <setjmp.h>
	74	/* Just in case the inclusion of perl.h did not
	75	* pull in enough system headers, let's try again. */
	76	#ifdef I_STDLIB
	77	#include <stdlib.h>
	78	#endif
	79	#ifdef I_STDDEF
	80	#include <stddef.h>
	81	#endif
	82	#ifdef I_STDARG
	83	#include <stdarg.h>
	84	#endif
	85	#ifdef I_LIMITS
	86	#include <limits.h>
	87	#endif
	88	#ifdef I_DIRENT
	89	#include <dirent.h>
	90	#endif
	91	#ifdef I_UNISTD
	92	#include <unistd.h>
	93	#endif
463bdbaf	94	#ifdef I_SYS_TYPES
a07cd53d JH	95	#include <sys/types.h>
a07cd53d JH	96	#endif
463bdbaf	97	#ifdef I_SYS_PARAM
a07cd53d JH	98	#include <sys/param.h>
a07cd53d JH	99	#endif
463bdbaf	100	#ifdef I_SYS_RESOURCE
a07cd53d JH	101	#include <sys/resource.h>
a07cd53d JH	102	#endif
463bdbaf	103	#ifdef I_SYS_SELECT
a07cd53d JH	104	#include <sys/select.h>
	105	#endif
	106	#if defined(HAS_SOCKET) && !defined(VMS) && !defined(WIN32) /* See perl.h. */
	107	#include <sys/socket.h>
	108	#endif
463bdbaf	109	#ifdef I_SYS_STAT
a07cd53d JH	110	#include <sys/stat.h>
a07cd53d JH	111	#endif
463bdbaf	112	#ifdef I_SYS_TIME
a07cd53d JH	113	#include <sys/time.h>
a07cd53d JH	114	#endif
463bdbaf	115	#ifdef I_SYS_TIMES
a07cd53d JH	116	#include <sys/times.h>
a07cd53d JH	117	#endif
463bdbaf	118	#ifdef I_SYS_WAIT
a07cd53d JH	119	#include <sys/wait.h>
	120	#endif
	121	/* The gcc -ansi can cause a lot of noise in Solaris because of:
	122	/usr/include/sys/resource.h:148: warning: 'struct rlimit64' declared inside parameter list
	123	*/
	124	int main(int argc, char *argv[]) {
	125
	126	/* Add here test code found to be problematic in some gcc platform. */
	127
	128	/* Off_t/off_t is a struct in Solaris with largefiles, and with gcc -ansi
	129	* that struct cannot be compared in some gcc releases with a flat
	130	* integer, such as a STRLEN. */
	131
215ed6ce	132	IV iv;
a07cd53d JH	133	Off_t t0a = 2;
a07cd53d JH	134	STRLEN t0b = 3;
f049db42 JH	135	int t0c = (STRLEN)t0a == t0b;
	136
	137	printf("%s: %d\n", argv[0], argc);
a07cd53d	138
215ed6ce AD	139	/* In FreeBSD 6.2 (and probably other releases too), with -Duse64bitint,
	140	perl will use atoll(3). However, that declaration is hidden in <stdlib.h>
	141	if we force the compiler to use -std=c89 mode.
	142	*/
	143	iv = Atol("42");
	144
	145	return (!t0c && (iv == 42)) ? 0 : -1; /* Try to avoid 'unused' warnings. */
a07cd53d JH	146	}
	147	__EOT__
	148
	149	stdflags=''
bc730b18	150
215ed6ce AD	151	# Further gcc warning options. Build up a list of options that work.
	152	# Note that some problems may only show up with combinations of options,
	153	# e.g. a warning might show up only with -Wall -ansi, not with either
	154	# one individually.
813665af	155	# TODO: Ponder whether to migrate this back to Configure so hints files can
215ed6ce	156	# tweak it. Also, be paranoid about whether results we've deduced in Configure
813665af	157	# (especially about things like long long, which are not in C89) will still be
215ed6ce AD	158	# valid if we now add flags like -std=c89.
215ed6ce AD	159
f049db42 JH	160	pedantic=''
	161	case "$gccansipedantic" in
	162	define) pedantic='-pedantic' ;;
	163	esac
	164
bc730b18 JH	165	case "$gccversion" in
bc730b18 JH	166	'') ;;
a07cd53d JH	167	[12]*) ;; # gcc versions 1 (gasp!) and 2 are not good for this.
a07cd53d JH	168	Intel*) ;; # # Is that you, Intel C++?
f049db42 JH	169	#
f049db42 JH	170	# NOTE 1: the -std=c89 without -pedantic is a bit pointless.
abf4b099	171	# Just -std=c89 means "if there is room for interpretation,
f049db42 JH	172	# interpret the C89 way." It does NOT mean "strict C89" on its own.
	173	# You need to add the -pedantic for that. To do this with Configure,
	174	# do -Dgccansipedantic (note that the -ansi is included in any case,
	175	# the option is a bit oddly named, for historical reasons.)
	176	#
	177	# NOTE 2: -pedantic necessitates adding a couple of flags:
	178	# * -PERL_GCC_PEDANTIC so that the perl code can adapt: there's nothing
	179	# added by gcc itself to indicate pedanticness.
	180	# * -Wno-overlength-strings under -DDEBUGGING because quite many of
	181	# the LEAVE_with_name() and assert() calls generate string literals
	182	# longer then the ANSI minimum of 509 bytes.
	183	#
	184	# NOTE 3: the relative order of these options matters:
	185	# -Wextra before -W, and -pedantic* before -Werror=d-a-s.
abf4b099	186	#
f049db42	187	*) for opt in -ansi -std=c89 $pedantic \
d2d49204	188	-Werror=declaration-after-statement \
f049db42	189	-Wextra -W \
fae2e960	190	-Wc++-compat -Wwrite-strings
bc730b18 JH	191	do
bc730b18 JH	192	case " $ccflags " in
a07cd53d JH	193	" $opt ") ;; # Skip if already there.
a07cd53d JH	194	*) rm -f _cflags$_exe
f049db42 JH	195	flags="-DPERL_NO_INLINE_FUNCTIONS $ccflags $warn $stdflags $opt"
	196	case "$opt" in
	197	-pedantic) flags="$flags -DPERL_GCC_PEDANTIC" ;;
	198	esac
	199	# echo "opt = $opt, flags = $flags"
	200	cmd="$cc $flags _cflags.c -o _cflags$_exe"
	201	out="`$cmd 2>&1`"
	202	# echo "$cmd --> $out"
	203	case "$out" in
bc730b18	204	"unrecognized") ;;
d39195d4	205	"unknown") ;;
215ed6ce	206	"implicit declaration") ;; # Was something useful hidden?
bc730b18	207	"Invalid") ;;
9ac4c107	208	"is valid for C") ;;
a07cd53d JH	209	*) if test -x _cflags$_exe
	210	then
	211	case "$opt" in
be5a9ab8 JH	212	-std*)
	213	echo "cflags.SH: Adding $opt."
	214	stdflags="$stdflags $opt"
	215	;;
905ccdc7 JH	216	*) case "$opt" in
	217	-W)
	218	# -Wextra is the modern form of -W, so add
	219	# -W only if -Wextra is not there already.
	220	case " $warn " in
	221	-Wextra) ;;
be5a9ab8 JH	222	*)
be5a9ab8 JH	223	echo "cflags.SH: Adding $opt."
f049db42	224	warn="$warn $opt"
be5a9ab8	225	;;
905ccdc7 JH	226	esac
905ccdc7 JH	227	;;
f049db42 JH	228	-Werror=declaration-after-statement)
	229	# -pedantic* (with -std=c89) covers -Werror=d-a-s.
	230	case "$stdflags$warn" in
	231	-std=c89-pedantic\|-pedantic-std=c89) ;;
	232	*)
	233	echo "cflags.SH: Adding $opt."
	234	warn="$warn $opt"
	235	;;
	236	esac
	237	;;
be5a9ab8 JH	238	*)
	239	echo "cflags.SH: Adding $opt."
	240	warn="$warn $opt"
	241	;;
905ccdc7	242	esac
a07cd53d JH	243	esac
	244	fi
	245	;;
bc730b18 JH	246	esac
	247	;;
	248	esac
f049db42 JH	249	case "$ccflags$warn" in
	250	-pedantic)
	251	overlength=''
	252	case "$ccflags$optimize" in
	253	-DDEBUGGING) overlength='-Wno-overlength-strings' ;;
	254	esac
	255	for opt2 in -DPERL_GCC_PEDANTIC $overlength
	256	do
	257	case "$ccflags$warn" in
	258	"$opt2") ;;
	259	*) echo "cflags.SH: Adding $opt2 because of -pedantic."
	260	warn="$warn $opt2" ;;
	261	esac
	262	done
	263	;;
	264	esac
bc730b18 JH	265	done
	266	;;
	267	esac
a07cd53d	268	rm -f _cflags.c _cflags$_exe
bc730b18	269
9ac4c107 JH	270	case "$gccversion" in
	271	'') ;;
	272	*)
f049db42 JH	273	case "$warn$ccflags" in
f049db42 JH	274	-pedantic)
3e8416a3	275	# If we have -Duse64bitint (or equivalent) in effect and the quadtype
f049db42 JH	276	# has become 'long long', gcc -pedantic* becomes unbearable
f049db42 JH	277	# (moreso when combined with -Wall) because long long and LL and %lld\|%Ld
3e8416a3	278	# become warn-worthy. So let's drop the -pedantic in that case.
f049db42	279	#
215ed6ce AD	280	# Similarly, since 'long long' isn't part of C89, FreeBSD 6.2 headers
	281	# don't declare atoll() under -std=c89, but we need it. In general,
	282	# insisting on -std=c89 is inconsistent with insisting on using
813665af	283	# 'long long'. So drop -std=c89 and -ansi as well if we're using
215ed6ce	284	# 'long long' as our main integral type.
f049db42 JH	285	#
	286	# usedtrace (DTrace) uses unportable features (dollars in identifiers,
	287	# and gcc statement expressions), it is just easier to turn off pedantic.
	288	remove=''
	289	case "$quadtype:$ivtype:$sPRId64:$usedtrace" in
	290	"long long"\|lld\|Ld) remove='long long' ;;
	291	*) case "$usedtrace" in
	292	define) remove='usedtrace' ;;
	293	esac
	294	;;
	295	esac
	296	case "$remove" in
	297	'') ;;
	298	) echo "cflags.SH: Removing -pedantic, -std=c89, and -ansi because of $remove."
	299	ccflags=`echo $ccflags\|sed -e 's/-pedantic-errors/ /' -e 's/-pedantic/ /' -e 's/-std=c89/ /' -e 's/-ansi/ /' -e 's/-DPERL_GCC_PEDANTIC/ /'`
	300	warn=`echo $warn\|sed -e 's/-pedantic-errors/ /' -e 's/-pedantic/ /' -e 's/-ansi/ /' -e 's/-DPERL_GCC_PEDANTIC/ /'`
	301	stdflags=`echo $stdflags\|sed -e 's/-std=c89/ /'`
	302	;;
215ed6ce	303	esac
5bd6d383 JH	304	;;
	305	esac
	306	;;
	307	esac
	308
	309	case "$cc" in
	310	g++)
	311	# Extra paranoia in case people have bad canned ccflags:
	312	# bad in the sense that the flags are accepted by g++,
	313	# but then whined about.
d2d49204 JH	314	#
	315	# -Werror=d-a-s option is valid for g++, by definition,
	316	# but we remove it just for cleanliness and shorter command lines.
	317	for f in -Wdeclaration-after-statement \
	318	-Werror=declaration-after-statement \
49c60343	319	-Wc++-compat \
d2d49204	320	-std=c89
5bd6d383	321	do
95f0c784	322	case "$ccflags$warn" in
5bd6d383	323	"$f")
95f0c784 JH	324	echo "cflags.SH: Removing $f because of g++."
	325	ccflags=`echo $ccflags\|sed 's/$f/ /'`
	326	warn=`echo $warn\|sed 's/$f/ /'`
	327	;;
5bd6d383 JH	328	esac
	329	done
	330	;;
	331	esac
	332
d2d49204	333	for f in -Wdeclaration-after-statement -Werror=declaration-after-statement
5bd6d383 JH	334	do
	335	case "$cppflags" in
	336	"$f")
	337	echo "cflags.SH: Removing $f from cppflags."
	338	cppflags=`echo $cppflags\|sed 's/$f/ /'` ;;
	339	esac
	340	done
	341
f049db42 JH	342	echo "cflags.SH: cc = $cc"
	343	echo "cflags.SH: ccflags = $ccflags"
	344	echo "cflags.SH: stdflags = $stdflags"
	345	echo "cflags.SH: optimize = $optimize"
	346	echo "cflags.SH: warn = $warn"
	347
10edeb5d	348	# Code to set any extra flags here.
a07cd53d	349	extra=''
11fcce85	350
2b317908	351	echo "Extracting cflags (with variable substitutions)"
44213caa DM	352	# This section of the file will have variable substitutions done on it.
	353	# Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
	354	# Protect any dollar signs and backticks that you do not want interpreted
	355	# by putting a backslash in front. You may delete these comments.
165b7424	356	rm -f cflags
2b317908	357	$spitshell >cflags <<!GROK!THIS!
ecfc5424	358	$startsh
bc730b18	359
cb9238a7 DM	360	# !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
	361
	362	# This file is generated by cflags.SH
	363
5bd6d383	364	# Used to restore possible edits by cflags.SH.
57d2761b	365	myccflags="$ccflags"
11fcce85	366	# Extra warnings, used e.g. for gcc.
bc730b18	367	warn="$warn"
11fcce85 JH	368	# Extra standardness.
11fcce85 JH	369	stdflags="$stdflags"
b1e55cab JH	370	# Extra extra.
b1e55cab JH	371	extra="$extra"
dcff826f YO	372	# what do executables look like?
dcff826f YO	373	_exe="$_exe"
bc730b18	374
2b317908 LW	375	!GROK!THIS!
2b317908 LW	376
44213caa	377	# In the following dollars and backticks do not need the extra backslash.
2b317908	378	$spitshell >>cflags <<'!NO!SUBS!'
a02608de	379	case $PERL_CONFIG_SH in
2b317908	380	'')
a0d0e21e LW	381	if test -f config.sh; then TOP=.;
	382	elif test -f ../config.sh; then TOP=..;
	383	elif test -f ../../config.sh; then TOP=../..;
	384	elif test -f ../../../config.sh; then TOP=../../..;
	385	elif test -f ../../../../config.sh; then TOP=../../../..;
	386	else
	387	echo "Can't find config.sh."; exit 1
	388	fi
	389	. $TOP/config.sh
57d2761b	390	ccflags="$myccflags" # Restore possible edits by cflags.SH.
a0d0e21e LW	391	;;
	392	esac
	393
ba0f5503 DM	394	# syntax: cflags [optimize=XXX] [file[.suffix]] ...
	395	# displays the proposed compiler command line for each 'file'
	396	#
	397	# with no file, dispalys it for all *.c files.
	398	# The optimise=XXX arg (if present) is evalled, setting the default
	399	# value of the $optimise variable, which is output on the command line
	400	# (but which may be overridden for specific files below)
75550b4e	401
1167a30e	402	case "X$1" in
26102cc7	403	Xoptimize=\|X"optimize=")
1167a30e IZ	404	eval "$1"
	405	shift
	406	;;
	407	esac
	408
1c3d792e LW	409	case $# in
1c3d792e LW	410	0) set *.c; echo "The current C flags are:" ;;
1c3d792e	411	esac
2b317908	412
578789a7	413	set `echo "$* " \| sed -e 's/\.[oc] / /g' -e 's/\.obj / /g' -e "s/\\$obj_ext / /g"`
2b317908	414
1c3d792e LW	415	for file do
	416
	417	case "$#" in
	418	1) ;;
2b317908	419	*) echo $n " $file.c $c" ;;
1c3d792e LW	420	esac
1c3d792e LW	421
44213caa	422	# allow variables like toke_cflags to be evaluated
2b317908	423
8736538c AS	424	if echo $file \| grep -v / >/dev/null
	425	then
	426	eval 'eval ${'"${file}_cflags"'-""}'
	427	fi
2b317908	428
44213caa	429	# or customize here
2b317908	430
1c3d792e	431	case "$file" in
1c3d792e	432	*) ;;
5729ffdd	433
5bd6d383 JH	434	# Customization examples follow.
	435	#
	436	# The examples are intentionally unreachable as the '*)' case above always
44213caa DM	437	# matches. To use them, move before the '*)' and edit as appropriate.
	438	# It is not a good idea to set ccflags to an absolute value here, as it
	439	# often contains general -D defines which are needed for correct
	440	# compilation. It is better to edit ccflags as shown, using interpolation
	441	# to add flags, or sed to remove flags.
5729ffdd	442
5bd6d383 JH	443	av) ccflags=`echo $ccflags \| sed -e s/-pipe//` ;;
	444	deb) ccflags="$ccflags -fno-jump-tables" ;;
	445	hv) warn=`echo $warn \| sed -e s/-Wextra//` ;;
	446	toke) optimize=-O0 ;;
7e827271	447	esac
666ea192	448
44213caa	449	# Can we perhaps use $ansi2knr here
b1e55cab	450	echo "$cc -c -DPERL_CORE $ccflags $stdflags $optimize $warn $extra"
2b317908	451
a0d0e21e	452	. $TOP/config.sh
2b317908	453
a7d59441	454	# end per file behaviour
1c3d792e	455	done
2b317908	456	!NO!SUBS!
a0d0e21e	457	chmod 755 cflags
2b317908	458	$eunicefix cflags