dnl @synopsis AX_CREATE_TARGET_H [(HEADER-FILE [,PREFIX)]
dnl
dnl create the header-file and let it contain '#defines' for the target
dnl platform. This macro is used for libraries that have
dnl platform-specific quirks. Instead of inventing a target-specific
dnl target.h.in files, just let it create a header file from the
dnl definitions of AC_CANONICAL_SYSTEM and put only ifdef's in the
dnl installed header-files.
dnl
dnl  if the HEADER-FILE is absent, [target.h] is used. 
dnl  if the PREFIX is absent, [TARGET] is used. 
dnl  the prefix can be the packagename. (y:a-z-:A-Z_:)
dnl
dnl the defines look like...
dnl
dnl  #ifndef TARGET_CPU_M68K
dnl  #define TARGET_CPU_M68K "m68k"
dnl  #endif
dnl
dnl  #ifndef TARGET_OS_LINUX
dnl  #define TARGET_OS_LINUX "linux-gnu"
dnl  #endif
dnl
dnl  #ifndef TARGET_OS_TYPE                     /* the string itself */
dnl  #define TARGET_OS_TYPE "linux-gnu"
dnl  #endif
dnl
dnl detail: in the case of hppa1.1, the three idents "hppa1_1" "hppa1"
dnl and "hppa" are derived, for an m68k it just two, "m68k" and "m"
dnl
dnl variants:
dnl - AX_CREATE_TARGET_H - the host and target defines
dnl - AX_CREATE_PREFIX_TARGET_H - host and target defines with package prefix
dnl - AX_CREATE_HOST_H - only host defines
dnl - AX_CREATE_PREFIX_HOST_H - only host defines with package prefix
dnl
dnl implementation note:
dnl - it should have been defined through config.status but it is not.
dnl
dnl @category Misc
dnl @author Guido U. Draheim <guidod@gmx.de>
dnl @version 2007-07-27
dnl @license GPLWithACException

dnl -------------------------------------------------------------------

dnl
dnl the instruction set architecture (ISA) has evolved for a small set
dnl of cpu types. So they often have specific names, e.g. sparclite,
dnl yet they share quite a few similarities. This macro will set the
dnl shell-var $target_cpu_type to the basic type. Note that these
dnl names are often in conflict with their original 32-bit type name
dnl of these processors, just use them for directory-handling or add
dnl a prefix/suffix to distinguish them from $target_cpu
dnl
dnl this macros has been invented since config.guess is sometimes
dnl too specific about the cpu-type. I chose the names along the lines
dnl of linux/arch/ which is modelled after widespread arch-naming, IMHO.
dnl A longer definition can be found in elf.h as the EM_* defines.
dnl
AC_DEFUN([AX_SET_CANONICAL_CPU_TYPE],[dnl
AS_VAR_PUSHDEF([TYPE],[$1])dnl
AS_VAR_PUSHDEF([CPU],[$2])dnl
TYPE=`echo "$CPU" | $as_tr_sh`
case $TYPE 
in i386*|i486*|i586*|i686*|i786*) TYPE="i386"
;; power*)   TYPE="ppc"
;; arm*)     TYPE="arm"
;; sparc64*) TYPE="sparc64"
;; sparc*)   TYPE="sparc"
;; mips64*)  TYPE="mips64"
;; mips*|cris*|etrax*) TYPE="mips"
;; alpha*)   TYPE="alpha"
;; hppa1*)   TYPE="hppa1"
;; hppa2*)   TYPE="hppa2"
;; arm*)     TYPE="arm"
;; sh*64)    TYPE="sh64"
;; sh*)      TYPE="sh"
;; m68???|mcf54??) TYPE="m68k"
;; esac
AS_VAR_POPDEF([CPU])dnl
AS_VAR_POPDEF([TYPE])dnl
])

AC_DEFUN([AX_SET_CANONICAL_OS_TYPE],[dnl
AS_VAR_PUSHDEF([TYPE],[$1])dnl
AS_VAR_PUSHDEF([OS],[$2])dnl
TYPE=`echo "$OS" | $as_tr_sh`
case $TYPE
in solaris*|sunos*)            TYPE="solaris"
;; *linux*)                    TYPE="linux"
;; *bsd*|*darwin*|*irix*)      TYPE="bsd"
;; win*|vista*)                TYPE="windows"
;; *sysv*|*aix*|*hpux*|*true*) TYPE="sysv"
;; esac
AS_VAR_POPDEF([OS])dnl
AS_VAR_POPDEF([TYPE])dnl
])


AC_DEFUN([AX_CANONICAL_BUILD_CPU_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
AX_SET_CANONICAL_CPU_TYPE([build_cpu_type],[build_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_HOST_CPU_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_HOST])dnl
AX_SET_CANONICAL_CPU_TYPE([host_cpu_type],[host_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_TARGET_CPU_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_TARGET])dnl
AX_SET_CANONICAL_CPU_TYPE([target_cpu_type],[target_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_BUILD_OS_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
AX_SET_CANONICAL_OS_TYPE([build_os_type],[build_os])dnl
])

AC_DEFUN([AX_CANONICAL_HOST_OS_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_HOST])dnl
AX_SET_CANONICAL_OS_TYPE([host_os_type],[host_os])dnl
])

AC_DEFUN([AX_CANONICAL_TARGET_OS_TYPE],[dnl
AC_REQUIRE([AC_CANONICAL_TARGET])dnl
AX_SET_CANONICAL_OS_TYPE([target_os_type],[target_os])dnl
])

AC_DEFUN([AX_SET_CANONICAL_SHORTHAND_TYPES],[dnl
AS_VAR_PUSHDEF([DEF0],[$1_0])dnl
AS_VAR_PUSHDEF([DEF1],[$1_1])dnl
AS_VAR_PUSHDEF([DEF2],[$1_2])dnl
AS_VAR_PUSHDEF([DEF3],[$1_3])dnl
DEF0=`echo "$2" | $as_tr_cpp`
DEF1=`echo "$DEF0" | sed "s:\\(m4_dquote(^$as_cr_digits)*\\).*:\\1:"`
DEF2=`echo "$DEF0" | sed "s:\\(m4_dquote(^_)*\\).*:\\1:"`
DEF3=`echo "$DEF2" | sed "s:\\(m4_dquote(^$as_cr_digits)*\\).*:\\1:"`
AS_VAR_POPDEF([DEF3])dnl
AS_VAR_POPDEF([DEF2])dnl
AS_VAR_POPDEF([DEF1])dnl
AS_VAR_POPDEF([DEF0])dnl
])

AC_DEFUN([AX_CANONICAL_BUILD_CPU_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_BUILD_CPU_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([build_cpu_type],[$build_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_HOST_CPU_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_CPU_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([host_cpu_type],[$host_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_TARGET_CPU_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_TARGET_CPU_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([target_cpu_type],[$target_cpu])dnl
])

AC_DEFUN([AX_CANONICAL_BUILD_OS_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_BUILD_OS_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([build_os_type],[$build_os])dnl
])

AC_DEFUN([AX_CANONICAL_HOST_OS_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_OS_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([host_os_type],[$host_os])dnl
])

AC_DEFUN([AX_CANONICAL_TARGET_OS_TYPES],[dnl
AC_REQUIRE([AX_CANONICAL_TARGET_OS_TYPE])dnl
AX_SET_CANONICAL_SHORTHAND_TYPES([target_os_type],[$target_os])dnl
])

AC_DEFUN([AX_CREATE_TARGET_DEFINE_INTO],[dnl
  {
   echo ""
   echo "#ifndef $2"
   echo "#define $2" $3
   echo "#endif"
  } >> $1
])
AC_DEFUN([AX_CREATE_TARGET_DEFINE_INTO_],[dnl
  AX_CREATE_TARGET_DEFINE_INTO([$1],[$2],['"'"$3"'"'])dnl
])

AC_DEFUN([AX_CREATE_WRITE_TARGET_INIT],[dnl
ax_create_write_target_h_defines="::"
])

AC_DEFUN([AX_CREATE_WRITE_TARGET_H],[dnl
AC_REQUIRE([AX_CREATE_WRITE_TARGET_INIT])dnl
AS_VAR_PUSHDEF([OLD],[ax_create_write_target_h_defines])dnl
for varname in $3 ; do
  varvalue=`eval echo '$'"$varname" `
  vardefine=`echo "$2"_"$varvalue" | $as_tr_cpp`
  if test "<$varvalue>" != "<>"; then
    case "$OLD:" 
    in *:$vardefine:*) : variable already defined
    ;; *) AX_CREATE_TARGET_DEFINE_INTO([$1],[$vardefine],[1])
    ;; esac
    OLD="$OLD:$vardefine"
  fi
done
AS_VAR_POPDEF([OLD])dnl
])

AC_DEFUN([AX_CREATE_UPDATE_TARGET_H],[dnl
    if cmp -s $1 $2 2>/dev/null; then
      rm -f $1
      AC_MSG_NOTICE([unchanged $2])
    else
      ac_dir=`AS_DIRNAME(["$2"])`
      AS_MKDIR_P(["$ac_dir"])
      rm -f $2
      mv $1 $2
    fi
])

dnl --------------------------------------------------------------- CPU

AC_DEFUN([AX_CREATE_HOST_CPU_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_CPU_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[dnl
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical host cpu target defines])
TMP="$tmp/target.h"
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU,[$host_cpu])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU_TYPE,[$host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU_TYPE,[host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU,[ \
  host_cpu_type host_cpu_type_0 \
  host_cpu_type_1 host_cpu_type_2 host_cpu_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
host_cpu="$host_cpu"
host_cpu_type="$host_cpu_type"
host_cpu_type_0="$host_cpu_type_0"
host_cpu_type_1="$host_cpu_type_1"
host_cpu_type_2="$host_cpu_type_2"
host_cpu_type_3="$host_cpu_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_HOST_CPU_TARGET_H],[
AX_CREATE_HOST_CPU_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

AC_DEFUN([AX_CREATE_CPU_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_CPU_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_TARGET_CPU_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical cpu target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_HOST_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU,[$host_cpu])
AX_CREATE_HOST_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU_TYPE,[$host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU_TYPE,[host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU,[ \
  host_cpu_type host_cpu_type_0 \
  host_cpu_type_1 host_cpu_type_2 host_cpu_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_CPU,[$target_cpu])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_CPU_TYPE,[$target_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_CPU_TYPE,[target_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_CPU,[ \
  target_cpu_type target_cpu_type_0 \
  target_cpu_type_1 target_cpu_type_2 target_cpu_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
target_cpu="$target_cpu"
target_cpu_type="$target_cpu_type"
target_cpu_type_0="$target_cpu_type_0"
target_cpu_type_1="$target_cpu_type_1"
target_cpu_type_2="$target_cpu_type_2"
target_cpu_type_3="$target_cpu_type_3"
host_cpu="$host_cpu"
host_cpu_type="$host_cpu_type"
host_cpu_type_0="$host_cpu_type_0"
host_cpu_type_1="$host_cpu_type_1"
host_cpu_type_2="$host_cpu_type_2"
host_cpu_type_3="$host_cpu_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_CPU_TARGET_H],[
AX_CREATE_CPU_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

AC_DEFUN([AX_CREATE_BUILD_CPU_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_CPU_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_TARGET_CPU_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_BUILD_CPU_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical build cpu target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_HOST_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU,[$host_cpu])
AX_CREATE_HOST_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU_TYPE,[$host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU_TYPE,[host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU,[ \
  host_cpu_type host_cpu_type_0 \
  host_cpu_type_1 host_cpu_type_2 host_cpu_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_CPU,[$target_cpu])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_CPU_TYPE,[$target_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_CPU_TYPE,[target_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_CPU,[ \
  target_cpu_type target_cpu_type_0 \
  target_cpu_type_1 target_cpu_type_2 target_cpu_type_3])
AX_CREATE_BUILD_DEFINE_INTO_($TMP, ${PRE}_BUILD_CPU,[$build_cpu])
AX_CREATE_BUILD_DEFINE_INTO_($TMP, ${PRE}_BUILD_CPU_TYPE,[$build_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_BUILD_CPU_TYPE,[build_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_BUILD_CPU,[ \
  build_cpu_type build_cpu_type_0 \
  build_cpu_type_1 build_cpu_type_2 build_cpu_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
host_cpu="$host_cpu"
host_cpu_type="$host_cpu_type"
host_cpu_type_0="$host_cpu_type_0"
host_cpu_type_1="$host_cpu_type_1"
host_cpu_type_2="$host_cpu_type_2"
host_cpu_type_3="$host_cpu_type_3"
target_cpu="$target_cpu"
target_cpu_type="$target_cpu_type"
target_cpu_type_0="$target_cpu_type_0"
target_cpu_type_1="$target_cpu_type_1"
target_cpu_type_2="$target_cpu_type_2"
target_cpu_type_3="$target_cpu_type_3"
build_cpu="$build_cpu"
build_cpu_type="$build_cpu_type"
build_cpu_type_0="$build_cpu_type_0"
build_cpu_type_1="$build_cpu_type_1"
build_cpu_type_2="$build_cpu_type_2"
build_cpu_type_3="$build_cpu_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_BUILD_CPU_TARGET_H],[
AX_CREATE_BUILD_CPU_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

dnl --------------------------------------------------------------- OS

AC_DEFUN([AX_CREATE_HOST_OS_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_OS_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical host os target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS,[$host_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS_TYPE,[$host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS_TYPE,[host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS,[ \
  host_os_type host_os_type_0 \
  host_os_type_1 host_os_type_2 host_os_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
host_os="$host_os"
host_os_type="$host_os_type"
host_os_type_0="$host_os_type_0"
host_os_type_1="$host_os_type_1"
host_os_type_2="$host_os_type_2"
host_os_type_3="$host_os_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_HOST_OS_TARGET_H],[
AX_CREATE_HOST_OS_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

AC_DEFUN([AX_CREATE_OS_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_OS_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_TARGET_OS_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical os target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS,[$host_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS_TYPE,[$host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS_TYPE,[host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS,[ \
  host_os_type host_os_type_0 \
  host_os_type_1 host_os_type_2 host_os_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_OS,[$target_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_OS_TYPE,[$target_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_OS_TYPE,[target_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_OS,[ \
  target_os_type target_os_type_0 \
  target_os_type_1 target_os_type_2 target_os_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
target_os="$target_os"
target_os_type="$target_os_type"
target_os_type_0="$target_os_type_0"
target_os_type_1="$target_os_type_1"
target_os_type_2="$target_os_type_2"
target_os_type_3="$target_os_type_3"
host_os="$host_os"
host_os_type="$host_os_type"
host_os_type_0="$host_os_type_0"
host_os_type_1="$host_os_type_1"
host_os_type_2="$host_os_type_2"
host_os_type_3="$host_os_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_OS_TARGET_H],[
AX_CREATE_OS_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

AC_DEFUN([AX_CREATE_BUILD_OS_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_OS_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_TARGET_OS_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_BUILD_OS_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical build os target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS,[$host_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS_TYPE,[$host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS_TYPE,[host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS,[ \
  host_os_type host_os_type_0 \
  host_os_type_1 host_os_type_2 host_os_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_OS,[$target_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_TARGET_OS_TYPE,[$target_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_OS_TYPE,[target_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_TARGET_OS,[ \
  target_os_type target_os_type_0 \
  target_os_type_1 target_os_type_2 target_os_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_BUILD_OS,[$build_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_BUILD_OS_TYPE,[$build_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_BUILD_OS_TYPE,[build_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_BUILD_OS,[ \
  build_os_type build_os_type_0 \
  build_os_type_1 build_os_type_2 build_os_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
host_os="$host_os"
host_os_type="$host_os_type"
host_os_type_0="$host_os_type_0"
host_os_type_1="$host_os_type_1"
host_os_type_2="$host_os_type_2"
host_os_type_3="$host_os_type_3"
target_os="$target_os"
target_os_type="$target_os_type"
target_os_type_0="$target_os_type_0"
target_os_type_1="$target_os_type_1"
target_os_type_2="$target_os_type_2"
target_os_type_3="$target_os_type_3"
build_os="$build_os"
build_os_type="$build_os_type"
build_os_type_0="$build_os_type_0"
build_os_type_1="$build_os_type_1"
build_os_type_2="$build_os_type_2"
build_os_type_3="$build_os_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_BUILD_OS_TARGET_H],[
AX_CREATE_BUILD_OS_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])

dnl --------------------------------------------------------------- OS + CPU

AC_DEFUN([AX_CREATE_HOST_TARGET_H],[dnl
AC_REQUIRE([AX_CANONICAL_HOST_CPU_TYPES])dnl
AC_REQUIRE([AX_CANONICAL_HOST_OS_TYPES])dnl
ax_create_target_h=ifelse($1, ,target.h, $1)
ax_create_target_prefix=ifelse($2, , _, $2)
AC_CONFIG_COMMANDS($ax_create_target_h,[
AC_MSG_NOTICE([creating: $ax_create_target_h: canonical host target defines])
AS_VAR_PUSHDEF([TMP],[ax_create_target_h_tmp])
AS_VAR_PUSHDEF([PRE],[ax_create_target_prefix])
TMP="$tmp/target.h"
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU,[$host_cpu])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_CPU_TYPE,[$host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU_TYPE,[host_cpu_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_CPU,[ \
  host_cpu_type host_cpu_type_0 \
  host_cpu_type_1 host_cpu_type_2 host_cpu_type_3])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS,[$host_os])
AX_CREATE_TARGET_DEFINE_INTO_($TMP, ${PRE}_HOST_OS_TYPE,[$host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS_TYPE,[host_os_type])
AX_CREATE_WRITE_TARGET_H($TMP, ${PRE}_HOST_OS,[ \
  host_os_type host_os_type_0 \
  host_os_type_1 host_os_type_2 host_os_type_3])
AX_CREATE_UPDATE_TARGET_H($TMP,$ax_create_target_h)
AS_VAR_POPDEF([PRE])
AS_VAR_POPDEF([TMP])
  ],[dnl
ax_create_target_h="$ax_create_target_h"
ax_create_target_prefix="$ax_create_target_prefix"
host_cpu="$host_cpu"
host_cpu_type="$host_cpu_type"
host_cpu_type_0="$host_cpu_type_0"
host_cpu_type_1="$host_cpu_type_1"
host_cpu_type_2="$host_cpu_type_2"
host_cpu_type_3="$host_cpu_type_3"
host_os="$host_os"
host_os_type="$host_os_type"
host_os_type_0="$host_os_type_0"
host_os_type_1="$host_os_type_1"
host_os_type_2="$host_os_type_2"
host_os_type_3="$host_os_type_3"
  ])dnl
])

AC_DEFUN([AX_CREATE_PREFIX_HOST_TARGET_H],[
AX_CREATE_HOST_TARGET_H([$1],[ifelse($2, ,$PACKAGE, $2)])dnl
])