[gentoo-commits] gentoo-alt r1628 - in trunk/aix-miscutils: . aixdll ldd

[Michael Haubenwallner (haubi)]

Author: haubi
Date: 2008-05-06 13:57:29 +0000 (Tue, 06 May 2008)
New Revision: 1628

Added:
   trunk/aix-miscutils/aixdll/aixdll.in
   trunk/aix-miscutils/aixdll/aixdll.sh
   trunk/aix-miscutils/ldd/Dependency.h
   trunk/aix-miscutils/ldd/Executable.h
   trunk/aix-miscutils/ldd/Object.h
   trunk/aix-miscutils/ldd/ObjectKey.h
   trunk/aix-miscutils/ldd/ObjectReader.cc
   trunk/aix-miscutils/ldd/ObjectReader.h
   trunk/aix-miscutils/ldd/SearchPath.h
   trunk/aix-miscutils/ldd/SharedObject.h
   trunk/aix-miscutils/ldd/StaticObject.h
   trunk/aix-miscutils/ldd/aixdll-query.cc
   trunk/aix-miscutils/ldd/ldd.cc
   trunk/aix-miscutils/ldd/smartptr.h
Removed:
   trunk/aix-miscutils/aixdll/aixdll
   trunk/aix-miscutils/ldd/ldd
Modified:
   trunk/aix-miscutils/aixdll/Makefile.am
   trunk/aix-miscutils/configure.ac
   trunk/aix-miscutils/ldd/Makefile.am
Log:
reimplemented 'ldd for aix with GNU-like output' in c++.
additionally, 'aixdll-query' is another c++-binary now reusing the same aix-dll-reader.

Modified: trunk/aix-miscutils/aixdll/Makefile.am
===================================================================
--- trunk/aix-miscutils/aixdll/Makefile.am	2008-04-21 18:37:05 UTC (rev 1627)
+++ trunk/aix-miscutils/aixdll/Makefile.am	2008-05-06 13:57:29 UTC (rev 1628)
@@ -2,8 +2,8 @@
 # Distributed under the terms of the GNU General Public License v2
 # Author: Michael Haubenwallner <haubi@g.o>
 
-sbin_SCRIPTS = aixdll
+sbin_SCRIPTS = aixdll.sh aixdll
 
-EXTRA_DIST = aixdll
+EXTRA_DIST = aixdll.sh aixdll.in
 
 MAINTAINERCLEANFILES = Makefile.in

Deleted: trunk/aix-miscutils/aixdll/aixdll
===================================================================
--- trunk/aix-miscutils/aixdll/aixdll	2008-04-21 18:37:05 UTC (rev 1627)
+++ trunk/aix-miscutils/aixdll/aixdll	2008-05-06 13:57:29 UTC (rev 1628)
@@ -1,494 +0,0 @@
-#! /usr/bin/env bash
-# Copyright 2008 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# Author: Michael Haubenwallner <haubi@g.o>
-#
-# Utilities for dynamic link libraries (aka. shared objects) on AIX.
-#
-
-PS4='(${LINENO})+ '
-
-ACTION=${0##*/}
-[[ ${ACTION} == 'aixdll-'* ]] && ACTION=${ACTION#aixdll-} || ACTION=
-
-die() {
-	[[ $# -gt 0 ]] && echo "${ACTION}: $@" >&2
-	exit 1
-}
-
-_aixdll_cutoff() {
-	local line=$1
-	local minlen=$2
-	local maxcol=$((${#line}-${minlen}))
-	local tmpline value
-	if [[ ${line:$((maxcol-1)):1} != ' ' ]]; then
-		tmpline=${line:0:${maxcol}}
-		tmpline=${tmpline% *}
-		maxcol=$((${#tmpline}+1))
-	fi
-	value=${line:${maxcol}}
-	echo ${value}
-	echo "${line%${value}}"
-}
-
-_aixdll_read_RUNPATH_DEPLIBS() {
-	# Reads stdin up to the first empty line.
-	# The first line on stdin must be:
-	#     "INDEX PATH BASE MEMBER "
-	# The blank-counts in this line are used to parse the data.
-	#
-	# Output:
-	# Two lines going to stdout:
-	# "/path1:/path2"
-	# "'lib1.a(shr1.o)' '/path/lib2.a(shr2.o)' 'lib3.so'"
-	local line
-	local runpath= deplibs=
-	local haveHeader=false
-	local dynMEMBER dynBASE dynPATH
-
-	# global constants to calculate once only
-	declare -i PATHlen=0 BASElen=0 MEMBERlen=0
-	declare -i PATHmin=0 BASEmin=0 MEMBERmin=0
-
-	while IFS= read line
-	do
-		# empty line marks end of ImportFileStrings section
-		[[ ${line} ]] || break
-		if [[ ${line} == "INDEX "* ]]; then
-			haveHeader=true
-			if [[ ${PATHmin} -eq 0 ]]; then
-				MEMBERlen=${#line}
-				line=${line%MEMBER *}
-				MEMBERmin=${#line}
-				MEMBERlen=$((MEMBERlen-MEMBERmin))
-				BASElen=${MEMBERmin}
-				line=${line%BASE *}
-				BASEmin=${#line}
-				BASElen=$((BASElen-BASEmin))
-				PATHlen=${BASEmin}
-				line=${line%PATH *}
-				PATHmin=${#line}
-				PATHlen=$((PATHlen-PATHmin))
-			fi
-			continue
-		fi
-		${haveHeader} || continue
-
-		{ IFS= read dynMEMBER; IFS= read line; } <<-EOC
-			$(_aixdll_cutoff "${line}" ${MEMBERlen})
-		EOC
-		{ IFS= read dynBASE; IFS= read line; } <<-EOC
-			$(_aixdll_cutoff "${line}" ${BASElen})
-		EOC
-		{ IFS= read dynPATH; IFS= read line; } <<-EOC
-			$(_aixdll_cutoff "${line}" ${PATHlen})
-		EOC
-
-		if [[ ! ${dynBASE} && ${dynPATH} ]]; then
-			runpath=${dynPATH}
-			continue
-		fi
-
-		[[ ${dynBASE} && ${dynBASE} != .. && ${dynBASE} != . ]] || continue
-
-		deplibs="${deplibs} '${dynPATH%/}${dynPATH:+/}${dynBASE}${dynMEMBER:+(}${dynMEMBER}${dynMEMBER:+)}'"
-	done
-
-	echo "${runpath}"
-	echo "${deplibs}"
-}
-
-aixdll_query() {
-	# Uses /usr/bin/dump to extract information from object files
-	# or archive libraries.
-	#
-	# First argument:
-	#   either
-	#     "/bin/true"
-	#        queries binary information from file.
-	#   or
-	#     "/lib/libc.a"
-	#        queries binary information for each archive member.
-	#   or
-	#     "/lib/libc.a(shr.o)"
-	#        queries binary information for specified archive members,
-	#        archive-members can contain shell-wildcards (*?).
-	# Further arguments:
-	#   any combination of
-	#     FILE MEMBER SHROBJ FLAGS FORMAT RUNPATH DEPLIBS
-	#
-	# Output on stdout:
-	#   One line for each file or archive member, to be evaluated in
-	#   another shell environment, setting at least these variables:
-	#     FILE='...';MEMBER='...';SHROBJ=[true|false]
-	#   The format for each variable is
-	#   either (for '/bin/true')
-	#     FILE='/bin/true'
-	#     MEMBER=''
-	#     FLAGS=
-	#     FORMAT=
-	#     RUNPATH=
-	#     DEPLIBS=
-	#     SHROBJ=false
-	#     FLAGS=' RELFLG EXEC LNNO DYNLOAD DEP__SYSTEM '
-	#     FORMAT='32-bit XCOFF'
-	#     RUNPATH='/usr/lib:/lib:/usr/lpp/xlC/lib'
-	#     DEPLIBS=" 'libc.a(shr.o)'"
-	#   or (for '/lib/libc.a')
-	#     FILE='/lib/libc.a'
-	#     MEMBER='ptrgl_64_64.o'
-	#     FLAGS=
-	#     FORMAT=
-	#     RUNPATH=
-	#     DEPLIBS=
-	#     SHROBJ=false
-	#     FLAGS=' DEP_SYSTEM '
-	#     FORMAT='64-bit XCOFF'
-	#    <newline for each archive member>
-	#     FILE='/lib/libc.a'
-	#     MEMBER='shr.o'
-	#     FLAGS=
-	#     FORMAT=
-	#     RUNPATH=
-	#     DEPLIBS=
-	#     SHROBJ=true
-	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
-	#     FORMAT='32-bit XCOFF'
-	#     RUNPATH='/usr/lib:/lib'
-	#     DEPLIBS=" '/unix' 'libcrypt.a(shr.o)'"
-	#    <newline>
-	#   or (for '/lib/libc.a(shr*)')
-	#     FILE='/lib/libc.a'
-	#     MEMBER='shr.o'
-	#     FLAGS=
-	#     FORMAT=
-	#     RUNPATH=
-	#     DEPLIBS=
-	#     SHROBJ=true
-	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
-	#     FORMAT='32-bit XCOFF'
-	#     RUNPATH='/usr/lib:/lib'
-	#     DEPLIBS=" '/unix' 'libcrypt.a(shr.o)'"
-	#    <newline>
-	#     FILE='/lib/libc.a'
-	#     MEMBER='shr_64.o'
-	#     FLAGS=
-	#     FORMAT=
-	#     RUNPATH=
-	#     DEPLIBS=
-	#     SHROBJ=true
-	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
-	#     FORMAT='64-bit XCOFF'
-	#     RUNPATH='/usr/lib:/lib'
-	#     DEPLIBS=" '/unix' 'libcrypt.a(shr_64.o)'"
-	#    <newline>
-
-	local dll=$1 shrobj=
-	shift
-	local what="$*"
-	local dumpopts='vo' line section
-
-	: ${what:="FILE MEMBER SHROBJ FLAGS FORMAT RUNPATH DEPLIBS"}
-	what=" ${what} "
-	
-	if [[ ${dll} == *'('*')'* ]]; then
-		shrobj=${dll#*(}
-		shrobj="${shrobj%)}"
-		dll=${dll%(${shrobj})}
-	fi
-	
-	[[ ${what} == *" RUNPATH "* \
-	|| ${what} == *" DEPLIBS "* \
-	]] && dumpopts="${dumpopts}H"
-
-	# sections from 'dump -Hov'
-	#    ***Object Module Header***
-	#    ***Optional Header***
-	#    ***Import File Strings***
-	#    ***Loader Section***
-	local usethis=false linebreak=: thisshrobj= x
-	while IFS= read line
-	do
-		if [[ ${line} == *: ]]; then
-			# new archive member
-			# line="/lib/libc.a[shr.o]:"
-			usethis=false
-			if [[ ${line} == "${dll}${shrobj:+[}${shrobj}${shrobj:+]}:" ]] \
-			|| [[ ${line} == "${dll}["${shrobj:-*}"]:" ]] \
-			; then
-				thisshrobj=${line#${dll}}
-				thisshrobj=${thisshrobj%:}
-				thisshrobj=${thisshrobj#[}
-				thisshrobj=${thisshrobj%]}
-				usethis=true
-				${linebreak}
-				linebreak=echo
-				for x in ${what}; do
-					echo -n "${x}=;"
-				done
-				[[ ${what} == *" FILE "* ]] &&
-				echo -n "FILE='${dll}';"
-				# "FILE='/lib/libc.a'
-				[[ ${what} == *" MEMBER "* ]] &&
-				echo -n "MEMBER='${thisshrobj}';"
-				# "MEMBER='shr.o';"
-			fi
-			continue
-		fi
-
-		${usethis} || continue
-
-		case "${section},${line}" in
-		*,) # empty line: end of section
-			section=
-			continue
-			;;
-		*,*'***Import File Strings***')
-			# parse complete section separately using
-			# _aixdll_read_RUNPATH_DEPLIBS()
-			{	IFS= read line
-				[[ ${what} == *" RUNPATH "* ]] &&
-				echo -n "RUNPATH='${line}';"
-				IFS= read line
-				[[ ${what} == *" DEPLIBS "* ]] &&
-				echo -n "DEPLIBS=\"${line}\";"
-			} <<-EOC
-				$(_aixdll_read_RUNPATH_DEPLIBS)
-			EOC
-			continue
-			;;
-		*,*'***')
-			# new section
-			section=${line//\*} # stars
-			section=${section//	}  # tabs
-			section=${section// }  # blanks
-			continue
-			;;
-		"ObjectModuleHeader,Flags="*)
-			# line="Flags=( EXEC DYNLOAD SHROBJ DEP__SYSTEM )"
-			if [[ ${what} == *" SHROBJ "* ]]; then
-				echo -n "SHROBJ="
-				[[ ${line} == *" SHROBJ "* ]] &&
-				echo -n "true;" ||
-				echo -n "false;"
-			fi
-			[[ ${what} == *" FLAGS "* ]] || continue
-			line=${line#Flags=(}
-			line=${line%)}
-			echo -n "FLAGS='${line}';"
-			# "FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM ';"
-			continue
-			;;
-		"ObjectModuleHeader,Magic = "*)
-			# line="Magic = 0x1df  (32-bit XCOFF)"
-			# line="Magic = 0x1f7  (64-bit XCOFF)"
-			[[ ${what} == *" FORMAT "* ]] || continue
-			line=${line#Magic = *(}
-			line=${line%)}
-			echo -n "FORMAT='${line}';"
-			# "FORMAT='32-bit XCOFF';"
-			# "FORMAT='64-bit XCOFF';"
-			continue
-			;;
-		"ImportFileStrings,INDEX"*)
-		esac
-	done <<-EOF
-		$(/usr/bin/dump -X32_64 -${dumpopts} "${dll}" 2>/dev/null)
-	EOF
-	${linebreak}
-}
-
-aixdll_find_unprepared() {
-	find "$1" -type f -name 'lib*.a' -print
-}
-
-aixdll_find_prepared() {
-	find "$1" -type d -name 'lib*.a.d' -print
-}
-
-aixdll_is_prepared() {
-	local what=$1
-	[[ ${what##*/} == lib*.a.d ]]
-}
-
-aixdll_get_preparedir_for_lib() {
-	echo "${1%.d}.d"
-}
-
-aixdll_get_lib_for_preparedir() {
-	echo "${1%.d}"
-}
-
-aixdll_prepare_for_merge() {
-	# $0 target-library [source-library]
-	local libsrc=${2-${1}}
-	local libad=$(aixdll_get_preparedir_for_lib "${1}")
-	mkdir -p "${libad}" || die "Cannot create ${libad}"
-	pushd "${libad}" >/dev/null || die "Cannot cd to ${libad}"
-	local status
-	/usr/ccs/bin/ar -X32_64 -x "${libsrc}"
-	status=$?
-	popd >/dev/null || die "Cannot cd back from ${libad}"
-	if [[ ${status} -ne 0 ]]; then
-		rmdir "${libad}" >&/dev/null
-		die "Cannot un-ar ${libsrc}"
-	fi
-	true
-}
-
-aixdll_finish_merge_single() {
-	local arg keepdir
-	local libad
-	for arg
-	do
-		case ${arg} in
-		--keepdir=*)
-			keepdir=${arg#*=}
-			continue
-			;;
-		*)
-			libad=$(aixdll_get_preparedir_for_lib "${arg}")
-			;;
-		esac
-	done
-
-	: ${keepdir:=true}
-
-	aixdll_is_prepared "${libad}" || return 0
-	local liba=$(aixdll_get_lib_for_preparedir "${libad}")
-	local f
-
-	if [[ -d ${libad} && $(ls -A "${libad}/") ]]; then
-		pushd "${libad}" >/dev/null || die "Cannot cd to ${libad}"
-		rm -f "./${liba##*/}.new" || die "Cannot remove ${liba##*/}.new"
-		/usr/ccs/bin/ar -coqszvl -X 32_64 "./${liba##*/}.new" ./* || die "Cannot recreate ${liba}"
-		mv -f "./${liba##*/}.new" "${liba}" || die "Cannot move ${liba##*/}.new to ${liba}"
-		popd >/dev/null || die "Cannot cd back from ${libad}"
-	elif [[ -f ${liba} ]]; then
-		rm -f "${liba}" || die "Cannot prune '${liba}'"
-		keepdir=false
-	fi
-
-	if [[ -d ${libad} ]] && ! ${keepdir}; then
-		pushd "${libad}" >/dev/null || die "Cannot cd to ${libad}"
-		rm -f ./* || die "Cannot prune '${libad}/*'"
-		popd >/dev/null || die "Cannot cd back from ${libad}"
-		rmdir "${libad}" || die "Cannot prune '${libad}'"
-	fi
-	true
-}
-
-aixdll_finish_merge() {
-	local arg status keepdir
-	for arg
-	do
-		[[ ${arg} == --keepdir=* ]] && keepdir=${arg#*=}
-	done
-
-	for arg
-	do
-		[[ ${arg} != --* ]] || continue
-		( aixdll_finish_merge_single --keepdir=${keepdir} "${arg}" ) || status=$?
-	done
-	return ${status}
-}
-
-aixdll_merge_runtime() {
-	[[ $# -gt 0 ]] || return 0
-	local arg target current curdir libad finish keepdir
-	local curdir=$(pwd)
-	for arg
-	do
-		case "${arg}" in
-		--target=*) target=${arg#*=} ;;
-		--current=*) current=${arg#*=} ;;
-		--finish=*) finish=${arg#*=} ;;
-		--keepdir=*) keepdir=${arg#*=} ;;
-		--*) die "Invalid argument ${arg}" ;;
-		esac
-	done
-	: ${finish:=true}
-	[[ ${target} ]] || die "Missing --target"
-	[[ ${target} == /* ]] || target=${curdir}/${target}
-	[[ ${current} && ${current} != /* ]] && current=${curdir}/${current}
-	libad=$(aixdll_get_preparedir_for_lib "${target}")
-	local line status
-	local FILE MEMBER SHROBJ FLAGS
-	for arg
-	do
-		[[ ${arg} == '--'* ]] && continue
-		[[ ${arg} == /* ]] || arg=${curdir}/${arg}
-
-		while IFS= read line
-		do
-			[[ ${line} == *SHROBJ=* ]] || continue
-			eval "${line}"
-			${SHROBJ} || continue
-			mkdir -p "${libad}" || die "Cannot create '${libad}'"
-			pushd "${libad}" >/dev/null || die "Cannot cd to ${libad}"
-			/usr/ccs/bin/ar -X32_64 -x "${FILE}" "${MEMBER}"
-			status=$?
-			if [[ ${status} -ne 0 ]]; then
-				popd >/dev/null || die "Cannot cd back from ${libad}"
-				rmdir "${libad}" >&/dev/null
-				die "Cannot extract '${MEMBER}' of '${FILE}'"
-			fi
-			if [[ ${arg} != "${current}" ]]; then
-				[[ ${FLAGS} == *" LOADONLY "* ]] ||
-				/usr/ccs/bin/strip -e "./${MEMBER}" ||
-				die "Cannot set flag LOADONLY for ${MEMBER}"
-			else
-				[[ ${FLAGS} != *" LOADONLY "* ]] ||
-				/usr/ccs/bin/strip -E "./${MEMBER}" ||
-				die "Cannot drop flag LOADONLY from ${MEMBER}"
-			fi
-			popd >/dev/null || die "Cannot cd back from ${libad}"
-		done <<-EOF
-			$(aixdll_query "${arg}" FILE MEMBER SHROBJ FLAGS)
-		EOF
-		:
-	done
-	${finish} || return 0
-	aixdll_finish_merge --keepdir=${keepdir} "${libad}"
-}
-
-aixdll_help() {
-	cat <<EOF
-Known actions:
-	--query
-	--find-unprepared
-	--find-prepared
-	--is-prepared
-	--prepare-for-merge
-	--finish-merge
-	--merge-runtime
-EOF
-}
-
-aixdll_main() {
-	: ${ACTION:=help}
-	while [[ ${1:+set} ]]
-	do
-		case ${1} in
-		--help | \
-		--query | \
-		--find-unprepared | \
-		--find-prepared | \
-		--is-prepared | \
-		--prepare-for-merge | \
-		--finish-merge | \
-		--merge-runtime )
-			ACTION=${1#--}
-			;;
-		--debug) set -x ;;
-		*) break ;;
-		esac
-		shift
-	done
-
-	aixdll_${ACTION//-/_} "$@"
-}
-
-aixdll_main "$@"
-
-exit $?

Added: trunk/aix-miscutils/aixdll/aixdll.in
===================================================================
--- trunk/aix-miscutils/aixdll/aixdll.in	                        (rev 0)
+++ trunk/aix-miscutils/aixdll/aixdll.in	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,22 @@
+#! /usr/bin/env bash
+# Copyright 2008 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# Author: Michael Haubenwallner <haubi@g.o>
+
+prefix="@prefix@"
+exec_prefix="@exec_prefix@"
+
+if [[ -f "@sbindir@"/functions.sh ]]; then
+	. "@sbindir@"/functions.sh
+else
+	die() {
+		[[ $# -gt 0 ]] && echo "${ACTION}: $@" >&2
+		exit 1
+	}
+fi
+
+. "@sbindir@"/aixdll.sh
+
+aixdll_main "$@"
+
+exit $?

Copied: trunk/aix-miscutils/aixdll/aixdll.sh (from rev 1626, trunk/aix-miscutils/aixdll/aixdll)
===================================================================
--- trunk/aix-miscutils/aixdll/aixdll.sh	                        (rev 0)
+++ trunk/aix-miscutils/aixdll/aixdll.sh	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,382 @@
+# Copyright 2008 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# Author: Michael Haubenwallner <haubi@g.o>
+#
+# Utilities for dynamic link libraries (aka. shared objects) on AIX.
+#
+
+PS4='(${LINENO})+ '
+
+AIXDLL_ACTION=${0##*/}
+[[ ${AIXDLL_ACTION} == 'aixdll-'* ]] && AIXDLL_ACTION=${AIXDLL_ACTION#aixdll-} || AIXDLL_ACTION=
+
+_aixdll_die() {
+	if type die >&/dev/null; then
+		[[ $# -gt 0 ]] && die "${AIXDLL_ACTION}: $@"
+		die
+	else
+		[[ $# -gt 0 ]] && echo "${AIXDLL_ACTION}: $@" >&2
+		exit 1
+	fi
+}
+
+_aixdll_cutoff() {
+	local line=$1
+	local minlen=$2
+	local maxcol=$((${#line}-${minlen}))
+	local tmpline value
+	if [[ ${line:$((maxcol-1)):1} != ' ' ]]; then
+		tmpline=${line:0:${maxcol}}
+		tmpline=${tmpline% *}
+		maxcol=$((${#tmpline}+1))
+	fi
+	value=${line:${maxcol}}
+	echo ${value}
+	echo "${line%${value}}"
+}
+
+_aixdll_read_RUNPATH_DEPLIBS() {
+	# Reads stdin up to the first empty line.
+	# The first line on stdin must be:
+	#     "INDEX PATH BASE MEMBER "
+	# The blank-counts in this line are used to parse the data.
+	#
+	# Output:
+	# Two lines going to stdout:
+	# "/path1:/path2"
+	# "'lib1.a(shr1.o)' '/path/lib2.a(shr2.o)' 'lib3.so'"
+	local line
+	local runpath= deplibs=
+	local haveHeader=false
+	local dynMEMBER dynBASE dynPATH
+
+	# global constants to calculate once only
+	declare -i PATHlen=0 BASElen=0 MEMBERlen=0
+	declare -i PATHmin=0 BASEmin=0 MEMBERmin=0
+
+	while IFS= read line
+	do
+		# empty line marks end of ImportFileStrings section
+		[[ ${line} ]] || break
+		if [[ ${line} == "INDEX "* ]]; then
+			haveHeader=true
+			if [[ ${PATHmin} -eq 0 ]]; then
+				MEMBERlen=${#line}
+				line=${line%MEMBER *}
+				MEMBERmin=${#line}
+				MEMBERlen=$((MEMBERlen-MEMBERmin))
+				BASElen=${MEMBERmin}
+				line=${line%BASE *}
+				BASEmin=${#line}
+				BASElen=$((BASElen-BASEmin))
+				PATHlen=${BASEmin}
+				line=${line%PATH *}
+				PATHmin=${#line}
+				PATHlen=$((PATHlen-PATHmin))
+			fi
+			continue
+		fi
+		${haveHeader} || continue
+
+		{ IFS= read dynMEMBER; IFS= read line; } <<-EOC
+			$(_aixdll_cutoff "${line}" ${MEMBERlen})
+		EOC
+		{ IFS= read dynBASE; IFS= read line; } <<-EOC
+			$(_aixdll_cutoff "${line}" ${BASElen})
+		EOC
+		{ IFS= read dynPATH; IFS= read line; } <<-EOC
+			$(_aixdll_cutoff "${line}" ${PATHlen})
+		EOC
+
+		if [[ ! ${dynBASE} && ${dynPATH} ]]; then
+			runpath=${dynPATH}
+			continue
+		fi
+
+		[[ ${dynBASE} && ${dynBASE} != .. && ${dynBASE} != . ]] || continue
+
+		deplibs="${deplibs} '${dynPATH%/}${dynPATH:+/}${dynBASE}${dynMEMBER:+(}${dynMEMBER}${dynMEMBER:+)}'"
+	done
+
+	echo "${runpath}"
+	echo "${deplibs}"
+}
+
+aixdll_query() {
+	# Uses /usr/bin/dump to extract information from object files
+	# or archive libraries.
+	#
+	# First argument:
+	#   either
+	#     "/bin/true"
+	#        queries binary information from file.
+	#   or
+	#     "/lib/libc.a"
+	#        queries binary information for each archive member.
+	#   or
+	#     "/lib/libc.a(shr.o)"
+	#        queries binary information for specified archive members,
+	#        archive-members can contain shell-wildcards (*?).
+	# Further arguments:
+	#   any combination of
+	#     FILE MEMBER SHROBJ FLAGS FORMAT RUNPATH DEPLIBS
+	#
+	# Output on stdout:
+	#   One line for each file or archive member, to be evaluated in
+	#   another shell environment, setting at least these variables:
+	#     FILE='...';MEMBER='...';SHROBJ=[true|false]
+	#   The format for each variable is
+	#   either (for '/bin/true')
+	#     FILE='/bin/true'
+	#     MEMBER=''
+	#     FLAGS=
+	#     FORMAT=
+	#     RUNPATH=
+	#     DEPLIBS=
+	#     SHROBJ=false
+	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
+	#     FORMAT='32-bit XCOFF'
+	#     RUNPATH='/usr/lib:/lib:/usr/lpp/xlC/lib'
+	#     DEPLIBS=" 'libc.a(shr.o)'"
+	#   or (for '/lib/libc.a')
+	#     FILE='/lib/libc.a'
+	#     MEMBER='ptrgl_64_64.o'
+	#     FLAGS=
+	#     FORMAT=
+	#     RUNPATH=
+	#     DEPLIBS=
+	#     SHROBJ=false
+	#     FLAGS=' DEP_SYSTEM '
+	#     FORMAT='64-bit XCOFF'
+	#    <newline for each archive member>
+	#     FILE='/lib/libc.a'
+	#     MEMBER='shr.o'
+	#     FLAGS=
+	#     FORMAT=
+	#     RUNPATH=
+	#     DEPLIBS=
+	#     SHROBJ=true
+	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
+	#     FORMAT='32-bit XCOFF'
+	#     RUNPATH='/usr/lib:/lib'
+	#     DEPLIBS=" '/unix' 'libcrypt.a(shr.o)'"
+	#    <newline>
+	#   or (for '/lib/libc.a(shr*)')
+	#     FILE='/lib/libc.a'
+	#     MEMBER='shr.o'
+	#     FLAGS=
+	#     FORMAT=
+	#     RUNPATH=
+	#     DEPLIBS=
+	#     SHROBJ=true
+	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
+	#     FORMAT='32-bit XCOFF'
+	#     RUNPATH='/usr/lib:/lib'
+	#     DEPLIBS=" '/unix' 'libcrypt.a(shr.o)'"
+	#    <newline>
+	#     FILE='/lib/libc.a'
+	#     MEMBER='shr_64.o'
+	#     FLAGS=
+	#     FORMAT=
+	#     RUNPATH=
+	#     DEPLIBS=
+	#     SHROBJ=true
+	#     FLAGS=' EXEC DYNLOAD SHROBJ DEP__SYSTEM '
+	#     FORMAT='64-bit XCOFF'
+	#     RUNPATH='/usr/lib:/lib'
+	#     DEPLIBS=" '/unix' 'libcrypt.a(shr_64.o)'"
+	#    <newline>
+
+	aixdll-query "$@"
+}
+
+aixdll_find_unprepared() {
+	find "$1" -type f -name 'lib*.a' -print
+}
+
+aixdll_find_prepared() {
+	find "$1" -type d -name 'lib*.a.d' -print
+}
+
+aixdll_is_prepared() {
+	local what=$1
+	[[ ${what##*/} == lib*.a.d ]]
+}
+
+aixdll_get_preparedir_for_lib() {
+	echo "${1%.d}.d"
+}
+
+aixdll_get_lib_for_preparedir() {
+	echo "${1%.d}"
+}
+
+aixdll_prepare_for_merge() {
+	# $0 target-library [source-library]
+	local libsrc=${2-${1}}
+	local libad=$(aixdll_get_preparedir_for_lib "${1}")
+	mkdir -p "${libad}" || _aixdll_die "Cannot create ${libad}"
+	pushd "${libad}" >/dev/null || _aixdll_die "Cannot cd to ${libad}"
+	local status
+	/usr/ccs/bin/ar -X32_64 -x "${libsrc}"
+	status=$?
+	popd >/dev/null || _aixdll_die "Cannot cd back from ${libad}"
+	if [[ ${status} -ne 0 ]]; then
+		rmdir "${libad}" >&/dev/null
+		_aixdll_die "Cannot un-ar ${libsrc}"
+	fi
+	true
+}
+
+aixdll_finish_merge_single() {
+	local arg keepdir
+	local libad
+	for arg
+	do
+		case ${arg} in
+		--keepdir=*)
+			keepdir=${arg#*=}
+			continue
+			;;
+		*)
+			libad=$(aixdll_get_preparedir_for_lib "${arg}")
+			;;
+		esac
+	done
+
+	: ${keepdir:=true}
+
+	aixdll_is_prepared "${libad}" || return 0
+	local liba=$(aixdll_get_lib_for_preparedir "${libad}")
+	local f
+
+	if [[ -d ${libad} && $(ls -A "${libad}/") ]]; then
+		pushd "${libad}" >/dev/null || _aixdll_die "Cannot cd to ${libad}"
+		rm -f "./${liba##*/}.new" || _aixdll_die "Cannot remove ${liba##*/}.new"
+		/usr/ccs/bin/ar -coqszvl -X 32_64 "./${liba##*/}.new" ./* || _aixdll_die "Cannot recreate ${liba}"
+		mv -f "./${liba##*/}.new" "${liba}" || _aixdll_die "Cannot move ${liba##*/}.new to ${liba}"
+		popd >/dev/null || _aixdll_die "Cannot cd back from ${libad}"
+	elif [[ -f ${liba} ]]; then
+		rm -f "${liba}" || _aixdll_die "Cannot prune '${liba}'"
+		keepdir=false
+	fi
+
+	if [[ -d ${libad} ]] && ! ${keepdir}; then
+		pushd "${libad}" >/dev/null || _aixdll_die "Cannot cd to ${libad}"
+		rm -f ./* || _aixdll_die "Cannot prune '${libad}/*'"
+		popd >/dev/null || _aixdll_die "Cannot cd back from ${libad}"
+		rmdir "${libad}" || _aixdll_die "Cannot prune '${libad}'"
+	fi
+	true
+}
+
+aixdll_finish_merge() {
+	local arg status keepdir
+	for arg
+	do
+		[[ ${arg} == --keepdir=* ]] && keepdir=${arg#*=}
+	done
+
+	for arg
+	do
+		[[ ${arg} != --* ]] || continue
+		( aixdll_finish_merge_single --keepdir=${keepdir} "${arg}" ) || status=$?
+	done
+	return ${status}
+}
+
+aixdll_merge_runtime() {
+	[[ $# -gt 0 ]] || return 0
+	local arg target current curdir libad finish keepdir
+	local curdir=$(pwd)
+	for arg
+	do
+		case "${arg}" in
+		--target=*) target=${arg#*=} ;;
+		--current=*) current=${arg#*=} ;;
+		--finish=*) finish=${arg#*=} ;;
+		--keepdir=*) keepdir=${arg#*=} ;;
+		--*) _aixdll_die "Invalid argument ${arg}" ;;
+		esac
+	done
+	: ${finish:=true}
+	[[ ${target} ]] || _aixdll_die "Missing --target"
+	[[ ${target} == /* ]] || target=${curdir}/${target}
+	[[ ${current} && ${current} != /* ]] && current=${curdir}/${current}
+	libad=$(aixdll_get_preparedir_for_lib "${target}")
+	local line status
+	local FILE MEMBER SHROBJ FLAGS
+	for arg
+	do
+		[[ ${arg} == '--'* ]] && continue
+		[[ ${arg} == /* ]] || arg=${curdir}/${arg}
+
+		while IFS= read line
+		do
+			[[ ${line} == *SHROBJ=* ]] || continue
+			eval "${line}"
+			${SHROBJ} || continue
+			mkdir -p "${libad}" || _aixdll_die "Cannot create '${libad}'"
+			pushd "${libad}" >/dev/null || _aixdll_die "Cannot cd to ${libad}"
+			/usr/ccs/bin/ar -X32_64 -x "${FILE}" "${MEMBER}"
+			status=$?
+			if [[ ${status} -ne 0 ]]; then
+				popd >/dev/null || _aixdll_die "Cannot cd back from ${libad}"
+				rmdir "${libad}" >&/dev/null
+				_aixdll_die "Cannot extract '${MEMBER}' of '${FILE}'"
+			fi
+			if [[ ${arg} != "${current}" ]]; then
+				[[ ${FLAGS} == *" LOADONLY "* ]] ||
+				/usr/ccs/bin/strip -e "./${MEMBER}" ||
+				_aixdll_die "Cannot set flag LOADONLY for ${MEMBER}"
+			else
+				[[ ${FLAGS} != *" LOADONLY "* ]] ||
+				/usr/ccs/bin/strip -E "./${MEMBER}" ||
+				_aixdll_die "Cannot drop flag LOADONLY from ${MEMBER}"
+			fi
+			popd >/dev/null || _aixdll_die "Cannot cd back from ${libad}"
+		done <<-EOF
+			$(aixdll_query "${arg}" FILE MEMBER SHROBJ FLAGS)
+		EOF
+		:
+	done
+	${finish} || return 0
+	aixdll_finish_merge --keepdir=${keepdir} "${libad}"
+}
+
+aixdll_help() {
+	cat <<EOF
+Known actions:
+	--query
+	--find-unprepared
+	--find-prepared
+	--is-prepared
+	--prepare-for-merge
+	--finish-merge
+	--merge-runtime
+EOF
+}
+
+aixdll_main() {
+	: ${AIXDLL_ACTION:=help}
+	while [[ ${1:+set} ]]
+	do
+		case ${1} in
+		--help | \
+		--query | \
+		--find-unprepared | \
+		--find-prepared | \
+		--is-prepared | \
+		--prepare-for-merge | \
+		--finish-merge | \
+		--merge-runtime )
+			AIXDLL_ACTION=${1#--}
+			;;
+		--debug) set -x ;;
+		*) break ;;
+		esac
+		shift
+	done
+
+	aixdll_${AIXDLL_ACTION//-/_} "$@"
+}

Modified: trunk/aix-miscutils/configure.ac
===================================================================
--- trunk/aix-miscutils/configure.ac	2008-04-21 18:37:05 UTC (rev 1627)
+++ trunk/aix-miscutils/configure.ac	2008-05-06 13:57:29 UTC (rev 1628)
@@ -5,9 +5,15 @@
 AC_INIT(aix-miscutils,0.1.svnversion)
 AC_CONFIG_AUX_DIR([build-aux])
 AC_PROG_INSTALL
-AC_CONFIG_SRCDIR(ldd/ldd)
+AC_CONFIG_SRCDIR(aixdll/aixdll.sh)
 AC_PREREQ(2.52)
 AC_CANONICAL_HOST
 AM_INIT_AUTOMAKE
-AC_CONFIG_FILES(./Makefile ldd/Makefile aixdll/Makefile)
+AC_PROG_CXX
+AC_CONFIG_FILES(
+	Makefile
+	ldd/Makefile
+	aixdll/Makefile
+	aixdll/aixdll
+)
 AC_OUTPUT

Added: trunk/aix-miscutils/ldd/Dependency.h
===================================================================
--- trunk/aix-miscutils/ldd/Dependency.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/Dependency.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,54 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_Dependency_h
+#define _aixdll_Dependency_h
+
+#include <string>
+
+#include "SearchPath.h"
+
+namespace aixdll {
+
+class Dependency : virtual public RefCounted
+{
+public:
+	~Dependency() {}
+
+	Dependency()
+	  : name_(0)
+	  , key_(0)
+	  , provider_(0)
+	{}
+
+	Dependency(ObjectNamePtr name)
+	  : name_(name)
+	  , key_(0)
+	  , provider_(0)
+	{}
+
+	Dependency(ObjectKeyPtr key)
+		: name_(0)
+		, key_(key)
+		, provider_(0)
+	{}
+
+	ObjectNamePtr const& name() const { return name_; }
+	ObjectKeyPtr const& key() const { return key_; }
+
+	ObjectPtr provider() const { return provider_; }
+	void setProvider(ObjectPtr provider) { provider_ = provider; }
+
+private:
+	ObjectNamePtr   name_;
+	ObjectKeyPtr    key_;
+	ObjectPtr       provider_;
+};
+
+typedef SmartPtr<Dependency> DependencyPtr;
+
+}
+
+#endif /* _aixdll_Dependency_h */

Added: trunk/aix-miscutils/ldd/Executable.h
===================================================================
--- trunk/aix-miscutils/ldd/Executable.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/Executable.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,24 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_Executable_h
+#define _aixdll_Executable_h
+
+#include "SharedObject.h"
+
+namespace aixdll {
+
+class Executable : public SharedObject
+{
+public:
+	~Executable() {}
+	Executable(ObjectKeyPtr const& key, std::string const& flags, std::string const& format)
+		: SharedObject(key, flags, format)
+	{}
+};
+
+}
+
+#endif /* _aixdll_Executable_h */

Modified: trunk/aix-miscutils/ldd/Makefile.am
===================================================================
--- trunk/aix-miscutils/ldd/Makefile.am	2008-04-21 18:37:05 UTC (rev 1627)
+++ trunk/aix-miscutils/ldd/Makefile.am	2008-05-06 13:57:29 UTC (rev 1628)
@@ -2,8 +2,33 @@
 # Distributed under the terms of the GNU General Public License v2
 # Author: Michael Haubenwallner <haubi@g.o>
 
-bin_SCRIPTS = ldd
+bin_PROGRAMS = ldd aixdll-query
 
-EXTRA_DIST = ldd
+ldd_SOURCES = \
+	Dependency.h \
+	Executable.h \
+	Object.h \
+	ObjectKey.h \
+	ObjectReader.cc \
+	ObjectReader.h \
+	SearchPath.h \
+	SharedObject.h \
+	StaticObject.h \
+	smartptr.h \
+	ldd.cc
 
+aixdll_query_SOURCES = \
+	Dependency.h \
+	Executable.h \
+	Object.h \
+	Object.h \
+	ObjectKey.h \
+	ObjectReader.cc \
+	ObjectReader.h \
+	SearchPath.h \
+	SharedObject.h \
+	StaticObject.h \
+	smartptr.h \
+	aixdll-query.cc
+
 MAINTAINERCLEANFILES = Makefile.in

Added: trunk/aix-miscutils/ldd/Object.h
===================================================================
--- trunk/aix-miscutils/ldd/Object.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/Object.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,121 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_Object_h
+#define _aixdll_Object_h
+
+#include <string>
+#include <vector>
+
+#include "smartptr.h"
+
+#include "ObjectKey.h"
+
+namespace aixdll {
+
+class Object : virtual public RefCounted
+{
+public:
+	class Flags {
+#undef FLAGS
+#define FLAGS \
+	FLAG(SHROBJ) \
+	FLAG(EXEC) \
+	FLAG(DYNLOAD) \
+	FLAG(DEP_SYSTEM) \
+	FLAG(DEP__SYSTEM) \
+	FLAG(RELFLG) \
+	FLAG(LNNO) \
+/* EOF */
+
+	public:
+
+		enum type {
+#undef FLAG
+#define FLAG(flag) flag,
+			FLAGS
+			Unknown
+		};
+
+		static type getFlag(std::string const& name)
+		{
+#undef FLAG
+#define FLAG(flag) if (name == #flag) return flag;
+			FLAGS
+			return Unknown;
+		}
+
+		static std::string getName(type that)
+		{
+#undef FLAG
+#define FLAG(flag) if (flag == that) return std::string(#flag);
+			FLAGS
+			return std::string("Unknown");
+		}
+	};
+
+	virtual ~Object() {}
+
+	Object(ObjectKeyPtr const& key
+		, std::string const& flags
+		, std::string const& format
+	) : key_(key)
+	  , flags_()
+	  , format_(format)
+	  , resolved_("not found")
+	{
+		std::string::const_iterator start = flags.begin();
+		std::string::const_iterator end = start;
+		std::string::const_iterator current = end;
+		while(end != flags.end()) {
+			current = end++;
+			if (*current == ' ') {
+				if (current > start) {
+					flags_.push_back(Flags::getFlag(std::string(start, current)));
+				}
+				start = end;
+			}
+		}
+	}
+
+	ObjectKeyPtr const& key() const
+	{ return key_; }
+
+	void setResolved(std::string const& resolved)
+	{ resolved_ = resolved; }
+
+	std::string const& getResolved() const
+	{ return resolved_; }
+
+	std::string flags() const
+	{
+		std::string out;
+		for(std::vector<Flags::type>::const_iterator f = flags_.begin()
+		  ; f != flags_.end()
+		  ; f++
+		) {
+			out += " ";
+			out += Flags::getName(*f);
+		}
+		return out;
+	}
+
+	std::string const& format() const
+	{ return format_; }
+
+protected:
+	ObjectKeyPtr        key_;
+
+private:
+	std::vector<Flags::type> flags_;
+	std::string         format_;
+	std::string			resolved_;
+};
+
+typedef SmartPtr<Object> ObjectPtr;
+
+}
+
+#endif /* _aixdll_Object_h */

Added: trunk/aix-miscutils/ldd/ObjectKey.h
===================================================================
--- trunk/aix-miscutils/ldd/ObjectKey.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/ObjectKey.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,151 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_ObjectKey_h
+#define _aixdll_ObjectKey_h
+
+#include <string>
+
+#include "smartptr.h"
+
+namespace aixdll {
+
+class ObjectPath : public std::string, virtual public RefCounted
+{
+public:
+	~ObjectPath() {}
+
+	ObjectPath(std::string const& path) : std::string(path) {}
+
+	std::string const& asIdentifier() const { return *this; }
+	std::string const& string() const { return *this; }
+};
+
+typedef SmartPtr<ObjectPath> ObjectPathPtr;
+
+class ObjectName : virtual public RefCounted {
+public:
+	~ObjectName() {}
+
+	ObjectName(std::string const& base, std::string const& member)
+		: base_(base)
+		, member_(member)
+	{}
+
+	std::string const& base() const { return base_; }
+	std::string const& member() const { return member_; }
+
+	bool operator< (ObjectName const& that) const
+	{
+		if (base_ < that.base_) return true;
+		if (member_ < that.member_) return true;
+		return false;
+	}
+
+	std::string asIdentifier() const
+	{
+		std::string identifier = base_;
+		if (member_.length() > 0) {
+			identifier += "[";
+			identifier += member_;
+			identifier += "]";
+		}
+		return identifier;
+	}
+
+private:
+	std::string base_;
+	std::string member_;
+};
+
+typedef SmartPtr<ObjectName> ObjectNamePtr;
+
+static void splitIdentifier(std::string const& identifier,
+		ObjectPathPtr &objPath, ObjectNamePtr &objName)
+{
+	objPath.forget();
+	objName.forget();
+
+	std::string::const_iterator end = identifier.end();
+	if (end == identifier.begin()) {
+		return;
+	}
+
+	std::string path, base, member;
+
+	std::string::const_iterator start = end;
+	--start;
+	if (*start == ')' || *start == ']') {
+		std::string::value_type starter = (*start == ')') ? '(' : '[';
+		end = start;
+		while(start > identifier.begin()) {
+			if (*start == starter) {
+				member.assign(start+1, end);
+				end = start;
+				start--;
+				break;
+			}
+			start--;
+		}
+	}
+	while(start > identifier.begin() && *start != '/') {
+		start--;
+	}
+
+	if (*start == '/') {
+		start++;
+	}
+	base.assign(start, end);
+
+	if (start > identifier.begin()) {
+		path.assign(identifier.begin(), start);
+	}
+
+	if (path.length() > 0) {
+		objPath.eat(new ObjectPath(path));
+	}
+	objName.eat(new ObjectName(base, member));
+}
+
+class ObjectKey : virtual public RefCounted {
+public:
+	~ObjectKey() {}
+
+	ObjectKey(std::string const& identifier)
+		: path_()
+		, name_()
+	{
+		splitIdentifier(identifier, path_, name_);
+	}
+
+	ObjectKey(ObjectPathPtr const& path, ObjectNamePtr const& name)
+		: path_(path)
+		, name_(name)
+	{}
+
+	ObjectPathPtr const& path() const { return path_; }
+	ObjectNamePtr const& name() const { return name_; }
+
+	std::string asIdentifier() const
+	{
+		return path_ ? path_->asIdentifier() + name_->asIdentifier() : name_->asIdentifier();
+	}
+
+	bool operator<(ObjectKey const& that) const
+	{
+		if (path_ < that.path_) return true;
+		if (name_ < that.name_) return true;
+		return false;
+	}
+private:
+	ObjectPathPtr path_;
+	ObjectNamePtr name_;
+};
+
+typedef SmartPtr<ObjectKey> ObjectKeyPtr;
+
+}
+
+#endif /* _aixdll_ObjectKey_h */

Added: trunk/aix-miscutils/ldd/ObjectReader.cc
===================================================================
--- trunk/aix-miscutils/ldd/ObjectReader.cc	                        (rev 0)
+++ trunk/aix-miscutils/ldd/ObjectReader.cc	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,328 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <stdexcept>
+
+#include "StaticObject.h"
+#include "Executable.h"
+
+#include "ObjectReader.h"
+
+namespace aixdll {
+
+static bool readLine(FILE *file, std::string& line)
+{
+	char linebuf[1024];
+
+	line = "";
+
+	do {
+		linebuf[sizeof(linebuf)-1] = '\0';
+		char *read = fgets(linebuf, sizeof(linebuf), file);
+		if (read == NULL) {
+			if (feof(file)) {
+				return false;
+			}
+			throw std::runtime_error(strerror(errno));
+		}
+		line += read;
+	} while(linebuf[sizeof(linebuf)-1] != '\0');
+
+	while(line.length() > 0
+	   && (line[line.length()-1] == '\n' || line[line.length()-1] == '\r')
+	) {
+		line.erase(line.length()-1);
+	}
+	return true;
+}
+
+static void cutoff(std::string& line, std::string::size_type minlen, std::string& out)
+{
+	if (line.length() < 1 || line.length() <= minlen) {
+		return;
+	}
+	std::string::size_type blank = line.rfind(" ", line.length() - minlen - 1);
+	if (blank == line.npos) {
+		return;
+	}
+	blank++;
+	out.assign(line, blank, line.length() - blank);
+	line.erase(blank, line.length() - blank);
+	std::string::iterator end = out.end();
+	while(--end >= out.begin()) {
+		if (*end != ' ') {
+			break;
+		}
+		end = out.erase(end);
+	}
+}
+
+class ObjectReader::Dumper {
+public:
+	Dumper(FILE* file)
+		: file_(file)
+	{}
+
+	~Dumper()
+	{
+		if (file_) {
+			pclose(file_);
+		}
+	}
+
+	FILE* file() { return file_; }
+private:
+	FILE *file_;
+};
+
+void ObjectReader::parseRunpathDeplibs(Dumper *dumper, SharedObjectPtr &object) const
+{
+	std::string line;
+	bool haveHeader = false;
+
+	std::string::size_type MEMBERlen = 0, MEMBERmin = 0;
+	std::string::size_type BASElen = 0, BASEmin = 0;
+	std::string::size_type PATHlen = 0, PATHmin = 0;
+
+	std::string path, base, member;
+
+	while(readLine(dumper->file(), line)) {
+		if (line.empty()) {
+			break;
+		}
+		if (line.find("INDEX ") == 0) {
+			haveHeader = true;
+			MEMBERmin = line.rfind("MEMBER ");
+			MEMBERlen = line.length() - MEMBERmin;
+			BASEmin = line.rfind("BASE ", MEMBERmin);
+			BASElen = MEMBERmin - BASEmin;
+			PATHmin = line.rfind("PATH ", BASEmin);
+			PATHlen = BASEmin - PATHmin;
+			continue;
+		}
+		if (! haveHeader) continue;
+
+		cutoff(line, MEMBERlen, member);
+		cutoff(line, BASElen, base);
+		cutoff(line, PATHlen, path);
+
+		if (base == "." || base == "..") {
+			continue;
+		}
+
+		if (base.length() == 0) {
+			object->setRunpath(SearchPathPtr(new SearchPath(path)));
+		} else
+		if (path.length() > 0) {
+			object->addDependency
+			(	DependencyPtr(new Dependency
+				(	ObjectKeyPtr(
+						new ObjectKey
+					(	ObjectPathPtr(new ObjectPath(path))
+					  ,	ObjectNamePtr(new ObjectName(base, member))
+					)
+				))
+			));
+		} else {
+			object->addDependency
+			(	DependencyPtr(new Dependency
+				(	ObjectNamePtr(new ObjectName(base, member)))
+			));
+		}
+	}
+}
+
+int ObjectReader::readObjects(std::string const& filename
+		, std::string const& identifier
+		, ObjectContainer& out
+)
+{
+	int rv = 0;
+	/* filename-based */
+	ObjectPathPtr fileObjPath;
+	ObjectNamePtr fileObjName;
+	std::string filePath;
+
+	std::string base; /* same for filename and identifier */
+	std::string member; /* same for filename and identifier */
+
+	/* identifier-based */
+	ObjectPathPtr idObjPath;
+	ObjectNamePtr idObjName;
+	std::string idPath;
+
+	/* currently read */
+	ObjectPathPtr objPath;
+	ObjectNamePtr objName;
+	std::string currMember;
+
+	splitIdentifier(filename, fileObjPath, fileObjName);
+	splitIdentifier(identifier, idObjPath, idObjName);
+
+	if (idObjPath) {
+		idPath = idObjPath->string();
+	}
+
+	if (fileObjPath) {
+		filePath = fileObjPath->string();
+	}
+	if (fileObjName && fileObjName->base().length() > 0) {
+		base = fileObjName->base();
+	}
+	if (fileObjName && fileObjName->member().length() > 0) {
+		member = fileObjName->member();
+	}
+
+	if (filePath.length() == 0) {
+		filePath = "./";
+	}
+
+	LibraryMemberCache::iterator cachedLib;
+	if (member.length() > 0) {
+		member.insert(0, "[");
+		member.append("]");
+		cachedLib = libraryMemberCache_.end();
+	} else {
+		cachedLib = libraryMemberCache_.find(idPath+base);
+	}
+
+	if (objectCache_.find(idPath + base + member) != objectCache_.end()) {
+		out.push_back(objectCache_[idPath + base + member]);
+		return 1;
+	}
+
+	if (cachedLib != libraryMemberCache_.end()) {
+		for(LibraryMemberNameContainer::iterator it = cachedLib->second.begin()
+		  ; it != cachedLib->second.end()
+		  ; ++it
+		) {
+			out.push_back(objectCache_[idPath + base + *it]);
+			++ rv;
+		}
+		return rv;
+	}
+
+	std::string dumpcommand = "/usr/bin/dump -Hov -X32_64 '";
+	dumpcommand += filePath;
+	dumpcommand += base;
+	dumpcommand += "' 2>/dev/null";
+
+	Dumper dumper(popen(dumpcommand.c_str(), "r"));
+
+	std::string line;
+
+	enum { NoSection, ImportFileStrings, ObjectModuleHeader } section = NoSection;
+
+	ObjectKeyPtr objectKey;
+	std::string flags, format;
+
+	ObjectPtr objectPtr;
+	SharedObjectPtr sharedObject;
+	StaticObjectPtr staticObject;
+
+	while(readLine(dumper.file(), line)) {
+		if (! line.empty() && line[line.length()-1] == ':') {
+			if (objectPtr != NULL) {
+				objectCache_[idPath + base + currMember] = objectPtr;
+				if (currMember.length() > 0) {
+					libraryMemberCache_[idPath + base].push_back(currMember);
+				}
+				if (member.length() == 0 || member == currMember) {
+					out.push_back(objectPtr);
+					++ rv;
+				}
+				objectPtr.forget();
+				sharedObject.forget();
+				staticObject.forget();
+			}
+
+			currMember.clear();
+
+			splitIdentifier(std::string(&line[0], &line[line.length()-1]),
+						objPath, objName);
+
+			currMember = objName->member();
+
+			if (currMember.length() > 0) {
+				currMember.insert(0, "[");
+				currMember.append("]");
+			}
+
+			if (objName->base() != base || objPath->string() != filePath) {
+				/* Huh? */
+				throw std::runtime_error("unexpected dump output");
+			}
+			objectKey.eat(new ObjectKey(idObjPath, objName));
+			flags="";
+			format="";
+			continue;
+		}
+
+		if (line.empty()) {
+			section = NoSection;
+			continue;
+		}
+
+		if (! objectPtr && flags.length() > 0 && format.length() > 0) {
+			if (flags.find("SHROBJ") != flags.npos) {
+				sharedObject.eat(new SharedObject(objectKey, flags, format));
+				objectPtr = sharedObject;
+			} else
+			if (flags.find("EXEC") != flags.npos) {
+				sharedObject.eat(new Executable(objectKey, flags, format));
+				objectPtr = sharedObject;
+			} else {
+				staticObject.eat(new StaticObject(objectKey, flags, format));
+				objectPtr =staticObject;
+			}
+			objectPtr->setResolved(filePath + objName->asIdentifier());
+		}
+
+		if (line.find("***Object Module Header***") != line.npos) {
+			section = ObjectModuleHeader;
+			continue;
+		}
+
+		if (line.find("***Import File Strings***") != line.npos) {
+			section = ImportFileStrings;
+			parseRunpathDeplibs(&dumper, sharedObject);
+			section = NoSection;
+			continue;
+		}
+
+		if (section == ObjectModuleHeader && line.find("Flags=(") == 0) {
+			line.erase(0, line.find("("));
+			line.erase(0, 1);
+			line.erase(line.find(")"));
+			flags = line;
+			continue;
+		}
+
+		if (section == ObjectModuleHeader && line.find("Magic = ") == 0) {
+			line.erase(0, line.find("("));
+			line.erase(0, 1);
+			line.erase(line.find(")"));
+			format = line;
+			continue;
+		}
+
+	}
+	if (objectPtr) {
+		objectCache_[idPath + base + currMember] = objectPtr;
+		if (currMember.length() > 0) {
+			libraryMemberCache_[idPath+base].push_back(currMember);
+		}
+		if (member.length() == 0 || member == currMember) {
+			out.push_back(objectPtr);
+			++ rv;
+		}
+	}
+
+	return rv;
+}
+
+}

Added: trunk/aix-miscutils/ldd/ObjectReader.h
===================================================================
--- trunk/aix-miscutils/ldd/ObjectReader.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/ObjectReader.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,41 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_ObjectReader_h
+#define _aixdll_ObjectReader_h
+
+#include <map>
+#include <string>
+
+#include "SharedObject.h"
+#include "StaticObject.h"
+
+namespace aixdll {
+
+class ObjectReader {
+public:
+	typedef std::vector<ObjectPtr> ObjectContainer;
+
+	~ObjectReader() {}
+	ObjectReader() : objectCache_(), libraryMemberCache_() {}
+
+	int readObjects(std::string const& filename
+		, std::string const& identifier
+		, ObjectContainer& out
+	);
+private:
+	class Dumper;
+	void parseRunpathDeplibs(Dumper *dumper, SharedObjectPtr &object) const;
+
+	std::map<std::string, ObjectPtr> objectCache_;
+
+	typedef std::vector<std::string> LibraryMemberNameContainer;
+	typedef std::map<std::string, LibraryMemberNameContainer> LibraryMemberCache;
+	LibraryMemberCache libraryMemberCache_;
+};
+
+}
+
+#endif /* _aixdll_ObjectReader_h */

Added: trunk/aix-miscutils/ldd/SearchPath.h
===================================================================
--- trunk/aix-miscutils/ldd/SearchPath.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/SearchPath.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,91 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_SearchPath_h
+#define _aixdll_SearchPath_h
+
+#include <string>
+#include <vector>
+
+#include "smartptr.h"
+
+namespace aixdll {
+
+class SearchPath : virtual public RefCounted
+{
+public:
+	typedef std::vector<std::string> PathContainer;
+
+	~SearchPath() {}
+
+	SearchPath()
+		: components_()
+	{}
+
+	SearchPath(std::string const& separated)
+		: components_()
+	{
+		appendSeparated(separated);
+	}
+
+	void appendSeparated(std::string const& separated)
+	{
+		std::string::const_iterator start = separated.begin();
+		std::string::const_iterator end = start;
+		std::string::const_iterator current = end;
+		while(end != separated.end()) {
+			current = end++;
+			if (*current == ':') {
+				if (*(current - 1) == '/') {
+					components_.push_back(std::string(start, current));
+				} else {
+					components_.push_back(std::string(start, current) + "/");
+				}
+				start = end;
+			}
+		}
+		if (current > start) {
+			if (*(end-1) == '/') {
+				components_.push_back(std::string(start, end));
+			} else {
+				components_.push_back(std::string(start, end) + "/");
+			}
+		}
+	}
+
+	void append(SearchPath const& that)
+	{
+		components_.insert(components_.end(), that.components_.begin(), that.components_.end());
+	}
+
+	PathContainer const& components() const
+	{ return components_; }
+
+	std::string asSeparated() const
+	{
+		std::string separated;
+		char const *sep = "";
+		for(PathContainer::const_iterator p = components_.begin()
+		  ; p != components_.end()
+		  ; p++
+		) {
+			separated += sep;
+			separated += *p;
+			if (p->length() > 1 && (*p)[p->length()-1] == '/') {
+				separated.erase(separated.length()-1);
+			}
+			sep = ":";
+		}
+		return separated;
+	}
+private:
+	PathContainer components_;
+};
+
+typedef SmartPtr<SearchPath> SearchPathPtr;
+
+}
+
+#endif /* _aixdll_SearchPath_h */

Added: trunk/aix-miscutils/ldd/SharedObject.h
===================================================================
--- trunk/aix-miscutils/ldd/SharedObject.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/SharedObject.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,56 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_SharedObject_h
+#define _aixdll_SharedObject_h
+
+#include "Object.h"
+#include "Dependency.h"
+
+namespace aixdll {
+
+class ObjectReader;
+
+class SharedObject : public Object
+{
+public:
+	typedef std::vector<DependencyPtr> DependencyContainer;
+
+	~SharedObject() {}
+
+	SharedObject(ObjectKeyPtr const& key
+		, std::string const& flags
+		, std::string const& format
+	) : Object(key, flags, format)
+	  , runpath_()
+	  , dependencies_()
+	{}
+
+	DependencyContainer const & getDependencies() const
+	{ return dependencies_; }
+
+	SearchPathPtr const& runpath() const
+	{ return runpath_; }
+protected:
+	friend class ObjectReader;
+	void setRunpath(SearchPathPtr const& runpath)
+	{
+		runpath_ = runpath;
+	}
+
+	void addDependency(DependencyPtr const& dependency)
+	{
+		dependencies_.push_back(dependency);
+	}
+private:
+	SearchPathPtr  runpath_;
+	DependencyContainer dependencies_;
+};
+
+typedef SmartPtr<SharedObject> SharedObjectPtr;
+
+}
+
+#endif /* _aixdll_SharedObject_h */

Added: trunk/aix-miscutils/ldd/StaticObject.h
===================================================================
--- trunk/aix-miscutils/ldd/StaticObject.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/StaticObject.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,18 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_StaticObject_h
+#define _aixdll_StaticObject_h
+
+#include "Object.h"
+
+namespace aixdll {
+
+typedef Object StaticObject;
+typedef SmartPtr<StaticObject> StaticObjectPtr;
+
+}
+
+#endif /* _aixdll_StaticObject_h */

Added: trunk/aix-miscutils/ldd/aixdll-query.cc
===================================================================
--- trunk/aix-miscutils/ldd/aixdll-query.cc	                        (rev 0)
+++ trunk/aix-miscutils/ldd/aixdll-query.cc	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,129 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#include <string>
+#include <map>
+#include <iostream>
+#include <errno.h>
+
+#include "ObjectReader.h"
+
+using namespace aixdll;
+
+typedef ObjectReader::ObjectContainer ObjectContainer;
+typedef std::map<std::string, bool> QuestionContainer;
+
+bool query(std::string const& filename, QuestionContainer const& questions)
+{
+	ObjectReader reader;
+	ObjectContainer objects;
+
+	if (reader.readObjects(filename, filename, objects) == 0) {
+		std::cerr << "ldd: " << filename << ": " << strerror(ENOENT) << std::endl;
+		return true;
+	}
+
+	for(ObjectContainer::iterator o = objects.begin()
+	  ; o != objects.end()
+	  ; o++
+	) {
+		if (questions.find("FILE") != questions.end()) std::cout
+			<< " FILE='"
+				<< (*o)->key()->path()->asIdentifier()
+				<< (*o)->key()->name()->base()
+			<< "';"
+		;
+		if (questions.find("MEMBER") != questions.end()) std::cout
+			<< " MEMBER='"
+				<< (*o)->key()->name()->member()
+			<< "';"
+		;
+		if (questions.find("FLAGS") != questions.end()) std::cout
+			<< " FLAGS='"
+				<< (*o)->flags()
+			<< "';"
+		;
+		if (questions.find("FORMAT") != questions.end()) std::cout
+			<< " FORMAT='"
+				<< (*o)->format()
+			<< "';"
+		;
+		SharedObject *sharedObject = dynamic_cast<SharedObject*>(o->ptr());
+		StaticObject *staticObject = dynamic_cast<StaticObject*>(o->ptr());
+		if (sharedObject) {
+			if (questions.find("SHROBJ") != questions.end()) std::cout
+				<< " SHROBJ=true;"
+			;
+			if (questions.find("RUNPATH") != questions.end()) std::cout
+				<< " RUNPATH='"
+					<< sharedObject->runpath()->asSeparated()
+				<< "';"
+			;
+			if (questions.find("DEPLIBS") != questions.end()) {
+				std::cout
+					<< " DEPLIBS=\""
+				;
+				SharedObject::DependencyContainer const& deps = sharedObject->getDependencies();
+				for(SharedObject::DependencyContainer::const_iterator dep = deps.begin()
+				  ; dep != deps.end()
+				  ; dep++
+				) {
+					std::cout << " '";
+					if ((*dep)->key()) {
+						std::cout << (*dep)->key()->asIdentifier();
+					} else {
+						std::cout << (*dep)->name()->asIdentifier();
+					}
+					std::cout << "'";
+				}
+				std::cout << "\";";
+			}
+		} else {
+			if (questions.find("SHROBJ") != questions.end()) std::cout
+				<< " SHROBJ=false;"
+			;
+			if (questions.find("RUNPATH") != questions.end()) std::cout
+				<< " RUNPATH='';"
+			;
+			if (questions.find("DEPLIBS") != questions.end()) std::cout
+				<< " DEPLIBS='';"
+			;
+		}
+
+		std::cout << std::endl;
+	}
+
+	return false;
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	QuestionContainer questions;
+
+	if (argc < 2) {
+		std::cout << argv[0] << " file [what1 [what2] [whatn]]\n"
+			"available for [what]:\n"
+			"\tFILE MEMBER FLAGS FORMAT SHROBJ RUNPATH DEPLIBS"
+		<< std::endl;
+		return 0;
+	}
+
+	for(i = 2; i < argc; i++) {
+		questions[argv[i]] = true;
+	}
+
+	if (questions.size() == 0) {
+		questions["FILE"] = true;
+		questions["MEMBER"] = true;
+		questions["FLAGS"] = true;
+		questions["FORMAT"] = true;
+		questions["SHROBJ"] = true;
+		questions["RUNPATH"] = true;
+		questions["DEPLIBS"] = true;
+	}
+
+	return query(argv[1], questions);
+}

Deleted: trunk/aix-miscutils/ldd/ldd
===================================================================
--- trunk/aix-miscutils/ldd/ldd	2008-04-21 18:37:05 UTC (rev 1627)
+++ trunk/aix-miscutils/ldd/ldd	2008-05-06 13:57:29 UTC (rev 1628)
@@ -1,174 +0,0 @@
-#! /usr/bin/env bash
-# Copyright 2008 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# Author: Michael Haubenwallner <haubi@g.o>
-#
-# An ldd for AIX with Linux-like output,
-# using /usr/bin/dump to grok the binaries.
-#
-
-declare -i PATHlen=0 BASElen=0 MEMBERlen=0
-declare -i PATHmin=0 BASEmin=0 MEMBERmin=0
-
-declare -i PATHcol=0 BASEcol=0 MEMBERcol=0
-
-declare -r NOTFOUND=" => not found"
-
-cutoff() {
-	local line=$1
-	local minlen=$2
-	local maxcol=$((${#line}-${minlen}))
-	local tmpline value
-	if [[ ${line:$((maxcol-1)):1} != ' ' ]]; then
-		tmpline=${line:0:${maxcol}}
-		tmpline=${tmpline% *}
-		maxcol=$((${#tmpline}+1))
-	fi
-	value=${line:${maxcol}}
-	echo ${value}
-	echo "${line%${value}}"
-}
-
-ldd_recurse() {
-
-	local binary=${1}
-	local dodeep=${2:-true}
-	local realfile=${binary%%(*}
-	if [[ ${realfile} != ${binary} ]]; then
-		local shrobj=${binary#*(}
-		shrobj=${shrobj%)}
-		binary="${realfile}[${shrobj}]"
-	fi
-	local useThisObject=false haveLoaderSection=false useThisLine=false
-	local dynMEMBER dynBASE dynPATH RUNPATH
-	local line recurse found
-
-	while IFS= read line
-	do
-		${useThisLine} && [[ ${line} == '' ]] && break
-		if [[ ${line} == *: ]]; then
-			${useThisObject} && break
-			useThisObject=false
-			haveLoaderSection=false
-			useThisLine=false
-			[[ ${line} == "${binary}:" ]] && useThisObject=true
-			continue
-		fi
-		${useThisObject} || continue
-
-		if ! ${haveLoaderSection} && [[ ${line} == *"***Import File Strings***"* ]]
-		then
-			haveLoaderSection=true
-			continue
-		fi
-		${haveLoaderSection} || continue
-
-		if ! ${useThisLine}; then
-			if [[ ${line} == "INDEX "* ]]; then
-				if [[ ${PATHmin} -eq 0 ]]; then
-					MEMBERlen=${#line}
-					line=${line%MEMBER *}
-					MEMBERmin=${#line}
-					MEMBERlen=$((MEMBERlen-MEMBERmin))
-					BASElen=${MEMBERmin}
-					line=${line%BASE *}
-					BASEmin=${#line}
-					BASElen=$((BASElen-BASEmin))
-					PATHlen=${BASEmin}
-					line=${line%PATH *}
-					PATHmin=${#line}
-					PATHlen=$((PATHlen-PATHmin))
-				fi
-				useThisLine=true
-			fi
-			continue
-		fi
-
-		{ IFS= read dynMEMBER; IFS= read line; } <<-EOC
-			$(cutoff "${line}" ${MEMBERlen})
-		EOC
-		{ IFS= read dynBASE; IFS= read line; } <<-EOC
-			$(cutoff "${line}" ${BASElen})
-		EOC
-		{ IFS= read dynPATH; IFS= read line; } <<-EOC
-			$(cutoff "${line}" ${PATHlen})
-		EOC
-
-		dynINDEX=$(echo ${line})
-
-		[[ ! ${dynBASE} && ${dynPATH} ]] && RUNPATH=${dynPATH}
-
-		[[ ${dynBASE} && ${dynBASE} != .. && ${dynBASE} != . ]] || continue
-
-		recurse="${dynPATH%/}${dynPATH:+/}${dynBASE}${dynMEMBER:+(}${dynMEMBER}${dynMEMBER:+)}"
-
-		saveIFS=$IFS; IFS=:; set dummy ${dynPATH:-${LIBPATH}${LIBPATH:+:}${RUNPATH}}; IFS=$saveIFS; shift
-		found=${NOTFOUND}
-		recurse=${NOTFOUND}
-		for p
-		do
-			p=${p%/}
-			test -f "${p}/${dynBASE}" || continue;
-			takeit=false
-			while IFS= read line; do
-				if [[ ${line} == "${p}/${dynBASE}"*: ]]; then
-					takeit=false
-					if [[ ${line} == "${p}/${dynBASE}${dynMEMBER:+[}${dynMEMBER}${dynMEMBER:+]}:" ]]; then
-						takeit=true
-						continue
-					fi
-				fi
-				${takeit} || continue
-				[[ ${line} == "Flags=("* ]] || continue
-				takeit=false
-				if [[ ${line} == *" EXEC "* && ${line} == *" DYNLOAD "* ]]; then
-					recurse="${p}/${dynBASE}${dynMEMBER:+(}${dynMEMBER}${dynMEMBER:+)}"
-					if [[ ${dynPATH} ]]; then
-						found=""
-					else
-						found=" => ${recurse}"
-					fi
-					break
-				fi
-			done <<-EOF
-			$(/usr/bin/dump -X32_64 -ov "${p}/${dynBASE}")
-			EOF
-			[[ ${found} != ${NOTFOUND} ]] && break
-		done
-		[[ ${SEEN} == *" '${recurse}' "* ]] && recurse=
-		if [[ ${recurse} ]]; then
-			echo "	${dynPATH%/}${dynPATH:+/}${dynBASE}${dynMEMBER:+(}${dynMEMBER}${dynMEMBER:+)}${found}"
-			[[ ${recurse} != ${NOTFOUND} ]] || continue
-			SEEN="${SEEN} '${recurse}' "
-			${dodeep} && ldd_recurse "${recurse}" true
-		fi
-	done <<-EOF
-	$(/usr/bin/dump -X32_64 -H "${realfile}")
-	EOF
-}
-
-ldd() {
-	local arg dodeep=true
-	local SEEN=
-	local TODO=
-
-	for arg
-	do
-		case ${arg} in
-		--shallow) dodeep=false ;;
-		--deep) dodeep=true ;;
-		*) 
-			TODO="${TODO} '${arg}'"
-		;;
-		esac
-	done
-	eval "set -- ${TODO}"
-	for arg
-	do
-		[[ $# -gt 1 ]] && echo "${arg}:"
-		SEEN=
-		ldd_recurse "${arg}" ${dodeep}
-	done
-}
-
-ldd "$@"

Added: trunk/aix-miscutils/ldd/ldd.cc
===================================================================
--- trunk/aix-miscutils/ldd/ldd.cc	                        (rev 0)
+++ trunk/aix-miscutils/ldd/ldd.cc	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,198 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+#include <errno.h>
+
+#include "ObjectReader.h"
+
+using namespace aixdll;
+
+typedef ObjectReader::ObjectContainer ObjectContainer;
+typedef std::map<std::string, ObjectPtr> SeenContainer;
+typedef std::vector<std::string> MissingContainer;
+
+static bool collectSharedObjects(ObjectReader& reader, bool shallow
+		, std::string const& path, std::string const& identifier
+		, SeenContainer& read, ObjectContainer& resolved, MissingContainer& unread, SearchPath& runpath
+	)
+{
+	ObjectContainer objects;
+
+	if (reader.readObjects(path + identifier, identifier, objects) == 0) {
+		return false;
+	}
+
+	ObjectContainer::iterator obj;
+	for(obj = objects.begin(); obj != objects.end(); obj++) {
+		SharedObject* sharedObject = dynamic_cast<SharedObject*>(obj->ptr());
+		if (sharedObject == NULL) {
+			continue;
+		}
+
+		runpath.append(*sharedObject->runpath().ptr());
+		read[sharedObject->key()->asIdentifier()] = *obj;
+		resolved.push_back(*obj);
+
+		if (shallow) continue;
+
+		SharedObject::DependencyContainer const& dependencies =
+			sharedObject->getDependencies();
+		SharedObject::DependencyContainer::const_iterator dep;
+		for(dep = dependencies.begin(); dep != dependencies.end(); dep++) {
+			if ((*dep)->key()) {
+				if (read.find((*dep)->key()->asIdentifier()) != read.end()) {
+					continue;
+				}
+				unread.push_back((*dep)->key()->asIdentifier());
+			} else
+			if ((*dep)->name()) {
+				if (read.find((*dep)->name()->asIdentifier()) != read.end()) {
+					continue;
+				}
+				unread.push_back((*dep)->name()->asIdentifier());
+			}
+		}
+	}
+
+	return true;
+}
+
+void ldd_r(ObjectReader& reader, bool shallow, std::string const& filename)
+{
+	SeenContainer read;
+	MissingContainer unread;
+	ObjectContainer resolved;
+	SearchPath runpath;
+	char const* envLibpath = getenv("LIBPATH");
+	if (envLibpath) {
+		runpath.appendSeparated(envLibpath);
+	}
+
+	if (!collectSharedObjects(reader, false, "", filename, read, resolved, unread, runpath)) {
+		return;
+	}
+
+	resolved.clear();
+
+	while(unread.size() > 0) {
+		MissingContainer::iterator unr = unread.begin();
+		ObjectPathPtr path;
+		ObjectNamePtr name;
+		std::string unrName = *unr;
+		unread.erase(unr);
+		if (read.find(unrName) != read.end()) {
+			continue;
+		}
+		splitIdentifier(unrName, path, name);
+		if (path) {
+			if (!collectSharedObjects(reader, shallow
+					, ""
+					, unrName
+					, read
+					, resolved
+					, unread
+					, runpath
+			)) {
+				resolved.push_back(
+					ObjectPtr(new Object(
+						ObjectKeyPtr(new ObjectKey(path, name))
+						, "", ""
+					))
+				);
+			}
+		} else {
+			SearchPath::PathContainer::const_iterator p;
+			for(p = runpath.components().begin()
+			  ; p != runpath.components().end()
+			  ; p++
+			) {
+				if (collectSharedObjects(reader, shallow
+						, (*p)
+						, name->asIdentifier()
+						, read
+						, resolved
+						, unread
+						, runpath
+				)) {
+					break;
+				}
+			}
+			if (p == runpath.components().end()) {
+				resolved.push_back(
+					ObjectPtr(new Object(
+						ObjectKeyPtr(new ObjectKey(path, name))
+						, "", ""
+					))
+				);
+			}
+		}
+	}
+
+	for(ObjectContainer::iterator r = resolved.begin()
+	  ; r != resolved.end()
+	  ; r++
+	) {
+		std::cout << "	" << (*r)->key()->asIdentifier()
+			<< " => "
+			<< (*r)->getResolved()
+			<< std::endl;
+	}
+}
+
+bool ldd(ObjectReader& reader, bool shallow, MissingContainer const& toread)
+{
+	ObjectContainer objects;
+	bool err = false;
+
+	for(MissingContainer::const_iterator filename = toread.begin()
+	  ; filename != toread.end()
+	  ; filename++
+	) {
+		if (reader.readObjects(*filename, *filename, objects) == 0) {
+			std::cerr << "ldd: " << *filename << ": " << strerror(ENOENT) << std::endl;
+			err = true;
+		}
+	}
+
+	for(ObjectContainer::iterator o = objects.begin()
+	  ; o != objects.end()
+	  ; o++
+	) {
+		SharedObject *sharedObject = dynamic_cast<SharedObject*>(o->ptr());
+		if (!sharedObject) {
+			continue;
+		}
+		if (objects.size() > 1) {
+			std::cout << (*o)->key()->asIdentifier() << ":" << std::endl;
+		}
+		ldd_r(reader, shallow, (*o)->key()->asIdentifier());
+	}
+
+	return err;
+}
+
+int main(int argc, char **argv)
+{
+	ObjectReader reader;
+	int i;
+	std::string arg;
+	bool shallow = false;
+	MissingContainer toread;
+
+	for(i = 1; i < argc; i++) {
+		arg = argv[i];
+		if (arg == "--shallow") {
+			shallow = true;
+			continue;
+		}
+		toread.push_back(arg);
+	}
+
+	return ldd(reader, shallow, toread);
+}

Added: trunk/aix-miscutils/ldd/smartptr.h
===================================================================
--- trunk/aix-miscutils/ldd/smartptr.h	                        (rev 0)
+++ trunk/aix-miscutils/ldd/smartptr.h	2008-05-06 13:57:29 UTC (rev 1628)
@@ -0,0 +1,110 @@
+/* Copyright 2008 Gentoo Foundation
+ * Distributed under the terms of the GNU General Public License v2
+ * Author: Michael Haubenwallner <haubi@g.o>
+ */
+
+#ifndef _aixdll_smartptr_h
+#define _aixdll_smartptr_h
+
+namespace aixdll {
+
+class RefCounted {
+public:
+   RefCounted() : refcount_(0) {}
+   virtual ~RefCounted() {}
+
+   RefCounted(const RefCounted&) : refcount_(0) {}
+   RefCounted& operator=(const RefCounted&) { return *this; }
+
+   virtual void ref() { refcount_++; }
+   virtual void unref() { if (!--refcount_) delete this; }
+
+   int refcount() const { return refcount_; }
+
+   static void ref(RefCounted* r) { if (r) r->ref(); }
+   static void unref(RefCounted* r) { if (r) r->unref(); }
+
+private:
+   int refcount_;
+};
+
+
+template <class T> class SmartPtr {
+public:
+
+   SmartPtr(): ptr_(0) {}
+
+   explicit SmartPtr(T* p): ptr_(p) { RefCounted::ref(ptr_); }
+
+   template<class RHS>
+   SmartPtr(const SmartPtr<RHS>& p): ptr_(0) { operator=(p); }
+
+   SmartPtr(const SmartPtr& p): ptr_(0) { operator=(p); }
+
+   ~SmartPtr() { RefCounted::unref(ptr_); }
+
+   template<class RHS>
+   SmartPtr&
+   operator=(
+      const SmartPtr<RHS>& p)
+   {
+      if (this->ptr() != p.ptr()) {
+         RefCounted::ref(p.ptr());
+         RefCounted::unref(this->ptr());
+         ptr_ = p.ptr();
+      }
+      return *this;
+   }
+
+   SmartPtr&
+   operator=(
+      const SmartPtr& p)
+   {
+      if (this->ptr() != p.ptr()) {
+         RefCounted::ref(p.ptr());
+         RefCounted::unref(this->ptr());
+         ptr_ = p.ptr();
+      }
+      return *this;
+   }
+
+   template<class RHS>
+   void eat(RHS* p)
+   {
+      if (p == ptr_) return;
+      RefCounted::unref(ptr_);
+      ptr_ = p;
+      RefCounted::ref(p);
+   }
+
+   void forget()
+   {
+      if (ptr_) {
+         RefCounted::unref(ptr_);
+         ptr_ = NULL;
+      }
+   }
+
+   operator bool() const {
+      return static_cast<bool>(ptr_);
+   }
+   bool operator !() const { return !ptr_; }
+   bool operator< (const SmartPtr& that) const { return ptr_< that.ptr_; }
+   bool operator==(const SmartPtr& that) const { return ptr_==that.ptr_; }
+   bool operator> (const SmartPtr& that) const { return ptr_> that.ptr_; }
+   bool operator<=(const SmartPtr& that) const { return ptr_<=that.ptr_; }
+   bool operator>=(const SmartPtr& that) const { return ptr_>=that.ptr_; }
+
+   T* ptr() const { return ptr_; }
+   T* operator->() { return ptr_; }
+   const T* cptr() const { return ptr_; }
+   const T* operator->() const { return ptr_; }
+
+
+private:
+   T* ptr_;
+};
+
+}
+
+#endif

-- 
gentoo-commits@l.g.o mailing list