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

    Properties

    Name Value
    svn:executable *