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

    Properties

    Name Value
    svn:executable *