ucx: make/configure.vm@fec90b848f4b

     1 #!/bin/sh

     3 # create temporary directory

     4 TEMP_DIR=".tmp-`uname -n`"

     5 rm -Rf "$TEMP_DIR"

     6 if mkdir -p "$TEMP_DIR"; then

     7     :

     8 else

     9     echo "Cannot create tmp dir $TEMP_DIR"

    10     echo "Abort"

    11     exit 1

    12 fi

    13 touch "$TEMP_DIR/options"

    14 touch "$TEMP_DIR/features"

    16 # define standard variables

    17 # also define standard prefix (this is where we will search for config.site)

    18 prefix=/usr

    19 exec_prefix=

    20 bindir=

    21 sbindir=

    22 libdir=

    23 libexecdir=

    24 datarootdir=

    25 datadir=

    26 sysconfdir=

    27 sharedstatedir=

    28 localstatedir=

    29 runstatedir=

    30 includedir=

    31 infodir=

    32 localedir=

    33 mandir=

    35 # custom variables

    36 #foreach( $var in $vars )

    37 #if( $var.exec )

    38 ${var.varName}=`${var.value}`

    39 #else

    40 ${var.varName}="${var.value}"

    41 #end

    42 #end

    44 # features

    45 #foreach( $feature in $features )

    46 #if( ${feature.auto} )

    47 ${feature.varName}=auto

    48 #end

    49 #end

    51 # clean abort

    52 abort_configure()

    53 {

    54     rm -Rf "$TEMP_DIR"

    55     exit 1

    56 }

    58 # help text

    59 printhelp()

    60 {

    61     echo "Usage: $0 [OPTIONS]..."

    62     cat << __EOF__

    63 Installation directories:

    64   --prefix=PREFIX         path prefix for architecture-independent files

    65                           [/usr]

    66   --exec-prefix=EPREFIX   path prefix for architecture-dependent files

    67                           [PREFIX]

    69   --bindir=DIR            user executables [EPREFIX/bin]

    70   --sbindir=DIR           system admin executables [EPREFIX/sbin]

    71   --libexecdir=DIR        program executables [EPREFIX/libexec]

    72   --sysconfdir=DIR        system configuration files [PREFIX/etc]

    73   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]

    74   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]

    75   --runstatedir=DIR       run-time variable data [LOCALSTATEDIR/run]

    76   --libdir=DIR            object code libraries [EPREFIX/lib]

    77   --includedir=DIR        C header files [PREFIX/include]

    78   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]

    79   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]

    80   --infodir=DIR           info documentation [DATAROOTDIR/info]

    81   --mandir=DIR            man documentation [DATAROOTDIR/man]

    82   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]

    84 #if( $options.size() > 0 )

    85 Options:

    86   --debug                 add extra compile flags for debug builds

    87   --release               add extra compile flags for release builds

    88 #foreach( $opt in $options )

    89   --${opt.argument}=${opt.valuesString}

    90 #end

    92 #end

    93 #if( $features.size() > 0 )

    94 Optional Features:

    95 #foreach( $feature in $features )

    96 #if( $feature.auto )

    97   --disable-${feature.arg}

    98 #else

    99   --enable-${feature.arg}

   100 #end

   101 #end

   103 #end

   104 __EOF__

   105 }

   107 #

   108 # parse arguments

   109 #

   110 BUILD_TYPE="default"

   111 #set( $D = '$' )

   112 for ARG in "$@"

   113 do

   114     case "$ARG" in

   115         "--prefix="*)         prefix=${D}{ARG#--prefix=} ;;

   116         "--exec-prefix="*)    exec_prefix=${D}{ARG#--exec-prefix=} ;;

   117         "--bindir="*)         bindir=${D}{ARG#----bindir=} ;;

   118         "--sbindir="*)        sbindir=${D}{ARG#--sbindir=} ;;

   119         "--libdir="*)         libdir=${D}{ARG#--libdir=} ;;

   120         "--libexecdir="*)     libexecdir=${D}{ARG#--libexecdir=} ;;

   121         "--datarootdir="*)    datarootdir=${D}{ARG#--datarootdir=} ;;

   122         "--datadir="*)        datadir=${D}{ARG#--datadir=} ;;

   123         "--sysconfdir="*)     sysconfdir=${D}{ARG#--sysconfdir=} ;;

   124         "--sharedstatedir="*) sharedstatedir=${D}{ARG#--sharedstatedir=} ;;

   125         "--localstatedir="*)  localstatedir=${D}{ARG#--localstatedir=} ;;

   126         "--includedir="*)     includedir=${D}{ARG#--includedir=} ;;

   127         "--infodir="*)        infodir=${D}{ARG#--infodir=} ;;

   128         "--mandir"*)          mandir=${D}{ARG#--mandir} ;;

   129         "--localedir"*)       localedir=${D}{ARG#--localedir} ;;

   130         "--help"*) printhelp; abort_configure ;;

   131         "--debug")           BUILD_TYPE="debug" ;;

   132         "--release")         BUILD_TYPE="release" ;;

   133     #foreach( $opt in $options )

   134         "--${opt.argument}="*) ${opt.varName}=${D}{ARG#--${opt.argument}=} ;;

   135     #end

   136     #foreach( $feature in $features )

   137         "--enable-${feature.arg}") ${feature.varName}=on ;;

   138         "--disable-${feature.arg}") unset ${feature.varName} ;;

   139     #end

   140         "-"*) echo "unknown option: $ARG"; abort_configure ;;

   141     esac

   142 done

   144 ## Begin unparsed content. **

   145 #[[

   147 # set defaults for dir variables

   148 : ${exec_prefix:="$prefix"}

   149 : ${bindir:='${exec_prefix}/bin'}

   150 : ${sbindir:='${exec_prefix}/sbin'}

   151 : ${libdir:='${exec_prefix}/lib'}

   152 : ${libexecdir:='${exec_prefix}/libexec'}

   153 : ${datarootdir:='${prefix}/share'}

   154 : ${datadir:='${datarootdir}'}

   155 : ${sysconfdir:='${prefix}/etc'}

   156 : ${sharedstatedir:='${prefix}/com'}

   157 : ${localstatedir:='${prefix}/var'}

   158 : ${runstatedir:='${localstatedir}/run'}

   159 : ${includedir:='${prefix}/include'}

   160 : ${infodir:='${datarootdir}/info'}

   161 : ${mandir:='${datarootdir}/man'}

   162 : ${localedir:='${datarootdir}/locale'}

   164 # check if a config.site exists and load it

   165 if [ -n "$CONFIG_SITE" ]; then

   166     # CONFIG_SITE may contain space separated file names

   167     for cs in $CONFIG_SITE; do

   168         printf "loading defaults from $cs... "

   169         . "$cs"

   170         echo ok

   171     done

   172 elif [ -f "$prefix/share/config.site" ]; then

   173     printf "loading site defaults... "

   174     . "$prefix/share/config.site"

   175     echo ok

   176 elif [ -f "$prefix/etc/config.site" ]; then

   177     printf "loading site defaults... "

   178     . "$prefix/etc/config.site"

   179     echo ok

   180 fi

   182 # Test for availability of pkg-config

   183 PKG_CONFIG=`command -v pkg-config`

   184 : ${PKG_CONFIG:="false"}

   186 # Simple uname based platform detection

   187 # $PLATFORM is used for platform dependent dependency selection

   188 OS=`uname -s`

   189 OS_VERSION=`uname -r`

   190 printf "detect platform... "

   191 if [ "$OS" = "SunOS" ]; then

   192     PLATFORM="solaris sunos unix svr4"

   193 fi

   194 if [ "$OS" = "Linux" ]; then

   195     PLATFORM="linux unix"

   196 fi

   197 if [ "$OS" = "FreeBSD" ]; then

   198     PLATFORM="freebsd bsd unix"

   199 fi

   200 if [ "$OS" = "Darwin" ]; then

   201     PLATFORM="macos osx bsd unix"

   202 fi

   203 if echo "$OS" | grep -i "MINGW" > /dev/null; then

   204     PLATFORM="windows mingw"

   205 fi

   206 : ${PLATFORM:="unix"}

   208 PLATFORM_NAME=`echo "$PLATFORM" | cut -f1 -d' ' -`

   209 echo "$PLATFORM_NAME"

   211 isplatform()

   212 {

   213     for p in $PLATFORM

   214     do

   215         if [ "$p" = "$1" ]; then

   216             return 0

   217         fi

   218     done

   219     return 1

   220 }

   221 notisplatform()

   222 {

   223     for p in $PLATFORM

   224     do

   225         if [ "$p" = "$1" ]; then

   226             return 1

   227         fi

   228     done

   229     return 0

   230 }

   231 ]]#

   232 ## End of unparsed content **

   234 # generate vars.mk

   235 cat > "$TEMP_DIR/vars.mk" << __EOF__

   236 prefix="$prefix"

   237 exec_prefix="$exec_prefix"

   238 bindir="$bindir"

   239 sbindir="$sbindir"

   240 libdir="$libdir"

   241 libexecdir="$libexecdir"

   242 datarootdir="$datarootdir"

   243 datadir="$datadir"

   244 sysconfdir="$sysconfdir"

   245 sharedstatedir="$sharedstatedir"

   246 localstatedir="$localstatedir"

   247 runstatedir="$runstatedir"

   248 includedir="$includedir"

   249 infodir="$infodir"

   250 mandir="$mandir"

   251 localedir="$localedir"

   252 #foreach( $var in $vars )

   253 ${var.varName}="${D}${var.varName}"

   254 #end

   255 __EOF__

   257 # toolchain detection utilities

   258 . make/toolchain.sh

   260 #

   261 # DEPENDENCIES

   262 #

   264 # check languages

   265 lang_c=

   266 lang_cpp=

   267 #foreach( $lang in $languages )

   268 if detect_${lang}_compiler ; then

   269     lang_${lang}=1

   270 fi

   271 #end

   273 # create buffer for make variables required by dependencies

   274 echo > "$TEMP_DIR/make.mk"

   276 test_pkg_config()

   277 {

   278     if "$PKG_CONFIG" --exists "$1" ; then :

   279     else return 1 ; fi

   280     if [ -z "$2" ] || "$PKG_CONFIG" --atleast-version="$2" "$1" ; then :

   281     else return 1 ; fi

   282     if [ -z "$3" ] || "$PKG_CONFIG" --exact-version="$3" "$1" ; then :

   283     else return 1 ; fi

   284     if [ -z "$4" ] || "$PKG_CONFIG" --max-version="$4" "$1" ; then :

   285     else return 1 ; fi

   286     return 0

   287 }

   289 print_check_msg()

   290 {

   291     if [ -z "$1" ]; then

   292         shift

   293         printf "$@"

   294     fi

   295 }

   297 #foreach( $dependency in $namedDependencies )

   298 dependency_error_${dependency.id}()

   299 {

   300     print_check_msg "${D}dep_checked_${dependency.id}" "checking for ${dependency.name}... "

   301     #foreach( $sub in $dependency.subdependencies )

   302     # dependency $sub.fullName

   303     while true

   304     do

   305         #if( $sub.platform )

   306         if notisplatform "${sub.platform}"; then

   307             break

   308         fi

   309         #end

   310         #foreach( $np in $sub.notList )

   311         if isplatform "${np}"; then

   312             break

   313         fi

   314         #end

   315         #foreach( $lang in $sub.lang )

   316         if [ -z "$lang_${lang}" ] ; then

   317             break

   318         fi

   319         #end

   320         #if( $sub.pkgconfig.size() > 0 )

   321         if [ -z "$PKG_CONFIG" ]; then

   322             break

   323         fi

   324         #end

   325         #foreach( $test in $sub.tests )

   326         if $test > /dev/null ; then

   327             :

   328         else

   329             break

   330         fi

   331         #end

   332         #foreach( $pkg in $sub.pkgconfig )

   333         if test_pkg_config "$pkg.name" "$pkg.atleast" "$pkg.exact" "$pkg.max" ; then

   334             TEMP_CFLAGS="$TEMP_CFLAGS `"$PKG_CONFIG" --cflags $pkg.name`"

   335             TEMP_LDFLAGS="$TEMP_LDFLAGS `"$PKG_CONFIG" --libs $pkg.name`"

   336         else

   337             break

   338         fi

   339         #end

   340         #foreach( $flags in $sub.flags )

   341         #if( $flags.exec )

   342         if tmp_flags=`$flags.value` ; then

   343             TEMP_$flags.varName="$TEMP_$flags.varName $tmp_flags"

   344         else

   345             break

   346         fi

   347         #else

   348         TEMP_$flags.varName="$TEMP_$flags.varName $flags.value"

   349         #end

   350         #end

   351         #if ( $sub.make.length() > 0 )

   352         cat >> $TEMP_DIR/make.mk << __EOF__

   353 # Dependency: $dependency.name

   354 $sub.make

   355 __EOF__

   356         #end

   357         print_check_msg "${D}dep_checked_${dependency.id}" "yes\n"

   358         dep_checked_${dependency.id}=1

   359         return 1

   360     done

   362     #end

   363     print_check_msg "${D}dep_checked_${dependency.id}" "no\n"

   364     dep_checked_${dependency.id}=1

   365     return 0

   366 }

   367 #end

   369 # start collecting dependency information

   370 echo > "$TEMP_DIR/flags.mk"

   372 DEPENDENCIES_FAILED=

   373 ERROR=0

   374 #if( $dependencies.size() > 0 )

   375 # unnamed dependencies

   376 TEMP_CFLAGS=

   377 TEMP_CXXFLAGS=

   378 TEMP_LDFLAGS=

   379 #foreach( $dependency in $dependencies )

   380 while true

   381 do

   382     #if( $dependency.platform )

   383     if notisplatform "${dependency.platform}"; then

   384         break

   385     fi

   386     #end

   387     #foreach( $np in $dependency.notList )

   388     if isplatform "${np}"; then

   389         break

   390     fi

   391     #end

   392     while true

   393     do

   394         #foreach( $lang in $dependency.lang )

   395         if [ -z "$lang_${lang}" ] ; then

   396             ERROR=1

   397             break

   398         fi

   399         #end

   400         #if( $dependency.pkgconfig.size() > 0 )

   401         if [ -z "$PKG_CONFIG" ]; then

   402             ERROR=1

   403             break

   404         fi

   405         #end

   406         #foreach( $pkg in $dependency.pkgconfig )

   407         print_check_msg "${D}dep_pkgconfig_checked_${pkg.id}" "checking for pkg-config package $pkg.name... "

   408         if test_pkg_config "$pkg.name" "$pkg.atleast" "$pkg.exact" "$pkg.max" ; then

   409             print_check_msg "${D}dep_pkgconfig_checked_${pkg.id}" "yes\n"

   410             dep_pkgconfig_checked_${pkg.id}=1

   411             TEMP_CFLAGS="$TEMP_CFLAGS `"$PKG_CONFIG" --cflags $pkg.name`"

   412             TEMP_LDFLAGS="$TEMP_LDFLAGS `"$PKG_CONFIG" --libs $pkg.name`"

   413         else

   414             print_check_msg "${D}dep_pkgconfig_checked_${pkg.id}" "no\n"

   415             dep_pkgconfig_checked_${pkg.id}=1

   416             ERROR=1

   417             break

   418         fi

   419         #end

   421         #foreach( $flags in $dependency.flags )

   422         #if( $flags.exec )

   423         $flags.value > /dev/null

   424         if tmp_flags=`$flags.value` ; then

   425             TEMP_$flags.varName="$TEMP_$flags.varName $tmp_flags"

   426         else

   427             ERROR=1

   428             break

   429         fi

   430         #else

   431         TEMP_$flags.varName="$TEMP_$flags.varName $flags.value"

   432         #end

   433         #end

   434         #if ( $dependency.make.length() > 0 )

   435         cat >> "$TEMP_DIR/make.mk" << __EOF__

   436 $dependency.make

   437 __EOF__

   438         #end

   439         break

   440     done

   441     break

   442 done

   443 #end

   445 # add general dependency flags to flags.mk

   446 echo "# general flags" >> "$TEMP_DIR/flags.mk"

   447 if [ -n "${TEMP_CFLAGS}" -a -n "$lang_c" ]; then

   448     echo "CFLAGS += $TEMP_CFLAGS" >> "$TEMP_DIR/flags.mk"

   449 fi

   450 if [ -n "${TEMP_CXXFLAGS}" -a -n "$lang_cpp" ]; then

   451     echo "CXXFLAGS += $TEMP_CXXFLAGS" >> "$TEMP_DIR/flags.mk"

   452 fi

   453 if [ -n "${TEMP_LDFLAGS}" ]; then

   454     echo "LDFLAGS += $TEMP_LDFLAGS" >> "$TEMP_DIR/flags.mk"

   455 fi

   456 #end

   458 #

   459 # OPTION VALUES

   460 #

   461 #foreach( $opt in $options )

   462 #foreach( $val in $opt.values )

   463 ${val.func}()

   464 {

   465     VERR=0

   466     #foreach( $dep in $val.dependencies )

   467     if dependency_error_$dep ; then

   468         VERR=1

   469     fi

   470     #end

   471     if [ $VERR -ne 0 ]; then

   472         return 1

   473     fi

   474     #foreach( $def in $val.defines )

   475         TEMP_CFLAGS="$TEMP_CFLAGS ${def.toFlags()}"

   476         TEMP_CXXFLAGS="$TEMP_CXXFLAGS ${def.toFlags()}"

   477     #end

   478     #if( $val.hasMake() )

   479     cat >> "$TEMP_DIR/make.mk" << __EOF__

   480 $val.make

   481 __EOF__

   482     #end

   483     return 0

   484 }

   485 #end

   486 #end

   488 #

   489 # TARGETS

   490 #

   492 #foreach( $target in $targets )

   493 echo >> "$TEMP_DIR/flags.mk"

   494 #if ( $target.name )

   495 echo "configuring target: $target.name"

   496 echo "# flags for target $target.name" >> "$TEMP_DIR/flags.mk"

   497 #else

   498 echo "configuring global target"

   499 echo "# flags for unnamed target" >> "$TEMP_DIR/flags.mk"

   500 #end

   501 TEMP_CFLAGS=

   502 TEMP_CXXFLAGS=

   503 TEMP_LDFLAGS=

   505 #foreach( $dependency in $target.dependencies )

   506 if dependency_error_$dependency; then

   507     DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED ${dependency} "

   508     ERROR=1

   509 fi

   510 #end

   512 # Features

   513 #foreach( $feature in $target.features )

   514 if [ -n "${D}${feature.varName}" ]; then

   515 #foreach( $dependency in $feature.dependencies )

   516     # check dependency

   517     if dependency_error_$dependency ; then

   518         # "auto" features can fail and are just disabled in this case

   519         if [ "${D}${feature.varName}" = "auto" ]; then

   520             DISABLE_${feature.varName}=1

   521         else

   522             DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED ${dependency} "

   523             ERROR=1

   524         fi

   525     fi

   526 #end

   527     if [ -n "$DISABLE_${feature.varName}" ]; then

   528         unset ${feature.varName}

   529     fi

   530 fi

   531 #end

   533 #foreach( $opt in $target.options )

   534 # Option: --${opt.argument}

   535 if [ -z "${D}${opt.varName}" ]; then

   536     echo "auto-detecting option '${opt.argument}'"

   537     SAVED_ERROR="$ERROR"

   538     SAVED_DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED"

   539     ERROR=1

   540     while true

   541     do

   542         #foreach( $optdef in $opt.defaults )

   543         #if( $optdef.platform )

   544         if isplatform "$optdef.platform"; then

   545         #end

   546         if $optdef.func ; then

   547             echo "  ${opt.argument}: ${optdef.valueName}" >> "$TEMP_DIR/options"

   548             ERROR=0

   549             break

   550         fi

   551         #if( $optdef.platform )

   552         fi

   553         #end

   554         #end

   555         break

   556     done

   557     if [ $ERROR -ne 0 ]; then

   558         SAVED_ERROR=1

   559         SAVED_DEPENDENCIES_FAILED="option '${opt.argument}' $SAVED_DEPENDENCIES_FAILED"

   560     fi

   561     ERROR="$SAVED_ERROR"

   562     DEPENDENCIES_FAILED="$SAVED_DEPENDENCIES_FAILED"

   563 else

   564     echo "checking option ${opt.argument} = ${D}${opt.varName}"

   565     if false; then

   566         false

   567     #foreach( $optval in $opt.values )

   568     elif [ "${D}${opt.varName}" = "${optval.value}" ]; then

   569         echo "  ${opt.argument}: ${D}${opt.varName}" >> $TEMP_DIR/options

   570         if $optval.func ; then

   571             :

   572         else

   573             ERROR=1

   574             DEPENDENCIES_FAILED="option '${opt.argument}' $DEPENDENCIES_FAILED"

   575         fi

   576     #end

   577     fi

   578 fi

   579 #end

   581 if [ -n "${TEMP_CFLAGS}" -a -n "$lang_c" ]; then

   582     echo "${target.cFlags}  += $TEMP_CFLAGS" >> "$TEMP_DIR/flags.mk"

   583 fi

   584 if [ -n "${TEMP_CXXFLAGS}" -a -n "$lang_cpp" ]; then

   585     echo "${target.cxxFlags}  += $TEMP_CXXFLAGS" >> "$TEMP_DIR/flags.mk"

   586 fi

   587 if [ "$BUILD_TYPE" = "debug" ]; then

   588     if [ -n "$lang_c" ]; then

   589         echo '${target.cFlags} += ${DEBUG_CC_FLAGS}' >> "$TEMP_DIR/flags.mk"

   590     fi

   591     if [ -n "$lang_cpp" ]; then

   592         echo '${target.cxxFlags} += ${DEBUG_CXX_FLAGS}' >> "$TEMP_DIR/flags.mk"

   593     fi

   594 fi

   595 if [ "$BUILD_TYPE" = "release" ]; then

   596     if [ -n "$lang_c" ]; then

   597         echo '${target.cFlags} += ${RELEASE_CC_FLAGS}' >> "$TEMP_DIR/flags.mk"

   598     fi

   599     if [ -n "$lang_cpp" ]; then

   600         echo '${target.cxxFlags} += ${RELEASE_CXX_FLAGS}' >> "$TEMP_DIR/flags.mk"

   601     fi

   602 fi

   603 if [ -n "${TEMP_LDFLAGS}" ]; then

   604     echo "${target.ldFlags} += $TEMP_LDFLAGS" >> "$TEMP_DIR/flags.mk"

   605 fi

   607 #end

   609 # final result

   610 if [ $ERROR -ne 0 ]; then

   611     echo

   612     echo "Error: Unresolved dependencies"

   613     echo "$DEPENDENCIES_FAILED"

   614     abort_configure

   615 fi

   617 echo "configure finished"

   618 echo

   619 echo "Build Config:"

   620 echo "  PREFIX:      $prefix"

   621 echo "  TOOLCHAIN:   $TOOLCHAIN_NAME"

   622 #if ( $options.size() > 0 )

   623 echo "Options:"

   624 cat "$TEMP_DIR/options"

   625 #end

   626 #if ( $features.size() > 0 )

   627 echo "Features:"

   628 #foreach( $feature in $features )

   629 if [ -n "${D}${feature.varName}" ]; then

   630 echo "  $feature.name: on"

   631 else

   632 echo "  $feature.name: off"

   633 fi

   634 #end

   635 #end

   636 echo

   638 # generate the config.mk file

   639 cat > "$TEMP_DIR/config.mk" << __EOF__

   640 #

   641 # config.mk generated by configure

   642 #

   644 __EOF__

   645 write_toolchain_defaults "$TEMP_DIR/toolchain.mk"

   646 cat "$TEMP_DIR/vars.mk" "$TEMP_DIR/toolchain.mk" "$TEMP_DIR/flags.mk" "$TEMP_DIR/make.mk" > config.mk

   647 rm -Rf "$TEMP_DIR"

Mercurial > hg > ucx / file revision

make/configure.vm@fec90b848f4b

make/configure.vm