#!/bin/sh

# TODO: check if gcc -pipe leads to problem following the system
# TODO: check for modules.conf location (warn if conf.modules is found)
# TODO: better version string detection (for exotic debian gcc versions for instance)

VERSION="?"


function version()
{
	# display version info then exit

	echo "$VERSION"
	exit 0
}

function commandline_help()
{
	# display help message then exit with $1

	echo "usage:"
	echo "    $BASE [switches]"
	echo "switches:"
	echo "    --prefix={PATH}           set runtime base directory (default=$DIST_PREFIX_DEFAULT)"
	echo "    --etc-prefix={PATH}       system config base directory (default=$DIST_ETC_DEFAULT)"
	echo "    --conf-prefix={PATH}      set conf base directory (default=$DIST_CONF_DEFAULT)"
	echo "    --conf-dir={DIR}          set conf directory (default=$DIST_CONF_DIR_DEFAULT)"
	echo "    --disable-debug           disable debug messages at runtime (default)"
	echo "    --enable-debug            enable debug messages at runtime"
	echo "    --disable-warnings        disable most warnings at compilation"
	echo "    --enable-warnings         enable most warnings at compilation (default)"
	echo "    --quiet                   silent operations"
	echo "    --clean                   clean temporary files then exit"
	echo "    --disable-make-check      do not check for make"
	echo "    --disable-gcc-check       do not check for gcc"
	echo "    --disable-pppd-check      do not check for make (default)"
	echo "    --disable-wish-check      do not check for wish"

	echo "    --disable-make-version    do not check for make version"
	echo "    --disable-gcc-version     do not check for gcc version"
	echo "    --disable-pppd-version    do not check for pppd version (default)"

	echo "    --enable-make-check       force check for make (default)"
	echo "    --enable-gcc-check        force check for gcc (default)"
	echo "    --enable-pppd-check       force check for pppd"
	echo "    --enable-wish-check       force check for wish (default)"

	echo "    --enable-make-version     force check for make version (default)"
	echo "    --enable-gcc-version      force check for gcc version (default)"
	echo "    --enable-pppd-version     force check for pppd version"

	echo "    --enable-maintainer-mode  use default settings for maintainers (config/make/runtime options)"
	echo "    -h or --help              display this help then exit"
	echo "    -v or --version           display version info then exit"
	echo "example:"
	echo "    $BASE --prefix-dir=/opt --etc-prefix=/opt --disable-debug"
	exit $1
}

function display()
{
	# conditional display, according to wished display level
	# anyway, display is stored in log file

	if [ $QUIET -eq 0 -o $1 -eq 2 ]
	then
		shift
		echo "$@" | tee -a "$LOGFILE"
		echo "> $@" >> "$TMPFILE"
	else
		shift
		echo "$@" >> "$LOGFILE"
		echo "> $@" >> "$TMPFILE"
	fi
}

function debug_info()
{
	# stores info message in tmp file to help postmortem diagnosis

	echo "$@" >> "$TMPFILE"
}

function abort()
{
	# abort script

	display 2
	display 2 "the $BASE script has failed, one or more errors have occurred,"
	display 2 "check ${LOGFILE##*/} and ${TMPFILE##*/} for further detail"
	# do not remove $TMPFILE
	exit 1
}

function default_or_user()
{
	# display text according to $1 and $2 [..] comparison
	declare FOUND=0
	COMP="$1"
	shift 1
	while [ -n "$1" ]
	do
		if [ "$COMP" == "$1" ]
		then
			let FOUND=1
		fi
		shift
	done
	if [ $FOUND -eq 1 ]
	then
		display 1 "(default)"
	else
		display 1 "(user)"
	fi
	unset COMP FOUND
}

function check_param()
{
	# check if $1 follows the form foo=bar

	PARAM="${1##*=}"
	if [ -n "$PARAM" ]
	then
		PARAM="${PARAM//\/\//\/}"
	else
		display 2 "missing parameter in switch ${1}"
	fi
	# relative path detected
	if [ "$PARAM" == "." -o "$PARAM" == ".." -o "${PARAM:0:2}" == "./"  -o "${PARAM:0:3}" == "../" ]
	then
		# relative path names are not allowed
		display 2 "relative path name ($PARAM) is not allowed for this switch, you should use an absolute path name"
		abort
	fi
}

function check_version()
{
	# check version numbers, up to 4 levels (major, minor, patchlevel, revision)
	# $1 $2 $3 $4 = major minor patchlevel revision
	# $5 $6 $7 $8 = required_major required_minor required_patchlevel required_revision
	# $9 = version string
	# parts are tested from left to right, if requested_{part} != ""

	test -n "$1" && REQ_MAJOR=$1 || REQ_MAJOR=0
	test -n "$2" && REQ_MINOR=$2 || REQ_MINOR=0
	test -n "$3" && REQ_PATCHLEVEL=$3 || REQ_PATCHLEVEL=0
	test -n "$4" && REQ_REVISION=$4 || REQ_REVISION=0
	test -n "$5" && MAJOR=$5 || MAJOR=0
	test -n "$6" && MINOR=$6 || MINOR=0
	test -n "$7" && PATCHLEVEL=$7 || PATCHLEVEL=0
	test -n "$8" && REVISION=$8 || REVISION=0

	BAD_VERSION="no"
	if [ -n "$1" -a $MAJOR -lt $REQ_MAJOR ]
	then
		BAD_VERSION="yes"
	else
		if [ $MAJOR -eq $REQ_MAJOR -a -n "$2" -a $MINOR -lt $REQ_MINOR ]
		then
			BAD_VERSION="yes"
		else
			if [ $MINOR -eq $REQ_MINOR -a -n "$3" -a $PATCHLEVEL -lt $REQ_PATCHLEVEL ]
			then
				BAD_VERSION="yes"
			else
				if [ $PATCHLEVEL -eq $REQ_PATCHLEVEL -a -n "$4" -a $REVISION -lt $REQ_REVISION ]
				then
					BAD_VERSION="yes"
				fi
			fi
		fi
	fi
	if [ "$BAD_VERSION" == "yes" ]
	then
		display 2 "version doesn't match (>=$9 is required)"
		abort
	fi
	unset BAD_VERSION MAJOR MINOR PATCHLEVEL REVISION REQ_MAJOR REQ_MINOR REQ_PATCHLEVEL REQ_REVISION
}

function insert_edit_warning()
{
	# insert a disclaimer in file $3 regarding to file edition
	# a list of files to edit instead is inserted ($4-)
	# each inserted line is prefixed with $1 (use "#" "" for sh-scripts, "/* "*/" for C,
	# "//"  "" for C++, etc.)

	PREFIX="$1"
	POSTFIX="$2"
	OUTFILE="$3"
	echo -e "$PREFIX the following lines are generated by the $BASE script $POSTFIX" >> "$OUTFILE"
	shift 3
	if [ -n "$1" ]
	then
		echo "$PREFIX DO NOT EDIT THIS FILE BUT THOSE INSTEAD: $POSTFIX" >> "$OUTFILE"
		while [ -n "$1" ]
		do
			if [ -f "$1" ]
			then
				echo "$PREFIX $1 $POSTFIX" >> "$OUTFILE"
			fi
			shift
		done
		echo >> "$OUTFILE"
	fi
	unset OUTFILE PREFIX
}

function check_source()
{
	display 1 -n "checking $1... "
	OPTIONS="$2"
	shift 2
	> "$GENFILE"
	while [ -n "$1" ]
	do
		echo "#include $1" >> "$GENFILE"
		shift
	done
	cat << END_OF_C_FILE >> "$GENFILE"

int main(int argc, char** argv)
{
	return(0);
}

END_OF_C_FILE

	$GCC $OPTIONS -pipe -o /dev/null "$GENFILE" >> "$TMPFILE" 2>&1
	if [ $? -eq 0 ]
	then
		display 1 "OK"
	else
		display 1 "not found"
		return 1
	fi
	return 0
}

function clean_files()
{
	rm -f "$TMPFILE" "$GENFILE" >/dev/null 2>&1
	if [ "$1" == "all" ]
	then
		rm -f "$LOGFILE" >/dev/null 2>&1
	fi
}

function configure_env()
{
	# make
	if [ $MAKE_CHECK -eq 1 ]
	then
		_bin_="make"
		display 1 -n "checking $_bin_ location... "
		MAKE="$(type -p $_bin_)"
		if [ $? -eq 0 ]
		then
			display 1 $MAKE
			debug_info "$_bin_: $MAKE"

			# make version
			if [ $MAKE_CHECK_VERSION -eq 1 ]
			then
				display 1 -n "checking $_bin_ version... "
				MAKE_VERSION="$($MAKE --version 2>&1)"
				debug_info "$_bin_.version: $MAKE_VERSION"
				if [ $(echo "$MAKE_VERSION" | head -1 | cut -d " " -f 3) == "version" ]
				then
					MAKE_VERSION=$(echo "$MAKE_VERSION" | head -1 | cut -d " " -f 4 | cut -d "," -f 1)
				else
					MAKE_VERSION=$(echo "$MAKE_VERSION" | head -1 | cut -d " " -f 3)
				fi
				if [ -n "$MAKE_VERSION" ]
				then
					display 1 $MAKE_VERSION

					MAKE_VERSION_TMP="$MAKE_VERSION"
					MAKE_VERSION=$(echo $MAKE_VERSION | tr "." " ")
					check_version "$MAKE_REQUIRED_MAJOR" "$MAKE_REQUIRED_MINOR" "$MAKE_REQUIRED_PATCHLEVEL" "" \
									"$(echo $MAKE_VERSION | awk '{print $1}')" "$(echo $MAKE_VERSION | awk '{print $2}')" \
									"$(echo $MAKE_VERSION | awk '{print $3}')" "$(echo $MAKE_VERSION | awk '{print $4}')" \
									"$MAKE_REQUIRED_MAJOR.$MAKE_REQUIRED_MINOR.$MAKE_REQUIRED_PATCHLEVEL"
					# restore original version string
					MAKE_VERSION="$MAKE_VERSION_TMP"
					unset MAKE_VERSION_TMP
				else
					display 2 "can't get $_bin_ version"
					abort
				fi
			fi
		else
			display 1 "not found"
			abort
		fi
	fi

	# gcc
	if [ $GCC_CHECK -eq 1 ]
	then
		_bin_="gcc"
		display 1 -n "checking $_bin_ location... "
		GCC="$(type -p $_bin_)"
		if [ $? -eq 0 ]
		then
			display 1 $GCC
			debug_info "$_bin_: $GCC"

			# gcc version
			if [ $GCC_CHECK_VERSION -eq 1 ]
			then
				display 1 -n "checking $_bin_ version... "
				GCC_VERSION="$($GCC --version 2>&1)"
				debug_info "$_bin_.version: $GCC_VERSION"
				GCC_VERSION=$(echo "$GCC_VERSION" | head -1)
				if [ -n "$GCC_VERSION" ]
				then
					display 1 $GCC_VERSION
					
					case "$GCC_VERSION" in
						egcs-*)			GCC_VERSION=${GCC_VERSION:5};;
						"gcc (GCC)"*)	GCC_VERSION=$(echo "$GCC_VERSION" | head -1 | cut -d " " -f 3);;
						*)				;;
					esac

					GCC_VERSION_TMP="$GCC_VERSION"
					GCC_VERSION=$(echo $GCC_VERSION | tr "." " ")
					check_version "$GCC_REQUIRED_MAJOR" "$GCC_REQUIRED_MINOR" "$GCC_REQUIRED_PATCHLEVEL" "" \
									"$(echo $GCC_VERSION | awk '{print $1}')" "$(echo $GCC_VERSION | awk '{print $2}')" \
									"$(echo $GCC_VERSION | awk '{print $3}')" "$(echo $GCC_VERSION | awk '{print $4}')" \
									"$GCC_REQUIRED_MAJOR.$GCC_REQUIRED_MINOR.$GCC_REQUIRED_PATCHLEVEL"
					# restore original version string
					GCC_VERSION="$GCC_VERSION_TMP"
					unset GCC_VERSION_TMP
				else
					display 2 "can't get $_bin_ version"
					abort
				fi
			fi
		else
			display 1 "not found"
			abort
		fi
	fi

	# pppd
	if [ $PPPD_CHECK -eq 1 ]
	then
		_bin_="pppd"
		display 1 -n "checking $_bin_ location... "
		PPPD="$(type -p $_bin_)"
		if [ $? -eq 0 ]
		then
			display 1 $PPPD
			debug_info "$_bin_: $PPPD"

			# pppd version
			if [ $PPPD_CHECK_VERSION -eq 1 ]
			then
				display 1 -n "checking $_bin_ version... "
				PPPD_VERSION="$($PPPD --version 2>&1)"
				debug_info "$_bin_.version: $PPPD_VERSION"
				PPPD_VERSION=$(echo "$PPPD_VERSION" | head -1 | cut -d ' ' -f 3)
				if [ -n "$PPPD_VERSION" ]
				then
					display 1 $PPPD_VERSION
					
					PPPD_VERSION_TMP="$PPPD_VERSION"
					PPPD_VERSION=$(echo $PPPD_VERSION | tr "." " ")
					check_version "$PPPD_REQUIRED_MAJOR" "$PPPD_REQUIRED_MINOR" "$PPPD_REQUIRED_PATCHLEVEL" "" \
									"$(echo $PPPD_VERSION | awk '{print $1}')" "$(echo $PPPD_VERSION | awk '{print $2}')" \
									"" "" \
									"$PPPD_REQUIRED_MAJOR.$PPPD_REQUIRED_MINOR.$PPPD_REQUIRED_PATCHLEVEL"
					# restore original version string
					PPPD_VERSION="$PPPD_VERSION_TMP"
					unset PPPD_VERSION_TMP
				else
					display 2 "can't get $_bin_ version"
					abort
				fi
			fi
		else
			display 1 "not found"
			abort
		fi
	fi

	# wish
	if [ $WISH_CHECK -eq 1 ]
	then
		_bin_="wish"
		display 1 -n "checking $_bin_ location... "
		WISH="$(type -p $_bin_)"
		if [ $? -eq 0 ]
		then
			display 1 $WISH
			debug_info "$_bin_: $WISH"
		else
			display 1 "not found"
		fi
	fi

	# try to guess which system is it
	if [ $PLATFORM_GUESS -eq 1 ]
	then
		display 1 -n "checking platform/OS type $1... "
		$GCC -pipe -o "$GENFILE" platform_guess.c >> "$TMPFILE" 2>&1 
		if [ $? -eq 0 ]
		then
			display 1 "$($GENFILE)"
		else
			display 1 "failed"
		fi
	fi

	unset _bin_	
}

function configure_dot()
{
	display 1 -e "\nentering ./"

	# Makefile generation
	MAKEFILE_CONFIG="Makefile.config"
	INMAKEFILE_CONFIG="Makefile.config.sk"
	display 1 -n "generating $MAKEFILE_CONFIG... "
	> "$MAKEFILE_CONFIG"
	insert_edit_warning "#" "" "$MAKEFILE_CONFIG" "$INMAKEFILE_CONFIG"
	cat "$INMAKEFILE_CONFIG" >> "$MAKEFILE_CONFIG"
	echo "PRODUCT_ID = $PRODUCT_ID" >> "$MAKEFILE_CONFIG"
	echo "PRODUCT_NAME = $PRODUCT_NAME" >> "$MAKEFILE_CONFIG"
	echo "PRODUCT_VERSION = $PRODUCT_VERSION" >> "$MAKEFILE_CONFIG"
	echo "PREFIX = $DIST_PREFIX" >> "$MAKEFILE_CONFIG"
	echo "ETC_PREFIX = $DIST_ETC_PREFIX" >> "$MAKEFILE_CONFIG"
	echo "CONF_PREFIX = $DIST_CONF_PREFIX" >> "$MAKEFILE_CONFIG"
	echo "BIN_DIR = \$(PREFIX)$DIST_BIN_DIR" >> "$MAKEFILE_CONFIG"
	echo "ETC_DIR = \$(ETC_PREFIX)$DIST_ETC_DIR" >> "$MAKEFILE_CONFIG"
	echo "CONF_DIR = \$(CONF_PREFIX)$DIST_CONF_DIR" >> "$MAKEFILE_CONFIG"
	if [ $WARNINGS -eq 1 ]
	then
		echo "CFLAGS += -pedantic -Wall -W" >> "$MAKEFILE_CONFIG"
	fi
	if [ $DEBUG -eq 1 ]
	then
		echo "CFLAGS += -g" >> "$MAKEFILE_CONFIG"
	fi
	display 1 "OK"
	unset MAKEFILE_CONFIG INMAKEFILE_CONFIG

	# global config.h generation
	CFGFILE="config.h"
	INCFGFILE="config.h.sk"
	display 1 -n "generating $CFGFILE... "
	> "$CFGFILE"
	insert_edit_warning "/*" "*/" "$CFGFILE" "$INCFGFILE"
	cat "$INCFGFILE" >> "$CFGFILE"
	if [ $DEBUG -eq 1 ]
	then
		echo "#define DEBUG" >> "$CFGFILE"
	else
		echo "#undef DEBUG" >> "$CFGFILE"
	fi
	echo "#define PRODUCT_ID \"$PRODUCT_ID\"" >> "$CFGFILE"
	echo "#define PRODUCT_NAME \"$PRODUCT_NAME\"" >> "$CFGFILE"
	echo "#define PRODUCT_VERSION \"$PRODUCT_VERSION\"" >> "$CFGFILE"
	echo "#define ETC_PATH \"$DIST_ETC_PREFIX\"" >> "$CFGFILE"
	echo "#define ETC_DIR \"$DIST_ETC_DIR\"" >> "$CFGFILE"
	echo "#define CONF_PATH \"$DIST_CONF_PREFIX\"" >> "$CFGFILE"
	echo "#define CONF_DIR \"$DIST_CONF_DIR\"" >> "$CFGFILE"
	display 1 "OK"
	unset CFGFILE INCFGFILE

	display 1 "leaving ./"
}

function maintainer_defaults()
{
	# force some default settings for maintainers
	if [ $MAINTAINER -eq 1 ]
	then
		let DEBUG=1
		let WARNINGS=1
		let PPPD_CHECK=1
		DIST_PREFIX="$(pwd)/dist"
		DIST_ETC_PREFIX="$(pwd)/dist"
		DIST_CONF_PREFIX="$(pwd)/dist"
	fi
}

# internal variables
BASE="$(pwd)/${0##*/}"
LOGFILE="$BASE.log"
TMPFILE="$BASE.tmp"
GENFILE="$BASE.c"
BASE="${0##*/}"

# dir and project info
PRODUCT_ID="$(head -1 ./ID)"
PRODUCT_NAME="$(tail -1 ./ID)"
PRODUCT_VERSION="$(head -1 ./VERSION)"
test -n "$PRODUCT_VERSION" && VERSION="$PRODUCT_VERSION"
SRC_DIR=""

# requested values for tools
MAKE_REQUIRED_MAJOR=3
MAKE_REQUIRED_MINOR=70
GCC_REQUIRED_MAJOR=2
GCC_REQUIRED_MINOR=91
GCC_REQUIRED_PATCHLEVEL=66
PPPD_REQUIRED_MAJOR=2
PPPD_REQUIRED_MINOR=4

# internal global variables
declare -i RET=0 

# some defaults values for configuration variables (settings)
# paths/dirs must be complete its left part, but please omit the trailing /
declare -i QUIET=0 DEBUG=0 WARNINGS=1 MAINTAINER=0
declare -i PLATFORM_GUESS=1
declare -i MAKE_CHECK=1 MAKE_CHECK_VERSION=1
declare -i GCC_CHECK=1 GCC_CHECK_VERSION=1
declare -i PPPD_CHECK=0 PPPD_CHECK_VERSION=0
declare -i WISH_CHECK=1
DIST_PREFIX_DEFAULT="/usr/local"
DIST_ETC_PREFIX_DEFAULT="/"
DIST_CONF_PREFIX_DEFAULT="/"
DIST_BIN_DIR_DEFAULT="/bin"
DIST_ETC_DIR_DEFAULT="/etc"
DIST_CONF_DIR_DEFAULT="/etc/eciadsl"
DIST_PREFIX=""
DIST_ETC_PREFIX=""
DIST_CONF_PREFIX=""
DIST_BIN_DIR=""
DIST_ETC_DIR=""
DIST_CONF_DIR=""

# commandline analyze
while [ -n "$1" ]
do
	case "$1" in
		"--prefix="*)				check_param "$1"
									DIST_PREFIX="$PARAM";;
		"--etc-prefix="*)			check_param "$1"
									DIST_ETC_PREFIX="$PARAM";;
		"--conf-prefix="*)			check_param "$1"
									DIST_CONF_PREFIX="$PARAM";;
		"--conf-dir="*)				check_param "$1"
									DIST_CONF_DIR="$PARAM";;
		"--disable-make-check")		let MAKE_CHECK=0;;
		"--disable-gcc-check")		let GCC_CHECK=0;;
		"--disable-pppd-check")		let PPPD_CHECK=0;;
		"--disable-wish-check")		let WISH_CHECK=0;;

		"--disable-make-version")	let MAKE_CHECK_VERSION=0;;
		"--disable-gcc-version")	let GCC_CHECK_VERSION=0;;
		"--disable-pppd-version")	let PPPD_CHECK_VERSION=0;;

		"--enable-make-check")	 	let MAKE_CHECK=1;;
		"--enable-gcc-check") 	 	let GCC_CHECK=1;;
		"--enable-pppd-check")	 	let PPPD_CHECK=1;;
		"--enable-wish-check")	 	let WISH_CHECK=1;;

		"--enable-make-version")	let MAKE_CHECK_VERSION=1;;
		"--enable-gcc-version")	 	let GCC_CHECK_VERSION=1;;
		"--enable-pppd-version")	let PPPD_CHECK_VERSION=1;;

		"--disable-warnings")		let WARNINGS=0;;
		"--enable-warnings")		let WARNINGS=1;;
		"--disable-debug")			let DEBUG=0;;
		"--enable-debug")			let DEBUG=1;;
		"--enable-maintainer-mode")	let MAINTAINER=1
									maintainer_defaults;;
		"--quiet")					let QUIET=1;;
		"--clean")					clean_files "all"
									exit 0;;
		"-h"|"--help")				commandline_help 0;;
		"-v"|"--version")			version;;
		*)							echo "unknown switch $1"
									commandline_help 1;;
	esac
	shift
done

# temp/log files init
> "$LOGFILE"
> "$TMPFILE"
> "$GENFILE"

# apply defaults if no user-defined settings
test -z "$DIST_PREFIX" && DIST_PREFIX="$DIST_PREFIX_DEFAULT"
test -z "$DIST_ETC_PREFIX" && DIST_ETC_PREFIX="$DIST_ETC_PREFIX_DEFAULT"
test -z "$DIST_CONF_PREFIX" && DIST_CONF_PREFIX="$DIST_CONF_PREFIX_DEFAULT"
test -z "$DIST_BIN_DIR" && DIST_BIN_DIR="$DIST_BIN_DIR_DEFAULT"
test -z "$DIST_ETC_DIR" && DIST_ETC_DIR="$DIST_ETC_DIR_DEFAULT"
test -z "$DIST_CONF_DIR" && DIST_CONF_DIR="$DIST_CONF_DIR_DEFAULT"

# display a summary of the settings
display 1 "settings:"
display 1 -n "runtime prefix path = $DIST_PREFIX "
default_or_user "$DIST_PREFIX" "$DIST_PREFIX_DEFAULT"
display 1 -n "system conf files prefix path = $DIST_ETC_PREFIX "
default_or_user "$DIST_ETC_PREFIX" "$DIST_ETC_PREFIX_DEFAULT"
display 1 -n "driver conf files prefix path = $DIST_CONF_PREFIX "
default_or_user "$DIST_CONF_PREFIX" "$DIST_CONF_PREFIX_DEFAULT"
display 1 -n "binaries directory = $DIST_BIN_DIR "
default_or_user "$DIST_BIN_DIR" "$DIST_BIN_DIR_DEFAULT"
display 1 -n "system conf files directory = $DIST_ETC_DIR "
default_or_user "$DIST_ETC_DIR" "$DIST_ETC_DIR_DEFAULT"
display 1 -n "driver conf files directory = $DIST_CONF_DIR "
default_or_user "$DIST_CONF_DIR" "$DIST_CONF_DIR_DEFAULT"

# fixes trailing and leading /
test "${DIST_PREFIX:${#DIST_PREFIX}-1}" != "/" && DIST_PREFIX="$DIST_PREFIX/"
test "${DIST_ETC_PREFIX:${#DIST_ETC_PREFIX}-1}" != "/" && DIST_ETC_PREFIX="$DIST_ETC_PREFIX/"
test "${DIST_CONF_PREFIX:${#DIST_CONF_PREFIX}-1}" != "/" && DIST_CONF_PREFIX="$DIST_CONF_PREFIX/"
test "${DIST_BIN_DIR:0:1}" == "/" && DIST_BIN_DIR="${DIST_BIN_DIR:1}"
test "${DIST_ETC_DIR:0:1}" == "/" && DIST_ETC_DIR="${DIST_ETC_DIR:1}"
test "${DIST_CONF_DIR:0:1}" == "/" && DIST_CONF_DIR="${DIST_CONF_DIR:1}"

# start configuring!
display 1 -e "\nstarting configuration for $PRODUCT_ID-$PRODUCT_VERSION in $(pwd)..\n"
configure_env
configure_dot

# end of process
if [ $RET -ne 0 ]
then
	abort
else
	display 1 ""
	display 1 "$BASE script has completed successfully"
	clean_files
fi
exit 0
