#!/bin/bash
#
# @echo off
#
# The common use data and routines

# Report message
msg()
{
	prog_name=`basename "$0"`
	echo "$prog_name: $1"
}

# Report error message
msgE()
{
	prog_name=`basename "$0"`
	echo "$prog_name[ERROR]: $1"
}

# Exit the program
do_exit()
{
	if [ $1 -eq 0 ]; then
		if [ "$2" != "" ]; then
			msg "$2"
		fi
		exit 0
	else
		msgE "$2"
		exit 1
	fi
}

# Make directory
# arg1 - pathname of directory
make_dir()
{
	if [ ! -d "$1" ]; then
		mkdir "$2"
		if [ $? -ne 0 ]; then
			do_exit 1 "Failed to make $3 directory"
		fi
	fi
}

# Abort the program if arg1 is not a directory
# arg1 - path name of directory
check_dir()
{
	if [ ! -d "$1" ]; then
		do_exit 1 "Not a directory: $1"
	fi
}

# Invalid number of parameters reaction
bad_param_number()
{
	do_exit 1 "Invalid number of parameters for command $1: applied $2, expected $3"
}

# Print out a list of lexems
echo_list()
{
	echo ""
	echo "  $1:"
	echo ""

	for lexem in $2
	do
		echo "       $lexem"
	done
}

# Return separated by ':' sorted last and previous
# elements of directory.
# arg1 - directory
get_two_last_dirs()
{
	local path previous last

	ls "$1" | sort -r |\
	while [ 1 ]
	do
		read filename
		if [ $? -ne 0 ] ; then
			echo ":$last:$previous:"
			break
		fi
		path="$1/$filename"
		if [ -d "$path" ]; then
			if [ -z "$last" ]; then
				last="$filename"
			elif [ -z "$previous" ]; then
				previous="$filename"
			fi
		fi
		if [ -n "$previous" -a -n "$last" ]; then
			echo ":$last:$previous:"
			break
		fi
	done
}

# Return string describing mode of run
# arg1 - bitmap of mode
# arg2 - what to print:
#        0 - part of pathname
#        1 - name of mode
#        2 - BITMODE
#        3 - OPTMODE
get_mode_string()
{
	local x OPTMODE BITMODE

	eval "x=$[ $1 & $FLAGOPT ]"
	if [ $x == 0 ]; then
		OPTMODE="nopt"
	else
		OPTMODE="opt"
	fi

	eval "x=$[ $1 & $FLAG64 ]"
	if [ $x == 0 ]; then
		BITMODE=32
	else
		BITMODE=64
	fi

	if [ $2 == 0 ]; then
		echo "$OPTMODE/$BITMODE"
	elif [ $2 == 1 ]; then
		echo "$BITMODE-bit $OPTMODE mode"
	elif [ $2 == 2 ]; then
		echo "$BITMODE"
	elif [ $2 == 3 ]; then
		echo "$OPTMODE"
	fi
}
export -f get_mode_string

# Return string describing mode of run
# arg1 - bitmap of mode
get_mode_id()
{
	local x OPTMODE BITMODE

	eval "x=$[ $1 & $FLAGOPT ]"
	if [ $x == 0 ]; then
		OPTMODE="n"
	else
		OPTMODE="o"
	fi

	eval "x=$[ $1 & $FLAG64 ]"
	if [ $x == 0 ]; then
		BITMODE=32
	else
		BITMODE=64
	fi

	echo "$BITMODE:$OPTMODE"
}

# check if mode id is valid
check_mode_id() {
	local m

	for m in $ALL_AVAILABLE_TEST_MODES; do
		if [ "x$m" = "x$1" ]; then
			return 0
		fi
	done
	return 1
}

# Echo the name of collection
# arg1 - opcode of collection
get_collection_name()
{
	local dirname

	case $1 in
		$FUNC_COLL_OP) dirname=functional;;
		$CPLX_COLL_OP) dirname=complex;;
		$EXCP_COLL_OP) dirname=exceptions;;
		$BDEMO_COLL_OP) dirname=bdemo;;
		$SERV_COLL_OP) dirname=service;;
		$MT_COLL_OP) dirname=mt;;
		$MS_IDENT_COLL_OP) dirname=Identity2MS;;
		$IMPL_COLL_OP) dirname=IMPL;;

		*) dirname="?"
	esac

	echo "$dirname"
}

# Return non-zero when the string is a name of some test collection
# arg1 - string (to be the name of some test collection)
is_collection_name()
{
	echo $ALL_AVAILABLE_COLLS | grep $1 > /dev/null
	return $?
}

# Return opcode of the test collection which
# contains the test case named as string parameter,
# COLLS_NUM, if no one collection contains such
# test case.
# arg1 - string (to be the name of some test case)
get_collection_opcode()
{
	local rval=0

	if [ -z $1 ]; then
		return $COLLS_NUM
	fi

	echo $FUNC_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $FUNC_COLL_OP
	fi

	echo $CPLX_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $CPLX_COLL_OP
	fi

	echo $EXCP_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $EXCP_COLL_OP
	fi

	echo $BDEMO_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $BDEMO_COLL_OP
	fi

	echo $SERV_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $SERV_COLL_OP
	fi

	echo $MT_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $MT_COLL_OP
	fi

	echo $MS_IDENT_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $MS_IDENT_COLL_OP
	fi

	echo $IMPL_COLL | grep -w $1 > /dev/null
	if [ $? -eq 0 ]; then
		return $IMPL_COLL_OP
	fi

	return $COLLS_NUM
}

# Mark - test collection was involved in processing
# arg1 - name of test case
mark_collection_flag()
{
	local ret

	get_collection_opcode "$1"
	ret=$?

	case $ret in
		$FUNC_COLL_OP)		FUNC_COLL_FLAG=1;;
		$CPLX_COLL_OP)		CPLX_COLL_FLAG=1;;
		$EXCP_COLL_OP)		EXCP_COLL_FLAG=1;;
		$BDEMO_COLL_OP)		BDEMO_COLL_FLAG=1;;
		$SERV_COLL_OP)		SERV_COLL_FLAG=1;;
		$MT_COLL_OP)		MT_COLL_FLAG=1;;
		$MS_IDENT_COLL_OP)	MS_IDENT_COLL_FLAG=1;;
		$IMPL_COLL_OP)		IMPL_COLL_FLAG=1;;
		*) do_exit 1 "Not the name of any test case: $1"
	esac
}

# Get ' ' blank-separated collections involved total
get_collections_total()
{
	local count=0 msg=" "

	if [ $FUNC_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $FUNC_COLL_OP`"
	fi
	if [ $CPLX_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $CPLX_COLL_OP`"
	fi
	if [ $EXCP_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $EXCP_COLL_OP`"
	fi
	if [ $BDEMO_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $BDEMO_COLL_OP`"
	fi
	if [ $SERV_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $SERV_COLL_OP`"
	fi
	if [ $MT_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $MT_COLL_OP`"
	fi
	if [ $MS_IDENT_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $MS_IDENT_COLL_OP`"
	fi
	if [ $IMPL_COLL_FLAG != 0 ]; then
		count=$[ $count + 1 ]
		msg="$msg `get_collection_name $IMPL_COLL_OP`"
	fi
	echo "$count:$msg:"
}

# Return the pathname of the collections root directory
# arg1 - root directory of aslts
get_collections_root_dir()
{
	echo "$1/src/runtime/collections"
}

# Return the pathname of the specified test collection
# arg1 - root directory of aslts
# arg2 - opcode of test collection
get_collection_dir()
{
	local dir

	dir="`get_collections_root_dir "$1"`/`get_collection_name $2`"

	echo "$dir"
}

# Get pathname of test case
# arg1 - root directory of aslts
# arg2 - opcode of test collection
# arg3 - name of test case
get_test_case_dir()
{
	local x path

	word_is_in_line "$OPER_TCASES" "$3" " "


	if [ $? -ne 0 ]; then
		path="`get_collection_dir "$1" $2`/operand/tests/$3"
	else
		x=`echo $RES_TCASES | grep $3`
		if [ $? -eq 0 ]; then
			path="`get_collection_dir "$1" $2`/result/tests/$3"
		else
			if [ $3 == exc_operand1 -o $3 == exc_operand2 ]; then
				path="`get_collection_dir "$1" $2`/exc_operand/$3"
			elif [ $3 == exc_result1 -o $3 == exc_result2 ]; then
				path="`get_collection_dir "$1" $2`/exc_result/$3"
			elif [ $3 == dynobj ]; then
				path="`get_collection_dir "$1" $2`/ACPICA/tests/$3"
			elif [ $3 == bdemo -o $3 == bdemof ]; then
				path="`get_collection_dir "$1" $2`/ACPICA/$3"
			elif [ $3 == extra -o $3 == extra_aslts ]; then
				path="`get_collection_dir "$1" $2`/abbu"
			elif [[ $3 == mt_* ]]; then
				x=`echo $3 | sed 's/mt_//'g`
				path="`get_collection_dir "$1" $2`/$x"
			else
				path="`get_collection_dir "$1" $2`/$3"
			fi
		fi
	fi

	echo "$path"
}

# Return the name of underlying system the tests were run on
#
# arg0 - pathname of Summary file
get_name_of_system()
{
	OLD_IFS=$IFS
	IFS=" "

	cat "$1" |\
	while [ 1 ]
	do
		read mark system line
		if [ $? -ne 0 ] ; then
			echo "?"
			break
		fi

		if [ "$mark" == ASLTS_SYSTEM ]; then
			echo "$system"
			break
		fi
	done

	IFS=$OLD_IFS
}

# Get element of line of file.
#
# Each line of file arg1 consists of elements separated by symbol arg2.
# The first element of line is marker. Routine seeks for the line identified
# by the given marker (arg3) and returns arg4-th element of that line.
#
# arg1 - pathname of file (line of file <marker of line>|el0|el1|...; | - any symbol)
# arg2 - separator
# arg3 - marker of line to fit
# arg4 - element of line to be returned  (now maximum is 4 elements - 0,1,2,3)
get_element_of_line()
{
	OLD_IFS=$IFS
	IFS="$2"

	cat "$1" |\
	while [ 1 ]
	do
		read marker s0 s1 s2 s3 line
		if [ $? -ne 0 ] ; then
			break
		fi
		if [ "$marker" == "$3" ] ; then
			case $4 in
				0) echo "$s0" ;;
				1) echo "$s1" ;;
				2) echo "$s2" ;;
				3) echo "$s3" ;;
				*)  echo "???"
			esac
		fi
	done

	IFS=$OLD_IFS
}

# Split the input file, each char is transformed to one line
split_line_to_chars()
{
	local x index=1

	while [ 1 ]
	do
		x=`echo "$1" | cut -c "$index"`
		if [ "x$x" == x ]; then
			break
		fi
		echo "$x"
		((index=index+1))
	done
}

# Transform input to a line where each char occurs only once,
# blanks are deleted.
#
# Note: works very slowly.
#
transform_to_single_chars()
{
	local x line str

	str="qwertyuiopasdfghjklzxcvbnm0123456789QWERTYUIOPASDFGHJKLZXCVBNM\*"

	while [ 1 ]
	do
		read line
		if [ $? -ne 0 ] ; then
			break
		fi
		x=`echo $line | sed 's/ //'g`
		split_line_to_chars "$x"
	done | sort | paste -s -d " " | sed 's/ //'g | tr -s "$str"
}

# Print out all lines of file arg1 corresponding to the
# chars of string arg2: line == <char>: <rest of line>.
report_lines_per_char()
{
	index=1

	while [ 1 ]
	do
		x=`echo "$2" | cut -c "$index"`
		if [ "x$x" == x ]; then
			break
		fi
		y=`get_element_of_line "$1" ":" "$x" 0`
		if [ "x$y" != x ]; then
			echo "$x -$y"
		elif [ "$x" != " " ]; then
			echo "$x - ???"
		fi
		((index=index+1))
	done
}

# arg1 - line
# arg2 - word
# arg3 - delimiter
word_is_in_line()
{
	local rval=0

	OLD_IFS=$IFS
	IFS="$3"

	echo "$1" | awk '{ for (i=1; i<=NF; i++) { print $i}}' |\
	while [ 1 ]
	do
		read line
		if [ $? -ne 0 ]; then
			return 0
		fi
		if [ "$line" == "$2" ]; then
			return 1
		fi
	done
	rval=$?

	IFS=$OLD_IFS

	return $rval
}

# Convert the centisecond unit time to string {[h:]m:s.c}
# arg1 - centisecond unit time
cent_units_to_cent_str()
{
	local rval
	local TIME_STRING=

	RAWSECONDS=$[ $1 / 100 ]
	RAWCENTISECS=$[ $1 - $RAWSECONDS * 100 ]
	RAWMINUTES=$[ $RAWSECONDS / 60 ]
	RAWSECONDS=$[ $RAWSECONDS - $RAWMINUTES * 60 ]
	RAWHOURS=$[ $RAWMINUTES / 60 ]
	RAWMINUTES=$[ $RAWMINUTES - $RAWHOURS * 60 ]

	if [ $RAWHOURS -le 9 ]; then
	    if [ $RAWHOURS -ne 0 ]; then
		TIME_STRING=0$RAWHOURS:
	    fi
	else
	    TIME_STRING=$RAWHOURS:
	fi

	if [ $RAWMINUTES -le 9 ]; then
	    TIME_STRING=${TIME_STRING}0$RAWMINUTES:
	else
	    TIME_STRING=$TIME_STRING$RAWMINUTES:
	fi

	if [ $RAWSECONDS -le 9 ]; then
	    TIME_STRING=${TIME_STRING}0$RAWSECONDS
	else
	    TIME_STRING=$TIME_STRING$RAWSECONDS
	fi

	if [ $RAWCENTISECS -le 9 ]; then
	    TIME_STRING=${TIME_STRING}.0$RAWCENTISECS
	else
	    TIME_STRING=${TIME_STRING}.$RAWCENTISECS
	fi

	eval "rval=$TIME_STRING"

	echo "$rval"
}
export -f cent_units_to_cent_str

# Convert time to centisecond units
#
#   Layout of time is one of these:
#	1) hours:mins:secs.centisecs
#	2)       mins:secs.centisecs
#
# arg1 - time 1
#
# Return:
#     0 - success
#     otherwise - bad layout
#
convert_string_to_centisecond_units()
{
	local n0=0 h0=0 m0=0 s0=0 csec0=0 sec0=0 total0=0

	n0=`echo "$1" | awk -F: '{ print NF}'`

	if [ "$n0" -eq 2 ]; then
		m0=`echo "$1" | awk -F: '{ print $1}'`
		x=`echo "$1" | awk -F: '{ print $2}'`
		s0=`echo "$x" | awk -F"." '{ print $1}'`
		csec0=`echo "$x" | awk -F"." '{ print $2}'`
		if [ x"$csec0" == x ]; then
			return 1
		fi
	elif [ "$n0" -eq 3 ]; then
		h0=`echo "$1" | awk -F: '{ print $1}'`
		m0=`echo "$1" | awk -F: '{ print $2}'`
		x=`echo "$1" | awk -F: '{ print $3}'`
		s0=`echo "$x" | awk -F"." '{ print $1}'`
		csec0=`echo "$x" | awk -F"." '{ print $2}'`
		if [ x"$csec0" == x ]; then
			return 2
		fi
	else
		return 3
	fi

	sec0=$[ $s0 + $m0 * 60 + $h0 * 3600 ]
	total0=$[ $csec0 + $sec0 * 100 ]

	echo "$total0"

	return 0
}

# Compare two times given by strings
#
#   Layout of time is one of these:
#	1) hours:mins:secs.centisecs
#	2)       mins:secs.centisecs
#
# arg1 - time 1
# arg2 - time 2
#
# Return:
#     0 - T1 == T2
#     1 - T1 < T2
#     2 - T1 > T2
#   3 - bad layout of T1
#   4 - bad layout of T2
#
diff_of_str_times()
{
	local total0=0
	local total1=0
	local rval=0 diff01 diff01str

	total0=`convert_string_to_centisecond_units "$1"`
	if [ $? -ne 0 ]; then
		return 3
	fi

	total1=`convert_string_to_centisecond_units "$2"`
	if [ $? -ne 0 ]; then
		return 4
	fi

	if [ "$total0" -gt "$total1" ]; then
		diff01=$[ $total0 - $total1 ]
		rval=2
	elif [ "$total0" -eq "$total1" ]; then
		diff01=0
		rval=0
	else
		diff01=$[ $total1 - $total0 ]
		rval=1
	fi

	diff01str=`cent_units_to_cent_str $diff01`

	echo "$total0|$total1|$diff01|$diff01str"

	return $rval
}

# ############################## MAIN ###############################

# Initialize the common variables

# Constants

# Bitmap: 1 - 64, 2 - opt
export FLAG64=1
export FLAGOPT=2
NORM32=0
NORM64=1
OPT32=2
OPT64=3

# Opcodes of the test collections (according to aslts)

ASL_COLL_OP=0
FUNC_COLL_OP=1
CPLX_COLL_OP=2
EXCP_COLL_OP=3
BDEMO_COLL_OP=4
SERV_COLL_OP=5
MT_COLL_OP=6
MS_IDENT_COLL_OP=7
IMPL_COLL_OP=8
RUNTIME_COLLS_NUM=8
COLLS_NUM=9