#!/bin/bash

# TODO: check if gcc -pipe leads to problem following the system
# TODO: check for modules.conf location (warn if conf.modules is found)

VERSION="?"


function version()
{
	# display version info then exit

	echo "$VERSION"
	exit 0
}

function commandline_help()
{
	# display help message then exit with $1
	cat << EO_HELP
usage:
  $BASE [switch..]

switches:
  --prefix={PATH}               set runtime base directory (default=$DIST_PREFIX_DEFAULT)
  --etc-prefix={PATH}           system config base directory (default=$DIST_ETC_DEFAULT)
  --conf-prefix={PATH}          set conf base directory (default=$DIST_CONF_PREFIX_DEFAULT)
  --conf-dir={DIR}              set conf directory (default=$DIST_CONF_DIR_DEFAULT)
  --doc-prefix={PATH}           set conf base directory (default=$DIST_PREFIX_DEFAULT)
  --doc-dir={DIR}               set conf directory (default=$DIST_DOC_DIR_DEFAULT)
  --disable-debug               disable debug messages at runtime (default)
  --enable-debug                enable debug messages at runtime
  --disable-warnings            disable most warnings at compilation
  --enable-warnings             enable most warnings at compilation (default)

  --disable-make-check          do not check for make
  --disable-gcc-check           do not check for gcc
  --disable-pppd-check          do not check for pppd
  --disable-wish-check          do not check for wish

  --disable-make-version        do not check for make version
  --disable-gcc-version         do not check for gcc version
  --disable-pppd-version        do not check for pppd version

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

  --enable-make-version         force check make version (default)
  --enable-gcc-version          force check gcc version (default)
  --enable-pppd-version         force check pppd version (default)

  --with-kernel-sources={PATH}  where to find the kernel sources (default=$KERNEL_SOURCES_PATH_DEFAULT)

  --enable-maintainer-mode      use default settings for maintainers (config/make/runtime options)
  --enable-rpm-maintainer-mode  use default settings for rpm maintainers (config/make/runtime options)
  --enable-tgz-maintainer-mode  use default settings for tgz maintainers (config/make/runtime options)

  --quiet                       silent operations
  --clean                       clean temporary files then exit

  -h or --help                  display this help then exit
  -v or --version               display version info then exit
example:
  $BASE --prefix-dir=/opt --etc-prefix=/opt --disable-debug
EO_HELP
	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 POSTFIX
}

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 -n 1 | cut -d " " -f 3) == "version" ]
				then
					MAKE_VERSION=$(echo "$MAKE_VERSION" | head -n 1 | cut -d " " -f 4 | cut -d "," -f 1)
				else
					MAKE_VERSION=$(echo "$MAKE_VERSION" | head -n 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 -n 1)
				if [ -n "$GCC_VERSION" ]
				then
					case "$GCC_VERSION" in
						"egcs-"*)			GCC_VERSION=${GCC_VERSION:5};;
						"gcc (GCC)"*)	GCC_VERSION=$(echo "$GCC_VERSION" | head -n 1 | cut -d " " -f 3);;
						*)				;;
					esac
					display 1 $GCC_VERSION

					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 -n 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"
				fi
			fi
		else
			display 1 "not found"
		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 "DOC_PREFIX = $DIST_DOC_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"
	echo "DOC_DIR = \$(DOC_PREFIX)$DIST_DOC_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
	if [ "$KERNEL_SOURCES_PATH" != "$KERNEL_SOURCES_PATH_DEFAULT" ]
	then
		echo "CFLAGS += -I$KERNEL_SOURCES_PATH/include" >> "$MAKEFILE_CONFIG"
	fi
	display 1 "OK"
	unset MAKEFILE_CONFIG INMAKEFILE_CONFIG

	# global config.h generation
	CFGFILE="config.h"
	INCFGFILE="config.h.sk"
	CFGTMPFILE="$CFGFILE.tmp"
	display 1 -n "generating $CFGFILE... "
	echo "#ifndef CONFIG_H" > "$CFGTMPFILE"
	echo "#define CONFIG_H" >> "$CFGTMPFILE"
	insert_edit_warning "/*" "*/" "$CFGTMPFILE" "$INCFGFILE"
	cat "$INCFGFILE" >> "$CFGTMPFILE"
	if [ $DEBUG -eq 1 ]
	then
		echo "#define DEBUG" >> "$CFGTMPFILE"
	else
		echo "#undef DEBUG" >> "$CFGTMPFILE"
	fi
	echo "#define PRODUCT_ID \"$PRODUCT_ID\"" >> "$CFGTMPFILE"
	echo "#define PRODUCT_NAME \"$PRODUCT_NAME\"" >> "$CFGTMPFILE"
	echo "#define PRODUCT_VERSION \"$PRODUCT_VERSION\"" >> "$CFGTMPFILE"
	echo "#define ETC_PATH \"$DIST_ETC_PREFIX\"" >> "$CFGTMPFILE"
	echo "#define ETC_DIR \"$DIST_ETC_DIR\"" >> "$CFGTMPFILE"
	echo "#define CONF_PATH \"$DIST_CONF_PREFIX\"" >> "$CFGTMPFILE"
	echo "#define CONF_DIR \"$DIST_CONF_DIR\"" >> "$CFGTMPFILE"
	echo "#define DOC_PATH \"$DIST_DOC_PREFIX\"" >> "$CFGTMPFILE"
	echo "#define DOC_DIR \"$DIST_DOC_DIR\"" >> "$CFGTMPFILE"
	echo "#endif" >> "$CFGTMPFILE"
	diff "$CFGTMPFILE" "$CFGFILE" > /dev/null 2>&1
	if [ $? -eq 0 ]
	then
		display 1 "unchanged"
		rm -f "$CFGTMPFILE"
	else
		mv -f "$CFGTMPFILE" "$CFGFILE"
		display 1 "OK"
	fi
	unset CFGFILE INCFGFILE CFGTMPFILE

	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=0
		let WISH_CHECK=0
		DIST_PREFIX="$(pwd)/dist"
		DIST_ETC_PREFIX="$(pwd)/dist"
		DIST_CONF_PREFIX="$(pwd)/dist"
		DIST_DOC_PREFIX="$(pwd)/dist"
	fi
}

function rpm_maintainer_defaults()
{
	# force some default settings for rpm maintainers
	if [ $MAINTAINER -eq 1 ]
	then
		let DEBUG=1
		let WARNINGS=1
		let PPPD_CHECK=0
		let WISH_CHECK=0
	fi
}

function tgz_maintainer_defaults()
{
	# force some default settings for rpm maintainers
	if [ $MAINTAINER -eq 1 ]
	then
		let DEBUG=1
		let WARNINGS=1
		let PPPD_CHECK=0
		let WISH_CHECK=0
		DIST_PREFIX="/tmp/eciadsl-usermode-$VERSION-tgz/usr/local"
		DIST_ETC_PREFIX="/tmp/eciadsl-usermode-$VERSION-tgz"
		DIST_CONF_PREFIX="/tmp/eciadsl-usermode-$VERSION-tgz"
	fi
}

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

# dir and project info
PRODUCT_ID="$(head -n 1 ./ID)"
PRODUCT_NAME="$(tail -n 1 ./ID)"
PRODUCT_VERSION="$(head -n 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=1 PPPD_CHECK_VERSION=1
declare -i WISH_CHECK=1
if [ $UID -ne 0 ]
then
	let PPPD_CHECK=0
else
	if [ $MAINTAINER -ne 1 ]
	then
		display 1 "warning: you're running this script as root"
		display 1 "root is only required to make install and make cfg"
		display 1 ""
	fi
fi
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_DOC_DIR_DEFAULT="/doc/eciadsl"
DIST_PREFIX=""
DIST_ETC_PREFIX=""
DIST_CONF_PREFIX=""
DIST_BIN_DIR=""
DIST_ETC_DIR=""
DIST_CONF_DIR=""
KERNEL_SOURCES_PATH_DEFAULT="/usr/src/linux"
KERNEL_SOURCES_PATH=""

# 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";;
		"--doc-prefix="*)			check_param "$1"
									DIST_DOC_PREFIX="$PARAM";;
		"--doc-dir="*)				check_param "$1"
									DIST_DOC_DIR="$PARAM";;
		"--with-kernel-sources="*)	check_param "$1"
									KERNEL_SOURCES_PATH="$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;;
		"--enable-rpm-maintainer-mode")	let MAINTAINER=1
									rpm_maintainer_defaults;;
		"--enable-tgz-maintainer-mode")	let MAINTAINER=1
									tgz_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_DOC_PREFIX" && DIST_DOC_PREFIX="$DIST_PREFIX"
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"
test -z "$DIST_DOC_DIR" && DIST_DOC_DIR="$DIST_DOC_DIR_DEFAULT"
test -z "$KERNEL_SOURCES_PATH" && KERNEL_SOURCES_PATH="$KERNEL_SOURCES_PATH_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 "driver doc files prefix path = $DIST_DOC_PREFIX "
default_or_user "$DIST_DOC_PREFIX" "$DIST_PREFIX"
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"
display 1 -n "driver doc files directory = $DIST_DOC_DIR "
default_or_user "$DIST_DOC_DIR" "$DIST_DOC_DIR_DEFAULT"
display 1 -n "kernel sources path = $KERNEL_SOURCES_PATH "
default_or_user "$KERNEL_SOURCES_PATH" "$KERNEL_SOURCES_PATH_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_DOC_PREFIX:${#DIST_DOC_PREFIX}-1}" != "/" && DIST_DOC_PREFIX="$DIST_DOC_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}"
test "${DIST_DOC_DIR:0:1}" == "/" && DIST_DOC_DIR="${DIST_DOC_DIR:1}"
test "${KERNEL_SOURCES_PATH:${#KERNEL_SOURCES_PATH}:1}" == "/" && KERNEL_SOURCES_PATH="${KERNEL_SOURCES_PATH: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
