Edit

kc3-lang/kc3/config.subr

Branch :

  • config.subr 
  • #!/bin/sh
## kc3
## Copyright 2022-2024 kmx.io <contact@kmx.io>
##
## Permission is hereby granted to use this software granted the above
## copyright notice and this permission paragraph are included in all
## copies and substantial portions of this software.
##
## THIS SOFTWARE IS PROVIDED "AS-IS" WITHOUT ANY GUARANTEE OF
## PURPOSE AND PERFORMANCE. IN NO EVENT WHATSOEVER SHALL THE
## AUTHOR BE CONSIDERED LIABLE FOR THE USE AND PERFORMANCE OF
## THIS SOFTWARE.

set -e

cd "$(dirname "$0")"

build_lib() {
    echo >> ${CONFIG_MK}
    echo "$LIB_ASAN: $OBJECTS_ASAN .build_ld_asan" >> ${CONFIG_MK}
    echo "	./.build_ld_asan $LIB_ASAN" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$LIB_COV: $OBJECTS_COV .build_ld_cov" >> ${CONFIG_MK}
    echo "	./.build_ld_cov $LIB_COV" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$LIB_DEBUG: $OBJECTS_DEBUG .build_ld_debug" >> ${CONFIG_MK}
    echo "	./.build_ld_debug $LIB_DEBUG" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$LIB: $OBJECTS .build_ld_main" >> ${CONFIG_MK}
    echo "	./.build_ld_main $LIB" >> ${CONFIG_MK}
}

build_lo() {
    for SRC in $SOURCES; do
        echo >> ${CONFIG_MK}
        SRC_ASAN_LO="$(c2ext .asan.lo "$SRC")"
        c_ext_rule .asan.lo "$SRC" .build_cc_asan >> ${CONFIG_MK}
        echo "	./.build_cc_asan $SRC $SRC_ASAN_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_COV_LO="$(c2ext .cov.lo "$SRC")"
        c_ext_rule .cov.lo "$SRC" .build_cc_cov >> ${CONFIG_MK}
        echo "	./.build_cc_cov $SRC $SRC_COV_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_DEBUG_LO="$(c2ext .debug.lo "$SRC")"
        c_ext_rule .debug.lo "$SRC" .build_cc_debug >> ${CONFIG_MK}
        echo "	./.build_cc_debug $SRC $SRC_DEBUG_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_LO="$(c2ext .main.lo "$SRC")"
        c_ext_rule .main.lo "$SRC" .build_cc_main >> ${CONFIG_MK}
        echo "	./.build_cc_main $SRC $SRC_LO" >> ${CONFIG_MK}
    done
}

build_lo_objc() {
    for SRC in $OBJC_SOURCES; do
        echo >> ${CONFIG_MK}
        SRC_LO="$(objc2ext .main.lo "$SRC")"
        objc_ext_rule .main.lo "$SRC" .build_objcc_main >> ${CONFIG_MK}
        echo "	./.build_objcc_main $SRC $SRC_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_LO="$(objc2ext .asan.lo "$SRC")"
        objc_ext_rule .asan.lo "$SRC" .build_objcc_asan >> ${CONFIG_MK}
        echo "	./.build_objcc_asan $SRC $SRC_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_LO="$(objc2ext .cov.lo "$SRC")"
        objc_ext_rule .cov.lo "$SRC" .build_objcc_cov >> ${CONFIG_MK}
        echo "	./.build_objcc_cov $SRC $SRC_LO" >> ${CONFIG_MK}

        echo >> ${CONFIG_MK}
        SRC_LO="$(objc2ext .debug.lo "$SRC")"
        objc_ext_rule .debug.lo "$SRC" .build_objcc_debug >> ${CONFIG_MK}
        echo "	./.build_objcc_debug $SRC $SRC_LO" >> ${CONFIG_MK}
    done
}

build_prog() {
    echo >> ${CONFIG_MK}
    echo "$PROG_ASAN: $LOCAL_LIBS_ASAN $OBJECTS_ASAN .build_ld_asan" \
         >> ${CONFIG_MK}
    echo "	./.build_ld_asan $PROG_ASAN" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$PROG_COV: $LOCAL_LIBS_COV $OBJECTS_COV .build_ld_cov" \
         >> ${CONFIG_MK}
    echo "	./.build_ld_cov $PROG_COV" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$PROG_DEBUG: $LOCAL_LIBS_DEBUG $OBJECTS_DEBUG .build_ld_debug" \
         >> ${CONFIG_MK}
    echo "	./.build_ld_debug $PROG_DEBUG" >> ${CONFIG_MK}

    echo >> ${CONFIG_MK}
    echo "$PROG: $LOCAL_LIBS $OBJECTS .build_ld_main" >> ${CONFIG_MK}
    echo "	./.build_ld_main $PROG" >> ${CONFIG_MK}
}

c_o_rule() {
    "$CC" $CPPFLAGS $CFLAGS -M "$1" || {
        echo "$1" | sed -e 's/^\(.*\)\.c$/\1.o: \1.c/'
    }
    echo "$1: $2" | sed -e 's/^\(.*\)\.c:/\1.o:/'
}

c_ext_rule() {
    c_o_rule "$2" "$3" | sed -e "s/\.o:/$1:/"
}

c_lo_rule() {
    c_ext_rule .lo "$1"
}

c_prog_rule() {
    { c_o_rule "$1" || exit 1; } | sed -e 's/[.]o:/:/'
}

c2ext() {
    EXT="$1"; shift
    echo "$@" | sed -e "s/[.]c$/${EXT}/" -e "s/[.]c /${EXT} /g"
}

c2la() {
    c2ext .la "$@"
}

c2lo() {
    c2ext .lo "$@"
}

c2o() {
    c2ext .o "$@"
}

c2prog() {
    echo "$@" | sed -e 's/[.]c$//' -e 's/[.]c / /g'
}

config_asan() {
    config_lib_have ASAN -lasan
}

config_define() {
    echo "#define $1 $2" >> "${CONFIG_H}"
}

config_have_stat_mtim() {
    OUT=".config_have_stat_mtim"
    OUT_C=".config_have_stat_mtim.c"
    echo "/* generated by configure */" > "$OUT_C"
    echo "#include <sys/stat.h>" >> "$OUT_C"
    echo "#ifdef __APPLE__" >> "$OUT_C"
    echo "# define st_mtim st_mtimespec" >> "$OUT_C"
    echo "#endif" >> "$OUT_C"
    echo "int main (void) {" >> "$OUT_C"
    echo "  struct stat tmp;" >> "$OUT_C"
    echo "  tmp.st_mtim.tv_sec = 0;" >> "$OUT_C"
    echo "  tmp.st_mtim.tv_nsec = 0;" >> "$OUT_C"
    echo "  return tmp.st_mtim.tv_sec + tmp.st_mtim.tv_nsec;" \
         >> "$OUT_C"
    echo "}" >> "$OUT_C"
    if $LIBTOOL --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                "$OUT_C" -o "$OUT"; then
        echo "#define HAVE_STAT_MTIM 1" >> "${CONFIG_H}"
        HAVE_STAT_MTIM=true
    else
        echo "#define HAVE_STAT_MTIM 0" >> "${CONFIG_H}"
        HAVE_STAT_MTIM=false
    fi
    rm -f "$OUT_C"
    rm -f "$OUT"
}

config_gnu() {
    if grep -q _GNU_SOURCE /usr/include/features.h 2>/dev/null; then
	CFLAGS="$CFLAGS -D_GNU_SOURCE -D_DEFAULT_SOURCE -D_BSD_SOURCE"
    fi
}

config_i386() {
    if [ "x$(uname -m)" = "xi386" ]; then
	CFLAGS="$CFLAGS -msse2 -mfpmath=sse"
    fi
}

config_include() {
    OUT=".config_$1"
    OUT_C=".config_$1.c"
    shift
    echo "/* generated by configure */" > "$OUT_C"
    while [ $# -gt 1 ]; do
        echo "#include <$1>" >> "$OUT_C"
        shift
    done
    echo "int main (void) { return 0; }" >> "$OUT_C"
    if $LIBTOOL --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                "$OUT_C" -o "$OUT" >/dev/null 2>&1; then
        echo "#define $1 1" >> "${CONFIG_H}"
        eval "$1=Yes"
    else
        echo "#define $1 0" >> "${CONFIG_H}"
        eval "$1=No"
    fi
    rm -f "$OUT_C"
    rm -f "$OUT"
}

config_include_have() {
    NAME="$1"
    shift
    OUT_C=".config_$NAME.c"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_C"
    echo "$@" >> "$OUT_C"
    echo "int main (void) { return 0; }" >> "$OUT_C"
    if $LIBTOOL --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                "$OUT_C" ${LIBS} -o "$OUT"; then
        eval "HAVE_$NAME=true"
        echo "HAVE_$NAME = true" >> ${CONFIG_MK}
    else
        eval "HAVE_$NAME=false"
        echo "HAVE_$NAME = false" >> ${CONFIG_MK}
    fi
    rm -f "$OUT" "$OUT_C"
}

config_lib() {
    NAME="$1"
    shift
    OUT_C=".config_$NAME.c"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_C"
    echo "int main (void) { return 0; }" >> "$OUT_C"
    if $LIBTOOL --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                "$OUT_C" ${LDFLAGS} ${LIBS} $@ -o "$OUT" \
                >/dev/null 2>&1; then
        LIBS="$LIBS $@"
        eval "HAVE_$NAME=true"
        echo "HAVE_$NAME = true" >> ${CONFIG_MK}
    else
        eval "HAVE_$NAME=false"
        echo "HAVE_$NAME = false" >> ${CONFIG_MK}
    fi
    rm -f "$OUT" "$OUT_C"
}

config_lib_have() {
    NAME="$1"
    shift
    OUT_C=".config_$NAME.c"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_C"
    echo "int main (void) { return 0; }" >> "$OUT_C"
    if $LIBTOOL --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                "$OUT_C" ${LIBS} $@ -o "$OUT" >/dev/null 2>&1; then
        eval "HAVE_$NAME=true"
        echo "HAVE_$NAME = true" >> ${CONFIG_MK}
    else
        eval "HAVE_$NAME=false"
        echo "HAVE_$NAME = false" >> ${CONFIG_MK}
    fi
    rm -f "$OUT" "$OUT_C"
}

config_no_undefined() {
    OUT_C=".config_no_undefined.c"
    OUT=".config_no_undefined"
    echo "/* generated by configure */" > "$OUT_C"
    echo "int main (void) { return 0; }" >> "$OUT_C"
    if ${LIBTOOL} --tag CC --mode link ${CC} ${CPPFLAGS} ${CFLAGS} \
                  "$OUT_C" ${LDFLAGS} -no-undefined ${LIBS} $@ \
                  -o "$OUT" >/dev/null 2>&1; then
        LDFLAGS="$LDFLAGS -no-undefined"
    fi
    rm -f "$OUT" "$OUT_C"
}

config_objc_include_have() {
    NAME="$1"
    shift
    OUT_M=".config_$NAME.m"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_M"
    echo "$@" >> "$OUT_M"
    echo "int main (void) { return 0; }" >> "$OUT_M"
    if $LIBTOOL --tag CC --mode link ${OBJCC} ${CPPFLAGS} ${OBJCFLAGS} \
                "$OUT_M" ${LIBS} -o "$OUT" >/dev/null 2>&1; then
        eval "HAVE_$NAME=true"
        echo "HAVE_$NAME = true" >> ${CONFIG_MK}
    else
        eval "HAVE_$NAME=false"
        echo "HAVE_$NAME = false" >> ${CONFIG_MK}
    fi
    rm -f "$OUT" "$OUT_M"
}

config_objc_lib() {
    NAME="$1"
    shift
    OUT_M=".config_$NAME.m"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_M"
    echo "int main (void) { return 0; }" >> "$OUT_M"
    if $LIBTOOL --tag CC --mode link ${OBJCC} ${CPPFLAGS} ${OBJCFLAGS} \
                "$OUT_M" ${LDFLAGS} ${LIBS} $@ \
                -o "$OUT" >/dev/null 2>&1; then
        LIBS="$LIBS $@"
    fi
    rm -f "$OUT" "$OUT_M"
}

config_objc_lib_have() {
    NAME="$1"
    shift
    OUT_M=".config_$NAME.m"
    OUT=".config_$NAME"
    echo "/* generated by configure */" > "$OUT_M"
    echo "int main (void) { return 0; }" >> "$OUT_M"
    if $LIBTOOL --tag CC --mode link ${OBJCC} ${CPPFLAGS} ${OBJCFLAGS} \
                "$OUT_M" ${LIBS} $@ -o "$OUT" >/dev/null 2>&1; then
        eval "HAVE_$NAME=true"
        echo "HAVE_$NAME = true" >> ${CONFIG_MK}
    else
        eval "HAVE_$NAME=false"
        echo "HAVE_$NAME = false" >> ${CONFIG_MK}
    fi
    rm -f "$OUT" "$OUT_M"
}

config_subdirs() {
    for SUBDIR; do
        ( cd "$SUBDIR" && ./configure; )
    done
}

cpp_o_rule() {
    "$CXX" $CPPFLAGS $CXXFLAGS -M "$1" || {
        echo "$1" | sed -e 's/^\(.*\)\.cpp$/\1.o: \1.cpp/'
    }
    echo "$1: $2" | sed -e 's/^\(.*\)\.cpp: $/\1.o: /'
}

cpp_ext_rule() {
    cpp_o_rule "$2" "$3" | sed -e "s/[.]o:/$1:/"
}

cpp_lo_rule() {
    cpp_ext_rule .lo "$1" "$2"
}

cpp_prog_rule() {
    { cpp_o_rule "$1" "$2" || exit 1; } | sed -e 's/[.]o:/:/'
}

cpp2ext() {
    EXT="$1"; shift
    echo "$@" | sed -e "s/[.]cpp$/${EXT}/" -e "s/[.]cpp /${EXT} /g"
}

cpp2la() {
    cpp2ext .la "$@"
}

cpp2lo() {
    cpp2ext .lo "$@"
}

cpp2o() {
    cpp2ext .o "$@"
}

cpp2prog() {
    echo "$@" | sed -e 's/[.]cpp$//' -e 's/[.]cpp / /g'
}

env_reset() {
    CPPFLAGS="$ENV_CPPFLAGS"
    CFLAGS="$ENV_CFLAGS"
    CXXFLAGS="$ENV_CXXFLAGS"
    LDFLAGS="$ENV_LDFLAGS"
    LIBS="$ENV_LIBS"
}

objc_o_rule() {
    echo "$1" | sed -e 's/^\(.*\)\.m$/\1.o: \1.m/'
    echo "$1: $2" | sed -e 's/^\(.*\)\.m: /\1.o: /'
}

objc_ext_rule() {
    objc_o_rule "$2" "$3" | sed -e "s/\.o:/$1:/"
}

objc2ext() {
    EXT="$1"; shift
    echo "$@" | sed -e "s/[.]m$/${EXT}/" -e "s/[.]m /${EXT} /g"
}

pkg_config() {
    if pkg-config "$1"; then
	CFLAGS="$CFLAGS $(pkg-config --cflags "$1")"
	CXXFLAGS="$CXXFLAGS $(pkg-config --cflags "$1")"
	LIBS="$LIBS $(pkg-config --libs "$1")"
    fi
}

require_pkg_config() {
    if ! which pkg-config >/dev/null; then
        echo "please install pkg-config" >&2
        exit 1
    fi
}

sources() {
    SOURCES_TMP="$(echo "$2" | sort -u)"
    echo "$1 = \\
$(echo "$SOURCES_TMP" | sed -e 's/^\(.*\)$/	"\1" \\/')
" >> ${SOURCES_MK}
    echo "$1='$(echo "$SOURCES_TMP" | tr '\n' ' ')'" >> ${SOURCES_SH}
}

swift_o_rule() {
    echo "$1" | sed -e 's/^\(.*\)\.swift$/\1.o: \1.c/'
    echo "$1" | sed -e 's/^\(.*\)\.swift$/\1.o: Makefile config.mk/'
}

swift_ext_rule() {
    swift_o_rule "$2" | sed -e "s/[.]o:/$1:/"
}

swift2ext() {
    EXT="$1"; shift
    echo "$@" | sed -e "s/[.]swift$/${EXT}/" -e "s/[.]swift /${EXT} /g"
}

update_and_chmod() {
    if ! cmp "$2" "$3" >/dev/null 2>&1; then
        mv "$2" "$3"
        echo "-> ${PWD}/$3"
    else
        rm "$2"
    fi
    chmod "$1" "$3"
}

update_build() {
    CC_MAIN=.build_cc_main.tmp
    CC_ASAN=.build_cc_asan.tmp
    CC_COV=.build_cc_cov.tmp
    CC_DEBUG=.build_cc_debug.tmp
    mkdir -p .build

    COMPILE="${LIBTOOL} --tag=CC --mode=compile"
    COMPILE="$COMPILE \${CC} \${CPPFLAGS} \${CFLAGS}"
    COMPILE="$COMPILE -c \"\$1\" -o \"\$2\""

    echo "#!/bin/sh" >> ${CC_ASAN}
    echo "# gen by configure" >> ${CC_ASAN}
    echo "LOG=\".build/\$1.debug.log\"" >> ${CC_ASAN}
    echo "CC=\"${CC}\"" >> ${CC_ASAN}
    echo "CPPFLAGS=\"${CPPFLAGS_ASAN}\"" >> ${CC_ASAN}
    echo "CFLAGS=\"${CFLAGS_ASAN}\"" >> ${CC_ASAN}
    echo "$COMPILE > \"\$LOG\" 2>&1 || $COMPILE" >> ${CC_ASAN}
    update_and_chmod 755 ${CC_ASAN} .build_cc_asan

    echo "#!/bin/sh" >> ${CC_COV}
    echo "# gen by configure" >> ${CC_COV}
    echo "LOG=\".build/\$1.debug.log\"" >> ${CC_COV}
    echo "CC=\"${CC}\"" >> ${CC_COV}
    echo "CPPFLAGS=\"${CPPFLAGS_COV}\"" >> ${CC_COV}
    echo "CFLAGS=\"${CFLAGS_COV}\"" >> ${CC_COV}
    echo "$COMPILE > \"\$LOG\" 2>&1 || $COMPILE" >> ${CC_COV}
    update_and_chmod 755 ${CC_COV} .build_cc_cov

    echo "#!/bin/sh" >> ${CC_DEBUG}
    echo "# gen by configure" >> ${CC_DEBUG}
    echo "LOG=\".build/\$1.debug.log\"" >> ${CC_DEBUG}
    echo "CC=\"${CC}\"" >> ${CC_DEBUG}
    echo "CPPFLAGS=\"${CPPFLAGS_DEBUG}\"" >> ${CC_DEBUG}
    echo "CFLAGS=\"${CFLAGS_DEBUG}\"" >> ${CC_DEBUG}
    echo "$COMPILE > \"\$LOG\" 2>&1 || $COMPILE" >> ${CC_DEBUG}
    update_and_chmod 755 ${CC_DEBUG} .build_cc_debug

    echo "#!/bin/sh" >> ${CC_MAIN}
    echo "# gen by configure" >> ${CC_MAIN}
    echo "LOG=\".build/\$1.main.log\"" >> ${CC_MAIN}
    echo "CC=\"${CC}\"" >> ${CC_MAIN}
    echo "CPPFLAGS=\"${CPPFLAGS}\"" >> ${CC_MAIN}
    echo "CFLAGS=\"${CFLAGS}\"" >> ${CC_MAIN}
    echo "$COMPILE > \"\$LOG\" 2>&1 || $COMPILE" >> ${CC_MAIN}
    update_and_chmod 755 ${CC_MAIN} .build_cc_main
}

update_build_lib() {
    LD_MAIN=.build_ld_main.tmp
    LD_ASAN=.build_ld_asan.tmp
    LD_COV=.build_ld_cov.tmp
    LD_DEBUG=.build_ld_debug.tmp
    mkdir -p .build

    LINK="${LIBTOOL} --tag=CC --mode=link "
    LINK="$LINK \${CC} -shared \${CFLAGS} \${LDFLAGS}"
    LINK="$LINK \${OBJECTS} \${LIBS} -rpath ${LIBDIR} -o \"\$1\""

    echo "#!/bin/sh" >> ${LD_ASAN}
    echo "# gen by configure" >> ${LD_ASAN}
    echo "LOG=\".build/\$1.asan.log\"" >> ${LD_ASAN}
    echo "CC=\"${CC}\"" >> ${LD_ASAN}
    echo "CFLAGS=\"${CFLAGS_ASAN}\"" >> ${LD_ASAN}
    echo "LDFLAGS=\"${LDFLAGS_ASAN}\"" >> ${LD_ASAN}
    echo "OBJECTS=\"${OBJECTS_ASAN}\"" >> ${LD_ASAN}
    echo "LIBS=\"${LIBS_ASAN}\"" >> ${LD_ASAN}
    echo >> ${LD_ASAN}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_ASAN}
    update_and_chmod 755 ${LD_ASAN} .build_ld_asan

    echo "#!/bin/sh" >> ${LD_COV}
    echo "# gen by configure" >> ${LD_COV}
    echo "LOG=\".build/\$1.cov.log\"" >> ${LD_COV}
    echo "CC=\"${CC}\"" >> ${LD_COV}
    echo "CFLAGS=\"${CFLAGS_COV}\"" >> ${LD_COV}
    echo "LDFLAGS=\"${LDFLAGS_COV}\"" >> ${LD_COV}
    echo "OBJECTS=\"${OBJECTS_COV}\"" >> ${LD_COV}
    echo "LIBS=\"${LIBS_COV}\"" >> ${LD_COV}
    echo >> ${LD_COV}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_COV}
    update_and_chmod 755 ${LD_COV} .build_ld_cov

    echo "#!/bin/sh" >> ${LD_DEBUG}
    echo "# gen by configure" >> ${LD_DEBUG}
    echo "LOG=\".build/\$1.debug.log\"" >> ${LD_DEBUG}
    echo "CC=\"${CC}\"" >> ${LD_DEBUG}
    echo "CFLAGS=\"${CFLAGS_DEBUG}\"" >> ${LD_DEBUG}
    echo "LDFLAGS=\"${LDFLAGS_DEBUG}\"" >> ${LD_DEBUG}
    echo "OBJECTS=\"${OBJECTS_DEBUG}\"" >> ${LD_DEBUG}
    echo "LIBS=\"${LIBS_DEBUG}\"" >> ${LD_DEBUG}
    echo >> ${LD_DEBUG}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_DEBUG}
    update_and_chmod 755 ${LD_DEBUG} .build_ld_debug

    echo "#!/bin/sh" >> ${LD_MAIN}
    echo "# gen by configure" >> ${LD_MAIN}
    echo "LOG=\".build/\$1.main.log\"" >> ${LD_MAIN}
    echo "CC=\"${CC}\"" >> ${LD_MAIN}
    echo "CFLAGS=\"${CFLAGS}\"" >> ${LD_MAIN}
    echo "LDFLAGS=\"${LDFLAGS}\"" >> ${LD_MAIN}
    echo "OBJECTS=\"${OBJECTS}\"" >> ${LD_MAIN}
    echo "LIBS=\"${LIBS}\"" >> ${LD_MAIN}
    echo >> ${LD_MAIN}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_MAIN}
    update_and_chmod 755 ${LD_MAIN} .build_ld_main
}

update_build_objc() {
    OBJCC_MAIN=.build_objcc_main.tmp
    OBJCC_ASAN=.build_objcc_asan.tmp
    OBJCC_COV=.build_objcc_cov.tmp
    OBJCC_DEBUG=.build_objcc_debug.tmp
    mkdir -p .build

    echo "#!/bin/sh" >> ${OBJCC_ASAN}
    echo "# gen by configure" >> ${OBJCC_ASAN}
    echo "OBJCC=\"${OBJCC}\"" >> ${OBJCC_ASAN}
    echo "CPPFLAGS=\"${CPPFLAGS_ASAN}\"" >> ${OBJCC_ASAN}
    echo "CFLAGS=\"${CFLAGS_ASAN}\"" >> ${OBJCC_ASAN}
    echo "${LIBTOOL} --tag=CC --mode=compile \${OBJCC} \${CPPFLAGS} \${CFLAGS} -c \"\$1\" -o \"\$2\" >> .build/log 2>&1" >> ${OBJCC_ASAN}
    update_and_chmod 755 ${OBJCC_ASAN} .build_objcc_asan

    echo "#!/bin/sh" >> ${OBJCC_COV}
    echo "# gen by configure" >> ${OBJCC_COV}
    echo "OBJCC=\"${OBJCC}\"" >> ${OBJCC_COV}
    echo "CPPFLAGS=\"${CPPFLAGS_COV}\"" >> ${OBJCC_COV}
    echo "CFLAGS=\"${CFLAGS_COV}\"" >> ${OBJCC_COV}
    echo "${LIBTOOL} --tag=CC --mode=compile \${OBJCC} \${CPPFLAGS} \${CFLAGS} -c \"\$1\" -o \"\$2\" >> .build/log 2>&1" >> ${OBJCC_COV}
    update_and_chmod 755 ${OBJCC_COV} .build_objcc_cov

    echo "#!/bin/sh" >> ${OBJCC_DEBUG}
    echo "# gen by configure" >> ${OBJCC_DEBUG}
    echo "OBJCC=\"${OBJCC}\"" >> ${OBJCC_DEBUG}
    echo "CPPFLAGS=\"${CPPFLAGS_DEBUG}\"" >> ${OBJCC_DEBUG}
    echo "CFLAGS=\"${CFLAGS_DEBUG}\"" >> ${OBJCC_DEBUG}
    echo "${LIBTOOL} --tag=CC --mode=compile \${OBJCC} \${CPPFLAGS} \${CFLAGS} -c \"\$1\" -o \"\$2\" >> .build/log 2>&1" >> ${OBJCC_DEBUG}
    update_and_chmod 755 ${OBJCC_DEBUG} .build_objcc_debug

    echo "#!/bin/sh" >> ${OBJCC_MAIN}
    echo "# gen by configure" >> ${OBJCC_MAIN}
    echo "OBJCC=\"${OBJCC}\"" >> ${OBJCC_MAIN}
    echo "CPPFLAGS=\"${CPPFLAGS}\"" >> ${OBJCC_MAIN}
    echo "CFLAGS=\"${CFLAGS}\"" >> ${OBJCC_MAIN}
    echo "${LIBTOOL} --tag=CC --mode=compile \${OBJCC} \${CPPFLAGS} \${CFLAGS} -c \"\$1\" -o \"\$2\" >> .build/log 2>&1" >> ${OBJCC_MAIN}
    update_and_chmod 755 ${OBJCC_MAIN} .build_objcc_main
}

update_build_prog() {
    LD_MAIN=.build_ld_main.tmp
    LD_ASAN=.build_ld_asan.tmp
    LD_COV=.build_ld_cov.tmp
    LD_DEBUG=.build_ld_debug.tmp
    mkdir -p .build

    LINK="${LIBTOOL} --tag=CC --mode=link"
    LINK="$LINK \${CC} \${CFLAGS} \${LDFLAGS} \${OBJECTS} \${LIBS}"
    LINK="$LINK -o \"\$1\""

    echo "#!/bin/sh" >> ${LD_ASAN}
    echo "# gen by configure" >> ${LD_ASAN}
    echo "LOG=\".build/\$1.asan.log\"" >> ${LD_ASAN}
    echo "CC=\"${CC}\"" >> ${LD_ASAN}
    echo "CFLAGS=\"${CFLAGS_ASAN}\"" >> ${LD_ASAN}
    echo "LDFLAGS=\"${LDFLAGS_ASAN}\"" >> ${LD_ASAN}
    echo "OBJECTS=\"${OBJECTS_ASAN}\"" >> ${LD_ASAN}
    echo "LIBS=\"${LIBS_ASAN}\"" >> ${LD_ASAN}
    echo >> ${LD_ASAN}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_ASAN}
    update_and_chmod 755 ${LD_ASAN} .build_ld_asan

    echo "#!/bin/sh" >> ${LD_COV}
    echo "# gen by configure" >> ${LD_COV}
    echo "LOG=\".build/\$1.cov.log\"" >> ${LD_COV}
    echo "CC=\"${CC}\"" >> ${LD_COV}
    echo "CFLAGS=\"${CFLAGS_COV}\"" >> ${LD_COV}
    echo "LDFLAGS=\"${LDFLAGS_COV}\"" >> ${LD_COV}
    echo "OBJECTS=\"${OBJECTS_COV}\"" >> ${LD_COV}
    echo "LIBS=\"${LIBS_COV}\"" >> ${LD_COV}
    echo >> ${LD_COV}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_COV}
    update_and_chmod 755 ${LD_COV} .build_ld_cov

    echo "#!/bin/sh" >> ${LD_DEBUG}
    echo "# gen by configure" >> ${LD_DEBUG}
    echo "LOG=\".build/\$1.debug.log\"" >> ${LD_DEBUG}
    echo "CC=\"${CC}\"" >> ${LD_DEBUG}
    echo "CFLAGS=\"${CFLAGS_DEBUG}\"" >> ${LD_DEBUG}
    echo "LDFLAGS=\"${LDFLAGS_DEBUG}\"" >> ${LD_DEBUG}
    echo "OBJECTS=\"${OBJECTS_DEBUG}\"" >> ${LD_DEBUG}
    echo "LIBS=\"${LIBS_DEBUG}\"" >> ${LD_DEBUG}
    echo >> ${LD_DEBUG}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_DEBUG}
    update_and_chmod 755 ${LD_DEBUG} .build_ld_debug

    echo "#!/bin/sh" >> ${LD_MAIN}
    echo "# gen by configure" >> ${LD_MAIN}
    echo "LOG=\".build/\$1.main.log\"" >> ${LD_MAIN}
    echo "CC=\"${CC}\"" >> ${LD_MAIN}
    echo "CFLAGS=\"${CFLAGS_DEBUG}\"" >> ${LD_MAIN}
    echo "LDFLAGS=\"${LDFLAGS}\"" >> ${LD_MAIN}
    echo "OBJECTS=\"${OBJECTS}\"" >> ${LD_MAIN}
    echo "LIBS=\"${LIBS}\"" >> ${LD_MAIN}
    echo >> ${LD_MAIN}
    echo "$LINK > \"\$LOG\" 2>&1 || $LINK" >> ${LD_MAIN}
    update_and_chmod 755 ${LD_MAIN} .build_ld_main
}

update_file() {
    if ! cmp "$1" "$2" >/dev/null 2>&1; then
        mv "$1" "$2"
        echo "-> ${PWD}/$2"
    else
        rm "$1"
    fi
}

update_config_h() {
    echo >> "${CONFIG_H}"
    echo "#endif /* ${CONFIG_H_PREFIX}CONFIG_H */" >> ${CONFIG_H}
    if ! cmp "${CONFIG_H}" config.h >/dev/null 2>&1; then
        mv "${CONFIG_H}" config.h
        echo "-> ${PWD}/config.h"
    else
        rm "${CONFIG_H}"
    fi
}

update_config_mk() {
    if ! cmp "${CONFIG_MK}" config.mk >/dev/null 2>&1; then
        mv "${CONFIG_MK}" config.mk
        echo "-> ${PWD}/config.mk"
    else
        rm "${CONFIG_MK}"
    fi
}

update_sources_mk() {
    if ! cmp "${SOURCES_MK}" sources.mk >/dev/null 2>&1; then
        mv "${SOURCES_MK}" sources.mk
        echo "-> ${PWD}/sources.mk"
    else
        rm "${SOURCES_MK}"
    fi
}

update_sources_sh() {
    if ! cmp "${SOURCES_SH}" sources.sh >/dev/null 2>&1; then
        mv "${SOURCES_SH}" sources.sh
        echo "-> ${PWD}/sources.sh"
    else
        rm "${SOURCES_SH}"
    fi
}

CONFIG_H=config.h
CONFIG_H=".config.h.tmp"
echo "/* config.h generated by configure */" > ${CONFIG_H}
echo "#ifndef ${CONFIG_H_PREFIX}CONFIG_H" >> ${CONFIG_H}
echo "#define ${CONFIG_H_PREFIX}CONFIG_H" >> ${CONFIG_H}
echo >> "${CONFIG_H}"

CONFIG_MK=config.mk
CONFIG_MK=".config.mk.tmp"
echo "# config.mk generated by configure" > ${CONFIG_MK}

SOURCES_MK=sources.mk
SOURCES_MK=".sources.mk.tmp"
SOURCES_SH=sources.sh
SOURCES_SH=".sources.sh.tmp"

VER=0.1
echo "VER = $VER" >> ${CONFIG_MK}
echo "SRC_TOP = $SRC_TOP" >> ${CONFIG_MK}

ENV_CPPFLAGS="$CPPFLAGS"
ENV_CFLAGS="$CFLAGS"
ENV_CXXFLAGS="$CXXFLAGS"
ENV_LDFLAGS="$LDFLAGS"
ENV_LIBS="$LIBS"

if [ "x$CC" = "x" ]; then
    if test -n $(which cc); then
        CC=cc
    elif test -n $(which gcc); then
        CC=gcc
    fi
fi
echo "CC = $CC" >> ${CONFIG_MK}

CC_TARGET=$(LC_ALL=C cc -v 2>&1 | grep 'Target: ' | cut -c 9-)
echo "CC_TARGET = $CC_TARGET" >> ${CONFIG_MK}

if [ "x$CXX" = "x" ]; then
    if test -n $(which c++); then
        CXX=c++
    elif test -n $(which g++); then
        CXX=g++
    fi
fi
echo "CXX = $CXX" >> ${CONFIG_MK}

if [ "x$GCOV" = "xfalse" ]; then
    HAVE_GCOV=false
else
    if [ "x$GCOV" = "x" ]; then
        if which gcov >/dev/null 2>&1; then
	    GCOV=gcov
            HAVE_GCOV=true
        elif which egcov >/dev/null 2>&1; then
	    GCOV=egcov
            HAVE_GCOV=true
        fi
        HAVE_GCOV=false
    else
        HAVE_GCOV=true
    fi
fi
echo "HAVE_GCOV = $HAVE_GCOV" >> ${CONFIG_MK}
if ${HAVE_GCOV}; then
    echo "GCOV = $GCOV" >> ${CONFIG_MK}
fi

if [ "x$GMAKE" = "x" ]; then
    if which gmake >/dev/null 2>&1; then
        GMAKE=gmake
    else
        GMAKE=make
    fi
fi
echo "GMAKE = $GMAKE" >> ${CONFIG_MK}

if [ "x$INSTALL" = "x" ]; then
    if test -x "$(which install)"; then
        INSTALL=install
    fi
fi
echo "INSTALL = $INSTALL" >> ${CONFIG_MK}

if [ "x$LIBTOOL" = "x" ]; then
    if test -x "$(which glibtool 2>/dev/null)"; then
        LIBTOOL="$(which glibtool)"
    elif test -x "/usr/local/bin/libtool"; then
        LIBTOOL="/usr/local/bin/libtool"
    elif test -x "$(which libtool 2>/dev/null)"; then
        LIBTOOL="$(which libtool)"
    else
        LIBTOOL=libtool
    fi
fi
echo "LIBTOOL = $LIBTOOL" >> ${CONFIG_MK}

#if [ "x$SWIFTC" = "x" ]; then
#    if test -x "$(which swiftc 2>/dev/null)"; then
#        SWIFTC="$(which swiftc)"
#	HAVE_SWIFT=true
#    else
#	HAVE_SWIFT=false
#    fi
#else
#    HAVE_SWIFT=true
#fi
#echo "SWIFTC = $SWIFTC" >> ${CONFIG_MK}
#echo "HAVE_SWIFT = $HAVE_SWIFT" >> ${CONFIG_MK}

if [ "x$OBJCC" = "x" ]; then
    if test -x "$(which clang 2>/dev/null)"; then
        OBJCC="$(which clang)"
    else
        OBJCC=clang
    fi
fi
echo "OBJCC = $OBJCC" >> ${CONFIG_MK}

PREFIX="${PREFIX:-/usr/local}"
echo "PREFIX = $PREFIX" >> ${CONFIG_MK}
echo "DESTDIR ?=" >> ${CONFIG_MK}
echo "prefix ?= ${DESTDIR}${PREFIX}" >> ${CONFIG_MK}

if [ "x$OWNER" = "x" ]; then
    OWNER="$(ls -ld "$PREFIX" | tr -s ' ' | cut -d ' ' -f 3)"
fi
echo "OWNER = $OWNER" >> ${CONFIG_MK}

if [ "x$GROUP" = "x" ]; then
    GROUP="$(ls -ld "$PREFIX" | tr -s ' ' | cut -d ' ' -f 4)"
fi
echo "GROUP = $GROUP" >> ${CONFIG_MK}

if [ "x$BINDIR" = "x" ]; then
    BINDIR="${PREFIX}/bin"
fi
echo "BINDIR = $BINDIR" >> ${CONFIG_MK}

if [ "x$LIBDIR" = "x" ]; then
    LIBDIR="${PREFIX}/lib"
fi
echo "LIBDIR = $LIBDIR" >> ${CONFIG_MK}

config_no_undefined