ucx: make/configure.vm@5e6f15005efd

     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 ${feature.helpText}

    97 #end

    99 #end

   100 __EOF__

   101 }

   103 #

   104 # parse arguments

   105 #

   106 BUILD_TYPE="default"

   107 #set( $D = '$' )

   108 for ARG in "$@"

   109 do

   110     case "$ARG" in

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   127         "--debug")           BUILD_TYPE="debug" ;;

   128         "--release")         BUILD_TYPE="release" ;;

   129     #foreach( $opt in $options )

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

   131     #end

   132     #foreach( $feature in $features )

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

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

   135     #end

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

   137     esac

   138 done

   140 ## Begin unparsed content. **

   141 #[[

   143 # set defaults for dir variables

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   162     # CONFIG_SITE may contain space separated file names

   163     for cs in $CONFIG_SITE; do

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

   165         . "$cs"

   166         echo ok

   167     done

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

   169     printf "loading site defaults... "

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

   171     echo ok

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

   173     printf "loading site defaults... "

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

   175     echo ok

   176 fi

   178 # Test for availability of pkg-config

   179 PKG_CONFIG=`command -v pkg-config`

   180 : ${PKG_CONFIG:="false"}

   182 # Simple uname based platform detection

   183 # $PLATFORM is used for platform dependent dependency selection

   184 OS=`uname -s`

   185 OS_VERSION=`uname -r`

   186 printf "detect platform... "

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

   188     PLATFORM="solaris sunos unix svr4"

   189 elif [ "$OS" = "Linux" ]; then

   190     PLATFORM="linux unix"

   191 elif [ "$OS" = "FreeBSD" ]; then

   192     PLATFORM="freebsd bsd unix"

   193 elif [ "$OS" = "OpenBSD" ]; then

   194     PLATFORM="openbsd bsd unix"

   195 elif [ "$OS" = "NetBSD" ]; then

   196     PLATFORM="netbsd bsd unix"

   197 elif [ "$OS" = "Darwin" ]; then

   198     PLATFORM="macos osx bsd unix"

   199 elif echo "$OS" | grep -i "MINGW" > /dev/null; then

   200     PLATFORM="windows mingw"

   201 fi

   202 : ${PLATFORM:="unix"}

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

   205 echo "$PLATFORM_NAME"

   207 isplatform()

   208 {

   209     for p in $PLATFORM

   210     do

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

   212             return 0

   213         fi

   214     done

   215     return 1

   216 }

   217 notisplatform()

   218 {

   219     for p in $PLATFORM

   220     do

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

   222             return 1

   223         fi

   224     done

   225     return 0

   226 }

   227 istoolchain()

   228 {

   229     for t in $TOOLCHAIN

   230     do

   231         if [ "$t" = "$1" ]; then

   232             return 0

   233         fi

   234     done

   235     return 1

   236 }

   237 notistoolchain()

   238 {

   239     for t in $TOOLCHAIN

   240     do

   241         if [ "$t" = "$1" ]; then

   242             return 1

   243         fi

   244     done

   245     return 0

   246 }

   247 ]]#

   248 ## End of unparsed content **

   250 # generate vars.mk

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

   252 prefix=$prefix

   253 exec_prefix=$exec_prefix

   254 bindir=$bindir

   255 sbindir=$sbindir

   256 libdir=$libdir

   257 libexecdir=$libexecdir

   258 datarootdir=$datarootdir

   259 datadir=$datadir

   260 sysconfdir=$sysconfdir

   261 sharedstatedir=$sharedstatedir

   262 localstatedir=$localstatedir

   263 runstatedir=$runstatedir

   264 includedir=$includedir

   265 infodir=$infodir

   266 mandir=$mandir

   267 localedir=$localedir

   268 #foreach( $var in $vars )

   269 ${var.varName}=${D}${var.varName}

   270 #end

   271 __EOF__

   273 # toolchain detection utilities

   274 . make/toolchain.sh

   276 #

   277 # DEPENDENCIES

   278 #

   280 # check languages

   281 lang_c=

   282 lang_cpp=

   283 #foreach( $lang in $languages )

   284 if detect_${lang}_compiler ; then

   285     lang_${lang}=1

   286 fi

   287 #end

   289 # create buffer for make variables required by dependencies

   290 echo > "$TEMP_DIR/make.mk"

   292 test_pkg_config()

   293 {

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

   295     else return 1 ; fi

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

   297     else return 1 ; fi

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

   299     else return 1 ; fi

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

   301     else return 1 ; fi

   302     return 0

   303 }

   305 print_check_msg()

   306 {

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

   308         shift

   309         printf "$@"

   310     fi

   311 }

   313 #foreach( $dependency in $namedDependencies )

   314 dependency_error_${dependency.id}()

   315 {

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

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

   318     # dependency $sub.fullName

   319     while true

   320     do

   321         #if( $sub.platform )

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

   323             break

   324         fi

   325         #end

   326         #if( $sub.toolchain )

   327         if notistoolchain "${sub.toolchain}"; then

   328             break

   329         fi

   330         #end

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

   332         if isplatform "${np}" || istoolchain "${np}"; then

   333             break

   334         fi

   335         #end

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

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

   338             break

   339         fi

   340         #end

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

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

   343             break

   344         fi

   345         #end

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

   347         if $test > /dev/null ; then

   348             :

   349         else

   350             break

   351         fi

   352         #end

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

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

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

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

   357         else

   358             break

   359         fi

   360         #end

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

   362         #if( $flags.exec )

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

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

   365         else

   366             break

   367         fi

   368         #else

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

   370         #end

   371         #end

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

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

   374 # Dependency: $dependency.name

   375 $sub.make

   376 __EOF__

   377         #end

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

   379         dep_checked_${dependency.id}=1

   380         return 1

   381     done

   383     #end

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

   385     dep_checked_${dependency.id}=1

   386     return 0

   387 }

   388 #end

   390 # start collecting dependency information

   391 echo > "$TEMP_DIR/flags.mk"

   393 DEPENDENCIES_FAILED=

   394 ERROR=0

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

   396 # unnamed dependencies

   397 TEMP_CFLAGS=

   398 TEMP_CXXFLAGS=

   399 TEMP_LDFLAGS=

   400 #foreach( $dependency in $dependencies )

   401 while true

   402 do

   403     #if( $dependency.platform )

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

   405         break

   406     fi

   407     #end

   408     #if( $dependency.toolchain )

   409     if notistoolchain "${dependency.toolchain}"; then

   410         break

   411     fi

   412     #end

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

   414     if isplatform "${np}" || istoolchain "${np}"; then

   415         break

   416     fi

   417     #end

   418     while true

   419     do

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

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

   422             ERROR=1

   423             break

   424         fi

   425         #end

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

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

   428             ERROR=1

   429             break

   430         fi

   431         #end

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

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

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

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

   436             dep_pkgconfig_checked_${pkg.id}=1

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

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

   439         else

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

   441             dep_pkgconfig_checked_${pkg.id}=1

   442             ERROR=1

   443             break

   444         fi

   445         #end

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

   448         #if( $flags.exec )

   449         $flags.value > /dev/null

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

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

   452         else

   453             ERROR=1

   454             break

   455         fi

   456         #else

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

   458         #end

   459         #end

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

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

   462 $dependency.make

   463 __EOF__

   464         #end

   465         break

   466     done

   467     break

   468 done

   469 #end

   471 # add general dependency flags to flags.mk

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

   473 if [ -n "${TEMP_CFLAGS}" ] && [ -n "$lang_c" ]; then

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

   475 fi

   476 if [ -n "${TEMP_CXXFLAGS}" ] && [ -n "$lang_cpp" ]; then

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

   478 fi

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

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

   481 fi

   482 #end

   484 #

   485 # OPTION VALUES

   486 #

   487 #foreach( $opt in $options )

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

   489 ${val.func}()

   490 {

   491     VERR=0

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

   493     if dependency_error_$dep ; then

   494         VERR=1

   495     fi

   496     #end

   497     if [ $VERR -ne 0 ]; then

   498         return 1

   499     fi

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

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

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

   503     #end

   504     #if( $val.hasMake() )

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

   506 $val.make

   507 __EOF__

   508     #end

   509     return 0

   510 }

   511 #end

   512 #end

   514 #

   515 # TARGETS

   516 #

   518 #foreach( $target in $targets )

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

   520 #if ( $target.name )

   521 echo "configuring target: $target.name"

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

   523 #else

   524 echo "configuring global target"

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

   526 #end

   527 TEMP_CFLAGS=

   528 TEMP_CXXFLAGS=

   529 TEMP_LDFLAGS=

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

   532 if dependency_error_$dependency; then

   533     DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED ${dependency} "

   534     ERROR=1

   535 fi

   536 #end

   538 # Features

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

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

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

   542     # check dependency

   543     if dependency_error_$dependency ; then

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

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

   546             DISABLE_${feature.varName}=1

   547         else

   548             DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED ${dependency} "

   549             ERROR=1

   550         fi

   551     fi

   552 #end

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

   554         unset ${feature.varName}

   555     fi

   556 fi

   557 #end

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

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

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

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

   563     SAVED_ERROR="$ERROR"

   564     SAVED_DEPENDENCIES_FAILED="$DEPENDENCIES_FAILED"

   565     ERROR=1

   566     while true

   567     do

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

   569         #if( $optdef.platform )

   570         if isplatform "$optdef.platform"; then

   571         #end

   572         if $optdef.func ; then

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

   574             ERROR=0

   575             break

   576         fi

   577         #if( $optdef.platform )

   578         fi

   579         #end

   580         #end

   581         break

   582     done

   583     if [ $ERROR -ne 0 ]; then

   584         SAVED_ERROR=1

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

   586     fi

   587     ERROR="$SAVED_ERROR"

   588     DEPENDENCIES_FAILED="$SAVED_DEPENDENCIES_FAILED"

   589 else

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

   591     if false; then

   592         false

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

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

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

   596         if $optval.func ; then

   597             :

   598         else

   599             ERROR=1

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

   601         fi

   602     #end

   603     fi

   604 fi

   605 #end

   607 if [ -n "${TEMP_CFLAGS}" ] && [ -n "$lang_c" ]; then

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

   609 fi

   610 if [ -n "${TEMP_CXXFLAGS}" ] && [ -n "$lang_cpp" ]; then

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

   612 fi

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

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

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

   616     fi

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

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

   619     fi

   620 fi

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

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

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

   624     fi

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

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

   627     fi

   628 fi

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

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

   631 fi

   633 #end

   635 # final result

   636 if [ $ERROR -ne 0 ]; then

   637     echo

   638     echo "Error: Unresolved dependencies"

   639     echo "$DEPENDENCIES_FAILED"

   640     abort_configure

   641 fi

   643 echo "configure finished"

   644 echo

   645 echo "Build Config:"

   646 echo "  PREFIX:      $prefix"

   647 echo "  TOOLCHAIN:   $TOOLCHAIN_NAME"

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

   649 echo "Options:"

   650 cat "$TEMP_DIR/options"

   651 #end

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

   653 echo "Features:"

   654 #foreach( $feature in $features )

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

   656 echo "  $feature.name: on"

   657 else

   658 echo "  $feature.name: off"

   659 fi

   660 #end

   661 #end

   662 echo

   664 # generate the config.mk file

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

   666 #

   667 # config.mk generated by configure

   668 #

   670 __EOF__

   671 write_toolchain_defaults "$TEMP_DIR/toolchain.mk"

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

   673 rm -Rf "$TEMP_DIR"

Mercurial > hg > ucx / file revision

make/configure.vm@5e6f15005efd

make/configure.vm