#!/bin/sh
#
# ACR: Auto Conf Replacement
#
# @license:  GPLv2
# @author:   pancake <pancake@phreaker.net>
# @homepage: http://www.nopcode.org/?t=acr
# @version:  @VERSION@
#
# acr-sh:
#   acr configure script generator.
#
#== How to find things in this large file ==
#
# Just search for the required string:
#
# ##INIT##     : All variable initilializations
# ##KEYWORDS## : switch/case with all keywords supported in configure.acr
# ##FI##       : Large enumeration of fi's :)
# ##FUNCS##    : helpkit functions
# ##LANGS##    : LANG_XXX keywords
# ##ENV_LANG## : env_XXX for languages
#

ACR_VERSION=@VERSION@

if [ -z "$1" ]; then
	if [ -f "configure.acr" ]; then
		ACRFILE=configure.acr
	else
		echo "No 'configure.acr' found in current directory." > /dev/stderr
		echo "Give me the file name as argument." > /dev/stderr
		exit 1
	fi
else
	ACRFILE="$1"
fi

##AWK##
AWK=awk
AWK_STRING="`awk -W version 2>&1`"
if [ `expr "$AWK_STRING" : "mawk"` -gt 0 ]; then
	AWK="awk -W interactive"
fi

##INIT##
SET_VAR=""
STR2=""
ENDSCRIPT=""
LANG=0 # no langs yet defined
LANG_C=""
LANG_C_REQUIRED=""
LANG_C_ENV=""
LANG_CPP_ENV=""
LANC_CXX=""
LANG_CXX_REQUIRED=""
LANG_CXX_ENV=""
LANG_TCL=""
LANG_TCL_REQUIRED=""
LANG_TCL_ENV=""
LANG_PERL=""
LANG_PERL_REQUIRED=0
LANG_PERL_ENV=""
LANG_JAVA=""
LANG_JAVA_REQUIRED=0
LANG_JAVA_ENV=""
LANG_PYTHON=""
LANG_PYTHON_REQUIRED=""
LANG_PYTHON_ENV=""
LANG_RUBY=""
LANG_RUBY_REQUIRED=""
LANG_RUBY_ENV=""
REPORT_REQUIRED=""
REPORT_OPTIONAL=""
REPORT_FLAGS=""
REPORT_LANGS=""
REPORT_TOOLS=""
# ALL INTERNAL FLAGS #
IS_FIRST_KEYWORD=1
SEDFLAGS=""
HAVE_LIBS=0
LIBSCRIPT=""
REPORT=""
SPACE=""
CHKVERSTR=""
#- pkgconfig -#
_USE_PTHREAD=0
_USE_PERL_THREADS=0
LANG_PERL_THREADS_REQUIRED=0
_PKGCONFIG=0
PKGCFG_STR=""
_PC_CFLAGS=""
_PC_LDFLAGS=""
#-- ? --#
_USE_BACKUP=0
_EXPORT=0
_EXPORT_DEFINED=0
_REQUIRE_ACR_VERSION=0
VPATH_VAR="VPATH"
NKEYS=0
_EXEC=0
_EXEC_VAR=""
_NOT=0
_USE_DL=0
_USE_DL_USED=0
_USE_ICONV=0
_CHKVER=0
_SIZEOF=0
_SIZEOF_STR=""
_DIE=0
_DIE_VAR=""
_DIE_BOOL=0
_IF=0
_IF_VAR=""
_IF_VAR2=""
_IF_OP=""
_IF_BOOL=0
_IF_SETVAR=""
_IF_VALUE=""
_IF_SETVALUE=""
_IF_VALUE_EOF="0"
_IFAND=0
_IFEQ=0
_IFEQVAL=0
IFSCRIPT=""
_REPORT=0
_CHK_CP=0
_CHK_PM=0
_CHK_PY=0
_CHK_RU=0
_CHK_PM_NAME=""
_CHKLIB=0
_CHKLIB_REQUIRED=0
_CHKLIB_NAME=""
_CHKFUNC=0
_CHKFUNC_NAME=""
_CHKFUNC_LIB=""
S="$" # hacky stuff
C="\`"
HAVE_PROGS=0
PRGSCRIPT=""
_CHKPRG=0
_CHKPRG=REQUIRED=0
_CHKPRG_VAR=""
_CHKPRG_NAME=""
_CHKINC=0
_CHKINC_REQUIRED=0
OUTPUT_H=0
OUTPUT_SH=0
CHECK=0
CHECK_VAR=""
CHECK_EOF=""
CHECK_STR=""
CHECKSCRIPT=""
H_FILES=""
SH_FILES=""
ARGUMENT=""    # ARGUMENTS #
ARG_VALUE=""
ARG_NAME=""
ARG_FLAG=""
ARG_DESC=""
FLAGHELP=""
FLAGSCRIPT=""
ENVWORDS="MANDIR INFODIR LIBDIR INCLUDEDIR LOCALSTATEDIR SYSCONFDIR DATADIR"
ENVWORDS="${ENVWORDS} LIBEXECDIR SBINDIR BINDIR EPREFIX PREFIX SPREFIX"
ENVWORDS="${ENVWORDS} TARGET HOST BUILD INSTALL INSTALL_LIB INSTALL_MAN"
ENVWORDS="${ENVWORDS} INSTALL_PROGRAM INSTALL_DIR INSTALL_SCRIPT INSTALL_DATA"
ENVHELP=""
LOCAL_CONTEXT=0
_EQUAL_3=0
EQUAL=""
EQUALSCR=""
_PKGNAME=""
PKGNAME="this package"
_CONTACT=0
CONTACT_MAIL=""
CONTACT_NAME=""
PACKAGE_BUGREPORT=""
_VERSION=""
VERSION=""
SUBST_FILES=0
S_FILES=""     # subst files
S_MKDIR=""     # subst directories to be created
SD_FILES=""
_LANG_CPP=0
INIVARS=""
SUBDIRS=0
SUBCONF=0
SUBCONF_DIRS=""

get_word_number() {
	printf "%04d" $WORDS_N
}

##FUNCS##
add_lang_envwords() {
	for A in `eval echo ${S}LANG_$1_ENV`; do
		add_envword ${A}
	done
}

add_envword() {
	word=`get_word_number`

	for A in ${ENVWORDS}; do
	if [ "${A}" = "$1" ]; then
		if [ "${EQUAL}" = "1" ]; then # IFOP='='
			word=`get_word_number`
			echo "$word < Warning: duplicated export variable '$1'." > /dev/stderr
		fi
		return;
	fi
	done

	if [ "${DEBUG}" = "1" ]; then
		echo "$word > env $1" > /dev/stderr
	fi

	ENVWORDS="${ENVWORDS} $1"
}

print_header() {
	echo "#!/bin/sh"
	echo "# This script was automatically generated by ACR v${ACR_VERSION}"
	echo "# @author: pancake <pancake@phreaker.net>"
	echo "# @url: http://www.nopcode.org/?t=acr"
	echo "#"
	echo ""
	echo "do_remove() {"
	echo "  rm -f ${S}{ACR_RMFILES}"
	echo "}"
	echo "control_c() {"
	echo "  printf \"\\n\\n^C control-c : script execution interrupted.\\n\""
	echo "  do_remove"
	echo "  exit 1"
	echo "}"
	echo "trap control_c 2"
}

concat() 
{
	OLD="$1"
	NEW="$2"

	if [ "${NEW}" = "\;" ]; then
		NEW=";"
	fi

	if [ -z "${OLD}" ]; then
		printf -- "${NEW}"
	else
		printf -- "${OLD} ${NEW}"
	fi
}

check_ifop() {
	IFOP=$1
	case ${IFOP} in
	"="|"+="|"?="|"<-")
		;;
	*)
		echo "$word | Invalid operator '${IFOP}' in conditional." > /dev/stderr
		exit 1
		;;
	esac
}

check_ru() {
	HAVE_LIBS=1
	VAR=`echo "HAVE_RU_$1" | \
		sed -e 's, ,,g' | \
		sed -e 's,/,_,g' | \
		awk '{ print toupper($0); }'`
	add_envword "${VAR}"
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
printf "checking for ${1} ruby extension... "
\\\`echo "require '$1'" | ${S}{RUBY} 2> /dev/null\\\`
if [ "${S}?" = "0" ]; then
	${VAR}=1
	echo ok
else
	${VAR}=0
	echo no
EOF
`
if [ "${_CHK_RU_REQUIRED}" = "1" ]; then
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
echo 'This ruby extension is required.'
exit 1
EOF
`
fi
LIBSCRIPT="${LIBSCRIPT}
fi"
}

check_endian() {
	add_envword "LIL_ENDIAN"
	add_envword "BIG_ENDIAN"
	add_envword "BYTEORDER"
	CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
printf "checking host endianness... "
echo "main(){int a=1;char *b=(char*)&a;printf(\"%d\\n\",b[0]);}" > test.c
${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} -o a.out test.c >/dev/null 2>&1
if [ ! "${S}?" = 0 ]; then
	echo "unexpected error"
	exit 1
fi
LIL_ENDIAN=${S}(./a.out)
if [ "${S}{LIL_ENDIAN}" = 1 ]; then
	BYTEORDER=1234
	BIG_ENDIAN=0
	echo little
else
	BYTEORDER=4321
	BIG_ENDIAN=1
	echo big
fi
EOF
`
}

check_py() {
	HAVE_LIBS=1
	VAR=`echo "HAVE_PY_$1" | \
		sed -e 's, ,,g' | \
		awk '{ print toupper($0); }'`
	add_envword "${VAR}"
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
printf "checking for ${1} python module... "
\\\`echo import ${1} | ${S}{PYTHON} - 2>&1 >/dev/null\\\` 2>/dev/null
if [ "${S}?" = "0" ]; then
	${VAR}=1
	echo ok
else
	${VAR}=0
	echo no
EOF
`
if [ "${_CHK_PY_REQUIRED}" = "1" ]; then
	LIBSCRIPT=`cat <<EOF
echo "This python module is required."
exit 1
EOF
`
fi
LIBSCRIPT="${LIBSCRIPT}
fi"
}

check_pm() {
	HAVE_LIBS=1
	VAR=`echo "HAVE_PM_$1" | \
		sed -e 's, ,,g;s,:,,g' | \
		awk '{ print toupper($0); }'`
	add_envword "${VAR}"
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
printf "checking for '${1}' perl module ... "
perl -m${1} -e '' 2>/dev/null
if [ "${S}?" = "0" ]; then
	${VAR}=1
	echo "ok"
else
	${VAR}=0
	echo "no"
EOF
`
if [ "${_CHK_PM_REQUIRED}" = "1" ]; then
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
echo 'This perl module is required.'
exit 1
EOF
`
fi
LIBSCRIPT="${LIBSCRIPT}
fi"
}

check_lib() {
	HAVE_LIBS=1
	_CHKLIB_LIBS="`echo $1 | awk -F + '{ for(i=1;i<=NF;i++) { str=str "-l" $i " " } print str; }'`"
	VAR=`echo "HAVE_LIB_$1" | sed -e 's,+,_AND_,g' | awk '{ print toupper($0); }'`
	add_envword "${VAR}"
	_CHKLIB_NAME=$1
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
 printf "checking for lib${_CHKLIB_NAME} ... "
 echo "main(){ }" > test.c
 ${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} ${_CHKLIB_LIBS} test.c >/dev/null 2>&1
 if [ "${S}?" = 0 ]; then
	${VAR}=1
	echo yes
 else
	${VAR}=0
	echo no
EOF
`
	if [ "${_CHKLIB_REQUIRED}" = "1" ]; then
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
  echo "this library is required."
  exit 1
EOF
`
	REPORT_REQUIRED="${REPORT_REQUIRED} lib${_CHKLIB_NAME}"
	else
	REPORT_OPTIONAL="${REPORT_OPTIONAL} lib${_CHKLIB_NAME}"
	fi
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
 fi

EOF
`
}

check_func() {
	HAVE_LIBS=1
	VAR=`echo "HAVE_$1" | awk '{ print toupper($0); }'`
	add_envword "${VAR}"
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
 printf "checking function ${_CHKFUNC_NAME}() in ${_CHKFUNC_LIB}... "
 echo "main(){ ${_CHKFUNC_NAME}(0); }" > test.c
 ${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} -l${_CHKFUNC_LIB} test.c >/dev/null 2>&1
 if [ "${S}?" = "0" ]; then
	echo yes ;
	${VAR}=1
 else
	${VAR}=0
	echo no
EOF
`
	if [ "${_CHKLIB_REQUIRED}" = "1" ]; then
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
  echo "this function is required." > /dev/stderr
  exit 1
EOF
`
	fi
	LIBSCRIPT=`cat <<EOF
${LIBSCRIPT}
 fi

EOF
`
}

check_sizeof() {
	THAT=$1
	VAR=`echo "SIZEOF_$1" | awk '{ gsub("\*","_PTR"); gsub(" ",""); gsub("\\\.","_"); gsub("/","_"); print toupper($0); }'`
	add_envword "${VAR}"
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
printf "checking size of $1... "
echo "main(){printf(\"%d\",sizeof($1));}" >test.c
${S}{CC} ${S}{CFLAGS} -o a.out test.c >/dev/null 2>&1
if [ "${S}?" = "0" ]; then 
	${VAR}=${S}(./a.out) ## XXX this could be not portable
	echo ${S}{${VAR}}
else
	${VAR}=0
	echo error
fi
EOF
`
}

check_inc() {
	INC=$1
	VAR=`echo "HAVE_$1" | awk '{ gsub("\\\.","_"); gsub("/","_"); print toupper($0); }'`
	add_envword "${VAR}"
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
printf "checking for $1... "
echo "#include <${INC}>" >test.c
echo "main(){}" >>test.c
${S}{CC} ${S}{CFLAGS} test.c >/dev/null 2>&1
if [ "${S}?" = "0" ]; then 
	${VAR}=1
	echo yes
else
	${VAR}=0
	echo no
EOF
`
	if [ "${_CHKINC_REQUIRED}" = "1" ]; then
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
echo "required include not found." > /dev/stderr
exit 1
EOF
`
	fi
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
fi

EOF
`
}

check_prg() {
	HAVE_PROGS=1
	add_envword ${_CHKPRG_VAR}
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
printf "checking for ${_CHKPRG_NAME}... "
FIND=${C}command -v ${_CHKPRG_NAME} 2>/dev/null ${C}
if [ -n "${S}{FIND}" ]; then 
 echo ${S}{FIND}; 
 ${_CHKPRG_VAR}=${S}{FIND}
else
 ${_CHKPRG_VAR}=${_CHKPRG_NAME}
 echo no
EOF
`
	if [ "${_CHKPRG_REQUIRED}" = "1" ]; then
	word=`get_word_number`
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
  echo "$word this program is required." > /dev/stderr
  exit 1
EOF
`
	fi
	PRGSCRIPT=`cat <<EOF
${PRGSCRIPT}
fi

EOF
`
}

## JAVA ##
lang_java() {
	echo "printf \"checking for javac... \""
	echo "HAVA_LANG_JAVA=1"
	echo "echo \"class test{public static void main(){}}\" > test.java"
	echo "if [ \"${S}{JAVAC}\" = \"javac\" ]; then if [ -n \"${S}{JAVA_HOME}\" ]; then"
	echo "JAVAC=${S}{JAVA_HOME}/bin/javac"
	echo "fi;fi"
	echo "${S}{JAVAC} test.java 2>&1 >/dev/null"
	echo "if [ \$? = 0 ]; then echo ${S}{JAVAC}; else"
	echo "echo no ; HAVE_LANG_JAVA=0"
	if [ "${LANG_JAVA_REQUIRED}" = "1" ]; then
	echo "echo \"ERROR: ${S}{JAVAC} cannot create bytecode\"; exit 1"
	fi
	echo "fi"
	echo ""
}
env_java() {
	if [ -n "${LANG_JAVA_ENV}" ]; then return ; fi
	LANG_JAVA_ENV="JAVA JAVAC HAVE_LANG_JAVA JAVA_HOME"
	LANG=1
	LANG_JAVA=1
	ACR_RMFILES="${ACR_RMFILES} test.java test.class"
	add_lang_envwords "JAVA"
	REPORT_LANGS="${REPORT_LANGS} java"
	ENVHELP=`cat <<EOF
${ENVHELP}
  JAVAC       Java compiler to be used.
  JAVA_HOME   Path to the Java SDK prefix.
EOF
`
	add_flag with JAVAC javac "="   "Manually assign the javac program"
	add_flag with JAVAC jikes jikes "Use jikes instead of javac"
	add_flag with JAVAC kjc   kjc   "Use the kaffe compiler"
}

lang_bash() {
	LANG=1
	REPORT_LANGS="${REPORT_LANGS} bash"
	echo "printf \"checking for bash... \""
	echo "type bash 2>&1 >/dev/null" 
	echo "if [ \$? = 0 ]; then echo yes ; "
	echo "SH=\`command -v bash\`"
	echo "else echo no ; fi"
	echo ""
	add_envword "SH"
	ENVHELP=`cat <<EOF
${ENVHELP}
  SH          Environment for bash command
EOF
`
}

##ENV_LANG##
env_ruby() {
	LANG_RUBY=1
	if [ -n "${LANG_RUBY_ENV}" ]; then return ; fi
	LANG_RUBY_ENV="RUBY RUBY_VERSION"
	ENVHELP=`cat <<EOF
${ENVHELP}
  RUBY        Ruby interpreter path or binary name.
EOF
`
	REPORT_LANGS="${REPORT_LANGS} ruby"
}
lang_ruby() {
	echo "printf \"checking for ruby... \""
	echo "HAVE_LANG_RUBY=0"
	echo "for A in \`echo ${S}{PATH} | sed -e 's,:, ,g'\`; do"
	echo "RUBY=\`ls ${S}{A}/ruby* 2>/dev/null\`"
	echo " if [ -n \"${S}{RUBY}\" ]; then "
	echo "   RUBY=\`echo ${S}{RUBY} | awk '{print ${S}1; }'\`"
	echo "   RUBY_VERSION=\`echo ${S}{RUBY} ${S}{A} | awk '{ print substr(${S}1,length(${S}2)+6) }'\`"
	echo "   echo ${S}{RUBY} ; HAVE_LANG_RUBY=1 ; break"
	echo " fi"
	echo "done"
	echo "if [ -z \"${S}{RUBY}\" ]; then"
	echo "echo no"
	if [ -n "${LANG_RUBY_REQUIRED}" ]; then
	echo 'echo "ERROR: No ruby binaries found in PATH" > /dev/stderr'
	echo "exit 1"
	fi
	echo "fi"
}

env_cpp() {
	if [ -n "${LANG_CPP_ENV}" ]; then return ; fi
	LANG_CPP_ENV="CPPFLAGS CPP"
	ENVHELP=`cat <<EOF
${ENVHELP}
  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
              headers in a nonstandard directory <include dir>
  CPP         C preprocessor
EOF
`
}

env_python() {
	if [ -n "${LANG_PYTHON_ENV}" ]; then return ; fi
	LANG_PYTHON_ENV="PYTHON HAVE_LANG_PYTHON"
	LANG=1
	LANG_PYTHON=1
	add_lang_envwords "PYTHON"
	REPORT_LANGS="${REPORT_LANGS} python"
}

lang_python() {
	echo "printf \"checking for python... \""
	echo "HAVE_LANG_PYTHON=0"
	echo "for A in \`echo ${S}{PATH} | sed -e 's,:, ,g'\` ; do"
	echo "PYTHON=\`ls ${S}{A}/python* 2>/dev/null\`"
	echo "if [ -n \"${S}{PYTHON}\" ]; then"
	echo " PYTHON=\`echo ${S}{PYTHON} | awk '{print ${S}1; }'\`"
	echo " echo ${S}{PYTHON} ; HAVE_LANG_PYTHON=1 ; break ; fi"
	echo "done"
	echo "if [ -z \"${S}{PYTHON}\" ]; then"
	echo "echo no"
	if [ -n "${LANG_PYTHON_REQUIRED}" ]; then
	echo 'echo "ERROR: No python binaries found in PATH" > /dev/stderr'
	echo "exit 1"
	fi
	echo "fi"
}

lang_cpp() {
	LANG=1
	if [ -n "${LANG_CPP_ENV}" ]; then return ; fi
	add_envword "CPP"
	_LANG_CPP=1
	echo "printf \"checking for cpp... \""
	echo "if [ \"${S}{CROSSBUILD}\" = 1 ]; then"
	echo "(exec ${S}{HOST}-${S}{CPP} --help >/dev/null 2>&1)"
	echo "if [ "${S}?" = "0" ]; then CPP=\"${S}{HOST}-${S}{CPP}\"; fi"
	echo "fi"
	echo "(echo \"main(){}\" | ${S}{CPP} ${CPPFLAGS} >/dev/null 2>&1)"
	echo "if [ \$? = 0 ]; then echo ${S}{CPP}; else"
	echo "echo \"ERROR: ${S}{CPP} cannot parse sources\"; fi"
	echo ""
}

env_tcl() {
	LANG=1
	LANG_TCL=1
	add_envword "TCL_VERSION"
	add_envword "HAVE_LANG_TCL"
	add_envword "TCL_LIBS"
	add_envword "TCL_CFLAGS"
	add_envword "TCL_LDFLAGS"
	REPORT_LANGS="${REPORT_LANGS} tcl"
	add_flag with TCL_BASEDIR tcl-basedir "=" "Sets the TCL basedir to find [/usr]/lib/tclConfig.sh"
}

lang_tcl() {
	LANG=1
	echo "printf \"checking for tcl... \""
	echo "HAVE_LANG_TCL=0"
	echo "for A in ${S}{TCL_LIBDIR} ${S}{SEARCHPATH}; do"
	echo "if [ -f \"${S}{A}/lib/tclConfig.sh\" ]; then"
	echo ". ${S}{A}/lib/tclConfig.sh"
	echo "  HAVE_TCL=1"
	echo "  TCL_CFLAGS=\"${S}{TCL_INCLUDE_SPEC}\""
	echo "  TCL_LDFLAGS=\"${S}{TCL_LIB_SPEC}\""
	echo "  echo \"${S}{TCL_VERSION}\""
	echo "  break;"
	echo "fi"
	echo "done"
	echo "if [ \"${S}{HAVE_LANG_TCL}\" = \"0\" ]; then echo no; "
	if [ "${LANG_TCL_REQUIRED}" = "1" ]; then
	echo "echo \"ERROR: You need TCL.\" ; exit 1"
	fi
	echo "fi"
}

use_pthread() {
	HAVE_LIBS=1
	add_envword "PTHREAD_LIBS"
	add_envword "HAVE_PTHREAD"
	LIBSCRIPT="${LIBSCRIPT}
printf \"checking for POSIX threads... \"
if [ \"${S}{HOST_OS}\" = \"freebsd\" ]; then
PTHREAD_LIBS=-pthread ; else
PTHREAD_LIBS=-lpthread ; fi
echo '#include <pthread.h>' > test.c
echo 'main(){pthread_testcancel();}' >> test.c
(exec ${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} ${S}{PTHREAD_LIBS} test.c 2>&1 >/dev/null)
if [ "\$?" = "1" ]; then
HAVE_PTHREAD=0 ; echo no ; else HAVE_PTHREAD=1; echo yes ; fi
"
	if [ "${_USE_PTHREAD}" = "2" ]; then
	REPORT_REQUIRED="${REPORT_REQUIRD} libpthread"
	LIBSCRIPT="${LIBSCRIPT}
if [ \"${S}{HAVE_PTHREAD}\" = \"0\" ]; then
	echo 'ERROR: You need the pthreads libraries.'
	exit 1
fi"
	else
	REPORT_OPTIONAL="${REPORT_OPTIONAL} libpthread"
	fi
}

use_jni() {
	add_envword "JAVA_HOME"
	add_envword "JCFLAGS"
	REPORT_REQUIRED="${REPORT_REQUIRED} JNI"
	CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
printf "checking for java native interface (jni)... "
if [ -z "${S}{JAVA_HOME}" ]; then
	echo no
	echo "ERROR: JAVA_HOME not defined." > /dev/stderr
	exit 1
fi
JCFLAGS="-I${S}{JAVA_HOME}/include -I${S}{JAVA_HOME}/include/linux"
echo "#include <jni.h>" > test.c
${S}{CC} test.c ${S}{JCFLAGS} -c >/dev/null 2>&1
if [ \"${S}?\" = \"0\" ]; then
	echo ok
else
	echo no
fi
EOF
`
}

use_tk() {
	echo "printf \"checking for tk... \""
	echo "HAVE_TK=0"
	echo "for A in ${S}{TK_BASEDIR} ${S}{SEARCHPATH}; do"
	echo "if [ -f \"${S}{A}/lib/tkConfig.sh\" ]; then"
	echo ". ${S}{A}/lib/tkConfig.sh"
	echo "  HAVE_TK=1"
	echo "  TK_LDFLAGS=\"${S}{TK_LIB_SPEC}\""
	echo "  echo \"${S}{TK_VERSION}\""
	echo "  break; fi"
	echo "done"
	echo "if [ \"${S}{HAVE_TK}\" = \"0\" ]; then echo no; fi"
}

## PERL ##
env_perl() {
	if [ -n "${LANG_PERL_ENV}" ]; then return ; fi
	LANG=1
	LANG_PERL=1
	LANG_PERL_ENV="PERL HAVE_LANG_PERL"
	ACR_RMFILES="${ACR_RMFILES} test.pl"
	add_lang_envwords "PERL"
	REPORT_LANGS="${REPORT_LANGS} perl"
}
env_perl_threads() {
	add_envword "HAVE_LANG_PERL_THREADS"
	if [ -z "${LANG_PERL}" ]; then
		word=`get_word_number`
		echo "$word You must set LANG_PERL before calling USE_PERL_THREADS" > /dev/stderr
		exit 1
	fi
	_USE_PERL_THREADS=1
}

lang_perl() {
	echo "printf \"checking for perl... \""
	echo "HAVE_LANG_PERL=0"
	echo "perl -e '' 2>&1 > /dev/null"
	echo "if [ "${S}?" = "0" ]; then"
	echo "  echo ok ; HAVE_LANG_PERL=1 ; else"
	echo "  echo no ; "
	word=`get_word_number`
	if [ "${LANG_PERL_REQUIRED}" = "1" ]; then
	echo "echo \"$word You need perl installed on your system.\" > /dev/stderr "
	echo "exit 1"
	fi
	echo "fi"
	if [ "${_USE_PERL_THREADS}" = "1" ]; then
	echo "printf \"checking for perl threads... \""
	echo "HAVE_LANG_PERL_THREADS=1"
	echo "perl -e 'use threads;' 2>&1 > /dev/null"
	echo "if [ "${S}?" = "0" ]; then"
	echo "  echo ok; else"
	echo "  echo no ; HAVE_LANG_PERL_THREADS=0"
	if [ "${LANG_PERL_THREADS_REQUIRED}" = "1" ]; then
	echo "echo \"ERROR: You need perl with threads.\" > /dev/stderr ; exit 1; fi"
	fi
	fi
}

env_c() {
	if [ -n "${LANG_C_ENV}" ]; then return ; fi
	LANG=1
	LANG_C=1
	LANG_C_ENV="CC CFLAGS LDFLAGS HAVE_LANG_C"
	ACR_RMFILES="${ACR_RMFILES} test.c a.out"
	REPORT_LANGS="${REPORT_LANGS} c"
	add_lang_envwords "C"
	ENVHELP=`cat <<EOF
${ENVHELP}
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
EOF
`
	env_cpp
}

lang_c() {
	echo "printf \"checking for c compiler... \""
	echo "HAVE_LANG_C=1"
	echo "if [ \"${S}{CROSSBUILD}\" = 1 ]; then"
	echo "(command -v ${S}{HOST}-${S}{CC} >/dev/null 2>&1)"
	echo "if [ "${S}?" = "0" ]; then CC=\"${S}{HOST}-${S}{CC}\"; fi"
	echo "fi"
	echo "echo \"main(){}\" > test.c"
	echo "(exec ${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} test.c >/dev/null 2>&1)"
	echo "if [ \$? = 0 ]; then echo ${S}{CC}; else"
	echo "echo no ; HAVE_LANG_C=0"
	if [ "${LANG_C_REQUIRED}" = "1" ]; then
	echo "echo \"ERROR: ${S}{CC} cannot create executables\" > /dev/stderr ;"
	echo "exit 1"
	fi
	echo "fi"
	echo ""

	lang_cpp
}

env_cxx() {
	LANG=1
	if [ -n "${LANG_CXX_ENV}" ]; then return ; fi
	LANG_CXX=1
	REPORT_LANGS="${REPORT_LANGS} c++"
	ACR_RMFILES="${ACR_RMFILES} test.cxx a.out a.exe"
	LANG_CXX_ENV="CXX CXXFLAGS LDFLAGS HAVE_LANG_CXX"
	add_lang_envwords "CXX"
	ENVHELP=`cat <<EOF
${ENVHELP}
  CXX         C++ compiler command
  CXXFLAGS    C++ compiler flags
EOF
`
}

lang_cxx() {
	add_envword "CXX"
	echo "HAVE_LANG_CXX=1"
	echo "printf \"checking for c++ compiler... \""
	echo "if [ \"${S}{CROSSBUILD}\" = 1 ]; then"
	echo "(command -v ${S}{HOST}-${S}{CXX} 2>&1 >/dev/null)"
	echo "if [ "${S}?" = "0" ]; then CXX=\"${S}{HOST}-${S}{CXX}\"; fi"
	echo "fi"
	echo "echo \"#include <iostream>\" > test.cxx"
	echo "echo \"main(){ std::cout << \\\"\\\"; }\" >> test.cxx"
	echo "(exec ${S}{CXX} ${S}{CXXFLAGS} ${S}{LDFLAGS} test.cxx >/dev/null 2>&1)"
	echo "if [ \$? = 0 ]; then echo ${S}{CXX}; else"
	echo "HAVE_LANG_CXX=0"
	echo "echo no"
	if [ "${LANG_CXX_REQUIRED}" = "1" ]; then
		echo "echo \"ERROR: ${S}{CXX} cannot create executables\" > /dev/stderr ;" 
		echo "exit 1"
	fi
	echo "fi"
	echo ""
	lang_cpp
}

use_x11() {
	add_envword "HAVE_X11"
	echo "printf \"checking for X11... \""
	echo "CFLAGS=\"${S}CFLAGS -I${S}{X11BASE}/include\""
	echo "LDFLAGS=\"${S}LDFLAGS -L${S}{X11BASE}/lib\""
	echo "if [ -n \"${X_INCLUDES}\" ]; then CFLAGS=\"${CFLAGS} -I${X_INCLUDES}\"; fi"
	echo "if [ -n \"${X_LIBRARIES}\" ]; then CFLAGS=\"${CFLAGS} -L${X_LIBRARIES}\"; fi"
	echo "if [ \"${S}{HAVE_X11}\" = \"1\" ]; then"
	echo "echo '#include <X11/Xlib.h>' > test.c"
	echo "echo 'main(){XrmInitialize();}' >> test.c"
	echo "${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} test.c -lX11 2> /dev/null"
	echo "if [ \"${S}?\" = 0 ]; then"
	echo "  echo ok ; HAVE_X11=1"
	echo "else"
	echo "  echo 'not found' > /dev/stderr ; HAVE_X11=0"
	echo "fi"
	echo "else"
	echo "  HAVE_X11=0 ; echo 'disabled' > /dev/stderr"
	echo "fi"
}

env_gmake() {
	add_envword "MAKE"
	add_envword "GMAKE"
	REPORT_TOOLS="${REPORT_TOOLS} gmake"
}

use_gmake() {
	# TODO ? set MAKE env to the properly path
	echo "printf \"checking for GNU make... \""
	echo "GMAKE=0"
	echo "for MAKE in make gmake ; do"
	echo " if [ ! \"\`${S}MAKE -version 2>&1 | grep GNU\`\" = \"\" ]; then"
	echo "  echo yes ; GMAKE=1 ; break"
	echo " fi"
	echo "done"
	echo " if [ \"${S}GMAKE\" = \"0\" ]; then"
	echo "  echo no"
	echo "  echo \"ERROR: No GNU make found.\" > /dev/stderr"
	echo "  exit 1"
	echo " fi"
	echo ""
}

acr_eof() {
	if [ "${LANG}" = "1" ]; then
	echo "printf \"cleaning temporally files... \""
		echo "do_remove"
		if [ "${LANG_C}" = "1" ]; then
		echo "rm -f test.c a.out"
		fi
		if [ "${LANG_JAVA}" = "1" ]; then
		echo "rm -f test.class test.java"
		fi
		if [ "${LANG_CXX}" = "1" ]; then
		echo "rm -f test.cxx"
		fi
	echo "echo \"done\""
	fi
}

report_h() {
	echo "for A in ${H_FILES}; do"
	echo " echo \"creating h ${S}{VPATH}/${S}{A}\""
	echo "  echo '' > ${S}{VPATH}/${S}{A}"
	echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	echo " for B in ${S}{ENVWORDS} ; do"
	echo "  eval \"VAR=\\${S}${S}{B}\""
	if [ "${_EXPORT_DEFINED}" = "1" ]; then
	#	echo "if [ ! \"\`echo ${S}{B} | grep -e HAVE -e VER -e PKG -e PACK\`\" = \"\" ]; then"
		echo "  if [ \"${S}{VAR}\" = "0" ]; then"
		echo "    echo \"/* #undef ${S}{B} */\" >> ${S}{VPATH}/${S}{A}"
		echo "  else"
		echo "  if [ -z \"${S}{VAR}\" ]; then"
		echo "    echo \"/* #undef ${S}{B} */\" >> ${S}{VPATH}/${S}{A}"
		echo "  else"
		echo "    echo \"#define ${S}{B} ${S}{VAR}\" >> ${S}{VPATH}/${S}{A}"
		echo "  fi"
		echo "  fi"
	#	echo "fi"
	else
		echo "  echo \"#define ${S}{B} ${S}{VAR}\" >> ${S}{VPATH}/${S}{A}"
	fi
	echo " done"
	echo "done"
	echo ""
}

report_sh() {
	echo "for A in ${SH_FILES}; do # SH_FILES"
	echo " echo \"creating sh ${S}{VPATH}/${S}{A}\""
	echo "  echo '# automatically generated by acr' > ${S}{VPATH}/${S}{A}"
	echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	echo " for B in ${S}{ENVWORDS} ; do"
	echo "  eval \"VAR=\\${S}${S}{B}\""
# nosense EXPORT_DEFINED HERE. (XXX)
#	if [ "${_EXPORT_DEFINED}" = "1" ]; then
#		echo "  if [ ! \"${S}{VAR}\" = \"0\" ]; then"
#		echo "  echo ${S}{B}=${S}{VAR} >> ${S}{VPATH}/${S}{A}"
#		echo "  fi"
#	else
	echo "  echo ${S}{B}=${S}{VAR} >> ${S}{VPATH}/${S}{A}"
#	fi
	echo " done"
	echo "done"
	echo ""
}

subst_tags() {
# if (crosspathbuild)
#  \
#   - create target directories (mkdir -p ${XX})
#   - target directori is localdir not VPATH

	# mkdirs
	echo "if [ \"${S}{WODIS}\" = \"crosspath\" ]; then"
	if [ -n "${S_MKDIR}" ]; then
	echo " mkdir -p ${S_MKDIR}"
	fi
	echo " for A in ${S_FILES} ; do"
	echo " echo \"filtering ${S}{A}\""
	echo "  cat ${S}{VPATH}/${S}{A} | eval sed ${S}{SEDFLAGS} > ${S}{A}"
	echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	echo " done"
	echo "else #--"
	# move files
	echo "for A in ${S_FILES} ; do # SUBST_FILES"
	echo " echo \"filtering ${S}{A}\""
	echo " if [ -f \"${S}{VPATH}/${S}{A}.orig\" ]; then"
	if [ "${USE_BACKUP}" = "1" ]; then
		echo "   if [ -f \"${S}{VPATH}/${S}{A}.backup\" ]; then"
		echo "   if [ -f \"${S}{VPATH}/${S}{A}\" ]; then"
		echo "   if [ -n \"\`diff ${S}{VPATH}/${S}{A}.backup ${S}{VPATH}/${S}{A}\`\" ]; then"
		echo "   echo \"It seems that ${S}{VPATH}/${S}{A} has changed. Check .backup first.\""
		echo "   exit 1 ; fi ; fi ; fi"
		echo "   rm ${S}{VPATH}/${S}{A}.backup"
	fi
	echo "   mv -f ${S}{VPATH}/${S}{A}.orig ${S}{VPATH}/${S}{A}"
	echo " fi"
	echo " if [ -f \"${S}{VPATH}/${S}{A}\" ]; then"
	echo "   mv -f ${S}{VPATH}/${S}{A} ${S}{VPATH}/${S}{A}.orig"
	echo " else"
	echo "  if [ ! -f \"${S}{VPATH}${S}{A}.orig\" ]; then"
	echo "    echo \"ERROR: Cannot find ${S}{VPATH}/${S}{A}.orig\" > /dev/stderr"
	echo "    exit 1"
	echo "  fi"
	echo " fi"
	echo " cat ${S}{VPATH}/${S}{A}.orig | eval sed ${S}{SEDFLAGS} > ${S}{VPATH}/${S}{A}"
	echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	if [ "${USE_BACKUP}" = "1" ]; then
		echo " cp ${S}{VPATH}/${S}{A} ${S}{VPATH}/${S}{A}.backup"
		echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	fi
	echo "done"
	echo "fi"
	echo ""
}

subst_dirs() {
	echo "for A in ${SD_FILES} ; do # SUBDIRS"
	echo " if [ -f \"${S}{A}.acr\" ]; then"
	echo "  SD_TARGET=${S}{A}"
	echo " else"
	echo "  if [ -d \"${S}{A}\" ]; then"
	echo "   SD_TARGET=${S}{A}/Makefile"
	echo "   mkdir -p ${S}{A}"
	echo "  else"
	echo "   echo \"ERROR: Cannot find ${S}{VPATH}/${S}{SD_TARGET}.acr\" > /dev/stderr"
	echo "   exit 1"
	echo "  fi"
	echo " fi"
	echo " echo \"creating ${S}{SD_TARGET}\""
	echo " cat ${S}{VPATH}/${S}{SD_TARGET}.acr | \\"
	echo "eval sed -e \"s,@${VPATH_VAR}@,${S}{VPATH}/${S}{A},g\" ${S}{SEDFLAGS} > ${S}{SD_TARGET}"
	echo "if [ \$? = 1 ]; then echo Cannot write target file ; control_c ; fi"
	echo "done"
	echo ""
}

add_flag() {
	# TODO ADD DEFAULT VALUE VAR=true|false
	# $1 = type (with,without,enable,disable)
	# $2 = affected variable
	# $3 = flag name (-static)
	# $4 = default value
	# $5 = description
	# $6 = argument name?
	REPORT_FLAGS="${REPORT_FLAGS} --${1}-${3}"
	add_envword ${2}
	TABS="`echo \"--${1}-${3}\" | awk '{ len=23-length($1); if (len<1) { print ""; len=25 } ; for (i=0;i<len;i++) { printf " "; } }'`"
	_TMP_="`printf "  --${1}-${3}${6}${TABS}${5}"`"
	FLAGHELP=`cat <<EOF
${FLAGHELP}
${_TMP_}
EOF
`
	#"with"|"enable") value=""; INIVARS="${INIVARS} ${2}=\"\" ; " ;;
	#"without") value=""; INIVARS="${INIVARS} ${2}=\"\" ; " ;;
	if [ -z "${4}" ]; then
		case $1 in
			"enable"|"with") value=1; echo "${2}=0"; ;;
			"disable"|"without") value=0; echo "${2}=1"; ;;
			*)	if [ -z "$6" ]; then 
					value="${S}${2}"; 
					echo "${2}=\"${S}${2}\""
				else
					value="${S}{value}"	
					echo "${2}=\"${S}${value}\""
				fi
			;;
		esac
		FLAGSCRIPT="`printf \"${FLAGSCRIPT}\n\"--${1}-${3}\") $2=\\\"${value}\\\"
		ENDSCRIPT=\\\"${S}{ENDSCRIPT} ${2}=${value} ;\\\";;\"`"
	else
		if [ "${4}" = "=" ]; then
		FLAGSCRIPT="`printf \"${FLAGSCRIPT}\n\"--${1}-${3}\") $2=\\\"${S}{value}\\\" ;;\"`"
		else
		FLAGSCRIPT="`printf \"${FLAGSCRIPT}\n\"--${1}-${3}\") $2=\\\"${4}\\\" ;;\"`"
		fi
	fi
}

create_body() {
cat <<EOF
split_host() {
	DOL="${S}"
	while : ; do
	ENVWORDS="${S}{ENVWORDS} ${S}1_CPU ${S}1_OS"
	STR=\`eval "echo ${S}{DOL}${S}1"\`
	SPLIT_CPU="\`echo "${S}STR" | awk -F - '{ print ${S}1 }'\`"
	SPLIT_OS="\`echo "${S}STR" | awk -F - '{ print ${S}3 }'\`"
	eval "${S}1_CPU=\"${S}SPLIT_CPU\""
	eval "${S}1_OS=\"${S}SPLIT_OS\""
	shift
	if [ -z "${S}1" ]; then break; fi
	done
}

guess_os() {
	CPU="\`uname -m|sed -e 's, ,,g'\`"
	OS="\`uname -s|awk '{print(tolower(${S}0))}'\`"
	GNU="\`uname --help 2>&1 | grep gnu\`"
	if [ -n "${S}{GNU}" ]; then OS="${S}{OS}-gnu"; fi
	if [ "${S}{CPU}" = "ppc" ]; then CPU="powerpc"; fi
	echo "${S}{CPU}-unknown-${S}{OS}"
}

SEARCHPATH="/usr /usr/local /usr/pkg /sw"

test -z "${S}{PREFIX}" && PREFIX=/usr/local
CROSSBUILD=0
BUILD=\`guess_os\`
HOST="${S}{BUILD}"
TARGET="${S}{HOST}"
SYSCONFDIR=""

create_environ() {
	test -z "${S}{EPREFIX}"    && EPREFIX="${S}{PREFIX}"
	test -z "${S}{SPREFIX}"    && SPREFIX="${S}{PREFIX}"
	test -z "${S}{BINDIR}"     && BINDIR="${S}{SPREFIX}/bin"
	test -z "${S}{SBINDIR}"    && SBINDIR="${S}{SPREFIX}/sbin"
	test -z "${S}{SYSCONFDIR}" && SYSCONFDIR="${S}{SPREFIX}/etc"
	test -z "${S}{LIBDIR}"     && LIBDIR="${S}{SPREFIX}/lib"
	test -z "${S}{LIBEXECDIR}" && LIBEXECDIR="${S}{SPREFIX}/libexec"
	test -z "${S}{DATADIR}"    && DATADIR="${S}{SPREFIX}/share"
	test -z "${S}{INCLUDEDIR}" && INCLUDEDIR="${S}{SPREFIX}/include"
	test -z "${S}{INFODIR}"    && INFODIR="${S}{SPREFIX}/info"
	test -z "${S}{MANDIR}"     && MANDIR="${S}{SPREFIX}/man"
	test -z "${S}{LOCALSTATEDIR}"  && LOCALSTATEDIR="${S}{SPREFIX}/var"
	test -z "${S}{INSTALL}"    && INSTALL="/usr/bin/install"
	test -z "${S}{INSTALL_DIR}" && INSTALL_DIR="${S}{INSTALL} -d"
	test -z "${S}{INSTALL_DATA}" && INSTALL_DATA="${S}{INSTALL} -m 644"
	test -z "${S}{INSTALL_SCRIPT}" && INSTALL_SCRIPT="${S}{INSTALL}"
	test -z "${S}{INSTALL_PROGRAM}" && INSTALL_PROGRAM="${S}{INSTALL} -s"
	test -z "${S}{INSTALL_MAN}" && INSTALL_MAN="${S}{INSTALL} -m 444"
	test -z "${S}{INSTALL_LIB}" && INSTALL_LIB="${S}{INSTALL}"

${INIVARS}
}
                
                
show_usage() {
`cat <<EOF1
cat <<EOF2
'configure' configures ${PKGNAME}-${VERSION} to adapt to many kinds of systems.

Usage: ./configure [OPTION]... [VAR=VALUE]...

To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE.  See below for descriptions of some of the useful variables.

Defaults for the options are specified in brackets.

Configuration:
  -h, --help              display this help and exit
  -V, --version           display version information and exit
  -r, --report            show what libs/programs require to work

Installation directories:
  --prefix=PREFIX        install arch-independent files in PREFIX [/usr/local]
  --exec-prefix=EPREFIX  install arch-dependent files in EPREFIX [PREFIX]
  --sandbox=SPREFIX      sandbox prefix directory: SPREFIX [PREFIX]

Fine tuning of the installation directories:
  --bindir=DIR           user executables [EPREFIX/bin]
  --sbindir=DIR          system admin executables [EPREFIX/sbin]
  --libexecdir=DIR       program executables [EPREFIX/libexec]
  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
  --libdir=DIR           object code libraries [EPREFIX/lib]
  --includedir=DIR       C header files [PREFIX/include]
  --infodir=DIR          info documentation [PREFIX/info]
  --mandir=DIR           man documentation [PREFIX/man]

System types:
  --build=BUILD          configure for building on BUILD [guessed]
  --host=HOST            cross-compile to build programs to run on HOST [BUILD]
  --target=TARGET        configure for building compilers for TARGET [HOST]
EOF2
EOF1
`

EOF
if [ -n "${FLAGHELP}" ]; then
	echo "printf \"\nOptional Features:${FLAGHELP}\n\""
fi
if [ -n "${ENVHELP}" ]; then
	echo "printf \"\nSome influential environment variables:${ENVHELP}\n\""
else
	echo ""
fi
if [ -n "${CONTACT_MAIL}" ]; then
	echo "printf \"\nReport bugs to: ${CONTACT_NAME} <${CONTACT_MAIL}>\""
fi
cat <<EOF
echo ""
exit 0
}

take_environ() {
	if [ -z "\${SH}" ]; then SH=sh ; fi
EOF
if [ "${LANG_C}" = "1" ]; then
	echo "if [ -z \"${S}{CC}\" ]; then CC=gcc ; fi"
	echo "if [ -z \"${S}{CPP}\" ]; then CPP=cpp ; fi"
fi
if [ "${LANG_CXX}" = "1" ]; then
cat <<EOF
	if [ -z "\${CXX}" ]; then CXX=g++ ; fi
EOF
fi
if [ "${LANG_JAVA}" = "1" ]; then
cat <<EOF
	if [ -z "\${JAVAC}" ]; then JAVAC=javac ; fi
EOF
fi
if [ "${LANG_PERL}" = "1" ]; then
cat <<EOF
	if [ -z "\${PERL}" ]; then PERL=perl ; fi
EOF
fi
cat <<EOF
	if [ -z "\${PREFIX}" ]; then PREFIX="/usr/local/" ; fi
}
                
show_version() {
	echo "${PKGNAME} configure ${VERSION}"
	echo "generated by ACR ${ACR_VERSION} : Auto Conf Replacement."
	echo ""
	echo "The 'Free Software Foundation' message is only for autodetection."
	echo "Originally written by pancake <pancake@phreaker.net>."
	exit 0
}

parse_options() {
	flag=\`echo \$1| awk -F = '{ print \$1 }'\`
	value=\`echo \$1| awk -F = '{ print \$2 }'\`
	flag2=\`echo \$flag|cut -f2- -d -| sed -e 's,-,_,g' -e 's,^_,,g'|tr '[a-z]' '[A-Z]'\`
	#if [ -z "\$value" ]; then value=0; fi # XXX

	case \$flag in
	"-h"|"--help"|"--hel"|"--h"|"--he"|"-help")
		show_usage ; ;;
	"-V"|"-version"|"--version")
		show_version ; ;;
	"-r"|"--r"|"--report")
EOF
	if [ ! "${PKGNAME}" = "this package" ]; then
		echo "echo \"PKGNAME:   ${PKGNAME}\""; fi
	if [ -n "${VERSION}" ]; then
		echo "echo \"VERSION:   ${VERSION}\""; fi
	if [ -n "${REPORT_LANGS}" ]; then
		echo "echo \"LANGS:    ${REPORT_LANGS}\"" ; fi
	if [ -n "${REPORT_REQUIRED}" ]; then
		echo "echo \"REQUIRED: ${REPORT_REQUIRED}\"" ; fi
	if [ -n "${REPORT_OPTIONAL}" ]; then
		echo "echo \"OPTIONAL: ${REPORT_OPTIONAL}\"" ; fi
	if [ -n "${REPORT_FLAGS}" ]; then
		echo "echo \"FLAGS:    ${REPORT_FLAGS}\"" ; fi
	if [ -n "${REPORT_TOOLS}" ]; then
		echo "echo \"TOOLS:    ${REPORT_TOOLS}\"" ; fi
cat <<EOF
		exit 0
		;;
	"--cache-file") 
		# ignored: acr doesnt needs cache
		;;
	"--build")
		BUILD="\$value"; ;;
	"--host")
		CROSSBUILD=1
		HOST="\$value"; ;;
	"--target")
		TARGET="\$value"; ;;
	"--prefix")
		PREFIX="\$value"; ;;
	"--exec-prefix")
		EPREFIX="\$value"; ;;
	"--sandbox"|"--sprefix")
		SPREFIX="\$value"; ;;
	"--bindir")
		BINDIR="\$value"; ;;
	"--sbindir")
		SBINDIR="\$value"; ;;
	"--libexecdir")
		LIBEXECDIR="\$value"; ;;
	"--datadir")
		DATADIR="\$value"; ;;
	"--sysconfdir")
		SYSCONFDIR="\$value"; ;;
	"--sharedstatedir")
		SHAREDSTATEDIR="\$value"; ;;
	"--localstatedir")
		LOCALSTATEDIR="\$value"; ;;
	"--libdir")
		LIBDIR="\$value"; ;;
	"--includedir")
		INCLUDEDIR="\$value"; ;;
	"--infodir")
		INFODIR="\$value"; ;;
	"--mandir")
		MANDIR="\$value"; ;;
${FLAGSCRIPT}
	*) if [ -n "\$value" ]; then eval "\`echo \$flag2=\$value\`" ; fi
		;;
	esac
}

# MAIN #
take_environ

while : ; do
        if [ -z "\$1" ]; then break; fi
        parse_options \$1
        shift;
done

ENVWORDS="${ENVWORDS}"

create_environ

${EQUALSCR}
EOF
}

check_path() {
	cat <<EOF
VPATH=\`dirname ${S}{0}\`
if [ "${S}{VPATH}" = "." ]; then 
	WODIS=current
else
	if [ "${S}{VPATH}" = "${S}{PWD}" ]; then
		VPATH=.
		WODIS=current
	else
		WODIS=crosspath
		CURDIR=${S}PWD
		cd ${S}VPATH
		VPATH="${S}{PWD}/"
		cd ${S}CURDIR
	fi
fi

echo "checking for working directories... ${S}{WODIS}"
echo "using prefix ${S}{PREFIX}"

EOF
}

check_os() {
	cat <<EOF
	echo "checking build system type... ${S}{BUILD}"
	echo "checking host system type... ${S}{HOST}"
	echo "checking target system type... ${S}{TARGET}"
	if [ "${S}{CROSSBUILD}" = 1 ]; then
	echo "using crosscompilation mode."
	fi

	split_host BUILD HOST TARGET

EOF
}

## - script output generation - ##

create_script() {
	echo "ENDSCRIPT=\"\""

	create_body

	# checks
	check_os
	check_path

	echo "ACR_RMFILES=\"${ACR_RMFILES}\""
	if [ "${LANG_C}" = "1" ]; then lang_c ; fi
	if [ "${LANG_CXX}" = "1" ]; then lang_cxx ; fi
	if [ "${LANG_JAVA}" = "1" ]; then lang_java ; fi
	if [ "${LANG_BASH}" = "1" ]; then lang_bash ; fi
	if [ "${LANG_TCL}" = "1" ]; then lang_tcl ; fi
	if [ "${LANG_PERL}" = "1" ]; then lang_perl ; fi
	if [ "${LANG_PYTHON}" = "1" ]; then lang_python ; fi
	if [ "${LANG_RUBY}" = "1" ]; then lang_ruby ; fi
	if [ "${USE_X11}" = "1" ]; then use_x11 ; fi
	if [ "${USE_TK}" = "1" ]; then use_tk ; fi
	if [ "${USE_GMAKE}" = "1" ]; then use_gmake ; fi
	if [ "${HAVE_LIBS}" = "1" ]; then echo "${LIBSCRIPT}" ; fi

	echo "eval \"${S}{ENDSCRIPT}\""

	if [ -n "${PRGSCRIPT}" ]; then echo "${PRGSCRIPT}" ; fi
	if [ -n "${PKGCFG_STR}" ]; then echo "${PKGCFG_STR}" ; fi
	if [ -n "${CHECKSCRIPT}" ]; then echo "${CHECKSCRIPT}" ; fi
	if [ -n "${IFSCRIPT}" ]; then echo "${IFSCRIPT}" ; fi
	if [ -n "${CHKVERSTR}" ]; then echo "${CHKVERSTR}" ; fi

	cat <<EOF

SEDFLAGS="${SEDFLAGS}"
for A in ${S}{ENVWORDS} ; do
	if [ "${S}{A}" = "VPATH" ]; then continue; fi
	if [ "${S}{A}" = "srcdir" ]; then continue; fi ## XXX ugly fix
	eval "VAR=\\${S}${S}{A}"
	VAR="\`echo ${S}{VAR} | sed -e 's/\,/\\\\\,/g'\`"
	SEDFLAGS="${S}{SEDFLAGS} -e 's,@${S}{A}@,${S}{VAR},g;'"
done

EOF

	if [ -n "${H_FILES}" ]; then
		report_h   ${H_FILES} ; fi
	if [ -n "${SH_FILES}" ]; then
		report_sh  ${SH_FILES} ; fi
	if [ -n "${S_FILES}" ]; then
		subst_tags ${S_FILES} ; fi
	if [ -n "${SD_FILES}" ]; then
		subst_dirs ${SD_FILES} ; fi

	acr_eof

	# subdirs
	if [ -n "${SUBCONF_DIRS}" ]; then
	cat <<EOF
for A in ${SUBCONF_DIRS} ; do
	if [ -x ${S}{A}/configure ]; then
		echo "=> running ./configure in ${S}{A}"
		cd ${S}{A}
		./configure ${S}@
		cd - > /dev/null
	else
		echo "Cannot find ./configure on directory ${S}{A}."
		exit 1
	fi
done
EOF
	fi
}

show_report() {
	if [ -n "${REPORT}" ]; then
		echo "echo \"\""
		echo "echo \"Final report:\""
		echo "for A in ${REPORT} ; do # REPORT"
		echo "  eval \"VAL=\\${S}${S}{A}\""
		echo "  if [ -z \"${S}{VAL}\" ]; then VAL=\"(null)\"; fi"
		echo "  echo \" - ${S}{A} = ${S}{VAL}\""
		echo "done"
	fi
}

is_buggy() {
	WORD=$1

	if [ ! "${WORD}" = ";" ]; then 

		if [ -n "`echo $1 | grep ';'`" ]; then
			word=`get_word_number`
			echo "$word | Warning: keyword '$1' contains a ';'. Is this fine?" > /dev/stderr
		fi

	fi
}

LAST_DOT=0
show_progress_bar() {
	DOTS=`echo $WORDS_N $WORDS_T | awk '{printf ("%.d",$1*70/$2);}'`
	if [ -z "${DOTS}" ]; then DOTS=0; fi
	if [ "${LAST_DOT}" = "${DOTS}" ]; then return ; fi
	PCENT=`echo $WORDS_N $WORDS_T | awk '{printf ("%.d",$1*100/$2);}'`
	LAST_DOT=$DOTS
	dots=`printf "%.2d" $PCENT`
	N=0
	BAR=""
	BAR=`echo $DOTS | awk '{ str=""; for(i=0;i<$1;i++) { str=str"#"; } print str;  }'`
	printf "     [------------------------------------------------------------------------]\r" > /dev/stderr
	printf "  $dots%% [${BAR}\r" > /dev/stderr
}

# MAIN LOOP #

print_header # show /bin/sh stuff

COMMENT=0
WORDS=`cat "${ACRFILE}"`
WORDS_N=0 # number of current word (counter)
WORDS_K=0 # keyword word
WORDS_T=`echo ${WORDS} | wc -w ` # total number of words

for STR in ${WORDS} NOP ;
do
	if [ "${PBAR}" = "1" ]; then
	show_progress_bar ; fi

	WORDS_N=`expr $WORDS_N + 1`
	IS_KEYWORD=1
	is_buggy ${STR}

	if [ ! "${STR}" = "<-" ]; then
		if [ "`echo ${STR}| cut -c -2`" = "<-" ]; then
			VAR="`echo ${STR} | cut -c 3-`"
			TMP="${S}${VAR}"
			if [ "${DEBUG}" = "1" ]; then
				word=`get_word_number`
				echo "$word > get value" > /dev/stderr
			fi
			STR=${TMP}
		fi
	fi

	# COMMENTS #
	if [ -z "${STR}" ]; then continue; fi

	if [ "${COMMENT}" = "1" ]; then
		if [ "${STR}" = "##" ]; then   COMMENT=0; fi
		if [ "${STR}" = "\\\\" ]; then COMMENT=0; fi
		if [ "${STR}" = "))" ]; then   COMMENT=0; fi
		continue
	else
		if [ "${STR}" = "##" ]; then COMMENT=1; continue; fi
		if [ "${STR}" = "//" ]; then COMMENT=1; continue; fi
		if [ "${STR}" = "((" ]; then COMMENT=1; continue; fi
	fi
	# one word comment
	if [ "`echo $STR | cut -c 1`" = "#" ]; then continue; fi

	# CONDITION FLAGS #
	if [ "${_CHKFUNC}" = "1" ]; then
		IS_KEYWORD=0
		if [ -z "${_CHKFUNC_LIB}" ]; then
			_CHKFUNC_LIB=${STR}
		else
			_CHKFUNC_NAME=${STR}
			check_func $_CHKLIB_LIB ${_CHKFUNC_NAME}
			_CHKFUNC=0
			_CHKFUNC_REQUIRED=0
			_CHKFUNC_LIB=""
			_CHKFUNC_NAME=""
		fi
	else
	if [ "${_CHK_CP}" = "1" ]; then
		IS_KEYWORD=0
		REPORT_REQUIRED="${REPORT_REQUIRED} ${STR}"
		CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
printf "checking for classpath ${STR}... "
echo "import ${STR}.*;" > test.java
${S}{JAVAC} test.java 2>&1 > /dev/null
if [ \"${S}?\" = \"0\" ]; then echo yes
else
	echo no
EOF
`
		if [ "${_CHK_CP_REQUIRED}" = "1" ]; then
				echo "echo 'This classpath is required.'"
				echo "exit 1"
		fi
		CHECKSCRIPT="${CHECKSCRIPT} ; fi "
		_CHKCP_REQUIRED=0
		_CHK_CP=0
	else
	if [ "${_CHKLIB}" = "1" ]; then
		IS_KEYWORD=0
		check_lib ${STR}
		_CHKLIB=0
		_CHKLIB_REQUIRED=0
		_CHKLIB_NAME=""
	else
	if [ "${_CHK_PY}" = "1" ]; then
		IS_KEYWORD=0
		check_py ${STR}
		_CHK_PY=0
	else
	if [ "${_CHK_RU}" = "1" ]; then
		IS_KEYWORD=0
		check_ru ${STR}
		_CHK_RU=0
	else
	if [ "${_CHK_PM}" = "1" ]; then
		IS_KEYWORD=0
		check_pm ${STR}
		_CHK_PM=0
	else
	if [ "${CHECK}" = "1" ]; then
		IS_KEYWORD=0
		if [ -z "${CHECK_VAR}" ]; then	
			CHECK_VAR=${STR};
		else
		if [ -z "${CHECK_EOF}" ]; then
			CHECK_EOF=${STR}
		else
			if [ "${STR}" = "${CHECK_EOF}" ]; then
CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
printf "checking for ${CHECK_VAR}... "
${CHECK_STR} 
if [ "${S}${CHECK_VAR}" = "1" ]; then
	echo yes
else
	${CHECK_VAR}=0
	echo no
fi

EOF
`
				add_envword ${CHECK_VAR}
				CHECK=0
				CHECK_VAR=""
				CHECK_EOF=""
				CHECK_STR=""
			else
				if [ "${STR}" = "\\" ]; then
				CHECK_STR="${CHECK_STR} ; "
				else
				CHECK_STR="${CHECK_STR}${STR} "
				fi
			fi
		fi
		fi
	else
	if [ "${_CHKVER}" = "1" ]; then
		IS_KEYWORD=0
		REPORT_REQUIRED="${REPORT_REQUIRED} lib${_CHKVER_LIB}>=${STR}"
		if [ -z "${_CHKVER_LIB}" ]; then
			_CHKVER_LIB="${STR}"
		else
			CHKVERSTR=`cat <<EOF
printf "checking version of library ${_CHKVER_LIB} >= ${STR}..."
pkg-config --atleast-version=${STR} ${_CHKVER_LIB} >/dev/null 2>&1
if [ ${S}? = 0 ]; then echo ok; else
echo "no"
echo "ERROR: You need ${_CHKVER_LIB} <= ${STR}." > /dev/stderr
exit 1; fi
EOF
`
			_CHKVER=0
			_CHKVER_LIB=""
		fi
	else
	if [ "${_USE_ICONV}" = "1" ]; then
		_USE_ICONV=0
		add_envword "HAVE_LIB_ICONV"
		add_envword "ICONV_LIBS"
		REPORT_REQUIRED="${REPORT_REQUIRED} libiconv"
		CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
	printf "checking for iconv... "
	HAVE_LIB_ICONV=0
	ICONV_LIBS=""
	for HOST_OS in solaris linux netbsd ; do
		HAVE_LIB_ICONV=1
		echo libc
		break;
	done
	if [ "${HAVE_LIB_ICONV}" = "0" ]; then
		echo 'main(){iconv_open}' > test.c
		${S}{CC} ${S}{CFLAGS} ${S}{LDFLAGS} test.c 2> /dev/null
		if [ "${S}?" = "0" ]; then
			echo yes
			HAVE_LIB_ICONV=1
		else
			echo no
		fi
	fi
EOF
`
	else
	if [ "${_EXEC}" = "1" ]; then
		IS_KEYWORD=0
		if [ -z "${_EXEC_VAR}" ]; then
			_EXEC_VAR="${STR}"
		else
		if [ "${STR}" = ";" ]; then
		add_envword "${_EXEC_VAR}"
		CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}
	printf "checking exec ${_EXEC_CMD}... "
	${_EXEC_VAR}="\\\`${_EXEC_CMD} 2>/dev/null\\\`" 
	if [ "${S}?" = 0 ]; then
		echo "ok"
	else
		${_EXEC_VAR}=""
		echo "not found"
	fi
EOF
`
			_EXEC=0
			_EXEC_VAR=""
			_EXEC_CMD=""
		else
			if [ -z "${_EXEC_CMD}" ]; then _EXEC_CMD=${STR}; else
			_EXEC_CMD="${_EXEC_CMD} ${STR}"; fi
		fi
		fi
	else
	if [ "${_USE_DL}" = "1" ]; then
	_USE_DL=0
	REPORT_REQUIRED="${REPORT_REQUIRED} libdl"
	add_envword "HAVE_LIB_DL"
	add_envword "DL_LIBS"
	# Linux Darwin BeOS Solaris need libdl
	CHECKSCRIPT=`cat <<EOF
${CHECKSCRIPT}

printf "checking for dynamic library... "
HAVE_LIB_DL=0
for OS in linux syllable sunos darwin beos solaris ; do
if [ "${S}{HOST_OS}" = "${S}{OS}" ]; then
	HAVE_LIB_DL=1
	break;
fi
done
if [ "${S}{HAVE_LIB_DL}" = "1" ]; then
	DL_LIBS="-ldl"
	echo "required"
else
	DL_LIBS=""
	echo "libc"
fi
EOF
`	
	else
	if [ "${_EXPORT}" = "1" ]; then
		IS_KEYWORD=0;
		if [ "${STR}" = ";" ]; then
			_EXPORT=0;
		else
			add_envword $STR
		fi
	else
	if [ "${_NOT}" = "1" ]; then
		IS_KEYWORD=0
		IFSCRIPT="${IFSCRIPT} ; if [ \"${S}{STR}\" = \"0\" ]; then ${STR}=1 ; else ${STR}=0 ; fi"
		_NOT=0
	else
	if [ "${_DIE}" = "1" ]; then
		IS_KEYWORD=0;
		if [ -z "${_DIE_VAR}" ]; then
			_DIE_VAR=${STR}
		else
		if [ "${STR}" = ";" ]; then
			if [ "${_DIE_BOOL}" = "0" ]; then
			IFSCRIPT="${IFSCRIPT}
case \"${S}${_DIE_VAR}\" in 0|\"\") echo ; echo \"ERROR:${_DIE_STRING}\" > /dev/stderr ; echo ; exit 1 ;; esac"
			else
			IFSCRIPT="${IFSCRIPT}
case \"${S}${_DIE_VAR}\" in 0|\"\") ;; *) echo ; echo \"ERROR:${_DIE_STRING}\" > /dev/stderr ; echo ; exit 1 ; ;; esac"
			fi
		_DIE=0;
		_DIE_VAR="";
		_DIE_STRING="";
		else
			_DIE_STRING="${_DIE_STRING} ${STR}"
		fi
		fi
	else
	if [ "${_IF}" = "1" ]; then ##IF##
		IS_KEYWORD=0
		if [ -z "${_IF_VAR}" ]; then
			_IF_VAR=${STR}
		else
		if [ -z "${_IF_SETVAR}" ]; then
			if [ "${STR}" = "{" ]; then
				LOCAL_CONTEXT="1"
				IFSCRIPT="${IFSCRIPT}
if [ \"${S}${_IF_VAR}\" = \"${_IF_BOOL}\" ]; then"
				NKEYS=`expr $NKEYS + 1`
				_IF=0
				_IF_VAR=""
				_IF_SETVAR=""
				_IF_OP=""
			else
			_IF_SETVAR=${STR}
			_IF_SETVAL=""
			fi
		else
		if [ -z "${_IF_OP}" ]; then
			_IF_OP=${STR}
			check_ifop ${_IF_OP}
		else
			if [ "${STR}" = ";" ]; then
			add_envword ${_IF_SETVAR}
			IFSCRIPT="${IFSCRIPT}
if [ \"${S}${_IF_VAR}\" = \"${_IF_BOOL}\" ]; then"
			# check_ifop TODO -> use ifop instead of that.
			case ${_IF_OP} in
				"=") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${_IF_SETVAL}\" ; fi"
					;;
				"+=") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${S}{${_IF_SETVAR}} ${_IF_SETVAL}\" ; fi"
					;;
				"?=") IFSCRIPT="${IFSCRIPT} if [ -z \"${S}${_IF_SETVAR}\" ]; then ${_IF_SETVAR}=\"${_IF_SETVAL}\"; fi"
					;;
				"<-") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"\`eval 'echo \$${_IF_SETVAL}'\`\"; fi"
					;;
			esac
			_IF=0
			_IF_OP=""
			_IF_VAR=""
			_IF_SETVAR=""
			_IF_SETVAL=""
			else
				_IF_SETVAL="`concat "${_IF_SETVAL}" ${STR}`"
			fi
		fi
		fi
		fi
	else
	if [ "${_IFEQVAL}" = "1" ]; then ##IFEQVAL##
		IS_KEYWORD=0
		if [ -z "${_IF_VAR}" ]; then
			_IF_VAR=$STR
		else
			if [ -z "${_IF_VAR2}" ]; then
				_IF_VAR2=$STR
			else
				if [ -z "${_IF_SETVAR}" ]; then
						if [ "${STR}" = "{" ]; then
							LOCAL_CONTEXT="1"
							if [ "${_IF_BOOL}" = "1" ]; then
								IFSCRIPT="${IFSCRIPT}
if ["
							else
								IFSCRIPT="${IFSCRIPT}
if [ !"
							fi
							IFSCRIPT="${IFSCRIPT} \\\"${S}${_IF_VAR}\\\" = \\\"${S}${_IF_VAR2}\\\" ]; then"
							NKEYS=`expr $NKEYS + 1` 
							_IFEQVAL=0
							_IF_VAR=""
							_IF_VAR2=""
							_IF_SETVAR=""
							_IF_SETVAL=""
							_IF_OP=""
						else
							_IF_SETVAR=${STR}
						fi
				else
					if [ -z "${_IF_OP}" ]; then
						_IF_OP=${STR}
						check_ifop ${_IF_OP}
					else
						if [ "${STR}" = ";" ]; then
							if [ "${_IF_BOOL}" = "1" ]; then
								IFSCRIPT="${IFSCRIPT}
if ["
							else
								IFSCRIPT="${IFSCRIPT}
if [ !"
							fi
						IFSCRIPT="${IFSCRIPT} \"${S}${_IF_VAR}\" = \"${S}${_IF_VAR2}\" ]; then "

						# TODO this must be in a external function
						case ${_IF_OP} in
							"=")  IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${_IF_SETVAL}\" ; fi"
								;;
							"+=") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${S}{${_IF_SETVAR}} ${_IF_SETVAL}\" ; fi"
								;;
							"?=") IFSCRIPT="${IFSCRIPT} if [ -z \"${S}${_IF_SETVAR}\" ]; then ${_IF_SETVAR}=\"${_IF_SETVAL}\"; fi"
								;;
							"<-") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"\`eval 'echo \$${_IF_SETVAL}'\`\"; fi"
								;;
						esac

						_IFEQVAL=0
						_IF_BOOL=0
						_IF_VAR=""
						_IF_VAR2=""
						_IF_SETVAR=""
						_IF_OP=""
						_IF_VALUE=""
						else
							_IF_SETVAL="`concat "${_IF_SETVAL}" "${STR}"`"
						fi
					fi
				fi
			fi
		fi
	else
	if [ "${_IFEQ}" = "1" ]; then ##IFEQ##
		IS_KEYWORD=0
		if [ -z "${_IF_VAR}" ]; then
			_IF_VAR=${STR}
		else
		if [ "${_IF_VALUE_EOF}" = "0" ]; then
			if [ "${STR}" = ";" ]; then
				_IF_VALUE_EOF=1
			else
				_IF_VALUE="`concat "${_IF_VALUE}" "${STR}"`"
			fi
		else
			if [ -z "${_IF_SETVAR}" ]; then
				if [ "${STR}" = "{" ]; then
					LOCAL_CONTEXT="1"
					if [ "${_IF_BOOL}" = "1" ]; then
						IFSCRIPT="`printf \"${IFSCRIPT}\nif [\"`"
					else
						IFSCRIPT="`printf \"${IFSCRIPT}\nif [ !\"`"
					fi
					IFSCRIPT="`printf \"${IFSCRIPT} \\\"${S}${_IF_VAR}\\\" = \\\"${_IF_VALUE}\\\" ]; then\"`"
					NKEYS=`expr $NKEYS + 1`
					_IF_VALUE_EOF=0
					_IFEQ=0
					_IF_VAR2=""
					_IF_VAR=""
					_IF_VALUE=""
					_IF_SETVAR=""
					_IF_OP=""
				else
					_IF_SETVAR=${STR}
				fi
			else
			if [ -z "${_IF_OP}" ]; then
				_IF_OP="${STR}"
				check_ifop ${_IF_OP}
			else
			if [ "${STR}" = ";" ]; then
				# bool
				if [ "${_IF_BOOL}" = "1" ]; then
					IFSCRIPT="`printf \"${IFSCRIPT}\nif [\"`"
				else
					IFSCRIPT="`printf \"${IFSCRIPT}\nif [ !\"`"
				fi
				IFSCRIPT="`printf \"${IFSCRIPT} \\\"${S}${_IF_VAR}\\\" = \\\"${_IF_VALUE}\\\" ]; then\"`"

				# set
				# TODO create a new function that concats IFSCRIPT checking IF_OP
				case ${_IF_OP} in
					"=")  IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${_IF_SETVAL}\" ; fi ;"
						;;
					"+=")	IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"${S}{${_IF_SETVAR}} ${_IF_SETVAL}\" ; fi ;"
						;;
					"?=") IFSCRIPT="${IFSCRIPT} if [ -z \"${S}${_IF_SETVAR}\" ]; then ${_IF_SETVAR}=\"${_IF_SETVAL}\"; fi ; fi ;"
						;;
					"<-")  IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"\`eval 'echo \$${_IF_SETVAL}'\`\"; fi"
						;;
				esac
				# reset
				_IFEQ=0
				_IF_OP=""
				_IF_VALUE=""
				_IF_VAR=""
				_IF_SETVAR=""
				_IF_SETVAL=""
				_IF_VALUE_EOF=0
			else
				if [ -z "${_IF_SETVAL}" ]; then
					_IF_SETVAL="${STR}"
				else
					_IF_SETVAL="${_IF_SETVAL} ${STR}"
				fi
			fi

			fi
			fi
		fi
		fi
	else
	if [ "${_IFAND}" = "1" ]; then ##IFAND##
		IS_KEYWORD=0
		if [ -z "${_IF_VAR}" ]; then
			_IF_VAR=${STR}
		else
		if [ -z "${_IF_VALUE}" ]; then # TODO: rename to IF_VAR2
			_IF_VALUE="${STR}"
		else
		if [ -z "${_IF_SETVAR}" ]; then
			if [ "${STR}" = "{" ]; then
				LOCAL_CONTEXT="1"
				#IFSCRIPT="`printf \"${IFSCRIPT} \\\"${S}${_IF_VAR}\\\" = \\\"${_IF_VALUE}\\\" ]; then\"`"

				if [ "${_IF_BOOL}" = "1" ]; then
				OGLE="11" ; else OGLE="00" ; fi

				IFSCRIPT="${IFSCRIPT}
if [ ${OGLE} = \"${S}${_IF_VAR}${S}${_IF_VALUE}\" ]; then
"
				NKEYS=`expr $NKEYS + 1`
				_IF_VALUE_EOF=0
				_IFAND=0
				_IF_VAR2=""
				_IF_VAR=""
				_IF_VALUE=""
				_IF_SETVAR=""
				_IF_OP=""
			else
			_IF_SETVAR=${STR}
	fi
		else
		if [ -z "${_IF_OP}" ]; then
			_IF_OP="${STR}"
			check_ifop ${_IF_OP}
		else
			if [ ! "${STR}" = ";" ]; then
				if [ -z "${_IF_SETVAL}" ]; then
				_IF_SETVAL="${STR}"
				else
				_IF_SETVAL="${_IF_SETVAL} ${STR}"
				fi
			else
				if [ "${_IF_BOOL}" = "1" ]; then
				OGLE="1" ; else OGLE="0" ; fi

				case ${_IF_OP} in
					"=") STR="${_IF_SETVAR}=\"${_IF_SETVAL}\""
						;;
					"+=")	STR="${_IF_SETVAR}=\"${S}{${_IF_SETVAR}} ${_IF_SETVAL}\""
						;;
					"?=") STR="if [ -z \"${S}${_IF_SETVAR}\" ]; then ${_IF_SETVAR}=\"${_IF_SETVAL}\"; fi"
						;;
					"<-") IFSCRIPT="${IFSCRIPT} ${_IF_SETVAR}=\"\`eval 'echo \$${_IF_SETVAL}'\`\"; fi"
						;;
				esac
				IFSCRIPT="${IFSCRIPT}
if [ ${OGLE} = \"${S}${_IF_VAR}\" ]; then
if [ ${OGLE} = \"${S}${_IF_VALUE}\" ]; then
${STR} ; fi ; fi"

## TODO XXX this must be other command (IFEQVAR..or something similar
#if [ ${OGLE}"${S}${_IF_VAR}" = "${S}${_IF_VALUE}" ]; then ${_IF_SETVAR}="${STR}" ; fi ;
				_IFAND=0
				_IF_VALUE=""
				_IF_VAR=""
				_IF_OP=""
				_IF_SETVAR=""
				_IF_SETVAL=""
			fi
		fi
		fi
		fi
		fi
	else
	if [ "${_PKGCONFIG}" = "1" ]; then
		IS_KEYWORD=0
		if [ -z "${_PC_CFLAGS}" ]; then
			_PC_CFLAGS="${STR}"
		else
			if [ -z "${_PC_LDFLAGS}" ]; then
				_PC_LDFLAGS="${STR}"
			else
				add_envword ${_PC_CFLAGS}
				add_envword ${_PC_LDFLAGS}
				PKGCFG_STR="`printf \"${PKGCFG_STR}\nprintf 'checking pkg-config flags for ${STR}... '\"`"
				## - flags - ##
				PKGCFG_STR="`printf \"${PKGCFG_STR}\ntmp=\\\`pkg-config --cflags ${STR} 2>/dev/null\\\`\"`"
				PKGCFG_STR="`printf \"${PKGCFG_STR}\nif [ ${S}? = 1 ]; then echo no ; else \"`"
				if [ "${_PKGCONFIG_PLUS}" = "1" ]; then
				PKGCFG_STR="`printf \"${PKGCFG_STR}\n${_PC_CFLAGS}=\\\"${S}${_PC_CFLAGS} ${S}tmp\\\"; \"`"
				else
				PKGCFG_STR="`printf \"${PKGCFG_STR}\n${_PC_CFLAGS}=${S}tmp; \"`"
				fi
				## - libs - ##
				PKGCFG_STR="`printf \"${PKGCFG_STR}\ntmp=\\\`pkg-config --libs ${STR} 2>/dev/null\\\`\"`"
				PKGCFG_STR="`printf \"${PKGCFG_STR}\nif [ ! ${S}? = 1 ]; then \"`"
				PKGCFG_STR="`printf \"${PKGCFG_STR}\necho yes\"; `"
				if [ "${_PKGCONFIG_PLUS}" = "1" ]; then
				PKGCFG_STR="`printf \"${PKGCFG_STR}\n${_PC_LDFLAGS}=\\\"${S}${_PC_LDFLAGS} ${S}tmp\\\"; fi; fi\"`"
				else
				PKGCFG_STR="`printf \"${PKGCFG_STR}\n${_PC_LDFLAGS}=${S}tmp; fi; fi\"`"
				fi
				## -eof- ##
				_PC_CFLAGS=""
				_PC_LDFLAGS=""
				_PKGCONFIG=0
			fi
		fi
	else
	if [ "${_REPORT}" = "1" ]; then
		IS_KEYWORD=0
		if [ "${STR}" = ";" ]; then _REPORT=0; 
		else
		REPORT="${REPORT} ${STR}"
		fi
	else
	if [ "${_CHKINC}" = "1" ]; then
		check_inc ${STR}
		IS_KEYWORD=0
		_CHKINC=0
		_CHKINC_REQUIRED=0
	else
	if [ "${SUBCONF}" = "1" ]; then
		IS_KEYWORD=0
		if [ "${STR}" = ";" ]; then
			SUBCONF=0
		else
			SUBCONF_DIRS="${SUBCONF_DIRS} ${STR}"
		fi
	else
	if [ "${SUBDIRS}" = "1" ]; then
		IS_KEYWORD=0
		if [ "${STR}" = ";" ]; then
			SUBDIRS=0
		else
			SD_FILES="${SD_FILES}${STR} "
		fi
	else
	if [ "${_CHKPRG}" = "1" ]; then
		IS_KEYWORD=0
		if [ -z "${_CHKPRG_VAR}" ]; then
			_CHKPRG_VAR=${STR}
		else
			_CHKPRG_NAME=${STR}
			check_prg ${_CHKPRG_VAR} ${_CHKPRG_NAME}
			_CHKPRG=0
			_CHKPRG_VAR=""
			_CHKPRG_NAME=""
		fi
	else
	if [ "${OUTPUT_H}" = "1" ]; then
		if [ "${STR}" = ";" ]; then
			OUTPUT_H=0
		else
			H_FILES="${H_FILES} ${STR}"
		fi
		IS_KEYWORD=0
	else
	if [ "${OUTPUT_SH}" = "1" ]; then
		if [ "${STR}" = ";" ]; then
			OUTPUT_SH=0
		else
			SH_FILES="${SH_FILES} ${STR}"
		fi
		IS_KEYWORD=0
	else
	if [ -n "${ARGUMENT}" ]; then
		if [ "${STR}" = ";" ]; then
			add_flag ${ARGUMENT} ${ARG_NAME} \
				${ARG_FLAG} "${ARG_VALUE}" "${ARG_DESC}"
			ARG_NAME=""
			ARG_FLAG=""
			ARG_DESC=""
			ARGUMENT=""
			ARG_VALUE=""
		else
			if [ -z "${ARG_NAME}" ]; then
				ARG_NAME=`echo ${STR} | awk -F = '{ print $1 }'`
				ARG_VALUE=`echo ${STR} | awk -F = '{ print $2 }'`
			else
			if [ -z "${ARG_FLAG}" ]; then
				ARG_FLAG=${STR}
			else
			ARG_DESC="${ARG_DESC}${STR} "
			fi ; fi
		fi
		IS_KEYWORD=0
	else
	if [ -n "${EQUAL}" ]; then
		if [ "${STR}" = ";" ]; then
			for A in 1 2 3 4 ; do
				if [ "${A}" = "${EQUAL}" ]; then
				word=`get_word_number`
				echo "$word | There's a null body assignation to variable ${SET_VAR}. Please type \"\" or ''" > /dev/stderr
				exit 1
				IS_KEYWORD=0
				fi
			done
			case $LOCAL_CONTEXT in
			0) # global
				EQUALSCR="${EQUALSCR}
${EQUAL}\""
				if [ "${_EQUAL_3}" = "1" ]; then
					EQUALSCR="${EQUALSCR} ; fi"
				fi
				;;
			1) # local
				IFSCRIPT="${IFSCRIPT}
${EQUAL}\""
				;;
			esac

	#		eval ${EQUAL}\" # XXX ?
			EQUAL=""
			SPACE=""
			_EQUAL_3=0
		else
			if [ -n "${SET_VAR}" ]; then
				STR2=${STR}
				STR=${SET_VAR}
				SET_VAR=""
			fi
			case $STR2 in
			"''"|"\"\"")
				STR2=""
				;;
			esac
			case "${EQUAL}" in
			1)  EQUAL="${STR}=\"${STR2}" ;;                               # =
			2)  EQUAL="${STR}=\"${S}{${STR}} ${STR2}" ;;                  # +=
			3)  EQUAL="if [ \"${S}{${STR}}\" = \"\" ]; then ${STR}=\"${STR2}" ;; # ?=
			4)  EQUAL="${STR}=\"${S}${STR2}" ; ;;                # <-
			*)  EQUAL="`concat "${EQUAL}" ${STR2}`" ; ;;          # .concat()
				
			esac
			STR2=""
			continue
		fi
		IS_KEYWORD=0
	else
	if [ -n "${_PKGNAME}" ]; then
		add_envword "PKGNAME"
		add_envword "VPATH"
		INIVARS="${INIVARS} PKGNAME='${STR}' ;"
		PKGNAME=${STR}
		_PKGNAME=""
		IS_KEYWORD=0
	else
	if [ -n "${_VERSION}" ]; then
		if [ "${PKGNAME}" = "this package" ]; then
			word=`get_word_number`
			echo "$word | PKGNAME must be defined before VERSION" > /dev/stderr
			exit 1
		fi
		add_envword "VERSION"
		INIVARS="${INIVARS} VERSION='${STR}' ;"
		VERSION="${STR}"
		_VERSION=""
		IS_KEYWORD=0
	else
	if [ ! "${_CONTACT}" = "0" ]; then
		IS_KEYWORD=0
		if [ "${_CONTACT}" = "1" ]; then
			if [ "${STR}" = ";" ]; then _CONTACT=2 ; else
				if [ -z "${CONTACT_NAME}" ]; then CONTACT_NAME="${STR}"; else
				CONTACT_NAME="${CONTACT_NAME} ${STR}"; fi
			fi
		else
			CONTACT_MAIL=${STR};
			_CONTACT=0;
			add_envword "CONTACT"
			add_envword "CONTACT_NAME"
			add_envword "CONTACT_MAIL"
			INIVARS="${INIVARS} CONTACT_MAIL=\"${CONTACT_MAIL}\" ;"
			INIVARS="${INIVARS} CONTACT_NAME=\"${CONTACT_NAME}\" ;"
			INIVARS="${INIVARS} CONTACT=\"${CONTACT_NAME} <${CONTACT_MAIL}>\" ;"
		fi
	else
	if [ "${_REQUIRE_ACR_VERSION}" = "1" ]; then
		IS_KEYWORD=0
		_REQUIRE_ACR_VERSION=0
		_OK="`echo ${STR} ${ACR_VERSION} | awk '{ if ($1 <= $2) {print "ok";} }'`"
		if [ -z "${_OK}" ]; then
			word=`get_word_number`
			echo "$word | Invalid ACR version. You need at least v${STR}" > /dev/stderr
			exit 1
		fi
	else
	if [ "${_SIZEOF}" = "1" ]; then
		if [ "${STR}" = ";" ]; then
			check_sizeof "${_SIZEOF_STR}"
			_SIZEOF=0
			_SIZEOF_STR=""
		else
			_SIZEOF_STR="`concat "${_SIZEOF_STR}" ${STR}`"
		fi
		IS_KEYWORD=0
	else
	if [ "${SUBST_FILES}" = "1" ]; then
		IS_KEYWORD=0
		if [ "${STR}" = ";" ]; then
			SUBST_FILES=0
		else
			S_FILES="${S_FILES} ${STR}"
			# XXX may be buggy on >1 dir. must be checked
			DIR="`echo ${STR} | awk -F '/' '{ print substr($0,0,length($0)-length($NF)) }'`"
			S_MKDIR="${S_MKDIR} ${DIR}"
		fi
	##FI##
	fi ; fi ; fi ; fi ; fi ; fi # SMILE! %)
	fi      ; fi ; fi ;      fi
	fi ; fi ; fi ; fi ; fi ; fi
	fi      ; fi ; fi ;      fi
	fi ;      fi ;           fi
	fi ;                fi ; fi
	fi ; fi ; fi ; fi ; fi ; fi

	##KEYWORDS##
	if [ "${IS_KEYWORD}" = "0" ]; then
		if [ "${DEBUG}" = "1" ]; then
		if [ ! "${STR}" = ";" ]; then
				printf "%04d | " $WORDS_N > /dev/stderr
				echo "  ${STR}" > /dev/stderr
		fi
		fi
	else

	WORDS_K=$WORDS_N

	if [ "${DEBUG}" = "1" ]; then
		if [ ! "${WORDS_N}" = "${WORDS_T}" ]; then 
		printf "%04d | " $WORDS_N > /dev/stderr
		echo "${STR}" > /dev/stderr
		fi
	fi

	if [ -n "${SET_VAR}" ]; then
		case $STR in
		"=")
			EQUAL=1
			;;
		"+=")
			EQUAL=2
			;;
		"?=")
			EQUAL=3
			_EQUAL_3=1
			;;
		"<-")
			EQUAL=4
			;;
		*)
			EQUAL=1 ## will crash in check_ifop :)
			;;
		esac
		continue
	fi

	case $STR in
					#------------ token keywords
	";")
		word=`get_word_number`
		echo "$word < found ';' character out of context." > /dev/stderr
		exit 1
		;;
	"}{"|"}ELSE{")
		if [ $NKEYS -le 0 ]; then
			echo "$word < '}{' unmatching ELSE key." > /dev/stderr
			exit 1
		fi
		IFSCRIPT="${IFSCRIPT}
else"
		;;
	"}")
		NKEYS=`echo $NKEYS|awk '{print $1-1;}'`
		if [ $NKEYS = 0 ]; then
			LOCAL_CONTEXT=0
		fi

		if [ $NKEYS -lt 0 ]; then
			echo "$word < unmatching '}' key." > /dev/stderr
			exit 1
		fi
		IFSCRIPT="${IFSCRIPT}; fi"
		;;
					#------------- segmentation keywords
	"LOCAL:") 
		LOCAL_CONTEXT=1
		;;
	"GLOBAL:") 
		LOCAL_CONTEXT=0
		;;
					#------------- command keywords
	"NOP")
		IS_KEYWORD=0 # Do Nothing Keyword
		;;
	##LANGS##
	"LANG_C")               env_c ; ;;
	"LANG_C!")              env_c ; LANG_C_REQUIRED=1 ; ;;
	"LANG_CC"|"LANG_CXX")   env_cxx ; ;;
	"LANG_CC!"|"LANG_CXX!") env_cxx ; LANG_CXX_REQUIRED=1 ; ;;
	"LANG_BASH")                      LANG_BASH=1; HAVE_PROGS=1 ; ;;
	"LANG_TCL")             env_tcl ; ;;
	"LANG_TCL!")            env_tcl ; LANG_TCL_REQUIRED=1 ; ;;
	"LANG_PYTHON")          env_python ; ;;
	"LANG_PYTHON!")         env_python ; LANG_PYTHON_REQUIRED=1 ; ;;
	"LANG_JAVA")            env_java ; ;;
	"LANG_JAVA!")           env_java ; LANG_JAVA_REQUIRED=1 ; ;;
	"LANG_PERL")            env_perl ; ;;
	"LANG_PERL!")           env_perl ; LANG_PERL_REQUIRED=1 ; ;;
	"LANG_RUBY")				env_ruby ; ;;
	"LANG_RUBY!")				env_ruby ; LANG_RUBY_REQUIRED=1 ; ;;
	"USE_TK") 
		add_envword "TK_VERSION"
		add_envword "HAVE_TK"
		add_envword "TK_LIBS"
		add_envword "TK_LDFLAGS"
		add_flag with TK_BASEDIR tk-basedir "=" "Sets the TK basedir to find [/usr]/lib/tkConfig.sh"
		USE_TK=1 ; ;;
	"USE_X11")   
		REPORT_OPTIONAL="${REPORT_OPTIONAL} X11"
		add_envword "HAVE_X11"
		add_envword "X11BASE"
		echo "X11BASE=/usr/X11R6/"
		add_flag without HAVE_X11 x "" "Disable the X11 window system"
		add_flag with X11BASE x11base "=" "Sets the X11BASE directory [/usr/X11R6]"
		add_flag x X_INCLUDES includes "=" "X include files are in DIR" "=DIR"
		add_flag x X_LIBRARIES libraries "=" "Points to the X11 library directory" "=DIR"
		USE_X11=1   ; ;;
	"USE_GMAKE") USE_GMAKE=1 ; env_gmake ; ;;
	"PKGNAME")   _PKGNAME=1  ; ;;
	"VERSION")   _VERSION=1  ; ;;
	"CONTACT")   _CONTACT=1  ; ;;
	"REQUIRE_ACR_VERSION") _REQUIRE_ACR_VERSION=1 ; ;;
	"CHECK_INCLUDE"|"CHECK_INCLUDE!"|"CHKINC"|"CHKINC!")
		if [ -z "${LANG_C}" ]; then
		word=`get_word_number`
		echo "$word | Define LANG_C before use CHECK_INC" > /dev/stderr
		exit 1
		fi
		_CHKINC=1
		_CHKINC_REQUIRED=0
		if [ -n "`echo ${STR} | grep '!'`" ]; then
			_CHKINC_REQUIRED=1 ; fi
		;;
	"CHK_CP"|"CHK_CP!"|"CHECK_CLASSPATH"|"CHECK_CLASSPATH!")
		if [ -z "${LANG_JAVA}" ]; then
		word=`get_word_number`
		echo "$word | Define LANG_JAVA before use CHECK_CLASSPATH" > /dev/stderr
		exit 1
		fi
		_CHK_CP=1
		_CHK_CP_REQUIRED=0
		if [ -n "`echo ${STR}| grep '!'`" ]; then	
			_CHK_CP_REQUIRED=1 ; fi
		;;
	"CHKFNC"|"CHKFNC!"|"CHECK_FUNCTION"|"CHECK_FUNCTION!")
		if [ -z "${LANG_C}" ]; then
		word=`get_word_number`
		echo "$word | Define LANG_C before use CHECK_FUNC" > /dev/stderr
		exit 1
		fi
		_CHKFUNC=1
		_CHKFUNC_REQUIRED=0
		if [ -n "`echo ${STR}| grep '!'`" ]; then	
			_CHKFUNC_REQUIRED=1 ; fi
		;;
	"CHK_PY"|"CHK_PY!"|"CHECK_PYTHON_MODULE"|"CHECK_PYTHON_MODULE!")
		if [ -z "${LANG_PYTHON}" ]; then
			word=`get_word_number`
			echo "$word | Define LANG_PYTHON before CHECK_PYTHON_MODULE." > /dev/stderr
			exit 1
		fi
		_CHK_PY=1
		_CHK_PY_REQUIRED=0
		if [ -n "`echo ${STR}| grep '!'`" ]; then	
			_CHK_PY_REQUIRED=1 ; fi
		;;
	"CHK_RU"|"CHK_RU!"|"CHECK_RUBY_EXTENSION"|"CHECK_RUBY_EXTENSION")
		if [ -z "${LANG_RUBY}" ]; then
			word=`get_word_number`
			echo "$word | Define LANG_RUBY before CHECK_RUBY_EXTENSION." > /dev/stderr
			exit 1
		fi
		_CHK_RU=1
		_CHK_RU_REQUIRED=0
		if [ -n "`echo ${STR}| grep '!'`" ]; then	
			_CHK_RU_REQUIRED=1 ; fi
		;;
	"CHK_PM"|"CHK_PM!"|"CHECK_PERL_MODULE"|"CHECK_PERL_MODULE!")
		if [ -z "${LANG_PERL}" ]; then
		word=`get_word_number`
		echo "$word | Define LANG_PERL before using CHK_PM directive" > /dev/stderr
		exit 1
		fi
		_CHK_PM=1
		_CHK_PM_REQUIRED=0
		if [ -n "`echo ${STR}| grep '!'`" ]; then	
			_CHK_PM_REQUIRED=1 ; fi
		;;
	"CHKLIB"|"CHKLIB!"|"CHECK_LIBRARY"|"CHECK_LIBRARY!") 
		if [ -z "${LANG_C}" ]; then
		word=`get_word_number`
		echo "$word | Define LANG_C before use CHECK_LIB" > /dev/stderr
		exit 1
		fi
		_CHKLIB=1
		if [ -n "`echo $STR | grep '!'`" ]; then
			_CHKLIB_REQUIRED=1 ; fi
		;;
	"CHKPRG"|"CHKPRG!"|"CHECK_PROGRAM"|"CHECK_PROGRAM!")
		_CHKPRG=1
		if [ -n "`echo $STR | grep '!'`" ]; then
			_CHKPRG_REQUIRED=1 ; fi
		;;
	"ENDIAN"|"CHECK_ENDIAN")
		if [ -z "${LANG_C}" ]; then
			word=`get_word_number`
			echo "$word | Define LANG_C before use CHECK_ENDIAN" > /dev/stderr
			exit 1
		fi
		check_endian
		;;
	"SIZEOF")
		if [ -z "${LANG_C}" ]; then
			word=`get_word_number`
			echo "$word | Define LANG_C before use SIZEOF" > /dev/stderr
			exit 1
		fi
		_SIZEOF=1
		;;
	"PKGCONFIG"|"PKGCFG")
		_PKGCONFIG=1
		_PKGCONFIG_PLUS=0
		;;
	"PKGCONFIG+"|"PKGCFG+")
		_PKGCONFIG=1
		_PKGCONFIG_PLUS=1
		;;
	"USE_PTHREAD")
		if [ -z "${LANG_C}" ]; then
			word=`get_word_number`
			echo "$word | USE_PTHREAD requires LANG_C." > /dev/stderr
			exit 1
		fi
		_USE_PTHREAD=1
		use_pthread
		;;
	"USE_PTHREAD!")
		if [ -z "${LANG_C}" ]; then
			word=`get_word_number`
			echo "$word | USE_PTHREAD requires LANG_C." > /dev/stderr
			exit 1
		fi
		_USE_PTHREAD=2
		use_pthread
		;;
	"USE_BACKUP")
		_USE_BACKUP=1
		;;
	"EXPORT_DEFINED"|"ED")
		_EXPORT_DEFINED=1
		;;
	"USE_JNI")
		if [ -z "${LANG_C}" ]; then
			word=`get_word_number`
			echo "$word | USE_JNI requires LANG_C and LANG_JAVA" > /dev/stderr
			exit 1
		fi
		if [ -z "${LANG_JAVA}" ]; then
			word=`get_word_number`
			echo "$word | USE_JNI requires LANG_C and LANG_JAVA" > /dev/stderr
			exit 1
		fi
		use_jni
		;;
	"USE_PERL_THREADS") env_perl_threads ; ;;
	"USE_PERL_THREADS!") LANG_PERL_THREADS_REQUIRED=1 env_perl_threads ; ;;
	"REPORT")
		_REPORT=1
		;;
	"EXPORT")
		_EXPORT=1 ;;
	"OUTPUT_H")
		OUTPUT_H=1 ;;
	"OUTPUT_SH")
		OUTPUT_SH=1 ;;
	"SUBST"|"SUBST_FILES")
		SUBST_FILES=1 ;;
	"SUBCONF")
		SUBCONF=1 ;;
	"SUBDIRS")
		SUBDIRS=1 ;;
	"IF")
		_IF=1 
		_IF_BOOL=1 ;;
	"IFNOT")
		_IF=1 
		_IF_BOOL=0 ;;
	"IFNULL")
		_IF=1
		_IF_BOOL="" ;;
	"IFNOTNULL")
		_IFEQ=1
		_IF_BOOL=0
		_IF_VALUE=""
		_IF_VALUE_EOF=1
		;;
	"IFEQ")
		_IFEQ=1 
		_IF_BOOL=1 ;;
	"IFNOTEQ")
		_IFEQ=1 
		_IF_BOOL=0 ;;
	"IFEQVAL")
		_IFEQVAL=1
		_IF_BOOL=1 ;;
	"IFNOTEQVAL")
		_IFEQVAL=1
		_IF_BOOL=0 ;;
	"IFAND")
		_IFAND=1 
		_IF_BOOL=1 ;;
	"IFNOTAND")
		_IFAND=1
		_IF_BOOL=0 ;;
	"NOT")
		_NOT=1
		;;
	"DIE")
		_DIE=1 
		_DIE_BOOL=1 ;;
	"DIENOT")
		_DIE=1
		_DIE_BOOL=0 ;;
	"CHKVER"|"CHECK_VERSION")
		_CHKVER=1 ;;
	"USE_DL")
		if [ "${_USE_DL_USED}" = "0" ]; then
			_USE_DL=1
			_USE_DL_USED=`get_word_number`
		else
			word=`get_word_number`
			echo "$word | ignored twice USE_DL found at ${_USE_DL_USED}." > /dev/stderr
		fi ;;
	"EXEC")
		_EXEC=1 ;;
	"USE_ICONV")
		_USE_ICONV=1 ;;
	"ARG_WITH")
		ARGUMENT=with ;;
	"ARG_WITHOUT")
		ARGUMENT=without ;;
	"ARG_ENABLE")
		ARGUMENT=enable ;;
	"ARG_DISABLE")
		ARGUMENT=disable ;;
	"CHECK") CHECK=1 ; ;;
	"="|"+="|"?="|"<-")
		echo "The *old* format <op> <var> <value> is deprecated." >/dev/stderr
		echo "Please use the standard format <var> <op> <value>." >/dev/stderr
		exit 1
		;;
	#"=")     EQUAL=1 ; ;;
	#"+=")    EQUAL=2 ; ;;
	#"?=")    EQUAL=3 ; _EQUAL_3=1 ;;
	#"<-")    EQUAL=4 ; ;;
	*)
		SET_VAR=$STR
		;;
#	*)	word=`get_word_number`
#		echo "$word | Invalid keyword '${STR}'" > /dev/stderr
#		exit 1
#		;;
	esac
	IS_FIRST_KEYWORD=0;
	fi
	fi
	fi

done

if [ "${IS_KEYWORD}" = "1" ]; then
	word=`get_word_number`
	echo "$word | Unexpected end of file." > /dev/stderr
	exit 1
fi

if [ "${COMMENT}" = "1" ]; then
	word=`get_word_number`
	echo "$word | Comment tag not closed." > /dev/stderr
	exit 1
fi

# Final stage
if [ "${MAKEFILE}" = "1" ]; then
if [ -f Makefile.acr ]; then
	echo "ERROR: Makefile.acr already exists. Remove't manually." > /dev/stderr
	exit 1
fi

if [ -z "${VERSION}" ]; then
	echo "ERROR: no VERSION defined." > /dev/stderr
	exit 1
fi
if [ "${PKGNAME}" = "this package" ]; then
	echo "ERROR: no PKGNAME defined." > /dev/stderr
	exit 1
fi

if [ $NKEYS -lt 0 ]; then
	echo "$word < unmatching ']' key." > /dev/stderr
	exit 1
fi

cat > Makefile.acr <<EOF
PKGNAME=@PKGNAME@
VERSION=@VERSION@
VPATH=@VPATH@
.PHONY: all dist clean mrproper
EOF

if [ "${LANG_JAVA}" = "1" ]; then
cat >> Makefile.acr <<EOF
JAVAC=@JAVAC@

%.class: %.java
	${S}{JAVAC} $<
EOF
fi

if [ "${LANG_C}" = "1" ]; then
cat >> Makefile.acr <<EOF
CC=@CC@
CFLAGS=@CFLAGS@
EOF
fi

if [ "${LANG_CXX}" = "1" ]; then
CXX=@CXX@
CXXFLAGS=@CXXFLAGS@
fi

if [ "${USE_BACKUP}" = "1" ]; then
cat >> Makefile.acr <<EOF
define unsubst
   @echo unsubst ${S}{1}
   @if [ -f "${S}{1}.backup" ]; then\\
      if [ ! -f "${S}{1}" ]; then\\
         FOO="";\\
      else\\
         FOO="\`diff -u ${S}{1} ${S}{1}.backup\`";\\
      fi;\\
      if [ -n "${S}{FOO}" ]; then\\
         echo "Looks like '${S}{1}' has changed. Check .backup";\\
         exit 1;\\
      else\\
         rm -f ${S}{1}.backup;\\
         mv -f ${S}{1}.orig ${S}{1};\\
      fi\\
   fi
endef

EOF
fi
echo "" >> Makefile.acr
echo "all:" >> Makefile.acr
for A in ${SD_FILES} ; do
	if [ ! "${A}" = "." ]; then
	printf "\tcd ${A} && ${S}{MAKE}/\n" >> Makefile.acr
	fi
done

cat >> Makefile.acr <<EOF

install:

clean:
EOF

if [ "${USE_BACKUP}" = 1 ]; then
	for A in ${S_FILES}; do
	printf "\t${S}(call unsubst,${A})\n" >> Makefile.acr
	done
else
	for A in ${S_FILES}; do
	printf "\tmv -f ${A}.orig ${A}\n" >> Makefile.acr
	done
fi

if [ -n "${H_FILES}" ]; then
	printf "\trm -f ${H_FILES}\n" >> Makefile.acr
fi
if [ -n "${SH_FILES}" ]; then
	printf "\trm -f ${SH_FILES}\n" >> Makefile.acr
fi
cat >> Makefile.acr <<EOF
	rm Makefile

mrproper: clean

dist: mrproper
	cd ..  && \\
	mv -f ${S}{PKGNAME} ${S}{PKGNAME}-${S}{VERSION} && \\
	tar czvf ${S}{PKGNAME}-${S}{VERSION}.tar.gz ${S}{PKGNAME}-${S}{VERSION} && \\
	mv -f ${S}{PKGNAME}-${S}{VERSION} ${S}{PKGNAME} && \\
	echo "dist done"
EOF
	echo "acr: Makefile.acr created succesfully." > /dev/stderr
else
	if [ "${PBAR}" = "1" ]; then
	echo > /dev/stderr ; fi
	create_script
	
	if [ $NKEYS -lt 0 ]; then
		echo "$word < unmatching ']' key." > /dev/stderr
		exit 1
	fi
	show_report
	if [ "${NOPE}" = "0" ]; then
		echo "acr: ./configure script created succesfully." > /dev/stderr
	fi
fi

makedist_failed(){
	echo "ERROR: $1" >/dev/stderr
	exit 1
}

if [ "${MAKEDIST}" = "1" ]; then
	if [ -z "$PKGNAME" ]; then
		makedist_failed "PKGNAME not defined"
	fi
	if [ -z "$VERSION" ]; then
		VERSION=`date +%Y%m%d`
		echo "VERSION not defined. Using current date">/dev/stderr
	fi
	DIRNAME="`expr $PWD : '.*\/\(.*\)$'`"
	if [ ! "$DIRNAME" = "$PKGNAME" ]; then
		makedist_failed "Invalid directory name '$DIRNAME' must be '$PKGNAME'." >/dev/stderr
	fi
##
	echo "[2/4] Running configure." > /dev/stderr
	./configure 2>&1 | ${AWK} '{ printf "."; }' >/dev/stderr
	echo >/dev/stderr
	if [ ! -e "Makefile.acr" ]; then
		makedist_failed "No Makefile.acr found in current directory. Cannot clean"
	fi
	echo "[3/4] Cleaning (make clean)" >/dev/stderr
	make clean 2>&1 | ${AWK} '{ printf "."; }' >/dev/stderr
	echo >/dev/stderr
	echo "[4/4] Disting project into a tarball." > /dev/stderr
	cd ..
	mv $PKGNAME $PKGNAME-$VERSION
	tar czvf $PKGNAME-$VERSION.tar.gz $PKGNAME 2>&1 | ${AWK} '{ printf "."; }'>/dev/stderr
	if [ ! $? = 0 ]; then
		mv $PKGNAME-$VERSION $PKGNAME
		makedist_failed "Cannot create ../$PKGNAME-$VERSION" 
	fi
	mv $PKGNAME-$VERSION $PKGNAME
	cd -
	echo>/dev/stderr
	echo "Tarball created successfully at ../$PKGNAME-$VERSION.tar.gz">/dev/stderr
fi
