dnl configure.ac for MCPP   2003/11, 2008/11  kmatsui

dnl Process this file with autoconf to produce a configure script.

dnl WARNING: This script does not assume cross-compiling.

dnl To cross-compile you must edit here and there of this file.

AC_INIT( mcpp, 2.7.2, kmatsui@t3.rim.or.jp)

AC_CONFIG_SRCDIR( src/main.c)

AM_CONFIG_HEADER( src/config.h)

AC_CONFIG_AUX_DIR( config)

AC_CANONICAL_TARGET

AM_INIT_AUTOMAKE( no-dependencies)

dnl Checks for programs.

AC_PROG_CC

AC_PROG_CPP

AC_PROG_INSTALL

AC_PROG_EGREP

AC_LIBTOOL_WIN32_DLL

AC_PROG_LIBTOOL

dnl WARNING: Configure must check the characteristics of target compiler.

dnl MCPP may modify the behavior of the target compiler-system.

dnl You must uninstall MCPP before re-configuring.

AC_MSG_CHECKING( [whether the cpp is target preprocessor])

mcpp=`$CPP $CFLAGS -xc -v /dev/null 2>&1 | grep 'MCPP'`

if test "x$mcpp" != x; then

    AC_MSG_ERROR( Do 'make uninstall' before configuring again.)

fi

AC_MSG_RESULT( yes)

dnl Define host system and target system

case $host_os in

linux*)

    AC_DEFINE( [HOST_SYSTEM], [SYS_LINUX], [Define the host system.])

    ac_c_define_HOST_SYSTEM=[SYS_LINUX]

    ;;

freebsd*)

    AC_DEFINE( [HOST_SYSTEM], [SYS_FREEBSD])

    ac_c_define_HOST_SYSTEM=[SYS_FREEBSD]

    ;;

darwin*)

    AC_DEFINE( [HOST_SYSTEM], [SYS_MAC])

    ac_c_define_HOST_SYSTEM=[SYS_MAC]

    ;;

cygwin*)

    AC_DEFINE( [HOST_SYSTEM], [SYS_CYGWIN])

    ac_c_define_HOST_SYSTEM=[SYS_CYGWIN]

    ;;

mingw*)

    AC_DEFINE( [HOST_SYSTEM], [SYS_MINGW])

    ac_c_define_HOST_SYSTEM=[SYS_MINGW]

    ;;

*)

    AC_MSG_WARN( [Unsupported host OS, assuming to be an UNIX variant])

    AC_DEFINE( [HOST_SYSTEM], [SYS_UNIX])

    ac_c_define_HOST_SYSTEM=[SYS_UNIX]

    ;;

esac

host_system=$ac_c_define_HOST_SYSTEM

case $target_os in

linux*)

    AC_DEFINE( [SYSTEM], [SYS_LINUX], [Define the target system.])

    ;;

freebsd*)

    AC_DEFINE( [SYSTEM], [SYS_FREEBSD])

    ;;

darwin*)

    AC_DEFINE( [SYSTEM], [SYS_MAC])

    ;;

cygwin*)

    AC_DEFINE( [SYSTEM], [SYS_CYGWIN])

    ;;

mingw*)

    AC_DEFINE( [SYSTEM], [SYS_MINGW])

    ;;

*)

    AC_MSG_WARN( Unsupported target OS, assuming to be an UNIX variant)

    AC_DEFINE( [SYSTEM], [SYS_UNIX])

    ;;

esac

## --enable-replace-cpp option

AC_ARG_ENABLE( replace-cpp,

    AC_HELP_STRING( [--enable-replace-cpp],

        [Replace the resident preprocessor with mcpp]),

    ,       ## the compiler name will be defined later

    AC_DEFINE( [COMPILER], [INDEPENDENT], [Define the target compiler.])

            ## else define COMPILER as INDEPENDENT

)

## Generally this configure does not support cross-compiling.

## Nevertheless, it can configure cross-compiler of Apple-GCC (i686 vs ppc).

if test x$enable_replace_cpp = xyes    \

        && test $ac_c_define_HOST_SYSTEM = SYS_MAC    \

        && test $host_cpu != $target_cpu; then

## Enable to build mcpp into cross-compiler of Apple-GCC

## --with-target-cc option

AC_ARG_WITH( target_cc,

    AC_HELP_STRING( [--with-target-cc],

        [Specify the target compiler to build mcpp into on Mac OS X]),

    if test x${withval+set} = xset; then

        target_cc=$withval

        target_name=`echo $target_cc | sed 's/-gcc.*$//'`

        if test $target_name != $target_alias; then

            AC_MSG_ERROR( [The argument of --with-target-cc option conflicts with --target option.])

        fi

        AC_SUBST( [target_cc])

    fi

)

fi

dnl Define a target specific macro.

AC_MSG_CHECKING( for target cpu)

## These are not predefined macros of MCPP.  MCPP will define predefined macros

## on compile time based on the CPU macro, and possibly redefine them at an

## execution time.

case $target_cpu in

x86_64|amd64)

    Target_Cpu=x86_64

    ;;

i?86*)

    Target_Cpu=i386

    ;;

powerpc64|ppc64)

    Target_Cpu=ppc64

    ;;

powerpc|ppc|ppc7400)

    Target_Cpu=ppc

    ;;

*)

    Target_Cpu=$target_cpu

    ;;

esac

AC_MSG_RESULT( $Target_Cpu)

AC_DEFINE_UNQUOTED( [CPU], "$Target_Cpu", [Define the cpu-specific-macro.])

## Build into cross-compiler on Mac OS

if test x$enable_replace_cpp = xyes    \

        && test $ac_c_define_HOST_SYSTEM = SYS_MAC    \

        && test x${target_cc+set} = xset; then

    arch_opt="-arch $Target_Cpu"

fi

dnl Checks for header files.

AC_CHECK_HEADERS( [unistd.h, stdint.h, inttypes.h])

dnl Checks for typedefs, and compiler characteristics.

AC_CHECK_TYPES( [intmax_t, long long])

dnl Check for library functions.

AC_CHECK_FUNCS( [stpcpy])

dnl Checks for some system characteristics.

AC_CACHE_CHECK( if the cases of filename are folded,

    ac_cv_fname_fold,

    [touch hJkL

    [ac_cv_fname_fold=no]

    AC_RUN_IFELSE( [[

#include    <stdio.h>

#include    <errno.h>

    void exit();

int main( void)

{

    if (fopen( "HjKl", "r") == NULL)

        exit( errno);

    else

        exit( 0);

} ]],

        [ac_cv_fname_fold=yes],

        [],

        AC_MSG_WARN( cannot run on cross-compiling so assumes that the cases of filename are not folded.)

    )

    rm hJkL],

)

if test x$ac_cv_fname_fold = xyes; then

    AC_DEFINE( [FNAME_FOLD], 1,

        [Define if the cases of file name are folded.])

fi

dnl Checks for some host compiler characteristics.

AC_DEFINE_UNQUOTED( [OBJEXT], ["$ac_cv_objext"],

    [Define the suffix of object file.])

dnl Check printf length modifier of the longest integer.

# AC_CHECK_MOD_LL( modifier, additional include header)

# Try the printf length modifier for the longest integer.

# The redundant sscanf() is for some compilers which cannot handle

# long long integer token.

AC_DEFUN([AC_CHECK_MOD_LL], [

    AC_CACHE_CHECK( [printf length modifier for the longest integer],

        [ac_cv_c_printf_modifier],

        AC_RUN_IFELSE( [[

#include    <stdio.h>

#include    <assert.h>

    int     strcmp();

    void    exit();

$3

int main( void)

{   char    buf@<:@ 20@:>@;

    $1  num;

    sscanf( "1234567890123456789", "%$2d", &num);

    sprintf( buf, "%$2d", num);

    assert( strcmp( buf, "1234567890123456789") == 0);

    exit( 0);

} ]],

            [ac_cv_c_printf_modifier=$2],

            ,

            AC_MSG_WARN( cannot run on cross-compiling so assumes the length modifier of long long is "%ll")

            AC_DEFINE( [LL_FORM], "ll",

                [Define printf length modifier for the longest integer.])

            [ac_cv_c_printf_modifier=ll]

        )

    )

] )

if test x$ac_cv_type_intmax_t = xyes; then

    AC_CHECK_MOD_LL( [intmax_t], [j], [#include <stdint.h>])

    if test $ac_c_define_HOST_SYSTEM = SYS_CYGWIN \

            || test $ac_c_define_HOST_SYSTEM = SYS_MINGW; then

        sleep 1         # wait for cleanup

    fi

fi

if test x$ac_cv_type_long_long = xyes; then

    for modifier in ll I64 q L

    do

        AC_CHECK_MOD_LL( [long long], ${modifier})

        if test x${ac_cv_c_printf_modifier+set} = xset; then

            break

        fi

        if test $ac_c_define_HOST_SYSTEM = SYS_CYGWIN \

                || test $ac_c_define_HOST_SYSTEM = SYS_MINGW; then

            sleep 1         # wait for cleanup

        fi

    done

fi

if test x${ac_cv_c_printf_modifier+set} = xset; then

    AC_DEFINE_UNQUOTED( [LL_FORM], "$ac_cv_c_printf_modifier",

        [Define printf length modifier for the longest integer.])

fi

if test $ac_c_define_HOST_SYSTEM = SYS_FREEBSD &&   \

        test x$mcpp_ac_c_define_SYSTEM_SP_STD != x__FreeBSD__; then

    fbsd_ver=`echo '__FreeBSD__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ .*//'`

    AC_DEFINE_UNQUOTED( [SYSTEM_EXT_VAL], "$fbsd_ver",

        [Define the version of FreeBSD.])

fi

if test x$ac_cv_c_compiler_gnu = xyes; then

    AC_DEFINE( [HOST_COMPILER], [GNUC], [Define the host compiler.])

    AC_DEFINE( [HOST_CMP_NAME], "GCC", [Define the host compiler name.])

    AC_MSG_CHECKING( for value of __GNUC__)

    gcc_maj_ver=`echo '__GNUC__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ *//'`

    AC_MSG_RESULT( $gcc_maj_ver)

    AC_DEFINE_UNQUOTED( [GCC_MAJOR_VERSION], "$gcc_maj_ver",

        [Define gcc major version.])

    AC_MSG_CHECKING( for value of __GNUC_MINOR__)

    gcc_min_ver=`echo __GNUC_MINOR__ | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ *//'`

    AC_MSG_RESULT( $gcc_min_ver)

    AC_DEFINE_UNQUOTED( [GCC_MINOR_VERSION], "$gcc_min_ver",

        [Define gcc minor version.])

    cw=`pwd`

    if test x$srcdir = "x." || test x$srcdir = x; then

        src_dir=$cw

    else

        src_dir=$srcdir

    fi

    if test $ac_c_define_HOST_SYSTEM = SYS_CYGWIN; then

        AC_CACHE_CHECK( the root directory,

            ac_cv_cygwin_root,

            [ac_cv_cygwin_root=`$src_dir/config/cygwin_root`]

        )

        AC_DEFINE_UNQUOTED( [CYGWIN_ROOT_DIRECTORY], "$ac_cv_cygwin_root",

            [Define root directory of CYGWIN.])

    fi

    if test $ac_c_define_HOST_SYSTEM = SYS_MINGW; then

        AC_CACHE_CHECK( the root directory,

            ac_cv_msys_root,

            cd /tmp

            cat > getcwd.c <<\_EOF

#include <stdio.h>

#include <unistd.h>

#include <limits.h>

int main( int argc, char ** argv)

{   char    buf@<:@ PATH_MAX@:>@;

    getcwd( buf, PATH_MAX);

    puts( buf);

    return 0;

}

_EOF

            $CC getcwd.c

            cd /

            [ac_cv_msys_root=`$src_dir/config/mingw_root`]

        )

        AC_CACHE_CHECK( the /mingw directory,

            ac_cv_mingw_dir,

            cd /mingw

            [ac_cv_mingw_dir=`$src_dir/config/mingw_root`]

        )

        cd $cw

        rm -f /tmp/getcwd.c /tmp/a.exe

        AC_DEFINE_UNQUOTED( [MSYS_ROOT_DIRECTORY], "$ac_cv_msys_root",

            [Define root directory of MSYS.])

        AC_DEFINE_UNQUOTED( [MINGW_DIRECTORY], "$ac_cv_mingw_dir",

            [Define /mingw directory.])

    fi

else    # not gcc

# mcpp_AC_C_DEFINE( SYSTEM | CPU | COMPILER, STD | OLD, $enableval)

# Specify the target-specific predefined macro.

AC_DEFUN([mcpp_AC_C_DEFINE], [

    name=`echo $3 | sed 's/=.*//'`

    mcpp_macro=$1_SP_$2

    stripped_mcpp_macro=`echo $mcpp_macro | sed 's/STD//'`

    if test x$stripped_mcpp_macro != x$mcpp_macro; then

        stripped_name=`echo $name | sed 's/^_//'`

        if test x$stripped_name = x$name; then

            AC_MSG_ERROR( The macro name '$name' should begin with '_'.)

        fi

    else

        stripped_name=`echo $name | sed 's/^@<:@A-Za-z@:>@//'`

        if test x$stripped_name = x$name; then

            AC_MSG_ERROR( The macro name '$name' should begin with an alphabetic letter.)

        fi

    fi

    if test x$name = x$3; then

        [replace=1]

    else

        [replace=`echo $3 | sed 's/^.*=//'`]

    fi

    AC_DEFINE_UNQUOTED( [$mcpp_macro], "$name")

    AC_DEFINE_UNQUOTED( [${mcpp_macro}_VAL], "$replace")

    mcpp_ac_c_define_$1_$2=$name

])

# mcpp_AC_C_PREDEF( SYSTEM | CPU | COMPILER, STD | OLD, additional description)

# Specify the target-specific predefined macro via mcpp_AC_C_DEFINE.

AC_DEFUN([mcpp_AC_C_PREDEF], [

    AC_ARG_ENABLE( $1-$2-macro,

        AC_HELP_STRING( --enable-$1-$2-macro=name@<:@=replace@:>@,

            [specify the $1-specific $2-style predefined macro.  $3]),

        if test x$enableval = xyes || test x$enableval = xno; then

            AC_MSG_ERROR( This option requires an argument as 'name@<:@=replace@:>@'.)

        fi

        mcpp_AC_C_DEFINE( $1, $2, $enableval)

        AH_TEMPLATE( [$1_SP_$2],

            [Define the name of $1-specific $2-style predefined macro.])

        AH_TEMPLATE( [$1_SP_$2_VAL],

            [Define the value of $1-specific $2-style predefined macro.])

    )

])

mcpp_AC_C_PREDEF( [SYSTEM], [STD],

    [In all this and the following 5 options,

    'STD'-style name begins with an '_',

    'OLD'-style name begins with an alphabetic and

    if '=replace' is missing the macro is defined as 1.]

)

mcpp_AC_C_PREDEF( [SYSTEM], [OLD])

mcpp_AC_C_PREDEF( [CPU], [STD])

mcpp_AC_C_PREDEF( [CPU], [OLD])

mcpp_AC_C_PREDEF( [COMPILER], [STD])

mcpp_AC_C_PREDEF( [COMPILER], [OLD])

fi

## MacOS has "framework" directories.

if test $ac_c_define_HOST_SYSTEM = SYS_MAC; then

    AC_MSG_CHECKING( for the MacOS-specific framework directory)

    frameworks=`$CPP $CFLAGS $arch_opt -xc -v /dev/null 2>&1 | sed 's/^ *//' | sed 's/ .*$//' | $EGREP '/Frameworks$'`

    n=1

    for dir in $frameworks

    do

        case $n in

        1)  framework1=$dir;;

        2)  framework2=$dir;;

        3)  framework3=$dir;;

        esac

        let n=n+1

    done

    if test x${framework1+set} = xset; then

        AC_DEFINE_UNQUOTED( [FRAMEWORK1], "$framework1",

            [Define MacOS-specific framework directory 1.])

        AC_MSG_RESULT( $framework1)

    else

        AC_MSG_RESULT( none)

    fi

    if test x${framework2+set} = xset; then

        AC_DEFINE_UNQUOTED( [FRAMEWORK2], "$framework2",

            [Define MacOS-specific framework directory 2.])

        AC_MSG_RESULT( $framework2)

    fi

    if test x${framework3+set} = xset; then

        AC_DEFINE_UNQUOTED( [FRAMEWORK3], "$framework3",

            [Define MacOS-specific framework directory 3.])

        AC_MSG_RESULT( $framework3)

    fi

fi  ## SYS_MAC

## --enable-mcpplib option

AC_ARG_ENABLE( mcpplib,

    AC_HELP_STRING( [--enable-mcpplib],

        [Build libmcpp rather than stand-alone mcpp])

)

if test x$enable_mcpplib = xyes; then               ## mcpplib mode

    AC_DEFINE( [MCPP_LIB], 1, [Define if build libmcpp])

    if test x$enable_replace_cpp = xyes; then

        AC_MSG_WARN( Ignores enable-replace-cpp option)

        [enable_replace_cpp=no]

    fi

else

if test x$enable_replace_cpp = xyes; then           ## replace-cpp mode

dnl Check the characteristics of target compiler.

dnl Note: The following 3 hundred and more lines are for replace-cpp-mode.

dnl Target-compiler-specific configuration need these lines.

dnl These lines are not used in compiler-independent configuration.

dnl Check which header file CPP includes,

dnl relative to CURRENT or SOURCE directory.

# AC_C_INCLUDE_PREF( CURRENT | SOURCE | NEXT)

# Check the include preference ('NEXT' means CURRENT & SOURCE)

AC_DEFUN([AC_C_INCLUDE_PREF], [

    AC_EGREP_CPP( $1, [

#include "../next/header.h"

],

        [ac_cv_c_include_pref=$1],

    )

])

AC_CACHE_CHECK( include preference - relative to current or source directory,

    ac_cv_c_include_pref,

    mkdir mcpp-tmp

    cd mcpp-tmp

    mkdir dir ../next ../next/dir

    echo '#include "dir/what.h"'    > ../next/header.h

    echo '#include "next.h"'        >> ../next/header.h

    echo 'CURRENT'  > dir/what.h

    echo 'SOURCE'   > ../next/dir/what.h

    echo 'NEXT'     > ../next/next.h

    AC_C_INCLUDE_PREF( [SOURCE])

    if test x$ac_cv_c_include_pref != xSOURCE; then

        AC_C_INCLUDE_PREF( [CURRENT])

        if test x$ac_cv_c_include_pref = xCURRENT; then

            AC_C_INCLUDE_PREF( [NEXT])

            if test x$ac_cv_c_include_pref = xNEXT; then

                [ac_cv_c_include_pref="(CURRENT & SOURCE)"]

            fi

        else

            AC_MSG_ERROR( Failed to include header file.)

        fi

    fi

    cd ..

    rm -rf mcpp-tmp next

    if test $ac_c_define_HOST_SYSTEM = SYS_CYGWIN \

            || test $ac_c_define_HOST_SYSTEM = SYS_MINGW; then

        sleep 1         # wait for cleanup

    fi

)

AC_DEFINE_UNQUOTED( [SEARCH_INIT], $ac_cv_c_include_pref,

    [Define include preference.])

AC_CACHE_CHECK( if the argument of pragma is macro expanded,

    ac_cv_c_pragma_is_expanded,

    AC_COMPILE_IFELSE( [[

#define once

#pragma once]],

        [ac_cv_c_pragma_is_expanded=no],

        [ac_cv_c_pragma_is_expanded=yes]

    )

)

if test x$ac_cv_c_pragma_is_expanded = xyes; then

    AC_DEFINE( [EXPAND_PRAGMA], 1,

        [Define if the argument of pragma is macro expanded.])

fi

AC_CACHE_CHECK( if digraphs can be used,

    ac_cv_c_digraph,

    [AC_PREPROC_IFELSE( [

%:if 1

%:endif],

        [ac_cv_c_digraph=yes],

        [ac_cv_c_digraph=no]

    )]

)

if test x$ac_cv_c_digraph = xyes; then

    AC_DEFINE( [HAVE_DIGRAPHS], 1, [Define if digraphs are available.])

fi

AC_CACHE_CHECK( preprocessor output format of line directive,

    ac_cv_c_line_format,

    [ac_cv_c_line_format=\"`echo '#line 4321' | $CPP - | grep 432 | sed 's/432.*$//'`\"]

## Note: the output line number may be 4320 on GCC 2.* or other preprocessors.

)

AC_DEFINE_UNQUOTED( [LINE_PREFIX], $ac_cv_c_line_format,

    [Define output format of line directive.])

if test "x$ac_cv_c_line_format" = "x\"#line \""; then

    ac_cv_c_std_line_prefix=1

else

    ac_cv_c_std_line_prefix=0

fi

AC_DEFINE_UNQUOTED( [STD_LINE_PREFIX], $ac_cv_c_std_line_prefix,

    [Define whether output format of line directive is C source style.])

AC_CACHE_CHECK( default value of __STDC__,

    ac_cv_c_stdc,

    [stdc=`echo '__STDC__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ .*//'`]

    if test x"$stdc" = x"__STDC__"; then

        [ac_cv_c_stdc=0]

    else

        [ac_cv_c_stdc=$stdc]

    fi

)

AC_DEFINE_UNQUOTED( [STDC], $ac_cv_c_stdc,

    [Define the default value of __STDC__.])

AC_CACHE_CHECK( default value of __STDC_VERSION__,

    ac_cv_c_stdc_ver,

    [stdc_ver=`echo '__STDC_VERSION__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ .*//'`]

    if test x"$stdc_ver" = x"__STDC_VERSION__"; then

        [ac_cv_c_stdc_ver=0]

    else

        [ac_cv_c_stdc_ver=$stdc_ver]

    fi

)

AC_DEFINE_UNQUOTED( [STDC_VERSION], $ac_cv_c_stdc_ver,

    [Define the default value of __STDC_VERSION__.])

if test x${ac_cv_c_compiler_gnu} != xyes; then

# Specify the compiler's name

AC_ARG_WITH( compiler-name,

    AC_HELP_STRING( [--with-compiler-name=NAME],

        [specify the compiler name which is used as the definition of COMPILER macro]),

    AC_DEFINE_UNQUOTED( [COMPILER], $compiler_name, [specify the compiler name]),

    AC_MSG_ERROR( --with-compiler-name=NAME option should be specified to define [COMPILER] macro.)

)

# Specify the C++ header file directory

AC_ARG_WITH( cxx-include-dir,

    AC_HELP_STRING( [--with-cxx-include-dir=directory],

        [specify the C++ include directory by absolute path [[none]]]),

    [case "${withval}" in

    [\\/]* | [A-Za-z]:[\\/]*)

        cxx_include_dir=`echo $withval | sed 's,/$,,'; 's,\\$,,'`

        AC_DEFINE_UNQUOTED( [CPLUS_INCLUDE_DIR1], $cxx_include_dir,

            [Define the C++ include directory.])

        ;;

    *)  AC_MSG_ERROR( $withval should be an absolute path.) ;;

    esac]

)

fi  # not gcc

dnl Define compiler specific elements.

AC_MSG_NOTICE( checking for some compiler specific elements)

# Define GCC specific elements.

if test x$ac_cv_c_compiler_gnu = xyes; then

    AC_DEFINE( [COMPILER], [GNUC], [Define the target compiler.])

    cpp_call=`$CPP $CFLAGS $arch_opt -xc -v /dev/null 2>&1 | $EGREP '/cpp|/cc1' | sed 's/^ *//; s/ .*//'` 

    AC_MSG_CHECKING( for the directory to install mcpp)

    cpp_name=`expr $cpp_call : '.*/\(.*\)'`

    bindir=`expr $cpp_call : "\(.*\)/$cpp_name"`

    AC_MSG_RESULT( $bindir)

    AC_PATH_PROG( [gcc_path], [$CC], , [$PATH])

    cc_path=`echo $CC | $EGREP "/"`

    if test x$cc_path != x; then

        AC_MSG_ERROR( [Environment variables CC and CXX for GCC-specific-build should not contain a directory part.]);

    fi

    ## force to set $prefix to GCC's prefix

    ## (i.e. "/usr/local" of "/usr/local/bin/gcc")

    gcc_prefix=`echo $gcc_path | $EGREP "/bin/$CC\$" | sed "s,/bin/$CC\$,,"`

    if test "x$gcc_prefix" != xNONE; then

        if test "x$prefix" != xNONE && "x$gcc_prefix" != "x$prefix"; then

            AC_MSG_WARN( [Ignored --prefix option, since it conflicts with GCC path])

        fi

        prefix=$gcc_prefix

    else

        if test "x$prefix" = xNONE; then

            prefix=$ac_default_prefix

        fi

    fi

    lang_save=$LANG

    export LANG=C

    AC_MSG_CHECKING( for the compiler-specific C include directory)

    exclude="^/usr(/local|)/include\$|^${prefix}(/local|)/include\$|/Frameworks|End of search list"

    c_include_dirs=`$CPP $CFLAGS $arch_opt -xc -v /dev/null 2>&1 | sed '1,/<...> search starts here/d' | sed '/End of search list/q' | sed 's/^ *//' | $EGREP -v "$exclude"`

    n=1

    for dir in $c_include_dirs

    do

        case $n in

        1)  c_include_dir1=$dir;;

        2)  c_include_dir2=$dir;;

        3)  c_include_dir3=$dir;;

        esac

        let n=n+1

    done

    if test x${c_include_dir1+set} = xset; then

        AC_DEFINE_UNQUOTED( [C_INCLUDE_DIR1], "$c_include_dir1",

            [Define compiler-specific C include directory 1.])

        AC_MSG_RESULT( $c_include_dir1)

    else

        AC_MSG_RESULT( none)

    fi

    if test x${c_include_dir2+set} = xset; then

        AC_DEFINE_UNQUOTED( [C_INCLUDE_DIR2], "$c_include_dir2",

            [Define compiler-specific C include directory 2.])

        AC_MSG_RESULT( $c_include_dir2)

    fi

    if test x${c_include_dir3+set} = xset; then

        AC_DEFINE_UNQUOTED( [C_INCLUDE_DIR3], "$c_include_dir3",

            [Define compiler-specific C include directory 3.])

        AC_MSG_RESULT( $c_include_dir3)

    fi

    AC_PROG_CXX

    AC_PROG_CXXCPP

    AC_LANG_PUSH( C++)

    AC_MSG_CHECKING( for the compiler-specific C++ include directory)

    exclude="^/usr(/local|)/include\$|^${prefix}(/local|)/include\$|/Frameworks|^${c_include_dir1}\$|^${c_include_dir2}\$|^${c_include_dir3}\$"

    cxx_include_dirs=`${CXXCPP} ${CXXFLAGS} $arch_opt -xc++ -v /dev/null 2>&1 | sed '1,/<...> search starts here/d' | sed '/End of search list/q' | sed '/End of search list/d' | sed 's/^ *//' | $EGREP -v "$exclude"`

    n=1

    for dir in ${cxx_include_dirs}

    do

        case $n in

        1)  cxx_include_dir1=$dir;;

        2)  cxx_include_dir2=$dir;;

        3)  cxx_include_dir3=$dir;;

        4)  cxx_include_dir4=$dir;;

        esac

        let n=n+1

    done

    if test x${cxx_include_dir1+set} = xset; then

        AC_DEFINE_UNQUOTED( [CPLUS_INCLUDE_DIR1], "$cxx_include_dir1",

            [Define compiler-specific C++ include directory 1.])

        AC_MSG_RESULT( $cxx_include_dir1)

    fi

    if test x${cxx_include_dir2+set} = xset; then

        AC_DEFINE_UNQUOTED( [CPLUS_INCLUDE_DIR2], "$cxx_include_dir2",

            [Define compiler-specific C++ include directory 2.])

        AC_MSG_RESULT( $cxx_include_dir2)

    fi

    if test x${cxx_include_dir3+set} = xset; then

        AC_DEFINE_UNQUOTED( [CPLUS_INCLUDE_DIR3], "$cxx_include_dir3",

            [Define compiler-specific C++ include directory 3.])

        AC_MSG_RESULT( $cxx_include_dir3)

    fi

    if test x${cxx_include_dir4+set} = xset; then

        AC_DEFINE_UNQUOTED( [CPLUS_INCLUDE_DIR4], "$cxx_include_dir4",

            [Define compiler-specific C++ include directory 4.])

        AC_MSG_RESULT( $cxx_include_dir4)

    fi

    AC_LANG_POP( C++)

    export LANG=$lang_save

    ## the directory into which mcpp_g*.h header files are generated

    ## '/mcpp-gcc' will be appended to 'inc_dir'

    if test $ac_c_define_HOST_SYSTEM = SYS_MINGW; then

        inc_dir=$c_include_dir2

    else

        if test x${c_include_dir1+set} = xset; then

            inc_dir=$c_include_dir1

        else

            inc_dir="$prefix"/include

        fi

    fi

    AC_DEFINE_UNQUOTED( [INC_DIR], "$inc_dir",

        [Define include directory to install mcpp_g*.h header files.])

    AC_SUBST( [CPPFLAGS])

    AC_SUBST( [host_system])

    AC_SUBST( [Target_Cpu])

    AC_SUBST( [inc_dir])

    AC_SUBST( [gcc_maj_ver])

    AC_SUBST( [gcc_min_ver])

    AC_SUBST( [cpp_call])

    AC_PROG_LN_S

    if test x$gcc_maj_ver = x2; then

        AC_CACHE_CHECK( for value of predefined macro '__SIZE_TYPE__',

            size_type,

            [size_type=`echo '__SIZE_TYPE__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ *//'`]

        )

        AC_DEFINE_UNQUOTED( [COMPILER_SP1_VAL], "$size_type",

            [Define the type of size_t.])

        AC_CACHE_CHECK( for value of predefined macro '__PTRDIFF_TYPE__',

            ptrdiff_type,

            [ptrdiff_type=`echo '__PTRDIFF_TYPE__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ *$//'`]

        )

        AC_DEFINE_UNQUOTED( [COMPILER_SP2_VAL], "$ptrdiff_type",

            [Define the type of ptrdiff_t.])

        AC_CACHE_CHECK( for value of predefined macro '__WCHAR_TYPE__',

            wchar_type,

            [wchar_type=`echo '__WCHAR_TYPE__' | $CPP - | sed 's/^ *//' | $EGREP -v '^#|^$' | sed 's/ *$//'`]

        )

        AC_DEFINE_UNQUOTED( [COMPILER_SP3_VAL], "$wchar_type",

        [Define the type of wchar_t.])

    fi

fi

## Handling of multi-byte characters containing '0x5c' codes:

## These tests cannot be executed without appropriate options for the

## compiler.  So, here we define all of these macros as FALSE.

## User should edit config.h by hand after executing this script.

## These should be 0 for GCC at least upto V.4.1.

    AC_DEFINE( [SJIS_IS_ESCAPE_FREE], 0,

        [Define if '0x5c' in SJIS multi-byte character is safe.])

    AC_DEFINE( [ISO2022_JP_IS_ESCAPE_FREE], 0,

        [Define if '0x5c' in ISO2022-JP multi-byte character is safe.])

    AC_DEFINE( [BIGFIVE_IS_ESCAPE_FREE], 0,

        [Define if '0x5c' in BIG5 multi-byte character is safe.])

fi ## replace-cpp mode

fi ## build-cpp mode or replace-cpp mode

AC_ARG_WITH( [gcc-testsuite-dir],

    AC_HELP_STRING( [--with-gcc-testsuite-dir=directory],

        [specify the gcc testsuite directory to do make check.

        e.g. /usr/src/rpm/SOURCES/gcc-2.95.4/gcc/testsuite,

        /usr/local/src/gcc-3.2/gcc/testsuite, etc.

        The testsuite of mcpp uses gcc testsuite, hence needs gcc source

        or at least gcc testsuite.

        This option needs --enable-replace-cpp option.]),

    if test x${withval+set} = xset; then

        if test x$enable_replace_cpp = xyes; then

            [gcc_testsuite_dir=`echo $withval | sed 's,/$,,'`]

        else

            AC_MSG_ERROR( [--with-gcc-testsuite-dir option requires --enable-replace-cpp option.])

        fi

    else

        AC_MSG_ERROR( [--with-gcc-testsuite-dir option requires an argument.])

    fi

)

AC_SUBST( [gcc_testsuite_dir])

AM_CONDITIONAL( [GNUC], test x$ac_cv_c_compiler_gnu = xyes)

AM_CONDITIONAL( [MCPP_LIB], test x$enable_mcpplib = xyes)

AM_CONDITIONAL( [REPLACE_CPP], test x$enable_replace_cpp = xyes)

AM_CONDITIONAL( [MINGW], test $ac_c_define_HOST_SYSTEM = SYS_MINGW)

dnl Final output.

AC_OUTPUT( Makefile src/Makefile tests/Makefile)