Utilities/Release/cmake_release.sh

   1 #!/bin/sh
   2 #=============================================================================
   3 #
   4 # Program:   CMake - Cross-Platform Makefile Generator
   5 # Module:    $RCSfile: cmake_release.sh,v $
   6 # Language:  C++
   7 # Date:      $Date: 2004-10-28 19:31:29 $
   8 # Version:   $Revision: 1.32.2.12 $
   9 #
  10 # Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  11 # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  12 #
  13 #    This software is distributed WITHOUT ANY WARRANTY; without even
  14 #    the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15 #    PURPOSE.  See the above copyright notices for more information.
  16 #
  17 #=============================================================================
  18
  19 #
  20 # CMake UNIX Release Script.
  21 #
  22 # Run with no arguments for documentation.
  23 #
  24
  25 # Release version number.
  26 TAG="CMake-2-0-5"
  27 CMAKE_VERSION="2.0"
  28 VERSION="${CMAKE_VERSION}.5"
  29 RELEASE="1"
  30 PREVIOUS_VERSION="1.8.3"
  31 PREVIOUS_RELEASE="1"
  32
  33 # CVSROOT setting used to check out CMake.
  34 CVSROOT=":pserver:anonymous@www.cmake.org:/cvsroot/CMake"
  35 CVSROOT_GREP=":pserver:anonymous@www.cmake.org:[0-9]*/cvsroot/CMake"
  36
  37 # CMake release root directory.
  38 RELEASE_ROOT_NAME="CMakeReleaseRoot"
  39 RELEASE_ROOT="${HOME}/${RELEASE_ROOT_NAME}"
  40 INSTALL_DIR="Install"
  41
  42 # Installation prefix used during tarball creation.  Tarballs are
  43 # relative to the installation prefix and do not include this in their
  44 # paths.
  45 PREFIX="/usr/local"
  46
  47 # Directory relative to PREFIX where documentation should be placed.
  48 DOC_DIR="/doc/cmake"
  49
  50 # No default compiler.  The config file must provide it.
  51 CC=""
  52 CXX=""
  53 CFLAGS=""
  54 CXXFLAGS=""
  55
  56 # Provide a default make and build flags.
  57 MAKE="make"
  58 BUILD_FLAGS=""
  59 BOOTSTRAP_FLAGS=""
  60
  61 # Details of remote invocation.
  62 [ -z "$REMOTE" ] && SELF="$0"
  63
  64 #-----------------------------------------------------------------------------
  65 usage()
  66 {
  67     cat <<EOF
  68 CMake Release Script Usage:
  69   $0 [command]
  70
  71 Typical usage:
  72   Cleanup remote host release directory:
  73
  74     $0 remote <host> clean
  75
  76   Create binary release tarball:
  77
  78     $0 remote_binary <host>
  79
  80   Create source release tarball:
  81
  82     $0 remote_source <host>
  83
  84   Upload tarballs:
  85
  86     $0 upload
  87
  88   Create and upload cygwin package:
  89
  90     $0 cygwin_package
  91     $0 cygwin_upload
  92
  93 Available commands:
  94
  95 EOF
  96     cat "$0" | awk '
  97 /^#--*$/               { doc=1; text="" }
  98
  99 /(^#$|^#[^-].*$)/     {
 100   if(doc)
 101     {
 102     if(text != "") { text = sprintf("%s  %s\n", text, $0) }
 103     else           { text = sprintf("  %s\n", $0) }
 104     }
 105 }
 106
 107 /^[A-Za-z0-9_]*\(\)$/ {
 108   doc=0;
 109   if(text != "") { printf("%s:\n%s\n", $0, text) }
 110 }
 111 '
 112 }
 113
 114 #-----------------------------------------------------------------------------
 115 error_log()
 116 {
 117     echo "An error has been logged to $1:" &&
 118     cat "$1" &&
 119     return 1
 120 }
 121
 122 #-----------------------------------------------------------------------------
 123 check_host()
 124 {
 125     HOST="$1"
 126     if [ -z "$HOST" ]; then
 127         echo "Must specify host."
 128         return 1
 129     fi
 130 }
 131
 132 #-----------------------------------------------------------------------------
 133 # Run a command on the specified remote host.
 134 #
 135 #  remote <host> [command]
 136 #
 137 # Only one level of remote invocation is allowed.  The <host>
 138 # specification must be a valid ssh destination with public
 139 # key authentication and no password.
 140 remote()
 141 {
 142     if [ ! -z "$REMOTE" ]; then
 143         echo "Cannot do recursive remote calls."
 144         return 1
 145     fi
 146     check_host "$1" || return 1
 147     shift
 148     RTASK="'$1'"; shift; for i in "$@"; do RTASK="${RTASK} '$i'"; done
 149     RESULT=0
 150     echo "------- Running remote task on $HOST. -------" &&
 151     (echo "REMOTE=\"1\"" &&
 152         (echo TASK=\"`(eval echo '${RTASK}') | (sed 's/"/\\\\"/g')`\") &&
 153         cat $SELF) | ssh -e none "$HOST" /bin/sh  || RESULT=1
 154     echo "-------- Remote task on $HOST done.  --------" &&
 155     return $RESULT
 156 }
 157
 158 #-----------------------------------------------------------------------------
 159 # Copy tarballs from the specified host.
 160 #
 161 #  remote_copy <host> [EXPR]
 162 #
 163 # The <host> specification must be a valid ssh destination
 164 # with public key authentication and no password.  Only
 165 # files matching the given expression are copied.  If
 166 # no expression is given, "*" is used.
 167 remote_copy()
 168 {
 169     check_host "$1" || return 1
 170     EXPR="$2"
 171     [ ! -z "$EXPR" ] || EXPR="*"
 172     echo "------- Copying tarballs from $HOST. -------" &&
 173     scp "$HOST:${RELEASE_ROOT_NAME}/Tarballs/${EXPR}" . &&
 174     echo "---- Done copying tarballs from $HOST. -----"
 175 }
 176
 177 #-----------------------------------------------------------------------------
 178 remote_copy_source()
 179 {
 180     check_host "$1" || return 1
 181     remote_copy "$HOST" "cmake-${VERSION}.tar*"
 182 }
 183
 184 #-----------------------------------------------------------------------------
 185 remote_copy_binary()
 186 {
 187     check_host "$1" || return 1
 188     remote_copy "$HOST" "cmake-${VERSION}-*"
 189 }
 190
 191 #-----------------------------------------------------------------------------
 192 # Create source tarballs on the specified host and copy them locally.
 193 #
 194 #  remote_source <host>
 195 #
 196 # The <host> specification must be a valid ssh destination
 197 # with public key authentication and no password.
 198 remote_source()
 199 {
 200     check_host "$1" || return 1
 201     remote "$HOST" source_tarball &&
 202     remote_copy_source "$HOST"
 203 }
 204
 205 #-----------------------------------------------------------------------------
 206 # Create binary tarballs on the specified host and copy them locally.
 207 #
 208 #  remote_binary <host>
 209 #
 210 # The <host> specification must be a valid ssh destination
 211 # with public key authentication and no password.
 212 remote_binary()
 213 {
 214     check_host "$1" || return 1
 215     remote "$HOST" binary_tarball &&
 216     remote_copy_binary "$HOST"
 217 }
 218
 219 #-----------------------------------------------------------------------------
 220 # Upload any tarballs in the current directory to the CMake FTP site.
 221 #
 222 #  upload
 223 #
 224 # The user must be able to ssh to kitware@www.cmake.org with public
 225 # key authentication and no password.
 226 upload()
 227 {
 228     echo "------- Copying tarballs to www.cmake.org. -------"
 229     scp cmake-${VERSION}*tar.* kitware@www.cmake.org:/projects/FTP/pub/cmake/v${CMAKE_VERSION}
 230     echo "---- Done copying tarballs to www.cmake.org. -----"
 231 }
 232
 233 #-----------------------------------------------------------------------------
 234 setup()
 235 {
 236     [ -z "${DONE_setup}" ] || return 0 ; DONE_setup="yes"
 237     mkdir -p ${RELEASE_ROOT}/Logs &&
 238     echo "Entering ${RELEASE_ROOT}" &&
 239     cd ${RELEASE_ROOT}
 240 }
 241
 242 #-----------------------------------------------------------------------------
 243 # Remove the release root directory.
 244 #
 245 #  clean
 246 #
 247 clean()
 248 {
 249     cd "${HOME}" &&
 250     echo "Cleaning up ${RELEASE_ROOT}" &&
 251     rm -rf "${RELEASE_ROOT_NAME}"
 252 }
 253
 254 #-----------------------------------------------------------------------------
 255 cvs_login()
 256 {
 257     [ -z "${DONE_cvs_login}" ] || return 0 ; DONE_cvs_login="yes"
 258     setup || return 1
 259     (
 260         if [ -f "${HOME}/.cvspass" ]; then
 261             CVSPASS="${HOME}/.cvspass"
 262         else
 263             CVSPASS=""
 264         fi
 265         if [ -z "`grep \"$CVSROOT_GREP\" ${CVSPASS} /dev/null`" ]; then
 266             echo "cmake" | cvs -q -z3 -d $CVSROOT login
 267         else
 268             echo "Already logged in."
 269         fi
 270     ) >Logs/cvs_login.log 2>&1 || error_log Logs/cvs_login.log
 271 }
 272
 273 #-----------------------------------------------------------------------------
 274 utilities()
 275 {
 276     [ -z "${DONE_utilities}" ] || return 0 ; DONE_utilities="yes"
 277     cvs_login || return 1
 278     (
 279         if [ -d "ReleaseUtilities/CVS" ]; then
 280             cd ReleaseUtilities && cvs -z3 -q update -dAP -r ${TAG}
 281         else
 282             rm -rf CheckoutTemp &&
 283             mkdir CheckoutTemp &&
 284             cd CheckoutTemp &&
 285             cvs -q -z3 -d $CVSROOT co -r ${TAG} CMake/Utilities/Release &&
 286             mv CMake/Utilities/Release ../ReleaseUtilities &&
 287             cd .. &&
 288             rm -rf CheckoutTemp
 289         fi
 290     ) >Logs/utilities.log 2>&1 || error_log Logs/utilities.log
 291 }
 292
 293 #-----------------------------------------------------------------------------
 294 config()
 295 {
 296     [ -z "${DONE_config}" ] || return 0 ; DONE_config="yes"
 297     utilities || return 1
 298     CONFIG_FILE="config_`uname`"
 299     echo "Loading ${CONFIG_FILE} ..."
 300     . "${RELEASE_ROOT}/ReleaseUtilities/${CONFIG_FILE}" >Logs/config.log 2>&1 || error_log Logs/config.log
 301     if [ -z "${CC}" ] || [ -z "${CXX}" ] || [ -z "${PLATFORM}" ]; then
 302         echo "${CONFIG_FILE} should specify CC, CXX, and PLATFORM." &&
 303         return 1
 304     fi
 305     export CC CXX CFLAGS CXXFLAGS LDFLAGS PATH LD_LIBRARY_PATH MAKE
 306 }
 307
 308 #-----------------------------------------------------------------------------
 309 checkout()
 310 {
 311     [ -z "${DONE_checkout}" ] || return 0 ; DONE_checkout="yes"
 312     config || return 1
 313     echo "Updating CMake from cvs ..." &&
 314     (
 315         if [ -d cmake-${VERSION}/CVS ]; then
 316             cd cmake-${VERSION} &&
 317             cvs -q -z3 -d $CVSROOT update -dAP -r ${TAG}
 318         else
 319             rm -rf cmake-${VERSION} &&
 320             rm -rf CheckoutTemp &&
 321             mkdir CheckoutTemp &&
 322             cd CheckoutTemp &&
 323             cvs -q -z3 -d $CVSROOT co -r ${TAG} CMake &&
 324             mv CMake ../cmake-${VERSION} &&
 325             cd .. &&
 326             rm -rf CheckoutTemp
 327         fi
 328     ) >Logs/checkout.log 2>&1 || error_log Logs/checkout.log
 329 }
 330
 331 #-----------------------------------------------------------------------------
 332 # Create source tarballs for CMake.
 333 #
 334 #  source_tarball
 335 #
 336 source_tarball()
 337 {
 338     [ -z "${DONE_source_tarball}" ] || return 0 ; DONE_source_tarball="yes"
 339     config || return 1
 340     [ -d "cmake-${VERSION}" ] || checkout || return 1
 341     echo "Creating source tarballs ..." &&
 342     (
 343         mkdir -p Tarballs &&
 344         rm -rf Tarballs/cmake-${VERSION}.tar* &&
 345         tar cvf Tarballs/cmake-${VERSION}.tar --exclude CVS cmake-${VERSION} &&
 346         gzip -c Tarballs/cmake-${VERSION}.tar >Tarballs/cmake-${VERSION}.tar.gz &&
 347         compress Tarballs/cmake-${VERSION}.tar
 348     ) >Logs/source_tarball.log 2>&1 || error_log Logs/source_tarball.log
 349 }
 350
 351 #-----------------------------------------------------------------------------
 352 write_cache()
 353 {
 354     write_standard_cache
 355 }
 356
 357 #-----------------------------------------------------------------------------
 358 write_standard_cache()
 359 {
 360     cat > CMakeCache.txt <<EOF
 361 BUILD_TESTING:BOOL=ON
 362 CMAKE_SKIP_RPATH:BOOL=1
 363 CMAKE_VERBOSE_MAKEFILE:BOOL=1
 364 HAVE_LIBDL:INTERNAL=0
 365 HAVE_DLOPEN:INTERNAL=0
 366 HAVE_GETHOSTBYADDR_R:INTERNAL=0
 367 HAVE_GETHOSTBYADDR_R_5:INTERNAL=0
 368 HAVE_GETHOSTBYADDR_R_5_REENTRANT:INTERNAL=0
 369 HAVE_GETHOSTBYADDR_R_7:INTERNAL=0
 370 HAVE_GETHOSTBYADDR_R_7_REENTRANT:INTERNAL=0
 371 HAVE_GETHOSTBYADDR_R_8:INTERNAL=0
 372 HAVE_GETHOSTBYADDR_R_8_REENTRANT:INTERNAL=0
 373 HAVE_GETHOSTBYNAME_R:INTERNAL=0
 374 HAVE_GETHOSTBYNAME_R_3:INTERNAL=0
 375 HAVE_GETHOSTBYNAME_R_3_REENTRANT:INTERNAL=0
 376 HAVE_GETHOSTBYNAME_R_5:INTERNAL=0
 377 HAVE_GETHOSTBYNAME_R_5_REENTRANT:INTERNAL=0
 378 HAVE_GETHOSTBYNAME_R_6:INTERNAL=0
 379 HAVE_GETHOSTBYNAME_R_6_REENTRANT:INTERNAL=0
 380 HAVE_GETPASS_R:INTERNAL=0
 381 HAVE_GMTIME_R:INTERNAL=0
 382 HAVE_INET_NTOA_R:INTERNAL=0
 383 HAVE_INET_NTOA_R_DECL:INTERNAL=0
 384 HAVE_INET_NTOA_R_DECL_REENTRANT:INTERNAL=0
 385 HAVE_LOCALTIME_R:INTERNAL=0
 386 HAVE_STRTOK_R:INTERNAL=0
 387 EOF
 388 }
 389
 390 #-----------------------------------------------------------------------------
 391 cache()
 392 {
 393     [ -z "${DONE_cache}" ] || return 0 ; DONE_cache="yes"
 394     config || return 1
 395     echo "Writing CMakeCache.txt ..." &&
 396     (
 397         rm -rf "cmake-${VERSION}-${PLATFORM}" &&
 398         mkdir -p "cmake-${VERSION}-${PLATFORM}" &&
 399         cd "cmake-${VERSION}-${PLATFORM}" &&
 400         write_cache
 401     ) >Logs/cache.log 2>&1 || error_log Logs/cache.log
 402 }
 403
 404 #-----------------------------------------------------------------------------
 405 configure()
 406 {
 407     [ -z "${DONE_configure}" ] || return 0 ; DONE_configure="yes"
 408     config || return 1
 409     [ -d "cmake-${VERSION}" ] || checkout || return 1
 410     cache || return 1
 411     echo "Running bootstrap ..." &&
 412     (
 413         cd "cmake-${VERSION}-${PLATFORM}" &&
 414         ../cmake-${VERSION}/bootstrap --prefix=${PREFIX} ${BOOTSTRAP_FLAGS}
 415     ) >Logs/configure.log 2>&1 || error_log Logs/configure.log
 416 }
 417
 418 #-----------------------------------------------------------------------------
 419 build()
 420 {
 421     [ -z "${DONE_build}" ] || return 0 ; DONE_build="yes"
 422     config || return 1
 423     if [ ! -d "cmake-${VERSION}-${PLATFORM}/Bootstrap" ]; then
 424         configure || return 1
 425     fi
 426     echo "Running make ..." &&
 427     (
 428         cd "cmake-${VERSION}-${PLATFORM}" &&
 429         ${MAKE} ${BUILD_FLAGS}
 430     ) >Logs/build.log 2>&1 || error_log Logs/build.log
 431 }
 432
 433 #-----------------------------------------------------------------------------
 434 tests()
 435 {
 436     [ -z "${DONE_tests}" ] || return 0 ; DONE_tests="yes"
 437     config || return 1
 438     [ -f "cmake-${VERSION}-${PLATFORM}/bin/ccmake" ] || build || return 1
 439     echo "Running tests ..." &&
 440     (
 441         cd "cmake-${VERSION}-${PLATFORM}" &&
 442         rm -rf Tests &&
 443         ./bin/ctest -V
 444     ) >Logs/tests.log 2>&1 || error_log Logs/tests.log
 445 }
 446
 447 #-----------------------------------------------------------------------------
 448 install()
 449 {
 450     [ -z "${DONE_install}" ] || return 0 ; DONE_install="yes"
 451     config || return 1
 452     [ -d "cmake-${VERSION}-${PLATFORM}/Tests/Simple" ] || tests || return 1
 453     echo "Running make install ..." &&
 454     (
 455         rm -rf ${INSTALL_DIR} &&
 456         cd "cmake-${VERSION}-${PLATFORM}" &&
 457         ${MAKE} install DESTDIR="${RELEASE_ROOT}/${INSTALL_DIR}"
 458     ) >Logs/install.log 2>&1 || error_log Logs/install.log
 459 }
 460
 461 #-----------------------------------------------------------------------------
 462 strip()
 463 {
 464     [ -z "${DONE_strip}" ] || return 0 ; DONE_strip="yes"
 465     config || return 1
 466     [ -f "${INSTALL_DIR}/usr/local/bin/ccmake" ] || install || return 1
 467     echo "Stripping executables ..." &&
 468     (
 469         strip ${INSTALL_DIR}${PREFIX}/bin/*
 470     ) >Logs/strip.log 2>&1 || error_log Logs/strip.log
 471 }
 472
 473 #-----------------------------------------------------------------------------
 474 manifest()
 475 {
 476     [ -z "${DONE_manifest}" ] || return 0 ; DONE_manifest="yes"
 477     config || return 1
 478     [ -f "${INSTALL_DIR}/usr/local/bin/ccmake" ] || install || return 1
 479     echo "Writing MANIFEST ..." &&
 480     (
 481         mkdir -p ${INSTALL_DIR}${PREFIX}${DOC_DIR} &&
 482         rm -rf ${INSTALL_DIR}${PREFIX}${DOC_DIR}/MANIFEST &&
 483         touch ${INSTALL_DIR}${PREFIX}${DOC_DIR}/MANIFEST &&
 484         cd ${INSTALL_DIR}${PREFIX} &&
 485         FILES=`find . -type f |sed 's/^\.\///'` &&
 486         cd ${RELEASE_ROOT} &&
 487         (cat >> ${INSTALL_DIR}${PREFIX}${DOC_DIR}/MANIFEST <<EOF
 488 ${FILES}
 489 EOF
 490         ) &&
 491         rm -rf ${INSTALL_DIR}/README &&
 492         (cat > ${INSTALL_DIR}/README <<EOF
 493 CMake $VERSION binary for $PLATFORM
 494
 495 Extract the file "cmake-${VERSION}-${PLATFORM}-files.tar" into your
 496 destination directory (typically /usr/local).  The following files will
 497 be extracted:
 498
 499 ${FILES}
 500
 501 EOF
 502         )
 503     ) >Logs/manifest.log 2>&1 || error_log Logs/manifest.log
 504 }
 505
 506 #-----------------------------------------------------------------------------
 507 # Create binary tarballs for CMake.
 508 #
 509 #  binary_tarball
 510 #
 511 binary_tarball()
 512 {
 513     [ -z "${DONE_binary_tarball}" ] || return 0 ; DONE_binary_tarball="yes"
 514     config || return 1
 515     strip || return 1
 516     manifest || return 1
 517     echo "Creating binary tarballs ..." &&
 518     (
 519         mkdir -p Tarballs &&
 520         rm -rf ${INSTALL_DIR}/cmake-${VERSION}-${PLATFORM}-files.tar &&
 521         (
 522             cd ${INSTALL_DIR}${PREFIX} &&
 523             tar cvf ${RELEASE_ROOT}/${INSTALL_DIR}/cmake-${VERSION}-${PLATFORM}-files.tar *
 524         ) &&
 525         rm -rf Tarballs/cmake-${VERSION}-${PLATFORM}.tar* &&
 526         (
 527             cd ${INSTALL_DIR} &&
 528             tar cvf ${RELEASE_ROOT}/Tarballs/cmake-${VERSION}-${PLATFORM}.tar cmake-${VERSION}-${PLATFORM}-files.tar README
 529         ) &&
 530         (
 531             cd Tarballs &&
 532             gzip -c cmake-${VERSION}-${PLATFORM}.tar >cmake-${VERSION}-${PLATFORM}.tar.gz &&
 533             compress cmake-${VERSION}-${PLATFORM}.tar
 534         )
 535     ) >Logs/binary_tarball.log 2>&1 || error_log Logs/binary_tarball.log
 536 }
 537
 538 #-----------------------------------------------------------------------------
 539 cygwin_source_tarball()
 540 {
 541     [ -z "${DONE_cygwin_source_tarball}" ] || return 0 ; DONE_cygwin_source_tarball="yes"
 542     config || return 1
 543     [ -d "cmake-${VERSION}" ] || checkout || return 1
 544     echo "Creating cygwin source tarball ..." &&
 545     (
 546         mkdir -p Cygwin &&
 547         rm -rf Cygwin/cmake-${VERSION}.tar.bz2 &&
 548         tar cvjf Cygwin/cmake-${VERSION}.tar.bz2 --exclude CVS cmake-${VERSION}
 549     ) >Logs/cygwin_source_tarball.log 2>&1 || error_log Logs/cygwin_source_tarball.log
 550 }
 551
 552 #-----------------------------------------------------------------------------
 553 cygwin_source_patch()
 554 {
 555     [ -z "${DONE_cygwin_source_patch}" ] || return 0 ; DONE_cygwin_source_patch="yes"
 556     config || return 1
 557     [ -d "cmake-${VERSION}" ] || checkout || return 1
 558     echo "Creating source patch for cygwin ..." &&
 559     (
 560         mkdir -p Cygwin &&
 561         rm -rf Cygwin/Patched &&
 562         mkdir -p Cygwin/Patched &&
 563         (tar c --exclude CVS cmake-${VERSION} | (cd Cygwin/Patched; tar x)) &&
 564         cd Cygwin/Patched &&
 565         mkdir -p cmake-${VERSION}/CYGWIN-PATCHES &&
 566         (
 567             CYGVERSION=`uname -r`
 568             cat > cmake-${VERSION}/CYGWIN-PATCHES/cmake.README <<EOF
 569 cmake
 570 --------------------------------------
 571 Runtime requirements:
 572   cygwin-${CYGVERSION} or newer
 573
 574 Build requirements
 575   cygwin-${CYGVERSION} or newer
 576   make
 577
 578 Canonical homepage:
 579   http://www.cmake.org
 580
 581 Canonical download:
 582   ftp://www.cmake.org/pub/cmake/
 583
 584 ------------------------------------
 585
 586 Build instructions:
 587   unpack cmake-${VERSION}-${RELEASE}-src.tar.bz2
 588     if you use setup to install this src package, it will be
 589          unpacked under /usr/src automatically
 590   cd /usr/src
 591   ./cmake-${VERSION}-${RELEASE}.sh all
 592
 593 This will create:
 594   /usr/src/cmake-${VERSION}-${RELEASE}.tar.bz2
 595   /usr/src/cmake-${VERSION}-${RELEASE}-src.tar.bz2
 596
 597 -------------------------------------------
 598
 599 Port Notes:
 600
 601 The directory /usr/share/cmake-${VERSION}/include is purposely not
 602 located at /usr/include/cmake-${VERSION} or /usr/include/cmake.  The
 603 files it contains are not meant for inclusion in any C or C++ program.
 604 They are used for compiling dynamically loadable CMake commands inside
 605 projects that provide them.  CMake will automatically provide the
 606 proper include path when the files are needed.
 607
 608 ------------------
 609
 610 Cygwin port maintained by: CMake Developers <cmake@www.cmake.org>
 611
 612 EOF
 613         ) &&
 614         (
 615             cat > cmake-${VERSION}/CYGWIN-PATCHES/setup.hint <<EOF
 616 # CMake setup.hint file for cygwin setup.exe program
 617 category: Devel
 618 requires: libncurses7 cygwin
 619 sdesc: "A cross platform build manger"
 620 ldesc: "CMake is a cross platform build manager. It allows you to specify build parameters for C and C++ programs in a cross platform manner. For cygwin Makefiles will be generated. CMake is also capable of generating microsoft project files, nmake, and borland makefiles. CMake can also perform system inspection operations like finding installed libraries and header files."
 621 EOF
 622         ) &&
 623         dos2unix cmake-${VERSION}/CYGWIN-PATCHES/setup.hint &&
 624         cp cmake-${VERSION}/CYGWIN-PATCHES/setup.hint ../setup.hint &&
 625         (diff -x CVS -urN "../../cmake-${VERSION}" "cmake-${VERSION}" > "../cmake-${VERSION}-${RELEASE}.patch"; [ "$?" = "1" ])
 626     ) >Logs/cygwin_source_patch.log 2>&1 || error_log Logs/cygwin_source_patch.log
 627 }
 628
 629 #-----------------------------------------------------------------------------
 630 cygwin_package_script()
 631 {
 632     [ -z "${DONE_cygwin_package_script}" ] || return 0 ; DONE_cygwin_package_script="yes"
 633     utilities || return 1
 634     echo "Creating cygwin packaging script ..." &&
 635     (
 636         mkdir -p Cygwin &&
 637         cp ReleaseUtilities/cygwin-package.sh.in Cygwin/cmake-${VERSION}-${RELEASE}.sh &&
 638         chmod u+x Cygwin/cmake-${VERSION}-${RELEASE}.sh
 639     ) >Logs/cygwin_package_script.log 2>&1 || error_log Logs/cygwin_package_script.log
 640 }
 641
 642 #-----------------------------------------------------------------------------
 643 # Create the CMake cygwin package files.
 644 #
 645 #  cygwin_package
 646 #
 647 # This command should be run from a cygwin prompt.
 648 cygwin_package()
 649 {
 650     [ -z "${DONE_cygwin_package}" ] || return 0 ; DONE_cygwin_package="yes"
 651     config || return 1
 652     [ -f "Cygwin/cmake-${VERSION}.tar.bz2" ] || cygwin_source_tarball || return 1
 653     [ -f "Cygwin/cmake-${VERSION}-${RELEASE}.patch" ] || cygwin_source_patch || return 1
 654     [ -f "Cygwin/cmake-${VERSION}-${RELEASE}.sh" ] || cygwin_package_script || return 1
 655     echo "Running cygwin packaging script ..." &&
 656     (
 657         rm -rf Cygwin/Package &&
 658         mkdir -p Cygwin/Package &&
 659         cd Cygwin/Package &&
 660         cp ../setup.hint . &&
 661         cp ../cmake-${VERSION}.tar.bz2 . &&
 662         cp ../cmake-${VERSION}-${RELEASE}.patch . &&
 663         cp ../cmake-${VERSION}-${RELEASE}.sh . &&
 664         ./cmake-${VERSION}-${RELEASE}.sh all
 665     ) >Logs/cygwin_package.log 2>&1 || error_log Logs/cygwin_package.log
 666 }
 667
 668 #-----------------------------------------------------------------------------
 669 # Upload the CMake cygwin package files.
 670 #
 671 #  cygwin_upload
 672 #
 673 # This should be run after "cygwin_package".
 674 cygwin_upload()
 675 {
 676     setup || return 1
 677     echo "------- Copying cywgin packages to www.cmake.org. -------"
 678     scp Cygwin/Package/cmake-${VERSION}-${RELEASE}-src.tar.bz2 \
 679         Cygwin/Package/cmake-${VERSION}-${RELEASE}.tar.bz2 \
 680         Cygwin/Package/setup.hint \
 681         kitware@www.cmake.org:/projects/FTP/pub/cmake/cygwin
 682     echo "---- Done copying cygwin packages to www.cmake.org. -----"
 683 }
 684
 685 #-----------------------------------------------------------------------------
 686 win32_zipfile()
 687 {
 688     setup || return 1
 689     echo "Creating windows non-admin install zip file ..." &&
 690     (
 691         mkdir -p Win32 &&
 692         cd "c:/Program Files" &&
 693         rm -rf cmake-${VERSION}-x86-win.zip &&
 694         zip -r cmake-${VERSION}-x86-win.zip CMake \
 695             -x CMake/INSTALL.LOG -x CMake/UNWISE.EXE -x CMake/WiseUpdt.exe &&
 696         mv cmake-${VERSION}-x86-win.zip ${RELEASE_ROOT}/Win32
 697     ) >Logs/win32_zipfile.log 2>&1 || error_log Logs/win32_zipfile.log
 698 }
 699
 700 #-----------------------------------------------------------------------------
 701 win32_upload()
 702 {
 703     setup || return 1
 704     echo "------- Copying windows zip file to www.cmake.org. -------"
 705     scp Win32/cmake-${VERSION}-x86-win.zip \
 706         kitware@www.cmake.org:/projects/FTP/pub/cmake/v${CMAKE_VERSION}
 707     echo "---- Done copying windows zip file to www.cmake.org. -----"
 708 }
 709
 710 #-----------------------------------------------------------------------------
 711 # Install CMake into the OSX package directory structure.
 712 #
 713 #  osx_install
 714 #
 715 # This will build CMake if it is not already built.
 716 osx_install()
 717 {
 718     [ -z "${DONE_osx_install}" ] || return 0 ; DONE_osx_install="yes"
 719     config || return 1
 720     [ -f "cmake-${VERSION}-${PLATFORM}/bin/ccmake" ] || build || return 1
 721     if [ -z "${WX_RESOURCES}" ]; then
 722         echo "${CONFIG_FILE} should specify WX_RESOURCES."
 723         return 1
 724     fi
 725     echo "Running make install for OSX package ..." &&
 726     (
 727         rm -rf OSX &&
 728         mkdir -p OSX/Resources &&
 729         (
 730             cd "cmake-${VERSION}-${PLATFORM}" &&
 731             ${MAKE} install DESTDIR="${RELEASE_ROOT}/OSX/Package_Root"
 732         ) &&
 733         cp cmake-${VERSION}/Copyright.txt OSX/Resources/License.txt
 734     ) >Logs/osx_install.log 2>&1 || error_log Logs/osx_install.log
 735 # Use this version when the wxCMakeSetup dialog is restored:
 736 #     (
 737 #         rm -rf OSX &&
 738 #         mkdir -p OSX/Resources &&
 739 #         mkdir -p OSX/Package_Root/Applications &&
 740 #         (
 741 #             cd "cmake-${VERSION}-${PLATFORM}" &&
 742 #             ${MAKE} install DESTDIR="${RELEASE_ROOT}/OSX/Package_Root"
 743 #         ) &&
 744 #         cp cmake-${VERSION}/Copyright.txt OSX/Resources/License.txt &&
 745 #         cp -r cmake-${VERSION}-${PLATFORM}/bin/CMake.app OSX/Package_Root/Applications &&
 746 #         echo "APPL????" > OSX/Package_Root/Applications/CMake.app/Contents/PkgInfo &&
 747 #         cp "${WX_RESOURCES}" OSX/Package_Root/Applications/CMake.app/Contents/Resources/wxCMakeSetup.rsrc
 748 #     ) >Logs/osx_install.log 2>&1 || error_log Logs/osx_install.log
 749 }
 750
 751 #-----------------------------------------------------------------------------
 752 run()
 753 {
 754     CMD="'$1'"; shift; for i in "$@"; do CMD="${CMD} '$i'"; done
 755     eval "$CMD"
 756 }
 757
 758 # Determine task and evaluate it.
 759 if [ -z "$TASK" ] && [ -z "$REMOTE" ] ; then
 760     if [ -z "$1" ]; then
 761         usage
 762     else
 763         run "$@"
 764     fi
 765 else
 766     [ -z "$TASK" ] || eval run "$TASK"
 767 fi