linux-qubasis

genfn.sh

(7466B)

 pkg() {
 	subgen $1 init_pkg fini_pkg
 }
 
 init_pkg() {
 	FTCH=
 	OBJS=
 	HDRS=
 	SRCS=
 	DEPS=
 
 	var srcdir $dir/src
 	var libdir $outdir
 	var objdir $outdir/obj
 	var hdrdir $outdir/include
 	var datdir $outdir/share
 
 	unset -f host
 	init_files
 }
 
 fini_pkg() {
 	if command -v host >/dev/null 2>&1 && persist; then
 		pkgsub host init_host
 	fi
 
 	[ "$DEPS" ] && phony deps $DEPS
 	[ "$HDRS" ] && phony headers $HDRS
 
 	fetch_complete
 	fini_files
 }
 
 pkgsub() {
 	SRCS="$SRCS $(sub $1 ${2-init_pkgsub} ${3-fini_pkgsub})"
 }
 
 init_host() {
 	SRCS=
 	OBJS=
 	DEPS=
 
 	var tgtdir $outdir
 	var outdir $hostdir
 	var libdir $outdir
 	var hdrdir $outdir/include
 	var objdir $objdir/host
 	var ar ar
 	var as as
 	var cc cc
 	var ld ld
 	var objcopy objcopy
 	var cflags -O2 -pipe
 	var ldflags ''
 }
 
 init_pkgsub() {
 	OBJS=
 	SRCS=
 	var outdir $outdir/$1
 	var objdir $outdir/obj
 	var libdir $outdir
 }
 
 fini_pkgsub() {
 	echo $SRCS
 }
 
 build() {
 	_v1=$1
 	_v2=$2
 	shift 2
 
 	prefix _v2 $outdir $_v2
 	prefix _vs \$srcdir $*
 
 	for _v in $_vs; do
 		case $_v in
 		\$srcdir/*) SRCS="$SRCS $_v"
 		esac
 	done
 
 	build_parse $_vs
 	write "build $_v2: $_v1 $_vs $_vd $_vo"
 }
 
 cflags() {
 	var cflags '$cflags' "$*"
 }
 
 ldflags() {
 	var ldflags '$ldflags' "$*"
 }
 
 dep() {
 	_deps=
 	for _d in $*; do
 		case $_d in
 			*.c)		prefix _d $outdir $_d;;
 			*.h)		prefix _d $hdrdir $_d;;
 			*/headers)	prefix _d pkg $_d;;
 		esac
 		_deps="$_deps $_d"
 	done
 	DEPS="$DEPS $_deps"
 }
 
 bin() {
 	_m=0755
 
 	while [ ${1#-} != $1 ]; do
 		case $1 in
 		-m) _m=$2;;
 		esac
 		shift 2
 	done
 
 	exe $*
 	file reg $_m '$bindir'/$_out $OUTDIR/$_out
 }
 
 libexec() {
 	_p=
 
 	while [ ${1#-} != $1 ]; do
 		case $1 in
 		-p) _p=$2/;;
 		esac
 		shift 2
 	done
 
 	exe $*
 	file reg 0755 '$libexecdir'/$_p$_out $OUTDIR/$_out
 }
 
 exe() {
 	_out=$1
 	shift
 	compile $*
 
 	if [ ! "$_deps" ]; then
 		link $_out $_objs $_libs
 	else
 		_rspfile=$outdir/$_out.rsp
 
 		awk $_rspfile $_deps '|' ./pkg/rsp.awk
 		bind expr '-f ./pkg/rsp.awk'
 
 		link $_out $_objs $_libs '|' $_rspfile
 		bind ldlibs @$_rspfile
 	fi
 }
 
 lib() {
 	_out=$1
 	shift
 	compile $*
 
 	ar $libdir/$_out $_objs
 	rsp $libdir/$_out.d $libdir/$_out $_rsps
 
 	file reg 0644 '$libdir'/$_out $OUTDIR/$_out
 }
 
 compile() {
 	_cflags=
 	_src_prefix=
 
 	_srcs=
 	_objs=
 	_libs=
 	_deps=
 	_hdrs=
 	_rsps=
 
 	while [ $# -gt 0 ] && [ "${1#-}" != "$1" ]; do
 		case $1 in
 		-I*|-W*|-D*|-p*|-m*)
 			_cflags="$_cflags $1"
 			shift
 			;;
 		-iquote|-include|-isystem)
 			_cflags="$_cflags $1 $2"
 			shift 2
 			;;
 		--src-prefix)
 			_src_prefix=$2/
 			shift 2
 			;;
 		-*)
 			error unknown compiler flag $1
 			;;
 		esac
 	done
 
 	for _src in $*; do
 		case $_src in
 		\$*.[cS])	_srcs="$_srcs $_src";;
 		*.[cS])		_srcs="$_srcs $_src_prefix$_src";;
 		*.o)		_objs="$_objs $_src";;
 		*.h)		_hdrs="$_hdrs $_src";;
 		*.a)		_libs="$_libs $_src"
 					_rsps="$_rsps $_src";;
 		*.a.d)		_deps="$_deps $_src"
 					_rsps="$_rsps $_src";;
 		*) error unknown file to compile: $_src;;
 		esac
 	done
 
 	prefix _srcs $srcdir $_srcs
 	prefix _hdrs $hdrdir $_hdrs
 	prefix _objs $objdir $_objs
 	prefix _libs $libdir $_libs
 	prefix _deps $libdir $_deps
 	prefix _rsps $libdir $_rsps
 
 	for _src in $_srcs; do
 		_obj=$objdir/${_src#\$*/}.o
 
 		if has $_obj $OBJS; then
 			_objs="$_objs $_obj"
 			continue
 		fi
 
 		[ "$DEPS" ] && _src="$_src || $dir/deps"
 		[ "$_hdrs" ] && _src="$_src || $_hdrs"
 
 		cc $_obj $_src
 		_objs="$_objs $_obj"
 		OBJS="$OBJS $_obj"
 
 		if [ "$_cflags" ]; then
 			bind cflags $cflags $_cflags
 		fi
 	done
 }
 
 binfiles() {
 	files --prefix binfiles $*
 	for _file in $_files; do
 		_out=${_file#*/}
 		file reg 0755 '$bindir'/${_out#binfiles/} $OUTDIR/$_out
 	done
 }
 
 libfiles() {
 	files $*
 	for _file in $_files; do
 		_out=${_file#*/}
 		file reg 0644 '$libdir'/$_out $OUTDIR/$_out
 	done
 }
 
 share() {
 	files --prefix $datdir $*
 
 	for _file in $_files; do
 		_out=${_file#*/}
 		file reg 0644 '$datadir'/$_out $OUTDIR/share/$_out
 	done
 }
 
 include() {
 	files --prefix $hdrdir $*
 
 	for _file in $_files; do
 		_out=${_file#*/}
 		file reg 0644 '$includedir'/$_out $OUTDIR/include/$_out
 		HDRS="$HDRS $_file"
 	done
 }
 
 files() {
 	_prefix=$outdir
 	_src_prefix=$srcdir
 	_keep_path=false
 
 	while [ $# -gt 0 ]; do
 		case "$1" in
 		--keep-path)
 			_keep_path=true
 			shift
 			;;
 		--prefix)
 			case $2 in
 			\$*)	_prefix=$2;;
 			*)		_prefix=$_prefix/$2;;
 			esac
 			shift 2
 			;;
 		--src-prefix)
 			case $2 in
 			\$*)	_src_prefix=$2;;
 			*)		_src_prefix=$_src_prefix/$2;;
 			esac
 			shift 2
 			;;
 		*)
 			break
 			;;
 		esac
 	done
 
 	prefix _srcs $_src_prefix $*
 	_files=
 
 	for _src in $_srcs; do
 		case $_src in
 		$_prefix/*) _out=$_src;;
 		$srcdir/*|$outdir/*|$dir/*)
 			$_keep_path && _prefix_src=${_src#$_src_prefix/} || _prefix_src=${_src##*/}
 			prefix _out $_prefix $_prefix_src
 			copy $_out $_src
 			;;
 		*) error files cannot handle $_src;;
 		esac
 		_files="$_files $_out"
 	done
 }
 
 git() {
 	[ ! "${1-}" ] && error missing git ref || _ref=$1
 	fetch_git ${_ref}_fetched
 	bind ref $_ref
 	FTCH="$FTCH $outdir/${_ref}_fetched"
 }
 
 curl() {
 	_replstr=',^[^/]*,$srcdir,'
 
 	while [ $# -gt 0 ] && [ ${1#--} != $1 ]; do
 		case $1 in
 		--replstr) _replstr="$2";;
 		*) error unknown curl flag $1;;
 		esac
 		shift 2
 	done
 
 	[ ! "${1-}" ] && error missing curl url || _url=$1
 	[ ! "${2-}" ] && error missing curl sha256sum || _sha=$2
 	shift 2
 
 	_srcs=$*
 	_name=${_url##*/}
 
 	fetch_curl $_name
 	bind url $_url
 
 	sha256sum ${_name}_checked $outdir/$_name
 	bind sha256 $_sha
 
 	case $_name in
 	*.tar.gz|*.tgz) _tool=gzip;;
 	*.tar.xz)		_tool=xz;;
 	*.tar.bz2)		_tool=bzip2;;
 	*) error unknown archive type $_name;;
 	esac
 
 	extract ${_name}_extracted $outdir/$_name '|' $outdir/${_name}_checked
 	bind tool $_tool
 	bind srcs $_srcs
 	bind replstr \"$_replstr\"
 
 	if ! grep -qE "^${DIR#./}/src$" .git/info/exclude; then
 		printf "%s/src\n" ${DIR#./} >> .git/info/exclude
 	fi
 
 	FTCH="$FTCH $outdir/${_name}_extracted"
 }
 
 fetch_complete() {
 	if [ ! "$FTCH" ]; then
 		return
 	fi
 
 	_patches=
 	phony fetch $FTCH
 
 	if [ -d $DIR/patch ]; then
 		case "$FTCH" in
 		*extracted) _rule=git_apply;;
 		*)			_rule=git_patch;;
 		esac
 
 		for _v in $DIR/patch/*.patch; do
 			_out=$outdir/${_v##*/}
 			_in=$dir/${_v#"$DIR"/}
 			$_rule $_out $_in '|' $dir/fetch $_patches
 			_patches="$_patches $_out"
 		done
 	fi
 
 	if [ "$SRCS" ]; then
 		phony "$(printf '%s\n' $SRCS | sort | uniq | xargs)" $dir/fetch "$_patches"
 	fi
 }
 
 man() {
 	_src=$1
 	_sec=${2-}
 	_out=${_src##*/}
 
 	if [ $_sec ]; then
 		_out=${_out%.*}.$_sec
 	else
 		_sec=${_out##*.}
 	fi
 
 	gzip $_out.gz $_src
 	file reg 0644 '$mandir'/man$_sec/$_out.gz $OUTDIR/$_out.gz
 }
 
 sym() {
 	case ${1%%/*} in
 	bin)	_prefix='$bindir';;
 	man)	_prefix='$mandir';;
 	share)	_prefix='$datadir';;
 	*)		error sym cannot handles prefix $_prefix;;
 	esac
 
 	file sym 0777 $_prefix/${1#*/} $2
 }
 
 file() {
 	if persist; then
 		printf '%s\n' "$*" >> $DIR/files.tmp
 	fi
 }
 
 init_files() {
 	if persist && [ -e $DIR/files.tmp ]; then
 		rm -f $DIR/files.tmp
 	fi
 }
 
 fini_files() {
 	_f=$DIR/files
 	if persist && [ -e $_f.tmp ]; then
 		if cmp -s $_f.tmp $_f; then
 			rm -f $_f.tmp
 		else
 			mv $_f.tmp $_f
 		fi
 		GEN_OUTS="$GEN_OUTS $DIR/files"
 	fi
 }
 
 waylandproto() {
 	_proto=$1
 	shift 1
 
 	while [ $# -gt 1 ]; do
 		wayland_proto $2 $_proto
 		case $1 in
 		--client) bind type client-header;;
 		--server) bind type server-header;;
 		--code)
 			bind type public-code
 			cc $outdir/$2.o $outdir/$2 '||' ./pkg/wayland/headers
 			bind cflags $cflags -isystem $pkgdir/wayland/include
 			;;
 		*) error unknown waylandproto flag $1
 		esac
 		shift 2
 	done
 }
 
 has_video_driver() {
 	has $1 $VIDEO_DRIVERS
 }