xref: /titanic_51/usr/src/cmd/ast/libshell/common/scripts/numtree1.sh (revision b4dd7d09880f14016feece03929a224eca1cf39a)

#!/usr/bin/ksh93

#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# numtree1 - basic compound variable tree demo+benchmark
#

# Solaris needs /usr/xpg6/bin:/usr/xpg4/bin because the tools in /usr/bin are not POSIX-conformant
export PATH=/usr/xpg6/bin:/usr/xpg4/bin:/bin:/usr/bin

# Make sure all math stuff runs in the "C" locale to avoid problems
# with alternative # radix point representations (e.g. ',' instead of
# '.' in de_DE.*-locales). This needs to be set _before_ any
# floating-point constants are defined in this script).
if [[ "${LC_ALL}" != "" ]] ; then
    export \
        LC_MONETARY="${LC_ALL}" \
        LC_MESSAGES="${LC_ALL}" \
        LC_COLLATE="${LC_ALL}" \
        LC_CTYPE="${LC_ALL}"
        unset LC_ALL
fi
export LC_NUMERIC=C

function fatal_error
{
	print -u2 "${progname}: $*"
	exit 1
}

function add_number_to_tree
{
	typeset treename=$1
	integer num=$2
	integer i
	typeset nodepath # full name of compound variable
	integer -a pe # path elements
	integer len
	typeset revnums="$(rev <<<"${num}")"

	# first built an array containing the names of each path element
	# (e.g. "135" results in an array containing "( 1 3 5 )")
	# 10#<number> is used to prevent leading zeros being interpreted
	# as octals
	for (( len=${#revnums} , i=$( printf "10#%s\n" "${revnums}" ) ; len > 0 ; len--, i=i/10 )) ; do
		pe+=( $((i % 10)) )
	done

	# walk path described via the "pe" array and build nodes if
	# there aren't any nodes yet
	nodepath="${treename}"
	for (( i=0 ; i < ${#pe[@]} ; i++ )) ; do
		nameref x="${nodepath}"

		# [[ -v ]] does not work for arrays because [[ -v ar ]]
		# is equal to [[ -v ar[0] ]]. In this case we can
		# use the output of typeset +p x.nodes
		[[ "${ typeset +p x.nodes ;}" == "" ]] && compound -a x.nodes

		nodepath+=".nodes[${pe[i]}]"
	done

	# insert element (leaf)
	nameref node="${nodepath}"
	[[ "${ typeset +p node.elements ;}" == "" ]] && integer -a node.elements
	node.elements+=( ${num} )

	# DEBUG only
	[[ "${!node.elements[*]}" != ""                ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${ typeset +p node.elements ;}" == *-a*    ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${ typeset +p node.elements ;}" == *-i*    ]] || fatal_error "assertion $LINENO FAILED"
	[[ -v node                                     ]] || fatal_error "assertion $LINENO FAILED"
	[[ -R node                                     ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${ typeset +p ${!node} ;}" == *-C*         ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${!x.nodes[*]}" != ""                      ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${ typeset +p x.nodes ;}" == *-a*          ]] || fatal_error "assertion $LINENO FAILED"
	[[ "${ typeset +p x.nodes ;}" == *-C*          ]] || fatal_error "assertion $LINENO FAILED"

	return 0
}


# floating-point version of "seq"
function floatseq
{
	float i
	float arg1=$1
	float arg2=$2
	float arg3=$3

	case $# in
		1)
			for (( i=1. ; i <= arg1 ; i=i+1. )) ; do
				printf "%a\n" i
			done
			;;
		2)
			for (( i=arg1 ; i <= arg2 ; i=i+1. )) ; do
				printf "%a\n" i
			done
			;;
		3)
			for (( i=arg1 ; i <= arg3 ; i+=arg2 )) ; do
				printf "%a\n" i
			done
			;;
		*)
			print -u2 -f "%s: Illegal number of arguments %d\n" "$0" $#
			return 1
			;;
	esac

	return 0
}


function usage
{
	OPTIND=0
	getopts -a "${progname}" "${numtree1_usage}" OPT '-?'
	exit 2
}

# main
builtin basename
builtin rev

set -o noglob
set -o errexit
set -o nounset

compound base

compound bench=(
	float start
	float stop
)

integer i

typeset progname="${ basename "${0}" ; }"

typeset -r numtree1_usage=$'+
[-?\n@(#)\$Id: numtree1 (Roland Mainz) 2010-03-27 \$\n]
[-author?Roland Mainz <roland.mainz@nrubsig.org>]
[+NAME?numtree1 - generate sorted variable tree containing numbers]
[+DESCRIPTION?\bnumtree1\b is a simple variable tree generator
	sorts a given set of numbers into a ksh compound variable tree).
	the application supports two different modes: \'seq\' takes
	1-3 arguments to specify the set of numbers via seq(1) and
	\'stdin\' reads the numbers from stdin (one per line)]

method [ arguments ]

[+SEE ALSO?\bksh93\b(1), \bseq\b(1)]
'

while getopts -a "${progname}" "${numtree1_usage}" OPT ; do
#	printmsg "## OPT=|${OPT}|, OPTARG=|${OPTARG}|"
	case ${OPT} in
		*) usage ;;
	esac
done
shift $((OPTIND-1))

# prechecks
(( $# > 0 )) || usage

cmd=$1
shift

# Read numbers from stdin outside benchmark loop
if [[ ${cmd} == 'stdin' ]] ; then
	stdin_numbers="$( cat /dev/stdin )" || fatal_error "stdin read error"
fi

(( bench.start=SECONDS ))

case ${cmd} in
	"seq")
		for i in ${ floatseq "$@" ; } ; do
			add_number_to_tree base "${i}"
		done
		;;
	"stdin")
		for i in ${stdin_numbers} ; do
			add_number_to_tree base "${i}"
		done
		;;
	"demo1")
		for i in 1 32 33 34 34 38 90 ; do
			add_number_to_tree base "${i}"
		done
		;;
	"demo2")
		for (( i=1000000000 ; i < 1000000000+10 ; i++ )) ; do
			add_number_to_tree base "$i"
		done
		;;
	*)
		fatal_error "Invalid command ${cmd}."
		;;
esac

(( bench.stop=SECONDS ))

print -u2 -f "# time used: %f\n" $((bench.stop - bench.start))

# print tree
print -v base

exit 0
# EOF.