kc3-lang/kc3/config.subr

Branch - branch -masterv0.1configurefnfractionsfractions-rebaselinuxratio-rebase- tag -v0.1.9v0.1.8v0.1.7v0.1.6v0.1.5v0.1.4v0.1.3v0.1.2v0.1.1v0.1.0v0.1.13v0.1.12v0.1.11v0.1.10v0HTTPd-v0.1.1HTTPd-v0.1.0

• Show log

  Commit

• Hash : 3989128c
  Author : Thomas de Grivel
  Date : 2024-08-08T17:32:56
  

  fix configure

Download

• 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_ASAN_LO="$(objc2ext .asan.lo "$SRC")"
          objc_ext_rule .asan.lo "$SRC" .build_objc_asan >> ${CONFIG_MK}
          echo "	./.build_objc_asan $SRC $SRC_ASAN_LO" >> ${CONFIG_MK}
  
          echo >> ${CONFIG_MK}
          SRC_COV_LO="$(objc2ext .cov.lo "$SRC")"
          objc_ext_rule .cov.lo "$SRC" .build_objc_cov >> ${CONFIG_MK}
          echo "	./.build_objc_cov $SRC $SRC_COV_LO" >> ${CONFIG_MK}
  
          echo >> ${CONFIG_MK}
          SRC_DEBUG_LO="$(objc2ext .debug.lo "$SRC")"
          objc_ext_rule .debug.lo "$SRC" .build_objc_debug >> ${CONFIG_MK}
          echo "	./.build_objc_debug $SRC $SRC_DEBUG_LO" >> ${CONFIG_MK}
  
          echo >> ${CONFIG_MK}
          SRC_MAIN_LO="$(objc2ext .main.lo "$SRC")"
          objc_ext_rule .main.lo "$SRC" .build_objc_main >> ${CONFIG_MK}
          echo "	./.build_objc_main $SRC $SRC_MAIN_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$GDB" = "x" ]; then
      if which egdb >/dev/null 2>&1; then
          GDB=egdb
      else
          GDB=gdb
      fi
  fi
  echo "GDB = $GDB" >> ${CONFIG_MK}
  
  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
  

Download