#!/bin/sh

# depends: common runX11 fixtar dtree

: ${BASE=/Volumes/Builds/packages}

RBUILDS=$BASE
# SKIPCHKD=1 : skip if pkg was already checked
# ERRONLY=1  : skip pkg that were checked successfully (looks for *.Rcheck/00install.out)
# CHKXX=1    : exit after check (can be used for a single package only)

## short-circuit for performance for now ..
#if [ -z "$NOSKIP" -a -n "$1" -a -e $BASE/high-sierra-x86_64/results/4.0/$1.chkinfo ]; then echo "(already checked) $1"; exit 0; fi
#if [ -z "$NOSKIP" -a -n "$1" -a -e $BASE/high-sierra-x86_64/bin/4.0/$1_*.tgz ]; then echo "(exists) $1"; exit 0; fi

# let R generate dsyms
export PKG_MAKE_DSYM=1

# we use watchdog if it is available (it is on CRNA)
if [ -e "$BASE/watchdog" ]; then
    # set watchdog timeout to 30 minutes
    WDOG="$BASE/watchdog -v -t 1800 -f $BASE/watchdog.log"
fi

: ${INSTFLAGS=--pkglock}

# run in UTF-8 locale
export LANG=en_US.UTF-8

# add any common check flags
. $BASE/cran-flags

## Enable Timing reports
export _R_CHECK_TIMINGS_=0
export _R_CHECK_TEST_TIMING_=yes
export _R_CHECK_VIGNETTE_TIMING_=yes

# GLX is broken when running in VM, so have to set rgl to NULL
export RGL_USE_NULL=TRUE

# remove all make flags
unset MAKEFLAGS
unset MAKELEVEL
unset MFLAGS

# always enable NOAWT (to be used on Leopard)
export NOAWT=1

# set a CPU limit on builds to avoid infinite loops (1h for now)
if [ -z "$UNLIMITTED" ]; then
    ulimit -t 3600
fi

# make mu5 a no-op if it is not installed
if [ ! -e "$BASE/mu5" ]; then
    MU5="true"
else
    # so far we don't expect more than 8k packages ... adjust later
    MU5IF="-i 8192"
    MU5="$BASE/mu5"
fi

if [ ! -e $BASE/var ]; then
    mkdir -p $BASE/var
fi

if [ -z "$PKGLOCK" ]; then
    LOCKPATH=$BASE/var/lock.checking
else
    LOCKPATH=$BASE/var/lock.$PKGLOCK.checking
fi

if [ -e $LOCKPATH ]; then
    LPID=`cat $LOCKPATH`
    if ps -p $LPID|grep 'mk\.chk' 2>/dev/null; then
        echo "**ERROR: package check is locked by another build, pid $LPID." &1>2
	if [ -z "$FORCE" ]; then
	    exit 1
	fi
    else
        echo "Stale lock for pid $LPID, removing"
        rm -f $LOCKPATH
    fi
fi
echo "$$" > $LOCKPATH

: ${CRANBASE=$RBUILDS/CRAN}
if [ "${CRANBASE}" = "${RBUILDS}/CRAN" ]; then
    plain_cran=yes
fi
: ${METABASE=$CRANBASE/meta}
PKGSRCDIR=$CRANBASE/src/contrib
METASRCDIR=`echo $PKGSRCDIR|sed -e "s|$CRANBASE|$METABASE|"`
PKGDEP=$CRANBASE/dep.list

if [ -n "$CUSTOM" ]; then
    RBUILDS=`pwd`
    CRANBASE=$RBUILDS
    PKGSRCDIR=$RBUILDS/$CUSTOM
    PKGDEP=$CRANBASE/dep.list
fi

## this is only used by INSTALL_CRAN_DEPS=1 and not
## by CRAN itself (since we have everything locally)
: ${CRAN_URL=https://cloud.R-project.org}

OWD=`pwd`

. $RBUILDS/common

# TeX architecture (always native)
tarch=$arch
if [ arch == ppc ]; then tarch=powerpc; fi

: ${RBIN=R}

# prefix to use for local libraries
if [ -e "/opt/R/$arch/bin" ]; then
    R_LOCAL_PREFIX=/opt/R/$arch
else
    R_LOCAL_PREFIX=/usr/local
fi

# /sw/bin for makeinfo, teTeX for latex
if [ -z "$NOPATH" ]; then
    PATH=${R_LOCAL_PREFIX}/bin:/Library/TeX/texbin:/usr/texbin:${R_LOCAL_PREFIX}/gfortran/bin:/usr/local/bin:/usr/local/gfortran/bin:/usr/local/teTeX/bin/${tarch}-apple-darwin-current:$PATH
    if echo $rver | grep ^4.[34] >/dev/null; then
	PATH=/opt/gfortran/bin:$PATH
    fi
    export PATH
    R_PKG_CONFIG_PATH=${R_LOCAL_PREFIX}/lib/pkgconfig:${R_LOCAL_PREFIX}/share/pkgconfig:/usr/lib/pkgconfig:/opt/X11/lib/pkgconfig:/opt/X11/share/pkgconfig
    ## we re-set PKG_CONFIG_PATH before each check so use this value if set
fi

if [ $oscode = big-sur ]; then
    export SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.sdk
    export MACOSX_DEPLOYMENT_TARGET=11.0
fi

# remember the path so it can be restored
INITPATH="$PATH"

PKG_LIBRARY_PATH=

if [ -z "$RBIN" ]; then
    echo "RBIN must be either unset or non-empty"
    exit 1
fi

echo "RBUILDS: $RBUILDS"
echo "base: $CRANBASE"
echo "sources: $PKGSRCDIR"
echo "meta: $METASRCDIR"
echo "RBIN: $RBIN"
echo "CLANGPATH: $CLANGPATH"

if [ -z "$NOX11" ]; then
    X11OK=no
    for Xnum in 0 1 2 3 4; do 
	if (DISPLAY=:$Xnum xset q) >/dev/null 2>&1; then
	    X11OK=yes
	    DISPLAY=:$Xnum
	    echo ' [X11] Using session X at :'$Xnum
	    break
	fi
    done
    
    if [ $X11OK = no -a -z "$FORCE" ]; then
	echo "*** X11 is not running. Please use FORCE=1 if you want to continue anyway ***" >&2
	echo "FAILED: X11 is not running" > $BASE/FAILED-X11
#    echo " - starting virtual X11"
#    nohup $RBUILDS/runX11 &
	exit 5
    fi
    
    export DISPLAY
fi

: ${sanity=yes}

# now we get it from common
RVER=$rver
RSVER=`echo $RVER|sed 's/\([0-9]\{1,\}\.[0-9]\{1,\}\).*/\1/'`
RHOME=`$RBIN RHOME`
tri=no
quad=no
if [ -e "$RHOME/etc/x86_64" ]; then tri=yes; fi
if [ -e "$RHOME/etc/ppc64" ]; then quad=yes; fi
if [ ! -e "$RHOME/etc/ppc" ]; then NO_PPC=1; GLOBAL_NO_PPC=1; fi

#RVER=`$RBIN --version|sed -n 's/^R \([0-9.]\{1,\}\) .*/\1/p'`
#if [ -z "$RVER" ]; then
#    RVER=`$RBIN --version|sed -n 's/^Version \([0-9.]\{1,\}\) .*/\1/p'`
#fi
echo "R version $RVER"
if [ -z "$RVER" ]; then
    echo "Cannot find usable R."
    exit 1;
fi

# 2.13 and up use --compact-docs
if [ "$RSVER" != 2.12 ]; then
    LOCALINSTFLAGS=--compact-docs
fi

if [ "$RSVER" = 2.6 ]; then
  # this is for R-2.6 where everything non-UTF8 is broken
  export R_ENCODING_LOCALES="latin1=en_US.UTF-8:latin2=cs_CZ.UTF-8:UTF-8=en_US.UTF-8"
else
  # for R-devel where locales work
  export R_ENCODING_LOCALES="latin1=en_US.ISO8859-1:latin2=cs_CZ.ISO8859-2:UTF-8=en_US.UTF-8"
fi

if [ -z "$SKIP_CHK" ]; then
    SKIP_CHK=no
fi
if [ $SKIP_CHK != no ]; then
    SKIP_CHK=yes
fi
if [ -z "$UPDATE" ]; then
    UPDATE=no
fi
if [ $UPDATE != no ]; then
    UPDATE=yes
fi

if [ -z "$CHK_ONLY" ]; then
    CHK_ONLY=no
fi
if [ $CHK_ONLY != no ]; then
    CHK_ONLY=yes
    if [ $SKIP_CHK == yes ]; then
	echo "Conflicting flags, CHK_ONLY and SKIP_CHK cannot be both 'yes'." >&2
	exit 1
    fi
fi

echo " SKIP_CHK: $SKIP_CHK"
echo " CHK_ONLY: $CHK_ONLY"
echo " UPDATE  : $UPDATE"

MUDB="$RBUILDS/$biname/done.$RSVER.mudb"

: ${OUTBASE=$RBUILDS}
BINOSX=$OUTBASE/$biname/bin/$RSVER
: ${RLIB=$RBUILDS/$biname/Rlib/$RSVER}
if [ -e ${RBUILDS}/bioc.repos -a "${plain_cran}" = yes -a -z "${NOBIOC}" ]; then
    biocsd=`head -n 1 ${RBUILDS}/bioc.repos`
    : ${RLIBS=$RLIB:${RBUILDS}/BIOC.new/bin/${biocsd}/${biname}/Rlib/${RSVER}}
else
    : ${RLIBS=$RLIB}
fi

## for non-CRAN builds allow CRAN deps to be in a separate directory
if [ -e "$RBUILDS/$biname/CRANlib/$RSVER" ]; then
    RLIBS="${RLIBS}:$RBUILDS/$biname/CRANlib/$RSVER"
fi

## we are maintaining a small set of packages that other may depend on although they're not from CRAN
if [ -e "$RBUILDS/$biname/extralib/$RSVER" ]; then
    RLIBS="${RLIBS}:$RBUILDS/$biname/extralib/$RSVER"
fi

CHKRES=$OUTBASE/$biname/results/$RSVER
STOPFILE=$RBUILDS/stop.$RSVER

echo "OUTPUT:"
echo "  Rlib: $RLIB"
echo "  bin : $BINOSX"
echo "  res : $CHKRES"
echo "RLIBS=$RLIBS"

#rm -f $STOPFILE
RNAME=`openssl rand -base64 6|sed 'y|/|-|'`
#rm -rf /tmp/R* 2> /dev/null
BLDIR=/tmp/CRAN.bld.$biname.$RNAME
rm -rf $BLDIR 2> /dev/null
mkdir -p $BLDIR 2> /dev/null
#rm -rf $CHKRES 2> /dev/null
mkdir -p $CHKRES 2> /dev/null
mkdir -p $BINOSX 2> /dev/null
mkdir -p $RLIB 2> /dev/null

ccpu=$HOSTTYPE
oscs=macosx

## profiler query is expensive so only do it once
if [ ! -e "$CHKRES/00_system_info" ]; then
OSNAME=`system_profiler SPSoftwareDataType | sed -n 's/.*System Version: //p'`
HWTYPE=`system_profiler SPHardwareDataType | sed -n 's/.*Model Name: //p'`
HWCPU=`system_profiler SPHardwareDataType | sed -n 's/.*Processor Name: //p'`
if [ -z "$HWCPU" ]; then HWCPU=`system_profiler SPHardwareDataType | sed -n 's/.*Chip: //p'`; fi
HWCPUF=`system_profiler SPHardwareDataType | sed -n 's/.*Processor Speed: //p'`
SDKVER=`plutil -extract DisplayName xml1 $(xcrun --show-sdk-path)/SDKSettings.plist -o - | sed -n 's:</*string>::gp'`
CCVER=`$($RBIN CMD config CC) --version 2>&1 | sed -E -n 's:.*version.*\(([^)]+)\).*:\1:p'`
FCVER=`$($RBIN CMD config FC) --version 2>&1 | head -n1`
case ${RVER} in
    4.3*)  ppname="r-release" ;;
    4.4*)  ppname="r-devel" ;;
    2.*)   ppname="r-oldrel" ;;
    3.*)   ppname="r-oldrel" ;;
    4.*)   ppname="r-oldrel" ;;
    *) ppname="r-${RVER}" ;;
esac

LCINFO=`Rscript -e 'cat(Sys.getlocale("LC_CTYPE"))'`

echo "${ppname}-${oscs}-${ccpu}|${RVER}|${oscs}|${OSNAME}|${HWTYPE}|${HWCPU}|${HWCPUF}|${LCINFO}|${SDKVER}|${CCVER}|${FCVER}" > $CHKRES/00_system_info

echo "Machine : ${HWTYPE}, ${HWCPU} ${HWCPUF}"
echo "System  : ${OSNAME}"
echo "Profile : ${ppname}-${oscs}-${ccpu}"
echo "SDK     : ${SDKVER} (C compiler: ${CCVER})"
echo ''
fi


checkPKG() {
    if [ -e "$STOPFILE" ]; then
	echo "STOP requested ($STOPFILE)."
	rm -rf $BLDIR 2> /dev/null
	exit 2
    fi

    ## check R version
    curver=`echo 'cat(paste(R.version$major,R.version$minor,sep="."))'|$RBIN --vanilla --slave`
    if [ "$curver" != "$RVER" ]; then
	date >> $BASE/ERROR-chk-$RSVER
	echo "FATAL: R version changed from $RVER to $curver" >> $BASE/ERROR-chk-$RSVER
	echo "       while running mk.chk on '$PKG' ($TGZ)" >> $BASE/ERROR-chk-$RSVER
	exit 1
    fi

    if [ -z "${CUSTOM_TGZ}" -o -z "${TGZ}" ]; then
	TGZ=`ls $PKGSRCDIR/${PKG}_* | tail -n1`
    fi
    if [ -n "$STATINFO" ]; then
	echo "SRC_STAT: $PKG" `stat -r "${TGZ}"`
    fi
    
    TS=`date +%s:%Y%m%d:%H%M%S`
    if [ -e "$RBUILDS/excludes/$PKG" -o ! -e "$TGZ" ]; then
	if [ -e "$RBUILDS/excludes/$PKG" ]; then
	    xr=`head -n 1 $RBUILDS/excludes/$PKG`
	    echo "$TS:XCL:$PKG:excluded, reason: $xr" >> $CHKRES/chk.log
	    echo "$PKG: excluded, $xr"
	else
	    echo "$TS:ERR:$PKG:$TGZ doesn't exist" >> $CHKRES/chk.log
	fi
    else
	chkflags=''
	echo "$TS:$PKG:"
	echo "  $TGZ"
	## the following is never used on CRAN since we already have
	## all packages but may be useful for stand-alone runs
	if [ -n "$INSTALL_CRAN_DEPS" ]; then
	    R_LIBS="$RLIB" "$RBIN" --vanilla --no-save -q -s -e "fs=c('Depends','Imports','LinkingTo','Suggests','Enhances'); a= tools:::.process_package_files_for_repository_db('$TGZ','source',fs,FALSE,FALSE)[[1]][fs]; deps=tools:::.extract_dependency_package_names(paste(a[!is.na(a)],collapse=', ')); deps=deps[!deps %in% rownames(installed.packages())]; if (length(deps)) install.packages(deps, '$RLIB', repos='$CRAN_URL')"
	fi
	if [ -e "$RBUILDS/flags/$PKG" ]; then
	    chkflags=`head -n 1 $RBUILDS/flags/$PKG`
	    echo "  extra check flags: $chkflags"
	fi
	# make sure the PATH is back to normal even if preconf changed before
	PATH="$INITPATH"
	export PATH
	unset PKG_CFLAGS
	unset PKG_CPPFLAGS
	unset PKG_LIBS
	unset LIBS
	unset MAKEFLAGS
	if [ -z "$GLOBAL_NO_PPC" ]; then unset NO_PPC; fi
	if [ -z "$R_PKG_CONFIG_PATH" ]; then unset PKG_CONFIG_PATH; else
	    PKG_CONFIG_PATH="$R_PKG_CONFIG_PATH"
	    export PKG_CONFIG_PATH
	fi
	if [ -e "$RBUILDS/preconf/$PKG" ]; then
	    . "$RBUILDS/preconf/$PKG"
	    echo "  extra preconfiguration (PKG_CFLAGS=${PKG_CFLAGS}, PKG_CPPFLAGS=${PKG_CPPFLAGS}, PKG_LIBS=${PKG_LIBS})"
	    export PKG_CFLAGS
	    export PKG_CPPFLAGS
	    export PKG_LIBS
	    export LIBS
	fi
	metad=`echo "$TGZ"|sed -e "s|$CRANBASE|$METABASE|" -e 's|.tar.gz|.DESCRIPTION|'`
	echo " - looking for $metad"
	if [ "x$NOCACHE" = x -a -e $metad ]; then
	    echo " - using cached DESCRIPTION file for detection"
	    PKGVER=`sed -n 's/^Version:[ \t]\{0,\}\([a-zA-Z0-9\.\_\-]\{1,\}\).*/\1/p' $metad|head -n 1`
	    if [ x$UPDATE = xyes -a -e $BINOSX/${PKG}_${PKGVER}.tgz ]; then
		echo "  - binary exists, skipping (cached)"
		return
	    fi
	    if [ "$UPLIB" = yes -a -e ${RLIB}/${PKG} ]; then
		echo "  - package is installed, skipping"
		return
	    fi
	    #if [ x$SKIPCHKD != x -a -e $CHKRES/$PKG.Rcheck ]; then
	    if [ x$SKIPCHKD != x -a -e $CHKRES/$PKG.chkinfo ]; then
		echo "  - already checked, skipping (cached)"
		return
	    fi
	    if test x$ERRONLY != x -a -e $CHKRES/$PKG.Rcheck/00check.log && ! grep -E '^Status:.*(WARN|ERR)' $CHKRES/$PKG.Rcheck/00check.log; then
		echo "  - $PKG already checked with NOTE or OK, skipping (cached)"
		return
	    fi
	    if [ -n "$CHKBUILT" ]; then
		R_VER_FULL=`"$RBIN" --vanilla --slave -e 'cat(R.version$major, R.version$minor, sep=".")'`
		if grep "$R_VER_FULL" $CHKRES/$PKG.Rcheck/00check.log > /dev/null; then
		    echo "  - already checked against R $R_VER_FULL, skipping (cached)"
		    return
		fi
	    fi
	fi
	## check available disk space before proceeding - we require at least 1GB 
	DSKF=`df -g "$BLDIR" | awk '{print $4}' | tail -n 1`
	if [ "$DSFK" = 0 ]; then
	    echo "***FATAL ERROR: out of disk space!"
	    exit 1
	fi

	echo "  - unpacking"
	cd $BLDIR
	tar fxz "$TGZ" 2> $CHKRES/$PKG.tar
	FVER=`echo "$TGZ" | sed -n 's/.*_\(.*\).tar.gz/\1/p'`
	bundle=no
	if [ -e DESCRIPTION ]; then
	    echo "$TS:INF:$pkg:bundle"
	    bundle=yes
	fi
	if [ ! -e $PKG/DESCRIPTION ]; then
	    TS=`date +%s:%Y%m%d:%H%M%S`
	    echo "$TS:ERR:$pkg:DESCRIPTION not found" >> $CHKRES/chk.log
	    return
	fi
	PKGVER=`sed -n 's/^Version:[ \t]\{0,\}\([a-zA-Z0-9\.\_\-]\{1,\}\).*/\1/p' $PKG/DESCRIPTION|head -n 1`
	if [ -z "$PKGVER" ]; then
	    TS=`date +%s:%Y%m%d:%H%M%S`
	    echo "$TS:PVE:$pkg:package version empty" >> $CHKRES/chk.log
	    PKGVER=$FVER
	fi
	if [ "x$FVER" != "x$PKGVER" ]; then
	    echo "$TS:PVM:$pkg:$FVER:$PKGVER:version mismatch" >> $CHKRES/chk.log
	fi
	# force output file to have the same verison name - important for bundles
	#PKGVER=FVER

	mode=unknown
	checked=no
	installed=no
	bundle=no
	bcont=''
	fnbin=''

	skipthis=no
	if [ x$UPDATE = xyes -a -e $BINOSX/${PKG}_${PKGVER}.tgz ]; then
	    echo "  - $PKG binary exists, skipping"
	    skipthis=yes
	    mode=skip
	fi
#	if [ x$SKIPCHKD != x -a -e $CHKRES/$PKG.Rcheck ]; then
	if [ x$SKIPCHKD != x -a -e $CHKRES/$PKG.chkinfo ]; then
	    echo "  - $PKG already checked, skipping"
	    skipthis=yes
	    mode=skip
	fi
	if test x$ERRONLY != x -a -e $CHKRES/$PKG.Rcheck/00check.log && ! grep -E '^Status:.*(WARN|ERR)' $CHKRES/$PKG.Rcheck/00check.log; then
	    echo "  - $PKG already checked (successfully?), skipping"
	    skipthis=yes
	    mode=skip
	fi
	if [ x$SKIPDONE != x ]; then
	    if $MU5 -d "$MUDB" "$TGZ" > /dev/null; then
		echo "  - already processed, skipping"
		skipthis=yes
		mode=skip
	    fi
	fi
	CHKI=-1
	if [ $skipthis = no ]; then
	    if [ x$SKIP_CHK != xyes ]; then
		checked=yes
		echo "  - checking $PKG $chkflags"
		TS=`date +%s:%Y%m%d:%H%M%S`
		ET1=`date +%s`
		echo "$TS:CKB:$PKG:checking" >> $CHKRES/chk.log
		set > /tmp/check-status
		echo '' >> /tmp/check-status
		echo '---' >> /tmp/check-status
		## add --no-clean-on-error so we can report config.log
		chkflags="--no-clean-on-error $chkflags"
		echo R_LIBS=$RLIBS $WDOG $RBIN CMD check -o $CHKRES $chkflags  "$TGZ" >> /tmp/check-status
		R_LIBS=$RLIBS $WDOG $RBIN CMD check -o $CHKRES $chkflags "$TGZ" > $CHKRES/$PKG.out 2> $CHKRES/$PKG.err
		CHKR=$?
		TS=`date +%s:%Y%m%d:%H%M%S`
		ET2=`date +%s`
		echo "$TS:CKR:$PKG:$CHKR" >> $CHKRES/chk.log
		if [ $CHKR = 0 ]; then
		    mode=OK
		    # if it's ok also remove the build itself
		    rm -rf $CHKRES/$PKG.Rcheck/$PKG
		else
		    mode='failed check'
		    ## keep config.log if it exists
		    if [ -e $CHKRES/$PKG.Rcheck/00_pkg_src/$PKG/config.log ]; then
			cp $CHKRES/$PKG.Rcheck/00_pkg_src/$PKG/config.log $CHKRES/$PKG.Rcheck/00config.log
		    fi
		fi
		## remove the source inside the check
		rm -rf $CHKRES/$PKG.Rcheck/00_pkg_src
		ETD=`expr $ET2 - $ET1`
		FET=`expr $ETD / 60`:`expr $ETD % 60 | sed 's:^\(.\)$:0\1:'`
		cp $PKG/DESCRIPTION $CHKRES/$PKG.Rcheck/00package.dcf
		chmod a+r $CHKRES/$PKG.Rcheck/00package.dcf
		if [ -n "$chkflags" ]; then
		    echo "* using check arguments '$chkflags'" >> $CHKRES/$PKG.Rcheck/00check.log
		fi
		if [ -e "$RBUILDS/preconf/$PKG" ]; then
		    echo "* pre-conf. environment: (PKG_CFLAGS=${PKG_CFLAGS}, PKG_CPPFLAGS=${PKG_CPPFLAGS}, PKG_LIBS=${PKG_LIBS})" >> $CHKRES/$PKG.Rcheck/00check.log
		fi
		echo ''  >> $CHKRES/$PKG.Rcheck/00check.log
		echo "* elapsed time (check, wall clock): $FET" >> $CHKRES/$PKG.Rcheck/00check.log
	        # create per-package fixed-format report file
		echo "$CHKR" > "$CHKRES/$PKG.ck"
		echo "$TS" >> "$CHKRES/$PKG.ck"
		echo "$PKG" >> "$CHKRES/$PKG.ck"
		echo "$PKGVER" >> "$CHKRES/$PKG.ck"
		has_errors=no
		has_notes=no
		if grep ERROR$ "$CHKRES/$PKG.out"; then
		    has_errors=yes
		fi
		if grep NOTE$ "$CHKRES/$PKG.out"; then
		    has_notes=yes
		fi
		has_warn=no
		if grep WARNING$ "$CHKRES/$PKG.out"; then
		    has_warn=yes
		    if [ "$mode" = OK ]; then
			mode=warnings
		    fi
		fi
		echo $has_errors >> "$CHKRES/$PKG.ck"
		echo $has_warn >> "$CHKRES/$PKG.ck"
		echo "$PKG|$PKGVER|$CHKR|$has_errors|$has_warn|$has_notes|$ET1|$ETD|$chkflags" > $CHKRES/$PKG.Rcheck/00info.txt
		echo "$PKG|$PKGVER|$CHKR|$has_errors|$has_warn|$has_notes|$ET1|$ETD|$chkflags" > $CHKRES/$PKG.chkinfo
		$MU5 -d "$MUDB" $MU5IF -s "$TGZ" "$ET1|$PKG|$PKGVER|$CHKR|$has_errors|$has_warn|$has_notes|$ETD"
		CHKI=$CHKR
		if [ x$CHKXX != x ]; then exit 0; fi ## CHKXX causes mk.chk to exit after check - no installation etc.
	    else
	        # when we skip check, we just fake check=ok
		CHKR=0
	    fi
	    if [ "$CHKR" == 0 -a "$CHK_ONLY" == no ]; then
		echo "  - installing from sources"
		ET1=`date +%s`
		installed=yes
		# Don't remove the old one in case the install fails (if there were no checks ...)
		# rm -rf $RLIB/$PKG
		pkginstflags=''
		if [ -e "$RBUILDS/flags.inst/$PKG" ]; then
		    pkginstflags=`head -n 1 $RBUILDS/flags.inst/$PKG`
		    echo "  extra INSTALL flags: $pkginstflags"
		fi
		
		if [ -n "${KEEP_OBJ}" ]; then
		    OBJDIR="$OUTBASE/$biname/obj/$RSVER"
		    mkdir -p "$OBJDIR" 2>/dev/null
		    rm -rf "$OBJDIR/$PKG"
		    tar fxz "$TGZ" -C "$OBJDIR"
		    echo R_LIBS=$RLIBS $RBIN CMD INSTALL --no-clean-on-error $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB "$OBJDIR/$PKG"  > $CHKRES/$PKG.srci
		    R_LIBS=$RLIBS $RBIN CMD INSTALL --no-clean-on-error $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB "$OBJDIR/$PKG" >> $CHKRES/$PKG.srci 2> $CHKRES/$PKG.sier
		else
		    if [ -z "$pkginstflags" ]; then
			echo R_LIBS=$RLIBS $RBIN CMD INSTALL --no-clean-on-error $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB $TGZ  > $CHKRES/$PKG.srci
			R_LIBS=$RLIBS $RBIN CMD INSTALL --no-clean-on-error $INSTFLAGS $LOCALINSTFLAGS -l $RLIB $TGZ >> $CHKRES/$PKG.srci 2> $CHKRES/$PKG.sier
		    else
			echo R_LIBS=$RLIBS $RBIN CMD INSTALL $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB $TGZ  > $CHKRES/$PKG.install
			/bin/sh $CHKRES/$PKG.install >> $CHKRES/$PKG.srci 2> $CHKRES/$PKG.sier
		    fi
		fi
		SIX=$?
		if [ $universal = yes -a $SIX = 0 ]; then
		    rm -f $CHKRES/00.lib.$PKG
		    if [ ! -e "$RLIB/$PKG/libs" ]; then
			echo "    (no libs, nothing to worry about)"
		    elif [ -e "$RLIB/$PKG/libs/i386" -a -e "$RLIB/$PKG/libs/ppc" ]; then
			echo "    (multi-arch, has libs, built automatically)"
		    else
			if [ -z "${NO_PPC}" ]; then
			    echo "    (universal, building extra ppc lib) $SIX"
			    echo '---- ppc ----' >> $CHKRES/$PKG.srci
			    echo '---- ppc ----' >> $CHKRES/$PKG.sier
			    R_LIBS=$RLIBS R_ARCH=/ppc $RBIN CMD INSTALL $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB --libs-only $TGZ >> $CHKRES/$PKG.srci 2>> $CHKRES/$PKG.sier
			    SIX=$?
			fi
			if [ $tri = yes ]; then
			    echo "    (tri-arch, building extra x86_64 lib) $SIX"
			    echo '---- x86_64 ----' >> $CHKRES/$PKG.srci
			    echo '---- x86_64 ----' >> $CHKRES/$PKG.sier

			    if [ -z "$pkginstflags" ]; then
				echo R_LIBS=$RLIBS $RBIN --arch x86_64 CMD INSTALL --libs-only $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB $TGZ  > $CHKRES/$PKG.srci
				R_LIBS=$RLIBS $RBIN --arch x86_64 CMD INSTALL --libs-only $INSTFLAGS $LOCALINSTFLAGS -l $RLIB $TGZ >> $CHKRES/$PKG.srci 2> $CHKRES/$PKG.sier
			    else
				echo R_LIBS=$RLIBS $RBIN --arch x86_64 CMD INSTALL --libs-only $INSTFLAGS $LOCALINSTFLAGS $pkginstflags -l $RLIB $TGZ  > $CHKRES/$PKG.install
				/bin/sh $CHKRES/$PKG.install >> $CHKRES/$PKG.srci 2> $CHKRES/$PKG.sier
			    fi
			    SIX=$?
			    if [ "$?" != 0 ]; then
				echo "x86_64" >> $CHKRES/00.lib.$PKG
			    fi
			fi
			if [ $quad = yes ]; then
			    echo '    (giving up on ppc64)'
			    # there is no point in trying since it will fail with invalid binary error
			    #echo "    (quad-arch, building extra ppc64 lib) $SIX"
			    #echo "ppc64" >> $CHKRES/00.lib.$PKG
			    #R_LIBS=$RLIBS R_ARCH=/ppc64 $RBIN CMD INSTALL -l $RLIB --libs-only $TGZ >> $CHKRES/$PKG.srci 2>> $CHKRES/$PKG.sier
			    # ppc64 won't work, becasue we cannot run ppc64 binaries ... need caladan for this ...
			    #SIX=$?
			fi
		    fi
		fi
		if [ ! $SIX = 0 ]; then
		    echo "    [FAILED -- result: $SIX]"
		fi
		TS=`date +%s:%Y%m%d:%H%M%S`
		ET2=`date +%s`
		ETD=`expr $ET2 - $ET1`
		echo "$PKG|$PKGVER|$CHKI|$SIX|$ET1|$ETD|" > $CHKRES/$PKG.info
		echo "$TS:SIR:$PKG:$SIX" >> $CHKRES/chk.log
		if [ $SIX = 0 ]; then		
		    if [ -e $RLIB/$PKG/DESCRIPTION ]; then
			tar fc - -C $RLIB $PKG | gzip -cf9 > $BINOSX/${PKG}_${PKGVER}.tgz
			if [ -e $BINOSX/${PKG}_${PKGVER}.tgz ]; then
			    echo "$TS:OSX:$PKG:$BINOSX/${PKG}_${PKGVER}.tgz" >> $CHKRES/chk.log
			    echo "$PKG|$PKGVER|$CHKI|$SIX|$ET1|$ETD|$BINOSX/${PKG}_${PKGVER}.tgz" > $CHKRES/$PKG.info
			fi
			
	                # at least a simple sanity check
	                # FIXME: this is stupid - we need to install it first!
			if [ $CHK_ONLY = yes -a "$sanity" = yes ]; then
			    checked=sanity
			    echo "library($PKG)"|R_LIBS=$RLIBS $RBIN --no-save --slave >$CHKRES/$PKG.out 2> $CHKRES/$PKG.err
			    CHKR=$?
			    if [ $CHKR = 0 ]; then
				mode=OK
			    else
				mode='failed load'
			    fi
			fi
		    else
			if tar fxzO $TGZ $PKG/DESCRIPTION|grep ^Bundle:; then
			    bundle=yes
			    bcont=`tar fxzO $TGZ $PKG/DESCRIPTION|sed -n 's/^Contains:\(.*\)/\1/p'|tr -d '\\r'`
			    if [ -z "$bcont" ]; then
				echo "$TS:IBT:$PKG:empty Contains: clause" >> $CHKRES/chk.log
			    else
				echo "$TS:IBC:$PKG:Bundle contains '$bcont'" >> $CHKRES/chk.log
				tar fxzO $TGZ $PKG/DESCRIPTION > $RLIB/DESCRIPTION.1
				echo "Package: $PKG" > $RLIB/DESCRIPTION.0
				echo "Title: Bundle of $bcont" >> $RLIB/DESCRIPTION.0
				cat $RLIB/DESCRIPTION.0 $RLIB/DESCRIPTION.1 > $RLIB/DESCRIPTION
				rm -f $RLIB/DESCRIPTION.0 $RLIB/DESCRIPTION.1
				tar fc - -C $RLIB DESCRIPTION $bcont | gzip -cf9 > $BINOSX/${PKG}_${PKGVER}.tgz
				rm -f $RLIB/DESCRIPTION
				if [ -e $BINOSX/${PKG}_${PKGVER}.tgz ]; then
				    echo "$TS:OSX:$PKG:$BINOSX/${PKG}_${PKGVER}.tgz" >> $CHKRES/chk.log
				    echo "$PKG|$PKGVER|$CHKI|$SIX|$ET1|$ETD|$BINOSX/${PKG}_${PKGVER}.tgz" > $CHKRES/$PKG.info
				fi
			    fi
			else
			    echo "$TS:IPT:$PKG:missing installed $PKG/DESCRIPTION" >> $CHKRES/chk.log
			fi
		    fi
		else
		    mode='failed install'
		fi
		if [ -e $BINOSX/${PKG}_${PKGVER}.tgz ]; then
		    fnbin="${PKG}_${PKGVER}.tgz"
		    echo -n "$TS:PFX:$PKG:" >> $CHKRES/chk.log
		    $RBUILDS/fixtar "$BINOSX/${PKG}_${PKGVER}.tgz" 2>&1 >> $CHKRES/chk.log
		    # install binary
		    rm -rf "$RLIB/${PKG}"; $RBIN CMD INSTALL --pkglock -l "$RLIB" "$BINOSX/${PKG}_${PKGVER}.tgz" 2>&1 >> $CHKRES/chk.log
		    # register binary
#		    $BASE/register-pkgs "=$BINOSX/${PKG}_${PKGVER}.tgz" bin .tgz
		fi
	    fi
	fi
	rm -rf $PKG

	# make sure the PATH is back to normal even if preconf changed before
	PATH="$INITPATH"
	export PATH

	DTS=`date '+%Y-%m-%d %H:%M:%S'`;
	fnsrc=`basename $TGZ`;
	if [ "$mode" != skip ]; then
	    echo "$PKGSRCDIR|$PKG|$PKGVER|$RVER|$biname|$DTS|$mode|$checked|$installed|$bundle|$bcont|$fnbin|$fnsrc|$TGZ|$BINOSX/${PKG}_${PKGVER}.tgz" >> $CHKRES/db.log
	fi
#	rm -rf /tmp/Rinst.*
    fi
}

if [ -z "$1" ]; then
    echo "Building package dependency tree.."
    echo "(from $PKGSRCDIR)"
#    if [ -e "$PKGSRCDIR/Descriptions" ]; then
#	./dtree --desc $PKGSRCDIR/Descriptions $PKGSRCDIR $EXTRAREPOS > $PKGDEP
#    else
	if [ -e "$METASRCDIR" ]; then
	    echo ./dtree --desc $METASRCDIR $PKGSRCDIR $EXTRAREPOS '>' $PKGDEP
	    ./dtree --desc $METASRCDIR $PKGSRCDIR $EXTRAREPOS > $PKGDEP
	else
	    ./dtree $PKGSRCDIR $EXTRAREPOS > $PKGDEP
	fi
#    fi
    #PKGLIST=`ls $PKGSRCDIR/*.tar.gz|sed -n 's/.*\/\(.*\)_.*/\1/p'`

    echo "Checking all packages.."
    PKGLIST=`cat $PKGDEP`
    if [ -n "$FAKE" ]; then
	echo " fake run requested, terminating."
	rm -rf $BLDIR 2> /dev/null
	exit 0
    fi
    $RBIN --version > $CHKRES/R-VERSION
    uname -a > $CHKRES/SYSTEM-VERSION
    if [ -n "${PAR}" ]; then
	echo " (parallel checks ${PAR} concurrently)"
	cd "${BASE}"
	./sched "${BLDIR}/sync.bin" create "${PAR}"
	for PKG in $PKGLIST; do
	    ./sched "${BLDIR}/sync.bin" add "./mk.chk ${PKG}"
	done
	echo " waititng to finish..."
	./sched "${BLDIR}/sync.bin" close
    else
	for PKG in $PKGLIST; do
	    checkPKG
	done
    fi
else
    if [ -n "$FAKE" ]; then
	echo " fake run requested, terminating."
	rm -rf $BLDIR 2> /dev/null
	exit 0
    fi
    $RBIN --version > $CHKRES/R-VERSION
    uname -a > $CHKRES/SYSTEM-VERSION
    PKG=$1
    if [ -n "$2" ]; then
	CUSTOM_TGZ=yes
	TGZ="$2"
    fi
    checkPKG
fi
rm -f "$LOCKPATH"

cd "${OWD}"
rm -rf "$BLDIR" 2> /dev/null