Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mage/usr/lib/mage/smage2.sh

    Contents of /trunk/mage/usr/lib/mage/smage2.sh

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 1617 - (show annotations) (download) (as text)
    Mon Jan 9 20:13:34 2012 UTC (12 years, 3 months ago) by niro
    File MIME type: application/x-sh
    File size: 44767 byte(s) 
    -added --resume support for smage
    1 #!/bin/bash
    2 # $Id$
    3
    4 # compiles/installs .smage2 source install scripts
    5 # needs pkgbuild_dir (mage)
    6
    7 # TODO: record dynlib, gz | xz database
    8
    9
    10 # set default user mage.rc
    11 : ${MAGERC="/etc/mage.rc"}
    12
    13 # export default C locale
    14 export LC_ALL=C
    15
    16 source /etc/mage.rc.global
    17 source ${MAGERC}
    18 source ${MLIBDIR}/mage4.functions.sh
    19
    20 ## setup ##
    21 SMAGENAME="$1"
    22 SMAGEVERSION="$(< ${MLIBDIR}/version)"
    23
    24 # set PKGDIR and BUILDDIR and BINDIR to MROOT
    25 if [[ -n ${MROOT} ]]
    26 then
    27 export PKGDIR=${MROOT}/${PKGDIR}
    28 export BUILDDIR=${MROOT}/${BUILDDIR}
    29 export BINDIR=${MROOT}/${BINDIR}
    30 fi
    31
    32 # sources the smage file and uses state from distribution file if exist
    33 # may helpful for repository support later on
    34 smagesource()
    35 {
    36 local file="$1"
    37 local mystate
    38 local mycodename
    39
    40 source ${file}
    41
    42 [[ -n ${STATE} ]] && mystate="${STATE}"
    43
    44 # do not overide if local state was broken or disabled!
    45 case ${STATE} in
    46 broken) return ;;
    47 disabled) return ;;
    48 esac
    49
    50 if [ -f ${SMAGESCRIPTSDIR}/distribution ]
    51 then
    52 source ${SMAGESCRIPTSDIR}/distribution
    53 [[ -n ${STATE} ]] && mystate="${STATE}"
    54 fi
    55 # now switch state and export it
    56 STATE="${mystate}"
    57 }
    58
    59 showversion()
    60 {
    61 echo -en "Magellan Source Install v${SMAGEVERSION} "
    62 echo -e "-- Niels Rogalla (niro@magellan-linux.de)"
    63 }
    64
    65 die()
    66 {
    67 xtitleclean
    68 echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
    69 echo "SMAGE failed: $@"
    70 exit 1
    71 }
    72
    73 die_pipestatus()
    74 {
    75 # the status change if we do any parameter declarations!!
    76 # dont do this anymore, keep this in mind!
    77 #
    78 # local pos="$1"
    79 # local comment="$2"
    80 #
    81 # [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
    82 #
    83 [ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
    84 }
    85
    86 xtitle()
    87 {
    88 if [[ ${TERM} = xterm ]]
    89 then
    90 echo -ne "\033]0;[sMage: $@]\007"
    91 fi
    92 return 0
    93 }
    94
    95 xtitleclean()
    96 {
    97 if [[ ${TERM} = xterm ]]
    98 then
    99 echo -ne "\033]0;\007"
    100 fi
    101 return 0
    102 }
    103
    104 syncsmage2()
    105 {
    106 xtitle "Updating smage2-script tree ..."
    107 local i
    108 for i in ${SMAGE2RSYNC}
    109 do
    110 rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
    111 if [[ $? = 0 ]]
    112 then
    113 break
    114 else
    115 continue
    116 fi
    117 done
    118
    119 # clean up backup files (foo~)
    120 find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
    121
    122 xtitleclean
    123 }
    124
    125 # $1 filename
    126 get_db_md5_sum()
    127 {
    128 local DB_FILE
    129 local MD5_FILE
    130 local i
    131
    132 DB_ENTRY="$(basename $1)"
    133 MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} ${SMAGESUFFIX})"
    134
    135 i="$(cat ${MD5_FILE}| grep ${DB_ENTRY} | cut -d' ' -f1)"
    136
    137 echo "${i}"
    138 }
    139
    140 download_sources()
    141 {
    142 [ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0
    143
    144 local count=${#SRC_URI[*]}
    145 local uri
    146 local subdir
    147 local outputdir
    148 local db_md5_file="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    149 local fetching
    150 local i
    151
    152 # check if FETCHING is needed
    153 if mchecksum --rundir "${SOURCEDIR}/${PNAME}" --file "${db_md5_file}" --method md5
    154 then
    155 # md5's ok, no fetching needed
    156 fetching=false
    157 else
    158 fetching=true
    159 fi
    160
    161 if [[ ${fetching} = true ]]
    162 then
    163 for ((i=0; i < count; i++))
    164 do
    165 # url to file
    166 uri="${SRC_URI[${i}]%%' '*}"
    167
    168 # subdir in sources dir; the my_SRCI_URI file goes to there
    169 subdir="${SRC_URI[${i}]##*' '}"
    170
    171 # if $subdir is not equal with $uri then an other dir is used
    172 if [[ ${uri} != ${subdir} ]]
    173 then
    174 outputdir="${SOURCEDIR}/${PNAME}/${subdir}"
    175 else
    176 outputdir="${SOURCEDIR}/${PNAME}"
    177 fi
    178
    179 echo -e "${COLBLUE}==>${COLGREEN} fetching ${uri}${COLDEFAULT}"
    180 # do not die here, mchecksum catches download errors
    181 mdownload --uri "${uri}" --dir "${outputdir}"
    182
    183 # unset them to be sure
    184 unset uri
    185 unset subdir
    186 unset outputdir
    187 done
    188
    189 # recheck md5 sums after download
    190 echo
    191 echo -e "${COLBLUE}===${COLGREEN} Checking MD5 sums:${COLDEFAULT}"
    192 mchecksum --rundir "${SOURCEDIR}/${PNAME}" --file "${db_md5_file}" --method md5 || die "md5 failed"
    193 echo
    194 else
    195 echo -e "${COLBLUE}===${COLGREEN} All sources already fetched, nothing to do${COLDEFAULT}"
    196 fi
    197
    198 # not needed anymore
    199 unset SRC_URI
    200 }
    201
    202 # dummy function, used if that does not exist in smage file
    203 src_prepare()
    204 {
    205 echo "no src_prepare defined; doing nothing ..."
    206 return 0
    207 }
    208
    209 # dummy function, used if that does not exist in smage file
    210 src_compile()
    211 {
    212 echo "no src_compile defined; doing nothing ..."
    213 return 0
    214 }
    215
    216 # dummy function, used if that does not exist in smage file
    217 src_check()
    218 {
    219 echo "no src_check defined; doing nothing ..."
    220 return 0
    221 }
    222
    223 # dummy function, used if that does not exist in smage file
    224 src_install()
    225 {
    226 echo "no src_install defined; doing nothing ..."
    227 return 0
    228 }
    229
    230 mlibdir()
    231 {
    232 local libdir=lib
    233 [[ ${ARCH} = x86_64 ]] && libdir=lib64
    234
    235 echo "${libdir}"
    236 }
    237
    238 mconfigure()
    239 {
    240 local myopts
    241 if [[ ! -z ${CTARGET} ]]
    242 then
    243 myopts="--target=${CTARGET}"
    244 fi
    245
    246 if [ -x ./configure ]
    247 then
    248 ./configure \
    249 --prefix=/usr \
    250 --host=${CHOST} \
    251 --build=${CHOST} \
    252 --mandir=/usr/share/man \
    253 --infodir=/usr/share/info \
    254 --datadir=/usr/share \
    255 --sysconfdir=/etc \
    256 --localstatedir=/var/lib \
    257 --libdir=/usr/$(mlibdir) \
    258 ${myopts} \
    259 "$@" || die "mconfigure failed"
    260 else
    261 echo "configure is not an executable ..."
    262 exit 1
    263 fi
    264 }
    265
    266 minstall()
    267 {
    268 if [ -f ./[mM]akefile -o -f ./GNUmakefile ]
    269 then
    270 make prefix=${BINDIR}/usr \
    271 datadir=${BINDIR}/usr/share \
    272 infodir=${BINDIR}/usr/share/info \
    273 localstatedir=${BINDIR}/var/lib \
    274 mandir=${BINDIR}/usr/share/man \
    275 sysconfdir=${BINDIR}/etc \
    276 libdir=${BINDIR}/usr/$(mlibdir) \
    277 "$@" install || die "minstall failed"
    278 else
    279 die "no Makefile found"
    280 fi
    281 }
    282
    283 mmake()
    284 {
    285 make ${MAKEOPTS} ${EXTRA_EMAKE} "$@"
    286 }
    287
    288 munpack()
    289 {
    290 local SRCFILE
    291 local IFTAR
    292 local DEST
    293
    294 SRCFILE=$1
    295
    296 if [[ -z $2 ]]
    297 then
    298 DEST=${BUILDDIR}
    299 else
    300 DEST=$2
    301 fi
    302
    303 [[ ! -d ${DEST} ]] && install -d ${DEST}
    304
    305 case "${SRCFILE##*.}" in
    306 bz2)
    307 IFTAR="$(basename $SRCFILE .bz2)"
    308 IFTAR="${IFTAR##*.}"
    309 if [[ ${IFTAR} = tar ]]
    310 then
    311 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.bz2 unpack failed."
    312 else
    313 pushd ${DEST} > /dev/null
    314 bzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .bz2) || die ".bz2 unpack failed."
    315 popd > /dev/null
    316 fi
    317 ;;
    318 gz)
    319 IFTAR="$(basename $SRCFILE .gz)"
    320 IFTAR="${IFTAR##*.}"
    321 if [[ ${IFTAR} = tar ]]
    322 then
    323 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.gz unpack failed."
    324 else
    325 pushd ${DEST} > /dev/null
    326 zcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .gz) || die ".gz unpack failed."
    327 popd > /dev/null
    328 fi
    329 ;;
    330 xz)
    331 IFTAR="$(basename $SRCFILE .xz)"
    332 IFTAR="${IFTAR##*.}"
    333 if [[ ${IFTAR} = tar ]]
    334 then
    335 tar --no-same-owner -xvJf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.xz unpack failed."
    336 else
    337 pushd ${DEST} > /dev/null
    338 xzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .xz) || die ".xz unpack failed."
    339 popd > /dev/null
    340 fi
    341 ;;
    342 tbz2|mpks|mpk)
    343 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tbz2 unpack failed."
    344 ;;
    345 tgz)
    346 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tgz unpack failed."
    347 ;;
    348 txz|mpkzs|mpkz)
    349 tar --no-same-owner -xvJf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".txz unpack failed."
    350 ;;
    351 rar)
    352 unrar x ${SOURCEDIR}/${PNAME}/${SRCFILE} ${DEST} || die ".rar unpack failed."
    353 ;;
    354 zip|xpi|jar)
    355 unzip ${SOURCEDIR}/${PNAME}/${SRCFILE} -d ${DEST} || die ".zip unpack failed."
    356 ;;
    357 rpm)
    358 pushd ${DEST} > /dev/null
    359 rpm2targz ${SOURCEDIR}/${PNAME}/${SRCFILE} || die "rpm2targz: .rpm unpack failed."
    360 tar --no-same-owner -xvzf ${SRCFILE/.rpm/.tar.gz} || die "tar: .rpm unpack failed."
    361 if [[ -f ${DEST}/${SRCFILE/.rpm/.tar.gz} ]]
    362 then
    363 rm ${DEST}/${SRCFILE/.rpm/.tar.gz}
    364 fi
    365 ;;
    366 *)
    367 die "munpack failed"
    368 ;;
    369 esac
    370 }
    371
    372 mpatch()
    373 {
    374 local PATCHOPTS
    375 local PATCHFILE
    376 local i
    377
    378 PATCHOPTS=$1
    379 PATCHFILE=$2
    380
    381 if [[ -z $2 ]]
    382 then
    383 PATCHFILE=$1
    384
    385 ## patch level auto-detection, get patch level
    386 for ((i=0; i < 10; i++))
    387 do
    388 patch --dry-run -Np${i} -i ${SOURCEDIR}/${PNAME}/${PATCHFILE} > /dev/null
    389 if [[ $? = 0 ]]
    390 then
    391 PATCHOPTS="-Np${i}"
    392 break
    393 fi
    394 done
    395 fi
    396
    397 echo -e "${COLBLUE}*** ${COLGREEN}Applying patch '${PATCHFILE}'${COLDEFAULT}"
    398 patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}
    399 }
    400
    401 mlibtoolize()
    402 {
    403 local opts="$@"
    404 [[ -z ${opts} ]] && opts="--verbose --install --force"
    405
    406 libtoolize ${opts} || die "running: mlibtoolize ${opts}"
    407 }
    408
    409 mautoreconf()
    410 {
    411 local opts="$@"
    412 [[ -z ${opts} ]] && opts="--verbose --install --force"
    413
    414 autoreconf ${opts} || die "running: mautoreconf ${opts}"
    415 }
    416
    417 minstalldocs()
    418 {
    419 local docfiles
    420 local doc
    421 docfiles="$@"
    422
    423 if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]
    424 then
    425 install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."
    426 fi
    427
    428 for doc in ${docfiles}
    429 do
    430 if [ -f ${doc} ]
    431 then
    432 if mqueryfeature "compressdoc"
    433 then
    434 cat ${doc} | gzip -9c > ${BINDIR}/usr/share/doc/${PNAME}-${PVER}/$(basename ${doc}).gz || die "gzipping +installing ${doc}."
    435 chmod 0644 ${BINDIR}/usr/share/doc/${PNAME}-${PVER}/$(basename ${doc}).gz || die "fixing permissions of ${doc}."
    436 else
    437 install -m 0644 ${SRCDIR}/${i} ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "installing ${doc}."
    438 fi
    439 fi
    440 done
    441 }
    442
    443 mstriplibs()
    444 {
    445 local stripdir="$@"
    446
    447 [[ -z ${stripdir} ]] && stripdir="${BINDIR}"
    448 [[ -z ${STRIP_DYN_LIB} ]] && STRIP_DYN_LIB="--strip-debug"
    449 find ${stripdir} ! -type d | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_DYN_LIB} 2> /dev/null
    450 }
    451
    452 mstripbins()
    453 {
    454 local stripdir="$@"
    455
    456 [[ -z ${stripdir} ]] && stripdir="${BINDIR}"
    457 [[ -z ${STRIP_DYN_BIN} ]] && STRIP_DYN_BIN="--strip-debug"
    458 find ${stripdir} ! -type d | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_DYN_BIN} 2> /dev/null
    459 }
    460
    461 mstripstatic()
    462 {
    463 local stripdir="$@"
    464
    465 [[ -z ${stripdir} ]] && stripdir="${BINDIR}"
    466 [[ -z ${STRIP_STATIC_LIB} ]] && STRIP_STATIC_LIB="--strip-debug"
    467 find ${stripdir} ! -type d | xargs file | grep "ar archive" | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_STATIC_LIB} 2> /dev/null
    468 }
    469
    470 mstriplibtoolarchive()
    471 {
    472 local stripdir="$@"
    473
    474 [[ -z ${stripdir} ]] && stripdir="${BINDIR}"
    475 find ${stripdir} ! -type d -name \*.la | xargs | grep "libtool library" | cut -f 1 -d : | xargs --no-run-if-empty rm -f -- 2> /dev/null
    476 }
    477
    478 mpurgetargets()
    479 {
    480 local stripdir="$@"
    481 local target
    482
    483 [[ -z ${stripdir} ]] && stripdir=${BINDIR}
    484 # nothing to do in this case
    485 [[ -z ${PURGE_TARGETS[*]} ]] && return
    486
    487 for target in ${PURGE_TARGETS[*]}
    488 do
    489 # check if target is a regex pattern without any slashes
    490 if [[ ${target} = ${target//\/} ]]
    491 then
    492 find ${BINDIR} -type f -name "${target}" | xargs --no-run-if-empty rm -f -- 2> /dev/null
    493 else
    494 rm -f -- ${target} 2> /dev/null
    495 fi
    496 done
    497 }
    498
    499 mcompressdocs()
    500 {
    501 local bindir="$@"
    502
    503 if [ -d ${bindir}/usr/share/man ]
    504 then
    505 echo -e "${COLBLUE}===${COLGREEN} compressing man-pages ...${COLDEFAULT}"
    506 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/man
    507 fi
    508
    509 if [ -d ${bindir}/usr/share/info ]
    510 then
    511 echo -e "${COLBLUE}===${COLGREEN} compressing info-pages ...${COLDEFAULT}"
    512 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/info
    513 fi
    514 }
    515
    516 sminclude()
    517 {
    518 local i
    519
    520 if [[ -n "$@" ]]
    521 then
    522 for i in $@
    523 do
    524 echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    525 source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    526 done
    527 echo
    528 fi
    529 }
    530
    531 setup_distcc_environment()
    532 {
    533 if [ -x /usr/bin/distcc ]
    534 then
    535 echo -e "${COLBLUE}---${COLGREEN} Using DistCC for compilation ...${COLDEFAULT}"
    536 export PATH=/usr/$(mlibdir)/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
    537
    538 export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"
    539
    540 # creating distcc tempdir
    541 install -o distcc -g daemon -d ${DISTCC_DIR}
    542 chmod 1777 ${DISTCC_DIR}
    543 fi
    544 }
    545
    546 setup_ccache_environment()
    547 {
    548 if [ -x /usr/bin/ccache ]
    549 then
    550 echo -e "${COLBLUE}---${COLGREEN} Using CCache for compilation ...${COLDEFAULT}"
    551 export PATH=/usr/$(mlibdir)/ccache/bin:${PATH} || die "ccache: could not export new $PATH"
    552 fi
    553 }
    554
    555 # fixes given dependencies to match a MAGE_TARGET
    556 # fix_mage_deps -target s/depend # <-- note -target !
    557 fix_mage_deps()
    558 {
    559 local target="$1"
    560 local depend="$2"
    561 local NDEPEND
    562 local sym dep cat pver pname
    563
    564 # deps and provides are special
    565 # they must be fixed to match the target
    566
    567 # run this only if target and depend is not empty
    568 if [ -n "${target}" ] && [ -n "${depend}" ]
    569 then
    570 # fix DEPEND
    571 while read sym dep
    572 do
    573 # ignore empty lines
    574 [[ -z ${dep} ]] && continue
    575
    576 cat="$(dirname ${dep})"
    577 # change if not virtual
    578 if [[ ${cat} = virtual ]]
    579 then
    580 pname="$(basename ${dep})"
    581 else
    582 # fix pver to target-pver
    583 # to get pname-target-pver
    584
    585 # doing it backwards !
    586 pver="${dep##*-}"
    587 # full pver
    588 pname="$(basename ${dep/-${pver}/})${target}-${pver}"
    589 fi
    590
    591 # do not add empty lines
    592 if [ -z "${NDEPEND}" ]
    593 then
    594 NDEPEND="${sym} ${cat}/${pname}"
    595 else
    596 NDEPEND="${NDEPEND}
    597 ${sym} ${cat}/${pname}"
    598 fi
    599
    600 unset cat pname pver
    601 done << EOF
    602 ${depend}
    603 EOF
    604 # set NDEPEND to DEPEND
    605 depend="${NDEPEND}"
    606 fi
    607
    608 echo "${depend}"
    609 }
    610
    611 # build_mage_script(): helper functions for regen_mage_tree()
    612 # generates an mage file with given information in smage file
    613 # needs at least:
    614 # PNAME name of pkg
    615 # PVER version
    616 # PBUILD revision
    617 # PCATEGORIE categorie of the pkg
    618 # STATE state of pkg stable|unstable|old
    619 # DESCRIPTION va short description (opt)
    620 # HOMEPAGE homepage (opt)
    621 # DEPEND runtime dependencies (opt)
    622 # SDEPEND add. needed deps to build the pkg (opt)
    623 # PROVIDE provides a virtual (opt)
    624 #
    625 # special tags:
    626 # PKGTYPE type of pkg
    627 # INHERITS which functions get included
    628 # SPECIAL_FUNCTIONS special functions which should also be added
    629 # warning: they get killed before the build starts !
    630 # SPLIT_PACKAGES names of all subpackages which are splitted from parent
    631 # SPLIT_PACKAGE_BASE base package name for splitpackages
    632 # (only in the resulting magefile}
    633 #
    634 # MAGE_TREE_DEST target destination of the generated tree
    635 # REGEN_MAGE_TREE set to 'true' to enable this
    636 #
    637 # gets called with build_mage_script target
    638 build_mage_script()
    639 {
    640 local magefile
    641 local dest
    642 local target
    643 local split_pkg_base
    644 local sym
    645 local depname
    646
    647 # if MAGE_TREE_DEST not set use BUILDDIR
    648 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    649
    650 # determinate which suffix this mage file should get, if any
    651 [[ $1 = --target ]] && shift && target="-$1"
    652
    653 # mark package as splitpackage
    654 [[ $1 = --split-pkg-base ]] && shift && split_pkg_base="$1"
    655
    656 # name of magefile
    657 magefile="${PNAME}${target}-${PVER}-${PBUILD}.mage"
    658
    659 # destination to magefile
    660 dest="${MAGE_TREE_DEST}/${PCATEGORIE}/${PNAME}${target}/${magefile}"
    661
    662 # show what we are doing
    663 echo -e "${COLBLUE}===${COLGREEN} generating mage file:${COLDEFAULT}"
    664 echo "${dest}"
    665
    666 install -d "$(dirname ${dest})"
    667 # now build the mage file
    668 > ${dest}
    669
    670 # pgkname and state
    671 echo "PKGNAME=\"${PNAME}${target}-${PVER}-\${ARCH}-${PBUILD}\"" >> ${dest}
    672 echo "STATE=\"${STATE}\"" >> ${dest}
    673
    674 # description and homepage
    675 echo "DESCRIPTION=\"${DESCRIPTION}\"" >> ${dest}
    676 echo "HOMEPAGE=\"${HOMEPAGE}\"" >> ${dest}
    677
    678 # special tags and vars
    679 echo "PKGTYPE=\"${PKGTYPE}\"" >> ${dest}
    680
    681 # echo MAGE_TARGETS ## note -target is needed !
    682 echo "MAGE_TARGETS=\"${target}\"" >> ${dest}
    683
    684 # split package base
    685 echo "SPLIT_PACKAGE_BASE=\"${split_pkg_base}\"" >> ${dest}
    686
    687 # add special vars
    688 if [ -n "${SPECIAL_VARS}" ]
    689 then
    690 local i
    691 for i in ${SPECIAL_VARS}
    692 do
    693 # being tricky here :)
    694 echo "${i}=\"$(eval echo \$${i})\"" >> ${dest}
    695 done
    696 fi
    697
    698 # add at least all includes
    699 if [ -n "${INHERITS}" ]
    700 then
    701 echo -n "minclude" >> ${dest}
    702 local i
    703 for i in ${INHERITS}
    704 do
    705 echo -n " ${i}" >> ${dest}
    706 done
    707 # a CRLF is needed here!
    708 echo >> ${dest}
    709 fi
    710
    711 # deps and provides
    712 echo "DEPEND=\"$(fix_mage_deps "${target}" "${DEPEND}")\"" >> ${dest}
    713 echo "SDEPEND=\"$(fix_mage_deps "${target}" "${SDEPEND}")\"" >> ${dest}
    714 echo "PROVIDE=\"${PROVIDE}\"" >> ${dest}
    715
    716 # add special functions
    717 if [ -n "${SPECIAL_FUNCTIONS}" ]
    718 then
    719 local i
    720 for i in ${SPECIAL_FUNCTIONS}
    721 do
    722 # add to mage (quotes needed !)
    723 typeset -f "${i}" >> ${dest}
    724 # unset to be safe (quotes needed !)
    725 #unset "${i}" <-- later to get every target built
    726 done
    727 fi
    728
    729 # pre|post-install|removes
    730 typeset -f preinstall >> ${dest}
    731 typeset -f postinstall >> ${dest}
    732 typeset -f preremove >> ${dest}
    733 typeset -f postremove >> ${dest}
    734 }
    735
    736 regen_mage_tree()
    737 {
    738 local subpackage
    739
    740 # build them only if requested
    741 if mqueryfeature regentree
    742 then
    743 # run it without targets
    744 if [[ -n ${MAGE_TARGETS} ]]
    745 then
    746 # build for each target a mage file
    747 # run it with several targets
    748 echo
    749 for subpackage in ${MAGE_TARGETS}
    750 do
    751 build_mage_script --target "${subpackage}"
    752 done
    753 echo
    754
    755 # run it for splitpackages
    756 elif [[ -n ${SPLIT_PACKAGES} ]]
    757 then
    758 local split_pkg_base="${PNAME}"
    759 # save smage environment
    760 split_save_variables
    761 # build for each subpackage a mage file
    762 # run it with several targets
    763 echo
    764 for subpackage in ${SPLIT_PACKAGES}
    765 do
    766 # get the right variables for the split
    767 export PNAME="${subpackage}"
    768 split_info_${subpackage}
    769 # get the preinstall etc
    770 split_export_inherits ${subpackage}
    771 build_mage_script --split-pkg-base "${split_pkg_base}"
    772 # delete split preinstall etc
    773 split_delete_inherits ${subpackage}
    774 # restore smage environment
    775 split_restore_variables
    776 done
    777 echo
    778 # unset all saved smage variables
    779 split_unset_variables
    780
    781 else
    782 echo
    783 build_mage_script
    784 echo
    785 fi
    786 fi
    787
    788 # now unset all uneeded vars to be safe
    789 # unset PKGNAME <-- don't do that; smage needs this var
    790 # unset to be safe (quotes needed !)
    791 # for i in ${SPECIAL_FUNCTIONS}
    792 # do
    793 # unset "${i}"
    794 # done
    795 unset SPECIAL_FUNCTIONS
    796 # for i in ${SPECIAL_VARS}
    797 # do
    798 # unset "${i}"
    799 # done
    800 unset SPECIAL_VARS
    801 unset STATE
    802 unset DESCRIPTION
    803 unset HOMEPAGE
    804 # unset PKGTYPE <-- don't do that either; smage needs this var
    805 unset INHERITS
    806 unset DEPEND
    807 unset SDEPEND
    808 unset PROVIDE
    809 unset preinstall
    810 unset postinstall
    811 unset preremove
    812 unset postremove
    813 }
    814
    815 split_save_variables()
    816 {
    817 export SAVED_PNAME="${PNAME}"
    818 export SAVED_PVER="${PVER}"
    819 export SAVED_PBUILD="${PBUILD}"
    820 export SAVED_PCATEGORIE="${PCATEGORIE}"
    821 export SAVED_DESCRIPTION="${DESCRIPTION}"
    822 export SAVED_HOMEPAGE="${HOMEPAGE}"
    823 export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
    824 export SAVED_STATE="${STATE}"
    825 export SAVED_PKGTYPE="${PKGTYPE}"
    826 export SAVED_INHERITS="${INHERITS}"
    827 export SAVED_DEPEND="${DEPEND}"
    828 export SAVED_SDEPEND="${SDEPEND}"
    829 export SAVED_PROVIDE="${PROVIDE}"
    830 export SAVED_PKGTYPE="${PKGTYPE}"
    831
    832 # special handling needed for mage features
    833 # pkgbuild
    834 mqueryfeature "pkgbuild" && export SAVED_FEATURE_PKGBUILD="pkgbuild"
    835 mqueryfeature "!pkgbuild" && export SAVED_FEATURE_PKGBUILD="!pkgbuild"
    836 # strip
    837 mqueryfeature "strip" && export SAVED_FEATURE_STRIP="strip"
    838 mqueryfeature "!strip" && export SAVED_FEATURE_STRIP="!strip"
    839 # libtool
    840 mqueryfeature "libtool" && export SAVED_FEATURE_LIBTOOL="libtool"
    841 mqueryfeature "!libtool" && export SAVED_FEATURE_LIBTOOL="!libtool"
    842 # compressdoc
    843 mqueryfeature "compressdoc" && export SAVED_FEATURE_COMPRESSDOC="compressdoc"
    844 mqueryfeature "!compressdoc" && export SAVED_FEATURE_COMPRESSDOC="!compressdoc"
    845
    846 # bindir too
    847 export SAVED_BINDIR="${BINDIR}"
    848
    849 # export the SPLIT_PACKAGE_BASE
    850 export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
    851
    852 # functions
    853 if [[ ! -z $(typeset -f preinstall) ]]
    854 then
    855 # rename the old one
    856 local saved_preinstall
    857 saved_preinstall=SAVED_$(typeset -f preinstall)
    858 eval "${saved_preinstall}"
    859 export -f SAVED_preinstall
    860 fi
    861
    862 if [[ ! -z $(typeset -f postinstall) ]]
    863 then
    864 # rename the old one
    865 local saved_postinstall
    866 saved_postinstall=SAVED_$(typeset -f postinstall)
    867 eval "${saved_postinstall}"
    868 export -f SAVED_postinstall
    869 fi
    870
    871 if [[ ! -z $(typeset -f preremove) ]]
    872 then
    873 # rename the old one
    874 local saved_preremove
    875 saved_preremove=SAVED_$(typeset -f preremove)
    876 eval "${saved_preremove}"
    877 export -f SAVED_preremove
    878 fi
    879
    880 if [[ ! -z $(typeset -f postremove) ]]
    881 then
    882 # rename the old one
    883 local saved_postremove
    884 saved_postremove=SAVED_$(typeset -f postremove)
    885 eval "${saved_postremove}"
    886 export -f SAVED_postremove
    887 fi
    888 }
    889
    890 split_restore_variables()
    891 {
    892 export PNAME="${SAVED_PNAME}"
    893 export PVER="${SAVED_PVER}"
    894 export PBUILD="${SAVED_PBUILD}"
    895 export PCATEGORIE="${SAVED_PCATEGORIE}"
    896 export DESCRIPTION="${SAVED_DESCRIPTION}"
    897 export HOMEPAGE="${SAVED_HOMEPAGE}"
    898 export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
    899 export STATE="${SAVED_STATE}"
    900 export PKGTYPE="${SAVED_PKGTYPE}"
    901 export INHERITS="${SAVED_INHERITS}"
    902 export DEPEND="${SAVED_DEPEND}"
    903 export SDEPEND="${SAVED_SDEPEND}"
    904 export PROVIDE="${SAVED_PROVIDE}"
    905 export PKGTYPE="${SAVED_PKGTYPE}"
    906
    907 # special handling needed for mage features
    908 # pkgbuild
    909 FVERBOSE=off msetfeature "${SAVED_FEATURE_PKGBUILD}"
    910 # strip
    911 FVERBOSE=off msetfeature "${SAVED_FEATURE_STRIP}"
    912 # libtool
    913 FVERBOSE=off msetfeature "${SAVED_FEATURE_LIBTOOL}"
    914 # compressdoc
    915 FVERBOSE=off msetfeature "${SAVED_FEATURE_COMPRESSDOC}"
    916
    917 # bindir too
    918 export BINDIR="${SAVED_BINDIR}"
    919
    920 # functions
    921 if [[ ! -z $(typeset -f SAVED_preinstall) ]]
    922 then
    923 # rename the old one
    924 local saved_preinstall
    925 saved_preinstall=$(typeset -f SAVED_preinstall)
    926 eval "${saved_preinstall/SAVED_/}"
    927 export -f preinstall
    928 fi
    929
    930 if [[ ! -z $(typeset -f SAVED_postinstall) ]]
    931 then
    932 # rename the old one
    933 local saved_postinstall
    934 saved_postinstall=$(typeset -f SAVED_postinstall)
    935 eval "${saved_postinstall/SAVED_/}"
    936 export -f postinstall
    937 fi
    938
    939 if [[ ! -z $(typeset -f SAVED_preremove) ]]
    940 then
    941 # rename the old one
    942 local saved_preremove
    943 saved_preremove=$(typeset -f SAVED_preremove)
    944 eval "${saved_preremove/SAVED_/}"
    945 export -f preremove
    946 fi
    947
    948 if [[ ! -z $(typeset -f SAVED_postremove) ]]
    949 then
    950 # rename the old one
    951 local saved_postremove
    952 saved_postremove=$(typeset -f SAVED_postremove)
    953 eval "${saved_postremove/SAVED_/}"
    954 export -f postremove
    955 fi
    956 }
    957
    958 split_unset_variables()
    959 {
    960 # unset saved vars; not needed anymore
    961 unset SAVED_PNAME
    962 unset SAVED_PVER
    963 unset SAVED_PBUILD
    964 unset SAVED_PCATEGORIE
    965 unset SAVED_DESCRIPTION
    966 unset SAVED_HOMEPAGE
    967 unset SAVED_SPECIAL_VARS
    968 unset SAVED_STATE
    969 unset SAVED_PKGTYPE
    970 unset SAVED_INHERITS
    971 unset SAVED_DEPEND
    972 unset SAVED_SDEPEND
    973 unset SAVED_PROVIDE
    974 unset SAVED_BINDIR
    975 unset SAVED_PKGTYPE
    976 unset SAVED_FEATURE_PKGBUILD
    977 unset SAVED_FEATURE_STRIP
    978 unset SAVED_FEATURE_LIBTOOL
    979 unset SAVED_FEATURE_COMPRESSDOC
    980 unset SPLIT_PACKAGE_BASE
    981 unset -f SAVED_preinstall
    982 unset -f SAVED_postinstall
    983 unset -f SAVED_preremove
    984 unset -f SAVED_postremove
    985 }
    986
    987 split_export_inherits()
    988 {
    989 local subpackage="$1"
    990 local func
    991 local newfunc
    992
    993 for func in preinstall postinstall preremove postremove
    994 do
    995 if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
    996 then
    997 newfunc=$(typeset -f ${func}_${subpackage})
    998 newfunc="${newfunc/_${subpackage} (/ (}"
    999 eval "${newfunc}"
    1000 fi
    1001 done
    1002 }
    1003
    1004 split_delete_inherits()
    1005 {
    1006 local subpackage="$1"
    1007 local func
    1008
    1009 for func in preinstall postinstall preremove postremove
    1010 do
    1011 if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
    1012 then
    1013 unset -f ${func}
    1014 fi
    1015 done
    1016 }
    1017
    1018 export_inherits()
    1019 {
    1020 local include="$1"
    1021 shift
    1022
    1023 while [ "$1" ]
    1024 do
    1025 local functions="$1"
    1026
    1027 # sanity checks
    1028 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    1029 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    1030
    1031 eval "${functions}() { ${include}_${functions} ; }"
    1032
    1033 # debug
    1034 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    1035
    1036 shift
    1037 done
    1038 }
    1039
    1040 generate_package_md5sum()
    1041 {
    1042 local dest
    1043 local pcat
    1044 local pname
    1045 local pver
    1046 local pbuild
    1047 local parch
    1048 local target
    1049 local pkgname
    1050
    1051 # very basic getops
    1052 for i in $*
    1053 do
    1054 case $1 in
    1055 --pcat|-c) shift; pcat="$1" ;;
    1056 --pname|-n) shift; pname="$1" ;;
    1057 --pver|-v) shift; pver="$1" ;;
    1058 --pbuild|-b) shift; pbuild="$1" ;;
    1059 --parch|a) shift; parch="$1" ;;
    1060 --target|t) shift; target="$1" ;;
    1061 esac
    1062 shift
    1063 done
    1064
    1065 # sanity checks; abort if not given
    1066 [ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
    1067 [ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
    1068 [ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
    1069 [ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
    1070 [ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
    1071
    1072 # check needed global vars
    1073 [ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
    1074 [ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
    1075
    1076 # fix target as it may be empty !
    1077 [ -n "${target}" ] && target="-${target}"
    1078
    1079 # build pkgname
    1080 pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
    1081
    1082 # build pkg-md5-sum only if requested
    1083 if mqueryfeature regentree
    1084 then
    1085 echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
    1086
    1087 # abort if not exist
    1088 if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
    1089 then
    1090 echo -e "${COLRED}! exists${COLDEFAULT}"
    1091 return 0
    1092 fi
    1093
    1094 # if MAGE_TREE_DEST not set use BUILDDIR
    1095 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    1096
    1097 # setup md5 dir
    1098 dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
    1099 install -d ${dest}
    1100
    1101 # gen md5sum
    1102 ( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
    1103 > ${dest}/${pkgname}.md5
    1104 echo -e "${COLGREEN}done${COLDEFAULT}"
    1105 fi
    1106 }
    1107
    1108 source_pkg_build()
    1109 {
    1110 if [[ ${PKGTYPE} = virtual ]]
    1111 then
    1112 echo "Virtual package detected; src-pkg-tarball not necessary ..."
    1113 return 0
    1114 fi
    1115
    1116 if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
    1117 then
    1118 echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
    1119 return 0
    1120 fi
    1121
    1122 [ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
    1123
    1124 echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
    1125
    1126 # include the smage2 file
    1127 cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
    1128
    1129 ( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
    1130 [[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
    1131 mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
    1132
    1133 echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
    1134 }
    1135
    1136 step_by_step()
    1137 {
    1138 if mqueryfeature stepbystep
    1139 then
    1140 echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
    1141 echo "Press [enter] to continue"
    1142 read
    1143 fi
    1144 }
    1145
    1146 resume_stamp()
    1147 {
    1148 local step="$1"
    1149 touch ${BUILDDIR}/.smage-${PKGNAME}-${step}
    1150 }
    1151
    1152 run_resume()
    1153 {
    1154 local step="$1"
    1155
    1156 if mqueryfeature "resume" && [[ -f ${BUILDDIR}/.smage-${PKGNAME}-${step} ]]
    1157 then
    1158 echo -e "${COLMAGENTA}${step} already processed; doing nothing${COLDEFAULT}"
    1159 return 0
    1160 else
    1161 return 1
    1162 fi
    1163 }
    1164
    1165 # print out our version
    1166 showversion
    1167 echo
    1168
    1169 if [ -z "$1" ]
    1170 then
    1171 echo "No .smage2 file given. Exiting."
    1172 echo
    1173 exit 1
    1174 fi
    1175
    1176 # load supported mage features
    1177 load_mage_features
    1178
    1179 # updating smage2-scripts
    1180 if [[ $1 = update ]]
    1181 then
    1182 if [ ! -d ${SOURCEDIR} ]
    1183 then
    1184 install -d ${SOURCEDIR}
    1185 fi
    1186 syncsmage2
    1187 exit 0
    1188 fi
    1189
    1190 # creates md5sums for smages to given dir
    1191 if [[ $1 = calcmd5 ]]
    1192 then
    1193 if [ $# -ge 2 ]
    1194 then
    1195 SMAGENAME="$2"
    1196 MD5DIR="$3"
    1197 [[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"
    1198
    1199 smagesource ${SMAGENAME} || die "download source failed"
    1200
    1201 # overridable sourcedir; must be declared after source of the smage2
    1202 CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
    1203
    1204 [ -z "${SRC_URI}" ] && die "Nothing declared to calculate."
    1205
    1206 # end of array
    1207 EOA=${#SRC_URI[*]}
    1208
    1209 [ ! -d ${MD5DIR} ] && install -d ${MD5DIR}
    1210
    1211 # clear md5sum file
    1212 MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    1213 echo -n > ${MY_MD5_FILE}
    1214
    1215 for ((i=0; i < EOA; i++))
    1216 do
    1217 # url to file
    1218 my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
    1219
    1220 # subdir in sources dir; the my_SRCI_URI file goes to there
    1221 my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
    1222
    1223 # if my_src_uri_dest is not equal my_src_uri; than an other dir is used
    1224 if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
    1225 then
    1226 MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
    1227 else
    1228 MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
    1229 fi
    1230
    1231 if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
    1232 then
    1233 echo "calculating $(basename ${MY_SRC_FILE}) ..."
    1234 ( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
    1235 else
    1236 echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
    1237 fi
    1238
    1239 # unset them to be shure
    1240 unset my_SRC_URI
    1241 unset my_SRC_URI_DEST
    1242 unset my_SRC_URI_MIRROR
    1243 unset my_SOURCEDIR
    1244 done
    1245
    1246 echo
    1247 echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
    1248 echo
    1249 else
    1250 echo "Usage: Calculating MD5 Sums:"
    1251 echo " $(basename $0) calcmd5 /path/to/SMAGENAME [/path/to/MD5DIR]"
    1252 echo
    1253 echo
    1254 echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
    1255 echo
    1256 exit 1
    1257 fi
    1258
    1259 exit 0
    1260 fi
    1261
    1262 # download sources
    1263 if [ "$1" == "download" -a -n "$2" ]
    1264 then
    1265 if [ ! -d ${SMAGESCRIPTSDIR} ]
    1266 then
    1267 install -d ${SMAGESCRIPTSDIR}
    1268 fi
    1269
    1270 # get smage
    1271 SMAGENAME="$2"
    1272 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1273 smagesource ${SMAGENAME} || die "download source failed"
    1274
    1275 download_sources
    1276 exit 0
    1277 fi
    1278
    1279 # regen-mage-tree
    1280 if [ "$1" == "only-regen-tree" -a -n "$2" ]
    1281 then
    1282 # set correct SMAGENAME
    1283 SMAGENAME="$2"
    1284 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1285 smagesource ${SMAGENAME} || die "regen: smage2 not found"
    1286
    1287 regen_mage_tree
    1288
    1289 # build several targets
    1290 if [[ -n ${MAGE_TARGETS} ]]
    1291 then
    1292 for target in ${MAGE_TARGETS}
    1293 do
    1294 # build md5sum for existing packages
    1295 generate_package_md5sum \
    1296 --pcat "${PCATEGORIE}" \
    1297 --pname "${PNAME}" \
    1298 --pver "${PVER}" \
    1299 --pbuild "${PBUILD}" \
    1300 --parch "${ARCH}" \
    1301 --target "${target}"
    1302 done
    1303
    1304 # build several subpackages
    1305 elif [[ -n ${SPLIT_PACKAGES} ]]
    1306 then
    1307 split_save_variables
    1308 for subpackage in ${SPLIT_PACKAGES}
    1309 do
    1310 # get the right variables for the split
    1311 export PNAME="${subpackage}"
    1312 split_info_${subpackage}
    1313 # build md5sum for existing packages
    1314 generate_package_md5sum \
    1315 --pcat "${PCATEGORIE}" \
    1316 --pname "${PNAME}" \
    1317 --pver "${PVER}" \
    1318 --pbuild "${PBUILD}" \
    1319 --parch "${ARCH}"
    1320 # restore smage environment
    1321 split_restore_variables
    1322 done
    1323 # unset all saved smage variables
    1324 split_unset_variables
    1325
    1326 else
    1327 # build md5sum for existing packages
    1328 generate_package_md5sum \
    1329 --pcat "${PCATEGORIE}" \
    1330 --pname "${PNAME}" \
    1331 --pver "${PVER}" \
    1332 --pbuild "${PBUILD}" \
    1333 --parch "${ARCH}"
    1334 fi
    1335
    1336 exit 0
    1337 fi
    1338
    1339 if [ "$1" == "--create-src-tarball" -a -n "$2" ]
    1340 then
    1341 # set correct SMAGENAME
    1342 SMAGENAME="$2"
    1343 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1344
    1345 echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
    1346
    1347 smagesource ${SMAGENAME} || die "regen: smage2 not found"
    1348
    1349 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1350 then
    1351 echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1352 rm -rf ${SOURCEDIR}/${PKGNAME}
    1353 fi
    1354
    1355 download_sources
    1356 source_pkg_build ${SMAGENAME}
    1357 exit 0
    1358 fi
    1359
    1360 if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
    1361 then
    1362 SRCPKGTARBALL="${2}"
    1363 msetfeature "srcpkgtarball"
    1364
    1365 # abort if given file is not a source pkg
    1366 [[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
    1367
    1368 # set correct SMAGENAME; use the one that the src_pkg provide
    1369 # /path/to/SOURCEDIR/PNAME/SMAGENAME
    1370 SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
    1371
    1372 echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
    1373
    1374 [[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
    1375
    1376 # unpack srctarball
    1377 [[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
    1378
    1379 tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die "Error unpackung src-tarball ${SRCPKGTARBALL}"
    1380
    1381 [[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
    1382 fi
    1383
    1384 if [ "$1" == "--resume" -a -n "$2" ]
    1385 then
    1386 msetfeature "resume"
    1387 SMAGENAME="$2"
    1388 fi
    1389
    1390 [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
    1391 [ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
    1392 die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
    1393 [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
    1394 [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
    1395 [ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
    1396 [ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
    1397 [ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
    1398 [ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
    1399 [ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
    1400
    1401 smagesource ${SMAGENAME} || die "source failed"
    1402 PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
    1403 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1404 SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
    1405
    1406 xtitle "Compiling ${PKGNAME}"
    1407 echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
    1408
    1409 # auto regen mage tree if requested
    1410 regen_mage_tree
    1411
    1412 if mqueryfeature "srcpkg"
    1413 then
    1414 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1415 then
    1416 echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1417 rm -rf ${SOURCEDIR}/${PNAME}
    1418 fi
    1419 fi
    1420
    1421 # download sources
    1422 mqueryfeature "srcpkgtarball" || download_sources
    1423
    1424 # fixes some issues with these functions
    1425 export -f src_prepare || die "src_prepare export failed"
    1426 export -f src_compile || die "src_compile export failed"
    1427 export -f src_check || die "src_check export failed"
    1428 export -f src_install || die "src_install export failed"
    1429
    1430 # fixes some compile issues
    1431 export CHOST="${CHOST}" || die "CHOST export failed"
    1432 export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
    1433 if [[ -z ${CXXFLAGS} ]]
    1434 then
    1435 export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
    1436 else
    1437 export CXXFLAGS="${CXXFLAGS}" || die "CXXFLAGS export failed"
    1438 fi
    1439 export LDFLAGS="${LDFLAGS}" || die "LDFLAGS export failed"
    1440 export BINDIR="${BINDIR}" || die "BINDIR export failed"
    1441 export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
    1442
    1443 # setup distcc
    1444 # setup for distcc goes *before* ccache, so ccache comes before distcc in path
    1445 mqueryfeature "distcc" && setup_distcc_environment
    1446
    1447 # setup ccache
    1448 mqueryfeature "ccache" && setup_ccache_environment
    1449
    1450 if mqueryfeature "resume"
    1451 then
    1452 echo -e "${COLMAGENTA}Resume requested; continuing previous build${COLDEFAULT}"
    1453
    1454 # setup build logging
    1455 [[ ! -d /var/log/smage ]] && install -d /var/log/smage
    1456 if [[ -f /var/log/smage/${PKGNAME}.log.bz2 ]]
    1457 then
    1458 bunzip2 -f /var/log/smage/${PKGNAME}.log.bz2
    1459 fi
    1460 echo -e "### Resume started on $(date) ###\n" >> /var/log/smage/${PKGNAME}.log
    1461
    1462 else
    1463 # clean up builddir if a previously one exist
    1464 if [ -d ${BUILDDIR} ]
    1465 then
    1466 rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
    1467 fi
    1468 install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
    1469
    1470 # clean up srcdir if a previously unpacked one exist
    1471 if [ -d ${SRCDIR} ]
    1472 then
    1473 rm -rf ${SRCDIR}
    1474 fi
    1475
    1476 # clean up bindir if a previous build exist or create a new one
    1477 if [ -d ${BINDIR} ]
    1478 then
    1479 rm -rf ${BINDIR}
    1480 fi
    1481 install -d ${BINDIR} || die "couldn't create \$BINDIR."
    1482
    1483 # clean up package temp dir if a previous build exist
    1484 if [ -d ${BUILDDIR}/${PKGNAME} ]
    1485 then
    1486 rm -rf ${BUILDDIR}/${PKGNAME}
    1487 fi
    1488
    1489 # setup build logging
    1490 [[ ! -d /var/log/smage ]] && install -d /var/log/smage
    1491 echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
    1492 fi
    1493
    1494 if [[ ${PKGTYPE} = virtual ]]
    1495 then
    1496 echo "virtual package detected; nothing will be build ..."
    1497 # automatically set !pkgbuild here too
    1498 msetfeature "!pkgbuild"
    1499 else
    1500 ( run_resume src_prepare || src_prepare ) | ${SMAGE_LOG_CMD}
    1501 die_pipestatus 0 "src_prepare failed"
    1502 resume_stamp src_prepare
    1503 step_by_step src_prepare
    1504
    1505 ( run_resume src_compile || src_compile ) | ${SMAGE_LOG_CMD}
    1506 die_pipestatus 0 "src_compile failed"
    1507 resume_stamp src_compile
    1508 step_by_step src_compile
    1509
    1510 # only run checks if requested
    1511 if mqueryfeature "!check"
    1512 then
    1513 echo "!check detected; src_check() will not be run!" | ${SMAGE_LOG_CMD}
    1514 else
    1515 ( run_resume src_check || src_check ) | ${SMAGE_LOG_CMD}
    1516 die_pipestatus 0 "src_check failed"
    1517 resume_stamp src_check
    1518 fi
    1519 step_by_step src_check
    1520
    1521 # build several subpackages
    1522 if [[ -n ${SPLIT_PACKAGES} ]]
    1523 then
    1524 # save bindir & pname
    1525 split_save_variables
    1526 export SAVED_BINDIR="${BINDIR}"
    1527 for subpackage in ${SPLIT_PACKAGES}
    1528 do
    1529 if typeset -f src_install_${subpackage} > /dev/null
    1530 then
    1531 # export subpackage bindir
    1532 export BINDIR="${SAVED_BINDIR}_${subpackage}"
    1533 # export PNAME, several internal function and include
    1534 # rely on this variable
    1535 export PNAME="${subpackage}"
    1536
    1537 echo
    1538 echo -en "${COLBLUE}*** ${COLDEFAULT}"
    1539 echo -en " Running ${COLGREEN}split src_install()${COLDEFAULT}"
    1540 echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
    1541 echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."
    1542
    1543 ( run_resume src_install_${subpackage} || src_install_${subpackage} ) | ${SMAGE_LOG_CMD}
    1544 die_pipestatus 0 "src_install_${subpackage} failed"
    1545 resume_stamp src_install_${subpackage}
    1546 step_by_step src_install_${subpackage}
    1547 fi
    1548 done
    1549 # restore bindir & pname
    1550 split_restore_variables
    1551 # unset all saved smage variables
    1552 split_unset_variables
    1553 else
    1554 ( run_resume src_install || src_install ) | ${SMAGE_LOG_CMD}
    1555 die_pipestatus 0 "src_install failed"
    1556 resume_stamp src_install
    1557 step_by_step src_install
    1558 fi
    1559 fi
    1560
    1561 # echo for sake of good-looking
    1562 echo
    1563
    1564 if mqueryfeature "!compressdoc"
    1565 then
    1566 echo -e "!compressdoc detected; documentation will not be compressed ..."
    1567 elif mqueryfeature "!pkgbuild"
    1568 then
    1569 echo "!pkgbuild detected; skipping documentation compression..."
    1570 else
    1571 # compressing doc, info & man files
    1572 if [[ -n ${SPLIT_PACKAGES} ]]
    1573 then
    1574 for subpackage in ${SPLIT_PACKAGES}
    1575 do
    1576 run_resume mcompressdoc_${subpackage} || mcompressdocs ${BINDIR}_${subpackage}
    1577 resume_stamp mcompressdoc_${subpackage}
    1578 done
    1579 else
    1580 run_resume mcompressdoc || mcompressdocs ${BINDIR}
    1581 resume_stamp mcompressdoc
    1582 fi
    1583 fi
    1584
    1585 if mqueryfeature "!libtool"
    1586 then
    1587 if mqueryfeature "!pkgbuild"
    1588 then
    1589 echo "!pkgbuild detected; skipping libtool archive stripping ..."
    1590 else
    1591 if [[ -n ${SPLIT_PACKAGES} ]]
    1592 then
    1593 for subpackage in ${SPLIT_PACKAGES}
    1594 do
    1595 echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives for '${subpackage}' ...${COLDEFAULT}"
    1596 run_resume mstriplibtoolarchive_${subpackage} || mstriplibtoolarchive ${BINDIR}_${subpackage}
    1597 resume_stamp mstriplibtoolarchive_${subpackage}
    1598 done
    1599 else
    1600 echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives ...${COLDEFAULT}"
    1601 run_resume mstriplibtoolarchive || mstriplibtoolarchive ${BINDIR}
    1602 resume_stamp mstriplibtoolarchive
    1603 fi
    1604 fi
    1605 fi
    1606
    1607 if mqueryfeature "purge"
    1608 then
    1609 if mqueryfeature "!pkgbuild"
    1610 then
    1611 echo "!pkgbuild detected; skipping file purgation..."
    1612 else
    1613 if [[ -n ${SPLIT_PACKAGES} ]]
    1614 then
    1615 for subpackage in ${SPLIT_PACKAGES}
    1616 do
    1617 echo -e "${COLBLUE}===${COLGREEN} purging all purge targets in '${subpackage}' ...${COLDEFAULT}"
    1618 run_resume mpurgetargets_${subpackage} || mpurgetargets ${BINDIR}_${subpackage}
    1619 resume_stamp mpurgetargets_${subpackage}
    1620 done
    1621 else
    1622 echo -e "${COLBLUE}===${COLGREEN} purging all purge targets ...${COLDEFAULT}"
    1623 run_resume mpurgetargets || mpurgetargets ${BINDIR}
    1624 resume_stamp mpurgetargets
    1625 fi
    1626 fi
    1627 fi
    1628
    1629 # stripping all bins and libs
    1630 if mqueryfeature "!strip"
    1631 then
    1632 echo -e "!strip detected; Package will not be stripped ..."
    1633 elif mqueryfeature "!pkgbuild"
    1634 then
    1635 echo "!pkgbuild detected; skipping stripping of the package ..."
    1636 else
    1637 if [[ -n ${SPLIT_PACKAGES} ]]
    1638 then
    1639 for subpackage in ${SPLIT_PACKAGES}
    1640 do
    1641 echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
    1642 run_resume mstripbins_${subpackage} || mstripbins ${BINDIR}_${subpackage}
    1643 resume_stamp mstripbins_${subpackage}
    1644 echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries for '${subpackage}' ...${COLDEFAULT}"
    1645 run_resume mstriplibs_${subpackage} || mstriplibs ${BINDIR}_${subpackage}
    1646 resume_stamp mstriplibs_${subpackage}
    1647 echo -e "${COLBLUE}===${COLGREEN} stripping static libraries for '${subpackage}' ...${COLDEFAULT}"
    1648 run_resume mstripstatic_${subpackage} || mstripstatic ${BINDIR}_${subpackage}
    1649 resume_stamp mstripstatic_${subpackage}
    1650 done
    1651 else
    1652 echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
    1653 run_resume mstripbins || mstripbins ${BINDIR}
    1654 resume_stamp mstripbins
    1655 echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries ...${COLDEFAULT}"
    1656 run_resume mstriplibs || mstriplibs ${BINDIR}
    1657 resume_stamp mstriplibs
    1658 echo -e "${COLBLUE}===${COLGREEN} stripping static libraries ...${COLDEFAULT}"
    1659 run_resume mstripstatic || mstripstatic ${BINDIR}
    1660 resume_stamp mstripstatic
    1661 fi
    1662 fi
    1663
    1664 if mqueryfeature "!pkgbuild"
    1665 then
    1666 echo -e "!pkgbuild detected; Package will not be build ..."
    1667 else
    1668 # build several targets
    1669 if [[ -n ${MAGE_TARGETS} ]]
    1670 then
    1671 for target in ${MAGE_TARGETS}
    1672 do
    1673 # check if a special target_pkgbuild exists
    1674 if typeset -f ${target}_pkgbuild > /dev/null
    1675 then
    1676 # run it
    1677 run_resume ${target}_pkgbuild || ${target}_pkgbuild
    1678 resume_stamp ${target}_pkgbuild
    1679 fi
    1680 # now create the target package
    1681 run_resume pkg_builddir_${target} || ${MLIBDIR}/pkgbuild_dir.sh \
    1682 "${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
    1683 ${BINDIR} || die "target: ${target} package-build failed"
    1684 resume_stamp pkg_builddir_${target}
    1685
    1686 # build pkg-md5-sum if requested
    1687 run_resume md5sum_${target} || generate_package_md5sum \
    1688 --pcat "${PCATEGORIE}" \
    1689 --pname "${PNAME}" \
    1690 --pver "${PVER}" \
    1691 --pbuild "${PBUILD}" \
    1692 --parch "${ARCH}" \
    1693 --target "${target}"
    1694 resume_stamp md5sum_${target}
    1695
    1696 echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1697 done
    1698
    1699 # build several subpackages
    1700 elif [[ -n ${SPLIT_PACKAGES} ]]
    1701 then
    1702 split_save_variables
    1703 for subpackage in ${SPLIT_PACKAGES}
    1704 do
    1705 # get the right variables for the split
    1706 export PNAME="${subpackage}"
    1707 split_info_${PNAME}
    1708
    1709 # jump to next one if !pkgbuild is set in split_info
    1710 mqueryfeature "!pkgbuild" && continue
    1711
    1712 # check if an special subpackage_pkgbuild exists
    1713 if typeset -f ${PNAME}_pkgbuild > /dev/null
    1714 then
    1715 # run it
    1716 run_resume ${PNAME}_pkgbuild || ${PNAME}_pkgbuild
    1717 resume_stamp ${PNAME}_pkgbuild
    1718 fi
    1719 # now create the target package
    1720 run_resume pkg_builddir_${PNAME} || ${MLIBDIR}/pkgbuild_dir.sh \
    1721 "${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
    1722 "${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
    1723 resume_stamp pkg_builddir_${PNAME}
    1724
    1725 # build pkg-md5-sum if requested
    1726 run_resume md5sum_${PNAME} || generate_package_md5sum \
    1727 --pcat "${PCATEGORIE}" \
    1728 --pname "${PNAME}" \
    1729 --pver "${PVER}" \
    1730 --pbuild "${PBUILD}" \
    1731 --parch "${ARCH}"
    1732 resume_stamp md5sum_${PNAME}
    1733
    1734 echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1735
    1736 # restore smage environment
    1737 split_restore_variables
    1738 done
    1739 # unset all saved smage variables
    1740 split_unset_variables
    1741
    1742 else
    1743 run_resume pkg_builddir || ${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
    1744 resume_stamp pkg_builddir
    1745
    1746 # build pkg-md5-sum if requested
    1747 run_resume md5sum || generate_package_md5sum \
    1748 --pcat "${PCATEGORIE}" \
    1749 --pname "${PNAME}" \
    1750 --pver "${PVER}" \
    1751 --pbuild "${PBUILD}" \
    1752 --parch "${ARCH}"
    1753 resume_stamp md5sum
    1754
    1755 echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
    1756 fi
    1757
    1758 # build src-pkg-tarball if requested
    1759 if mqueryfeature "srcpkg"
    1760 then
    1761 resume_stamp srcpkgbuild || source_pkg_build ${SMAGENAME}
    1762 resume_stamp srcpkgbuild
    1763 fi
    1764 fi
    1765
    1766 if mqueryfeature "buildlog"
    1767 then
    1768 bzip2 -9f /var/log/smage/${PKGNAME}.log
    1769 else
    1770 [[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
    1771 fi
    1772
    1773 xtitleclean

    Properties

    Name Value
    svn:executable *